From f260c5ec6ffad2316ef85d0fbe1c5e24b9fdc653 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Thu, 6 Mar 2025 13:54:54 +0100
Subject: [PATCH 01/42] Reintroduced file listing and navigation.

---
 .../include/backend/ssh_session_manager.hpp   |   7 +
 .../source/backend/ssh_session_manager.cpp    | 281 ++++++++++++------
 .../frontend/terminal/executing_engine.hpp    |   5 +-
 .../frontend/terminal/sftp_file_engine.hpp    |   6 +-
 .../include/frontend/terminal/ssh_engine.hpp  |   9 +-
 .../frontend/terminal/terminal_engine.hpp     |   3 +-
 .../frontend/terminal/user_control_engine.hpp |   2 +-
 frontend/source/frontend/session.cpp          |  34 +--
 .../frontend/terminal/executing_engine.cpp    |   2 +-
 .../frontend/terminal/sftp_file_engine.cpp    |  68 +++--
 .../source/frontend/terminal/ssh_engine.cpp   |  73 +++--
 .../frontend/terminal/user_control_engine.cpp |   2 +-
 ssh/include/ssh/sftp_error.hpp                |  12 +
 13 files changed, 320 insertions(+), 184 deletions(-)

diff --git a/backend/include/backend/ssh_session_manager.hpp b/backend/include/backend/ssh_session_manager.hpp
index 05288df7..77b4d702 100644
--- a/backend/include/backend/ssh_session_manager.hpp
+++ b/backend/include/backend/ssh_session_manager.hpp
@@ -21,6 +21,8 @@
 class SshSessionManager
 {
   public:
+    constexpr static auto futureTimeout = std::chrono::seconds{10};
+
     SshSessionManager();
     ~SshSessionManager();
     SshSessionManager(SshSessionManager const&) = delete;
@@ -47,11 +49,16 @@ class SshSessionManager
     void registerRpcChannelWrite(Nui::Window&, Nui::RpcHub& hub);
     void registerRpcChannelPtyResize(Nui::Window&, Nui::RpcHub& hub);
 
+    // Sftp:
+    void registerRpcSftpListDirectory(Nui::Window&, Nui::RpcHub& hub);
+    void registerRpcSftpCreateDirectory(Nui::Window&, Nui::RpcHub& hub);
+
   private:
     std::mutex passwordProvidersMutex_{};
     std::mutex addSessionMutex_{};
     std::unordered_map<Ids::SessionId, std::unique_ptr<SecureShell::Session>, Ids::IdHash> sessions_{};
     std::unordered_map<Ids::ChannelId, std::weak_ptr<SecureShell::Channel>, Ids::IdHash> channels_{};
+    std::unordered_map<Ids::ChannelId, std::weak_ptr<SecureShell::SftpSession>, Ids::IdHash> sftpChannels_{};
     std::map<int, PasswordProvider*> passwordProviders_{};
     std::unique_ptr<std::thread> addSessionThread_{};
     std::vector<SecureShell::PasswordCacheEntry> pwCache_{};
diff --git a/backend/source/backend/ssh_session_manager.cpp b/backend/source/backend/ssh_session_manager.cpp
index 67f91769..0b1e4d48 100644
--- a/backend/source/backend/ssh_session_manager.cpp
+++ b/backend/source/backend/ssh_session_manager.cpp
@@ -153,24 +153,56 @@ void SshSessionManager::registerRpcCreateChannel(Nui::Window&, Nui::RpcHub& hub)
                 return;
             }
 
-            const auto sessionOptions = parameters["engine"]["sshSessionOptions"].get<Persistence::SshSessionOptions>();
-            auto env = sessionOptions.environment;
+            bool fileMode = false;
+            if (parameters.contains("fileMode") && parameters["fileMode"].is_boolean())
+            {
+                fileMode = parameters["fileMode"].get<bool>();
+            }
 
-            const auto weakChannel = sessions_[sessionId]->createPtyChannel({.environment = env}).get();
-            if (!weakChannel.has_value())
+            if (!fileMode)
             {
-                Log::error("Failed to create pty channel: {}", weakChannel.error());
-                hub->callRemote(responseId, nlohmann::json{{"error", "Failed to create pty channel"}});
-                return;
+                const auto sessionOptions =
+                    parameters["engine"]["sshSessionOptions"].get<Persistence::SshSessionOptions>();
+                auto env = sessionOptions.environment;
+
+                const auto weakChannel = sessions_[sessionId]->createPtyChannel({.environment = env}).get();
+                if (!weakChannel.has_value())
+                {
+                    Log::error("Failed to create pty channel: {}", weakChannel.error());
+                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to create pty channel"}});
+                    return;
+                }
+
+                const auto channelId = Ids::generateChannelId();
+                channels_.emplace(channelId, std::move(weakChannel).value());
+
+                Log::info(
+                    "Created pty channel with id '{}', channel total is now '{}'.",
+                    channelId.value(),
+                    channels_.size());
+
+                hub->callRemote(responseId, nlohmann::json{{"id", channelId.value()}});
             }
+            else
+            {
+                const auto weakChannel = sessions_[sessionId]->createSftpSession().get();
+                if (!weakChannel.has_value())
+                {
+                    Log::error("Failed to create sftp channel: {}", weakChannel.error().toString());
+                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to create sftp channel"}});
+                    return;
+                }
 
-            const auto channelId = Ids::generateChannelId();
-            channels_.emplace(channelId, std::move(weakChannel).value());
+                const auto channelId = Ids::generateChannelId();
+                sftpChannels_.emplace(channelId, std::move(weakChannel).value());
 
-            Log::info(
-                "Created pty channel with id '{}', channel total is now '{}'.", channelId.value(), channels_.size());
+                Log::info(
+                    "Created sftp channel with id '{}', sftp channel total is now '{}'.",
+                    channelId.value(),
+                    sftpChannels_.size());
 
-            hub->callRemote(responseId, nlohmann::json{{"id", channelId.value()}});
+                hub->callRemote(responseId, nlohmann::json{{"id", channelId.value()}});
+            }
         });
 }
 
@@ -277,6 +309,18 @@ void SshSessionManager::registerRpcChannelClose(Nui::Window&, Nui::RpcHub& hub)
                         channelId.value(),
                         channels_.size());
                 }
+                else if (auto iter = sftpChannels_.find(channelId); iter != sftpChannels_.end())
+                {
+                    if (auto channel = iter->second.lock(); channel)
+                    {
+                        channel->close();
+                    }
+                    sftpChannels_.erase(iter);
+                    Log::info(
+                        "Closed sftp channel with id '{}', now remaining sftp channels total '{}'.",
+                        channelId.value(),
+                        sftpChannels_.size());
+                }
                 else
                 {
                     Log::error("No channel found with id: {}", channelId.value());
@@ -414,6 +458,134 @@ void SshSessionManager::registerRpcChannelPtyResize(Nui::Window&, Nui::RpcHub& h
         });
 }
 
+void SshSessionManager::registerRpcSftpListDirectory(Nui::Window&, Nui::RpcHub& hub)
+{
+    hub.registerFunction(
+        "SshSessionManager::sftp::listDirectory",
+        [this, hub = &hub](
+            std::string const& responseId,
+            std::string const& sessionIdString,
+            std::string const& channelIdString,
+            std::string const& path) {
+            try
+            {
+                const auto sessionId = Ids::makeSessionId(sessionIdString);
+                const auto channelId = Ids::makeChannelId(channelIdString);
+
+                if (sessions_.find(sessionId) == sessions_.end())
+                {
+                    Log::error("No session found with id: {}", sessionId.value());
+                    hub->callRemote(responseId, nlohmann::json{{"error", "No session found with id"}});
+                    return;
+                }
+
+                auto channel = sftpChannels_.find(channelId);
+                if (channel == sftpChannels_.end())
+                {
+                    Log::error("No sftp channel found with id: {}", channelId.value());
+                    hub->callRemote(responseId, nlohmann::json{{"error", "No sftp channel found with id"}});
+                    return;
+                }
+
+                auto locked = channel->second.lock();
+                if (!locked)
+                {
+                    Log::error("Failed to lock sftp channel with id: {}", channelId.value());
+                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to lock sftp channel"}});
+                    return;
+                }
+
+                auto fut = locked->listDirectory(path);
+                if (fut.wait_for(futureTimeout) != std::future_status::ready)
+                {
+                    Log::error("Failed to list directory: timeout");
+                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to list directory: timeout"}});
+                    return;
+                }
+
+                const auto result = fut.get();
+                if (!result.has_value())
+                {
+                    Log::error("Failed to list directory: {}", result.error().message);
+                    hub->callRemote(responseId, nlohmann::json{{"error", result.error().message}});
+                    return;
+                }
+
+                hub->callRemote(responseId, nlohmann::json{{"entries", *result}});
+            }
+            catch (std::exception const& e)
+            {
+                Log::error("Error listing directory: {}", e.what());
+                hub->callRemote(responseId, nlohmann::json{{"error", e.what()}});
+                return;
+            }
+        });
+}
+
+void SshSessionManager::registerRpcSftpCreateDirectory(Nui::Window&, Nui::RpcHub& hub)
+{
+    hub.registerFunction(
+        "SshSessionManager::sftp::createDirectory",
+        [this, hub = &hub](
+            std::string const& responseId,
+            std::string const& sessionIdString,
+            std::string const& channelIdString,
+            std::string const& path) {
+            try
+            {
+                const auto sessionId = Ids::makeSessionId(sessionIdString);
+                const auto channelId = Ids::makeChannelId(channelIdString);
+
+                if (sessions_.find(sessionId) == sessions_.end())
+                {
+                    Log::error("No session found with id: {}", sessionId.value());
+                    hub->callRemote(responseId, nlohmann::json{{"error", "No session found with id"}});
+                    return;
+                }
+
+                auto channel = sftpChannels_.find(channelId);
+                if (channel == sftpChannels_.end())
+                {
+                    Log::error("No sftp channel found with id: {}", channelId.value());
+                    hub->callRemote(responseId, nlohmann::json{{"error", "No sftp channel found with id"}});
+                    return;
+                }
+
+                auto locked = channel->second.lock();
+                if (!locked)
+                {
+                    Log::error("Failed to lock sftp channel with id: {}", channelId.value());
+                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to lock sftp channel"}});
+                    return;
+                }
+
+                auto fut = locked->createDirectory(path);
+                if (fut.wait_for(futureTimeout) != std::future_status::ready)
+                {
+                    Log::error("Failed to list directory: timeout");
+                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to list directory: timeout"}});
+                    return;
+                }
+
+                const auto result = fut.get();
+                if (!result.has_value())
+                {
+                    Log::error("Failed to list directory: {}", result.error().message);
+                    hub->callRemote(responseId, nlohmann::json{{"error", result.error().message}});
+                    return;
+                }
+
+                hub->callRemote(responseId, nlohmann::json{{"success", true}});
+            }
+            catch (std::exception const& e)
+            {
+                Log::error("Error listing directory: {}", e.what());
+                hub->callRemote(responseId, nlohmann::json{{"error", e.what()}});
+                return;
+            }
+        });
+}
+
 void SshSessionManager::registerRpc(Nui::Window& wnd, Nui::RpcHub& hub)
 {
     registerRpcConnect(wnd, hub);
@@ -423,90 +595,7 @@ void SshSessionManager::registerRpc(Nui::Window& wnd, Nui::RpcHub& hub)
     registerRpcEndSession(wnd, hub);
     registerRpcChannelWrite(wnd, hub);
     registerRpcChannelPtyResize(wnd, hub);
-
-    // hub.registerFunction(
-    //     "SshSessionManager::sftp::listDirectory",
-    //     [this, hub = &hub](std::string const& responseId, std::string const& sessionIdString, std::string const&
-    //     path) {
-    //         try
-    //         {
-    //             const auto sessionId = Ids::makeSessionId(sessionIdString);
-
-    //             if (sessions_.find(sessionId) == sessions_.end())
-    //             {
-    //                 Log::error("No session found with id: {}", sessionId.value());
-    //                 hub->callRemote(responseId, nlohmann::json{{"error", "No session found with id"}});
-    //                 return;
-    //             }
-
-    //             auto& session = sessions_[sessionId];
-    //             auto sftpSession = session->getSftpSession();
-    //             if (!sftpSession)
-    //             {
-    //                 Log::error("Failed to create sftp session");
-    //                 hub->callRemote(responseId, nlohmann::json{{"error", "Failed to create sftp session"}});
-    //                 return;
-    //             }
-
-    //             auto result = sftpSession->listDirectory(path);
-    //             if (!result.has_value())
-    //             {
-    //                 Log::error("Failed to list directory: {}", result.error().message);
-    //                 hub->callRemote(responseId, nlohmann::json{{"error", result.error().message}});
-    //                 return;
-    //             }
-
-    //             hub->callRemote(responseId, nlohmann::json{{"entries", *result}});
-    //         }
-    //         catch (std::exception const& e)
-    //         {
-    //             Log::error("Error listing directory: {}", e.what());
-    //             hub->callRemote(responseId, nlohmann::json{{"error", e.what()}});
-    //             return;
-    //         }
-    //     });
-
-    // hub.registerFunction(
-    //     "SshSessionManager::sftp::createDirectory",
-    //     [this, hub = &hub](std::string const& responseId, std::string const& sessionIdString, std::string const&
-    //     path) {
-    //         try
-    //         {
-    //             const auto sessionId = Ids::makeSessionId(sessionIdString);
-
-    //             if (sessions_.find(sessionId) == sessions_.end())
-    //             {
-    //                 Log::error("No session found with id: {}", sessionId.value());
-    //                 hub->callRemote(responseId, nlohmann::json{{"error", "No session found with id"}});
-    //                 return;
-    //             }
-
-    //             auto& session = sessions_[sessionId];
-    //             auto sftpSession = session->getSftpSession();
-    //             if (!sftpSession)
-    //             {
-    //                 Log::error("Failed to create sftp session");
-    //                 hub->callRemote(responseId, nlohmann::json{{"error", "Failed to create sftp session"}});
-    //                 return;
-    //             }
-
-    //             auto result = sftpSession->createDirectory(path);
-    //             if (result)
-    //             {
-    //                 Log::error("Failed to create directory: {}", result->message);
-    //                 hub->callRemote(responseId, nlohmann::json{{"error", result->message}});
-    //                 return;
-    //             }
-
-    //             hub->callRemote(responseId, nlohmann::json{{"success", true}});
-    //         }
-    //         catch (std::exception const& e)
-    //         {
-    //             Log::error("Error creating directory: {}", e.what());
-    //             hub->callRemote(responseId, nlohmann::json{{"error", e.what()}});
-    //             return;
-    //         }
-    //     });
+    registerRpcSftpListDirectory(wnd, hub);
 }
 
 void SshSessionManager::addPasswordProvider(int priority, PasswordProvider* provider)
diff --git a/frontend/include/frontend/terminal/executing_engine.hpp b/frontend/include/frontend/terminal/executing_engine.hpp
index 2c62b8b0..c9b1fd11 100644
--- a/frontend/include/frontend/terminal/executing_engine.hpp
+++ b/frontend/include/frontend/terminal/executing_engine.hpp
@@ -8,9 +8,6 @@
 
 #include <memory>
 #include <string>
-#include <string_view>
-
-// TODO: https://devblogs.microsoft.com/commandline/windows-command-line-introducing-the-windows-pseudo-console-conpty/
 
 class ExecutingTerminalEngine : public SingleChannelTerminalEngine
 {
@@ -26,7 +23,7 @@ class ExecutingTerminalEngine : public SingleChannelTerminalEngine
     ExecutingTerminalEngine(Settings settings);
     ROAR_PIMPL_SPECIAL_FUNCTIONS(ExecutingTerminalEngine);
 
-    void open(std::function<void(bool, std::string const&)> onOpen, bool fileMode = false) override;
+    void open(std::function<void(bool, std::string const&)> onOpen) override;
     void dispose(std::function<void()> onDisposeComplete) override;
     void write(std::string const& data) override;
     void resize(int cols, int rows) override;
diff --git a/frontend/include/frontend/terminal/sftp_file_engine.hpp b/frontend/include/frontend/terminal/sftp_file_engine.hpp
index 5bd43346..9cca7d9e 100644
--- a/frontend/include/frontend/terminal/sftp_file_engine.hpp
+++ b/frontend/include/frontend/terminal/sftp_file_engine.hpp
@@ -6,7 +6,7 @@
 class SftpFileEngine : public FileEngine
 {
   public:
-    SftpFileEngine(SshTerminalEngine::Settings settings);
+    SftpFileEngine(SshTerminalEngine* engine);
     ROAR_PIMPL_SPECIAL_FUNCTIONS(SftpFileEngine);
 
     void listDirectory(
@@ -15,8 +15,10 @@ class SftpFileEngine : public FileEngine
     void dispose() override;
     void createDirectory(std::filesystem::path const& path, std::function<void(bool)> onComplete) override;
 
+    std::optional<Ids::ChannelId> release();
+
   private:
-    void lazyOpen(std::function<void(std::optional<Ids::SessionId> const&)> const& onOpen);
+    void lazyOpen(std::function<void(std::optional<Ids::ChannelId> const&)> const& onOpen);
 
   private:
     struct Implementation;
diff --git a/frontend/include/frontend/terminal/ssh_engine.hpp b/frontend/include/frontend/terminal/ssh_engine.hpp
index cb84819d..bf99adb5 100644
--- a/frontend/include/frontend/terminal/ssh_engine.hpp
+++ b/frontend/include/frontend/terminal/ssh_engine.hpp
@@ -27,12 +27,13 @@ class SshTerminalEngine : public MultiChannelTerminalEngine
     SshTerminalEngine(Settings settings);
     ROAR_PIMPL_SPECIAL_FUNCTIONS(SshTerminalEngine);
 
-    void open(std::function<void(bool, std::string const&)> onOpen, bool fileMode = false) override;
+    void open(std::function<void(bool, std::string const&)> onOpen) override;
 
     void createChannel(
         std::function<void(std::string const&)> handler,
         std::function<void(std::string const&)> errorHandler,
         std::function<void(std::optional<Ids::ChannelId> const&)> onCreated) override;
+    void createSftpChannel(std::function<void(std::optional<Ids::ChannelId> const&)> onCreated) override;
 
     void closeChannel(Ids::ChannelId const& channelId, std::function<void()> onChannelClosed = []() {}) override;
     SshChannel* channel(Ids::ChannelId const& channelId) override;
@@ -51,6 +52,12 @@ class SshTerminalEngine : public MultiChannelTerminalEngine
     // Usually indicates that the entire session is closed
     void onChannelDeath();
 
+    void createChannelImpl(
+        std::function<void(std::string const&)> handler,
+        std::function<void(std::string const&)> errorHandler,
+        std::function<void(std::optional<Ids::ChannelId> const&)> onCreated,
+        bool fileMode);
+
   private:
     struct Implementation;
     std::unique_ptr<Implementation> impl_;
diff --git a/frontend/include/frontend/terminal/terminal_engine.hpp b/frontend/include/frontend/terminal/terminal_engine.hpp
index 6571e9a6..09e391a4 100644
--- a/frontend/include/frontend/terminal/terminal_engine.hpp
+++ b/frontend/include/frontend/terminal/terminal_engine.hpp
@@ -9,7 +9,7 @@
 class TerminalEngine
 {
   public:
-    virtual void open(std::function<void(bool, std::string const&)> onOpen, bool fileMode = false) = 0;
+    virtual void open(std::function<void(bool, std::string const&)> onOpen) = 0;
     virtual std::string engineName() const = 0;
     virtual void dispose(std::function<void()> onDisposeComplete) = 0;
     virtual ~TerminalEngine() = default;
@@ -22,6 +22,7 @@ class MultiChannelTerminalEngine : public TerminalEngine
         std::function<void(std::string const&)> handler,
         std::function<void(std::string const&)> errorHandler,
         std::function<void(std::optional<Ids::ChannelId> const&)> onCreated) = 0;
+    virtual void createSftpChannel(std::function<void(std::optional<Ids::ChannelId> const&)> onCreated) = 0;
     virtual void closeChannel(Ids::ChannelId const& channelId, std::function<void()> onClose = []() {}) = 0;
     virtual ChannelInterface* channel(Ids::ChannelId const& channelId) = 0;
 };
diff --git a/frontend/include/frontend/terminal/user_control_engine.hpp b/frontend/include/frontend/terminal/user_control_engine.hpp
index 720a2a0e..0bad9cd7 100644
--- a/frontend/include/frontend/terminal/user_control_engine.hpp
+++ b/frontend/include/frontend/terminal/user_control_engine.hpp
@@ -23,7 +23,7 @@ class UserControlEngine : public SingleChannelTerminalEngine
     UserControlEngine(Settings settings);
     ROAR_PIMPL_SPECIAL_FUNCTIONS(UserControlEngine);
 
-    void open(std::function<void(bool, std::string const&)> onOpen, bool) override;
+    void open(std::function<void(bool, std::string const&)> onOpen) override;
     void dispose(std::function<void()> onDisposeComplete) override;
     void write(std::string const& data) override;
     void resize(int cols, int rows) override;
diff --git a/frontend/source/frontend/session.cpp b/frontend/source/frontend/session.cpp
index 7058c685..958919ed 100644
--- a/frontend/source/frontend/session.cpp
+++ b/frontend/source/frontend/session.cpp
@@ -216,7 +216,6 @@ void Session::setupFileGrid()
         Log::info("New item requested: {}", static_cast<int>(type));
         if (type == NuiFileExplorer::FileGrid::Item::Type::Directory)
         {
-            // impl_->fileEngine->createDirectory(impl_->currentPath);
             impl_->newItemAskDialog->open(
                 "New directory",
                 "Enter the name of the new directory",
@@ -369,24 +368,21 @@ void Session::navigateTo(std::filesystem::path path)
 
 void Session::openSftp()
 {
-    Log::warn("SFTP is not implemented yet");
-    // if (impl_->terminal.value() && impl_->terminal.value()->engine().engineName() == "ssh")
-    // {
-    //     auto const& opts = std::get<Persistence::SshTerminalEngine>(impl_->engine.engine).sshSessionOptions.value();
-    //     if (opts.openSftpByDefault)
-    //     {
-    //         Log::info("Opening SFTP by default");
-    //         impl_->fileEngine = std::make_unique<SftpFileEngine>(SshTerminalEngine::Settings{
-    //             .engineOptions = std::get<Persistence::SshTerminalEngine>(impl_->engine.engine),
-    //             .onExit = std::bind(&Session::onFileExplorerConnectionClose, this),
-    //         });
-    //         navigateTo(opts.defaultDirectory.value_or("/"));
-    //     }
-    // }
-    // else
-    // {
-    //     Log::error("Cannot open SFTP for non-ssh terminal");
-    // }
+    if (impl_->terminal.value() && impl_->terminal.value()->engine().engineName() == "ssh")
+    {
+        auto const& opts = std::get<Persistence::SshTerminalEngine>(impl_->engine.engine).sshSessionOptions.value();
+        if (opts.openSftpByDefault)
+        {
+            Log::info("Opening SFTP by default");
+            impl_->fileEngine =
+                std::make_unique<SftpFileEngine>(static_cast<SshTerminalEngine*>(&impl_->terminal.value()->engine()));
+            navigateTo(opts.defaultDirectory.value_or("/"));
+        }
+    }
+    else
+    {
+        Log::info("Cannot open SFTP for non-ssh terminal");
+    }
 }
 
 void Session::fallbackToUserControlEngine()
diff --git a/frontend/source/frontend/terminal/executing_engine.cpp b/frontend/source/frontend/terminal/executing_engine.cpp
index b1622a10..583291f0 100644
--- a/frontend/source/frontend/terminal/executing_engine.cpp
+++ b/frontend/source/frontend/terminal/executing_engine.cpp
@@ -48,7 +48,7 @@ ExecutingTerminalEngine::~ExecutingTerminalEngine()
 
 ROAR_PIMPL_SPECIAL_FUNCTIONS_IMPL_NO_DTOR(ExecutingTerminalEngine);
 
-void ExecutingTerminalEngine::open(std::function<void(bool, std::string const&)> onOpen, bool)
+void ExecutingTerminalEngine::open(std::function<void(bool, std::string const&)> onOpen)
 {
     impl_->stdoutReceiver =
         Nui::RpcClient::autoRegisterFunction("execTerminalStdout_" + impl_->id, [this](Nui::val val) {
diff --git a/frontend/source/frontend/terminal/sftp_file_engine.cpp b/frontend/source/frontend/terminal/sftp_file_engine.cpp
index 5daa101f..206da056 100644
--- a/frontend/source/frontend/terminal/sftp_file_engine.cpp
+++ b/frontend/source/frontend/terminal/sftp_file_engine.cpp
@@ -6,67 +6,69 @@
 
 struct SftpFileEngine::Implementation
 {
-    SshTerminalEngine underlyingEngine;
     bool wasDisposed = false;
+    SshTerminalEngine* engine;
+    std::optional<Ids::ChannelId> sftpChannelId{std::nullopt};
 
-    Implementation(SshTerminalEngine::Settings settings)
-        : underlyingEngine{std::move(settings)}
+    Implementation(SshTerminalEngine* engine)
+        : engine{engine}
     {}
 };
 
-SftpFileEngine::SftpFileEngine(SshTerminalEngine::Settings settings)
-    : impl_{std::make_unique<Implementation>(std::move(settings))}
+SftpFileEngine::SftpFileEngine(SshTerminalEngine* engine)
+    : impl_{std::make_unique<Implementation>(engine)}
 {}
 SftpFileEngine::~SftpFileEngine()
 {
-    if (!moveDetector_.wasMoved() && !impl_->wasDisposed)
+    if (!moveDetector_.wasMoved())
     {
         dispose();
     }
 }
 
+std::optional<Ids::ChannelId> SftpFileEngine::release()
+{
+    return std::move(impl_->sftpChannelId);
+}
+
 void SftpFileEngine::dispose()
 {
-    impl_->wasDisposed = true;
-    if (!impl_->underlyingEngine.sshSessionId().isValid())
+    if (!impl_->wasDisposed)
     {
-        return;
+        if (impl_->sftpChannelId)
+        {
+            Log::info("Closing sftp channel");
+            impl_->engine->closeChannel(impl_->sftpChannelId.value(), []() {});
+        }
     }
-    impl_->underlyingEngine.dispose([]() {});
+    impl_->wasDisposed = true;
 }
 
 ROAR_PIMPL_SPECIAL_FUNCTIONS_IMPL_NO_DTOR(SftpFileEngine);
 
-void SftpFileEngine::lazyOpen(std::function<void(std::optional<Ids::SessionId> const&)> const& onOpen)
+void SftpFileEngine::lazyOpen(std::function<void(std::optional<Ids::ChannelId> const&)> const& onOpen)
 {
-    if (impl_->underlyingEngine.sshSessionId().isValid())
+    if (impl_->sftpChannelId)
     {
-        onOpen(impl_->underlyingEngine.sshSessionId());
+        onOpen(impl_->sftpChannelId);
         return;
     }
 
-    impl_->underlyingEngine.open(
-        [this, onOpen](bool success, std::string const& error) {
-            if (!success)
-            {
-                Log::error("Failed to open SFTP: {}", error);
-                onOpen(std::nullopt);
-                return;
-            }
-
-            onOpen(impl_->underlyingEngine.sshSessionId());
-        },
-        true);
+    Log::info("Creating sftp channel");
+    impl_->engine->createSftpChannel([this, onOpen](auto const& id) {
+        impl_->sftpChannelId = id;
+        onOpen(id);
+    });
 }
 
 void SftpFileEngine::listDirectory(
     std::filesystem::path const& path,
     std::function<void(std::optional<std::vector<SharedData::DirectoryEntry>> const&)> onComplete)
 {
-    lazyOpen([path, onComplete = std::move(onComplete)](auto const& sshSessionId) {
-        if (!sshSessionId)
+    lazyOpen([this, path, onComplete = std::move(onComplete)](auto const& channelId) {
+        if (!channelId)
         {
-            Log::error("Cannot list directory, no ssh session");
+            Log::error("Cannot list directory, no sftp channel");
             return;
         }
 
@@ -92,15 +94,16 @@ void SftpFileEngine::listDirectory(
 
                 onComplete(nlohmann::json::parse(Nui::JSON::stringify(val))["entries"]);
             },
-            sshSessionId->value(),
+            impl_->engine->sshSessionId().value(),
+            channelId.value().value(),
             path.generic_string());
     });
 }
 
 void SftpFileEngine::createDirectory(std::filesystem::path const& path, std::function<void(bool)> onComplete)
 {
-    lazyOpen([path, onComplete = std::move(onComplete)](auto const& sshSessionId) {
-        if (!sshSessionId)
+    lazyOpen([this, path, onComplete = std::move(onComplete)](auto const& channelId) {
+        if (!channelId)
         {
             Log::error("Cannot create directory, no ssh session");
             return;
@@ -121,7 +124,8 @@ void SftpFileEngine::createDirectory(std::filesystem::path const& path, std::fun
 
                 onComplete(true);
             },
-            sshSessionId->value(),
+            impl_->engine->sshSessionId().value(),
+            channelId.value().value(),
             path.generic_string());
     });
 }
\ No newline at end of file
diff --git a/frontend/source/frontend/terminal/ssh_engine.cpp b/frontend/source/frontend/terminal/ssh_engine.cpp
index f0b7f2a4..55806745 100644
--- a/frontend/source/frontend/terminal/ssh_engine.cpp
+++ b/frontend/source/frontend/terminal/ssh_engine.cpp
@@ -14,7 +14,6 @@ struct SshTerminalEngine::Implementation
     Ids::SessionId sshSessionId;
     std::unordered_map<Ids::ChannelId, SshChannel, Ids::IdHash> channels;
     std::function<void()> disposer;
-    bool fileMode;
     bool wasDisposed;
     bool blockedByDestruction;
 
@@ -23,7 +22,6 @@ struct SshTerminalEngine::Implementation
         , sshSessionId{}
         , channels{}
         , disposer{}
-        , fileMode{false}
         , wasDisposed{false}
         , blockedByDestruction{false}
     {}
@@ -44,7 +42,7 @@ SshTerminalEngine::~SshTerminalEngine()
 
 ROAR_PIMPL_SPECIAL_FUNCTIONS_IMPL_NO_DTOR(SshTerminalEngine);
 
-void SshTerminalEngine::open(std::function<void(bool, std::string const&)> onOpen, bool fileMode)
+void SshTerminalEngine::open(std::function<void(bool, std::string const&)> onOpen)
 {
     if (impl_->blockedByDestruction)
     {
@@ -52,8 +50,6 @@ void SshTerminalEngine::open(std::function<void(bool, std::string const&)> onOpe
         return onOpen(false, "Blocked by destruction");
     }
 
-    impl_->fileMode = fileMode;
-
     Nui::val obj = Nui::val::object();
     obj.set("engine", asVal(impl_->settings.engineOptions));
 
@@ -105,10 +101,11 @@ void SshTerminalEngine::onChannelDeath()
     dispose([]() {});
 }
 
-void SshTerminalEngine::createChannel(
+void SshTerminalEngine::createChannelImpl(
     std::function<void(std::string const&)> handler,
     std::function<void(std::string const&)> errorHandler,
-    std::function<void(std::optional<Ids::ChannelId> const&)> onCreated)
+    std::function<void(std::optional<Ids::ChannelId> const&)> onCreated,
+    bool fileMode)
 {
     if (impl_->blockedByDestruction)
     {
@@ -119,11 +116,15 @@ void SshTerminalEngine::createChannel(
     Nui::val obj = Nui::val::object();
     obj.set("engine", asVal(impl_->settings.engineOptions));
     obj.set("sessionId", impl_->sshSessionId.value());
+    obj.set("fileMode", fileMode);
 
     Nui::RpcClient::callWithBackChannel(
         "SshSessionManager::Session::createChannel",
-        [this, onCreated = std::move(onCreated), handler = std::move(handler), errorHandler = std::move(errorHandler)](
-            Nui::val val) {
+        [this,
+         onCreated = std::move(onCreated),
+         handler = std::move(handler),
+         errorHandler = std::move(errorHandler),
+         fileMode](Nui::val val) {
             if (val.hasOwnProperty("error"))
             {
                 Log::error("Failed to create channel: {}", val["error"].as<std::string>());
@@ -151,27 +152,47 @@ void SshTerminalEngine::createChannel(
                     Log::info("Channel died, disconnecting entire session");
                     onChannelDeath();
                 },
-                impl_->fileMode);
-
-            Nui::RpcClient::callWithBackChannel(
-                "SshSessionManager::Channel::startReading",
-                [this, channelId, onCreated](Nui::val val) {
-                    if (val.hasOwnProperty("error"))
-                    {
-                        Log::error("Failed to start reading: {}", val["error"].as<std::string>());
-                        closeChannel(channelId, []() {});
-                        onCreated(std::nullopt);
-                        return;
-                    }
-                    Log::info("Started reading: {}", channelId.value());
-                    onCreated(channelId);
-                },
-                impl_->sshSessionId.value(),
-                channelId.value());
+                fileMode);
+
+            if (!fileMode)
+            {
+                Nui::RpcClient::callWithBackChannel(
+                    "SshSessionManager::Channel::startReading",
+                    [this, channelId, onCreated](Nui::val val) {
+                        if (val.hasOwnProperty("error"))
+                        {
+                            Log::error("Failed to start reading: {}", val["error"].as<std::string>());
+                            closeChannel(channelId, []() {});
+                            onCreated(std::nullopt);
+                            return;
+                        }
+                        Log::info("Started reading: {}", channelId.value());
+                        onCreated(channelId);
+                    },
+                    impl_->sshSessionId.value(),
+                    channelId.value());
+            }
+            else
+            {
+                onCreated(channelId);
+            }
         },
         obj);
 }
 
+void SshTerminalEngine::createChannel(
+    std::function<void(std::string const&)> handler,
+    std::function<void(std::string const&)> errorHandler,
+    std::function<void(std::optional<Ids::ChannelId> const&)> onCreated)
+{
+    createChannelImpl(std::move(handler), std::move(errorHandler), std::move(onCreated), false);
+}
+
+void SshTerminalEngine::createSftpChannel(std::function<void(std::optional<Ids::ChannelId> const&)> onCreated)
+{
+    createChannelImpl([](std::string const&) {}, [](std::string const&) {}, std::move(onCreated), true);
+}
+
 Ids::SessionId SshTerminalEngine::sshSessionId() const
 {
     return impl_->sshSessionId;
diff --git a/frontend/source/frontend/terminal/user_control_engine.cpp b/frontend/source/frontend/terminal/user_control_engine.cpp
index 6029eef9..fa635e56 100644
--- a/frontend/source/frontend/terminal/user_control_engine.cpp
+++ b/frontend/source/frontend/terminal/user_control_engine.cpp
@@ -42,7 +42,7 @@ UserControlEngine::~UserControlEngine()
 
 ROAR_PIMPL_SPECIAL_FUNCTIONS_IMPL_NO_DTOR(UserControlEngine);
 
-void UserControlEngine::open(std::function<void(bool, std::string const&)> onOpen, bool)
+void UserControlEngine::open(std::function<void(bool, std::string const&)> onOpen)
 {
     onOpen(true, "Never Fails");
 }
diff --git a/ssh/include/ssh/sftp_error.hpp b/ssh/include/ssh/sftp_error.hpp
index 11d09d77..c9039839 100644
--- a/ssh/include/ssh/sftp_error.hpp
+++ b/ssh/include/ssh/sftp_error.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <fmt/format.h>
+
 #include <string>
 
 namespace SecureShell
@@ -21,5 +23,15 @@ namespace SecureShell
         int sshError = 0;
         int sftpError = 0;
         WrapperErrors wrapperError = WrapperErrors::None;
+
+        inline std::string toString() const
+        {
+            return fmt::format(
+                "SftpError: message: {}, sshError: {}, sftpError: {}, wrapperError: {}",
+                message,
+                sshError,
+                sftpError,
+                static_cast<int>(wrapperError));
+        }
     };
 }
\ No newline at end of file

From 6f8e1620960e3af9718f2b7142357e0248f953e2 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Thu, 6 Mar 2025 15:58:14 +0100
Subject: [PATCH 02/42] Added create file.

---
 .../include/backend/ssh_session_manager.hpp   |  1 +
 .../source/backend/ssh_session_manager.cpp    | 75 ++++++++++++++++++-
 .../include/frontend/terminal/file_engine.hpp |  1 +
 .../frontend/terminal/sftp_file_engine.hpp    |  1 +
 frontend/source/frontend/session.cpp          | 28 +++++++
 .../frontend/terminal/sftp_file_engine.cpp    | 32 +++++++-
 6 files changed, 133 insertions(+), 5 deletions(-)

diff --git a/backend/include/backend/ssh_session_manager.hpp b/backend/include/backend/ssh_session_manager.hpp
index 77b4d702..58a0624d 100644
--- a/backend/include/backend/ssh_session_manager.hpp
+++ b/backend/include/backend/ssh_session_manager.hpp
@@ -52,6 +52,7 @@ class SshSessionManager
     // Sftp:
     void registerRpcSftpListDirectory(Nui::Window&, Nui::RpcHub& hub);
     void registerRpcSftpCreateDirectory(Nui::Window&, Nui::RpcHub& hub);
+    void registerRpcSftpCreateFile(Nui::Window&, Nui::RpcHub& hub);
 
   private:
     std::mutex passwordProvidersMutex_{};
diff --git a/backend/source/backend/ssh_session_manager.cpp b/backend/source/backend/ssh_session_manager.cpp
index 0b1e4d48..bc2a7d49 100644
--- a/backend/source/backend/ssh_session_manager.cpp
+++ b/backend/source/backend/ssh_session_manager.cpp
@@ -562,15 +562,15 @@ void SshSessionManager::registerRpcSftpCreateDirectory(Nui::Window&, Nui::RpcHub
                 auto fut = locked->createDirectory(path);
                 if (fut.wait_for(futureTimeout) != std::future_status::ready)
                 {
-                    Log::error("Failed to list directory: timeout");
-                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to list directory: timeout"}});
+                    Log::error("Failed to create directory: timeout");
+                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to create directory: timeout"}});
                     return;
                 }
 
                 const auto result = fut.get();
                 if (!result.has_value())
                 {
-                    Log::error("Failed to list directory: {}", result.error().message);
+                    Log::error("Failed to create directory: {}", result.error().message);
                     hub->callRemote(responseId, nlohmann::json{{"error", result.error().message}});
                     return;
                 }
@@ -579,13 +579,77 @@ void SshSessionManager::registerRpcSftpCreateDirectory(Nui::Window&, Nui::RpcHub
             }
             catch (std::exception const& e)
             {
-                Log::error("Error listing directory: {}", e.what());
+                Log::error("Error creating directory: {}", e.what());
                 hub->callRemote(responseId, nlohmann::json{{"error", e.what()}});
                 return;
             }
         });
 }
 
+void SshSessionManager::registerRpcSftpCreateFile(Nui::Window&, Nui::RpcHub& hub)
+{
+    hub.registerFunction(
+        "SshSessionManager::sftp::createFile",
+        [this, hub = &hub](
+            std::string const& responseId,
+            std::string const& sessionIdString,
+            std::string const& channelIdString,
+            std::string const& path) {
+            try
+            {
+                const auto sessionId = Ids::makeSessionId(sessionIdString);
+                const auto channelId = Ids::makeChannelId(channelIdString);
+
+                if (sessions_.find(sessionId) == sessions_.end())
+                {
+                    Log::error("No session found with id: {}", sessionId.value());
+                    hub->callRemote(responseId, nlohmann::json{{"error", "No session found with id"}});
+                    return;
+                }
+
+                auto channel = sftpChannels_.find(channelId);
+                if (channel == sftpChannels_.end())
+                {
+                    Log::error("No sftp channel found with id: {}", channelId.value());
+                    hub->callRemote(responseId, nlohmann::json{{"error", "No sftp channel found with id"}});
+                    return;
+                }
+
+                auto locked = channel->second.lock();
+                if (!locked)
+                {
+                    Log::error("Failed to lock sftp channel with id: {}", channelId.value());
+                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to lock sftp channel"}});
+                    return;
+                }
+
+                auto fut = locked->createFile(path);
+                if (fut.wait_for(futureTimeout) != std::future_status::ready)
+                {
+                    Log::error("Failed to create file: timeout");
+                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to create file: timeout"}});
+                    return;
+                }
+
+                const auto result = fut.get();
+                if (!result.has_value())
+                {
+                    Log::error("Failed to create file: {}", result.error().message);
+                    hub->callRemote(responseId, nlohmann::json{{"error", result.error().message}});
+                    return;
+                }
+
+                hub->callRemote(responseId, nlohmann::json{{"success", true}});
+            }
+            catch (std::exception const& exc)
+            {
+                Log::error("Error creating file: {}", exc.what());
+                hub->callRemote(responseId, nlohmann::json{{"error", exc.what()}});
+                return;
+            }
+        });
+}
+
 void SshSessionManager::registerRpc(Nui::Window& wnd, Nui::RpcHub& hub)
 {
     registerRpcConnect(wnd, hub);
@@ -595,7 +659,10 @@ void SshSessionManager::registerRpc(Nui::Window& wnd, Nui::RpcHub& hub)
     registerRpcEndSession(wnd, hub);
     registerRpcChannelWrite(wnd, hub);
     registerRpcChannelPtyResize(wnd, hub);
+
     registerRpcSftpListDirectory(wnd, hub);
+    registerRpcSftpCreateDirectory(wnd, hub);
+    registerRpcSftpCreateFile(wnd, hub);
 }
 
 void SshSessionManager::addPasswordProvider(int priority, PasswordProvider* provider)
diff --git a/frontend/include/frontend/terminal/file_engine.hpp b/frontend/include/frontend/terminal/file_engine.hpp
index b66fbe9f..5961cc67 100644
--- a/frontend/include/frontend/terminal/file_engine.hpp
+++ b/frontend/include/frontend/terminal/file_engine.hpp
@@ -21,6 +21,7 @@ class FileEngine
         std::function<void(std::optional<std::vector<SharedData::DirectoryEntry>> const&)> onComplete) = 0;
 
     virtual void createDirectory(std::filesystem::path const& path, std::function<void(bool)> onComplete) = 0;
+    virtual void createFile(std::filesystem::path const& path, std::function<void(bool)> onComplete) = 0;
 
     virtual void dispose() = 0;
 };
\ No newline at end of file
diff --git a/frontend/include/frontend/terminal/sftp_file_engine.hpp b/frontend/include/frontend/terminal/sftp_file_engine.hpp
index 9cca7d9e..9f86f43c 100644
--- a/frontend/include/frontend/terminal/sftp_file_engine.hpp
+++ b/frontend/include/frontend/terminal/sftp_file_engine.hpp
@@ -14,6 +14,7 @@ class SftpFileEngine : public FileEngine
         std::function<void(std::optional<std::vector<SharedData::DirectoryEntry>> const&)> onComplete) override;
     void dispose() override;
     void createDirectory(std::filesystem::path const& path, std::function<void(bool)> onComplete) override;
+    void createFile(std::filesystem::path const& path, std::function<void(bool)> onComplete) override;
 
     std::optional<Ids::ChannelId> release();
 
diff --git a/frontend/source/frontend/session.cpp b/frontend/source/frontend/session.cpp
index 958919ed..c5908221 100644
--- a/frontend/source/frontend/session.cpp
+++ b/frontend/source/frontend/session.cpp
@@ -242,6 +242,34 @@ void Session::setupFileGrid()
                     });
                 });
         }
+        else if (type == NuiFileExplorer::FileGrid::Item::Type::Regular)
+        {
+            impl_->newItemAskDialog->open(
+                "New file",
+                "Enter the name of the new file",
+                "Create a new file",
+                false,
+                [this](std::optional<std::string> const& name) {
+                    if (!name)
+                        return;
+
+                    Log::info("Creating new file: {}", *name);
+                    if (name->find('/') != std::string::npos)
+                    {
+                        Log::error("Invalid file name (cannot contain slashes): {}", *name);
+                        return;
+                    }
+                    impl_->fileEngine->createFile(impl_->currentPath / *name, [this](bool success) {
+                        if (!success)
+                        {
+                            Log::error("Failed to create file");
+                            return;
+                        }
+                        // Refresh list from server:
+                        navigateTo(impl_->currentPath);
+                    });
+                });
+        }
         else
         {
             // TODO: create file
diff --git a/frontend/source/frontend/terminal/sftp_file_engine.cpp b/frontend/source/frontend/terminal/sftp_file_engine.cpp
index 206da056..f9001cb2 100644
--- a/frontend/source/frontend/terminal/sftp_file_engine.cpp
+++ b/frontend/source/frontend/terminal/sftp_file_engine.cpp
@@ -105,7 +105,7 @@ void SftpFileEngine::createDirectory(std::filesystem::path const& path, std::fun
     lazyOpen([this, path, onComplete = std::move(onComplete)](auto const& channelId) {
         if (!channelId)
         {
-            Log::error("Cannot create directory, no ssh session");
+            Log::error("Cannot create directory, no channel");
             return;
         }
 
@@ -128,4 +128,34 @@ void SftpFileEngine::createDirectory(std::filesystem::path const& path, std::fun
             channelId.value().value(),
             path.generic_string());
     });
+}
+
+void SftpFileEngine::createFile(std::filesystem::path const& path, std::function<void(bool)> onComplete)
+{
+    lazyOpen([this, path, onComplete = std::move(onComplete)](auto const& channelId) {
+        if (!channelId)
+        {
+            Log::error("Cannot create file, no channel");
+            return;
+        }
+
+        Log::info("Creating file: {}", path.generic_string());
+        Nui::RpcClient::callWithBackChannel(
+            "SshSessionManager::sftp::createFile",
+            [onComplete = std::move(onComplete)](Nui::val val) {
+                Nui::Console::log(val);
+
+                if (val.hasOwnProperty("error"))
+                {
+                    Log::error("(Frontend) Failed to create file: {}", val["error"].as<std::string>());
+                    onComplete(false);
+                    return;
+                }
+
+                onComplete(true);
+            },
+            impl_->engine->sshSessionId().value(),
+            channelId.value().value(),
+            path.generic_string());
+    });
 }
\ No newline at end of file

From 6a1108a961c1a3c40d5676286d88956a10a3bb71 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Fri, 7 Mar 2025 14:35:48 +0100
Subject: [PATCH 03/42] Improved channel shutdowns.

---
 ssh/include/ssh/async/processing_thread.hpp |  9 +++-
 ssh/include/ssh/channel.hpp                 |  2 +
 ssh/include/ssh/file_stream.hpp             |  7 ++-
 ssh/include/ssh/sftp_session.hpp            | 19 +++++--
 ssh/source/ssh/async/processing_thread.cpp  | 10 ++++
 ssh/source/ssh/channel.cpp                  | 28 ++++++----
 ssh/source/ssh/file_stream.cpp              |  8 +++
 ssh/source/ssh/session.cpp                  | 15 +++---
 ssh/source/ssh/sftp_session.cpp             | 48 ++++++++++++++---
 ssh/test/ssh/main.cpp                       |  4 +-
 ssh/test/ssh/test_processing_thread.hpp     | 17 ++++++
 ssh/test/ssh/test_sftp.hpp                  | 58 ++++++++++++++-------
 ssh/test/ssh/test_ssh_session.hpp           |  3 +-
 ssh/test/ssh/utility/node.cpp               | 24 ++++++++-
 ssh/test/ssh/utility/node.hpp               |  1 +
 15 files changed, 199 insertions(+), 54 deletions(-)

diff --git a/ssh/include/ssh/async/processing_thread.hpp b/ssh/include/ssh/async/processing_thread.hpp
index 76c4edcd..94eadf9c 100644
--- a/ssh/include/ssh/async/processing_thread.hpp
+++ b/ssh/include/ssh/async/processing_thread.hpp
@@ -14,7 +14,7 @@ namespace SecureShell
     class ProcessingThread
     {
       public:
-        constexpr static unsigned int maximumTasksProcessableAtOnce = 10;
+        constexpr static unsigned int maximumTasksProcessableAtOnce = 100;
 
         struct PermanentTaskId
         {
@@ -65,6 +65,13 @@ namespace SecureShell
         int permanentTaskCount() const;
         void clearPermanentTasks();
 
+        bool awaitCycle(std::chrono::milliseconds maxWait = std::chrono::seconds{5});
+
+        bool withinProcessingThread() const
+        {
+            return processingThreadId_ == std::this_thread::get_id();
+        }
+
       private:
         void run(std::chrono::milliseconds const& waitCycleTimeout, std::chrono::milliseconds const& minimumCycleWait);
 
diff --git a/ssh/include/ssh/channel.hpp b/ssh/include/ssh/channel.hpp
index e7e0959f..d0af51e3 100644
--- a/ssh/include/ssh/channel.hpp
+++ b/ssh/include/ssh/channel.hpp
@@ -28,6 +28,8 @@ namespace SecureShell
             return *channel_;
         }
 
+        void shutdown();
+
         void close();
 
         /**
diff --git a/ssh/include/ssh/file_stream.hpp b/ssh/include/ssh/file_stream.hpp
index b3daa1dd..dc6c4a81 100644
--- a/ssh/include/ssh/file_stream.hpp
+++ b/ssh/include/ssh/file_stream.hpp
@@ -14,7 +14,7 @@ namespace SecureShell
     class Session;
     class SftpSession;
 
-    class FileStream
+    class FileStream : public std::enable_shared_from_this<FileStream>
     {
       public:
         FileStream(std::shared_ptr<SftpSession> sftp, sftp_file file, sftp_limits_struct limits);
@@ -95,6 +95,11 @@ namespace SecureShell
          */
         sftp_file release();
 
+        /**
+         * @brief Closes the file and removes itself from the sftp session.
+         */
+        void close();
+
       private:
         std::function<void(sftp_file)> makeFileDeleter();
 
diff --git a/ssh/include/ssh/sftp_session.hpp b/ssh/include/ssh/sftp_session.hpp
index 1d437eb4..8e9085e0 100644
--- a/ssh/include/ssh/sftp_session.hpp
+++ b/ssh/include/ssh/sftp_session.hpp
@@ -25,6 +25,7 @@ namespace SecureShell
     {
       public:
         using Error = SftpError;
+        friend class FileStream;
 
         SftpSession(Session* owner, sftp_session session);
         ~SftpSession();
@@ -38,7 +39,7 @@ namespace SecureShell
             return session_;
         }
 
-        void close();
+        void close(bool removeSelf = true);
 
         struct DirectoryEntry : public SharedData::DirectoryEntry
         {
@@ -70,6 +71,14 @@ namespace SecureShell
             return promise.get_future();
         }
 
+        bool awaitCycle()
+        {
+            std::scoped_lock lock{ownerMutex_};
+            if (owner_)
+                return owner_->processingThread_.awaitCycle();
+            return false;
+        }
+
         /**
          * @brief Retrieves the last error that occurred. May contain success.
          */
@@ -174,15 +183,19 @@ namespace SecureShell
             Exclusive = O_EXCL,
         };
 
-        std::future<std::expected<FileStream, Error>>
+        std::future<std::expected<std::weak_ptr<FileStream>, Error>>
         openFile(std::filesystem::path const& path, OpenType openType, std::filesystem::perms permissions);
 
         std::future<std::expected<sftp_limits_struct, Error>> limits();
 
+      private:
+        void fileStreamRemoveItself(FileStream* stream);
+        void removeAllFileStreams();
+
       private:
         std::mutex ownerMutex_;
         Session* owner_;
         sftp_session session_;
-        // std::optional<ProcessingThread::PermanentTaskId> readTaskId_{std::nullopt};
+        std::vector<std::shared_ptr<FileStream>> fileStreams_;
     };
 }
\ No newline at end of file
diff --git a/ssh/source/ssh/async/processing_thread.cpp b/ssh/source/ssh/async/processing_thread.cpp
index 46208fb7..bdadf8ed 100644
--- a/ssh/source/ssh/async/processing_thread.cpp
+++ b/ssh/source/ssh/async/processing_thread.cpp
@@ -224,4 +224,14 @@ namespace SecureShell
         std::lock_guard lock{taskMutex_};
         return permanentTasks_.size();
     }
+    bool ProcessingThread::awaitCycle(std::chrono::milliseconds maxWait)
+    {
+        if (!withinProcessingThread() && running_)
+        {
+            return pushPromiseTask([]() {
+                       return true;
+                   }).wait_for(maxWait) == std::future_status::ready;
+        }
+        return false;
+    }
 }
\ No newline at end of file
diff --git a/ssh/source/ssh/channel.cpp b/ssh/source/ssh/channel.cpp
index 397a1458..41b01656 100644
--- a/ssh/source/ssh/channel.cpp
+++ b/ssh/source/ssh/channel.cpp
@@ -24,19 +24,29 @@ namespace SecureShell
         }
         return *this;
     }
-    void Channel::close()
+    void Channel::shutdown()
     {
-        std::scoped_lock lock{ownerMutex_};
-        if (owner_)
         {
-            if (readTaskId_)
-            {
+            std::scoped_lock lock{ownerMutex_};
+            if (owner_ && readTaskId_)
                 owner_->processingThread_.removePermanentTask(*readTaskId_);
-            }
-
-            owner_->channelRemoveItself(this);
-            owner_ = nullptr;
         }
+        if (channel_ && channel_->isOpen())
+        {
+            channel_->sendEof();
+            channel_->close();
+        }
+        channel_.reset();
+    }
+    void Channel::close()
+    {
+        shutdown();
+        decltype(owner_) cpy = nullptr;
+        {
+            std::scoped_lock lock{ownerMutex_};
+            cpy = std::exchange(owner_, nullptr);
+        }
+        cpy->channelRemoveItself(this);
     }
     void Channel::write(std::string data)
     {
diff --git a/ssh/source/ssh/file_stream.cpp b/ssh/source/ssh/file_stream.cpp
index edc34de6..585a23e5 100644
--- a/ssh/source/ssh/file_stream.cpp
+++ b/ssh/source/ssh/file_stream.cpp
@@ -38,11 +38,19 @@ namespace SecureShell
         , file_{other.file_.release(), makeFileDeleter()}
         , limits_{other.limits_}
     {}
+    void FileStream::close()
+    {
+        if (auto sftp = sftp_.lock(); sftp)
+        {
+            sftp->fileStreamRemoveItself(this);
+        }
+    }
     std::function<void(sftp_file)> FileStream::makeFileDeleter()
     {
         return [this](sftp_file file) {
             if (auto sftp = this->sftp_.lock(); sftp)
             {
+                // This is safe because file is just a pointer, even if 'this' is deleted by this point.
                 sftp->perform([file]() {
                     sftp_close(file);
                 });
diff --git a/ssh/source/ssh/session.cpp b/ssh/source/ssh/session.cpp
index 1917896f..ec9ea429 100644
--- a/ssh/source/ssh/session.cpp
+++ b/ssh/source/ssh/session.cpp
@@ -66,9 +66,7 @@ namespace SecureShell
                 {
                     channelsToRemove_.push_back(*it);
                     channels_.erase(it);
-                    processingThread_.pushTask([this]() {
-                        removalTask();
-                    });
+                    removalTask();
                 }
                 else
                 {
@@ -82,12 +80,7 @@ namespace SecureShell
     {
         for (const auto& toRemove : channelsToRemove_)
         {
-            auto& channel = static_cast<ssh::Channel&>(*toRemove);
-            if (channel.isOpen())
-            {
-                channel.sendEof();
-                channel.close();
-            }
+            toRemove->shutdown();
         }
         channelsToRemove_.clear();
     }
@@ -111,6 +104,10 @@ namespace SecureShell
     void Session::removeAllSftpSessions()
     {
         processingThread_.pushTask([this]() {
+            for (auto& sftp : sftpSessions_)
+            {
+                sftp->close(false);
+            }
             sftpSessions_.clear();
         });
     }
diff --git a/ssh/source/ssh/sftp_session.cpp b/ssh/source/ssh/sftp_session.cpp
index 88d1470a..7143706d 100644
--- a/ssh/source/ssh/sftp_session.cpp
+++ b/ssh/source/ssh/sftp_session.cpp
@@ -11,21 +11,50 @@ namespace SecureShell
         : ownerMutex_{}
         , owner_{owner}
         , session_{session}
+        , fileStreams_{}
     {}
     SftpSession::~SftpSession()
     {
         /* close makes no sense, since this lives in a shared_ptr and will only ever end here when it was already
          * removed */
     }
-    void SftpSession::close()
+    void SftpSession::close(bool removeSelf)
     {
-        std::scoped_lock lock{ownerMutex_};
-        if (owner_)
+        removeAllFileStreams();
         {
-            owner_->sftpSessionRemoveItself(this);
-            owner_ = nullptr;
+            std::scoped_lock lock{ownerMutex_};
+            if (owner_)
+            {
+                if (removeSelf)
+                    owner_->sftpSessionRemoveItself(this);
+                owner_ = nullptr;
+            }
         }
     }
+    void SftpSession::fileStreamRemoveItself(FileStream* stream)
+    {
+        if (stream)
+        {
+            perform([this, stream]() {
+                fileStreams_.erase(
+                    std::remove_if(
+                        fileStreams_.begin(),
+                        fileStreams_.end(),
+                        [stream](auto const& item) {
+                            return item.get() == stream;
+                        }),
+                    fileStreams_.end());
+            });
+            awaitCycle();
+        }
+    }
+    void SftpSession::removeAllFileStreams()
+    {
+        perform([this]() {
+            fileStreams_.clear();
+        });
+        awaitCycle();
+    }
     SftpSession::DirectoryEntry SftpSession::DirectoryEntry::fromSftpAttributes(sftp_attributes attributes)
     {
         return DirectoryEntry{
@@ -256,11 +285,11 @@ namespace SecureShell
         });
     }
 
-    std::future<std::expected<FileStream, SftpSession::Error>>
+    std::future<std::expected<std::weak_ptr<FileStream>, SftpSession::Error>>
     SftpSession::openFile(std::filesystem::path const& path, OpenType openType, std::filesystem::perms permissions)
     {
         return performPromise(
-            [this, path = std::move(path), openType, permissions]() -> std::expected<FileStream, Error> {
+            [this, path = std::move(path), openType, permissions]() -> std::expected<std::weak_ptr<FileStream>, Error> {
                 std::unique_ptr<sftp_file_struct, std::function<void(sftp_file_struct*)>> file{
                     sftp_open(
                         session_,
@@ -281,7 +310,10 @@ namespace SecureShell
                 if (limits == nullptr)
                     return std::unexpected(lastError());
 
-                return FileStream{shared_from_this(), file.release(), *limits};
+                auto stream = std::make_shared<FileStream>(shared_from_this(), file.release(), *limits);
+                fileStreams_.push_back(stream);
+
+                return std::weak_ptr<FileStream>{stream};
             });
     }
 }
\ No newline at end of file
diff --git a/ssh/test/ssh/main.cpp b/ssh/test/ssh/main.cpp
index 89427dab..81728d8a 100644
--- a/ssh/test/ssh/main.cpp
+++ b/ssh/test/ssh/main.cpp
@@ -1,5 +1,5 @@
-// #include "test_processing_thread.hpp"
-// #include "test_ssh_session.hpp"
+#include "test_processing_thread.hpp"
+#include "test_ssh_session.hpp"
 #include "test_sftp.hpp"
 
 #include "utility/node.hpp"
diff --git a/ssh/test/ssh/test_processing_thread.hpp b/ssh/test/ssh/test_processing_thread.hpp
index b675327a..b3dbaad2 100644
--- a/ssh/test/ssh/test_processing_thread.hpp
+++ b/ssh/test/ssh/test_processing_thread.hpp
@@ -339,4 +339,21 @@ namespace SecureShell::Test
         processingThread.clearPermanentTasks();
         EXPECT_EQ(0, processingThread.permanentTaskCount());
     }
+
+    TEST_F(ProcessingThreadTest, CanWaitForCycle)
+    {
+        ProcessingThread processingThread;
+        processingThread.start(std::chrono::milliseconds{1});
+        EXPECT_TRUE(processingThread.awaitCycle());
+    }
+
+    TEST_F(ProcessingThreadTest, CanWaitForCyclesMultipleTimes)
+    {
+        ProcessingThread processingThread;
+        processingThread.start(std::chrono::milliseconds{1});
+        for (int i = 0; i < 5; ++i)
+        {
+            EXPECT_TRUE(processingThread.awaitCycle());
+        }
+    }
 }
\ No newline at end of file
diff --git a/ssh/test/ssh/test_sftp.hpp b/ssh/test/ssh/test_sftp.hpp
index 43840dd5..8ad0b7b3 100644
--- a/ssh/test/ssh/test_sftp.hpp
+++ b/ssh/test/ssh/test_sftp.hpp
@@ -260,10 +260,12 @@ namespace SecureShell::Test
         auto result = fut.get();
         ASSERT_TRUE(result.has_value());
 
-        auto file = std::move(result).value();
-        std::byte byte;
+        auto fileWeak = std::move(result).value();
+        auto file = fileWeak.lock();
+        ASSERT_TRUE(file);
 
-        auto readFut = file.read(&byte, 1);
+        std::byte byte;
+        auto readFut = file->read(&byte, 1);
         ASSERT_EQ(readFut.wait_for(1s), std::future_status::ready);
         auto readResult = readFut.get();
         ASSERT_TRUE(readResult.has_value());
@@ -282,9 +284,12 @@ namespace SecureShell::Test
         auto result = fut.get();
         ASSERT_TRUE(result.has_value());
 
-        auto file = std::move(result).value();
+        auto fileWeak = std::move(result).value();
+        auto file = fileWeak.lock();
+        ASSERT_TRUE(file);
+
         std::vector<std::byte> buffer(1024);
-        auto readFut = file.read(buffer.data(), buffer.size());
+        auto readFut = file->read(buffer.data(), buffer.size());
 
         ASSERT_EQ(readFut.wait_for(1s), std::future_status::ready);
         auto readResult = readFut.get();
@@ -305,9 +310,12 @@ namespace SecureShell::Test
         auto result = fut.get();
         ASSERT_TRUE(result.has_value());
 
-        auto file = std::move(result).value();
+        auto fileWeak = std::move(result).value();
+        auto file = fileWeak.lock();
+        ASSERT_TRUE(file);
+
         std::string data;
-        auto readFut = file.read([&data](std::string_view chunk) {
+        auto readFut = file->read([&data](std::string_view chunk) {
             data.append(chunk);
             return true;
         });
@@ -330,9 +338,12 @@ namespace SecureShell::Test
         auto result = fut.get();
         ASSERT_TRUE(result.has_value());
 
-        auto file = std::move(result).value();
+        auto fileWeak = std::move(result).value();
+        auto file = fileWeak.lock();
+        ASSERT_TRUE(file);
+
         std::string data;
-        auto readFut = file.read([&data](std::string_view chunk) {
+        auto readFut = file->read([&data](std::string_view chunk) {
             data.append(chunk);
             return true;
         });
@@ -355,10 +366,13 @@ namespace SecureShell::Test
         auto result = fut.get();
         ASSERT_TRUE(result.has_value());
 
-        auto file = std::move(result).value();
-        ASSERT_EQ(file.seek(2).wait_for(1s), std::future_status::ready);
+        auto fileWeak = std::move(result).value();
+        auto file = fileWeak.lock();
+        ASSERT_TRUE(file);
+
+        ASSERT_EQ(file->seek(2).wait_for(1s), std::future_status::ready);
         std::vector<std::byte> buffer(1024);
-        auto readFut2 = file.read(buffer.data(), buffer.size());
+        auto readFut2 = file->read(buffer.data(), buffer.size());
 
         ASSERT_EQ(readFut2.wait_for(1s), std::future_status::ready);
         auto readResult2 = readFut2.get();
@@ -379,11 +393,14 @@ namespace SecureShell::Test
         auto result = fut.get();
         ASSERT_TRUE(result.has_value());
 
-        auto file = std::move(result).value();
+        auto fileWeak = std::move(result).value();
+        auto file = fileWeak.lock();
+        ASSERT_TRUE(file);
+
         std::vector<std::byte> buffer(1024);
-        ASSERT_EQ(file.seek(2).wait_for(1s), std::future_status::ready);
-        ASSERT_EQ(file.rewind().wait_for(1s), std::future_status::ready);
-        auto readFut2 = file.read(buffer.data(), buffer.size());
+        ASSERT_EQ(file->seek(2).wait_for(1s), std::future_status::ready);
+        ASSERT_EQ(file->rewind().wait_for(1s), std::future_status::ready);
+        auto readFut2 = file->read(buffer.data(), buffer.size());
 
         ASSERT_EQ(readFut2.wait_for(1s), std::future_status::ready);
         auto readResult2 = readFut2.get();
@@ -404,9 +421,12 @@ namespace SecureShell::Test
         auto result = fut.get();
         ASSERT_TRUE(result.has_value());
 
-        auto file = std::move(result).value();
-        ASSERT_EQ(file.seek(2).wait_for(1s), std::future_status::ready);
-        auto tellFut = file.tell();
+        auto fileWeak = std::move(result).value();
+        auto file = fileWeak.lock();
+        ASSERT_TRUE(file);
+
+        ASSERT_EQ(file->seek(2).wait_for(1s), std::future_status::ready);
+        auto tellFut = file->tell();
 
         ASSERT_EQ(tellFut.wait_for(1s), std::future_status::ready);
         auto tellResult = tellFut.get();
diff --git a/ssh/test/ssh/test_ssh_session.hpp b/ssh/test/ssh/test_ssh_session.hpp
index 2dd9687d..04f86e3c 100644
--- a/ssh/test/ssh/test_ssh_session.hpp
+++ b/ssh/test/ssh/test_ssh_session.hpp
@@ -268,7 +268,8 @@ namespace SecureShell::Test
         auto [result, processThread] = createSshServer();
         ASSERT_TRUE(result);
         auto joiner = Nui::ScopeExit{[&]() noexcept {
-            result->command("exit");
+            // result->command("exit");
+            result->terminate();
             if (processThread.joinable())
                 processThread.join();
         }};
diff --git a/ssh/test/ssh/utility/node.cpp b/ssh/test/ssh/utility/node.cpp
index 00c3db6e..5383945f 100644
--- a/ssh/test/ssh/utility/node.cpp
+++ b/ssh/test/ssh/utility/node.cpp
@@ -35,6 +35,21 @@ namespace SecureShell::Test
         }
     }
 
+    void NodeProcessResult::terminate()
+    {
+        if (killed)
+            return;
+        killed = true;
+        try
+        {
+            mainModule->terminate();
+        }
+        catch (std::exception const& e)
+        {
+            std::cerr << "Failed to terminate process: " << e.what() << std::endl;
+        }
+    }
+
     void npmInstall(
         boost::asio::any_io_executor executor,
         std::filesystem::path const& directory,
@@ -127,7 +142,14 @@ namespace SecureShell::Test
             if (auto result = weak.lock())
             {
                 result->killed = true;
-                result->mainModule->terminate();
+                try
+                {
+                    result->mainModule->terminate();
+                }
+                catch (std::exception const& e)
+                {
+                    std::cerr << "Failed to terminate process: " << e.what() << std::endl;
+                }
             }
         });
 
diff --git a/ssh/test/ssh/utility/node.hpp b/ssh/test/ssh/utility/node.hpp
index 4f1e3a4a..8e3e670f 100644
--- a/ssh/test/ssh/utility/node.hpp
+++ b/ssh/test/ssh/utility/node.hpp
@@ -32,6 +32,7 @@ namespace SecureShell::Test
         int code = 0;
 
         void command(std::string const& command);
+        void terminate();
     };
 
     void npmInstall(

From 0163757f510491c94c72f81b59fb1fbc5b29ac32 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sat, 8 Mar 2025 03:31:32 +0100
Subject: [PATCH 04/42] Improved synchronization of ssh channels and sessions
 using strands.

---
 ssh/include/ssh/async/processing_strand.hpp |  88 ++++++++++++++
 ssh/include/ssh/async/processing_thread.hpp |   5 +
 ssh/include/ssh/channel.hpp                 |   8 +-
 ssh/include/ssh/session.hpp                 |   3 -
 ssh/include/ssh/sftp_session.hpp            |  32 +----
 ssh/source/ssh/async/processing_thread.cpp  |  31 ++++-
 ssh/source/ssh/channel.cpp                  |  55 +++------
 ssh/source/ssh/session.cpp                  |  77 ++++--------
 ssh/source/ssh/sftp_session.cpp             |  50 +++-----
 ssh/test/ssh/test_processing_thread.hpp     | 128 +++++++++++++++++++-
 ssh/test/ssh/test_sftp.hpp                  |   2 +-
 11 files changed, 318 insertions(+), 161 deletions(-)
 create mode 100644 ssh/include/ssh/async/processing_strand.hpp

diff --git a/ssh/include/ssh/async/processing_strand.hpp b/ssh/include/ssh/async/processing_strand.hpp
new file mode 100644
index 00000000..996df09f
--- /dev/null
+++ b/ssh/include/ssh/async/processing_strand.hpp
@@ -0,0 +1,88 @@
+#pragma once
+
+#include <ssh/async/processing_thread.hpp>
+
+#include <set>
+#include <future>
+#include <functional>
+#include <mutex>
+
+namespace SecureShell
+{
+    class ProcessingStrand
+    {
+      public:
+        ProcessingStrand(ProcessingThread* processingThread)
+            : processingThread_(processingThread)
+        {}
+
+        bool pushTask(std::function<void()> task)
+        {
+            std::scoped_lock lock(mutex_);
+            if (finalized_)
+            {
+                return false;
+            }
+            return processingThread_->pushTask(std::move(task));
+        }
+
+        std::pair<bool, ProcessingThread::PermanentTaskId> pushPermanentTask(std::function<void()> task)
+        {
+            std::scoped_lock lock(mutex_);
+            if (finalized_)
+            {
+                return {false, ProcessingThread::PermanentTaskId{-1}};
+            }
+            auto result = processingThread_->pushPermanentTask(std::move(task));
+            this->permanentTasks_.insert(result.second);
+            return result;
+        }
+
+        void pushFinalTask(std::function<void()> task)
+        {
+            std::scoped_lock lock(mutex_);
+            if (finalized_)
+            {
+                return;
+            }
+            finalized_ = true;
+            for (auto const& id : permanentTasks_)
+            {
+                processingThread_->removePermanentTask(id);
+            }
+            processingThread_->pushTask(std::move(task));
+        }
+
+        void doFinalSync(std::function<void()> const& task)
+        {
+            std::scoped_lock lock(mutex_);
+            if (finalized_)
+            {
+                return;
+            }
+            finalized_ = true;
+            for (auto const& id : permanentTasks_)
+            {
+                processingThread_->removePermanentTask(id);
+            }
+            task();
+        }
+
+        template <typename Func>
+        auto pushPromiseTask(Func&& func) -> std::future<std::invoke_result_t<std::decay_t<Func>>>
+        {
+            std::scoped_lock lock(mutex_);
+            if (finalized_)
+            {
+                throw std::runtime_error("Cannot push task to finalized strand.");
+            }
+            return processingThread_->pushPromiseTask(std::forward<Func>(func));
+        }
+
+      private:
+        std::recursive_mutex mutex_{};
+        bool finalized_ = false;
+        ProcessingThread* processingThread_{};
+        std::set<ProcessingThread::PermanentTaskId> permanentTasks_{};
+    };
+}
\ No newline at end of file
diff --git a/ssh/include/ssh/async/processing_thread.hpp b/ssh/include/ssh/async/processing_thread.hpp
index 94eadf9c..f90f3ab6 100644
--- a/ssh/include/ssh/async/processing_thread.hpp
+++ b/ssh/include/ssh/async/processing_thread.hpp
@@ -8,9 +8,12 @@
 #include <condition_variable>
 #include <map>
 #include <future>
+#include <memory>
 
 namespace SecureShell
 {
+    class ProcessingStrand;
+
     class ProcessingThread
     {
       public:
@@ -72,6 +75,8 @@ namespace SecureShell
             return processingThreadId_ == std::this_thread::get_id();
         }
 
+        std::unique_ptr<ProcessingStrand> createStrand();
+
       private:
         void run(std::chrono::milliseconds const& waitCycleTimeout, std::chrono::milliseconds const& minimumCycleWait);
 
diff --git a/ssh/include/ssh/channel.hpp b/ssh/include/ssh/channel.hpp
index d0af51e3..1ba15d52 100644
--- a/ssh/include/ssh/channel.hpp
+++ b/ssh/include/ssh/channel.hpp
@@ -2,6 +2,7 @@
 
 #include <libssh/libsshpp.hpp>
 #include <ssh/async/processing_thread.hpp>
+#include <ssh/async/processing_strand.hpp>
 
 #include <memory>
 #include <functional>
@@ -16,7 +17,7 @@ namespace SecureShell
     class Channel : public std::enable_shared_from_this<Channel>
     {
       public:
-        Channel(Session* owner, std::unique_ptr<ssh::Channel>);
+        Channel(Session* owner, std::unique_ptr<ProcessingStrand> strand, std::unique_ptr<ssh::Channel>);
         ~Channel();
         Channel(Channel const&) = delete;
         Channel& operator=(Channel const&) = delete;
@@ -28,8 +29,6 @@ namespace SecureShell
             return *channel_;
         }
 
-        void shutdown();
-
         void close();
 
         /**
@@ -79,12 +78,11 @@ namespace SecureShell
         void readTask(std::chrono::milliseconds pollTimeout = std::chrono::milliseconds{0});
 
       private:
-        std::mutex ownerMutex_;
         Session* owner_;
+        std::unique_ptr<ProcessingStrand> strand_;
         std::unique_ptr<ssh::Channel> channel_;
         std::function<void(std::string const&)> onStdout_{};
         std::function<void(std::string const&)> onStderr_{};
         std::function<void()> onExit_{};
-        std::optional<ProcessingThread::PermanentTaskId> readTaskId_{std::nullopt};
     };
 }
\ No newline at end of file
diff --git a/ssh/include/ssh/session.hpp b/ssh/include/ssh/session.hpp
index 204f9110..a3d51d6e 100644
--- a/ssh/include/ssh/session.hpp
+++ b/ssh/include/ssh/session.hpp
@@ -86,8 +86,6 @@ namespace SecureShell
         void sftpSessionRemoveItself(SftpSession* sftpSession);
         void removeAllSftpSessions();
 
-        void removalTask();
-
         /**
          * @brief Shuts down the session and closes all channels.
          * The session is not usable after this.
@@ -98,7 +96,6 @@ namespace SecureShell
         SecureShell::ProcessingThread processingThread_;
         ssh::Session session_;
         std::vector<std::shared_ptr<Channel>> channels_;
-        std::vector<std::shared_ptr<Channel>> channelsToRemove_;
         std::vector<std::shared_ptr<SftpSession>> sftpSessions_;
     };
 
diff --git a/ssh/include/ssh/sftp_session.hpp b/ssh/include/ssh/sftp_session.hpp
index 8e9085e0..797620be 100644
--- a/ssh/include/ssh/sftp_session.hpp
+++ b/ssh/include/ssh/sftp_session.hpp
@@ -3,6 +3,7 @@
 #include <libssh/libsshpp.hpp>
 #include <libssh/sftp.h>
 #include <ssh/async/processing_thread.hpp>
+#include <ssh/async/processing_strand.hpp>
 #include <shared_data/directory_entry.hpp>
 #include <ssh/file_stream.hpp>
 #include <ssh/sftp_error.hpp>
@@ -27,7 +28,7 @@ namespace SecureShell
         using Error = SftpError;
         friend class FileStream;
 
-        SftpSession(Session* owner, sftp_session session);
+        SftpSession(Session* owner, std::unique_ptr<ProcessingStrand> strand, sftp_session session);
         ~SftpSession();
         SftpSession(SftpSession const&) = delete;
         SftpSession& operator=(SftpSession const&) = delete;
@@ -39,7 +40,7 @@ namespace SecureShell
             return session_;
         }
 
-        void close(bool removeSelf = true);
+        void close();
 
         struct DirectoryEntry : public SharedData::DirectoryEntry
         {
@@ -49,34 +50,13 @@ namespace SecureShell
         template <typename FunctionT>
         void perform(FunctionT&& func)
         {
-            std::scoped_lock lock{ownerMutex_};
-            if (owner_)
-                owner_->processingThread_.pushTask(std::forward<FunctionT>(func));
+            strand_->pushTask(std::forward<FunctionT>(func));
         }
 
         template <typename FunctionT>
         auto performPromise(FunctionT&& func) -> std::future<std::invoke_result_t<std::decay_t<FunctionT>>>
         {
-            using ResultType = std::invoke_result_t<std::decay_t<FunctionT>>;
-            {
-                std::scoped_lock lock{ownerMutex_};
-                if (owner_)
-                    return owner_->processingThread_.pushPromiseTask(std::forward<FunctionT>(func));
-            }
-            std::promise<ResultType> promise{};
-            promise.set_value(std::unexpected(SftpError{
-                .message = "Owner is null",
-                .wrapperError = WrapperErrors::OwnerNull,
-            }));
-            return promise.get_future();
-        }
-
-        bool awaitCycle()
-        {
-            std::scoped_lock lock{ownerMutex_};
-            if (owner_)
-                return owner_->processingThread_.awaitCycle();
-            return false;
+            return strand_->pushPromiseTask(std::forward<FunctionT>(func));
         }
 
         /**
@@ -193,8 +173,8 @@ namespace SecureShell
         void removeAllFileStreams();
 
       private:
-        std::mutex ownerMutex_;
         Session* owner_;
+        std::unique_ptr<ProcessingStrand> strand_;
         sftp_session session_;
         std::vector<std::shared_ptr<FileStream>> fileStreams_;
     };
diff --git a/ssh/source/ssh/async/processing_thread.cpp b/ssh/source/ssh/async/processing_thread.cpp
index bdadf8ed..bb86475e 100644
--- a/ssh/source/ssh/async/processing_thread.cpp
+++ b/ssh/source/ssh/async/processing_thread.cpp
@@ -1,4 +1,5 @@
 #include <ssh/async/processing_thread.hpp>
+#include <ssh/async/processing_strand.hpp>
 
 #include <stdexcept>
 #include <future>
@@ -68,6 +69,10 @@ namespace SecureShell
         taskCondition_.notify_one();
         return true;
     }
+    std::unique_ptr<ProcessingStrand> ProcessingThread::createStrand()
+    {
+        return std::make_unique<ProcessingStrand>(this);
+    }
     std::pair<bool, ProcessingThread::PermanentTaskId> ProcessingThread::pushPermanentTask(std::function<void()> task)
     {
         if (!task)
@@ -107,14 +112,28 @@ namespace SecureShell
     }
     bool ProcessingThread::removePermanentTask(PermanentTaskId const& id)
     {
-        std::lock_guard lock{taskMutex_};
+        std::unique_lock lock{taskMutex_};
         if (processingPermanents_)
         {
-            deferredTaskModification_.push_back([this, id]() {
-                permanentTasks_.erase(id);
-                permanentTasksAvailable_ = !permanentTasks_.empty();
-            });
-            return true;
+            if (withinProcessingThread())
+            {
+                deferredTaskModification_.push_back([this, id]() {
+                    permanentTasks_.erase(id);
+                    permanentTasksAvailable_ = !permanentTasks_.empty();
+                });
+                return true;
+            }
+            else
+            {
+                std::promise<bool> promise{};
+                deferredTaskModification_.push_back([this, id, &promise]() {
+                    const bool result = permanentTasks_.erase(id) > 0;
+                    permanentTasksAvailable_ = !permanentTasks_.empty();
+                    promise.set_value(result);
+                });
+                lock.unlock();
+                return promise.get_future().wait_for(std::chrono::seconds{5}) == std::future_status::ready;
+            }
         }
 
         auto result = permanentTasks_.erase(id);
diff --git a/ssh/source/ssh/channel.cpp b/ssh/source/ssh/channel.cpp
index 41b01656..46dad315 100644
--- a/ssh/source/ssh/channel.cpp
+++ b/ssh/source/ssh/channel.cpp
@@ -3,8 +3,9 @@
 
 namespace SecureShell
 {
-    Channel::Channel(Session* owner, std::unique_ptr<ssh::Channel> channel)
+    Channel::Channel(Session* owner, std::unique_ptr<ProcessingStrand> strand, std::unique_ptr<ssh::Channel> channel)
         : owner_{owner}
+        , strand_{std::move(strand)}
         , channel_{std::move(channel)}
     {}
     Channel::~Channel()
@@ -14,53 +15,42 @@ namespace SecureShell
     }
     Channel::Channel(Channel&& other)
         : owner_{std::exchange(other.owner_, nullptr)}
+        , strand_{std::move(other.strand_)}
+        , channel_{std::move(other.channel_)}
     {}
     Channel& Channel::operator=(Channel&& other)
     {
-        std::scoped_lock lock{ownerMutex_, other.ownerMutex_};
         if (this != &other)
         {
             owner_ = std::exchange(other.owner_, nullptr);
+            strand_ = std::exchange(other.strand_, nullptr);
+            channel_ = std::exchange(other.channel_, nullptr);
         }
         return *this;
     }
-    void Channel::shutdown()
-    {
-        {
-            std::scoped_lock lock{ownerMutex_};
-            if (owner_ && readTaskId_)
-                owner_->processingThread_.removePermanentTask(*readTaskId_);
-        }
-        if (channel_ && channel_->isOpen())
-        {
-            channel_->sendEof();
-            channel_->close();
-        }
-        channel_.reset();
-    }
     void Channel::close()
     {
-        shutdown();
-        decltype(owner_) cpy = nullptr;
-        {
-            std::scoped_lock lock{ownerMutex_};
-            cpy = std::exchange(owner_, nullptr);
-        }
-        cpy->channelRemoveItself(this);
+        strand_->doFinalSync([this]() {
+            if (channel_ && channel_->isOpen())
+            {
+                channel_->sendEof();
+                channel_->close();
+            }
+            channel_.reset();
+            owner_->channelRemoveItself(this);
+        });
     }
     void Channel::write(std::string data)
     {
-        std::scoped_lock lock{ownerMutex_};
-        owner_->processingThread_.pushTask([this, data = std::move(data)]() {
+        strand_->pushTask([this, data = std::move(data)]() {
             if (channel_)
                 channel_->write(data.data(), data.size());
         });
     }
     std::future<int> Channel::resizePty(int cols, int rows)
     {
-        std::scoped_lock lock{ownerMutex_};
         auto promise = std::make_shared<std::promise<int>>();
-        owner_->processingThread_.pushTask([this, cols, rows, promise]() {
+        strand_->pushTask([this, cols, rows, promise]() {
             if (channel_)
                 promise->set_value(channel_->changePtySize(cols, rows));
             else
@@ -120,22 +110,17 @@ namespace SecureShell
         std::function<void(std::string const&)> onStderr,
         std::function<void()> onExit)
     {
-        std::scoped_lock lock{ownerMutex_};
-
         onStdout_ = std::move(onStdout);
         onStderr_ = std::move(onStderr);
         onExit_ = std::move(onExit);
 
-        auto [success, id] = owner_->processingThread_.pushPermanentTask([this]() {
+        auto [success, id] = strand_->pushPermanentTask([this]() {
             readTask();
         });
         if (!success)
         {
-            // TODO: ???
-        }
-        else
-        {
-            readTaskId_ = id;
+            // TODO: Do I want to throw here?
+            throw std::runtime_error("Failed to start reading.");
         }
     }
 }
\ No newline at end of file
diff --git a/ssh/source/ssh/session.cpp b/ssh/source/ssh/session.cpp
index ec9ea429..b7f29863 100644
--- a/ssh/source/ssh/session.cpp
+++ b/ssh/source/ssh/session.cpp
@@ -11,7 +11,6 @@ namespace SecureShell
         : processingThread_{}
         , session_{}
         , channels_{}
-        , channelsToRemove_{}
     {}
 
     void Session::start()
@@ -47,68 +46,37 @@ namespace SecureShell
     void Session::removeAllChannels()
     {
         processingThread_.pushTask([this]() {
-            if (!channelsToRemove_.empty())
-                removalTask();
-            channelsToRemove_ = std::move(channels_);
-            removalTask();
+            for (auto& channel : channels_)
+                channel->close();
         });
     }
 
-    void Session::channelRemoveItself(Channel* channel)
+    void Session::removeAllSftpSessions()
     {
-        if (channel)
-        {
-            processingThread_.pushTask([this, channel]() {
-                auto it = std::find_if(channels_.begin(), channels_.end(), [channel](const auto& c) {
-                    return c.get() == channel;
-                });
-                if (it != channels_.end())
-                {
-                    channelsToRemove_.push_back(*it);
-                    channels_.erase(it);
-                    removalTask();
-                }
-                else
-                {
-                    // Possibly already flagged for removal
-                }
-            });
-        }
+        processingThread_.pushTask([this]() {
+            for (auto& sftp : sftpSessions_)
+                sftp->close();
+        });
     }
 
-    void Session::removalTask()
+    void Session::channelRemoveItself(Channel* channel)
     {
-        for (const auto& toRemove : channelsToRemove_)
-        {
-            toRemove->shutdown();
-        }
-        channelsToRemove_.clear();
+        processingThread_.pushTask([this, channel]() {
+            auto it = std::find_if(channels_.begin(), channels_.end(), [channel](const auto& c) {
+                return c.get() == channel;
+            });
+            if (it != channels_.end())
+                channels_.erase(it);
+        });
     }
-
     void Session::sftpSessionRemoveItself(SftpSession* sftpSession)
     {
-        if (sftpSession)
-        {
-            processingThread_.pushTask([this, sftpSession]() {
-                auto it = std::find_if(sftpSessions_.begin(), sftpSessions_.end(), [sftpSession](const auto& s) {
-                    return s.get() == sftpSession;
-                });
-                if (it != sftpSessions_.end())
-                {
-                    sftpSessions_.erase(it);
-                }
+        processingThread_.pushTask([this, sftpSession]() {
+            auto it = std::find_if(sftpSessions_.begin(), sftpSessions_.end(), [sftpSession](const auto& s) {
+                return s.get() == sftpSession;
             });
-        }
-    }
-
-    void Session::removeAllSftpSessions()
-    {
-        processingThread_.pushTask([this]() {
-            for (auto& sftp : sftpSessions_)
-            {
-                sftp->close(false);
-            }
-            sftpSessions_.clear();
+            if (it != sftpSessions_.end())
+                sftpSessions_.erase(it);
         });
     }
 
@@ -149,7 +117,8 @@ namespace SecureShell
                 return promise->set_value(std::unexpected(session_.getErrorCode()));
             }
 
-            auto sharedChannel = std::make_shared<Channel>(this, std::move(ptyChannel));
+            auto sharedChannel =
+                std::make_shared<Channel>(this, processingThread_.createStrand(), std::move(ptyChannel));
             channels_.push_back(sharedChannel);
             return promise->set_value(sharedChannel);
         });
@@ -182,7 +151,7 @@ namespace SecureShell
                 sftp_free(sftp);
             }
 
-            auto sftpSession = std::make_shared<SftpSession>(this, sftp);
+            auto sftpSession = std::make_shared<SftpSession>(this, processingThread_.createStrand(), sftp);
             promise->set_value(sftpSession);
             sftpSessions_.push_back(sftpSession);
         });
diff --git a/ssh/source/ssh/sftp_session.cpp b/ssh/source/ssh/sftp_session.cpp
index 7143706d..a32b6103 100644
--- a/ssh/source/ssh/sftp_session.cpp
+++ b/ssh/source/ssh/sftp_session.cpp
@@ -7,9 +7,9 @@
 
 namespace SecureShell
 {
-    SftpSession::SftpSession(Session* owner, sftp_session session)
-        : ownerMutex_{}
-        , owner_{owner}
+    SftpSession::SftpSession(Session* owner, std::unique_ptr<ProcessingStrand> strand, sftp_session session)
+        : owner_{owner}
+        , strand_{std::move(strand)}
         , session_{session}
         , fileStreams_{}
     {}
@@ -18,42 +18,32 @@ namespace SecureShell
         /* close makes no sense, since this lives in a shared_ptr and will only ever end here when it was already
          * removed */
     }
-    void SftpSession::close(bool removeSelf)
+    void SftpSession::close()
     {
-        removeAllFileStreams();
-        {
-            std::scoped_lock lock{ownerMutex_};
-            if (owner_)
-            {
-                if (removeSelf)
-                    owner_->sftpSessionRemoveItself(this);
-                owner_ = nullptr;
-            }
-        }
+        strand_->doFinalSync([this]() {
+            removeAllFileStreams();
+            owner_->sftpSessionRemoveItself(this);
+        });
     }
     void SftpSession::fileStreamRemoveItself(FileStream* stream)
     {
-        if (stream)
-        {
-            perform([this, stream]() {
-                fileStreams_.erase(
-                    std::remove_if(
-                        fileStreams_.begin(),
-                        fileStreams_.end(),
-                        [stream](auto const& item) {
-                            return item.get() == stream;
-                        }),
-                    fileStreams_.end());
-            });
-            awaitCycle();
-        }
+        perform([this, stream]() {
+            fileStreams_.erase(
+                std::remove_if(
+                    fileStreams_.begin(),
+                    fileStreams_.end(),
+                    [stream](auto const& item) {
+                        return item.get() == stream;
+                    }),
+                fileStreams_.end());
+        });
     }
     void SftpSession::removeAllFileStreams()
     {
         perform([this]() {
-            fileStreams_.clear();
+            for (auto& stream : fileStreams_)
+                stream->close();
         });
-        awaitCycle();
     }
     SftpSession::DirectoryEntry SftpSession::DirectoryEntry::fromSftpAttributes(sftp_attributes attributes)
     {
diff --git a/ssh/test/ssh/test_processing_thread.hpp b/ssh/test/ssh/test_processing_thread.hpp
index b3dbaad2..a6d5706d 100644
--- a/ssh/test/ssh/test_processing_thread.hpp
+++ b/ssh/test/ssh/test_processing_thread.hpp
@@ -2,10 +2,10 @@
 
 #include "utility/awaiter.hpp"
 #include <ssh/async/processing_thread.hpp>
+#include <ssh/async/processing_strand.hpp>
 
 #include <gtest/gtest.h>
 
-#include <future>
 #include <latch>
 #include <thread>
 
@@ -356,4 +356,130 @@ namespace SecureShell::Test
             EXPECT_TRUE(processingThread.awaitCycle());
         }
     }
+
+    TEST_F(ProcessingThreadTest, CanMakeStrandAndPushTaskThroughIt)
+    {
+        ProcessingThread processingThread;
+        processingThread.start(std::chrono::milliseconds{1});
+        auto strand = processingThread.createStrand();
+        strand->pushTask([] {});
+        processingThread.stop();
+    }
+
+    TEST_F(ProcessingThreadTest, CanMakeStrandAndPushPermanentTaskThroughIt)
+    {
+        ProcessingThread processingThread;
+        processingThread.start(std::chrono::milliseconds{1});
+        auto strand = processingThread.createStrand();
+        strand->pushPermanentTask([] {});
+        processingThread.stop();
+    }
+
+    TEST_F(ProcessingThreadTest, TaskInStrandIsExecuted)
+    {
+        Awaiter awaiter{};
+        ProcessingThread processingThread;
+        processingThread.start(std::chrono::milliseconds{1});
+        auto strand = processingThread.createStrand();
+        strand->pushTask([&awaiter] {
+            awaiter.arrive();
+        });
+        ASSERT_TRUE(awaiter.waitFor());
+    }
+
+    TEST_F(ProcessingThreadTest, PermanentTaskInStrandIsExecuted)
+    {
+        Awaiter awaiter{};
+        ProcessingThread processingThread;
+        processingThread.start(std::chrono::milliseconds{1});
+        auto strand = processingThread.createStrand();
+        auto result = strand->pushPermanentTask([&awaiter] {
+            awaiter.arrive();
+        });
+        ASSERT_TRUE(result.first);
+        ASSERT_TRUE(awaiter.waitFor());
+    }
+
+    TEST_F(ProcessingThreadTest, CannotPushTaskAfterFinalTask)
+    {
+        ProcessingThread processingThread;
+        processingThread.start(std::chrono::milliseconds{1});
+        auto strand = processingThread.createStrand();
+        strand->pushFinalTask([] {});
+        EXPECT_FALSE(strand->pushTask([] {}));
+    }
+
+    TEST_F(ProcessingThreadTest, CannotPushPermanentTaskAfterFinalTask)
+    {
+        ProcessingThread processingThread;
+        processingThread.start(std::chrono::milliseconds{1});
+        auto strand = processingThread.createStrand();
+        strand->pushFinalTask([] {});
+        EXPECT_FALSE(strand->pushPermanentTask([] {}).first);
+    }
+
+    TEST_F(ProcessingThreadTest, CanPushFinalTaskAfterFinalTask)
+    {
+        ProcessingThread processingThread;
+        processingThread.start(std::chrono::milliseconds{1});
+        auto strand = processingThread.createStrand();
+        strand->pushFinalTask([] {});
+        EXPECT_NO_THROW(strand->pushFinalTask([] {}));
+    }
+
+    TEST_F(ProcessingThreadTest, FinalTaskRemovesAllPermanentTasks)
+    {
+        ProcessingThread processingThread;
+        processingThread.start(std::chrono::milliseconds{1});
+        auto strand = processingThread.createStrand();
+        strand->pushPermanentTask([] {});
+        strand->pushPermanentTask([] {});
+        strand->pushPermanentTask([] {});
+        strand->pushFinalTask([] {});
+        EXPECT_EQ(0, processingThread.permanentTaskCount());
+    }
+
+    TEST_F(ProcessingThreadTest, CanPushFinalFromTask)
+    {
+        Awaiter awaiter{};
+        ProcessingThread processingThread;
+        processingThread.start(std::chrono::milliseconds{1});
+        auto strand = processingThread.createStrand();
+        strand->pushTask([&strand, &awaiter] {
+            strand->pushFinalTask([&awaiter] {
+                awaiter.arrive();
+            });
+        });
+        ASSERT_TRUE(awaiter.waitFor());
+    }
+
+    TEST_F(ProcessingThreadTest, CanPushFinalFromPermanentTask)
+    {
+        Awaiter awaiter{};
+        ProcessingThread processingThread;
+        processingThread.start(std::chrono::milliseconds{1});
+        auto strand = processingThread.createStrand();
+        strand->pushPermanentTask([&strand, &awaiter] {
+            strand->pushFinalTask([&awaiter] {
+                awaiter.arrive();
+            });
+        });
+        ASSERT_TRUE(awaiter.waitFor());
+    }
+
+    TEST_F(ProcessingThreadTest, CanPushFinalFromTaskFromPermanentTask)
+    {
+        Awaiter awaiter{};
+        ProcessingThread processingThread;
+        processingThread.start(std::chrono::milliseconds{1});
+        auto strand = processingThread.createStrand();
+        strand->pushPermanentTask([&strand, &awaiter] {
+            strand->pushTask([&strand, &awaiter] {
+                strand->pushFinalTask([&awaiter] {
+                    awaiter.arrive();
+                });
+            });
+        });
+        ASSERT_TRUE(awaiter.waitFor());
+    }
 }
\ No newline at end of file
diff --git a/ssh/test/ssh/test_sftp.hpp b/ssh/test/ssh/test_sftp.hpp
index 8ad0b7b3..1a487978 100644
--- a/ssh/test/ssh/test_sftp.hpp
+++ b/ssh/test/ssh/test_sftp.hpp
@@ -79,7 +79,7 @@ namespace SecureShell::Test
         ASSERT_EQ(fut.wait_for(1s), std::future_status::ready);
         auto result = fut.get();
 
-        ASSERT_TRUE(result.has_value());
+        ASSERT_TRUE(result.has_value()) << result.error().toString();
         EXPECT_GT(result.value().size(), 0);
         auto it = std::find_if(result.value().begin(), result.value().end(), [](const auto& entry) {
             return entry.path == "file1.txt";

From 9ee44191f98f7b4b261081e9657e4c613ca4d36d Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sat, 8 Mar 2025 03:40:00 +0100
Subject: [PATCH 05/42] Added some docs comments.

---
 ssh/include/ssh/async/processing_strand.hpp | 50 +++++++++++++++++----
 1 file changed, 42 insertions(+), 8 deletions(-)

diff --git a/ssh/include/ssh/async/processing_strand.hpp b/ssh/include/ssh/async/processing_strand.hpp
index 996df09f..bf0d818a 100644
--- a/ssh/include/ssh/async/processing_strand.hpp
+++ b/ssh/include/ssh/async/processing_strand.hpp
@@ -9,42 +9,65 @@
 
 namespace SecureShell
 {
+    /**
+     * @brief This class makes it impossible to push tasks to a strand after it has been finalized.
+     * Finalization usually means some close operation is happening and no more tasks should be pushed.
+     * Like reading a file when the session is closed.
+     */
     class ProcessingStrand
     {
       public:
+        /**
+         * @brief Construct a new Processing Strand object living on top of a processing thread.
+         *
+         * @param processingThread The processing thread to push tasks to.
+         */
         ProcessingStrand(ProcessingThread* processingThread)
             : processingThread_(processingThread)
         {}
 
+        /**
+         * @brief Pushes a task, but not if the strand has been finalized and not simultaneously with any other push.
+         *
+         * @param task The task to push.
+         * @return true If the task was pushed.
+         * @return false If the strand has been finalized or the task was empty.
+         */
         bool pushTask(std::function<void()> task)
         {
             std::scoped_lock lock(mutex_);
             if (finalized_)
-            {
                 return false;
-            }
             return processingThread_->pushTask(std::move(task));
         }
 
+        /**
+         * @brief Pushes a task that will be executed until the strand is finalized.
+         * But not if the strand has been finalized and not simultaneously with any other push.
+         *
+         * @param task The task to push.
+         * @return std::pair<bool, ProcessingThread::PermanentTaskId> If the task was pushed and the id of the task.
+         */
         std::pair<bool, ProcessingThread::PermanentTaskId> pushPermanentTask(std::function<void()> task)
         {
             std::scoped_lock lock(mutex_);
             if (finalized_)
-            {
                 return {false, ProcessingThread::PermanentTaskId{-1}};
-            }
             auto result = processingThread_->pushPermanentTask(std::move(task));
             this->permanentTasks_.insert(result.second);
             return result;
         }
 
+        /**
+         * @brief Pushes a task that makes any further pushes impossible. Also removes all permanent tasks.
+         *
+         * @param task The task to push.
+         */
         void pushFinalTask(std::function<void()> task)
         {
             std::scoped_lock lock(mutex_);
             if (finalized_)
-            {
                 return;
-            }
             finalized_ = true;
             for (auto const& id : permanentTasks_)
             {
@@ -53,13 +76,17 @@ namespace SecureShell
             processingThread_->pushTask(std::move(task));
         }
 
+        /**
+         * @brief Does a final task but runs it on the current calling thread.
+         * Otherwise behaves like pushFinalTask.
+         *
+         * @param task The task to run.
+         */
         void doFinalSync(std::function<void()> const& task)
         {
             std::scoped_lock lock(mutex_);
             if (finalized_)
-            {
                 return;
-            }
             finalized_ = true;
             for (auto const& id : permanentTasks_)
             {
@@ -68,6 +95,13 @@ namespace SecureShell
             task();
         }
 
+        /**
+         * @brief Pushes a task the return of which is returned for a future.
+         *
+         * @tparam Func The type of the task.
+         * @param func The task to push.
+         * @return std::future<std::invoke_result_t<std::decay_t<Func>>> The future of the return value of the task.
+         */
         template <typename Func>
         auto pushPromiseTask(Func&& func) -> std::future<std::invoke_result_t<std::decay_t<Func>>>
         {

From 5f410f33f88992314cc5759de65e5c80e7364ccb Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sat, 8 Mar 2025 03:46:30 +0100
Subject: [PATCH 06/42] Added documentation to processing thread class.

---
 ssh/include/ssh/async/processing_thread.hpp | 81 +++++++++++++++++++++
 1 file changed, 81 insertions(+)

diff --git a/ssh/include/ssh/async/processing_thread.hpp b/ssh/include/ssh/async/processing_thread.hpp
index f90f3ab6..bab8ea4a 100644
--- a/ssh/include/ssh/async/processing_thread.hpp
+++ b/ssh/include/ssh/async/processing_thread.hpp
@@ -14,11 +14,18 @@ namespace SecureShell
 {
     class ProcessingStrand;
 
+    /**
+     * @brief A processing thread that can be used to execute tasks sequentially in a separate thread.
+     * This allows for complex simultaneous operations to be executed in a single thread.
+     */
     class ProcessingThread
     {
       public:
         constexpr static unsigned int maximumTasksProcessableAtOnce = 100;
 
+        /**
+         * @brief A permanent task id that can be used to remove permanent tasks.
+         */
         struct PermanentTaskId
         {
             int id = -1;
@@ -35,15 +42,47 @@ namespace SecureShell
         ProcessingThread(ProcessingThread&&) = delete;
         ProcessingThread& operator=(ProcessingThread&&) = delete;
 
+        /**
+         * @brief Starts the processing thread.
+         *
+         * @param waitCycleTimeout The time to wait for a task to become available before checking if the thread should
+         * stop.
+         * @param minimumCycleWait The minimum wait time between cycles to throttle the processing thread in case of the
+         * existence of permanent tasks.
+         */
         void start(
             std::chrono::milliseconds const& waitCycleTimeout = std::chrono::seconds{1},
             std::chrono::milliseconds const& minimumCycleWait = std::chrono::milliseconds{0});
+
+        /**
+         * @brief Stops the processing thread. Executes all pending tasks.
+         */
         void stop();
 
+        /**
+         * @brief Returns true if the processing thread is running.
+         *
+         * @return true If the processing thread is running.
+         * @return false If the processing thread is not running.
+         */
         bool isRunning() const;
 
+        /**
+         * @brief Pushes a task to the processing thread.
+         *
+         * @param task The task to push.
+         * @return true If the task was pushed.
+         * @return false If the task was empty or the processing thread is shutting down.
+         */
         bool pushTask(std::function<void()> task);
 
+        /**
+         * @brief Pushes a task that has a return value to the processing thread.
+         * The return value is then accessible through the returned future.
+         *
+         * @param func The function to execute.
+         * @return std::future<std::invoke_result_t<std::decay_t<Func>>> The future that will contain the return value.
+         */
         template <typename Func>
         auto pushPromiseTask(Func&& func) -> std::future<std::invoke_result_t<std::decay_t<Func>>>
         {
@@ -63,18 +102,60 @@ namespace SecureShell
             return promise->get_future();
         }
 
+        /**
+         * @brief Pushes a task that is not removed upon execution. Will be executed every cycle.
+         *
+         * @param task The task to push.
+         * @return std::pair<bool, PermanentTaskId> If the task was pushed and the id of the task.
+         */
         std::pair<bool, PermanentTaskId> pushPermanentTask(std::function<void()> task);
+
+        /**
+         * @brief Removes a permanent task.
+         *
+         * @param id The id of the task to remove.
+         * @return true If the task was removed.
+         * @return false If the task was not found.
+         */
         bool removePermanentTask(PermanentTaskId const& id);
+
+        /**
+         * @brief Returns the number of permanent tasks.
+         *
+         * @return int The number of permanent tasks.
+         */
         int permanentTaskCount() const;
+
+        /**
+         * @brief Removes all permanent tasks.
+         */
         void clearPermanentTasks();
 
+        /**
+         * @brief Waits for a cycle to complete.
+         *
+         * @param maxWait The maximum time to wait for a cycle.
+         * @return true If a cycle was completed.
+         * @return false If the maximum wait time was reached.
+         */
         bool awaitCycle(std::chrono::milliseconds maxWait = std::chrono::seconds{5});
 
+        /**
+         * @brief Returns true if the current thread is the processing thread.
+         *
+         * @return true If the current thread is the processing thread.
+         * @return false If the current thread is not the processing thread.
+         */
         bool withinProcessingThread() const
         {
             return processingThreadId_ == std::this_thread::get_id();
         }
 
+        /**
+         * @brief Creates a new processing strand.
+         *
+         * @return std::unique_ptr<ProcessingStrand> The processing strand.
+         */
         std::unique_ptr<ProcessingStrand> createStrand();
 
       private:

From 1d0b3f30daed2b2e901ee1a013e97084da21ecf0 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sat, 8 Mar 2025 17:31:49 +0100
Subject: [PATCH 07/42] Improved multi threading behaviour of close.

---
 ssh/include/ssh/async/processing_strand.hpp |  39 ++++++-
 ssh/include/ssh/async/processing_thread.hpp |  18 +--
 ssh/include/ssh/channel.hpp                 |   4 +-
 ssh/include/ssh/file_stream.hpp             |   2 +-
 ssh/include/ssh/session.hpp                 |   4 +-
 ssh/include/ssh/sftp_error.hpp              |   3 +-
 ssh/include/ssh/sftp_session.hpp            |   4 +-
 ssh/source/ssh/async/processing_thread.cpp  |  97 ++++++++-------
 ssh/source/ssh/channel.cpp                  |  51 +++++---
 ssh/source/ssh/file_stream.cpp              |  37 +++++-
 ssh/source/ssh/session.cpp                  |  68 ++++++-----
 ssh/source/ssh/sftp_session.cpp             |  42 ++++---
 ssh/test/ssh/test_processing_thread.hpp     |   2 +-
 ssh/test/ssh/test_sftp.hpp                  |  32 +++++
 ssh/test/ssh/test_ssh_session.hpp           | 123 ++++++++++++++++++++
 15 files changed, 385 insertions(+), 141 deletions(-)

diff --git a/ssh/include/ssh/async/processing_strand.hpp b/ssh/include/ssh/async/processing_strand.hpp
index bf0d818a..bb2e38c1 100644
--- a/ssh/include/ssh/async/processing_strand.hpp
+++ b/ssh/include/ssh/async/processing_strand.hpp
@@ -76,6 +76,30 @@ namespace SecureShell
             processingThread_->pushTask(std::move(task));
         }
 
+        /**
+         * @brief Works like pushFinalTask but returns a future for the return value of the task.
+         *
+         * @param task The task to run.
+         */
+        template <typename FunctionT>
+        auto pushFinalPromiseTask(FunctionT&& func) -> std::future<std::invoke_result_t<std::decay_t<FunctionT>>>
+        {
+            std::scoped_lock lock(mutex_);
+            if (finalized_)
+            {
+                std::promise<std::invoke_result_t<std::decay_t<FunctionT>>> promise{};
+                promise.set_exception(
+                    std::make_exception_ptr(std::runtime_error("Cannot push task to finalized strand.")));
+                return promise.get_future();
+            }
+            finalized_ = true;
+            for (auto const& id : permanentTasks_)
+            {
+                processingThread_->removePermanentTask(id);
+            }
+            return processingThread_->pushPromiseTask(std::forward<FunctionT>(func));
+        }
+
         /**
          * @brief Does a final task but runs it on the current calling thread.
          * Otherwise behaves like pushFinalTask.
@@ -108,11 +132,24 @@ namespace SecureShell
             std::scoped_lock lock(mutex_);
             if (finalized_)
             {
-                throw std::runtime_error("Cannot push task to finalized strand.");
+                std::promise<std::invoke_result_t<std::decay_t<Func>>> promise{};
+                promise.set_exception(
+                    std::make_exception_ptr(std::runtime_error("Cannot push task to finalized strand.")));
+                return promise.get_future();
             }
             return processingThread_->pushPromiseTask(std::forward<Func>(func));
         }
 
+        bool withinProcessingThread() const noexcept
+        {
+            return processingThread_->withinProcessingThread();
+        }
+
+        bool isFinalized() const noexcept
+        {
+            return finalized_;
+        }
+
       private:
         std::recursive_mutex mutex_{};
         bool finalized_ = false;
diff --git a/ssh/include/ssh/async/processing_thread.hpp b/ssh/include/ssh/async/processing_thread.hpp
index bab8ea4a..1dd3b60f 100644
--- a/ssh/include/ssh/async/processing_thread.hpp
+++ b/ssh/include/ssh/async/processing_thread.hpp
@@ -2,7 +2,7 @@
 
 #include <thread>
 #include <atomic>
-#include <queue>
+#include <deque>
 #include <mutex>
 #include <functional>
 #include <condition_variable>
@@ -21,7 +21,7 @@ namespace SecureShell
     class ProcessingThread
     {
       public:
-        constexpr static unsigned int maximumTasksProcessableAtOnce = 100;
+        constexpr static std::size_t maximumTasksProcessableAtOnce = 100ull;
 
         /**
          * @brief A permanent task id that can be used to remove permanent tasks.
@@ -50,9 +50,7 @@ namespace SecureShell
          * @param minimumCycleWait The minimum wait time between cycles to throttle the processing thread in case of the
          * existence of permanent tasks.
          */
-        void start(
-            std::chrono::milliseconds const& waitCycleTimeout = std::chrono::seconds{1},
-            std::chrono::milliseconds const& minimumCycleWait = std::chrono::milliseconds{0});
+        void start(std::chrono::milliseconds const& minimumCycleWait = std::chrono::milliseconds{0});
 
         /**
          * @brief Stops the processing thread. Executes all pending tasks.
@@ -146,7 +144,7 @@ namespace SecureShell
          * @return true If the current thread is the processing thread.
          * @return false If the current thread is not the processing thread.
          */
-        bool withinProcessingThread() const
+        bool withinProcessingThread() const noexcept
         {
             return processingThreadId_ == std::this_thread::get_id();
         }
@@ -159,7 +157,7 @@ namespace SecureShell
         std::unique_ptr<ProcessingStrand> createStrand();
 
       private:
-        void run(std::chrono::milliseconds const& waitCycleTimeout, std::chrono::milliseconds const& minimumCycleWait);
+        void run(std::chrono::milliseconds const& minimumCycleWait);
 
       private:
         std::thread thread_{};
@@ -172,11 +170,7 @@ namespace SecureShell
         std::atomic_bool processingPermanents_{false};
         std::vector<std::function<void()>> deferredTaskModification_{};
 
-        std::mutex taskWaitMutex_{};
-        std::condition_variable taskCondition_{};
-        bool taskAvailable_ = false;
-
-        std::queue<std::function<void()>> tasks_{};
+        std::deque<std::function<void()>> tasks_{};
         std::map<PermanentTaskId, std::function<void()>> permanentTasks_{};
     };
 }
\ No newline at end of file
diff --git a/ssh/include/ssh/channel.hpp b/ssh/include/ssh/channel.hpp
index 1ba15d52..65a337ca 100644
--- a/ssh/include/ssh/channel.hpp
+++ b/ssh/include/ssh/channel.hpp
@@ -29,14 +29,14 @@ namespace SecureShell
             return *channel_;
         }
 
-        void close();
+        bool close(bool isBackElement = false);
 
         /**
          * @brief Writes data to the channel.
          *
          * @param data The data to write
          */
-        void write(std::string data);
+        bool write(std::string data);
 
         struct Dimensions
         {
diff --git a/ssh/include/ssh/file_stream.hpp b/ssh/include/ssh/file_stream.hpp
index dc6c4a81..deb89aaa 100644
--- a/ssh/include/ssh/file_stream.hpp
+++ b/ssh/include/ssh/file_stream.hpp
@@ -98,7 +98,7 @@ namespace SecureShell
         /**
          * @brief Closes the file and removes itself from the sftp session.
          */
-        void close();
+        void close(bool isBackElement = false);
 
       private:
         std::function<void(sftp_file)> makeFileDeleter();
diff --git a/ssh/include/ssh/session.hpp b/ssh/include/ssh/session.hpp
index a3d51d6e..b23ef044 100644
--- a/ssh/include/ssh/session.hpp
+++ b/ssh/include/ssh/session.hpp
@@ -80,10 +80,10 @@ namespace SecureShell
         std::future<std::expected<std::weak_ptr<SftpSession>, SftpError>> createSftpSession();
 
       private:
-        void channelRemoveItself(Channel* channel);
+        void channelRemoveItself(Channel* channel, bool isBackElement);
         void removeAllChannels();
 
-        void sftpSessionRemoveItself(SftpSession* sftpSession);
+        void sftpSessionRemoveItself(SftpSession* sftpSession, bool isBackElement);
         void removeAllSftpSessions();
 
         /**
diff --git a/ssh/include/ssh/sftp_error.hpp b/ssh/include/ssh/sftp_error.hpp
index c9039839..77cd38f8 100644
--- a/ssh/include/ssh/sftp_error.hpp
+++ b/ssh/include/ssh/sftp_error.hpp
@@ -13,7 +13,8 @@ namespace SecureShell
         SharedPtrDestroyed,
         // This happens when the client does not respect the server max_write_length.
         // See: https://api.libssh.org/stable/structsftp__limits__struct.html
-        ShortWrite
+        ShortWrite,
+        FileNull,
     };
 
     struct SftpError
diff --git a/ssh/include/ssh/sftp_session.hpp b/ssh/include/ssh/sftp_session.hpp
index 797620be..3f3b654e 100644
--- a/ssh/include/ssh/sftp_session.hpp
+++ b/ssh/include/ssh/sftp_session.hpp
@@ -40,7 +40,7 @@ namespace SecureShell
             return session_;
         }
 
-        void close();
+        bool close(bool isBackElement = false);
 
         struct DirectoryEntry : public SharedData::DirectoryEntry
         {
@@ -169,7 +169,7 @@ namespace SecureShell
         std::future<std::expected<sftp_limits_struct, Error>> limits();
 
       private:
-        void fileStreamRemoveItself(FileStream* stream);
+        void fileStreamRemoveItself(FileStream* stream, bool isBackElement);
         void removeAllFileStreams();
 
       private:
diff --git a/ssh/source/ssh/async/processing_thread.cpp b/ssh/source/ssh/async/processing_thread.cpp
index bb86475e..c3a472f9 100644
--- a/ssh/source/ssh/async/processing_thread.cpp
+++ b/ssh/source/ssh/async/processing_thread.cpp
@@ -16,24 +16,28 @@ namespace SecureShell
     {
         return running_;
     }
-    void ProcessingThread::start(
-        std::chrono::milliseconds const& waitCycleTimeout,
-        std::chrono::milliseconds const& minimumCycleWait)
+    void ProcessingThread::start(std::chrono::milliseconds const& minimumCycleWait)
     {
-        running_ = true;
+        {
+            std::lock_guard lock{taskMutex_};
+            running_ = true;
+        }
         shuttingDown_ = false;
         std::promise<void> awaitThreadStart{};
-        thread_ = std::thread([this, &awaitThreadStart, waitCycleTimeout, minimumCycleWait] {
+        thread_ = std::thread([this, &awaitThreadStart, minimumCycleWait] {
             awaitThreadStart.set_value();
             processingThreadId_.store(std::this_thread::get_id());
-            run(waitCycleTimeout, minimumCycleWait);
+            run(minimumCycleWait);
         });
         awaitThreadStart.get_future().wait();
     }
     void ProcessingThread::stop()
     {
         shuttingDown_ = true;
-        running_ = false;
+        {
+            std::lock_guard lock{taskMutex_};
+            running_ = false;
+        }
         if (thread_.joinable())
             thread_.join();
 
@@ -41,8 +45,8 @@ namespace SecureShell
         std::lock_guard lock{taskMutex_};
         while (!tasks_.empty())
         {
-            tasks_.front()();
-            tasks_.pop();
+            tasks_.back()();
+            tasks_.pop_back();
         }
         shuttingDown_ = false;
     }
@@ -60,13 +64,8 @@ namespace SecureShell
 
         {
             std::lock_guard lock{taskMutex_};
-            tasks_.push(std::move(task));
+            tasks_.push_back(std::move(task));
         }
-        {
-            std::lock_guard lock{taskWaitMutex_};
-            taskAvailable_ = true;
-        }
-        taskCondition_.notify_one();
         return true;
     }
     std::unique_ptr<ProcessingStrand> ProcessingThread::createStrand()
@@ -101,6 +100,7 @@ namespace SecureShell
         if (processingPermanents_)
         {
             deferredTaskModification_.push_back([this]() {
+                /* taskMutex_ is held here */
                 permanentTasks_.clear();
                 permanentTasksAvailable_ = false;
             });
@@ -118,6 +118,7 @@ namespace SecureShell
             if (withinProcessingThread())
             {
                 deferredTaskModification_.push_back([this, id]() {
+                    /* taskMutex_ is held here */
                     permanentTasks_.erase(id);
                     permanentTasksAvailable_ = !permanentTasks_.empty();
                 });
@@ -125,14 +126,15 @@ namespace SecureShell
             }
             else
             {
-                std::promise<bool> promise{};
-                deferredTaskModification_.push_back([this, id, &promise]() {
+                auto promise = std::make_shared<std::promise<bool>>();
+                deferredTaskModification_.push_back([this, id, promise]() {
+                    /* taskMutex_ is held here */
                     const bool result = permanentTasks_.erase(id) > 0;
                     permanentTasksAvailable_ = !permanentTasks_.empty();
-                    promise.set_value(result);
+                    promise->set_value(result);
                 });
                 lock.unlock();
-                return promise.get_future().wait_for(std::chrono::seconds{5}) == std::future_status::ready;
+                return promise->get_future().wait_for(std::chrono::seconds{5}) == std::future_status::ready;
             }
         }
 
@@ -140,9 +142,7 @@ namespace SecureShell
         permanentTasksAvailable_ = !permanentTasks_.empty();
         return result > 0;
     }
-    void ProcessingThread::run(
-        std::chrono::milliseconds const& waitCycleTimeout,
-        std::chrono::milliseconds const& minimumCycleWait)
+    void ProcessingThread::run(std::chrono::milliseconds const& minimumCycleWait)
     {
         auto timePoint = std::chrono::steady_clock::now();
 
@@ -188,40 +188,33 @@ namespace SecureShell
                         modify();
                     }
                 }
-                else
+
                 {
-                    std::unique_lock lock(taskWaitMutex_);
-                    if (!taskAvailable_)
+                    std::vector<std::function<void()>> tasks{};
                     {
-                        bool result = taskCondition_.wait_for(lock, waitCycleTimeout, [this] {
-                            return taskAvailable_;
-                        });
-                        if (!result)
-                            continue;
+                        std::lock_guard lock(taskMutex_);
+                        tasks.reserve(std::min(tasks_.size(), maximumTasksProcessableAtOnce));
+                        std::move(
+                            tasks_.begin(),
+                            tasks_.begin() + std::min(tasks_.size(), maximumTasksProcessableAtOnce),
+                            std::back_inserter(tasks));
+                        tasks_.erase(
+                            tasks_.begin(), tasks_.begin() + std::min(tasks_.size(), maximumTasksProcessableAtOnce));
                     }
-                }
 
-                std::vector<std::function<void()>> tasks{};
-                {
-                    std::lock_guard lock(taskMutex_);
-                    for (int i = 0; i != maximumTasksProcessableAtOnce && !tasks_.empty(); ++i)
+                    for (auto const& task : tasks)
                     {
-                        tasks.push_back(std::move(tasks_.front()));
-                        tasks_.pop();
+                        // Task is checked before adding, shouldnt possibly be empty:
+#ifndef N_DEBUG
+                        if (!task)
+                        {
+                            throw std::runtime_error("Task must not be empty.");
+                        }
+#endif
+                        task();
                     }
                 }
 
-                for (auto& task : tasks)
-                {
-                    // Task is checked before adding, shouldnt possibly be empty:
-                    task();
-                }
-
-                {
-                    std::lock_guard lock{taskWaitMutex_};
-                    taskAvailable_ = !tasks_.empty();
-                }
-
                 if (minimumCycleWait.count() > 0)
                 {
                     auto now = std::chrono::steady_clock::now();
@@ -235,6 +228,7 @@ namespace SecureShell
         }
         catch (...)
         {
+            std::lock_guard lock{taskMutex_};
             running_ = false;
         }
     }
@@ -245,7 +239,12 @@ namespace SecureShell
     }
     bool ProcessingThread::awaitCycle(std::chrono::milliseconds maxWait)
     {
-        if (!withinProcessingThread() && running_)
+        bool running = false;
+        {
+            std::lock_guard lock{taskMutex_};
+            running = running_;
+        }
+        if (!withinProcessingThread() && running)
         {
             return pushPromiseTask([]() {
                        return true;
diff --git a/ssh/source/ssh/channel.cpp b/ssh/source/ssh/channel.cpp
index 46dad315..24cd8438 100644
--- a/ssh/source/ssh/channel.cpp
+++ b/ssh/source/ssh/channel.cpp
@@ -28,21 +28,27 @@ namespace SecureShell
         }
         return *this;
     }
-    void Channel::close()
+    bool Channel::close(bool isBackElement)
     {
-        strand_->doFinalSync([this]() {
-            if (channel_ && channel_->isOpen())
-            {
-                channel_->sendEof();
-                channel_->close();
-            }
-            channel_.reset();
-            owner_->channelRemoveItself(this);
-        });
+        if (strand_->isFinalized())
+            return false;
+
+        return strand_
+            ->pushFinalPromiseTask([this, isBackElement]() {
+                if (channel_ && channel_->isOpen())
+                {
+                    channel_->sendEof();
+                    channel_->close();
+                }
+                channel_.reset();
+                owner_->channelRemoveItself(this, isBackElement);
+                return true;
+            })
+            .get();
     }
-    void Channel::write(std::string data)
+    bool Channel::write(std::string data)
     {
-        strand_->pushTask([this, data = std::move(data)]() {
+        return strand_->pushTask([this, data = std::move(data)]() {
             if (channel_)
                 channel_->write(data.data(), data.size());
         });
@@ -50,12 +56,15 @@ namespace SecureShell
     std::future<int> Channel::resizePty(int cols, int rows)
     {
         auto promise = std::make_shared<std::promise<int>>();
-        strand_->pushTask([this, cols, rows, promise]() {
-            if (channel_)
-                promise->set_value(channel_->changePtySize(cols, rows));
-            else
-                promise->set_value(SSH_ERROR);
-        });
+        if (!strand_->pushTask([this, cols, rows, promise]() {
+                if (channel_)
+                    promise->set_value(channel_->changePtySize(cols, rows));
+                else
+                    promise->set_value(SSH_ERROR);
+            }))
+        {
+            promise->set_value(SSH_ERROR);
+        }
         return promise->get_future();
     }
     void Channel::readTask(std::chrono::milliseconds pollTimeout)
@@ -63,6 +72,12 @@ namespace SecureShell
         if (!onStdout_ || !onStderr_ || !onExit_)
             return;
 
+        if (!channel_)
+        {
+            std::this_thread::sleep_for(pollTimeout);
+            return;
+        }
+
         constexpr static int bufferSize = 1024;
         char buffer[bufferSize];
 
diff --git a/ssh/source/ssh/file_stream.cpp b/ssh/source/ssh/file_stream.cpp
index 585a23e5..d8195d2a 100644
--- a/ssh/source/ssh/file_stream.cpp
+++ b/ssh/source/ssh/file_stream.cpp
@@ -5,6 +5,10 @@
 
 namespace SecureShell
 {
+#define VERIFY_FILE_STREAM() \
+    if (!file_) \
+    return std::unexpected(SftpError{.message = "File is null", .wrapperError = WrapperErrors::FileNull})
+
     template <typename FunctionT>
     void FileStream::perform(FunctionT&& func)
     {
@@ -38,11 +42,24 @@ namespace SecureShell
         , file_{other.file_.release(), makeFileDeleter()}
         , limits_{other.limits_}
     {}
-    void FileStream::close()
+    void FileStream::close(bool isBackElement)
     {
         if (auto sftp = sftp_.lock(); sftp)
         {
-            sftp->fileStreamRemoveItself(this);
+            if (!sftp->strand_->withinProcessingThread())
+            {
+                sftp->performPromise([this, isBackElement, sftp]() -> bool {
+                        file_.reset();
+                        sftp->fileStreamRemoveItself(this, isBackElement);
+                        return true;
+                    })
+                    .get();
+            }
+            else
+            {
+                file_.reset();
+                sftp->fileStreamRemoveItself(this, isBackElement);
+            }
         }
     }
     std::function<void(sftp_file)> FileStream::makeFileDeleter()
@@ -70,6 +87,7 @@ namespace SecureShell
     std::future<std::expected<void, SftpError>> FileStream::seek(std::size_t pos)
     {
         return performPromise([this, pos]() -> std::expected<void, SftpError> {
+            VERIFY_FILE_STREAM();
             sftp_seek64(file_.get(), pos);
             return {};
         });
@@ -77,12 +95,14 @@ namespace SecureShell
     std::future<std::expected<std::size_t, SftpError>> FileStream::tell()
     {
         return performPromise([this]() -> std::expected<std::size_t, SftpError> {
+            VERIFY_FILE_STREAM();
             return static_cast<std::size_t>(sftp_tell64(file_.get()));
         });
     }
     std::future<std::expected<void, SftpError>> FileStream::rewind()
     {
         return performPromise([this]() -> std::expected<void, SftpError> {
+            VERIFY_FILE_STREAM();
             sftp_rewind(file_.get());
             return {};
         });
@@ -104,6 +124,7 @@ namespace SecureShell
     std::future<std::expected<std::size_t, SftpError>> FileStream::read(std::byte* buffer, std::size_t bufferSize)
     {
         return performPromise([this, buffer, bufferSize]() -> std::expected<std::size_t, SftpError> {
+            VERIFY_FILE_STREAM();
             const auto result = sftp_read(file_.get(), buffer, bufferSize);
             if (result < 0)
                 return std::unexpected(lastError());
@@ -156,6 +177,14 @@ namespace SecureShell
             void doRead()
             {
                 stream.perform([state = shared_from_this()]() {
+                    if (!state->stream.file_)
+                    {
+                        state->promise.set_value(std::unexpected(SftpError{
+                            .message = "File is null",
+                            .wrapperError = WrapperErrors::FileNull,
+                        }));
+                        return;
+                    }
                     state->onRead(sftp_read(state->stream.file_.get(), state->buffer.data(), state->buffer.size()));
                 });
             }
@@ -178,6 +207,9 @@ namespace SecureShell
         std::function<void(std::expected<void, SftpError>&&)> onWriteComplete)
     {
         perform([this, toWrite, onWriteComplete = std::move(onWriteComplete)]() {
+            if (!file_)
+                return;
+
             const auto written = sftp_write(file_.get(), toWrite.data(), std::min(toWrite.size(), writeLengthLimit()));
 
             if (written < 0)
@@ -203,6 +235,7 @@ namespace SecureShell
         if (data.size() <= writeLengthLimit())
         {
             return performPromise([this, data]() -> std::expected<void, SftpError> {
+                VERIFY_FILE_STREAM();
                 const auto written = sftp_write(file_.get(), data.data(), data.size());
                 if (written < 0)
                     return std::unexpected(lastError());
diff --git a/ssh/source/ssh/session.cpp b/ssh/source/ssh/session.cpp
index b7f29863..843df2ac 100644
--- a/ssh/source/ssh/session.cpp
+++ b/ssh/source/ssh/session.cpp
@@ -7,6 +7,25 @@
 
 namespace SecureShell
 {
+    namespace
+    {
+        void removeFromContainer(auto& container, auto* ptr, bool isBackElement)
+        {
+            if (isBackElement && container.back().get() == ptr)
+            {
+                container.pop_back();
+            }
+            else
+            {
+                auto it = std::find_if(container.begin(), container.end(), [ptr](const auto& c) {
+                    return c.get() == ptr;
+                });
+                if (it != container.end())
+                    container.erase(it);
+            }
+        }
+    }
+
     Session::Session()
         : processingThread_{}
         , session_{}
@@ -15,7 +34,7 @@ namespace SecureShell
 
     void Session::start()
     {
-        processingThread_.start(std::chrono::milliseconds{100}, std::chrono::milliseconds{1});
+        processingThread_.start(std::chrono::milliseconds{1});
     }
 
     void Session::stop()
@@ -32,10 +51,8 @@ namespace SecureShell
     {
         removeAllChannels();
         removeAllSftpSessions();
-        processingThread_.pushTask([this]() {
-            session_.disconnect();
-        });
         processingThread_.stop();
+        session_.disconnect();
     }
 
     Session::~Session()
@@ -45,46 +62,34 @@ namespace SecureShell
 
     void Session::removeAllChannels()
     {
-        processingThread_.pushTask([this]() {
-            for (auto& channel : channels_)
-                channel->close();
-        });
+        while (!channels_.empty())
+        {
+            channels_.back()->close(true);
+        }
     }
 
     void Session::removeAllSftpSessions()
     {
-        processingThread_.pushTask([this]() {
-            for (auto& sftp : sftpSessions_)
-                sftp->close();
-        });
+        while (!sftpSessions_.empty())
+        {
+            sftpSessions_.back()->close(false);
+        }
     }
 
-    void Session::channelRemoveItself(Channel* channel)
+    void Session::channelRemoveItself(Channel* channel, bool isBackElement)
     {
-        processingThread_.pushTask([this, channel]() {
-            auto it = std::find_if(channels_.begin(), channels_.end(), [channel](const auto& c) {
-                return c.get() == channel;
-            });
-            if (it != channels_.end())
-                channels_.erase(it);
-        });
+        removeFromContainer(channels_, channel, isBackElement);
     }
-    void Session::sftpSessionRemoveItself(SftpSession* sftpSession)
+    void Session::sftpSessionRemoveItself(SftpSession* sftpSession, bool isBackElement)
     {
-        processingThread_.pushTask([this, sftpSession]() {
-            auto it = std::find_if(sftpSessions_.begin(), sftpSessions_.end(), [sftpSession](const auto& s) {
-                return s.get() == sftpSession;
-            });
-            if (it != sftpSessions_.end())
-                sftpSessions_.erase(it);
-        });
+        removeFromContainer(sftpSessions_, sftpSession, isBackElement);
     }
 
     std::future<std::expected<std::weak_ptr<Channel>, int>> Session::createPtyChannel(PtyCreationOptions options)
     {
         auto promise = std::make_shared<std::promise<std::expected<std::weak_ptr<Channel>, int>>>();
-        auto fut = promise->get_future();
-        processingThread_.pushTask([this, options = std::move(options), promise = std::move(promise)]() mutable {
+
+        processingThread_.pushTask([this, options = std::move(options), promise]() mutable {
             auto ptyChannel = std::make_unique<ssh::Channel>(session_);
             auto& channel = *ptyChannel;
             auto result = Detail::sequential(
@@ -122,7 +127,8 @@ namespace SecureShell
             channels_.push_back(sharedChannel);
             return promise->set_value(sharedChannel);
         });
-        return fut;
+
+        return promise->get_future();
     }
 
     std::future<std::expected<std::weak_ptr<SftpSession>, SftpError>> Session::createSftpSession()
diff --git a/ssh/source/ssh/sftp_session.cpp b/ssh/source/ssh/sftp_session.cpp
index a32b6103..8be7b803 100644
--- a/ssh/source/ssh/sftp_session.cpp
+++ b/ssh/source/ssh/sftp_session.cpp
@@ -3,8 +3,6 @@
 
 #include <fcntl.h>
 
-#include <iostream>
-
 namespace SecureShell
 {
     SftpSession::SftpSession(Session* owner, std::unique_ptr<ProcessingStrand> strand, sftp_session session)
@@ -18,16 +16,27 @@ namespace SecureShell
         /* close makes no sense, since this lives in a shared_ptr and will only ever end here when it was already
          * removed */
     }
-    void SftpSession::close()
+    bool SftpSession::close(bool isBackElement)
     {
-        strand_->doFinalSync([this]() {
-            removeAllFileStreams();
-            owner_->sftpSessionRemoveItself(this);
-        });
+        if (strand_->isFinalized())
+            return false;
+
+        return strand_
+            ->pushFinalPromiseTask([this, isBackElement]() {
+                removeAllFileStreams();
+                owner_->sftpSessionRemoveItself(this, isBackElement);
+                return true;
+            })
+            .get();
     }
-    void SftpSession::fileStreamRemoveItself(FileStream* stream)
+    void SftpSession::fileStreamRemoveItself(FileStream* stream, bool isBackElement)
     {
-        perform([this, stream]() {
+        if (isBackElement && fileStreams_.back().get() == stream)
+        {
+            fileStreams_.pop_back();
+        }
+        else
+        {
             fileStreams_.erase(
                 std::remove_if(
                     fileStreams_.begin(),
@@ -36,14 +45,14 @@ namespace SecureShell
                         return item.get() == stream;
                     }),
                 fileStreams_.end());
-        });
+        }
     }
     void SftpSession::removeAllFileStreams()
     {
-        perform([this]() {
-            for (auto& stream : fileStreams_)
-                stream->close();
-        });
+        while (!fileStreams_.empty())
+        {
+            fileStreams_.back()->close(true);
+        }
     }
     SftpSession::DirectoryEntry SftpSession::DirectoryEntry::fromSftpAttributes(sftp_attributes attributes)
     {
@@ -216,18 +225,13 @@ namespace SecureShell
     {
         return performPromise(
             [this, source = std::move(source), destination = std::move(destination)]() -> std::expected<void, Error> {
-                std::cout << "X" << std::endl;
                 auto s = source.generic_string();
                 auto d = destination.generic_string();
 
-                std::cout << "Supported: " << sftp_extension_supported(session_, "posix-rename@openssh.com", "1")
-                          << std::endl;
-
                 auto result = sftp_rename(session_, s.c_str(), d.c_str());
                 if (result != SSH_OK)
                 {
                     const auto le = lastError();
-                    std::cout << "Error: " << le.message << " - " << le.sftpError << " - " << le.sshError << std::endl;
                     return std::unexpected(le);
                 }
                 return {};
diff --git a/ssh/test/ssh/test_processing_thread.hpp b/ssh/test/ssh/test_processing_thread.hpp
index a6d5706d..99faefcc 100644
--- a/ssh/test/ssh/test_processing_thread.hpp
+++ b/ssh/test/ssh/test_processing_thread.hpp
@@ -74,7 +74,7 @@ namespace SecureShell::Test
         Awaiter awaiter{};
         {
             ProcessingThread processingThread;
-            processingThread.start(std::chrono::milliseconds{1}, std::chrono::milliseconds{100});
+            processingThread.start(std::chrono::milliseconds{1});
             for (unsigned int i = 0; i < ProcessingThread::maximumTasksProcessableAtOnce * 3; ++i)
             {
                 EXPECT_TRUE(processingThread.pushTask([&counter, &awaiter] {
diff --git a/ssh/test/ssh/test_sftp.hpp b/ssh/test/ssh/test_sftp.hpp
index 1a487978..1c2f26ab 100644
--- a/ssh/test/ssh/test_sftp.hpp
+++ b/ssh/test/ssh/test_sftp.hpp
@@ -434,4 +434,36 @@ namespace SecureShell::Test
 
         EXPECT_EQ(tellResult.value(), 2);
     }
+
+    TEST_F(SftpTests, CanLetSftpSessionMoveOutOfScope)
+    {
+        CREATE_SERVER_AND_JOINER(Sftp);
+
+        {
+            auto [_, sftp] = createSftpSession(serverStartResult->port);
+        }
+    }
+
+    TEST_F(SftpTests, CanLetSftpSessionMoveOutOfScopeWithOpenFile)
+    {
+        CREATE_SERVER_AND_JOINER(Sftp);
+
+        {
+            auto [_, sftp] = createSftpSession(serverStartResult->port);
+            auto fut =
+                sftp->openFile("/home/test/file1.txt", SftpSession::OpenType::Read, std::filesystem::perms::owner_read);
+            ASSERT_EQ(fut.wait_for(1s), std::future_status::ready);
+            auto result = fut.get();
+            ASSERT_TRUE(result.has_value());
+        }
+    }
+
+    TEST_F(SftpTests, CannotCloseSftpSessionTwice)
+    {
+        CREATE_SERVER_AND_JOINER(Sftp);
+
+        auto [_, sftp] = createSftpSession(serverStartResult->port);
+        ASSERT_TRUE(sftp->close());
+        EXPECT_FALSE(sftp->close());
+    }
 }
diff --git a/ssh/test/ssh/test_ssh_session.hpp b/ssh/test/ssh/test_ssh_session.hpp
index 04f86e3c..6cef2699 100644
--- a/ssh/test/ssh/test_ssh_session.hpp
+++ b/ssh/test/ssh/test_ssh_session.hpp
@@ -97,6 +97,27 @@ namespace SecureShell::Test
                 processThread.join();
         }};
 
+        auto sessionScope = [this, &result]() {
+            auto expectedSession = makePasswordTestSession(result->port);
+
+            ASSERT_TRUE(expectedSession.has_value());
+            auto session = std::move(expectedSession).value();
+            session->start();
+        };
+
+        ASSERT_NO_FATAL_FAILURE(sessionScope());
+    }
+
+    TEST_F(SshSessionTests, CanConnectToSshServerCreateChannelAndDestructWithoutCrash)
+    {
+        auto [result, processThread] = createSshServer();
+        ASSERT_TRUE(result);
+        auto joiner = Nui::ScopeExit{[&]() noexcept {
+            result->command("exit");
+            if (processThread.joinable())
+                processThread.join();
+        }};
+
         auto sessionScope = [this, &result]() {
             auto expectedSession = makePasswordTestSession(result->port);
 
@@ -394,4 +415,106 @@ namespace SecureShell::Test
 
         ASSERT_NO_FATAL_FAILURE(sessionScope());
     }
+
+    TEST_F(SshSessionTests, CannotStartReadingOnClosedChannel)
+    {
+        auto [result, processThread] = createSshServer();
+        ASSERT_TRUE(result);
+        auto joiner = Nui::ScopeExit{[&]() noexcept {
+            result->command("exit");
+            if (processThread.joinable())
+                processThread.join();
+        }};
+
+        auto expectedSession = makePasswordTestSession(result->port);
+
+        ASSERT_TRUE(expectedSession.has_value());
+        auto session = std::move(expectedSession).value();
+        session->start();
+
+        auto expectedChannel = session->createPtyChannel({}).get();
+        ASSERT_TRUE(expectedChannel.has_value());
+        auto channel = expectedChannel.value().lock();
+
+        channel->close();
+
+        std::promise<void> awaiter{};
+        EXPECT_THROW(channelStartReading(channel, awaiter), std::runtime_error);
+    }
+
+    TEST_F(SshSessionTests, CannotWriteAfterChannelClose)
+    {
+        auto [result, processThread] = createSshServer();
+        ASSERT_TRUE(result);
+        auto joiner = Nui::ScopeExit{[&]() noexcept {
+            result->command("exit");
+            if (processThread.joinable())
+                processThread.join();
+        }};
+
+        auto expectedSession = makePasswordTestSession(result->port);
+
+        ASSERT_TRUE(expectedSession.has_value());
+        auto session = std::move(expectedSession).value();
+        session->start();
+
+        auto expectedChannel = session->createPtyChannel({}).get();
+        ASSERT_TRUE(expectedChannel.has_value());
+        auto channel = expectedChannel.value().lock();
+
+        channel->close();
+
+        EXPECT_EQ(channel->write("ls -lah"), false);
+    }
+
+    TEST_F(SshSessionTests, CannotResizePtyAfterChannelClose)
+    {
+        auto [result, processThread] = createSshServer();
+        ASSERT_TRUE(result);
+        auto joiner = Nui::ScopeExit{[&]() noexcept {
+            result->command("exit");
+            if (processThread.joinable())
+                processThread.join();
+        }};
+
+        auto expectedSession = makePasswordTestSession(result->port);
+
+        ASSERT_TRUE(expectedSession.has_value());
+        auto session = std::move(expectedSession).value();
+        session->start();
+
+        auto expectedChannel = session->createPtyChannel({}).get();
+        ASSERT_TRUE(expectedChannel.has_value());
+        auto channel = expectedChannel.value().lock();
+
+        channel->close();
+
+        auto resizeFut = channel->resizePty(80, 24);
+        ASSERT_EQ(resizeFut.wait_for(5s), std::future_status::ready);
+        EXPECT_EQ(resizeFut.get(), SSH_ERROR);
+    }
+
+    TEST_F(SshSessionTests, CannotCloseChannelTwice)
+    {
+        auto [result, processThread] = createSshServer();
+        ASSERT_TRUE(result);
+        auto joiner = Nui::ScopeExit{[&]() noexcept {
+            result->command("exit");
+            if (processThread.joinable())
+                processThread.join();
+        }};
+
+        auto expectedSession = makePasswordTestSession(result->port);
+
+        ASSERT_TRUE(expectedSession.has_value());
+        auto session = std::move(expectedSession).value();
+        session->start();
+
+        auto expectedChannel = session->createPtyChannel({}).get();
+        ASSERT_TRUE(expectedChannel.has_value());
+        auto channel = expectedChannel.value().lock();
+
+        channel->close();
+        EXPECT_FALSE(channel->close());
+    }
 }

From d79f027133062773aaeaa8a9cc5c346d079c7541 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sat, 8 Mar 2025 17:34:20 +0100
Subject: [PATCH 08/42] Made file explorer button border more visible.

---
 nui-file-explorer/styles/dropdown_menu.css | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nui-file-explorer/styles/dropdown_menu.css b/nui-file-explorer/styles/dropdown_menu.css
index 79f848df..2452a208 100644
--- a/nui-file-explorer/styles/dropdown_menu.css
+++ b/nui-file-explorer/styles/dropdown_menu.css
@@ -35,7 +35,7 @@
 
 .nui-file-grid-head-dropdown-button {
     transition: filter 0.3s ease;
-    border-left: 1px solid color-mix(in srgb, var(--nui-file-grid-border-color), white 20%);
+    border-left: 1px solid color-mix(in srgb, var(--nui-file-grid-border-color), white 35%);
     background-color: var(--nui-file-grid-dropdown-background);
     padding-left: 8px;
     padding-right: 8px;

From 8c6446099a9eddc95a390dba856b6b1265b235cf Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sun, 9 Mar 2025 18:08:42 +0100
Subject: [PATCH 09/42] Started implementation of download operation class.

---
 CMakeLists.txt                                |   1 +
 .../backend/sftp/download_operation.hpp       |  83 ++++
 backend/include/backend/sftp/operation.hpp    |  77 +++
 .../include/backend/sftp/operation_queue.hpp  |  16 +
 .../include/backend/ssh_session_manager.hpp   |  13 +-
 backend/source/backend/CMakeLists.txt         |  37 +-
 backend/source/backend/pty/windows/conpty.cpp |   1 +
 .../backend/sftp/download_operation.cpp       | 350 +++++++++++++
 .../source/backend/sftp/operation_queue.cpp   |   0
 .../source/backend/ssh_session_manager.cpp    |   9 +-
 backend/test/backend/CMakeLists.txt           |  41 ++
 backend/test/backend/main.cpp                 |  19 +
 .../test/backend/test_download_operation.hpp  | 464 ++++++++++++++++++
 .../session_components/operation_queue.hpp    |  27 +
 frontend/source/frontend/CMakeLists.txt       |   1 +
 frontend/source/frontend/session.cpp          |  27 +-
 .../session_components/operation_queue.cpp    |  55 +++
 ids/include/ids/ids.hpp                       |   4 +-
 log/include/log/logger_backend.hpp            |   6 +-
 .../include/shared_data/directory_entry.hpp   |  34 +-
 ssh/include/ssh/async/processing_strand.hpp   |   2 +-
 ssh/include/ssh/async/processing_thread.hpp   |   1 -
 ssh/include/ssh/file_information.hpp          |  13 +
 ssh/include/ssh/file_stream.hpp               |  38 +-
 ssh/include/ssh/file_stream_interface.hpp     | 119 +++++
 ssh/include/ssh/mocks/file_stream_mock.hpp    |  41 ++
 ssh/include/ssh/sftp_session.hpp              |  18 +-
 ssh/source/ssh/file_information.cpp           |  31 ++
 ssh/source/ssh/file_stream.cpp                |  24 +-
 ssh/source/ssh/sftp_session.cpp               |  42 +-
 ssh/test/ssh/CMakeLists.txt                   |   1 +
 ssh/test/ssh/common_fixture.hpp               |   2 +-
 ssh/test/ssh/test_processing_thread.hpp       |   2 +-
 ssh/test/ssh/test_sftp.hpp                    |  28 +-
 ssh/test/ssh/utility/node.hpp                 |   2 +-
 ssh/test/ssh/utility/temporary_directory.hpp  |  80 ---
 .../include}/utility/awaiter.hpp              |   0
 .../include/utility/temporary_directory.hpp   |  69 ++-
 .../source/utility/temporary_directory.cpp    |  75 +--
 39 files changed, 1574 insertions(+), 279 deletions(-)
 create mode 100644 backend/include/backend/sftp/download_operation.hpp
 create mode 100644 backend/include/backend/sftp/operation.hpp
 create mode 100644 backend/include/backend/sftp/operation_queue.hpp
 create mode 100644 backend/source/backend/sftp/download_operation.cpp
 create mode 100644 backend/source/backend/sftp/operation_queue.cpp
 create mode 100644 backend/test/backend/CMakeLists.txt
 create mode 100644 backend/test/backend/main.cpp
 create mode 100644 backend/test/backend/test_download_operation.hpp
 create mode 100644 frontend/include/frontend/session_components/operation_queue.hpp
 create mode 100644 frontend/source/frontend/session_components/operation_queue.cpp
 create mode 100644 ssh/include/ssh/file_information.hpp
 create mode 100644 ssh/include/ssh/file_stream_interface.hpp
 create mode 100644 ssh/include/ssh/mocks/file_stream_mock.hpp
 create mode 100644 ssh/source/ssh/file_information.cpp
 delete mode 100644 ssh/test/ssh/utility/temporary_directory.hpp
 rename {ssh/test/ssh => utility/include}/utility/awaiter.hpp (100%)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6775509b..4e7f68e4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -69,5 +69,6 @@ else()
         include(./_cmake/dependencies/gtest.cmake)
         enable_testing()
         add_subdirectory(ssh/test/ssh)
+        add_subdirectory(backend/test/backend)
     endif()
 endif()
\ No newline at end of file
diff --git a/backend/include/backend/sftp/download_operation.hpp b/backend/include/backend/sftp/download_operation.hpp
new file mode 100644
index 00000000..46e2aa21
--- /dev/null
+++ b/backend/include/backend/sftp/download_operation.hpp
@@ -0,0 +1,83 @@
+#pragma once
+
+#include <backend/sftp/operation.hpp>
+#include <ssh/file_stream.hpp>
+#include <nui/utility/move_detector.hpp>
+
+#include <filesystem>
+#include <fstream>
+#include <string>
+
+class DownloadOperation : public Operation
+{
+  public:
+    struct DownloadOperationOptions
+    {
+        std::function<void(std::int64_t min, std::int64_t max, std::int64_t current)> progressCallback =
+            [](auto, auto, auto) {};
+        std::function<void(bool success)> onCompletionCallback = [](auto) {};
+        std::filesystem::path remotePath{};
+        std::filesystem::path localPath{};
+        std::string tempFileSuffix{".filepart"};
+        bool mayOverwrite{false};
+        bool reserveSpace{false};
+        bool tryContinue{false};
+        bool inheritPermissions{false};
+        bool doCleanup{true};
+        std::optional<std::filesystem::perms> permissions{std::nullopt};
+        std::chrono::seconds futureTimeout{5};
+    };
+
+    DownloadOperation(std::weak_ptr<SecureShell::IFileStream> fileStream, DownloadOperationOptions options);
+    ~DownloadOperation() override;
+    DownloadOperation(DownloadOperation const&) = delete;
+    DownloadOperation(DownloadOperation&&) = delete;
+    DownloadOperation& operator=(DownloadOperation const&) = delete;
+    DownloadOperation& operator=(DownloadOperation&&) = delete;
+
+    std::expected<void, Error> prepare() override;
+    std::expected<void, Error> start() override;
+    void cancel() override;
+    std::expected<void, Error> pause() override;
+    std::expected<void, Error> finalize() override;
+
+  private:
+    std::expected<void, Error> openOrAdoptFile(SecureShell::IFileStream& stream);
+
+    template <typename FunctionT>
+    bool perform(FunctionT&& func)
+    {
+        auto stream = fileStream_.lock();
+        if (!stream)
+            return false;
+
+        auto* strand = stream->strand();
+        if (!strand)
+            return false;
+
+        return strand->pushTask(std::forward<FunctionT>(func));
+    }
+
+    void cleanup();
+
+  private:
+    std::recursive_mutex mutex_;
+    std::weak_ptr<SecureShell::IFileStream> fileStream_;
+    std::filesystem::path remotePath_;
+    std::filesystem::path localPath_;
+    std::string tempFileSuffix_;
+    std::function<void(std::int64_t min, std::int64_t max, std::int64_t current)> progressCallback_;
+    std::function<void(bool success)> onCompletionCallback_;
+    bool mayOverwrite_;
+    bool reserveSpace_;
+    bool tryContinue_;
+    bool inheritPermissions_;
+    bool doCleanup_;
+    bool preparationDone_;
+    std::atomic_bool interuptRead_;
+    std::optional<std::filesystem::perms> permissions_;
+    std::ofstream localFile_;
+    std::uint64_t fileSize_;
+    std::future<std::expected<std::size_t, SecureShell::SftpError>> readFuture_;
+    std::chrono::seconds futureTimeout_;
+};
\ No newline at end of file
diff --git a/backend/include/backend/sftp/operation.hpp b/backend/include/backend/sftp/operation.hpp
new file mode 100644
index 00000000..6515067f
--- /dev/null
+++ b/backend/include/backend/sftp/operation.hpp
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <ssh/sftp_error.hpp>
+#include <utility/describe.hpp>
+
+#include <ids/ids.hpp>
+
+#include <optional>
+#include <expected>
+
+BOOST_DEFINE_ENUM_CLASS(
+    OperationErrorType,
+    FileExists,
+    FileNotFound,
+    OpenFailure,
+    FileStreamExpired,
+    FileStatFailed,
+    SftpError,
+    InvalidPath,
+    RenameFailure,
+    CannotSetFilePermissions,
+    FutureTimeout,
+    OperationNotPrepared);
+
+class Operation
+{
+  public:
+    Operation()
+        : id_{Ids::generateOperationId()}
+    {}
+    Operation(Operation const&) = delete;
+    Operation& operator=(Operation const&) = delete;
+    Operation(Operation&&) = default;
+    Operation& operator=(Operation&&) = default;
+
+    using ErrorType = OperationErrorType;
+
+    struct Error
+    {
+        ErrorType type;
+        std::optional<SecureShell::SftpError> sftpError = std::nullopt;
+    };
+
+    Ids::OperationId id() const
+    {
+        return id_;
+    }
+
+    virtual ~Operation() = default;
+
+    virtual std::expected<void, Error> prepare() = 0;
+
+    /**
+     * @brief Starts the operation, can also be used to resume cancelled operations.
+     *
+     * @return std::expected<void, Error>
+     */
+    virtual std::expected<void, Error> start() = 0;
+
+    /**
+     * @brief Cancels the operation and possibly does some cleanup.
+     */
+    virtual void cancel() = 0;
+
+    /**
+     * @brief Pauses the operation.
+     */
+    virtual std::expected<void, Error> pause() = 0;
+
+    /**
+     * @brief Finalizes the operation. This should be called after the operation is done (progress == max).
+     */
+    virtual std::expected<void, Error> finalize() = 0;
+
+  private:
+    Ids::OperationId id_;
+};
\ No newline at end of file
diff --git a/backend/include/backend/sftp/operation_queue.hpp b/backend/include/backend/sftp/operation_queue.hpp
new file mode 100644
index 00000000..72aec0c2
--- /dev/null
+++ b/backend/include/backend/sftp/operation_queue.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <ids/ids.hpp>
+#include <ssh/file_stream.hpp>
+
+class FileOperationQueue
+{
+  public:
+    FileOperationQueue();
+
+    void pause();
+    void resume();
+    void cancelAll(bool clean);
+
+  private:
+};
\ No newline at end of file
diff --git a/backend/include/backend/ssh_session_manager.hpp b/backend/include/backend/ssh_session_manager.hpp
index 58a0624d..f23d51ea 100644
--- a/backend/include/backend/ssh_session_manager.hpp
+++ b/backend/include/backend/ssh_session_manager.hpp
@@ -54,12 +54,23 @@ class SshSessionManager
     void registerRpcSftpCreateDirectory(Nui::Window&, Nui::RpcHub& hub);
     void registerRpcSftpCreateFile(Nui::Window&, Nui::RpcHub& hub);
 
+    // Sftp Files:
+
   private:
     std::mutex passwordProvidersMutex_{};
     std::mutex addSessionMutex_{};
     std::unordered_map<Ids::SessionId, std::unique_ptr<SecureShell::Session>, Ids::IdHash> sessions_{};
     std::unordered_map<Ids::ChannelId, std::weak_ptr<SecureShell::Channel>, Ids::IdHash> channels_{};
-    std::unordered_map<Ids::ChannelId, std::weak_ptr<SecureShell::SftpSession>, Ids::IdHash> sftpChannels_{};
+    struct SftpSession
+    {
+        std::weak_ptr<SecureShell::SftpSession> sftp{};
+        std::unordered_map<Ids::FileId, SecureShell::FileStream, Ids::IdHash> fileStreams{};
+
+        SftpSession(std::weak_ptr<SecureShell::SftpSession> sftp)
+            : sftp{std::move(sftp)}
+        {}
+    };
+    std::unordered_map<Ids::ChannelId, SftpSession, Ids::IdHash> sftpChannels_{};
     std::map<int, PasswordProvider*> passwordProviders_{};
     std::unique_ptr<std::thread> addSessionThread_{};
     std::vector<SecureShell::PasswordCacheEntry> pwCache_{};
diff --git a/backend/source/backend/CMakeLists.txt b/backend/source/backend/CMakeLists.txt
index b81aa3f8..8cf06463 100644
--- a/backend/source/backend/CMakeLists.txt
+++ b/backend/source/backend/CMakeLists.txt
@@ -1,40 +1,47 @@
-target_sources(
-    ${PROJECT_NAME}
-    PRIVATE
+add_library(
+    backend
+    STATIC
         password/password_prompter.cpp
         process/process.cpp
         process/process_store.cpp
         process/environment.cpp
         ssh_session_manager.cpp
-        main.cpp
+        sftp/operation_queue.cpp
+        sftp/download_operation.cpp
 )
 
 if (WIN32)
     target_sources(
-        ${PROJECT_NAME}
+        backend
         PRIVATE
             pty/windows/conpty.cpp
             pty/windows/pipe.cpp
     )
 else()
     target_sources(
-        ${PROJECT_NAME}
+        backend
         PRIVATE
             pty/linux/pty.cpp
     )
 endif()
 
+target_sources(
+    ${PROJECT_NAME}
+    PRIVATE
+        main.cpp
+)
+
 find_package(Boost CONFIG 1.86.0 REQUIRED COMPONENTS system filesystem asio)
 
-target_include_directories(${PROJECT_NAME} PRIVATE "${CMAKE_SOURCE_DIR}/backend/include")
+target_include_directories(backend PUBLIC "${CMAKE_SOURCE_DIR}/backend/include")
 
-target_compile_definitions(${PROJECT_NAME} PRIVATE -DSSH_NO_CPP_EXCEPTIONS)
+target_compile_definitions(backend PUBLIC -DSSH_NO_CPP_EXCEPTIONS)
 
 include("${CMAKE_CURRENT_LIST_DIR}/../../../_cmake/dependencies/libssh.cmake")
 
 # Link backend of nui outside of emscripten
 target_link_libraries(
-    ${PROJECT_NAME}
+    backend
     PRIVATE
         nui-backend
         efsw-static
@@ -51,8 +58,16 @@ target_link_libraries(
         events
 )
 
+target_link_libraries(
+    ${PROJECT_NAME}
+    PRIVATE
+        backend
+)
+
 nui_set_target_output_directories(${PROJECT_NAME})
 
+add_dependencies(backend scp-resource-copy)
+
 # Creates a target that is compiled through emscripten. This target becomes the frontend part.
 nui_add_emscripten_target(
     TARGET
@@ -65,6 +80,4 @@ nui_add_emscripten_target(
     CMAKE_OPTIONS
         # I recommend to work with a release build by default because debug builds get big fast.
         -DCMAKE_BUILD_TYPE=Release
-)
-
-add_dependencies(${PROJECT_NAME} scp-resource-copy)
\ No newline at end of file
+)
\ No newline at end of file
diff --git a/backend/source/backend/pty/windows/conpty.cpp b/backend/source/backend/pty/windows/conpty.cpp
index 14b9efff..8c546b77 100644
--- a/backend/source/backend/pty/windows/conpty.cpp
+++ b/backend/source/backend/pty/windows/conpty.cpp
@@ -47,6 +47,7 @@ namespace ConPTY
 #pragma clang diagnostic push
 // This is winapi for you.
 #pragma clang diagnostic ignored "-Wcast-function-type-strict"
+#pragma clang diagnostic ignored "-Wcast-function-type-mismatch"
             , createPseudoConsole{reinterpret_cast<CreatePseudoConsoleFn>(
                   GetProcAddress(kernel32, "CreatePseudoConsole"))}
             , resizePseudoConsole{reinterpret_cast<ResizePseudoConsoleFn>(
diff --git a/backend/source/backend/sftp/download_operation.cpp b/backend/source/backend/sftp/download_operation.cpp
new file mode 100644
index 00000000..94e03976
--- /dev/null
+++ b/backend/source/backend/sftp/download_operation.cpp
@@ -0,0 +1,350 @@
+#include <backend/sftp/download_operation.hpp>
+
+#include <log/log.hpp>
+
+DownloadOperation::DownloadOperation(
+    std::weak_ptr<SecureShell::IFileStream> fileStream,
+    DownloadOperationOptions options)
+    : Operation{}
+    , mutex_{}
+    , fileStream_{std::move(fileStream)}
+    , remotePath_{std::move(options.remotePath)}
+    , localPath_{std::move(options.localPath)}
+    , tempFileSuffix_{std::move(options.tempFileSuffix)}
+    , progressCallback_{std::move(options.progressCallback)}
+    , onCompletionCallback_{[this, cb = std::move(options.onCompletionCallback), once = false](bool success) mutable {
+        if (!cb)
+            throw std::invalid_argument("onCompletionCallback must be set.");
+        if (once)
+            return;
+        once = true;
+        progressCallback_(0, fileSize_, fileSize_);
+        cb(success);
+    }}
+    , mayOverwrite_{options.mayOverwrite}
+    , reserveSpace_{options.reserveSpace}
+    , tryContinue_{options.tryContinue}
+    , inheritPermissions_{options.inheritPermissions}
+    , doCleanup_{options.doCleanup}
+    , preparationDone_{false}
+    , interuptRead_{false}
+    , permissions_{options.permissions}
+    , localFile_{}
+    , fileSize_{0}
+    , readFuture_{}
+    , futureTimeout_{options.futureTimeout}
+{
+    if (tempFileSuffix_.empty())
+        tempFileSuffix_ = ".filepart";
+    if (tempFileSuffix_.find('/') != 0)
+        tempFileSuffix_ = ".filepart";
+}
+
+DownloadOperation::~DownloadOperation()
+{
+    cleanup();
+
+    if (auto stream = fileStream_.lock(); stream)
+    {
+        // wait for all tasks of the operation to finish
+        stream->strand()
+            ->pushPromiseTask([]() {
+                return true;
+            })
+            .get();
+    }
+}
+
+std::expected<void, DownloadOperation::Error> DownloadOperation::openOrAdoptFile(SecureShell::IFileStream& stream)
+{
+    std::scoped_lock lock{mutex_};
+
+    const auto tempPath = localPath_.generic_string() + tempFileSuffix_;
+
+    if (tryContinue_ && std::filesystem::exists(tempPath))
+    {
+        localFile_.open(tempPath, std::ios::binary | std::ios::app);
+        if (!localFile_.is_open())
+        {
+            Log::error("DownloadOperation: Failed to open file for appending: {}", tempPath);
+            return std::unexpected(Error{.type = ErrorType::OpenFailure});
+        }
+
+        // File complete but not renamed? just rename it in the finalize() step
+        if (static_cast<std::uint64_t>(localFile_.tellp()) == fileSize_)
+        {
+            Log::info("DownloadOperation: File '{}' already complete, will be renamed in finalize() step.", tempPath);
+            localFile_.close();
+            return {};
+        }
+        // File is larger than expected? discard it and start over.
+        else if (static_cast<std::uint64_t>(localFile_.tellp()) > fileSize_)
+        {
+            Log::info("DownloadOperation: File '{}' is larger than expected, discarding and starting over.", tempPath);
+            localFile_.close();
+            // Reset the file
+            localFile_.open(tempPath, std::ios::binary | std::ios::trunc);
+        }
+        else
+        {
+            Log::info("DownloadOperation: File '{}' is incomplete, continuing download.", tempPath);
+            // Seek stream to position:
+            auto seekResult = stream.seek(localFile_.tellp()).get();
+            if (!seekResult.has_value())
+                return std::unexpected(Error{.type = ErrorType::FileStatFailed});
+        }
+    }
+    else
+    {
+        Log::info("DownloadOperation: Starting new download to '{}'.", tempPath);
+        localFile_.open(tempPath, std::ios::binary | std::ios::trunc);
+    }
+
+    if (!localFile_.is_open())
+    {
+        Log::error("DownloadOperation: Failed to open file: {}", tempPath);
+        return std::unexpected(Error{.type = ErrorType::OpenFailure});
+    }
+
+    return {};
+}
+
+std::expected<void, Operation::Error> DownloadOperation::prepare()
+{
+    std::scoped_lock lock{mutex_};
+
+    if (localPath_.empty())
+    {
+        Log::error("DownloadOperation: Invalid local path.");
+        return std::unexpected(Error{.type = ErrorType::InvalidPath});
+    }
+
+    // Initial check. Check again later before rename
+    if (std::filesystem::exists(localPath_))
+    {
+        if (!mayOverwrite_)
+        {
+            Log::error(
+                "DownloadOperation: File '{}' already exists and may not be overwritten.", localPath_.generic_string());
+            return std::unexpected(Error{.type = ErrorType::FileExists});
+        }
+    }
+
+    auto stream = fileStream_.lock();
+    if (!stream)
+    {
+        Log::error("DownloadOperation: File stream expired.");
+        return std::unexpected(Error{.type = ErrorType::FileStreamExpired});
+    }
+
+    const auto fileInfo = stream->stat().get();
+    if (!fileInfo.has_value())
+    {
+        Log::error("DownloadOperation: Failed to stat file.");
+        return std::unexpected(Error{.type = ErrorType::FileStatFailed, .sftpError = fileInfo.error()});
+    }
+
+    fileSize_ = fileInfo->size;
+
+    auto openResult = openOrAdoptFile(*stream);
+    if (!openResult.has_value())
+    {
+        Log::error("DownloadOperation: Failed to open file.");
+        return std::unexpected(std::move(openResult).error());
+    }
+
+    if (reserveSpace_ && fileSize_ != 0)
+    {
+        // Reserve space
+        Log::info("DownloadOperation: Reserving space for file.");
+        const auto pos = localFile_.tellp();
+        localFile_.seekp(fileSize_ - 1);
+        localFile_.put('\0');
+        if (localFile_.fail())
+            return std::unexpected(Error{.type = ErrorType::OpenFailure});
+        localFile_.seekp(pos);
+    }
+
+    Log::info(
+        "DownloadOperation: Prepared download of '{}' to '{}'.",
+        remotePath_.generic_string(),
+        localPath_.generic_string());
+
+    preparationDone_ = true;
+    return {};
+}
+std::expected<void, Operation::Error> DownloadOperation::start()
+{
+    std::scoped_lock lock{mutex_};
+    interuptRead_ = false;
+
+    if (!preparationDone_)
+    {
+        Log::error("DownloadOperation: Operation not prepared.");
+        return std::unexpected(Error{.type = ErrorType::OperationNotPrepared});
+    }
+
+    if (!localFile_.is_open())
+    {
+        Log::error("DownloadOperation: File is not open.");
+        return std::unexpected(Error{.type = ErrorType::OpenFailure});
+    }
+
+    if (fileSize_ == 0)
+    {
+        Log::info("DownloadOperation: Remote file is empty, nothing to do.");
+        return {};
+    }
+
+    auto stream = fileStream_.lock();
+    if (!stream)
+    {
+        Log::error("DownloadOperation: File stream expired.");
+        return std::unexpected(Error{.type = ErrorType::FileStreamExpired});
+    }
+
+    readFuture_ = stream->read([this](std::string_view data) {
+        if (data.size() == 0)
+        {
+            Log::info("DownloadOperation: Remote file read complete or error.");
+            {
+                std::scoped_lock lock{mutex_};
+                localFile_.close();
+            }
+            // Defer completion by pushing it onto the strand.
+            perform([this]() {
+                std::scoped_lock lock{mutex_};
+                onCompletionCallback_(true);
+            });
+            return false;
+        }
+
+        std::scoped_lock lock{mutex_};
+        localFile_.write(data.data(), data.size());
+        progressCallback_(0, fileSize_, localFile_.tellp());
+        const auto doContinue = localFile_.good() || interuptRead_;
+        if (!doContinue)
+        {
+            if (!localFile_.good())
+            {
+                Log::error("DownloadOperation read cycle stopped: localFile_.good() == false");
+                perform([this]() {
+                    std::scoped_lock lock{mutex_};
+                    onCompletionCallback_(false);
+                });
+            }
+        }
+        return doContinue;
+    });
+
+    return {};
+}
+void DownloadOperation::cancel()
+{
+    std::scoped_lock lock{mutex_};
+
+    Log::info(
+        "DownloadOperation: Download of '{}' to '{}' canceled.",
+        remotePath_.generic_string(),
+        localPath_.generic_string());
+
+    perform([this]() {
+        std::scoped_lock lock{mutex_};
+        onCompletionCallback_(false);
+    });
+
+    cleanup();
+}
+void DownloadOperation::cleanup()
+{
+    std::scoped_lock lock{mutex_};
+    localFile_.close();
+
+    if (doCleanup_ && std::filesystem::exists(localPath_.generic_string() + tempFileSuffix_))
+        std::filesystem::remove(localPath_.generic_string() + tempFileSuffix_);
+
+    if (auto stream = fileStream_.lock(); stream)
+        stream->close(false);
+}
+std::expected<void, DownloadOperation::Error> DownloadOperation::pause()
+{
+    std::scoped_lock lock{mutex_};
+    interuptRead_ = true;
+
+    if (readFuture_.wait_for(futureTimeout_) != std::future_status::ready)
+    {
+        Log::error("DownloadOperation: Failed to pause download.");
+        return std::unexpected(Error{.type = ErrorType::FutureTimeout});
+    }
+    return {};
+}
+std::expected<void, DownloadOperation::Error> DownloadOperation::finalize()
+{
+    std::scoped_lock lock{mutex_};
+
+    if (readFuture_.wait_for(futureTimeout_) != std::future_status::ready)
+    {
+        Log::error("DownloadOperation: Failed to wait for download completion.");
+        return std::unexpected(Error{.type = ErrorType::FutureTimeout});
+    }
+
+    localFile_.close();
+
+    if (std::filesystem::exists(localPath_) && !mayOverwrite_)
+    {
+        Log::error(
+            "DownloadOperation: File '{}' already exists and may not be overwritten.", localPath_.generic_string());
+        return std::unexpected(Error{.type = ErrorType::FileExists});
+    }
+
+    std::error_code ec{};
+    std::filesystem::rename(localPath_.generic_string() + tempFileSuffix_, localPath_, ec);
+    if (ec)
+    {
+        Log::error("DownloadOperation: Failed to rename file: {}", ec.message());
+        return std::unexpected(Error{.type = ErrorType::RenameFailure});
+    }
+
+    if (inheritPermissions_)
+    {
+        Log::info("DownloadOperation: Inheriting permissions from remote file.");
+        auto stream = fileStream_.lock();
+        if (!stream)
+        {
+            Log::error("DownloadOperation: File stream expired.");
+            return std::unexpected(Error{.type = ErrorType::FileStreamExpired});
+        }
+
+        const auto fileInfo = stream->stat().get();
+        if (!fileInfo.has_value())
+        {
+            Log::error("DownloadOperation: Failed to stat file.");
+            return std::unexpected(Error{.type = ErrorType::FileStatFailed, .sftpError = fileInfo.error()});
+        }
+
+        std::error_code permissionsError{};
+        std::filesystem::permissions(localPath_, fileInfo->permissions, permissionsError);
+        if (permissionsError)
+        {
+            Log::error("DownloadOperation: Failed to set permissions: {}", permissionsError.message());
+            return std::unexpected(Error{.type = ErrorType::CannotSetFilePermissions});
+        }
+    }
+    else if (permissions_)
+    {
+        Log::info("DownloadOperation: Setting permissions.");
+        std::error_code permissionsError{};
+        std::filesystem::permissions(localPath_, *permissions_, permissionsError);
+        if (permissionsError)
+        {
+            Log::error("DownloadOperation: Failed to set permissions: {}", permissionsError.message());
+            return std::unexpected(Error{.type = ErrorType::CannotSetFilePermissions});
+        }
+    }
+
+    Log::info(
+        "DownloadOperation: Finalized download of '{}' to '{}'.",
+        remotePath_.generic_string(),
+        localPath_.generic_string());
+    return {};
+}
\ No newline at end of file
diff --git a/backend/source/backend/sftp/operation_queue.cpp b/backend/source/backend/sftp/operation_queue.cpp
new file mode 100644
index 00000000..e69de29b
diff --git a/backend/source/backend/ssh_session_manager.cpp b/backend/source/backend/ssh_session_manager.cpp
index bc2a7d49..0777a378 100644
--- a/backend/source/backend/ssh_session_manager.cpp
+++ b/backend/source/backend/ssh_session_manager.cpp
@@ -311,8 +311,9 @@ void SshSessionManager::registerRpcChannelClose(Nui::Window&, Nui::RpcHub& hub)
                 }
                 else if (auto iter = sftpChannels_.find(channelId); iter != sftpChannels_.end())
                 {
-                    if (auto channel = iter->second.lock(); channel)
+                    if (auto channel = iter->second.sftp.lock(); channel)
                     {
+                        iter->second.fileStreams.clear();
                         channel->close();
                     }
                     sftpChannels_.erase(iter);
@@ -487,7 +488,7 @@ void SshSessionManager::registerRpcSftpListDirectory(Nui::Window&, Nui::RpcHub&
                     return;
                 }
 
-                auto locked = channel->second.lock();
+                auto locked = channel->second.sftp.lock();
                 if (!locked)
                 {
                     Log::error("Failed to lock sftp channel with id: {}", channelId.value());
@@ -551,7 +552,7 @@ void SshSessionManager::registerRpcSftpCreateDirectory(Nui::Window&, Nui::RpcHub
                     return;
                 }
 
-                auto locked = channel->second.lock();
+                auto locked = channel->second.sftp.lock();
                 if (!locked)
                 {
                     Log::error("Failed to lock sftp channel with id: {}", channelId.value());
@@ -615,7 +616,7 @@ void SshSessionManager::registerRpcSftpCreateFile(Nui::Window&, Nui::RpcHub& hub
                     return;
                 }
 
-                auto locked = channel->second.lock();
+                auto locked = channel->second.sftp.lock();
                 if (!locked)
                 {
                     Log::error("Failed to lock sftp channel with id: {}", channelId.value());
diff --git a/backend/test/backend/CMakeLists.txt b/backend/test/backend/CMakeLists.txt
new file mode 100644
index 00000000..d320906a
--- /dev/null
+++ b/backend/test/backend/CMakeLists.txt
@@ -0,0 +1,41 @@
+include(GoogleTest)
+
+add_executable(
+    nui-scp-backend-test
+    main.cpp
+)
+
+find_package(GTest CONFIG REQUIRED)
+
+find_package(Boost CONFIG REQUIRED COMPONENTS filesystem asio system process)
+
+target_link_libraries(
+    nui-scp-backend-test
+    PUBLIC
+        secure-shell
+        backend
+        GTest::GTest
+        GTest::gmock_main
+        GTest::Main
+        Boost::filesystem
+        Boost::asio
+        Boost::system
+        Boost::process
+)
+
+if (WIN32)
+    target_link_libraries(nui-scp-backend-test PUBLIC ws2_32)
+endif()
+
+set_target_properties(nui-scp-backend-test PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/test")
+
+gtest_discover_tests(nui-scp-backend-test)
+
+# If msys2, copy dynamic libraries to executable directory, visual studio does this automatically.
+# And there is no need on linux.
+if (DEFINED ENV{MSYSTEM})
+    add_custom_command(TARGET nui-scp-backend-test POST_BUILD
+        COMMAND bash -c "ldd $<TARGET_FILE:nui-scp-backend-test>" | "grep" "clang" | awk "NF == 4 { system(\"${CMAKE_COMMAND} -E copy \" \$3 \" $<TARGET_FILE_DIR:nui-scp-backend-test>\") }"
+        VERBATIM
+    )
+endif()
\ No newline at end of file
diff --git a/backend/test/backend/main.cpp b/backend/test/backend/main.cpp
new file mode 100644
index 00000000..cfe644c1
--- /dev/null
+++ b/backend/test/backend/main.cpp
@@ -0,0 +1,19 @@
+#include "test_download_operation.hpp"
+
+#include <log/log.hpp>
+
+#include <gtest/gtest.h>
+
+#include <filesystem>
+
+std::filesystem::path programDirectory;
+
+int main(int argc, char** argv)
+{
+    Log::setLevel(Log::Level::Off);
+
+    programDirectory = std::filesystem::path{argv[0]}.parent_path();
+
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
\ No newline at end of file
diff --git a/backend/test/backend/test_download_operation.hpp b/backend/test/backend/test_download_operation.hpp
new file mode 100644
index 00000000..66fc1523
--- /dev/null
+++ b/backend/test/backend/test_download_operation.hpp
@@ -0,0 +1,464 @@
+#pragma once
+
+#include <backend/sftp/download_operation.hpp>
+#include <ssh/mocks/file_stream_mock.hpp>
+#include <utility/temporary_directory.hpp>
+
+#include <utility/awaiter.hpp>
+
+#include <gtest/gtest.h>
+
+using namespace std::chrono_literals;
+using namespace std::string_literals;
+
+extern std::filesystem::path programDirectory;
+
+namespace Test
+{
+    class DownloadOperationTests : public ::testing::Test
+    {
+      protected:
+        void SetUp() override
+        {
+            processingThread_.start(5ms);
+        }
+
+        void TearDown() override
+        {
+            processingThread_.stop();
+        }
+
+        std::shared_ptr<::testing::NiceMock<SecureShell::Test::FileStreamMock>> makeFileStreamMock()
+        {
+            auto mock = std::make_shared<::testing::NiceMock<SecureShell::Test::FileStreamMock>>();
+
+            ON_CALL(*mock, strand()).WillByDefault([this]() -> SecureShell::ProcessingStrand* {
+                return strand_.get();
+            });
+
+            return mock;
+        }
+
+        void giveMockDefaultStat(
+            std::shared_ptr<::testing::NiceMock<SecureShell::Test::FileStreamMock>> const& mock,
+            std::optional<std::size_t> size = std::nullopt)
+        {
+            if (!size)
+                size = fakeFileContent_.size();
+
+            ON_CALL(*mock, stat())
+                .WillByDefault(
+                    [size = size.value()]()
+                        -> std::future<std::expected<SecureShell::FileInformation, SecureShell::SftpError>> {
+                        std::promise<std::expected<SecureShell::FileInformation, SecureShell::SftpError>> promise;
+                        promise.set_value(SecureShell::FileInformation{{
+                            .size = size,
+                            .permissions = std::filesystem::perms::owner_all,
+                        }});
+                        return promise.get_future();
+                    });
+        }
+
+        void giveMockExpectedRead(std::shared_ptr<::testing::NiceMock<SecureShell::Test::FileStreamMock>> const& mock)
+        {
+            EXPECT_CALL(*mock, read(testing::_))
+                .WillRepeatedly(
+                    [this](std::function<bool(std::string_view data)> cb)
+                        -> std::future<std::expected<std::size_t, SecureShell::SftpError>> {
+                        onRead_ = std::move(cb);
+                        readPromise_ = {};
+                        return readPromise_.get_future();
+                    });
+        }
+
+        void fakeReadCycle(std::optional<std::size_t> chunkSizeOpt)
+        {
+            auto chunkSize = fakeFileContent_.size();
+            if (chunkSizeOpt)
+                chunkSize = chunkSizeOpt.value();
+
+            if (readOffset_ + chunkSize > fakeFileContent_.size())
+                chunkSize = fakeFileContent_.size() - readOffset_;
+
+            // EOF:
+            if (chunkSize == 0)
+            {
+                readPromise_.set_value(readOffset_);
+                onRead_({});
+                return;
+            }
+
+            if (onRead_)
+            {
+                onRead_(std::string_view{fakeFileContent_}.substr(readOffset_, chunkSize));
+                readOffset_ += chunkSize;
+            }
+            else
+            {
+                throw std::runtime_error("No read callback set.");
+            }
+        }
+
+      protected:
+        std::string fakeFileContent_{"Hello, World!"};
+        Utility::TemporaryDirectory isolateDirectory_{programDirectory / "temp", true};
+        SecureShell::ProcessingThread processingThread_{};
+        std::unique_ptr<SecureShell::ProcessingStrand> strand_{processingThread_.createStrand()};
+        std::promise<std::expected<std::size_t, SecureShell::SftpError>> readPromise_{};
+        std::function<bool(std::string_view data)> onRead_{};
+        std::size_t readOffset_{0};
+    };
+
+    TEST_F(DownloadOperationTests, CanCreateDownloadOperation)
+    {
+        auto fileStream = makeFileStreamMock();
+        auto options = DownloadOperation::DownloadOperationOptions{};
+        DownloadOperation operation{fileStream, options};
+    }
+
+    TEST_F(DownloadOperationTests, DownloadPreparationFailsWithLocalPathEmpty)
+    {
+        auto fileStream = makeFileStreamMock();
+        auto options = DownloadOperation::DownloadOperationOptions{};
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_FALSE(result.has_value());
+        EXPECT_EQ(result.error().type, DownloadOperation::ErrorType::InvalidPath);
+    }
+
+    TEST_F(DownloadOperationTests, DownloadPreparationFailsWhenFileExistsAndMayNotBeOverwritten)
+    {
+        auto fileStream = makeFileStreamMock();
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .mayOverwrite = false,
+        };
+        std::ofstream file{options.localPath};
+        file.close();
+
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_FALSE(result.has_value());
+        EXPECT_EQ(result.error().type, DownloadOperation::ErrorType::FileExists);
+    }
+
+    TEST_F(DownloadOperationTests, DownloadPreparationFailsWhenStreamIsExpired)
+    {
+        std::weak_ptr<SecureShell::IFileStream> fileWeak;
+        {
+            auto fileStream = makeFileStreamMock();
+            fileWeak = fileStream;
+        }
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+        };
+        DownloadOperation operation{fileWeak, options};
+
+        auto result = operation.prepare();
+        EXPECT_FALSE(result.has_value());
+        EXPECT_EQ(result.error().type, DownloadOperation::ErrorType::FileStreamExpired);
+    }
+
+    TEST_F(DownloadOperationTests, DownloadPreparationFailsWhenStattingTheFileFails)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+
+        EXPECT_CALL(*fileStream, stat()).WillOnce([]() -> std::future<std::expected<FileInformation, SftpError>> {
+            std::promise<std::expected<FileInformation, SftpError>> promise;
+            promise.set_value(std::unexpected(SftpError{
+                .message = "Stat failed",
+            }));
+            return promise.get_future();
+        });
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_FALSE(result.has_value());
+        EXPECT_EQ(result.error().type, DownloadOperation::ErrorType::FileStatFailed);
+    }
+
+    // TODO: Test continuation download
+
+    TEST_F(DownloadOperationTests, DownloadPreparationSucceedsWithEmptyRemoteFile)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+
+        EXPECT_CALL(*fileStream, stat())
+            .WillOnce([]() -> std::future<std::expected<FileInformation, SecureShell::SftpError>> {
+                std::promise<std::expected<FileInformation, SecureShell::SftpError>> promise;
+                promise.set_value(FileInformation{{
+                    .size = 0,
+                }});
+                return promise.get_future();
+            });
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+    }
+
+    TEST_F(DownloadOperationTests, DownloadPreparationSucceedsWithNonEmptyRemoteFile)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+
+        EXPECT_CALL(*fileStream, stat())
+            .WillOnce([]() -> std::future<std::expected<FileInformation, SecureShell::SftpError>> {
+                std::promise<std::expected<FileInformation, SecureShell::SftpError>> promise;
+                promise.set_value(FileInformation{{
+                    .size = 42,
+                }});
+                return promise.get_future();
+            });
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+    }
+
+    TEST_F(DownloadOperationTests, DownloadPreparationCreatesPartFile)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+
+        EXPECT_CALL(*fileStream, stat())
+            .WillOnce([]() -> std::future<std::expected<FileInformation, SecureShell::SftpError>> {
+                std::promise<std::expected<FileInformation, SecureShell::SftpError>> promise;
+                promise.set_value(FileInformation{{
+                    .size = 42,
+                }});
+                return promise.get_future();
+            });
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+        EXPECT_TRUE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
+    }
+
+    TEST_F(DownloadOperationTests, DestructorCleansUpIfOptionIsTrue)
+    {
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .doCleanup = true,
+        };
+
+        {
+            using namespace SecureShell;
+
+            auto fileStream = makeFileStreamMock();
+
+            EXPECT_CALL(*fileStream, stat())
+                .WillOnce([]() -> std::future<std::expected<FileInformation, SecureShell::SftpError>> {
+                    std::promise<std::expected<FileInformation, SecureShell::SftpError>> promise;
+                    promise.set_value(FileInformation{{
+                        .size = 42,
+                    }});
+                    return promise.get_future();
+                });
+
+            DownloadOperation operation{fileStream, options};
+
+            auto result = operation.prepare();
+            EXPECT_TRUE(result.has_value());
+            EXPECT_TRUE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
+        }
+
+        EXPECT_FALSE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
+    }
+
+    TEST_F(DownloadOperationTests, DestructorDoesNotCleanUpIfOptionIsFalse)
+    {
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .doCleanup = false,
+        };
+
+        {
+            using namespace SecureShell;
+
+            auto fileStream = makeFileStreamMock();
+
+            EXPECT_CALL(*fileStream, stat())
+                .WillOnce([]() -> std::future<std::expected<FileInformation, SecureShell::SftpError>> {
+                    std::promise<std::expected<FileInformation, SecureShell::SftpError>> promise;
+                    promise.set_value(FileInformation{{
+                        .size = 42,
+                    }});
+                    return promise.get_future();
+                });
+
+            DownloadOperation operation{fileStream, options};
+
+            auto result = operation.prepare();
+            EXPECT_TRUE(result.has_value());
+            EXPECT_TRUE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
+        }
+
+        EXPECT_TRUE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
+    }
+
+    TEST_F(DownloadOperationTests, CancelDoesNotRemoveTheFileIfCleanIsFalse)
+    {
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .doCleanup = false,
+        };
+
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream);
+
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+        EXPECT_TRUE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
+
+        operation.cancel();
+
+        EXPECT_TRUE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
+    }
+
+    TEST_F(DownloadOperationTests, CancelDoesRemoveTheFileIfCleanIsTrue)
+    {
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .doCleanup = true,
+        };
+
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+
+        EXPECT_CALL(*fileStream, stat())
+            .WillOnce([]() -> std::future<std::expected<FileInformation, SecureShell::SftpError>> {
+                std::promise<std::expected<FileInformation, SecureShell::SftpError>> promise;
+                promise.set_value(FileInformation{{
+                    .size = 42,
+                }});
+                return promise.get_future();
+            });
+
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+        EXPECT_TRUE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
+
+        operation.cancel();
+
+        EXPECT_FALSE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
+    }
+
+    TEST_F(DownloadOperationTests, CancelCallsTheCompletionHandler)
+    {
+        using namespace SecureShell;
+
+        std::promise<bool> completionPromise;
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .onCompletionCallback =
+                [&completionPromise](bool success) {
+                    completionPromise.set_value(success);
+                },
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .doCleanup = true,
+        };
+
+        const auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream);
+
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+        operation.cancel();
+
+        auto future = completionPromise.get_future();
+        ASSERT_EQ(future.wait_for(1s), std::future_status::ready);
+        // Cancel is a failure
+        EXPECT_FALSE(future.get());
+    }
+
+    TEST_F(DownloadOperationTests, StartWithEmptyRemoteFileSucceeds)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream, 0);
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+
+        result = operation.start();
+        EXPECT_TRUE(result.has_value());
+    }
+
+    TEST_F(DownloadOperationTests, StartWithoutPrepareFails)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.start();
+        EXPECT_FALSE(result.has_value());
+        EXPECT_EQ(result.error().type, DownloadOperation::ErrorType::OperationNotPrepared);
+    }
+
+    TEST_F(DownloadOperationTests, StartFailsWithExpiredFileStream)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream);
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value()) << boost::describe::enum_to_string(result.error().type, "INVALID_ENUM_VALUE");
+
+        fileStream.reset();
+
+        result = operation.start();
+        EXPECT_FALSE(result.has_value());
+        EXPECT_EQ(result.error().type, DownloadOperation::ErrorType::FileStreamExpired);
+    }
+}
\ No newline at end of file
diff --git a/frontend/include/frontend/session_components/operation_queue.hpp b/frontend/include/frontend/session_components/operation_queue.hpp
new file mode 100644
index 00000000..baa791f8
--- /dev/null
+++ b/frontend/include/frontend/session_components/operation_queue.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <persistence/state_holder.hpp>
+#include <frontend/dialog/confirm_dialog.hpp>
+#include <frontend/events/frontend_events.hpp>
+
+#include <nui/frontend/element_renderer.hpp>
+#include <roar/detail/pimpl_special_functions.hpp>
+
+class OperationQueue
+{
+  public:
+    OperationQueue(
+        Persistence::StateHolder* stateHolder,
+        FrontendEvents* events,
+        std::string persistenceSessionName,
+        std::string id,
+        ConfirmDialog* confirmDialog);
+
+    ROAR_PIMPL_SPECIAL_FUNCTIONS(OperationQueue);
+
+    Nui::ElementRenderer operator()();
+
+  private:
+    struct Implementation;
+    std::unique_ptr<Implementation> impl_;
+};
\ No newline at end of file
diff --git a/frontend/source/frontend/CMakeLists.txt b/frontend/source/frontend/CMakeLists.txt
index 1c58adbd..d2c6a3d6 100644
--- a/frontend/source/frontend/CMakeLists.txt
+++ b/frontend/source/frontend/CMakeLists.txt
@@ -13,6 +13,7 @@ target_sources(
         dialog/password_prompter.cpp
         dialog/confirm_dialog.cpp
         session_components/session_options.cpp
+        session_components/operation_queue.cpp
         terminal/terminal.cpp
         terminal/executing_engine.cpp
         terminal/sftp_file_engine.cpp
diff --git a/frontend/source/frontend/session.cpp b/frontend/source/frontend/session.cpp
index c5908221..dd94bd2f 100644
--- a/frontend/source/frontend/session.cpp
+++ b/frontend/source/frontend/session.cpp
@@ -8,6 +8,7 @@
 #include <frontend/classes.hpp>
 #include <frontend/dialog/input_dialog.hpp>
 #include <frontend/session_components/session_options.hpp>
+#include <frontend/session_components/operation_queue.hpp>
 #include <nui-file-explorer/file_grid.hpp>
 #include <persistence/state_holder.hpp>
 #include <constants/layouts.hpp>
@@ -53,7 +54,8 @@ struct Session::Implementation
     ConfirmDialog* confirmDialog;
 
     // Operation Queue for File Explorer
-    std::shared_ptr<Nui::Dom::Element> operationQueue;
+    OperationQueue operationQueue;
+    std::shared_ptr<Nui::Dom::Element> operationQueueElement;
 
     // File Explorer Things:
     NuiFileExplorer::FileGrid fileGrid;
@@ -101,6 +103,8 @@ struct Session::Implementation
         , options{this->engine.terminalOptions.value()}
         , newItemAskDialog{newItemAskDialog}
         , confirmDialog{confirmDialog}
+        , operationQueue{this->stateHolder, this->events, this->initialName, this->id, this->confirmDialog}
+        , operationQueueElement{}
         , fileGrid{{
               .pathBarOnTop = uiOptions.fileGridPathBarOnTop,
           }}
@@ -602,16 +606,7 @@ void Session::visible(bool value)
 
 auto Session::makeOperationQueueElement() -> Nui::ElementRenderer
 {
-    using Nui::Elements::div; // because of the global div.
-    using namespace Nui::Attributes;
-
-    // clang-format off
-    return div{
-        style = "width: 100%; height: auto; display: block",
-    }(
-        "OPERATION QUEUE HERE"
-    );
-    // clang-format on
+    return impl_->operationQueue();
 }
 
 void Session::onChannelClosedByUser(Ids::ChannelId const& channelId)
@@ -733,21 +728,21 @@ void Session::initializeLayout()
                 return Nui::val::undefined();
             }),
             Nui::bind([this]() -> Nui::val {
-                if (impl_->operationQueue)
+                if (impl_->operationQueueElement)
                 {
                     Log::warn("There is already an operation queue, cannot open another one");
                     return Nui::val::undefined();
                 }
-                impl_->operationQueue = Nui::Dom::makeStandaloneElement(makeOperationQueueElement());
-                return impl_->operationQueue->val();
+                impl_->operationQueueElement = Nui::Dom::makeStandaloneElement(makeOperationQueueElement());
+                return impl_->operationQueueElement->val();
             }),
             Nui::bind([this]() -> Nui::val {
-                if (!impl_->operationQueue)
+                if (!impl_->operationQueueElement)
                 {
                     Log::warn("There is no operation queue to remove");
                     return Nui::val::undefined();
                 }
-                impl_->operationQueue.reset();
+                impl_->operationQueueElement.reset();
                 return Nui::val::undefined();
             }),
             Nui::bind([this]() -> Nui::val {
diff --git a/frontend/source/frontend/session_components/operation_queue.cpp b/frontend/source/frontend/session_components/operation_queue.cpp
new file mode 100644
index 00000000..88943447
--- /dev/null
+++ b/frontend/source/frontend/session_components/operation_queue.cpp
@@ -0,0 +1,55 @@
+#include <frontend/session_components/operation_queue.hpp>
+
+#include <nui/frontend/attributes.hpp>
+#include <nui/frontend/elements.hpp>
+#include <fmt/format.h>
+
+struct OperationQueue::Implementation
+{
+    Persistence::StateHolder* stateHolder;
+    FrontendEvents* events;
+    std::string persistenceSessionName;
+    std::string id;
+    ConfirmDialog* confirmDialog;
+
+    Implementation(
+        Persistence::StateHolder* stateHolder,
+        FrontendEvents* events,
+        std::string persistenceSessionName,
+        std::string id,
+        ConfirmDialog* confirmDialog)
+        : stateHolder{stateHolder}
+        , events{events}
+        , persistenceSessionName{std::move(persistenceSessionName)}
+        , id{std::move(id)}
+        , confirmDialog{confirmDialog}
+    {}
+};
+
+OperationQueue::OperationQueue(
+    Persistence::StateHolder* stateHolder,
+    FrontendEvents* events,
+    std::string persistenceSessionName,
+    std::string id,
+    ConfirmDialog* confirmDialog)
+    : impl_{
+          std::make_unique<Implementation>(
+              stateHolder,
+              events,
+              std::move(persistenceSessionName),
+              std::move(id),
+              confirmDialog),
+      }
+{}
+ROAR_PIMPL_SPECIAL_FUNCTIONS_IMPL(OperationQueue);
+
+Nui::ElementRenderer OperationQueue::operator()()
+{
+    using namespace Nui::Elements;
+    using namespace Nui::Attributes;
+    using Nui::Elements::div;
+
+    return div{
+        style = "width: 100%; height: auto; display: block",
+    }("OPERATION QUEUE HERE NEW");
+}
\ No newline at end of file
diff --git a/ids/include/ids/ids.hpp b/ids/include/ids/ids.hpp
index 61866ed7..7b1e18ee 100644
--- a/ids/include/ids/ids.hpp
+++ b/ids/include/ids/ids.hpp
@@ -5,4 +5,6 @@
 DEFINE_ID_TYPE(SessionId)
 DEFINE_ID_TYPE(SessionFrontendId)
 DEFINE_ID_TYPE(ChannelId)
-DEFINE_ID_TYPE(UiSessionId)
\ No newline at end of file
+DEFINE_ID_TYPE(UiSessionId)
+DEFINE_ID_TYPE(FileId)
+DEFINE_ID_TYPE(OperationId)
\ No newline at end of file
diff --git a/log/include/log/logger_backend.hpp b/log/include/log/logger_backend.hpp
index 0ef0595f..02c1fe90 100644
--- a/log/include/log/logger_backend.hpp
+++ b/log/include/log/logger_backend.hpp
@@ -91,7 +91,11 @@ namespace Log
             else
             {
                 std::scoped_lock lock{guard_};
-                stash_.emplace_back(level, msg);
+                // Do not accumulate logs in tests:
+                if (level != Level::Off)
+                {
+                    stash_.emplace_back(level, msg);
+                }
             }
 
             spdlog::log(toSpdlogLevel(level), msg);
diff --git a/shared_data/include/shared_data/directory_entry.hpp b/shared_data/include/shared_data/directory_entry.hpp
index da7a76f6..63d68bac 100644
--- a/shared_data/include/shared_data/directory_entry.hpp
+++ b/shared_data/include/shared_data/directory_entry.hpp
@@ -9,9 +9,9 @@ namespace SharedData
 {
     struct DirectoryEntry
     {
-        std::filesystem::path path;
-        std::filesystem::path longName;
-        std::uint32_t flags;
+        std::filesystem::path path = "";
+        std::filesystem::path longName = "";
+        std::uint32_t flags = 0;
         /*
             SSH_FILEXFER_TYPE_REGULAR          1
             SSH_FILEXFER_TYPE_DIRECTORY        2
@@ -23,20 +23,20 @@ namespace SharedData
             SSH_FILEXFER_TYPE_BLOCK_DEVICE     8
             SSH_FILEXFER_TYPE_FIFO             9
          */
-        std::uint8_t type;
-        std::uint64_t size;
-        std::uint32_t uid;
-        std::uint32_t gid;
-        std::string owner;
-        std::string group;
-        std::filesystem::perms permissions;
-        std::uint64_t atime;
-        std::uint32_t atimeNsec;
-        std::uint64_t createTime;
-        std::uint32_t createTimeNsec;
-        std::uint64_t mtime;
-        std::uint32_t mtimeNsec;
-        std::string acl;
+        std::uint8_t type = 0;
+        std::uint64_t size = 0;
+        std::uint32_t uid = 0;
+        std::uint32_t gid = 0;
+        std::string owner = "";
+        std::string group = "";
+        std::filesystem::perms permissions = std::filesystem::perms::unknown;
+        std::uint64_t atime = 0;
+        std::uint32_t atimeNsec = 0;
+        std::uint64_t createTime = 0;
+        std::uint32_t createTimeNsec = 0;
+        std::uint64_t mtime = 0;
+        std::uint32_t mtimeNsec = 0;
+        std::string acl = "";
     };
 
     void to_json(nlohmann::json& j, DirectoryEntry const& entry);
diff --git a/ssh/include/ssh/async/processing_strand.hpp b/ssh/include/ssh/async/processing_strand.hpp
index bb2e38c1..7a74ff6a 100644
--- a/ssh/include/ssh/async/processing_strand.hpp
+++ b/ssh/include/ssh/async/processing_strand.hpp
@@ -2,10 +2,10 @@
 
 #include <ssh/async/processing_thread.hpp>
 
-#include <set>
 #include <future>
 #include <functional>
 #include <mutex>
+#include <set>
 
 namespace SecureShell
 {
diff --git a/ssh/include/ssh/async/processing_thread.hpp b/ssh/include/ssh/async/processing_thread.hpp
index 1dd3b60f..1f6ec767 100644
--- a/ssh/include/ssh/async/processing_thread.hpp
+++ b/ssh/include/ssh/async/processing_thread.hpp
@@ -5,7 +5,6 @@
 #include <deque>
 #include <mutex>
 #include <functional>
-#include <condition_variable>
 #include <map>
 #include <future>
 #include <memory>
diff --git a/ssh/include/ssh/file_information.hpp b/ssh/include/ssh/file_information.hpp
new file mode 100644
index 00000000..600bc9c6
--- /dev/null
+++ b/ssh/include/ssh/file_information.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <shared_data/directory_entry.hpp>
+
+#include <libssh/sftp.h>
+
+namespace SecureShell
+{
+    struct FileInformation : public SharedData::DirectoryEntry
+    {
+        static FileInformation fromSftpAttributes(sftp_attributes attributes);
+    };
+}
\ No newline at end of file
diff --git a/ssh/include/ssh/file_stream.hpp b/ssh/include/ssh/file_stream.hpp
index deb89aaa..dd70aef7 100644
--- a/ssh/include/ssh/file_stream.hpp
+++ b/ssh/include/ssh/file_stream.hpp
@@ -1,6 +1,8 @@
 #pragma once
 
+#include <ssh/file_stream_interface.hpp>
 #include <ssh/sftp_error.hpp>
+#include <ssh/file_information.hpp>
 
 #include <libssh/sftp.h>
 
@@ -14,11 +16,13 @@ namespace SecureShell
     class Session;
     class SftpSession;
 
-    class FileStream : public std::enable_shared_from_this<FileStream>
+    class FileStream
+        : public IFileStream
+        , public std::enable_shared_from_this<FileStream>
     {
       public:
         FileStream(std::shared_ptr<SftpSession> sftp, sftp_file file, sftp_limits_struct limits);
-        ~FileStream();
+        ~FileStream() override;
         FileStream(FileStream const&) = delete;
         FileStream& operator=(FileStream const&) = delete;
         FileStream(FileStream&&);
@@ -29,19 +33,26 @@ namespace SecureShell
          *
          * @param pos Where to move the file pointer to.
          */
-        std::future<std::expected<void, SftpError>> seek(std::size_t pos);
+        std::future<std::expected<void, SftpError>> seek(std::size_t pos) override;
 
         /**
          * @brief Tells the current position in the file.
          *
          * @return std::future<std::expected<std::size_t, SftpError>> The current position or an error.
          */
-        std::future<std::expected<std::size_t, SftpError>> tell();
+        std::future<std::expected<std::size_t, SftpError>> tell() override;
+
+        /**
+         * @brief Retrieves information about the file.
+         *
+         * @return std::future<std::expected<FileInformation, SftpError>>
+         */
+        std::future<std::expected<FileInformation, SftpError>> stat() override;
 
         /**
          * @brief Rewind the file to the beginning.
          */
-        std::future<std::expected<void, SftpError>> rewind();
+        std::future<std::expected<void, SftpError>> rewind() override;
 
         /**
          * @brief Reads some bytes from the file. Not necessarily fills the buffer. bufferSize MUST be less than or
@@ -51,7 +62,7 @@ namespace SecureShell
          * @param bufferSize
          * @return std::future<std::expected<std::size_t, SftpError>>
          */
-        std::future<std::expected<std::size_t, SftpError>> read(std::byte* buffer, std::size_t bufferSize);
+        std::future<std::expected<std::size_t, SftpError>> read(std::byte* buffer, std::size_t bufferSize) override;
 
         /**
          * @brief Reads all bytes from the file.
@@ -59,7 +70,8 @@ namespace SecureShell
          * @param onRead Let this function return false to stop reading.
          * @return std::future<std::expected<std::size_t, SftpError>> The number of bytes read or an error.
          */
-        std::future<std::expected<std::size_t, SftpError>> read(std::function<bool(std::string_view data)> onRead);
+        std::future<std::expected<std::size_t, SftpError>>
+        read(std::function<bool(std::string_view data)> onRead) override;
 
         /**
          * @brief Writes some bytes to the file.
@@ -70,7 +82,7 @@ namespace SecureShell
          * @param bufferSize
          * @return std::future<std::expected<void, SftpError>>
          */
-        std::future<std::expected<void, SftpError>> write(std::string_view data);
+        std::future<std::expected<void, SftpError>> write(std::string_view data) override;
 
         /**
          * @brief Returns the maximum number of bytes that can be written in a single pure write operation.
@@ -78,14 +90,14 @@ namespace SecureShell
          *
          * @return std::size_t
          */
-        std::size_t writeLengthLimit() const;
+        std::size_t writeLengthLimit() const override;
 
         /**
          * @brief Returns the maximum number of bytes that can be read in a single pure read operation.
          *
          * @return std::size_t
          */
-        std::size_t readLengthLimit() const;
+        std::size_t readLengthLimit() const override;
 
         /**
          * @brief Brings this class into an invalid state and returns the sftp_file. The ownership of the file is
@@ -93,12 +105,14 @@ namespace SecureShell
          *
          * @return sftp_file
          */
-        sftp_file release();
+        sftp_file release() override;
 
         /**
          * @brief Closes the file and removes itself from the sftp session.
          */
-        void close(bool isBackElement = false);
+        void close(bool isBackElement = false) override;
+
+        ProcessingStrand* strand() const override;
 
       private:
         std::function<void(sftp_file)> makeFileDeleter();
diff --git a/ssh/include/ssh/file_stream_interface.hpp b/ssh/include/ssh/file_stream_interface.hpp
new file mode 100644
index 00000000..4b47df28
--- /dev/null
+++ b/ssh/include/ssh/file_stream_interface.hpp
@@ -0,0 +1,119 @@
+#pragma once
+
+#include <ssh/async/processing_strand.hpp>
+#include <ssh/sftp_error.hpp>
+#include <ssh/file_information.hpp>
+
+#include <libssh/sftp.h>
+
+#include <functional>
+#include <future>
+#include <expected>
+
+namespace SecureShell
+{
+    class Session;
+    class SftpSession;
+
+    class IFileStream
+    {
+      public:
+        IFileStream() = default;
+        virtual ~IFileStream() = default;
+        IFileStream(IFileStream const&) = default;
+        IFileStream& operator=(IFileStream const&) = default;
+        IFileStream(IFileStream&&) = default;
+        IFileStream& operator=(IFileStream&&) = default;
+
+        /**
+         * @brief Moves the file pointer to the specified position.
+         *
+         * @param pos Where to move the file pointer to.
+         */
+        virtual std::future<std::expected<void, SftpError>> seek(std::size_t pos) = 0;
+
+        /**
+         * @brief Tells the current position in the file.
+         *
+         * @return std::future<std::expected<std::size_t, SftpError>> The current position or an error.
+         */
+        virtual std::future<std::expected<std::size_t, SftpError>> tell() = 0;
+
+        /**
+         * @brief Retrieves information about the file.
+         *
+         * @return std::future<std::expected<FileInformation, SftpError>>
+         */
+        virtual std::future<std::expected<FileInformation, SftpError>> stat() = 0;
+
+        /**
+         * @brief Rewind the file to the beginning.
+         */
+        virtual std::future<std::expected<void, SftpError>> rewind() = 0;
+
+        /**
+         * @brief Reads some bytes from the file. Not necessarily fills the buffer. bufferSize MUST be less than or
+         * equal to the read limit.
+         *
+         * @param buffer
+         * @param bufferSize
+         * @return std::future<std::expected<std::size_t, SftpError>>
+         */
+        virtual std::future<std::expected<std::size_t, SftpError>> read(std::byte* buffer, std::size_t bufferSize) = 0;
+
+        /**
+         * @brief Reads all bytes from the file.
+         *
+         * @param onRead Let this function return false to stop reading.
+         * @return std::future<std::expected<std::size_t, SftpError>> The number of bytes read or an error.
+         */
+        virtual std::future<std::expected<std::size_t, SftpError>>
+        read(std::function<bool(std::string_view data)> onRead) = 0;
+
+        /**
+         * @brief Writes some bytes to the file.
+         * Makes sure that all data is written even if the data is larger than the write limit by breaking it into
+         * smaller parts.
+         *
+         * @param buffer
+         * @param bufferSize
+         * @return std::future<std::expected<void, SftpError>>
+         */
+        virtual std::future<std::expected<void, SftpError>> write(std::string_view data) = 0;
+
+        /**
+         * @brief Returns the maximum number of bytes that can be written in a single pure write operation.
+         * This limit is not necessary to uphold for the write function of this class.
+         *
+         * @return std::size_t
+         */
+        virtual std::size_t writeLengthLimit() const = 0;
+
+        /**
+         * @brief Returns the maximum number of bytes that can be read in a single pure read operation.
+         *
+         * @return std::size_t
+         */
+        virtual std::size_t readLengthLimit() const = 0;
+
+        /**
+         * @brief Brings this class into an invalid state and returns the sftp_file. The ownership of the file is
+         * transferred to the caller.
+         *
+         * @return sftp_file
+         */
+        virtual sftp_file release() = 0;
+
+        /**
+         * @brief Closes the file and removes itself from the sftp session.
+         */
+        virtual void close(bool isBackElement = false) = 0;
+
+        /**
+         * @brief Returns the processing strand of the file stream.
+         *
+         * @return void*
+         */
+        virtual ProcessingStrand* strand() const = 0;
+    };
+}
\ No newline at end of file
diff --git a/ssh/include/ssh/mocks/file_stream_mock.hpp b/ssh/include/ssh/mocks/file_stream_mock.hpp
new file mode 100644
index 00000000..1e8ba0f5
--- /dev/null
+++ b/ssh/include/ssh/mocks/file_stream_mock.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <ssh/file_stream_interface.hpp>
+
+#include <gmock/gmock.h>
+
+#include <future>
+#include <optional>
+#include <cstdint>
+#include <cstddef>
+#include <filesystem>
+#include <memory>
+
+namespace SecureShell::Test
+{
+    class FileStreamMock : public SecureShell::IFileStream
+    {
+      public:
+        MOCK_METHOD((std::future<std::expected<void, SftpError>>), seek, (std::size_t), (override));
+        MOCK_METHOD((std::future<std::expected<std::size_t, SftpError>>), tell, (), (override));
+        MOCK_METHOD((std::future<std::expected<FileInformation, SftpError>>), stat, (), (override));
+        MOCK_METHOD((std::future<std::expected<void, SftpError>>), rewind, (), (override));
+        MOCK_METHOD(
+            (std::future<std::expected<std::size_t, SftpError>>),
+            read,
+            (std::byte * buffer, std::size_t bufferSize),
+            (override));
+        MOCK_METHOD(
+            (std::future<std::expected<std::size_t, SftpError>>),
+            read,
+            (std::function<bool(std::string_view data)> onRead),
+            (override));
+        MOCK_METHOD((std::future<std::expected<void, SftpError>>), write, (std::string_view data), (override));
+        MOCK_METHOD(std::size_t, writeLengthLimit, (), (const, override));
+        MOCK_METHOD(std::size_t, readLengthLimit, (), (const, override));
+        MOCK_METHOD(sftp_file, release, (), (override));
+        MOCK_METHOD(void, close, (bool isBackElement), (override));
+        MOCK_METHOD(ProcessingStrand*, strand, (), (const, override));
+    };
+    ;
+}
\ No newline at end of file
diff --git a/ssh/include/ssh/sftp_session.hpp b/ssh/include/ssh/sftp_session.hpp
index 3f3b654e..3a5a2343 100644
--- a/ssh/include/ssh/sftp_session.hpp
+++ b/ssh/include/ssh/sftp_session.hpp
@@ -4,7 +4,7 @@
 #include <libssh/sftp.h>
 #include <ssh/async/processing_thread.hpp>
 #include <ssh/async/processing_strand.hpp>
-#include <shared_data/directory_entry.hpp>
+#include <ssh/file_information.hpp>
 #include <ssh/file_stream.hpp>
 #include <ssh/sftp_error.hpp>
 #include <ssh/session.hpp>
@@ -42,11 +42,6 @@ namespace SecureShell
 
         bool close(bool isBackElement = false);
 
-        struct DirectoryEntry : public SharedData::DirectoryEntry
-        {
-            static DirectoryEntry fromSftpAttributes(sftp_attributes attributes);
-        };
-
         template <typename FunctionT>
         void perform(FunctionT&& func)
         {
@@ -68,9 +63,10 @@ namespace SecureShell
          * @brief Lists the contents of a directory.
          *
          * @param path
-         * @return std::future<std::expected<std::vector<DirectoryEntry>, Error>>
+         * @return std::future<std::expected<std::vector<FileInformation>, Error>>
          */
-        std::future<std::expected<std::vector<DirectoryEntry>, Error>> listDirectory(std::filesystem::path const& path);
+        std::future<std::expected<std::vector<FileInformation>, Error>>
+        listDirectory(std::filesystem::path const& path);
 
         /**
          * @brief Create a directory.
@@ -115,16 +111,16 @@ namespace SecureShell
          * @brief Gets the attributes of a file or directory.
          *
          * @param path
-         * @return std::future<std::expected<DirectoryEntry, Error>>
+         * @return std::future<std::expected<FileInformation, Error>>
          */
-        std::future<std::expected<DirectoryEntry, Error>> stat(std::filesystem::path const& path);
+        std::future<std::expected<FileInformation, Error>> stat(std::filesystem::path const& path);
 
         /**
          * @brief Sets the attributes of a file or directory.
          *
          * @param path
          * @param attributes
-         * @return std::future<std::expected<DirectoryEntry, Error>>
+         * @return std::future<std::expected<FileInformation, Error>>
          */
         std::future<std::expected<void, Error>> stat(std::filesystem::path const& path, sftp_attributes attributes);
 
diff --git a/ssh/source/ssh/file_information.cpp b/ssh/source/ssh/file_information.cpp
new file mode 100644
index 00000000..1a3e1980
--- /dev/null
+++ b/ssh/source/ssh/file_information.cpp
@@ -0,0 +1,31 @@
+#include <ssh/file_information.hpp>
+
+namespace SecureShell
+{
+    FileInformation FileInformation::fromSftpAttributes(sftp_attributes attributes)
+    {
+        return FileInformation{
+            SharedData::DirectoryEntry{
+                .path = attributes->name ? std::string{attributes->name} : std::string{},
+                .longName = attributes->longname ? std::string{attributes->longname} : std::string{},
+                .flags = attributes->flags,
+                .type = attributes->type,
+                .size = attributes->size,
+                .uid = attributes->uid,
+                .gid = attributes->gid,
+                .owner = attributes->owner ? std::string{attributes->owner} : std::string{},
+                .group = attributes->group ? std::string{attributes->group} : std::string{},
+                .permissions = static_cast<std::filesystem::perms>(attributes->permissions),
+                .atime = attributes->atime,
+                .atimeNsec = attributes->atime_nseconds,
+                .createTime = attributes->createtime,
+                .createTimeNsec = attributes->createtime_nseconds,
+                .mtime = attributes->mtime,
+                .mtimeNsec = attributes->mtime_nseconds,
+                .acl = attributes->acl
+                    ? std::string{ssh_string_get_char(attributes->acl), ssh_string_len(attributes->acl)}
+                    : std::string{},
+            },
+        };
+    }
+}
\ No newline at end of file
diff --git a/ssh/source/ssh/file_stream.cpp b/ssh/source/ssh/file_stream.cpp
index d8195d2a..3478e7eb 100644
--- a/ssh/source/ssh/file_stream.cpp
+++ b/ssh/source/ssh/file_stream.cpp
@@ -92,6 +92,17 @@ namespace SecureShell
             return {};
         });
     }
+    std::future<std::expected<FileInformation, SftpError>> FileStream::stat()
+    {
+        return performPromise([this]() -> std::expected<FileInformation, SftpError> {
+            VERIFY_FILE_STREAM();
+            std::unique_ptr<sftp_attributes_struct, decltype(&sftp_attributes_free)> attributes{
+                sftp_fstat(file_.get()), sftp_attributes_free};
+            if (attributes == nullptr)
+                return std::unexpected(lastError());
+            return FileInformation::fromSftpAttributes(attributes.get());
+        });
+    }
     std::future<std::expected<std::size_t, SftpError>> FileStream::tell()
     {
         return performPromise([this]() -> std::expected<std::size_t, SftpError> {
@@ -141,12 +152,14 @@ namespace SecureShell
             std::string buffer;
             std::function<bool(std::string_view data)> callback;
             std::promise<std::expected<std::size_t, SftpError>> promise;
+            std::size_t totalRead;
 
             ReadState(FileStream& stream, std::size_t limit, std::function<bool(std::string_view data)> callback)
                 : stream{stream}
                 , buffer(std::min(4096ull, limit), '\0')
                 , callback{std::move(callback)}
                 , promise{}
+                , totalRead{0}
             {}
 
             void onRead(std::make_signed_t<std::size_t> amount)
@@ -160,14 +173,16 @@ namespace SecureShell
 
                 if (amount == 0)
                 {
-                    promise.set_value(static_cast<std::size_t>(buffer.size()));
+                    promise.set_value(totalRead);
                     callback({});
                     return;
                 }
 
+                totalRead += amount;
+
                 if (!callback({buffer.data(), static_cast<std::size_t>(amount)}))
                 {
-                    promise.set_value(static_cast<std::size_t>(buffer.size()));
+                    promise.set_value(totalRead);
                     return;
                 }
 
@@ -229,6 +244,11 @@ namespace SecureShell
             writePart(toWrite.substr(written), std::move(onWriteComplete));
         });
     }
+    ProcessingStrand* FileStream::strand() const
+    {
+        auto sftp = sftp_.lock();
+        return sftp ? sftp->strand_.get() : nullptr;
+    }
     std::future<std::expected<void, SftpError>> FileStream::write(std::string_view data)
     {
         // Short easy path:
diff --git a/ssh/source/ssh/sftp_session.cpp b/ssh/source/ssh/sftp_session.cpp
index 8be7b803..e822fa64 100644
--- a/ssh/source/ssh/sftp_session.cpp
+++ b/ssh/source/ssh/sftp_session.cpp
@@ -54,41 +54,14 @@ namespace SecureShell
             fileStreams_.back()->close(true);
         }
     }
-    SftpSession::DirectoryEntry SftpSession::DirectoryEntry::fromSftpAttributes(sftp_attributes attributes)
-    {
-        return DirectoryEntry{
-            SharedData::DirectoryEntry{
-                .path = attributes->name ? std::string{attributes->name} : std::string{},
-                .longName = attributes->longname ? std::string{attributes->longname} : std::string{},
-                .flags = attributes->flags,
-                .type = attributes->type,
-                .size = attributes->size,
-                .uid = attributes->uid,
-                .gid = attributes->gid,
-                .owner = attributes->owner ? std::string{attributes->owner} : std::string{},
-                .group = attributes->group ? std::string{attributes->group} : std::string{},
-                .permissions = static_cast<std::filesystem::perms>(attributes->permissions),
-                .atime = attributes->atime,
-                .atimeNsec = attributes->atime_nseconds,
-                .createTime = attributes->createtime,
-                .createTimeNsec = attributes->createtime_nseconds,
-                .mtime = attributes->mtime,
-                .mtimeNsec = attributes->mtime_nseconds,
-                .acl = attributes->acl
-                    ? std::string{ssh_string_get_char(attributes->acl), ssh_string_len(attributes->acl)}
-                    : std::string{},
-            },
-        };
-    }
 
-    std::future<std::expected<std::vector<SftpSession::DirectoryEntry>, SftpSession::Error>>
+    std::future<std::expected<std::vector<FileInformation>, SftpSession::Error>>
     SftpSession::listDirectory(std::filesystem::path const& path)
     {
         return performPromise(
-            [this,
-             path = std::move(path)]() -> std::expected<std::vector<SftpSession::DirectoryEntry>, SftpSession::Error> {
+            [this, path = std::move(path)]() -> std::expected<std::vector<FileInformation>, SftpSession::Error> {
                 int closeResult = 0;
-                std::vector<DirectoryEntry> entries{};
+                std::vector<FileInformation> entries{};
 
                 {
                     std::unique_ptr<sftp_dir_struct, std::function<void(sftp_dir_struct*)>> dir{
@@ -113,7 +86,7 @@ namespace SecureShell
 
                         for (; entry != nullptr; entry.reset(sftp_readdir(session_, dir.get())))
                         {
-                            entries.push_back(DirectoryEntry::fromSftpAttributes(entry.get()));
+                            entries.push_back(FileInformation::fromSftpAttributes(entry.get()));
                         }
                     }
 
@@ -196,16 +169,15 @@ namespace SecureShell
         });
     }
 
-    std::future<std::expected<SftpSession::DirectoryEntry, SftpSession::Error>>
-    SftpSession::stat(std::filesystem::path const& path)
+    std::future<std::expected<FileInformation, SftpSession::Error>> SftpSession::stat(std::filesystem::path const& path)
     {
-        return performPromise([this, path = std::move(path)]() -> std::expected<DirectoryEntry, Error> {
+        return performPromise([this, path = std::move(path)]() -> std::expected<FileInformation, Error> {
             std::unique_ptr<sftp_attributes_struct, decltype(&sftp_attributes_free)> attributes{
                 sftp_stat(session_, path.generic_string().c_str()), sftp_attributes_free};
             if (attributes == nullptr)
                 return std::unexpected(lastError());
 
-            return DirectoryEntry::fromSftpAttributes(attributes.get());
+            return FileInformation::fromSftpAttributes(attributes.get());
         });
     }
 
diff --git a/ssh/test/ssh/CMakeLists.txt b/ssh/test/ssh/CMakeLists.txt
index 492606cf..1e0e820e 100644
--- a/ssh/test/ssh/CMakeLists.txt
+++ b/ssh/test/ssh/CMakeLists.txt
@@ -11,6 +11,7 @@ find_package(Boost CONFIG REQUIRED COMPONENTS filesystem asio system process)
 target_link_libraries(
     nui-scp-ssh-test
     PUBLIC
+        utility
         secure-shell
         GTest::GTest
         GTest::Main
diff --git a/ssh/test/ssh/common_fixture.hpp b/ssh/test/ssh/common_fixture.hpp
index 643cb629..560d663f 100644
--- a/ssh/test/ssh/common_fixture.hpp
+++ b/ssh/test/ssh/common_fixture.hpp
@@ -154,7 +154,7 @@ namespace SecureShell::Test
                 });
         }
 
-        TemporaryDirectory isolateDirectory_{programDirectory / "temp", false};
+        Utility::TemporaryDirectory isolateDirectory_{programDirectory / "temp", false};
         boost::asio::thread_pool pool_{1};
         nlohmann::json defaultPackageJson_ = nlohmann::json({
             {"name", "test"},
diff --git a/ssh/test/ssh/test_processing_thread.hpp b/ssh/test/ssh/test_processing_thread.hpp
index 99faefcc..641af68c 100644
--- a/ssh/test/ssh/test_processing_thread.hpp
+++ b/ssh/test/ssh/test_processing_thread.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "utility/awaiter.hpp"
+#include <utility/awaiter.hpp>
 #include <ssh/async/processing_thread.hpp>
 #include <ssh/async/processing_strand.hpp>
 
diff --git a/ssh/test/ssh/test_sftp.hpp b/ssh/test/ssh/test_sftp.hpp
index 1c2f26ab..fe756128 100644
--- a/ssh/test/ssh/test_sftp.hpp
+++ b/ssh/test/ssh/test_sftp.hpp
@@ -21,9 +21,12 @@ namespace SecureShell::Test
         {
             if (std::filesystem::exists(programDirectory / "temp" / "log.txt"))
             {
+                if (!std::filesystem::exists(programDirectory / "logs"))
+                    std::filesystem::create_directory(programDirectory / "logs");
+
                 std::filesystem::rename(
                     programDirectory / "temp" / "log.txt",
-                    programDirectory / "temp" /
+                    programDirectory / "logs" /
                         ("log_"s + ::testing::UnitTest::GetInstance()->current_test_info()->test_case_name() + "_"s +
                          ::testing::UnitTest::GetInstance()->current_test_info()->name() + ".txt"));
             }
@@ -466,4 +469,27 @@ namespace SecureShell::Test
         ASSERT_TRUE(sftp->close());
         EXPECT_FALSE(sftp->close());
     }
+
+    TEST_F(SftpTests, CanStatFileUsingFileStream)
+    {
+        CREATE_SERVER_AND_JOINER(Sftp);
+        auto [_, sftp] = createSftpSession(serverStartResult->port);
+
+        auto fut =
+            sftp->openFile("/home/test/file1.txt", SftpSession::OpenType::Read, std::filesystem::perms::owner_read);
+        ASSERT_EQ(fut.wait_for(1s), std::future_status::ready);
+        auto result = fut.get();
+        ASSERT_TRUE(result.has_value());
+
+        auto fileWeak = std::move(result).value();
+        auto file = fileWeak.lock();
+        ASSERT_TRUE(file);
+
+        auto statFut = file->stat();
+        ASSERT_EQ(statFut.wait_for(1s), std::future_status::ready);
+        auto statResult = statFut.get();
+        ASSERT_TRUE(statResult.has_value());
+
+        EXPECT_GT(statResult.value().size, 0);
+    }
 }
diff --git a/ssh/test/ssh/utility/node.hpp b/ssh/test/ssh/utility/node.hpp
index 8e3e670f..c94bac29 100644
--- a/ssh/test/ssh/utility/node.hpp
+++ b/ssh/test/ssh/utility/node.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "./temporary_directory.hpp"
+#include <utility/temporary_directory.hpp>
 
 #include <boost/asio.hpp>
 
diff --git a/ssh/test/ssh/utility/temporary_directory.hpp b/ssh/test/ssh/utility/temporary_directory.hpp
deleted file mode 100644
index 477b3d6b..00000000
--- a/ssh/test/ssh/utility/temporary_directory.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-#pragma once
-
-#include <filesystem>
-
-#include <boost/uuid/uuid_generators.hpp>
-#include <boost/uuid/uuid.hpp>
-#include <boost/uuid/uuid_generators.hpp>
-#include <boost/uuid/uuid_io.hpp>
-
-#include <string>
-
-namespace SecureShell::Test
-{
-    class TemporaryDirectory
-    {
-      public:
-        TemporaryDirectory(std::filesystem::path path, bool randomSubFolder = true)
-            : path_{std::move(path)}
-        {
-            using namespace std::string_literals;
-
-            std::error_code error;
-            bool valid = true;
-            if (!std::filesystem::exists(path_, error))
-            {
-                valid = std::filesystem::create_directories(path_, error) && !error;
-            }
-            else if (!std::filesystem::is_directory(path_))
-            {
-                throw std::runtime_error(std::string{"Given path exists and is not a directory: "} + path_.string());
-            }
-            if (valid && randomSubFolder)
-            {
-                auto dir = path_ / ("temp_"s + boost::uuids::to_string(gen_()));
-                std::filesystem::create_directory(dir);
-                valid = std::filesystem::is_directory(dir);
-                path_ = dir;
-            }
-            if (!valid)
-            {
-                throw std::runtime_error(std::string{"Could not setup temporary directory: "} + path_.string());
-            }
-        }
-        ~TemporaryDirectory()
-        {
-            std::error_code error;
-
-            // if (!path_.empty())
-            //     std::filesystem::remove_all(path_, error);
-        }
-
-        TemporaryDirectory(TemporaryDirectory const&) = delete;
-
-        TemporaryDirectory(TemporaryDirectory&& t)
-            : path_{std::move(t.path_)}
-        {}
-
-        TemporaryDirectory& operator=(TemporaryDirectory const&) = delete;
-
-        TemporaryDirectory& operator=(TemporaryDirectory&& t)
-        {
-            path_ = std::exchange(t.path_, {});
-            return *this;
-        }
-
-        std::filesystem::path path() const noexcept
-        {
-            return path_;
-        }
-
-        operator std::filesystem::path() const noexcept
-        {
-            return path_;
-        }
-
-      private:
-        std::filesystem::path path_;
-        boost::uuids::random_generator gen_{};
-    };
-}
\ No newline at end of file
diff --git a/ssh/test/ssh/utility/awaiter.hpp b/utility/include/utility/awaiter.hpp
similarity index 100%
rename from ssh/test/ssh/utility/awaiter.hpp
rename to utility/include/utility/awaiter.hpp
diff --git a/utility/include/utility/temporary_directory.hpp b/utility/include/utility/temporary_directory.hpp
index a59dfeba..95db6021 100644
--- a/utility/include/utility/temporary_directory.hpp
+++ b/utility/include/utility/temporary_directory.hpp
@@ -2,24 +2,79 @@
 
 #include <filesystem>
 
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid_io.hpp>
+
+#include <string>
+
 namespace Utility
 {
     class TemporaryDirectory
     {
       public:
-        TemporaryDirectory();
-        ~TemporaryDirectory();
+        TemporaryDirectory(std::filesystem::path path, bool randomSubFolder = true)
+            : path_{std::move(path)}
+        {
+            using namespace std::string_literals;
+
+            std::error_code error;
+            bool valid = true;
+            if (!std::filesystem::exists(path_, error))
+            {
+                valid = std::filesystem::create_directories(path_, error) && !error;
+            }
+            else if (!std::filesystem::is_directory(path_))
+            {
+                throw std::runtime_error(std::string{"Given path exists and is not a directory: "} + path_.string());
+            }
+            if (valid && randomSubFolder)
+            {
+                auto dir = path_ / ("temp_"s + boost::uuids::to_string(gen_()));
+                std::filesystem::create_directory(dir);
+                valid = std::filesystem::is_directory(dir);
+                path_ = dir;
+            }
+            if (!valid)
+            {
+                throw std::runtime_error(std::string{"Could not setup temporary directory: "} + path_.string());
+            }
+        }
+        ~TemporaryDirectory()
+        {
+            std::error_code error;
+
+            if (!path_.empty())
+                std::filesystem::remove_all(path_, error);
+        }
 
         TemporaryDirectory(TemporaryDirectory const&) = delete;
+
+        TemporaryDirectory(TemporaryDirectory&& t)
+            : path_{std::move(t.path_)}
+        {}
+
         TemporaryDirectory& operator=(TemporaryDirectory const&) = delete;
 
-        TemporaryDirectory(TemporaryDirectory&&) = delete;
-        TemporaryDirectory& operator=(TemporaryDirectory&&) = delete;
+        TemporaryDirectory& operator=(TemporaryDirectory&& t)
+        {
+            path_ = std::exchange(t.path_, {});
+            return *this;
+        }
+
+        std::filesystem::path path() const noexcept
+        {
+            return path_;
+        }
 
-        std::filesystem::path const& path() const;
+        operator std::filesystem::path() const noexcept
+        {
+            return path_;
+        }
 
       private:
-        std::filesystem::path m_basePath;
-        std::filesystem::path m_path;
+        std::filesystem::path path_;
+        boost::uuids::random_generator gen_{};
     };
 }
\ No newline at end of file
diff --git a/utility/source/utility/temporary_directory.cpp b/utility/source/utility/temporary_directory.cpp
index d0a5a33f..d3e50b4a 100644
--- a/utility/source/utility/temporary_directory.cpp
+++ b/utility/source/utility/temporary_directory.cpp
@@ -1,74 +1 @@
-#include <utility/temporary_directory.hpp>
-
-#include <cstdlib>
-#include <random>
-#include <ctime>
-
-using namespace std::string_literals;
-
-namespace Utility
-{
-    namespace
-    {
-        [[maybe_unused]] std::string generateRandomString(int length)
-        {
-            std::string characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-            std::string randomString;
-
-            std::mt19937 rng(std::time(nullptr)); // Seed the random generator with time
-            std::uniform_int_distribution<int> distribution(0, characters.length() - 1);
-
-            for (int i = 0; i < length; ++i)
-            {
-                randomString += characters[distribution(rng)];
-            }
-
-            return randomString;
-        }
-    }
-
-    TemporaryDirectory::TemporaryDirectory()
-        : m_basePath{[]() {
-            const auto temporaryDirectory = std::filesystem::temp_directory_path();
-            return temporaryDirectory / "sscv2_client_tmpdir";
-        }()}
-        , m_path{}
-    {
-        if (!std::filesystem::exists(m_basePath))
-            std::filesystem::create_directories(m_basePath);
-
-#if __linux__
-        std::string dirNameAsString{(m_basePath / "dirXXXXXX").string()};
-        bool valid = mkdtemp(&dirNameAsString[0]) && std::filesystem::is_directory(dirNameAsString);
-        if (valid)
-            m_path = dirNameAsString;
-#else
-        int i = 0;
-        for (; i != 1000; ++i)
-        {
-            const auto directoryName = "dir"s + generateRandomString(10);
-            const auto path = m_basePath / directoryName;
-            if (!std::filesystem::exists(path))
-            {
-                std::filesystem::create_directory(path);
-                m_path = path;
-                break;
-            }
-        }
-        bool valid = i != 1000;
-#endif
-        if (!valid)
-            throw std::runtime_error(std::string{"Could not setup temporary directory: "} + m_path.string());
-    }
-    TemporaryDirectory::~TemporaryDirectory()
-    {
-        std::error_code error;
-        std::filesystem::remove_all(m_path, error);
-        std::filesystem::remove(m_basePath, error);
-    }
-
-    std::filesystem::path const& TemporaryDirectory::path() const
-    {
-        return m_path;
-    }
-}
\ No newline at end of file
+// TODO: Remove
\ No newline at end of file

From 98143ab4cc2845af678868d588216b4954ffc715 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sun, 9 Mar 2025 18:49:22 +0100
Subject: [PATCH 10/42] Simplified operation task flush.

---
 backend/source/backend/sftp/download_operation.cpp | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/backend/source/backend/sftp/download_operation.cpp b/backend/source/backend/sftp/download_operation.cpp
index 94e03976..a6b28d3a 100644
--- a/backend/source/backend/sftp/download_operation.cpp
+++ b/backend/source/backend/sftp/download_operation.cpp
@@ -47,11 +47,7 @@ DownloadOperation::~DownloadOperation()
     if (auto stream = fileStream_.lock(); stream)
     {
         // wait for all tasks of the operation to finish
-        stream->strand()
-            ->pushPromiseTask([]() {
-                return true;
-            })
-            .get();
+        stream->strand()->pushPromiseTask([]() {}).get();
     }
 }
 

From 0cfca0f045b543dcf7d9c7b089c1a36024c294cb Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sun, 9 Mar 2025 23:25:30 +0100
Subject: [PATCH 11/42] Added tests for download operation.

---
 .../backend/sftp/download_operation.hpp       |   3 +-
 backend/include/backend/sftp/operation.hpp    |   5 +-
 .../backend/sftp/download_operation.cpp       |  75 ++-
 .../test/backend/test_download_operation.hpp  | 466 +++++++++++++++++-
 4 files changed, 523 insertions(+), 26 deletions(-)

diff --git a/backend/include/backend/sftp/download_operation.hpp b/backend/include/backend/sftp/download_operation.hpp
index 46e2aa21..0e58d039 100644
--- a/backend/include/backend/sftp/download_operation.hpp
+++ b/backend/include/backend/sftp/download_operation.hpp
@@ -37,7 +37,7 @@ class DownloadOperation : public Operation
 
     std::expected<void, Error> prepare() override;
     std::expected<void, Error> start() override;
-    void cancel() override;
+    std::expected<void, Error> cancel() override;
     std::expected<void, Error> pause() override;
     std::expected<void, Error> finalize() override;
 
@@ -74,6 +74,7 @@ class DownloadOperation : public Operation
     bool inheritPermissions_;
     bool doCleanup_;
     bool preparationDone_;
+    bool isReading_;
     std::atomic_bool interuptRead_;
     std::optional<std::filesystem::perms> permissions_;
     std::ofstream localFile_;
diff --git a/backend/include/backend/sftp/operation.hpp b/backend/include/backend/sftp/operation.hpp
index 6515067f..b1eb2d37 100644
--- a/backend/include/backend/sftp/operation.hpp
+++ b/backend/include/backend/sftp/operation.hpp
@@ -20,7 +20,8 @@ BOOST_DEFINE_ENUM_CLASS(
     RenameFailure,
     CannotSetFilePermissions,
     FutureTimeout,
-    OperationNotPrepared);
+    OperationNotPrepared,
+    CannotFinalizeDuringRead);
 
 class Operation
 {
@@ -60,7 +61,7 @@ class Operation
     /**
      * @brief Cancels the operation and possibly does some cleanup.
      */
-    virtual void cancel() = 0;
+    virtual std::expected<void, Error> cancel() = 0;
 
     /**
      * @brief Pauses the operation.
diff --git a/backend/source/backend/sftp/download_operation.cpp b/backend/source/backend/sftp/download_operation.cpp
index a6b28d3a..5149776e 100644
--- a/backend/source/backend/sftp/download_operation.cpp
+++ b/backend/source/backend/sftp/download_operation.cpp
@@ -18,6 +18,9 @@ DownloadOperation::DownloadOperation(
         if (once)
             return;
         once = true;
+
+        std::scoped_lock lock{mutex_};
+        isReading_ = false;
         progressCallback_(0, fileSize_, fileSize_);
         cb(success);
     }}
@@ -27,6 +30,7 @@ DownloadOperation::DownloadOperation(
     , inheritPermissions_{options.inheritPermissions}
     , doCleanup_{options.doCleanup}
     , preparationDone_{false}
+    , isReading_{false}
     , interuptRead_{false}
     , permissions_{options.permissions}
     , localFile_{}
@@ -199,29 +203,40 @@ std::expected<void, Operation::Error> DownloadOperation::start()
         return std::unexpected(Error{.type = ErrorType::FileStreamExpired});
     }
 
+    isReading_ = true;
     readFuture_ = stream->read([this](std::string_view data) {
         if (data.size() == 0)
         {
-            Log::info("DownloadOperation: Remote file read complete or error.");
             {
-                std::scoped_lock lock{mutex_};
-                localFile_.close();
+                std::lock_guard lock{mutex_};
+                isReading_ = false;
             }
+            Log::info("DownloadOperation: Remote file read complete or error.");
             // Defer completion by pushing it onto the strand.
             perform([this]() {
                 std::scoped_lock lock{mutex_};
                 onCompletionCallback_(true);
             });
-            return false;
+            return true;
         }
 
-        std::scoped_lock lock{mutex_};
-        localFile_.write(data.data(), data.size());
-        progressCallback_(0, fileSize_, localFile_.tellp());
-        const auto doContinue = localFile_.good() || interuptRead_;
+        std::uint64_t fileSize = 0;
+        std::uint64_t tellp = 0;
+        bool doContinue = true;
+        bool good = true;
+        {
+            std::scoped_lock lock{mutex_};
+            localFile_.write(data.data(), data.size());
+            fileSize = fileSize_;
+            tellp = static_cast<uint64_t>(localFile_.tellp());
+            good = localFile_.good();
+            doContinue = good && !interuptRead_;
+            isReading_ = doContinue;
+        }
+        progressCallback_(0, fileSize, tellp);
         if (!doContinue)
         {
-            if (!localFile_.good())
+            if (!good)
             {
                 Log::error("DownloadOperation read cycle stopped: localFile_.good() == false");
                 perform([this]() {
@@ -235,14 +250,26 @@ std::expected<void, Operation::Error> DownloadOperation::start()
 
     return {};
 }
-void DownloadOperation::cancel()
+std::expected<void, DownloadOperation::Error> DownloadOperation::cancel()
 {
-    std::scoped_lock lock{mutex_};
+    {
+        std::scoped_lock lock{mutex_};
 
-    Log::info(
-        "DownloadOperation: Download of '{}' to '{}' canceled.",
-        remotePath_.generic_string(),
-        localPath_.generic_string());
+        if (isReading_)
+        {
+            const auto res = pause();
+            if (!res.has_value())
+            {
+                Log::error("DownloadOperation: Failed to pause download.");
+                return res;
+            }
+        }
+
+        Log::info(
+            "DownloadOperation: Download of '{}' to '{}' canceled.",
+            remotePath_.generic_string(),
+            localPath_.generic_string());
+    }
 
     perform([this]() {
         std::scoped_lock lock{mutex_};
@@ -250,6 +277,8 @@ void DownloadOperation::cancel()
     });
 
     cleanup();
+
+    return {};
 }
 void DownloadOperation::cleanup()
 {
@@ -264,20 +293,32 @@ void DownloadOperation::cleanup()
 }
 std::expected<void, DownloadOperation::Error> DownloadOperation::pause()
 {
-    std::scoped_lock lock{mutex_};
-    interuptRead_ = true;
+    {
+        std::scoped_lock lock{mutex_};
+        interuptRead_ = true;
+    }
 
     if (readFuture_.wait_for(futureTimeout_) != std::future_status::ready)
     {
         Log::error("DownloadOperation: Failed to pause download.");
         return std::unexpected(Error{.type = ErrorType::FutureTimeout});
     }
+    {
+        std::scoped_lock lock{mutex_};
+        isReading_ = false;
+    }
     return {};
 }
 std::expected<void, DownloadOperation::Error> DownloadOperation::finalize()
 {
     std::scoped_lock lock{mutex_};
 
+    if (isReading_)
+    {
+        Log::error("DownloadOperation: Cannot finalize while reading.");
+        return std::unexpected(Error{.type = ErrorType::CannotFinalizeDuringRead});
+    }
+
     if (readFuture_.wait_for(futureTimeout_) != std::future_status::ready)
     {
         Log::error("DownloadOperation: Failed to wait for download completion.");
diff --git a/backend/test/backend/test_download_operation.hpp b/backend/test/backend/test_download_operation.hpp
index 66fc1523..aac4cacd 100644
--- a/backend/test/backend/test_download_operation.hpp
+++ b/backend/test/backend/test_download_operation.hpp
@@ -8,6 +8,12 @@
 
 #include <gtest/gtest.h>
 
+#include <thread>
+#include <string>
+#include <memory>
+#include <tuple>
+#include <vector>
+
 using namespace std::chrono_literals;
 using namespace std::string_literals;
 
@@ -20,6 +26,9 @@ namespace Test
       protected:
         void SetUp() override
         {
+            for (int i = 0; i != 10; ++i)
+                fakeFileContent_ += "This is a test file content.\n";
+
             processingThread_.start(5ms);
         }
 
@@ -84,14 +93,19 @@ namespace Test
             if (chunkSize == 0)
             {
                 readPromise_.set_value(readOffset_);
-                onRead_({});
+                onReadResult_ = onRead_({});
                 return;
             }
 
             if (onRead_)
             {
-                onRead_(std::string_view{fakeFileContent_}.substr(readOffset_, chunkSize));
+                onReadResult_ = onRead_(std::string_view{fakeFileContent_}.substr(readOffset_, chunkSize));
                 readOffset_ += chunkSize;
+                if (!onReadResult_)
+                {
+                    readPromise_.set_value(readOffset_);
+                    return;
+                }
             }
             else
             {
@@ -99,14 +113,21 @@ namespace Test
             }
         }
 
+        std::string readFile(std::filesystem::path const& path)
+        {
+            std::ifstream file{path};
+            return std::string{std::istreambuf_iterator<char>{file}, std::istreambuf_iterator<char>{}};
+        }
+
       protected:
-        std::string fakeFileContent_{"Hello, World!"};
+        std::string fakeFileContent_{};
         Utility::TemporaryDirectory isolateDirectory_{programDirectory / "temp", true};
         SecureShell::ProcessingThread processingThread_{};
         std::unique_ptr<SecureShell::ProcessingStrand> strand_{processingThread_.createStrand()};
         std::promise<std::expected<std::size_t, SecureShell::SftpError>> readPromise_{};
         std::function<bool(std::string_view data)> onRead_{};
         std::size_t readOffset_{0};
+        bool onReadResult_{true};
     };
 
     TEST_F(DownloadOperationTests, CanCreateDownloadOperation)
@@ -340,7 +361,7 @@ namespace Test
         EXPECT_TRUE(result.has_value());
         EXPECT_TRUE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
 
-        operation.cancel();
+        EXPECT_TRUE(operation.cancel().has_value());
 
         EXPECT_TRUE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
     }
@@ -371,7 +392,7 @@ namespace Test
         EXPECT_TRUE(result.has_value());
         EXPECT_TRUE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
 
-        operation.cancel();
+        EXPECT_TRUE(operation.cancel().has_value());
 
         EXPECT_FALSE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
     }
@@ -398,7 +419,7 @@ namespace Test
 
         auto result = operation.prepare();
         EXPECT_TRUE(result.has_value());
-        operation.cancel();
+        EXPECT_TRUE(operation.cancel().has_value());
 
         auto future = completionPromise.get_future();
         ASSERT_EQ(future.wait_for(1s), std::future_status::ready);
@@ -461,4 +482,437 @@ namespace Test
         EXPECT_FALSE(result.has_value());
         EXPECT_EQ(result.error().type, DownloadOperation::ErrorType::FileStreamExpired);
     }
+
+    TEST_F(DownloadOperationTests, StartCallsReadOnFileStream)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream, 42);
+        giveMockExpectedRead(fileStream);
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+
+        result = operation.start();
+        EXPECT_TRUE(result.has_value());
+    }
+
+    TEST_F(DownloadOperationTests, PrepareReservesSpaceForFile)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream, fakeFileContent_.size());
+        giveMockExpectedRead(fileStream);
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .reserveSpace = true,
+            .doCleanup = false,
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+
+        EXPECT_TRUE(operation.cancel().has_value());
+
+        EXPECT_EQ(
+            std::filesystem::file_size(options.localPath.generic_string() + ".filepart"), fakeFileContent_.size());
+    }
+
+    TEST_F(DownloadOperationTests, ReadCycleWritesDataToFile)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream, fakeFileContent_.size());
+        giveMockExpectedRead(fileStream);
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .doCleanup = false,
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+
+        result = operation.start();
+        EXPECT_TRUE(result.has_value());
+
+        fakeReadCycle(5);
+        fakeReadCycle(0); // EOF Cycle
+
+        EXPECT_TRUE(operation.cancel().has_value());
+
+        EXPECT_EQ(std::filesystem::file_size(options.localPath.generic_string() + ".filepart"), 5);
+        EXPECT_EQ(readFile(options.localPath.generic_string() + ".filepart"), fakeFileContent_.substr(0, 5));
+    }
+
+    TEST_F(DownloadOperationTests, ReadWritesFileThroughMultipleCycles)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream, fakeFileContent_.size());
+        giveMockExpectedRead(fileStream);
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .doCleanup = false,
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+
+        result = operation.start();
+        EXPECT_TRUE(result.has_value());
+
+        for (std::size_t i = 0; i < fakeFileContent_.size(); ++i)
+            fakeReadCycle(1);
+        fakeReadCycle(0); // EOF Cycle
+
+        EXPECT_TRUE(operation.cancel().has_value());
+
+        EXPECT_EQ(
+            std::filesystem::file_size(options.localPath.generic_string() + ".filepart"), fakeFileContent_.size());
+        EXPECT_EQ(readFile(options.localPath.generic_string() + ".filepart"), fakeFileContent_);
+    }
+
+    TEST_F(DownloadOperationTests, ReadWritesFileThroughSingleCycle)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream, fakeFileContent_.size());
+        giveMockExpectedRead(fileStream);
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .doCleanup = false,
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+
+        result = operation.start();
+        EXPECT_TRUE(result.has_value());
+
+        fakeReadCycle(fakeFileContent_.size());
+        fakeReadCycle(0); // EOF Cycle
+
+        EXPECT_TRUE(operation.cancel().has_value());
+
+        EXPECT_EQ(
+            std::filesystem::file_size(options.localPath.generic_string() + ".filepart"), fakeFileContent_.size());
+        EXPECT_EQ(readFile(options.localPath.generic_string() + ".filepart"), fakeFileContent_);
+    }
+
+    TEST_F(DownloadOperationTests, CanPauseRead)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream, fakeFileContent_.size());
+        giveMockExpectedRead(fileStream);
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .doCleanup = false,
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+
+        result = operation.start();
+        EXPECT_TRUE(result.has_value());
+
+        fakeReadCycle(5);
+
+        std::expected<void, DownloadOperation::Error> pauseResult;
+        std::promise<void> threadStarted;
+        std::thread asyncPause{[&operation, &pauseResult, &threadStarted]() {
+            threadStarted.set_value();
+            pauseResult = operation.pause();
+        }};
+        threadStarted.get_future().wait();
+        // dont know actually how to wait for the pause, except for burdening the wait on the user.
+        std::this_thread::sleep_for(200ms);
+
+        // This one still goes through but now signals a stop to the read.
+        fakeReadCycle(5);
+
+        asyncPause.join();
+
+        EXPECT_TRUE(operation.cancel().has_value());
+
+        EXPECT_EQ(onReadResult_, false);
+        EXPECT_EQ(std::filesystem::file_size(options.localPath.generic_string() + ".filepart"), 10);
+        EXPECT_EQ(readFile(options.localPath.generic_string() + ".filepart"), fakeFileContent_.substr(0, 10));
+    }
+
+    TEST_F(DownloadOperationTests, CanContinueReadingAfterPause)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream, fakeFileContent_.size());
+        giveMockExpectedRead(fileStream);
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .doCleanup = false,
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+
+        result = operation.start();
+        EXPECT_TRUE(result.has_value());
+
+        fakeReadCycle(5);
+
+        std::expected<void, DownloadOperation::Error> pauseResult;
+        std::promise<void> threadStarted;
+        std::thread asyncPause{[&operation, &pauseResult, &threadStarted]() {
+            threadStarted.set_value();
+            pauseResult = operation.pause();
+        }};
+        threadStarted.get_future().wait();
+        // dont know actually how to wait for the pause, except for burdening the wait on the user.
+        std::this_thread::sleep_for(200ms);
+
+        // This one still goes through but now signals a stop to the read.
+        fakeReadCycle(5);
+
+        asyncPause.join();
+
+        EXPECT_EQ(onReadResult_, false);
+
+        result = operation.start();
+        EXPECT_TRUE(result.has_value());
+
+        // This one should go through and continue the read.
+        fakeReadCycle(fakeFileContent_.size() - 10);
+        fakeReadCycle(0); // EOF Cycle
+
+        result = operation.cancel();
+        EXPECT_TRUE(result.has_value());
+
+        EXPECT_EQ(onReadResult_, true);
+        EXPECT_EQ(
+            std::filesystem::file_size(options.localPath.generic_string() + ".filepart"), fakeFileContent_.size());
+        EXPECT_EQ(readFile(options.localPath.generic_string() + ".filepart"), fakeFileContent_);
+    }
+
+    TEST_F(DownloadOperationTests, CannotFinalizeWhileReading)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream, fakeFileContent_.size());
+        giveMockExpectedRead(fileStream);
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .doCleanup = false,
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+
+        result = operation.start();
+        EXPECT_TRUE(result.has_value());
+
+        fakeReadCycle(5);
+
+        auto fin = operation.finalize();
+        EXPECT_FALSE(fin.has_value());
+        EXPECT_EQ(fin.error().type, DownloadOperation::ErrorType::CannotFinalizeDuringRead);
+    }
+
+    TEST_F(DownloadOperationTests, FinalizeFailsIfFileExistsButOverwriteIsForbidden)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream, fakeFileContent_.size());
+        giveMockExpectedRead(fileStream);
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .mayOverwrite = false,
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+
+        result = operation.start();
+        EXPECT_TRUE(result.has_value());
+
+        fakeReadCycle(fakeFileContent_.size());
+        fakeReadCycle(0); // EOF Cycle
+
+        {
+            std::ofstream file{options.localPath};
+        }
+
+        auto fin = operation.finalize();
+        EXPECT_FALSE(fin.has_value());
+        EXPECT_EQ(fin.error().type, DownloadOperation::ErrorType::FileExists);
+    }
+
+    TEST_F(DownloadOperationTests, CanFinalizeOperation)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream, fakeFileContent_.size());
+        giveMockExpectedRead(fileStream);
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .mayOverwrite = false,
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+
+        result = operation.start();
+        EXPECT_TRUE(result.has_value());
+
+        fakeReadCycle(fakeFileContent_.size());
+        fakeReadCycle(0); // EOF Cycle
+
+        auto fin = operation.finalize();
+        EXPECT_TRUE(fin.has_value());
+
+        EXPECT_EQ(readFile(options.localPath), fakeFileContent_);
+        EXPECT_FALSE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
+    }
+
+    TEST_F(DownloadOperationTests, FinalizeSucceedsIfFileExistsButOverwriteIsAllowed)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream, fakeFileContent_.size());
+        giveMockExpectedRead(fileStream);
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .mayOverwrite = true,
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+
+        result = operation.start();
+        EXPECT_TRUE(result.has_value());
+
+        fakeReadCycle(fakeFileContent_.size());
+        fakeReadCycle(0); // EOF Cycle
+
+        {
+            std::ofstream file{options.localPath};
+        }
+
+        auto fin = operation.finalize();
+        EXPECT_TRUE(fin.has_value());
+    }
+
+    TEST_F(DownloadOperationTests, ProgressCallbackIsCalledDuringRead)
+    {
+        using namespace SecureShell;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream, fakeFileContent_.size());
+        giveMockExpectedRead(fileStream);
+
+        std::vector<std::tuple<std::int64_t, std::int64_t, std::int64_t>> progressCalls;
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .progressCallback =
+                [&progressCalls](std::int64_t min, std::int64_t max, std::int64_t current) {
+                    progressCalls.emplace_back(min, max, current);
+                },
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .doCleanup = false,
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+
+        result = operation.start();
+        EXPECT_TRUE(result.has_value());
+
+        for (std::size_t i = 0; i < fakeFileContent_.size(); ++i)
+            fakeReadCycle(1);
+        fakeReadCycle(0); // EOF Cycle
+
+        EXPECT_TRUE(operation.cancel().has_value());
+
+        EXPECT_EQ(progressCalls.size(), fakeFileContent_.size());
+        for (std::size_t i = 0; i < fakeFileContent_.size(); ++i)
+        {
+            EXPECT_EQ(std::get<0>(progressCalls[i]), 0);
+            EXPECT_EQ(std::get<1>(progressCalls[i]), fakeFileContent_.size());
+            EXPECT_EQ(std::get<2>(progressCalls[i]), i + 1);
+        }
+
+        EXPECT_EQ(std::get<0>(progressCalls.back()), 0);
+        EXPECT_EQ(std::get<1>(progressCalls.back()), fakeFileContent_.size());
+        EXPECT_EQ(std::get<2>(progressCalls.back()), fakeFileContent_.size());
+    }
+
+    TEST_F(DownloadOperationTests, CompletionCallbackIsCalled)
+    {
+        using namespace SecureShell;
+
+        std::promise<bool> completionPromise;
+
+        auto fileStream = makeFileStreamMock();
+        giveMockDefaultStat(fileStream, fakeFileContent_.size());
+        giveMockExpectedRead(fileStream);
+
+        auto options = DownloadOperation::DownloadOperationOptions{
+            .onCompletionCallback =
+                [&completionPromise](bool success) {
+                    completionPromise.set_value(success);
+                },
+            .localPath = isolateDirectory_.path() / "file.txt",
+            .doCleanup = false,
+        };
+        DownloadOperation operation{fileStream, options};
+
+        auto result = operation.prepare();
+        EXPECT_TRUE(result.has_value());
+
+        result = operation.start();
+        EXPECT_TRUE(result.has_value());
+
+        for (std::size_t i = 0; i < fakeFileContent_.size(); ++i)
+            fakeReadCycle(1);
+        fakeReadCycle(0); // EOF Cycle
+
+        auto future = completionPromise.get_future();
+        ASSERT_EQ(future.wait_for(1s), std::future_status::ready);
+        EXPECT_TRUE(future.get());
+    }
 }
\ No newline at end of file

From cc301cef59b91d5731a2f39e870ed7a0fec4bbce Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Mon, 10 Mar 2025 02:39:13 +0100
Subject: [PATCH 12/42] Added download operation add to queue.

---
 .gitignore                                    |  3 +-
 backend/include/backend/sftp/operation.hpp    | 11 ++-
 .../include/backend/sftp/operation_queue.hpp  | 32 ++++++--
 .../include/backend/ssh_session_manager.hpp   | 20 ++---
 backend/source/backend/CMakeLists.txt         |  3 +-
 backend/source/backend/main.cpp               |  2 +-
 .../source/backend/sftp/operation_queue.cpp   | 68 ++++++++++++++++
 .../source/backend/ssh_session_manager.cpp    | 72 +++++++++++++++--
 .../persistence/state/sftp_options.hpp        | 35 +++++++++
 .../persistence/state/ssh_session_options.hpp |  2 +
 .../include/persistence/state/state.hpp       |  1 +
 persistence/source/persistence/CMakeLists.txt |  1 +
 .../source/persistence/state/sftp_options.cpp | 78 +++++++++++++++++++
 .../persistence/state/ssh_session_options.cpp |  4 +
 .../source/persistence/state/state.cpp        |  4 +
 ssh/source/ssh/CMakeLists.txt                 |  1 +
 ssh/test/ssh/utility/node.cpp                 |  2 +-
 ssh/test/ssh/utility/node.hpp                 |  2 +-
 18 files changed, 308 insertions(+), 33 deletions(-)
 create mode 100644 persistence/include/persistence/state/sftp_options.hpp
 create mode 100644 persistence/source/persistence/state/sftp_options.cpp

diff --git a/.gitignore b/.gitignore
index e3d5bf0d..82c65bbe 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,4 +9,5 @@ dependencies/*
 node_modules/*
 themes/node_modules/*
 themes/node_modules
-todo.txt
\ No newline at end of file
+todo.txt
+.clangd
\ No newline at end of file
diff --git a/backend/include/backend/sftp/operation.hpp b/backend/include/backend/sftp/operation.hpp
index b1eb2d37..353afeb4 100644
--- a/backend/include/backend/sftp/operation.hpp
+++ b/backend/include/backend/sftp/operation.hpp
@@ -21,7 +21,8 @@ BOOST_DEFINE_ENUM_CLASS(
     CannotSetFilePermissions,
     FutureTimeout,
     OperationNotPrepared,
-    CannotFinalizeDuringRead);
+    CannotFinalizeDuringRead,
+    InvalidOptionsKey);
 
 class Operation
 {
@@ -40,6 +41,14 @@ class Operation
     {
         ErrorType type;
         std::optional<SecureShell::SftpError> sftpError = std::nullopt;
+
+        std::string toString() const
+        {
+            const auto enumString = boost::describe::enum_to_string(type, "INVALID_ENUM_VALUE");
+            if (sftpError.has_value())
+                return fmt::format("{}: {}", enumString, sftpError->toString());
+            return enumString;
+        }
     };
 
     Ids::OperationId id() const
diff --git a/backend/include/backend/sftp/operation_queue.hpp b/backend/include/backend/sftp/operation_queue.hpp
index 72aec0c2..85aee22e 100644
--- a/backend/include/backend/sftp/operation_queue.hpp
+++ b/backend/include/backend/sftp/operation_queue.hpp
@@ -1,16 +1,36 @@
 #pragma once
 
+#include <backend/sftp/operation.hpp>
+#include <backend/sftp/download_operation.hpp>
+#include <persistence/state/state.hpp>
+#include <ssh/sftp_session.hpp>
 #include <ids/ids.hpp>
-#include <ssh/file_stream.hpp>
 
-class FileOperationQueue
+#include <vector>
+#include <filesystem>
+#include <memory>
+#include <utility>
+
+class OperationQueue
 {
   public:
-    FileOperationQueue();
+    OperationQueue();
+
+    using Error = OperationErrorType;
 
+    void start();
     void pause();
-    void resume();
-    void cancelAll(bool clean);
+    void cancelAll();
+    void cancel(Ids::OperationId id);
+
+    std::expected<void, Operation::Error> addDownloadOperation(
+        Persistence::State const& state,
+        std::string const& sshSessionOptionsKey,
+        SecureShell::SftpSession& sftp,
+        Ids::OperationId id,
+        std::filesystem::path const& localPath,
+        std::filesystem::path const& remotePath);
 
   private:
-};
\ No newline at end of file
+    std::vector<std::pair<Ids::OperationId, std::unique_ptr<Operation>>> operations_;
+};
diff --git a/backend/include/backend/ssh_session_manager.hpp b/backend/include/backend/ssh_session_manager.hpp
index f23d51ea..7db152b1 100644
--- a/backend/include/backend/ssh_session_manager.hpp
+++ b/backend/include/backend/ssh_session_manager.hpp
@@ -1,9 +1,9 @@
 #pragma once
 
 #include <persistence/state/terminal_engine.hpp>
+#include <persistence/state_holder.hpp>
 #include <backend/password/password_provider.hpp>
-// #include <backend/ssh/session.hpp>
-// #include <backend/ssh/sftp_session.hpp>
+#include <backend/sftp/operation_queue.hpp>
 #include <ssh/session.hpp>
 #include <ssh/sftp_session.hpp>
 #include <ids/ids.hpp>
@@ -23,7 +23,7 @@ class SshSessionManager
   public:
     constexpr static auto futureTimeout = std::chrono::seconds{10};
 
-    SshSessionManager();
+    SshSessionManager(Persistence::StateHolder* stateHolder);
     ~SshSessionManager();
     SshSessionManager(SshSessionManager const&) = delete;
     SshSessionManager& operator=(SshSessionManager const&) = delete;
@@ -55,22 +55,16 @@ class SshSessionManager
     void registerRpcSftpCreateFile(Nui::Window&, Nui::RpcHub& hub);
 
     // Sftp Files:
+    void registerRpcSftpAddDownloadOperation(Nui::Window&, Nui::RpcHub& hub);
 
   private:
     std::mutex passwordProvidersMutex_{};
     std::mutex addSessionMutex_{};
+    Persistence::StateHolder* stateHolder_{};
     std::unordered_map<Ids::SessionId, std::unique_ptr<SecureShell::Session>, Ids::IdHash> sessions_{};
     std::unordered_map<Ids::ChannelId, std::weak_ptr<SecureShell::Channel>, Ids::IdHash> channels_{};
-    struct SftpSession
-    {
-        std::weak_ptr<SecureShell::SftpSession> sftp{};
-        std::unordered_map<Ids::FileId, SecureShell::FileStream, Ids::IdHash> fileStreams{};
-
-        SftpSession(std::weak_ptr<SecureShell::SftpSession> sftp)
-            : sftp{std::move(sftp)}
-        {}
-    };
-    std::unordered_map<Ids::ChannelId, SftpSession, Ids::IdHash> sftpChannels_{};
+    std::unordered_map<Ids::ChannelId, std::weak_ptr<SecureShell::SftpSession>, Ids::IdHash> sftpChannels_{};
+    OperationQueue operationQueue_{};
     std::map<int, PasswordProvider*> passwordProviders_{};
     std::unique_ptr<std::thread> addSessionThread_{};
     std::vector<SecureShell::PasswordCacheEntry> pwCache_{};
diff --git a/backend/source/backend/CMakeLists.txt b/backend/source/backend/CMakeLists.txt
index 8cf06463..e0dad62a 100644
--- a/backend/source/backend/CMakeLists.txt
+++ b/backend/source/backend/CMakeLists.txt
@@ -42,13 +42,14 @@ include("${CMAKE_CURRENT_LIST_DIR}/../../../_cmake/dependencies/libssh.cmake")
 # Link backend of nui outside of emscripten
 target_link_libraries(
     backend
-    PRIVATE
+    PUBLIC
         nui-backend
         efsw-static
         Boost::filesystem
         Boost::asio
         Boost::system
         Boost::process
+        roar-include-only
         shared_data
         utility
         log
diff --git a/backend/source/backend/main.cpp b/backend/source/backend/main.cpp
index 152e87dc..c353d9c5 100644
--- a/backend/source/backend/main.cpp
+++ b/backend/source/backend/main.cpp
@@ -158,7 +158,7 @@ Main::Main(int const, char const* const* argv)
     , hub_{window_}
     , processes_{window_.getExecutor(), window_, hub_}
     , prompter_{hub_}
-    , sshSessionManager_{}
+    , sshSessionManager_{&stateHolder_}
     , shuttingDown_{false}
     , childSignalTimer_{window_.getExecutor()}
 {
diff --git a/backend/source/backend/sftp/operation_queue.cpp b/backend/source/backend/sftp/operation_queue.cpp
index e69de29b..7638890d 100644
--- a/backend/source/backend/sftp/operation_queue.cpp
+++ b/backend/source/backend/sftp/operation_queue.cpp
@@ -0,0 +1,68 @@
+#include <backend/sftp/operation_queue.hpp>
+
+#include <log/log.hpp>
+
+OperationQueue::OperationQueue()
+    : operations_{}
+{}
+void OperationQueue::start()
+{}
+void OperationQueue::pause()
+{}
+void OperationQueue::cancelAll()
+{}
+void OperationQueue::cancel(Ids::OperationId id)
+{}
+std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
+    Persistence::State const& state,
+    std::string const& sshSessionOptionsKey,
+    SecureShell::SftpSession& sftp,
+    Ids::OperationId id,
+    std::filesystem::path const& localPath,
+    std::filesystem::path const& remotePath)
+{
+    auto fut = sftp.openFile(remotePath, SecureShell::SftpSession::OpenType::Read, std::filesystem::perms::unknown);
+    if (fut.wait_for(std::chrono::seconds{5}) != std::future_status::ready)
+    {
+        Log::error("Failed to open remote sftp file: timeout");
+        return std::unexpected(Operation::Error{.type = Operation::ErrorType::OpenFailure});
+    }
+
+    const auto result = fut.get();
+    if (!result.has_value())
+    {
+        Log::error("Failed to open remote sftp file: {}", result.error().message);
+        return std::unexpected(Operation::Error{.type = Operation::ErrorType::SftpError, .sftpError = result.error()});
+    }
+
+    auto sessionOptsIter = state.sshSessionOptions.find(sshSessionOptionsKey);
+    if (sessionOptsIter == state.sshSessionOptions.end())
+    {
+        Log::error("No ssh session options found with key: {}", sshSessionOptionsKey);
+        return std::unexpected(Operation::Error{.type = Operation::ErrorType::InvalidOptionsKey});
+    }
+
+    auto sessionOpts = sessionOptsIter->second;
+    sessionOpts.sftpOptions.resolveWith(state.sftpOptions);
+    const auto& sftpOpts = sessionOpts.sftpOptions;
+    const auto transferOptions = sftpOpts->downloadOptions.value_or(Persistence::TransferOptions{});
+    const auto defaultOptions = DownloadOperation::DownloadOperationOptions{};
+
+    auto operation = std::make_unique<DownloadOperation>(
+        std::move(result).value(),
+        DownloadOperation::DownloadOperationOptions{
+            .remotePath = remotePath,
+            .localPath = localPath,
+            .tempFileSuffix = transferOptions.tempFileSuffix.value_or(defaultOptions.tempFileSuffix),
+            .mayOverwrite = transferOptions.mayOverwrite.value_or(defaultOptions.mayOverwrite),
+            .reserveSpace = transferOptions.reserveSpace.value_or(defaultOptions.reserveSpace),
+            .tryContinue = transferOptions.tryContinue.value_or(defaultOptions.tryContinue),
+            .inheritPermissions = transferOptions.inheritPermissions.value_or(defaultOptions.inheritPermissions),
+            .doCleanup = transferOptions.doCleanup.value_or(defaultOptions.doCleanup),
+            .permissions =
+                transferOptions.customPermissions ? transferOptions.customPermissions : defaultOptions.permissions,
+        });
+
+    operations_.emplace_back(id, std::move(operation));
+    return {};
+}
\ No newline at end of file
diff --git a/backend/source/backend/ssh_session_manager.cpp b/backend/source/backend/ssh_session_manager.cpp
index 0777a378..61be0711 100644
--- a/backend/source/backend/ssh_session_manager.cpp
+++ b/backend/source/backend/ssh_session_manager.cpp
@@ -59,7 +59,8 @@ int askPassDefault(char const* prompt, char* buf, std::size_t length, int, int,
     return -1;
 }
 
-SshSessionManager::SshSessionManager()
+SshSessionManager::SshSessionManager(Persistence::StateHolder* stateHolder)
+    : stateHolder_(stateHolder)
 {}
 
 SshSessionManager::~SshSessionManager()
@@ -311,9 +312,8 @@ void SshSessionManager::registerRpcChannelClose(Nui::Window&, Nui::RpcHub& hub)
                 }
                 else if (auto iter = sftpChannels_.find(channelId); iter != sftpChannels_.end())
                 {
-                    if (auto channel = iter->second.sftp.lock(); channel)
+                    if (auto channel = iter->second.lock(); channel)
                     {
-                        iter->second.fileStreams.clear();
                         channel->close();
                     }
                     sftpChannels_.erase(iter);
@@ -424,8 +424,8 @@ void SshSessionManager::registerRpcChannelPtyResize(Nui::Window&, Nui::RpcHub& h
                         // if (fut.wait_for(std::chrono::milliseconds{500}) != std::future_status::ready)
                         // {
                         //     Log::error("Failed to resize pty: timeout");
-                        //     hub->callRemote(responseId, nlohmann::json{{"error", "Failed to resize pty: timeout"}});
-                        //     return;
+                        //     hub->callRemote(responseId, nlohmann::json{{"error", "Failed to resize pty:
+                        //     timeout"}}); return;
                         // }
                         // const auto result = fut.get();
                         // if (result != 0)
@@ -488,7 +488,7 @@ void SshSessionManager::registerRpcSftpListDirectory(Nui::Window&, Nui::RpcHub&
                     return;
                 }
 
-                auto locked = channel->second.sftp.lock();
+                auto locked = channel->second.lock();
                 if (!locked)
                 {
                     Log::error("Failed to lock sftp channel with id: {}", channelId.value());
@@ -552,7 +552,7 @@ void SshSessionManager::registerRpcSftpCreateDirectory(Nui::Window&, Nui::RpcHub
                     return;
                 }
 
-                auto locked = channel->second.sftp.lock();
+                auto locked = channel->second.lock();
                 if (!locked)
                 {
                     Log::error("Failed to lock sftp channel with id: {}", channelId.value());
@@ -616,7 +616,7 @@ void SshSessionManager::registerRpcSftpCreateFile(Nui::Window&, Nui::RpcHub& hub
                     return;
                 }
 
-                auto locked = channel->second.sftp.lock();
+                auto locked = channel->second.lock();
                 if (!locked)
                 {
                     Log::error("Failed to lock sftp channel with id: {}", channelId.value());
@@ -651,6 +651,60 @@ void SshSessionManager::registerRpcSftpCreateFile(Nui::Window&, Nui::RpcHub& hub
         });
 }
 
+void SshSessionManager::registerRpcSftpAddDownloadOperation(Nui::Window&, Nui::RpcHub& hub)
+{
+    hub.registerFunction(
+        "SshSessionManager::sftp::addDownload",
+        [this, hub = &hub](
+            std::string const& responseId,
+            std::string const& sessionIdString,
+            std::string const& channelIdString,
+            std::string const& newOperationIdString,
+            std::string const& sshSessionOptionsKey,
+            std::string const& localPath,
+            std::string const& remotePath) {
+            auto const& state = stateHolder_->stateCache();
+
+            const auto sessionId = Ids::makeSessionId(sessionIdString);
+            const auto channelId = Ids::makeChannelId(channelIdString);
+
+            if (sessions_.find(sessionId) == sessions_.end())
+            {
+                Log::error("No session found with id: {}", sessionId.value());
+                hub->callRemote(responseId, nlohmann::json{{"error", "No session found with id"}});
+                return;
+            }
+
+            auto channel = sftpChannels_.find(channelId);
+            if (channel == sftpChannels_.end())
+            {
+                Log::error("No sftp channel found with id: {}", channelId.value());
+                hub->callRemote(responseId, nlohmann::json{{"error", "No sftp channel found with id"}});
+                return;
+            }
+
+            auto sftp = channel->second.lock();
+            if (!sftp)
+            {
+                Log::error("Failed to lock sftp channel with id: {}", channelId.value());
+                hub->callRemote(responseId, nlohmann::json{{"error", "Failed to lock sftp channel"}});
+                return;
+            }
+
+            const auto result = operationQueue_.addDownloadOperation(
+                state, sshSessionOptionsKey, *sftp, Ids::makeOperationId(newOperationIdString), localPath, remotePath);
+
+            if (!result.has_value())
+            {
+                Log::error("Failed to add download operation: {}", result.error().toString());
+                hub->callRemote(responseId, nlohmann::json{{"error", result.error().toString()}});
+                return;
+            }
+
+            hub->callRemote(responseId, nlohmann::json{{"success", true}});
+        });
+}
+
 void SshSessionManager::registerRpc(Nui::Window& wnd, Nui::RpcHub& hub)
 {
     registerRpcConnect(wnd, hub);
@@ -664,6 +718,8 @@ void SshSessionManager::registerRpc(Nui::Window& wnd, Nui::RpcHub& hub)
     registerRpcSftpListDirectory(wnd, hub);
     registerRpcSftpCreateDirectory(wnd, hub);
     registerRpcSftpCreateFile(wnd, hub);
+
+    registerRpcSftpAddDownloadOperation(wnd, hub);
 }
 
 void SshSessionManager::addPasswordProvider(int priority, PasswordProvider* provider)
diff --git a/persistence/include/persistence/state/sftp_options.hpp b/persistence/include/persistence/state/sftp_options.hpp
new file mode 100644
index 00000000..e9775c87
--- /dev/null
+++ b/persistence/include/persistence/state/sftp_options.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <persistence/state_core.hpp>
+
+#include <string>
+#include <optional>
+#include <filesystem>
+
+namespace Persistence
+{
+    struct TransferOptions
+    {
+        std::optional<std::string> tempFileSuffix{std::nullopt};
+        std::optional<bool> mayOverwrite{std::nullopt};
+        std::optional<bool> reserveSpace{std::nullopt};
+        std::optional<bool> tryContinue{std::nullopt};
+        std::optional<bool> inheritPermissions{std::nullopt};
+        std::optional<bool> doCleanup{std::nullopt};
+        std::optional<std::filesystem::perms> customPermissions{std::nullopt};
+
+        void useDefaultsFrom(TransferOptions const& other);
+    };
+    void to_json(nlohmann::json& j, TransferOptions const& options);
+    void from_json(nlohmann::json const& j, TransferOptions& options);
+
+    struct SftpOptions
+    {
+        std::optional<TransferOptions> downloadOptions{};
+        std::optional<TransferOptions> uploadOptions{};
+
+        void useDefaultsFrom(SftpOptions const& other);
+    };
+    void to_json(nlohmann::json& j, SftpOptions const& options);
+    void from_json(nlohmann::json const& j, SftpOptions& options);
+}
\ No newline at end of file
diff --git a/persistence/include/persistence/state/ssh_session_options.hpp b/persistence/include/persistence/state/ssh_session_options.hpp
index e972ffaf..0deecd41 100644
--- a/persistence/include/persistence/state/ssh_session_options.hpp
+++ b/persistence/include/persistence/state/ssh_session_options.hpp
@@ -2,6 +2,7 @@
 
 #include <persistence/state_core.hpp>
 #include <persistence/state/ssh_options.hpp>
+#include <persistence/state/sftp_options.hpp>
 #include <persistence/reference.hpp>
 
 #include <string>
@@ -21,6 +22,7 @@ namespace Persistence
         std::optional<std::string> defaultDirectory{std::nullopt};
 
         Referenceable<SshOptions> sshOptions{};
+        Referenceable<SftpOptions> sftpOptions{};
         void useDefaultsFrom(SshSessionOptions const& other);
     };
     void to_json(nlohmann::json& j, SshSessionOptions const& options);
diff --git a/persistence/include/persistence/state/state.hpp b/persistence/include/persistence/state/state.hpp
index add9ca7e..7743ed91 100644
--- a/persistence/include/persistence/state/state.hpp
+++ b/persistence/include/persistence/state/state.hpp
@@ -16,6 +16,7 @@ namespace Persistence
         std::unordered_map<std::string, TerminalOptions> terminalOptions{};
         std::unordered_map<std::string, Termios> termios{};
         std::unordered_map<std::string, SshOptions> sshOptions{};
+        std::unordered_map<std::string, SftpOptions> sftpOptions{};
         std::unordered_map<std::string, TerminalEngine> sessions{};
         std::unordered_map<std::string, SshSessionOptions> sshSessionOptions{};
         UiOptions uiOptions{};
diff --git a/persistence/source/persistence/CMakeLists.txt b/persistence/source/persistence/CMakeLists.txt
index 0e06eeb9..d4c1c7b1 100644
--- a/persistence/source/persistence/CMakeLists.txt
+++ b/persistence/source/persistence/CMakeLists.txt
@@ -2,6 +2,7 @@ add_library(
     persistence
     STATIC
         state/ssh_options.cpp
+        state/sftp_options.cpp
         state/ssh_session_options.cpp
         state/state.cpp
         state/terminal_engine.cpp
diff --git a/persistence/source/persistence/state/sftp_options.cpp b/persistence/source/persistence/state/sftp_options.cpp
new file mode 100644
index 00000000..30f42004
--- /dev/null
+++ b/persistence/source/persistence/state/sftp_options.cpp
@@ -0,0 +1,78 @@
+#include <persistence/state/sftp_options.hpp>
+
+namespace Persistence
+{
+    void TransferOptions::useDefaultsFrom(TransferOptions const& other)
+    {
+        if (!tempFileSuffix)
+            tempFileSuffix = other.tempFileSuffix;
+        if (!mayOverwrite)
+            mayOverwrite = other.mayOverwrite;
+        if (!reserveSpace)
+            reserveSpace = other.reserveSpace;
+        if (!tryContinue)
+            tryContinue = other.tryContinue;
+        if (!inheritPermissions)
+            inheritPermissions = other.inheritPermissions;
+        if (!doCleanup)
+            doCleanup = other.doCleanup;
+        if (!customPermissions)
+            customPermissions = other.customPermissions;
+    }
+    void to_json(nlohmann::json& j, TransferOptions const& options)
+    {
+        if (options.tempFileSuffix)
+            j["tempFileSuffix"] = *options.tempFileSuffix;
+        if (options.mayOverwrite)
+            j["mayOverwrite"] = *options.mayOverwrite;
+        if (options.reserveSpace)
+            j["reserveSpace"] = *options.reserveSpace;
+        if (options.tryContinue)
+            j["tryContinue"] = *options.tryContinue;
+        if (options.inheritPermissions)
+            j["inheritPermissions"] = *options.inheritPermissions;
+        if (options.doCleanup)
+            j["doCleanup"] = *options.doCleanup;
+        if (options.customPermissions)
+            j["customPermissions"] = static_cast<unsigned int>(*options.customPermissions);
+    }
+    void from_json(nlohmann::json const& j, TransferOptions& options)
+    {
+        if (j.contains("tempFileSuffix"))
+            options.tempFileSuffix = j["tempFileSuffix"].template get<std::string>();
+        if (j.contains("mayOverwrite"))
+            options.mayOverwrite = j["mayOverwrite"].get<bool>();
+        if (j.contains("reserveSpace"))
+            options.reserveSpace = j["reserveSpace"].get<bool>();
+        if (j.contains("tryContinue"))
+            options.tryContinue = j["tryContinue"].get<bool>();
+        if (j.contains("inheritPermissions"))
+            options.inheritPermissions = j["inheritPermissions"].get<bool>();
+        if (j.contains("doCleanup"))
+            options.doCleanup = j["doCleanup"].get<bool>();
+        if (j.contains("customPermissions"))
+            options.customPermissions = std::filesystem::perms{j["customPermissions"].template get<unsigned int>()};
+    }
+
+    void to_json(nlohmann::json& j, SftpOptions const& options)
+    {
+        if (options.downloadOptions)
+            j["downloadOptions"] = *options.downloadOptions;
+        if (options.uploadOptions)
+            j["uploadOptions"] = *options.uploadOptions;
+    }
+    void from_json(nlohmann::json const& j, SftpOptions& options)
+    {
+        if (j.contains("downloadOptions"))
+            options.downloadOptions = j["downloadOptions"].get<TransferOptions>();
+        if (j.contains("uploadOptions"))
+            options.uploadOptions = j["uploadOptions"].get<TransferOptions>();
+    }
+    void SftpOptions::useDefaultsFrom(SftpOptions const& other)
+    {
+        if (!downloadOptions)
+            downloadOptions = other.downloadOptions;
+        if (!uploadOptions)
+            uploadOptions = other.uploadOptions;
+    }
+}
\ No newline at end of file
diff --git a/persistence/source/persistence/state/ssh_session_options.cpp b/persistence/source/persistence/state/ssh_session_options.cpp
index e6db018a..d408ac8b 100644
--- a/persistence/source/persistence/state/ssh_session_options.cpp
+++ b/persistence/source/persistence/state/ssh_session_options.cpp
@@ -17,6 +17,7 @@ namespace Persistence
         if (!defaultDirectory.has_value())
             defaultDirectory = other.defaultDirectory;
 
+        sftpOptions.useDefaultsFrom(other.sftpOptions.value());
         sshOptions.useDefaultsFrom(other.sshOptions.value());
     }
 
@@ -31,6 +32,7 @@ namespace Persistence
         TO_JSON_OPTIONAL(j, options, defaultDirectory);
         j["openSftpByDefault"] = options.openSftpByDefault;
         j["sshOptions"] = options.sshOptions;
+        j["sftpOptions"] = options.sftpOptions;
     }
     void from_json(nlohmann::json const& j, SshSessionOptions& options)
     {
@@ -47,5 +49,7 @@ namespace Persistence
             j.at("sshOptions").get_to(options.sshOptions);
         if (j.contains("openSftpByDefault"))
             j.at("openSftpByDefault").get_to(options.openSftpByDefault);
+        if (j.contains("sftpOptions"))
+            j.at("sftpOptions").get_to(options.sftpOptions);
     }
 }
\ No newline at end of file
diff --git a/persistence/source/persistence/state/state.cpp b/persistence/source/persistence/state/state.cpp
index c6119d5e..0e23156e 100644
--- a/persistence/source/persistence/state/state.cpp
+++ b/persistence/source/persistence/state/state.cpp
@@ -13,6 +13,7 @@ namespace Persistence
         j["sessions"] = state.sessions;
         j["termios"] = state.termios;
         j["sshOptions"] = state.sshOptions;
+        j["sftpOptions"] = state.sftpOptions;
         j["sshSessionOptions"] = state.sshSessionOptions;
         j["uiOptions"] = state.uiOptions;
         j["logLevel"] = [&]() {
@@ -33,6 +34,9 @@ namespace Persistence
         if (j.contains("sshOptions"))
             j.at("sshOptions").get_to(state.sshOptions);
 
+        if (j.contains("sftpOptions"))
+            j.at("sftpOptions").get_to(state.sftpOptions);
+
         if (j.contains("sshSessionOptions"))
             j.at("sshSessionOptions").get_to(state.sshSessionOptions);
 
diff --git a/ssh/source/ssh/CMakeLists.txt b/ssh/source/ssh/CMakeLists.txt
index a0e36b57..1292dd21 100644
--- a/ssh/source/ssh/CMakeLists.txt
+++ b/ssh/source/ssh/CMakeLists.txt
@@ -6,6 +6,7 @@ add_library(
         channel.cpp
         sftp_session.cpp
         file_stream.cpp
+        file_information.cpp
 )
 
 target_include_directories(
diff --git a/ssh/test/ssh/utility/node.cpp b/ssh/test/ssh/utility/node.cpp
index 5383945f..c1492a8b 100644
--- a/ssh/test/ssh/utility/node.cpp
+++ b/ssh/test/ssh/utility/node.cpp
@@ -89,7 +89,7 @@ namespace SecureShell::Test
 
     std::shared_ptr<NodeProcessResult> nodeProcess(
         boost::asio::any_io_executor executor,
-        TemporaryDirectory const& isolateDirectory,
+        Utility::TemporaryDirectory const& isolateDirectory,
         std::string const& program)
     {
         using namespace std::string_literals;
diff --git a/ssh/test/ssh/utility/node.hpp b/ssh/test/ssh/utility/node.hpp
index c94bac29..dda85759 100644
--- a/ssh/test/ssh/utility/node.hpp
+++ b/ssh/test/ssh/utility/node.hpp
@@ -42,6 +42,6 @@ namespace SecureShell::Test
 
     std::shared_ptr<NodeProcessResult> nodeProcess(
         boost::asio::any_io_executor executor,
-        TemporaryDirectory const& isolateDirectory,
+        Utility::TemporaryDirectory const& isolateDirectory,
         std::string const& program);
 }
\ No newline at end of file

From 7db12eac16c8fa4e21280566565e98997db82212 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Tue, 11 Mar 2025 19:41:31 +0100
Subject: [PATCH 13/42] Removed unused code.

---
 persistence/source/persistence/state/termios.cpp |  2 ++
 ssh/test/ssh/utility/node.cpp                    | 16 ----------------
 2 files changed, 2 insertions(+), 16 deletions(-)

diff --git a/persistence/source/persistence/state/termios.cpp b/persistence/source/persistence/state/termios.cpp
index 0aeda704..7bcdd839 100644
--- a/persistence/source/persistence/state/termios.cpp
+++ b/persistence/source/persistence/state/termios.cpp
@@ -9,10 +9,12 @@ namespace Persistence
 {
     namespace
     {
+#ifndef _WIN32
         bool unpackBoolOptional(std::optional<bool> const& value)
         {
             return value.has_value() ? value.value() : false;
         }
+#endif
     }
 
     unsigned int Termios::InputFlags::assemble() const
diff --git a/ssh/test/ssh/utility/node.cpp b/ssh/test/ssh/utility/node.cpp
index c1492a8b..e4b136d9 100644
--- a/ssh/test/ssh/utility/node.cpp
+++ b/ssh/test/ssh/utility/node.cpp
@@ -108,22 +108,6 @@ namespace SecureShell::Test
             boost::asio::readable_pipe{executor},
             nullptr);
 
-#ifdef _WIN32
-        const auto nodeShell = MSYS2_BASH;
-        const auto nodeCommandArgs = std::vector<std::string>{
-            "--login",
-            "-i",
-            "-c",
-            "\"cd "s + isolateDirectory.path().generic_string() + " && node ./main.mjs --log-file=./log.txt\"",
-        };
-#else
-        const auto nodeShell = "/bin/bash";
-        const auto nodeCommandArgs = std::vector<std::string>{
-            "-c",
-            "cd "s + isolateDirectory.path().generic_string() + " && node ./main.mjs --log-file=./log.txt",
-        };
-#endif
-
         result->mainModule = std::make_unique<boost::process::v2::process>(
             executor,
             node,

From d7872510cf7e7d979e9cdf3989591e9f78f18f60 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <tim06tr@gmail.com>
Date: Tue, 11 Mar 2025 19:44:23 +0100
Subject: [PATCH 14/42] Removed accidentally added clangd file.

---
 .clangd | 18 ------------------
 1 file changed, 18 deletions(-)
 delete mode 100644 .clangd

diff --git a/.clangd b/.clangd
deleted file mode 100644
index 9342164e..00000000
--- a/.clangd
+++ /dev/null
@@ -1,18 +0,0 @@
-If:
-  PathMatch: "(ssh\/.*)|(ids\/.*)|(backend\/.*)|(dependencies\/Nui\/.*)"
-  PathExclude: "(dependencies\/Nui\/nui\/include\/nui\/frontend.*)"
-CompileFlags:
-  CompilationDatabase: "build/clang_debug"
-  Add:
-    - "-IE:/DevelopmentFast/scp/build/clang_debug/_deps/emscripten-src/upstream/emscripten/system/include"
-    - "-ID:/msys2/clang64/include"
-    - "-D__cplusplus=202302L"
----
-If:
-  PathMatch: "(frontend\/.*)|(nui-file-explorer\/.*)|(dependencies\/Nui\/nui\/include\/nui\/frontend.*)"
-CompileFlags:
-  CompilationDatabase: "build/clang_debug/module_nui-scp"
-  Add:
-    - "-D__EMSCRIPTEN__"
-    - "-IE:/DevelopmentFast/scp/build/clang_debug/_deps/emscripten-src/upstream/emscripten/system/include"
-    - "-ID:/msys2/clang64/include"

From 2c0b509a5e26043e374c8d5b1a3758e072409bdc Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Fri, 14 Mar 2025 19:56:24 +0100
Subject: [PATCH 15/42] Added handlers for file grid context menu.

---
 .../include/frontend/components/ui5-list.hpp  |  24 ++
 .../frontend/dialog/confirm_dialog.hpp        |  30 ++-
 .../include/frontend/dialog/input_dialog.hpp  |  16 +-
 .../source/frontend/dialog/confirm_dialog.cpp |  76 ++++--
 .../source/frontend/dialog/input_dialog.cpp   |  17 +-
 .../frontend/dialog/password_prompter.cpp     |  11 +-
 frontend/source/frontend/session.cpp          | 226 ++++++++++++++----
 .../session_components/session_options.cpp    |  44 +++-
 frontend/source/frontend/toolbar.cpp          |  11 +-
 .../include/nui-file-explorer/file_grid.hpp   |  63 +++++
 .../source/nui-file-explorer/file_grid.cpp    | 149 +++++++++++-
 nui-file-explorer/styles/file_grid.css        |  16 ++
 .../persistence/state/ssh_session_options.hpp |   2 +
 .../persistence/state/terminal_engine.hpp     |   1 +
 .../persistence/state/ssh_session_options.cpp |   4 +
 .../persistence/state/terminal_engine.cpp     |   2 +
 ssh/source/ssh/session.cpp                    |  12 +
 17 files changed, 588 insertions(+), 116 deletions(-)
 create mode 100644 frontend/include/frontend/components/ui5-list.hpp

diff --git a/frontend/include/frontend/components/ui5-list.hpp b/frontend/include/frontend/components/ui5-list.hpp
new file mode 100644
index 00000000..efdbe1fd
--- /dev/null
+++ b/frontend/include/frontend/components/ui5-list.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <nui/frontend/dom/element.hpp>
+
+// clang-format off
+
+#ifdef NUI_INLINE
+// @inline(js, ui5-list)
+js_import "@ui5/webcomponents/dist/List.js";
+js_import "@ui5/webcomponents/dist/ListItemStandard.js";
+js_import "@ui5/webcomponents/dist/ListItemCustom.js";
+js_import "@ui5/webcomponents/dist/ListItemGroup.js";
+// @endinline
+#endif
+
+// clang-format on
+
+namespace ui5
+{
+    NUI_MAKE_HTML_ELEMENT_RENAME(list, "ui5-list")
+    NUI_MAKE_HTML_ELEMENT_RENAME(li, "ui5-li")
+    NUI_MAKE_HTML_ELEMENT_RENAME(li_custom, "ui5-li-custom")
+    NUI_MAKE_HTML_ELEMENT_RENAME(li_group, "ui5-li-group")
+}
diff --git a/frontend/include/frontend/dialog/confirm_dialog.hpp b/frontend/include/frontend/dialog/confirm_dialog.hpp
index fb1e1291..a72a3ae2 100644
--- a/frontend/include/frontend/dialog/confirm_dialog.hpp
+++ b/frontend/include/frontend/dialog/confirm_dialog.hpp
@@ -20,6 +20,11 @@ class ConfirmDialog
         No = 0b0000'1000,
     };
 
+    friend auto operator|(Button lhs, Button rhs)
+    {
+        return static_cast<Button>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs));
+    }
+
     enum class State
     {
         None,
@@ -30,12 +35,25 @@ class ConfirmDialog
     };
 
     Nui::ElementRenderer operator()();
-    void open(
-        State state,
-        std::string const& headerText,
-        std::string const& text,
-        Button buttons = Button::Ok,
-        std::function<void(Button buttonPressed)> const& onClose = [](auto) {});
+
+    struct OpenOptions
+    {
+        State state = State::Information;
+        std::string headerText = "";
+        std::string text = "";
+        Button buttons = Button::Ok;
+        struct ListElement
+        {
+            std::string text;
+            std::optional<std::string> description = std::nullopt;
+            std::optional<std::string> additionalText = std::nullopt;
+            std::optional<State> additionalState = std::nullopt;
+        };
+        std::vector<ListElement> listItems = {};
+        std::function<void(Button buttonPressed)> onClose = [](auto) {};
+    };
+
+    void open(OpenOptions const& options);
 
   private:
     void close(Button button);
diff --git a/frontend/include/frontend/dialog/input_dialog.hpp b/frontend/include/frontend/dialog/input_dialog.hpp
index 3f8980a0..7871235c 100644
--- a/frontend/include/frontend/dialog/input_dialog.hpp
+++ b/frontend/include/frontend/dialog/input_dialog.hpp
@@ -12,12 +12,16 @@ class InputDialog
     ROAR_PIMPL_SPECIAL_FUNCTIONS(InputDialog);
 
     Nui::ElementRenderer operator()();
-    void open(
-        std::string const& whatFor,
-        std::string const& prompt,
-        std::string const& headerText,
-        bool isPassword,
-        std::function<void(std::optional<std::string> const&)> const& onConfirm);
+
+    struct OpenOptions
+    {
+        std::string whatFor{};
+        std::string prompt{};
+        std::string headerText{};
+        bool isPassword{false};
+        std::function<void(std::optional<std::string> const&)> onConfirm;
+    };
+    void open(OpenOptions const& options);
 
   private:
     void closeDialog(std::optional<std::string> const& password);
diff --git a/frontend/source/frontend/dialog/confirm_dialog.cpp b/frontend/source/frontend/dialog/confirm_dialog.cpp
index f242add3..86b2a31c 100644
--- a/frontend/source/frontend/dialog/confirm_dialog.cpp
+++ b/frontend/source/frontend/dialog/confirm_dialog.cpp
@@ -1,5 +1,6 @@
 #include <frontend/dialog/confirm_dialog.hpp>
 #include <frontend/components/ui5-text.hpp>
+#include <frontend/components/ui5-list.hpp>
 #include <log/log.hpp>
 
 #include <ui5/components/dialog.hpp>
@@ -10,6 +11,26 @@
 #include <nui/frontend/elements.hpp>
 #include <nui/frontend/dom/basic_element.hpp>
 
+namespace
+{
+    std::string stateToString(ConfirmDialog::State state)
+    {
+        switch (state)
+        {
+            case ConfirmDialog::State::Positive:
+                return "Positive";
+            case ConfirmDialog::State::Critical:
+                return "Critical";
+            case ConfirmDialog::State::Negative:
+                return "Negative";
+            case ConfirmDialog::State::Information:
+                return "Information";
+            default:
+                return "None";
+        }
+    }
+}
+
 struct ConfirmDialog::Implementation
 {
     std::string id;
@@ -19,6 +40,7 @@ struct ConfirmDialog::Implementation
     Nui::Observed<std::string> headerText;
     Nui::Observed<std::string> text;
     Nui::Observed<Button> buttons;
+    Nui::Observed<std::vector<OpenOptions::ListElement>> listItems;
 
     Implementation(std::string id)
         : id{std::move(id)}
@@ -27,6 +49,8 @@ struct ConfirmDialog::Implementation
         , state{}
         , headerText{}
         , text{}
+        , buttons{}
+        , listItems{}
     {}
 };
 
@@ -34,23 +58,19 @@ ConfirmDialog::ConfirmDialog(std::string id)
     : impl_{std::make_unique<Implementation>(id)}
 {}
 
-void ConfirmDialog::open(
-    State state,
-    std::string const& headerText,
-    std::string const& text,
-    Button buttons,
-    std::function<void(Button buttonPressed)> const& onClose)
+void ConfirmDialog::open(OpenOptions const& options)
 {
-    impl_->onClose = onClose;
-    impl_->state = state;
-    impl_->headerText = headerText;
-    impl_->text = text;
-    impl_->buttons = buttons;
+    impl_->onClose = options.onClose;
+    impl_->state = options.state;
+    impl_->headerText = options.headerText;
+    impl_->text = options.text;
+    impl_->buttons = options.buttons;
+    impl_->listItems = options.listItems;
     Nui::globalEventContext.executeActiveEventsImmediately();
 
     if (auto diag = impl_->dialog.lock(); diag)
     {
-        diag->val().set("header-text", headerText);
+        diag->val().set("header-text", options.headerText);
         diag->val().set("open", true);
     }
 }
@@ -78,20 +98,34 @@ Nui::ElementRenderer ConfirmDialog::operator()()
     return ui5::dialog{
         id = "ConfirmDialog_" + impl_->id,
         "state"_prop = observe(impl_->state).generate([this](){
-            switch (impl_->state.value())
-            {
-                case State::Positive: return "Positive";
-                case State::Critical: return "Critical";
-                case State::Negative: return "Negative";
-                case State::Information: return "Information";
-                default: return "None";
-            }
+            return stateToString(impl_->state.value());
         }),
         "headerText"_prop = impl_->headerText,
         reference = impl_->dialog,
     }(
         section{}(
-            ui5::text{}(impl_->text)
+            ui5::text{
+                style = "margin-bottom: 10px;"
+            }(impl_->text),
+            ui5::list{
+                style = "max-height: 500px; overflow-y: auto;"
+            }(
+                impl_->listItems.map([](auto, auto const& element) {
+                    const auto additionalTextState = [&element]() -> std::optional<std::string> {
+                        if (element.additionalState)
+                            return stateToString(element.additionalState.value());
+                        return std::nullopt;
+                    }();
+
+                    return ui5::li{
+                        "description"_attr = element.description,
+                        "additional-text"_attr = element.additionalText,
+                        "additional-text-state"_attr = additionalTextState
+                    }(
+                        element.text
+                    );
+                })
+            )
         ),
         div{
             "slot"_prop = "footer",
diff --git a/frontend/source/frontend/dialog/input_dialog.cpp b/frontend/source/frontend/dialog/input_dialog.cpp
index 50ce21a2..cc9b7726 100644
--- a/frontend/source/frontend/dialog/input_dialog.cpp
+++ b/frontend/source/frontend/dialog/input_dialog.cpp
@@ -32,17 +32,12 @@ InputDialog::InputDialog(std::string id)
     : impl_{std::make_unique<Implementation>(id)}
 {}
 
-void InputDialog::open(
-    std::string const& whatFor,
-    std::string const& prompt,
-    std::string const& headerText,
-    bool isPassword,
-    std::function<void(std::optional<std::string> const&)> const& onConfirm)
+void InputDialog::open(OpenOptions const& options)
 {
-    impl_->onConfirm = onConfirm;
-    impl_->headerText = headerText;
-    impl_->isPassword = isPassword;
-    impl_->whatFor = whatFor;
+    impl_->onConfirm = options.onConfirm;
+    impl_->headerText = options.headerText;
+    impl_->isPassword = options.isPassword;
+    impl_->whatFor = options.whatFor;
     Nui::globalEventContext.executeActiveEventsImmediately();
 
     if (auto input = impl_->input.lock())
@@ -52,7 +47,7 @@ void InputDialog::open(
 
     if (auto diag = impl_->dialog.lock(); diag)
     {
-        diag->val().set("header-text", whatFor + ": " + prompt);
+        diag->val().set("header-text", options.whatFor + ": " + options.prompt);
         diag->val().set("open", true);
     }
 }
diff --git a/frontend/source/frontend/dialog/password_prompter.cpp b/frontend/source/frontend/dialog/password_prompter.cpp
index f6935cc6..4ec03086 100644
--- a/frontend/source/frontend/dialog/password_prompter.cpp
+++ b/frontend/source/frontend/dialog/password_prompter.cpp
@@ -21,8 +21,15 @@ PasswordPrompter::PasswordPrompter()
 {
     Nui::RpcClient::registerFunction(
         "PasswordPrompter::prompt", [this](std::string const& whatFor, std::string const& prompt) {
-            impl_->dialog.open(whatFor, prompt, "Enter Password", true, [](std::optional<std::string> const& password) {
-                Nui::RpcClient::call("PasswordPrompter::promptDone", password.value_or(""));
+            impl_->dialog.open({
+                .whatFor = whatFor,
+                .prompt = prompt,
+                .headerText = "Enter Password",
+                .isPassword = true,
+                .onConfirm =
+                    [](std::optional<std::string> const& password) {
+                        Nui::RpcClient::call("PasswordPrompter::promptDone", password.value_or(""));
+                    },
             });
         });
 }
diff --git a/frontend/source/frontend/session.cpp b/frontend/source/frontend/session.cpp
index dd94bd2f..42ce16ec 100644
--- a/frontend/source/frontend/session.cpp
+++ b/frontend/source/frontend/session.cpp
@@ -50,7 +50,7 @@ struct Session::Implementation
     Nui::Observed<Persistence::TerminalOptions> options;
 
     // Dialogs:
-    InputDialog* newItemAskDialog;
+    InputDialog* inputDialog;
     ConfirmDialog* confirmDialog;
 
     // Operation Queue for File Explorer
@@ -87,7 +87,7 @@ struct Session::Implementation
         Persistence::UiOptions uiOptions,
         std::string initialName,
         std::optional<std::string> layoutName,
-        InputDialog* newItemAskDialog,
+        InputDialog* inputDialog,
         ConfirmDialog* confirmDialog,
         std::function<void(Session const*)> closeSelf,
         bool visible)
@@ -101,7 +101,7 @@ struct Session::Implementation
         , uiOptions{uiOptions}
         , engine{std::move(engine)}
         , options{this->engine.terminalOptions.value()}
-        , newItemAskDialog{newItemAskDialog}
+        , inputDialog{inputDialog}
         , confirmDialog{confirmDialog}
         , operationQueue{this->stateHolder, this->events, this->initialName, this->id, this->confirmDialog}
         , operationQueueElement{}
@@ -166,7 +166,7 @@ Session::Session(
     Persistence::UiOptions uiOptions,
     std::string initialName,
     std::optional<std::string> layoutName,
-    InputDialog* newItemAskDialog,
+    InputDialog* inputDialog,
     ConfirmDialog* confirmDialog,
     std::function<void(Session const*)> closeSelf,
     bool visible)
@@ -177,7 +177,7 @@ Session::Session(
           std::move(uiOptions),
           std::move(initialName),
           std::move(layoutName),
-          newItemAskDialog,
+          inputDialog,
           confirmDialog,
           std::move(closeSelf),
           visible)}
@@ -216,63 +216,192 @@ void Session::setupFileGrid()
         navigateTo(impl_->currentPath / item.path);
     });
 
+    impl_->fileGrid.onDelete([this](auto const& items) {
+        using namespace std::string_literals;
+
+        Log::info("Delete items requested: {}", items.size());
+        for (const auto& item : items)
+        {
+            Log::info("Item: {}", item.path.generic_string());
+        }
+
+        if (items.empty())
+        {
+            Log::error("No items selected for deletion");
+            return;
+        }
+
+        const auto itemSize = items.size();
+        std::string confirmText = fmt::format(
+            "Are you sure you want to delete {} {} {}?:",
+            itemSize > 1 ? "the following" : items.front().path.generic_string(),
+            itemSize == 1 ? ""s : std::to_string(itemSize),
+            itemSize == 1 ? "" : "items");
+
+        std::vector<ConfirmDialog::OpenOptions::ListElement> listItems;
+        for (const auto& item : items)
+        {
+            listItems.push_back({item.path.generic_string(), ""});
+        }
+
+        impl_->confirmDialog->open(
+            {.state = ConfirmDialog::State::Information,
+             .headerText = "Delete Items?",
+             .text = confirmText,
+             .buttons = ConfirmDialog::Button::Yes | ConfirmDialog::Button::No,
+             .listItems = listItems,
+             .onClose = [items](ConfirmDialog::Button button) {
+                 if (button != ConfirmDialog::Button::Yes)
+                 {
+                     Log::info("Delete items cancelled");
+                     return;
+                 }
+
+                 Log::info("Deleting items");
+                 // TODO: ...
+             }});
+    });
+
+    impl_->fileGrid.onDownload([this](auto const& items) {
+        Log::info("Download items requested: {}", items.size());
+        for (const auto& item : items)
+        {
+            Log::info("Item: {}", item.path.generic_string());
+        }
+
+        if (items.empty())
+        {
+            Log::error("No items selected for download");
+            return;
+        }
+
+        const auto itemsSize = items.size();
+        std::string confirmText = fmt::format(
+            "Are you sure you want to download {} {} {}?:",
+            itemsSize > 1 ? "the following" : items.front().path.generic_string(),
+            itemsSize == 1 ? "" : std::to_string(itemsSize),
+            itemsSize == 1 ? "" : "items");
+
+        std::vector<ConfirmDialog::OpenOptions::ListElement> listItems;
+        for (const auto& item : items)
+        {
+            listItems.push_back({item.path.generic_string(), ""});
+        }
+
+        impl_->confirmDialog->open(
+            {.state = ConfirmDialog::State::Information,
+             .headerText = "Download Items?",
+             .text = confirmText,
+             .buttons = ConfirmDialog::Button::Yes | ConfirmDialog::Button::No,
+             .listItems = listItems,
+             .onClose = [this, items](ConfirmDialog::Button button) {
+                 if (button != ConfirmDialog::Button::Yes)
+                 {
+                     Log::info("Download items cancelled");
+                     return;
+                 }
+
+                 Log::info("Downloading items");
+                 // TODO: ...
+             }});
+    });
+
+    impl_->fileGrid.onError([this](auto const& message) {
+        Log::error("File grid error: {}", message);
+        impl_->confirmDialog->open({
+            .state = ConfirmDialog::State::Negative,
+            .headerText = "File Grid Error",
+            .text = message,
+            .buttons = ConfirmDialog::Button::Ok,
+        });
+    });
+
+    impl_->fileGrid.onRename([this](auto const& item) {
+        Log::info("Rename item requested: {}", item.path.generic_string());
+
+        impl_->inputDialog->open({
+            .whatFor = "Rename",
+            .prompt = "Enter the new name for " + item.path.filename().string(),
+            .headerText = "Rename " + item.path.filename().string(),
+            .isPassword = false,
+            .onConfirm =
+                [this, item](std::optional<std::string> const& name) {
+                    if (!name)
+                        return;
+
+                    Log::info("Renaming item to: {}", *name);
+                    // TODO: ...
+                },
+        });
+    });
+
+    impl_->fileGrid.onProperties([this](auto const& item) {
+        Log::info("Properties requested: {}", item.path.generic_string());
+
+        // TODO: ...
+    });
+
     impl_->fileGrid.onNewItem([this](auto type) {
         Log::info("New item requested: {}", static_cast<int>(type));
         if (type == NuiFileExplorer::FileGrid::Item::Type::Directory)
         {
-            impl_->newItemAskDialog->open(
-                "New directory",
-                "Enter the name of the new directory",
-                "Create a new directory",
-                false,
-                [this](std::optional<std::string> const& name) {
-                    if (!name)
-                        return;
+            impl_->inputDialog->open({
+                .whatFor = "New directory",
+                .prompt = "Enter the name of the new directory",
+                .headerText = "Create a new directory",
+                .isPassword = false,
+                .onConfirm =
+                    [this](std::optional<std::string> const& name) {
+                        if (!name)
+                            return;
 
-                    Log::info("Creating new directory: {}", *name);
-                    if (name->find('/') != std::string::npos)
-                    {
-                        Log::error("Invalid directory name (cannot contain slashes): {}", *name);
-                        return;
-                    }
-                    impl_->fileEngine->createDirectory(impl_->currentPath / *name, [this](bool success) {
-                        if (!success)
+                        Log::info("Creating new directory: {}", *name);
+                        if (name->find('/') != std::string::npos)
                         {
-                            Log::error("Failed to create directory");
+                            Log::error("Invalid directory name (cannot contain slashes): {}", *name);
                             return;
                         }
-                        // Refresh list from server:
-                        navigateTo(impl_->currentPath);
-                    });
-                });
+                        impl_->fileEngine->createDirectory(impl_->currentPath / *name, [this](bool success) {
+                            if (!success)
+                            {
+                                Log::error("Failed to create directory");
+                                return;
+                            }
+                            // Refresh list from server:
+                            navigateTo(impl_->currentPath);
+                        });
+                    },
+            });
         }
         else if (type == NuiFileExplorer::FileGrid::Item::Type::Regular)
         {
-            impl_->newItemAskDialog->open(
-                "New file",
-                "Enter the name of the new file",
-                "Create a new file",
-                false,
-                [this](std::optional<std::string> const& name) {
-                    if (!name)
-                        return;
+            impl_->inputDialog->open({
+                .whatFor = "New file",
+                .prompt = "Enter the name of the new file",
+                .headerText = "Create a new file",
+                .isPassword = false,
+                .onConfirm =
+                    [this](std::optional<std::string> const& name) {
+                        if (!name)
+                            return;
 
-                    Log::info("Creating new file: {}", *name);
-                    if (name->find('/') != std::string::npos)
-                    {
-                        Log::error("Invalid file name (cannot contain slashes): {}", *name);
-                        return;
-                    }
-                    impl_->fileEngine->createFile(impl_->currentPath / *name, [this](bool success) {
-                        if (!success)
+                        Log::info("Creating new file: {}", *name);
+                        if (name->find('/') != std::string::npos)
                         {
-                            Log::error("Failed to create file");
+                            Log::error("Invalid file name (cannot contain slashes): {}", *name);
                             return;
                         }
-                        // Refresh list from server:
-                        navigateTo(impl_->currentPath);
-                    });
-                });
+                        impl_->fileEngine->createFile(impl_->currentPath / *name, [this](bool success) {
+                            if (!success)
+                            {
+                                Log::error("Failed to create file");
+                                return;
+                            }
+                            // Refresh list from server:
+                            navigateTo(impl_->currentPath);
+                        });
+                    },
+            });
         }
         else
         {
@@ -310,7 +439,8 @@ void Session::onBeforeTerminalConnectionClose()
     // TODO:
     // if (impl_->terminal.value())
     // {
-    //     impl_->terminal.value()->iterateAllChannels([](std::string const& /*channelId*/, TerminalChannel& channel) {
+    //     impl_->terminal.value()->iterateAllChannels([](std::string const& /*channelId*/, TerminalChannel&
+    //     channel) {
     //         std::string id = channel.stealTerminal();
     //         return true;
     //     });
diff --git a/frontend/source/frontend/session_components/session_options.cpp b/frontend/source/frontend/session_components/session_options.cpp
index 900f1d2d..48426382 100644
--- a/frontend/source/frontend/session_components/session_options.cpp
+++ b/frontend/source/frontend/session_components/session_options.cpp
@@ -117,7 +117,11 @@ Nui::ElementRenderer SessionOptions::operator()()
                         if (!success)
                         {
                             Log::error("Failed to load state holder");
-                            impl_->confirmDialog->open(ConfirmDialog::State::Negative, "Failed to save layout", "Failed to load state holder");
+                            impl_->confirmDialog->open({
+                                .state = ConfirmDialog::State::Negative,
+                                .headerText = "Failed to save layout",
+                                .text = "Failed to load state holder",
+                            });
                             return;
                         }
 
@@ -125,7 +129,11 @@ Nui::ElementRenderer SessionOptions::operator()()
                         if (layout.isUndefined())
                         {
                             Log::error("Failed to get layout");
-                            impl_->confirmDialog->open(ConfirmDialog::State::Negative, "Failed to save layout", "Failed to get layout");
+                            impl_->confirmDialog->open({
+                                .state = ConfirmDialog::State::Negative,
+                                .headerText = "Failed to save layout",
+                                .text = "Failed to get layout",
+                            });
                             return;
                         }
 
@@ -139,14 +147,22 @@ Nui::ElementRenderer SessionOptions::operator()()
 
                             stateHolder.save([this]() {
                                 Log::info("Layout saved");
-                                impl_->confirmDialog->open(ConfirmDialog::State::Positive, "Layout saved", "Layout was saved successfully");
+                                impl_->confirmDialog->open({
+                                    .state = ConfirmDialog::State::Positive,
+                                    .headerText = "Layout saved",
+                                    .text = "Layout was saved successfully",
+                                });
                                 impl_->events->onLayoutsChanged.modifyNow();
                                 loadLayoutNames();
                             });
                         }
                         else {
                             Log::error("No such persisted session config '{}'", impl_->persistenceSessionName);
-                            impl_->confirmDialog->open(ConfirmDialog::State::Negative, "Failed to save layout", "No such persisted session config");
+                            impl_->confirmDialog->open({
+                                .state = ConfirmDialog::State::Negative,
+                                .headerText = "Failed to save layout",
+                                .text = "No such persisted session config",
+                            });
                         }
                     });
                 }
@@ -160,25 +176,37 @@ Nui::ElementRenderer SessionOptions::operator()()
                         if (!success)
                         {
                             Log::error("Failed to load state holder");
-                            impl_->confirmDialog->open(ConfirmDialog::State::Negative, "Failed to delete layout", "Failed to load state holder");
+                            impl_->confirmDialog->open({.state = ConfirmDialog::State::Negative, .headerText = "Failed to delete layout", .text = "Failed to load state holder",});
                             return;
                         }
 
                         auto& layouts = stateHolder.stateCache().sessions.at(impl_->persistenceSessionName).layouts;
                         if (!layouts) {
                             Log::error("No such layout");
-                            impl_->confirmDialog->open(ConfirmDialog::State::Negative, "Failed to delete layout", "No such layout");
+                            impl_->confirmDialog->open({
+                                .state = ConfirmDialog::State::Negative,
+                                .headerText = "Failed to delete layout",
+                                .text = "No such layout",
+                            });
                         }
                         auto result = layouts->erase(impl_->selectedLayout);
                         if (result == 0) {
                             Log::error("Failed to delete layout '{}'", impl_->selectedLayout);
-                            impl_->confirmDialog->open(ConfirmDialog::State::Negative, "Failed to delete layout", fmt::format("Failed to delete layout '{}'", impl_->selectedLayout));
+                            impl_->confirmDialog->open({
+                                .state = ConfirmDialog::State::Negative,
+                                .headerText = "Failed to delete layout",
+                                .text = fmt::format("Failed to delete layout '{}'", impl_->selectedLayout),
+                            });
                             return;
                         }
 
                         stateHolder.save([this]() {
                             Log::info("Layout '{}' deleted", impl_->selectedLayout);
-                            impl_->confirmDialog->open(ConfirmDialog::State::Positive, "Layout deleted", fmt::format("Layout '{}' was deleted successfully", impl_->selectedLayout));
+                            impl_->confirmDialog->open({
+                                .state = ConfirmDialog::State::Positive,
+                                .headerText = "Layout deleted",
+                                .text = fmt::format("Layout '{}' was deleted successfully", impl_->selectedLayout),
+                            });
                             impl_->events->onLayoutsChanged.modifyNow();
                             loadLayoutNames();
                         });
diff --git a/frontend/source/frontend/toolbar.cpp b/frontend/source/frontend/toolbar.cpp
index 3394456e..1093d3aa 100644
--- a/frontend/source/frontend/toolbar.cpp
+++ b/frontend/source/frontend/toolbar.cpp
@@ -43,14 +43,23 @@ void Toolbar::Implementation::updateSessionsList(std::function<void()> onDone)
 
         auto const& state = holder.stateCache();
 
-        std::vector<std::string> engines;
+        std::vector<std::pair<std::string, std::string /*orderby*/>> enginesUnordered;
         for (auto const& [name, engine] : state.sessions)
+            enginesUnordered.push_back({name, engine.orderBy.value_or(name)});
+
+        std::sort(enginesUnordered.begin(), enginesUnordered.end(), [](auto const& lhs, auto const& rhs) {
+            return lhs.second < rhs.second;
+        });
+
+        std::vector<std::string> engines;
+        for (auto const& [name, _] : enginesUnordered)
             engines.push_back(name);
 
         {
             Log::info("Updating terminal engines list.");
             auto proxy = terminalEngines.modify();
             terminalEngines = std::move(engines);
+
             events->onNewSession.value() = terminalEngines.value().front();
         }
         Nui::globalEventContext.executeActiveEventsImmediately();
diff --git a/nui-file-explorer/include/nui-file-explorer/file_grid.hpp b/nui-file-explorer/include/nui-file-explorer/file_grid.hpp
index fddb5ba5..9899788c 100644
--- a/nui-file-explorer/include/nui-file-explorer/file_grid.hpp
+++ b/nui-file-explorer/include/nui-file-explorer/file_grid.hpp
@@ -90,20 +90,52 @@ namespace NuiFileExplorer
          * @brief Determines how the grid should be displayed.
          */
         void flavor(FileGridFlavor value);
+
+        /**
+         * @brief Returns the current grid flavor.
+         */
         FileGridFlavor flavor() const;
 
         /**
          * @brief Sets the size of the icons in the grid.
          */
         void iconSize(unsigned int value);
+
+        /**
+         * @brief Sets the spacing between icons in the grid.
+         */
         void iconSpacing(unsigned int value);
+
+        /**
+         * @brief Returns the size of the icons in the grid.
+         */
         unsigned int iconSize() const;
+
+        /**
+         * @brief Returns the spacing between icons in the grid.
+         */
         unsigned int iconSpacing() const;
 
+        /**
+         * @brief Deselects all items.
+         */
         void deselectAll(bool rerender = false);
 
+        /**
+         * @brief Selects all items.
+         */
         void selectAll(bool rerender = false);
 
+        /**
+         * @brief Returns all selected items.
+         */
+        std::vector<Item> selectedItems() const;
+
+        /**
+         * @brief Returns the paths of all selected items.
+         */
+        std::vector<std::filesystem::path> selectedPaths() const;
+
         /**
          * @brief Use this to close all menus and deselect all items.
          */
@@ -135,6 +167,37 @@ namespace NuiFileExplorer
          */
         void onRefresh(std::function<void()> const& callback);
 
+        /**
+         * @brief Triggered when items are requested to be deleted.
+         *
+         * @param callback
+         */
+        void onDelete(std::function<void(std::vector<Item> const&)> const& callback);
+
+        /**
+         * @brief Triggered when item is requested to be renamed.
+         *
+         * @param callback
+         */
+        void onRename(std::function<void(Item const&)> const& callback);
+
+        /**
+         * @brief Triggered when item is requested to be queried for attrs.
+         *
+         * @param callback
+         */
+        void onProperties(std::function<void(Item const&)> const& callback);
+
+        /**
+         * @brief Triggered when items are requested to be downloaded.
+         */
+        void onDownload(std::function<void(std::vector<Item> const&)> const& callback);
+
+        /**
+         * @brief Triggered when an error occurs.
+         */
+        void onError(std::function<void(std::string const&)> const& callback);
+
       private:
         Nui::ElementRenderer iconFlavor();
         Nui::ElementRenderer tableFlavor();
diff --git a/nui-file-explorer/source/nui-file-explorer/file_grid.cpp b/nui-file-explorer/source/nui-file-explorer/file_grid.cpp
index 8ddd10b8..b465b3bb 100644
--- a/nui-file-explorer/source/nui-file-explorer/file_grid.cpp
+++ b/nui-file-explorer/source/nui-file-explorer/file_grid.cpp
@@ -8,6 +8,8 @@
 #include <nui/frontend/attributes.hpp>
 #include <nui/frontend/api/console.hpp>
 
+using namespace std::string_literals;
+
 namespace NuiFileExplorer
 {
     namespace
@@ -125,7 +127,13 @@ namespace NuiFileExplorer
         Nui::Observed<std::filesystem::path> path{};
         std::function<void(std::filesystem::path const&)> onPathChange{};
         std::function<void()> onRefresh{};
+        std::function<void(std::vector<Item> const&)> onDelete{};
+        std::function<void(Item const&)> onRename{};
+        std::function<void(std::vector<Item> const&)> onDownload{};
+        std::function<void(std::string const&)> onError{};
+        std::function<void(Item const&)> onProperties{};
         Settings settings{};
+        std::vector<Item> contextMenuClickItems{};
 
         void sortItems()
         {
@@ -171,6 +179,23 @@ namespace NuiFileExplorer
         return impl_->flavor.value();
     }
 
+    void FileGrid::onDelete(std::function<void(std::vector<Item> const&)> const& callback)
+    {
+        impl_->onDelete = callback;
+    }
+    void FileGrid::onRename(std::function<void(Item const&)> const& callback)
+    {
+        impl_->onRename = callback;
+    }
+    void FileGrid::onDownload(std::function<void(std::vector<Item> const&)> const& callback)
+    {
+        impl_->onDownload = callback;
+    }
+    void FileGrid::onError(std::function<void(std::string const&)> const& callback)
+    {
+        impl_->onError = callback;
+    }
+
     void FileGrid::iconSize(unsigned int value)
     {
         impl_->iconSize = value;
@@ -222,6 +247,17 @@ namespace NuiFileExplorer
         closeMenus();
     }
 
+    std::vector<FileGrid::Item> FileGrid::selectedItems() const
+    {
+        std::vector<Item> result{};
+        for (auto const& item : impl_->items.value())
+        {
+            if (item.selected->value())
+                result.push_back(item.item);
+        }
+        return result;
+    }
+
     void FileGrid::closeMenus()
     {
         impl_->newItemMenu.close();
@@ -253,10 +289,40 @@ namespace NuiFileExplorer
             const auto left = targetOffsetLeft + offsetX;
             const auto top = targetOffsetTop + offsetY;
 
+            if (item)
+            {
+                Nui::Console::log("Context menu item: ", item->path.string());
+                auto selected = selectedItems();
+                if (std::find_if(selected.begin(), selected.end(), [&item](auto const& i) {
+                        return i.path == item->path;
+                    }) == selected.end())
+                {
+                    deselectAll();
+                    impl_->contextMenuClickItems = {item.value()};
+                }
+
+                impl_->contextMenuClickItems = selected;
+            }
+            else
+            {
+                Nui::Console::log("Context menu item: none");
+                impl_->contextMenuClickItems = selectedItems();
+            }
+            // filter ".." from context menu click items:
+            impl_->contextMenuClickItems.erase(
+                std::remove_if(
+                    impl_->contextMenuClickItems.begin(),
+                    impl_->contextMenuClickItems.end(),
+                    [](auto const& item) {
+                        return item.path.filename() == "..";
+                    }),
+                impl_->contextMenuClickItems.end());
+
+            // contextMenuClickItems
+
             menu->val()["style"].set("display", "block");
             menu->val()["style"].set("top", std::to_string(top) + "px");
             menu->val()["style"].set("left", std::to_string(left) + "px");
-            Nui::Console::log(event);
             return;
         }
     }
@@ -267,6 +333,16 @@ namespace NuiFileExplorer
         // Do NOT call onPathChange here. That is intentional.
     }
 
+    std::vector<std::filesystem::path> FileGrid::selectedPaths() const
+    {
+        std::vector<Item> selectedItems = this->selectedItems();
+        std::vector<std::filesystem::path> result(selectedItems.size());
+        std::transform(selectedItems.begin(), selectedItems.end(), result.begin(), [](auto const& item) {
+            return item.path;
+        });
+        return result;
+    }
+
     void FileGrid::onPathChange(std::function<void(std::filesystem::path const&)> const& callback)
     {
         impl_->onPathChange = callback;
@@ -277,6 +353,11 @@ namespace NuiFileExplorer
         impl_->onRefresh = callback;
     }
 
+    void FileGrid::onProperties(std::function<void(Item const&)> const& callback)
+    {
+        impl_->onProperties = callback;
+    }
+
     Nui::ElementRenderer FileGrid::contextMenu()
     {
         using namespace Nui;
@@ -290,28 +371,70 @@ namespace NuiFileExplorer
             class_ = "nui-file-grid-context-menu",
         }(
             div{
-                style = Style{
-                    "padding"_style = "0.5em",
-                    "border-bottom"_style = "1px solid var(--sapTextColor)",
+                class_ = "nui-file-grid-context-menu-item",
+                onClick = [this](Nui::val event){
+                    event.call<void>("stopPropagation");
+                    closeMenus();
+                    if (impl_->contextMenuClickItems.empty())
+                        impl_->onError("No items selected"s);
+                    if (impl_->onDownload)
+                        impl_->onDownload(impl_->contextMenuClickItems);
+                    impl_->contextMenuClickItems = {};
                 }
             }(
-                "Item 1"
+                "Download"
             ),
             div{
-                style = Style{
-                    "padding"_style = "0.5em",
-                    "border-bottom"_style = "1px solid var(--sapTextColor)",
+                class_ = "nui-file-grid-context-menu-item",
+                onClick = [this](Nui::val event){
+                    event.call<void>("stopPropagation");
+                    closeMenus();
+                    if (impl_->contextMenuClickItems.empty())
+                        impl_->onError("No items selected"s);
+                    if (impl_->onDelete)
+                        impl_->onDelete(impl_->contextMenuClickItems);
+                    impl_->contextMenuClickItems = {};
                 }
             }(
-                "Item 2"
+                "Delete"
             ),
             div{
-                style = Style{
-                    "padding"_style = "0.5em",
-                    "border-bottom"_style = "1px solid var(--sapTextColor)",
+                class_ = "nui-file-grid-context-menu-item",
+                onClick = [this](Nui::val event){
+                    event.call<void>("stopPropagation");
+                    closeMenus();
+                    const auto& items = impl_->contextMenuClickItems;
+                    if (items.empty())
+                        impl_->onError("No items selected"s);
+                    if (items.size() > 1 && impl_->onError) {
+                        impl_->onError("Cannot rename multiple items at once"s);
+                    } else if (items.size() == 1) {
+                        if (impl_->onRename)
+                            impl_->onRename(items.front());
+                    }
+                    impl_->contextMenuClickItems = {};
+                }
+            }(
+                "Rename"
+            ),
+            div{
+                class_ = "nui-file-grid-context-menu-item",
+                onClick = [this](Nui::val event){
+                    event.call<void>("stopPropagation");
+                    closeMenus();
+                    auto const& items = impl_->contextMenuClickItems;
+                    if (items.empty())
+                        impl_->onError("No items selected"s);
+                    if (items.size() > 1 && impl_->onError) {
+                        impl_->onError("Cannot view properties of multiple items at once"s);
+                    } else if (items.size() == 1) {
+                        if (impl_->onProperties)
+                            impl_->onProperties(items.front());
+                    }
+                    impl_->contextMenuClickItems = {};
                 }
             }(
-                "Item 3"
+                "Properties"
             )
         );
         // clang-format on
diff --git a/nui-file-explorer/styles/file_grid.css b/nui-file-explorer/styles/file_grid.css
index af306878..3e080a7e 100644
--- a/nui-file-explorer/styles/file_grid.css
+++ b/nui-file-explorer/styles/file_grid.css
@@ -19,6 +19,22 @@
     border-radius: var(--nui-file-grid-border-radius);
 }
 
+.nui-file-grid-context-menu-item {
+    padding: 0.5em;
+    border-bottom: 1px solid var(--nui-file-grid-border-color);
+    cursor: pointer;
+    color: var(--nui-file-grid-context-menu-color);
+
+    &:hover {
+        background-color: var(--nui-file-grid-context-menu-item-hover-background);
+        color: var(--nui-file-grid-context-menu-item-hover-color);
+    }
+
+    &:last-child {
+        border-bottom: none;
+    }
+}
+
 .nui-file-grid-item-icons {
     display: flex;
     flex-direction: column;
diff --git a/persistence/include/persistence/state/ssh_session_options.hpp b/persistence/include/persistence/state/ssh_session_options.hpp
index 0deecd41..4bb9c0d9 100644
--- a/persistence/include/persistence/state/ssh_session_options.hpp
+++ b/persistence/include/persistence/state/ssh_session_options.hpp
@@ -16,6 +16,8 @@ namespace Persistence
         std::string host{};
         std::optional<int> port{std::nullopt};
         std::optional<std::string> user{std::nullopt};
+        // TODO: Remove again. This was only for testing!
+        std::optional<std::string> passwordUnsafe{std::nullopt};
         std::optional<std::string> sshKey{std::nullopt};
         std::optional<std::unordered_map<std::string, std::string>> environment{std::nullopt};
         bool openSftpByDefault{true};
diff --git a/persistence/include/persistence/state/terminal_engine.hpp b/persistence/include/persistence/state/terminal_engine.hpp
index f084c3ec..54211c91 100644
--- a/persistence/include/persistence/state/terminal_engine.hpp
+++ b/persistence/include/persistence/state/terminal_engine.hpp
@@ -60,6 +60,7 @@ namespace Persistence
     struct TerminalEngine
     {
         std::string type{};
+        std::optional<std::string> orderBy{};
         std::optional<bool> startupSession{};
         Referenceable<TerminalOptions> terminalOptions{};
         Referenceable<Termios> termios{};
diff --git a/persistence/source/persistence/state/ssh_session_options.cpp b/persistence/source/persistence/state/ssh_session_options.cpp
index d408ac8b..8807c38c 100644
--- a/persistence/source/persistence/state/ssh_session_options.cpp
+++ b/persistence/source/persistence/state/ssh_session_options.cpp
@@ -10,6 +10,8 @@ namespace Persistence
             port = other.port;
         if (!user.has_value())
             user = other.user;
+        if (passwordUnsafe.has_value())
+            passwordUnsafe = other.passwordUnsafe;
         if (!sshKey.has_value())
             sshKey = other.sshKey;
         if (!environment.has_value())
@@ -27,6 +29,7 @@ namespace Persistence
 
         TO_JSON_OPTIONAL(j, options, port);
         TO_JSON_OPTIONAL(j, options, user);
+        TO_JSON_OPTIONAL(j, options, passwordUnsafe);
         TO_JSON_OPTIONAL(j, options, sshKey);
         TO_JSON_OPTIONAL(j, options, environment);
         TO_JSON_OPTIONAL(j, options, defaultDirectory);
@@ -40,6 +43,7 @@ namespace Persistence
 
         FROM_JSON_OPTIONAL(j, options, port);
         FROM_JSON_OPTIONAL(j, options, user);
+        FROM_JSON_OPTIONAL(j, options, passwordUnsafe);
         FROM_JSON_OPTIONAL(j, options, sshKey);
         FROM_JSON_OPTIONAL(j, options, environment);
         FROM_JSON_OPTIONAL(j, options, defaultDirectory);
diff --git a/persistence/source/persistence/state/terminal_engine.cpp b/persistence/source/persistence/state/terminal_engine.cpp
index ce067b7a..05977873 100644
--- a/persistence/source/persistence/state/terminal_engine.cpp
+++ b/persistence/source/persistence/state/terminal_engine.cpp
@@ -76,6 +76,7 @@ namespace Persistence
             });
 
         TO_JSON_OPTIONAL(j, engine, startupSession);
+        TO_JSON_OPTIONAL(j, engine, orderBy);
 
         if (engine.layouts)
             j["layouts"] = *engine.layouts;
@@ -111,6 +112,7 @@ namespace Persistence
         }
 
         FROM_JSON_OPTIONAL(j, engine, startupSession);
+        FROM_JSON_OPTIONAL(j, engine, orderBy);
 
         if (j.contains("layouts"))
             engine.layouts = j.at("layouts");
diff --git a/ssh/source/ssh/session.cpp b/ssh/source/ssh/session.cpp
index 843df2ac..569b6f74 100644
--- a/ssh/source/ssh/session.cpp
+++ b/ssh/source/ssh/session.cpp
@@ -411,6 +411,18 @@ namespace SecureShell
                     }
                 }
 
+                if (sessionOptions.passwordUnsafe)
+                {
+                    buf = sessionOptions.passwordUnsafe.value();
+                    const auto result = static_cast<ssh::Session&>(*session).userauthPassword(buf.data());
+                    if (result == SSH_AUTH_SUCCESS)
+                    {
+                        if (pwCache)
+                            pwCache->emplace_back(sessionOptions.user, sessionOptions.host, sessionOptions.port, buf);
+                        return (int)SSH_AUTH_SUCCESS;
+                    }
+                }
+
                 const auto r = askPass("Password: ", buf.data(), buf.size(), 0, 0, askPassUserDataPassword);
                 if (r == 0)
                 {

From c35c70668981002cbca1f420d9704d434b1d76b6 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sat, 21 Jun 2025 18:20:56 +0200
Subject: [PATCH 16/42] Refactored operations.

---
 backend/include/backend/main.hpp              |   2 +-
 .../include/backend/sftp/all_operations.hpp   |  20 +
 .../backend/sftp/download_operation.hpp       |  53 +-
 backend/include/backend/sftp/operation.hpp    |  99 +++-
 .../include/backend/sftp/operation_queue.hpp  |  38 +-
 .../include/backend/sftp/operation_type.hpp   |   7 +
 .../include/backend/ssh_session_manager.hpp   |  14 +-
 backend/source/backend/main.cpp               |  17 +-
 .../backend/sftp/download_operation.cpp       | 325 ++++++------
 .../source/backend/sftp/operation_queue.cpp   |  97 +++-
 .../source/backend/ssh_session_manager.cpp    |  41 +-
 .../test/backend/test_download_operation.hpp  | 499 ++++--------------
 .../session_components/operation_queue.hpp    |   9 +-
 frontend/source/frontend/CMakeLists.txt       |   1 +
 frontend/source/frontend/session.cpp          |  12 +-
 .../session_components/operation_queue.cpp    |  23 +-
 16 files changed, 627 insertions(+), 630 deletions(-)
 create mode 100644 backend/include/backend/sftp/all_operations.hpp
 create mode 100644 backend/include/backend/sftp/operation_type.hpp

diff --git a/backend/include/backend/main.hpp b/backend/include/backend/main.hpp
index 1e0a0a1d..a0b503b1 100644
--- a/backend/include/backend/main.hpp
+++ b/backend/include/backend/main.hpp
@@ -37,7 +37,7 @@ class Main
     Nui::RpcHub hub_;
     ProcessStore processes_;
     PasswordPrompter prompter_;
-    SshSessionManager sshSessionManager_;
+    std::shared_ptr<SshSessionManager> sshSessionManager_;
     std::atomic_bool shuttingDown_;
     boost::asio::steady_timer childSignalTimer_;
 };
\ No newline at end of file
diff --git a/backend/include/backend/sftp/all_operations.hpp b/backend/include/backend/sftp/all_operations.hpp
new file mode 100644
index 00000000..9552b549
--- /dev/null
+++ b/backend/include/backend/sftp/all_operations.hpp
@@ -0,0 +1,20 @@
+#include <backend/sftp/operation.hpp>
+#include <backend/sftp/download_operation.hpp>
+
+template <typename FunctionT>
+auto Operation::visit(FunctionT&& func) const
+{
+    using enum OperationType;
+    switch (type())
+    {
+        case Download:
+        {
+            return func(static_cast<DownloadOperation const&>(*this));
+        }
+        default:
+        {
+            Log::error("Operation: Unknown operation type: {}", static_cast<int>(type()));
+            return func(std::nullopt);
+        }
+    }
+}
\ No newline at end of file
diff --git a/backend/include/backend/sftp/download_operation.hpp b/backend/include/backend/sftp/download_operation.hpp
index 0e58d039..b0792ecd 100644
--- a/backend/include/backend/sftp/download_operation.hpp
+++ b/backend/include/backend/sftp/download_operation.hpp
@@ -15,7 +15,6 @@ class DownloadOperation : public Operation
     {
         std::function<void(std::int64_t min, std::int64_t max, std::int64_t current)> progressCallback =
             [](auto, auto, auto) {};
-        std::function<void(bool success)> onCompletionCallback = [](auto) {};
         std::filesystem::path remotePath{};
         std::filesystem::path localPath{};
         std::string tempFileSuffix{".filepart"};
@@ -28,6 +27,13 @@ class DownloadOperation : public Operation
         std::chrono::seconds futureTimeout{5};
     };
 
+    SecureShell::ProcessingStrand* strand() const override
+    {
+        if (auto stream = fileStream_.lock(); stream)
+            return stream->strand();
+        return nullptr;
+    }
+
     DownloadOperation(std::weak_ptr<SecureShell::IFileStream> fileStream, DownloadOperationOptions options);
     ~DownloadOperation() override;
     DownloadOperation(DownloadOperation const&) = delete;
@@ -35,50 +41,49 @@ class DownloadOperation : public Operation
     DownloadOperation& operator=(DownloadOperation const&) = delete;
     DownloadOperation& operator=(DownloadOperation&&) = delete;
 
-    std::expected<void, Error> prepare() override;
-    std::expected<void, Error> start() override;
-    std::expected<void, Error> cancel() override;
-    std::expected<void, Error> pause() override;
-    std::expected<void, Error> finalize() override;
-
-  private:
-    std::expected<void, Error> openOrAdoptFile(SecureShell::IFileStream& stream);
+    std::expected<WorkStatus, Error> work() override;
 
-    template <typename FunctionT>
-    bool perform(FunctionT&& func)
+    OperationType type() const override
     {
-        auto stream = fileStream_.lock();
-        if (!stream)
-            return false;
+        return OperationType::Download;
+    }
 
-        auto* strand = stream->strand();
-        if (!strand)
-            return false;
+    std::filesystem::path remotePath() const
+    {
+        return remotePath_;
+    }
 
-        return strand->pushTask(std::forward<FunctionT>(func));
+    std::filesystem::path localPath() const
+    {
+        return localPath_;
     }
 
+    std::expected<void, DownloadOperation::Error> cancel(bool adoptCancelState) override;
+
+    std::expected<void, Error> prepare();
+    std::expected<void, Error> finalize();
+
+  private:
+    /// Returns true if there is more data to read, false if the operation is complete.
+    std::expected<bool, Error> readOnce();
+
+    std::expected<void, Error> openOrAdoptFile(SecureShell::IFileStream& stream);
+
     void cleanup();
 
   private:
-    std::recursive_mutex mutex_;
     std::weak_ptr<SecureShell::IFileStream> fileStream_;
     std::filesystem::path remotePath_;
     std::filesystem::path localPath_;
     std::string tempFileSuffix_;
     std::function<void(std::int64_t min, std::int64_t max, std::int64_t current)> progressCallback_;
-    std::function<void(bool success)> onCompletionCallback_;
     bool mayOverwrite_;
     bool reserveSpace_;
     bool tryContinue_;
     bool inheritPermissions_;
     bool doCleanup_;
-    bool preparationDone_;
-    bool isReading_;
-    std::atomic_bool interuptRead_;
     std::optional<std::filesystem::perms> permissions_;
     std::ofstream localFile_;
     std::uint64_t fileSize_;
-    std::future<std::expected<std::size_t, SecureShell::SftpError>> readFuture_;
     std::chrono::seconds futureTimeout_;
 };
\ No newline at end of file
diff --git a/backend/include/backend/sftp/operation.hpp b/backend/include/backend/sftp/operation.hpp
index 353afeb4..8966edb7 100644
--- a/backend/include/backend/sftp/operation.hpp
+++ b/backend/include/backend/sftp/operation.hpp
@@ -2,11 +2,15 @@
 
 #include <ssh/sftp_error.hpp>
 #include <utility/describe.hpp>
+#include <backend/sftp/operation_type.hpp>
+#include <ssh/async/processing_strand.hpp>
+#include <log/log.hpp>
 
 #include <ids/ids.hpp>
 
 #include <optional>
 #include <expected>
+#include <mutex>
 
 BOOST_DEFINE_ENUM_CLASS(
     OperationErrorType,
@@ -22,7 +26,11 @@ BOOST_DEFINE_ENUM_CLASS(
     FutureTimeout,
     OperationNotPrepared,
     CannotFinalizeDuringRead,
-    InvalidOptionsKey);
+    InvalidOptionsKey,
+    TargetFileNotGood,
+    CannotWorkCompletedOperation,
+    CannotWorkFailedOperation,
+    UnknownWorkState);
 
 class Operation
 {
@@ -32,11 +40,20 @@ class Operation
     {}
     Operation(Operation const&) = delete;
     Operation& operator=(Operation const&) = delete;
-    Operation(Operation&&) = default;
-    Operation& operator=(Operation&&) = default;
+    Operation(Operation&&) = delete;
+    Operation& operator=(Operation&&) = delete;
+
+    virtual ~Operation() = default;
 
     using ErrorType = OperationErrorType;
 
+    virtual OperationType type() const = 0;
+
+    template <typename FunctionT>
+    auto visit(FunctionT&& func) const;
+
+    virtual SecureShell::ProcessingStrand* strand() const = 0;
+
     struct Error
     {
         ErrorType type;
@@ -51,36 +68,82 @@ class Operation
         }
     };
 
+    template <typename FunctionT>
+    bool perform(FunctionT&& func)
+    {
+        std::scoped_lock lock{mutex_};
+
+        if (auto* theStrand = strand(); theStrand)
+            return theStrand->pushTask(std::forward<FunctionT>(func));
+        else
+        {
+            Log::error("Operation: Cannot perform task on strand, no processing strand available.");
+            return false;
+        }
+    }
+
     Ids::OperationId id() const
     {
         return id_;
     }
 
-    virtual ~Operation() = default;
+    enum class OperationState
+    {
+        NotStarted,
+        Preparing,
+        Prepared,
+        Running,
+        Finalizing,
+        Completed,
+        Canceled,
+        Failed,
+    };
+
+    OperationState state() const
+    {
+        std::scoped_lock lock{mutex_};
+        return state_;
+    }
 
-    virtual std::expected<void, Error> prepare() = 0;
+    enum class WorkStatus
+    {
+        MoreWork,
+        Complete
+    };
 
     /**
-     * @brief Starts the operation, can also be used to resume cancelled operations.
+     * @brief Performs work for the operation depending on the operation type.
      *
-     * @return std::expected<void, Error>
+     * @return std::expected<bool, Error>, true if it wants to be retriggered without delay.
      */
-    virtual std::expected<void, Error> start() = 0;
+    virtual std::expected<WorkStatus, Error> work() = 0;
 
     /**
-     * @brief Cancels the operation and possibly does some cleanup.
+     * @brief Cancels the operation.
+     *
+     * @return std::expected<void, Error>
      */
-    virtual std::expected<void, Error> cancel() = 0;
+    virtual std::expected<void, Error> cancel(bool adoptCancelState) = 0;
 
-    /**
-     * @brief Pauses the operation.
-     */
-    virtual std::expected<void, Error> pause() = 0;
+    template <typename T = void>
+    std::expected<T, Error> enterErrorState(Error error)
+    {
+        std::scoped_lock lock{mutex_};
+        state_ = OperationState::Failed;
+        error_ = std::move(error);
+        const auto cancelResult = cancel(false);
+        if (!cancelResult.has_value())
+        {
+            Log::error("Operation: Failed to cancel operation: {}", cancelResult.error().toString());
+            // If cancel fails, we still want to call the completion callback.
+        }
+        return std::unexpected(error_.value());
+    }
 
-    /**
-     * @brief Finalizes the operation. This should be called after the operation is done (progress == max).
-     */
-    virtual std::expected<void, Error> finalize() = 0;
+  protected:
+    mutable std::recursive_mutex mutex_{};
+    OperationState state_{OperationState::NotStarted};
+    std::optional<Error> error_{std::nullopt};
 
   private:
     Ids::OperationId id_;
diff --git a/backend/include/backend/sftp/operation_queue.hpp b/backend/include/backend/sftp/operation_queue.hpp
index 85aee22e..33e1e6f9 100644
--- a/backend/include/backend/sftp/operation_queue.hpp
+++ b/backend/include/backend/sftp/operation_queue.hpp
@@ -1,12 +1,12 @@
 #pragma once
 
-#include <backend/sftp/operation.hpp>
-#include <backend/sftp/download_operation.hpp>
+#include <backend/sftp/all_operations.hpp>
 #include <persistence/state/state.hpp>
 #include <ssh/sftp_session.hpp>
 #include <ids/ids.hpp>
 
 #include <vector>
+#include <deque>
 #include <filesystem>
 #include <memory>
 #include <utility>
@@ -14,15 +14,38 @@
 class OperationQueue
 {
   public:
-    OperationQueue();
+    enum class CompletionReason
+    {
+        Completed,
+        Canceled,
+        Failed
+    };
+
+    struct CompletedOperation
+    {
+        CompletionReason reason;
+        Ids::OperationId id;
+        std::chrono::system_clock::time_point completionTime;
+        std::optional<std::filesystem::path> localPath{std::nullopt};
+        std::optional<std::filesystem::path> remotePath{std::nullopt};
+        std::optional<Operation::Error> error{std::nullopt};
+    };
+
+    OperationQueue(int parallelism = 1);
 
     using Error = OperationErrorType;
 
-    void start();
-    void pause();
     void cancelAll();
     void cancel(Ids::OperationId id);
 
+    /**
+     * @brief Returns true if it should be called without delay again.
+     *
+     * @return true
+     * @return false
+     */
+    bool update();
+
     std::expected<void, Operation::Error> addDownloadOperation(
         Persistence::State const& state,
         std::string const& sshSessionOptionsKey,
@@ -32,5 +55,8 @@ class OperationQueue
         std::filesystem::path const& remotePath);
 
   private:
-    std::vector<std::pair<Ids::OperationId, std::unique_ptr<Operation>>> operations_;
+    std::mutex mutex_{};
+    std::deque<std::pair<Ids::OperationId, std::unique_ptr<Operation>>> operations_{};
+    std::vector<CompletedOperation> completedOperations_{};
+    int parallelism_{1};
 };
diff --git a/backend/include/backend/sftp/operation_type.hpp b/backend/include/backend/sftp/operation_type.hpp
new file mode 100644
index 00000000..68b1d196
--- /dev/null
+++ b/backend/include/backend/sftp/operation_type.hpp
@@ -0,0 +1,7 @@
+#pragma once
+
+enum class OperationType
+{
+    Download,
+    Upload
+};
\ No newline at end of file
diff --git a/backend/include/backend/ssh_session_manager.hpp b/backend/include/backend/ssh_session_manager.hpp
index 7db152b1..581806c9 100644
--- a/backend/include/backend/ssh_session_manager.hpp
+++ b/backend/include/backend/ssh_session_manager.hpp
@@ -11,19 +11,19 @@
 #include <nui/rpc.hpp>
 #include <libssh/libsshpp.hpp>
 #include <libssh/sftp.h>
+#include <boost/asio/any_io_executor.hpp>
 
 #include <memory>
-#include <string>
 #include <map>
 #include <mutex>
 #include <thread>
 
-class SshSessionManager
+class SshSessionManager : public std::enable_shared_from_this<SshSessionManager>
 {
   public:
     constexpr static auto futureTimeout = std::chrono::seconds{10};
 
-    SshSessionManager(Persistence::StateHolder* stateHolder);
+    SshSessionManager(boost::asio::any_io_executor exectutor, Persistence::StateHolder* stateHolder);
     ~SshSessionManager();
     SshSessionManager(SshSessionManager const&) = delete;
     SshSessionManager& operator=(SshSessionManager const&) = delete;
@@ -40,6 +40,9 @@ class SshSessionManager
 
     friend int askPassDefault(char const* prompt, char* buf, std::size_t length, int echo, int verify, void* userdata);
 
+    void startUpdateDispatching();
+    void stopUpdateDispatching();
+
   private:
     void registerRpcConnect(Nui::Window& wnd, Nui::RpcHub& hub);
     void registerRpcCreateChannel(Nui::Window& wnd, Nui::RpcHub& hub);
@@ -57,9 +60,13 @@ class SshSessionManager
     // Sftp Files:
     void registerRpcSftpAddDownloadOperation(Nui::Window&, Nui::RpcHub& hub);
 
+  private:
+    void dispatchUpdates();
+
   private:
     std::mutex passwordProvidersMutex_{};
     std::mutex addSessionMutex_{};
+    boost::asio::any_io_executor executor_;
     Persistence::StateHolder* stateHolder_{};
     std::unordered_map<Ids::SessionId, std::unique_ptr<SecureShell::Session>, Ids::IdHash> sessions_{};
     std::unordered_map<Ids::ChannelId, std::weak_ptr<SecureShell::Channel>, Ids::IdHash> channels_{};
@@ -68,6 +75,7 @@ class SshSessionManager
     std::map<int, PasswordProvider*> passwordProviders_{};
     std::unique_ptr<std::thread> addSessionThread_{};
     std::vector<SecureShell::PasswordCacheEntry> pwCache_{};
+    std::atomic_bool updateDispatchRunning_{false};
 };
 
 int askPassDefault(char const* prompt, char* buf, std::size_t length, int echo, int verify, void* userdata);
\ No newline at end of file
diff --git a/backend/source/backend/main.cpp b/backend/source/backend/main.cpp
index c353d9c5..a758bccf 100644
--- a/backend/source/backend/main.cpp
+++ b/backend/source/backend/main.cpp
@@ -158,11 +158,11 @@ Main::Main(int const, char const* const* argv)
     , hub_{window_}
     , processes_{window_.getExecutor(), window_, hub_}
     , prompter_{hub_}
-    , sshSessionManager_{&stateHolder_}
+    , sshSessionManager_{std::make_shared<SshSessionManager>(window_.getExecutor(), &stateHolder_)}
     , shuttingDown_{false}
     , childSignalTimer_{window_.getExecutor()}
 {
-    sshSessionManager_.addPasswordProvider(-99, &prompter_);
+    sshSessionManager_->addPasswordProvider(-99, &prompter_);
 
     stateHolder_.load([](bool success, Persistence::StateHolder& holder) {
         if (!success)
@@ -174,6 +174,7 @@ Main::Main(int const, char const* const* argv)
 Main::~Main()
 {
     shuttingDown_ = true;
+    sshSessionManager_->stopUpdateDispatching();
     childSignalTimer_.cancel();
 }
 
@@ -189,7 +190,7 @@ void Main::registerRpc()
     Log::setupBackendRpcHub(&hub_);
     stateHolder_.registerRpc(hub_);
     processes_.registerRpc(window_, hub_);
-    sshSessionManager_.registerRpc(window_, hub_);
+    sshSessionManager_->registerRpc(window_, hub_);
 }
 
 void Main::show()
@@ -261,10 +262,12 @@ int main(int const argc, char const* const* argv)
 
     ssh_init();
 
-    Main m{argc, argv};
-    m.registerRpc();
-    m.startChildSignalTimer();
-    m.show();
+    {
+        Main m{argc, argv};
+        m.registerRpc();
+        m.startChildSignalTimer();
+        m.show();
+    }
 
     ssh_finalize();
 }
\ No newline at end of file
diff --git a/backend/source/backend/sftp/download_operation.cpp b/backend/source/backend/sftp/download_operation.cpp
index 5149776e..31d9e6ee 100644
--- a/backend/source/backend/sftp/download_operation.cpp
+++ b/backend/source/backend/sftp/download_operation.cpp
@@ -1,41 +1,25 @@
 #include <backend/sftp/download_operation.hpp>
 
 #include <log/log.hpp>
+#include <tuple>
 
 DownloadOperation::DownloadOperation(
     std::weak_ptr<SecureShell::IFileStream> fileStream,
     DownloadOperationOptions options)
     : Operation{}
-    , mutex_{}
     , fileStream_{std::move(fileStream)}
     , remotePath_{std::move(options.remotePath)}
     , localPath_{std::move(options.localPath)}
     , tempFileSuffix_{std::move(options.tempFileSuffix)}
     , progressCallback_{std::move(options.progressCallback)}
-    , onCompletionCallback_{[this, cb = std::move(options.onCompletionCallback), once = false](bool success) mutable {
-        if (!cb)
-            throw std::invalid_argument("onCompletionCallback must be set.");
-        if (once)
-            return;
-        once = true;
-
-        std::scoped_lock lock{mutex_};
-        isReading_ = false;
-        progressCallback_(0, fileSize_, fileSize_);
-        cb(success);
-    }}
     , mayOverwrite_{options.mayOverwrite}
     , reserveSpace_{options.reserveSpace}
     , tryContinue_{options.tryContinue}
     , inheritPermissions_{options.inheritPermissions}
     , doCleanup_{options.doCleanup}
-    , preparationDone_{false}
-    , isReading_{false}
-    , interuptRead_{false}
     , permissions_{options.permissions}
     , localFile_{}
     , fileSize_{0}
-    , readFuture_{}
     , futureTimeout_{options.futureTimeout}
 {
     if (tempFileSuffix_.empty())
@@ -46,7 +30,7 @@ DownloadOperation::DownloadOperation(
 
 DownloadOperation::~DownloadOperation()
 {
-    cleanup();
+    std::ignore = cancel(true);
 
     if (auto stream = fileStream_.lock(); stream)
     {
@@ -55,6 +39,156 @@ DownloadOperation::~DownloadOperation()
     }
 }
 
+std::expected<DownloadOperation::WorkStatus, DownloadOperation::Error> DownloadOperation::work()
+{
+    using enum OperationState;
+
+    switch (state_)
+    {
+        case (NotStarted):
+        {
+            state_ = Preparing;
+            [[fallthrough]];
+        }
+        case (Preparing):
+        {
+            const auto prepareResult = prepare();
+            if (!prepareResult.has_value())
+            {
+                Log::error("DownloadOperation: Failed to prepare operation: {}", prepareResult.error().toString());
+                return enterErrorState<WorkStatus>(prepareResult.error());
+            }
+            state_ = Prepared;
+            [[fallthrough]];
+        }
+        case (Prepared):
+        {
+            state_ = Running;
+            [[fallthrough]];
+        }
+        case (Running):
+        {
+            const auto result = readOnce();
+            if (!result.has_value())
+            {
+                Log::error("DownloadOperation: Failed to read file: {}", result.error().toString());
+                return enterErrorState<WorkStatus>(result.error());
+            }
+            if (result.value())
+            {
+                return WorkStatus::MoreWork;
+            }
+            // No More to read?
+            else
+            {
+                Log::info("DownloadOperation: Data reading completed.");
+                state_ = Finalizing;
+                [[fallthrough]];
+            }
+        }
+        case (Finalizing):
+        {
+            const auto finalizeResult = finalize();
+            if (!finalizeResult.has_value())
+            {
+                Log::error("DownloadOperation: Failed to finalize operation: {}", finalizeResult.error().toString());
+                return enterErrorState<WorkStatus>(finalizeResult.error());
+            }
+            state_ = Completed;
+            Log::info("DownloadOperation: Operation completed successfully.");
+            return WorkStatus::Complete;
+        }
+        case (Completed):
+        {
+            Log::warn("DownloadOperation: Operation already completed.");
+            // Dont enter error state here, it would overwrite the success state.
+            return std::unexpected(Error{.type = ErrorType::CannotWorkCompletedOperation});
+        }
+        case (Failed):
+        {
+            Log::warn("DownloadOperation: Operation already failed.");
+            // Do not enter error state here, it would overwrite the error state.
+            return std::unexpected(Error{.type = ErrorType::CannotWorkFailedOperation});
+        }
+        default:
+        {
+        }
+    }
+    Log::error("DownloadOperation: Unknown operation state: {}", static_cast<int>(state_));
+    return enterErrorState<WorkStatus>({.type = ErrorType::UnknownWorkState});
+}
+
+std::expected<bool, DownloadOperation::Error> DownloadOperation::readOnce()
+{
+    std::scoped_lock lock{mutex_};
+
+    if (state_ < OperationState::Prepared)
+    {
+        Log::error("DownloadOperation: Operation not prepared.");
+        return enterErrorState<bool>({.type = ErrorType::OperationNotPrepared});
+    }
+
+    if (!localFile_.is_open())
+    {
+        Log::error("DownloadOperation: File is not open.");
+        return enterErrorState<bool>({.type = ErrorType::OpenFailure});
+    }
+
+    if (fileSize_ == 0)
+    {
+        Log::info("DownloadOperation: Remote file is empty, nothing to do.");
+        return false;
+    }
+
+    auto stream = fileStream_.lock();
+    if (!stream)
+    {
+        Log::error("DownloadOperation: File stream expired.");
+        return enterErrorState<bool>({.type = ErrorType::FileStreamExpired});
+    }
+
+    bool doContinue = false;
+    const auto futureStatus =
+        stream
+            ->read([this, &doContinue](std::string_view data) {
+                if (data.size() == 0)
+                {
+                    Log::info("DownloadOperation: Remote file read complete or error.");
+                    return doContinue = false;
+                }
+
+                std::uint64_t tellp = 0;
+                std::uint64_t fileSize = 0;
+                bool good = true;
+                {
+                    std::scoped_lock lock{mutex_};
+                    localFile_.write(data.data(), data.size());
+                    tellp = static_cast<uint64_t>(localFile_.tellp());
+                    fileSize = fileSize_;
+                    good = localFile_.good();
+                    progressCallback_(0, fileSize, tellp);
+                }
+                if (!good)
+                {
+                    Log::error("DownloadOperation read cycle stopped: localFile_.good() == false");
+                    std::ignore = this->enterErrorState({
+                        .type = OperationErrorType::TargetFileNotGood,
+                    });
+                    return doContinue = false;
+                }
+                return doContinue = good && tellp < fileSize;
+            })
+            .wait_for(futureTimeout_);
+
+    if (futureStatus != std::future_status::ready)
+    {
+        Log::error("DownloadOperation: Future timed out while reading.");
+        return enterErrorState<bool>({.type = ErrorType::FutureTimeout});
+    }
+
+    return doContinue;
+}
+
 std::expected<void, DownloadOperation::Error> DownloadOperation::openOrAdoptFile(SecureShell::IFileStream& stream)
 {
     std::scoped_lock lock{mutex_};
@@ -67,7 +201,7 @@ std::expected<void, DownloadOperation::Error> DownloadOperation::openOrAdoptFile
         if (!localFile_.is_open())
         {
             Log::error("DownloadOperation: Failed to open file for appending: {}", tempPath);
-            return std::unexpected(Error{.type = ErrorType::OpenFailure});
+            return enterErrorState({.type = ErrorType::OpenFailure});
         }
 
         // File complete but not renamed? just rename it in the finalize() step
@@ -91,7 +225,7 @@ std::expected<void, DownloadOperation::Error> DownloadOperation::openOrAdoptFile
             // Seek stream to position:
             auto seekResult = stream.seek(localFile_.tellp()).get();
             if (!seekResult.has_value())
-                return std::unexpected(Error{.type = ErrorType::FileStatFailed});
+                return enterErrorState({.type = ErrorType::FileStatFailed});
         }
     }
     else
@@ -103,7 +237,7 @@ std::expected<void, DownloadOperation::Error> DownloadOperation::openOrAdoptFile
     if (!localFile_.is_open())
     {
         Log::error("DownloadOperation: Failed to open file: {}", tempPath);
-        return std::unexpected(Error{.type = ErrorType::OpenFailure});
+        return enterErrorState({.type = ErrorType::OpenFailure});
     }
 
     return {};
@@ -116,7 +250,7 @@ std::expected<void, Operation::Error> DownloadOperation::prepare()
     if (localPath_.empty())
     {
         Log::error("DownloadOperation: Invalid local path.");
-        return std::unexpected(Error{.type = ErrorType::InvalidPath});
+        return enterErrorState({.type = ErrorType::InvalidPath});
     }
 
     // Initial check. Check again later before rename
@@ -126,7 +260,7 @@ std::expected<void, Operation::Error> DownloadOperation::prepare()
         {
             Log::error(
                 "DownloadOperation: File '{}' already exists and may not be overwritten.", localPath_.generic_string());
-            return std::unexpected(Error{.type = ErrorType::FileExists});
+            return enterErrorState({.type = ErrorType::FileExists});
         }
     }
 
@@ -134,14 +268,14 @@ std::expected<void, Operation::Error> DownloadOperation::prepare()
     if (!stream)
     {
         Log::error("DownloadOperation: File stream expired.");
-        return std::unexpected(Error{.type = ErrorType::FileStreamExpired});
+        return enterErrorState({.type = ErrorType::FileStreamExpired});
     }
 
     const auto fileInfo = stream->stat().get();
     if (!fileInfo.has_value())
     {
         Log::error("DownloadOperation: Failed to stat file.");
-        return std::unexpected(Error{.type = ErrorType::FileStatFailed, .sftpError = fileInfo.error()});
+        return enterErrorState({.type = ErrorType::FileStatFailed, .sftpError = fileInfo.error()});
     }
 
     fileSize_ = fileInfo->size;
@@ -150,7 +284,7 @@ std::expected<void, Operation::Error> DownloadOperation::prepare()
     if (!openResult.has_value())
     {
         Log::error("DownloadOperation: Failed to open file.");
-        return std::unexpected(std::move(openResult).error());
+        return enterErrorState(std::move(openResult).error());
     }
 
     if (reserveSpace_ && fileSize_ != 0)
@@ -161,7 +295,10 @@ std::expected<void, Operation::Error> DownloadOperation::prepare()
         localFile_.seekp(fileSize_ - 1);
         localFile_.put('\0');
         if (localFile_.fail())
-            return std::unexpected(Error{.type = ErrorType::OpenFailure});
+        {
+            Log::error("DownloadOperation: Failed to open file.");
+            return enterErrorState({.type = ErrorType::OpenFailure});
+        }
         localFile_.seekp(pos);
     }
 
@@ -170,116 +307,25 @@ std::expected<void, Operation::Error> DownloadOperation::prepare()
         remotePath_.generic_string(),
         localPath_.generic_string());
 
-    preparationDone_ = true;
     return {};
 }
-std::expected<void, Operation::Error> DownloadOperation::start()
-{
-    std::scoped_lock lock{mutex_};
-    interuptRead_ = false;
-
-    if (!preparationDone_)
-    {
-        Log::error("DownloadOperation: Operation not prepared.");
-        return std::unexpected(Error{.type = ErrorType::OperationNotPrepared});
-    }
-
-    if (!localFile_.is_open())
-    {
-        Log::error("DownloadOperation: File is not open.");
-        return std::unexpected(Error{.type = ErrorType::OpenFailure});
-    }
-
-    if (fileSize_ == 0)
-    {
-        Log::info("DownloadOperation: Remote file is empty, nothing to do.");
-        return {};
-    }
-
-    auto stream = fileStream_.lock();
-    if (!stream)
-    {
-        Log::error("DownloadOperation: File stream expired.");
-        return std::unexpected(Error{.type = ErrorType::FileStreamExpired});
-    }
-
-    isReading_ = true;
-    readFuture_ = stream->read([this](std::string_view data) {
-        if (data.size() == 0)
-        {
-            {
-                std::lock_guard lock{mutex_};
-                isReading_ = false;
-            }
-            Log::info("DownloadOperation: Remote file read complete or error.");
-            // Defer completion by pushing it onto the strand.
-            perform([this]() {
-                std::scoped_lock lock{mutex_};
-                onCompletionCallback_(true);
-            });
-            return true;
-        }
 
-        std::uint64_t fileSize = 0;
-        std::uint64_t tellp = 0;
-        bool doContinue = true;
-        bool good = true;
-        {
-            std::scoped_lock lock{mutex_};
-            localFile_.write(data.data(), data.size());
-            fileSize = fileSize_;
-            tellp = static_cast<uint64_t>(localFile_.tellp());
-            good = localFile_.good();
-            doContinue = good && !interuptRead_;
-            isReading_ = doContinue;
-        }
-        progressCallback_(0, fileSize, tellp);
-        if (!doContinue)
-        {
-            if (!good)
-            {
-                Log::error("DownloadOperation read cycle stopped: localFile_.good() == false");
-                perform([this]() {
-                    std::scoped_lock lock{mutex_};
-                    onCompletionCallback_(false);
-                });
-            }
-        }
-        return doContinue;
-    });
-
-    return {};
-}
-std::expected<void, DownloadOperation::Error> DownloadOperation::cancel()
+std::expected<void, DownloadOperation::Error> DownloadOperation::cancel(bool adoptCancelState)
 {
-    {
-        std::scoped_lock lock{mutex_};
-
-        if (isReading_)
-        {
-            const auto res = pause();
-            if (!res.has_value())
-            {
-                Log::error("DownloadOperation: Failed to pause download.");
-                return res;
-            }
-        }
+    std::scoped_lock lock{mutex_};
 
-        Log::info(
-            "DownloadOperation: Download of '{}' to '{}' canceled.",
-            remotePath_.generic_string(),
-            localPath_.generic_string());
-    }
+    Log::info(
+        "DownloadOperation: Download of '{}' to '{}' canceled.",
+        remotePath_.generic_string(),
+        localPath_.generic_string());
 
-    perform([this]() {
-        std::scoped_lock lock{mutex_};
-        onCompletionCallback_(false);
-    });
+    if (adoptCancelState)
+        state_ = OperationState::Canceled;
 
     cleanup();
-
     return {};
 }
+
 void DownloadOperation::cleanup()
 {
     std::scoped_lock lock{mutex_};
@@ -291,40 +337,17 @@ void DownloadOperation::cleanup()
     if (auto stream = fileStream_.lock(); stream)
         stream->close(false);
 }
-std::expected<void, DownloadOperation::Error> DownloadOperation::pause()
-{
-    {
-        std::scoped_lock lock{mutex_};
-        interuptRead_ = true;
-    }
 
-    if (readFuture_.wait_for(futureTimeout_) != std::future_status::ready)
-    {
-        Log::error("DownloadOperation: Failed to pause download.");
-        return std::unexpected(Error{.type = ErrorType::FutureTimeout});
-    }
-    {
-        std::scoped_lock lock{mutex_};
-        isReading_ = false;
-    }
-    return {};
-}
 std::expected<void, DownloadOperation::Error> DownloadOperation::finalize()
 {
     std::scoped_lock lock{mutex_};
 
-    if (isReading_)
+    if (state_ == OperationState::Running)
     {
         Log::error("DownloadOperation: Cannot finalize while reading.");
         return std::unexpected(Error{.type = ErrorType::CannotFinalizeDuringRead});
     }
 
-    if (readFuture_.wait_for(futureTimeout_) != std::future_status::ready)
-    {
-        Log::error("DownloadOperation: Failed to wait for download completion.");
-        return std::unexpected(Error{.type = ErrorType::FutureTimeout});
-    }
-
     localFile_.close();
 
     if (std::filesystem::exists(localPath_) && !mayOverwrite_)
diff --git a/backend/source/backend/sftp/operation_queue.cpp b/backend/source/backend/sftp/operation_queue.cpp
index 7638890d..f2a1b287 100644
--- a/backend/source/backend/sftp/operation_queue.cpp
+++ b/backend/source/backend/sftp/operation_queue.cpp
@@ -1,18 +1,98 @@
 #include <backend/sftp/operation_queue.hpp>
 
 #include <log/log.hpp>
+#include <utility/overloaded.hpp>
 
-OperationQueue::OperationQueue()
-    : operations_{}
-{}
-void OperationQueue::start()
-{}
-void OperationQueue::pause()
+namespace
+{
+    OperationQueue::CompletedOperation makeCompletedOperation(
+        OperationQueue::CompletionReason reason,
+        Ids::OperationId id,
+        Operation const& operation,
+        std::optional<Operation::Error> error = std::nullopt)
+    {
+        return operation.visit(
+            Utility::overloaded(
+                [reason, id, error](DownloadOperation const& op) {
+                    return OperationQueue::CompletedOperation{
+                        .reason = reason,
+                        .id = id,
+                        .completionTime = std::chrono::system_clock::now(),
+                        .localPath = op.localPath(),
+                        .remotePath = op.remotePath(),
+                        .error = error,
+                    };
+                },
+                [reason, id](std::nullopt_t) {
+                    return OperationQueue::CompletedOperation{
+                        .reason = reason,
+                        .id = id,
+                        .completionTime = std::chrono::system_clock::now(),
+                    };
+                }));
+    }
+}
+
+OperationQueue::OperationQueue(int parallelism)
+    : parallelism_{parallelism}
 {}
+
 void OperationQueue::cancelAll()
-{}
+{
+    std::scoped_lock lock{mutex_};
+    operations_.clear();
+    Log::info("All operations in the queue have been canceled.");
+}
 void OperationQueue::cancel(Ids::OperationId id)
-{}
+{
+    std::scoped_lock lock{mutex_};
+    std::erase_if(operations_, [id](const auto& op) {
+        return op.first == id;
+    });
+}
+
+bool OperationQueue::update()
+{
+    std::scoped_lock lock{mutex_};
+    const auto updateCount = std::min(operations_.size(), static_cast<std::size_t>(parallelism_));
+
+    bool moreWork = false;
+    if (updateCount == 0)
+    {
+        return false;
+    }
+
+    for (std::size_t i = 0; i < updateCount; ++i)
+    {
+        auto& [id, operation] = operations_[i];
+        const auto workResult = operation->work();
+        if (!workResult.has_value())
+        {
+            Log::error("Operation failed: {}", workResult.error().toString());
+            completedOperations_.push_back(
+                makeCompletedOperation(OperationQueue::CompletionReason::Failed, id, *operation, workResult.error()));
+            continue;
+        }
+
+        const auto workStatus = workResult.value();
+        if (workStatus == Operation::WorkStatus::Complete)
+        {
+            Log::info("Operation completed successfully: {}", id.value());
+            completedOperations_.push_back(
+                makeCompletedOperation(OperationQueue::CompletionReason::Completed, id, *operation));
+            operations_.pop_front();
+            // Exit loop and avoid any offset math. Just do another update cycle.
+            return true;
+        }
+        else if (workStatus == Operation::WorkStatus::MoreWork)
+        {
+            moreWork = true;
+            continue;
+        }
+    }
+    return moreWork;
+}
+
 std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
     Persistence::State const& state,
     std::string const& sshSessionOptionsKey,
@@ -63,6 +143,7 @@ std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
                 transferOptions.customPermissions ? transferOptions.customPermissions : defaultOptions.permissions,
         });
 
+    std::scoped_lock lock{mutex_};
     operations_.emplace_back(id, std::move(operation));
     return {};
 }
\ No newline at end of file
diff --git a/backend/source/backend/ssh_session_manager.cpp b/backend/source/backend/ssh_session_manager.cpp
index 61be0711..f473c3e5 100644
--- a/backend/source/backend/ssh_session_manager.cpp
+++ b/backend/source/backend/ssh_session_manager.cpp
@@ -4,6 +4,7 @@
 #include <boost/uuid/uuid_generators.hpp>
 #include <boost/uuid/uuid.hpp>
 #include <boost/uuid/uuid_io.hpp>
+#include <boost/asio/dispatch.hpp>
 #include <libssh/libssh.h>
 #include <roar/utility/base64.hpp>
 #include <roar/filesystem/special_paths.hpp>
@@ -59,8 +60,9 @@ int askPassDefault(char const* prompt, char* buf, std::size_t length, int, int,
     return -1;
 }
 
-SshSessionManager::SshSessionManager(Persistence::StateHolder* stateHolder)
-    : stateHolder_(stateHolder)
+SshSessionManager::SshSessionManager(boost::asio::any_io_executor executor, Persistence::StateHolder* stateHolder)
+    : executor_{std::move(executor)}
+    , stateHolder_(stateHolder)
 {}
 
 SshSessionManager::~SshSessionManager()
@@ -512,6 +514,7 @@ void SshSessionManager::registerRpcSftpListDirectory(Nui::Window&, Nui::RpcHub&
                     return;
                 }
 
+                dispatchUpdates();
                 hub->callRemote(responseId, nlohmann::json{{"entries", *result}});
             }
             catch (std::exception const& e)
@@ -576,6 +579,7 @@ void SshSessionManager::registerRpcSftpCreateDirectory(Nui::Window&, Nui::RpcHub
                     return;
                 }
 
+                dispatchUpdates();
                 hub->callRemote(responseId, nlohmann::json{{"success", true}});
             }
             catch (std::exception const& e)
@@ -640,6 +644,7 @@ void SshSessionManager::registerRpcSftpCreateFile(Nui::Window&, Nui::RpcHub& hub
                     return;
                 }
 
+                dispatchUpdates();
                 hub->callRemote(responseId, nlohmann::json{{"success", true}});
             }
             catch (std::exception const& exc)
@@ -701,10 +706,42 @@ void SshSessionManager::registerRpcSftpAddDownloadOperation(Nui::Window&, Nui::R
                 return;
             }
 
+            dispatchUpdates();
             hub->callRemote(responseId, nlohmann::json{{"success", true}});
         });
 }
 
+void SshSessionManager::startUpdateDispatching()
+{
+    updateDispatchRunning_ = true;
+    dispatchUpdates();
+}
+void SshSessionManager::stopUpdateDispatching()
+{
+    updateDispatchRunning_ = false;
+}
+
+void SshSessionManager::dispatchUpdates()
+{
+    if (!updateDispatchRunning_)
+        return;
+
+    boost::asio::dispatch(executor_, [weak = weak_from_this()]() {
+        auto self = weak.lock();
+        if (!self)
+            return;
+
+        if (!self->updateDispatchRunning_)
+        {
+            Log::info("Update dispatching stopped");
+            return;
+        }
+
+        if (self->operationQueue_.update())
+            self->dispatchUpdates();
+    });
+}
+
 void SshSessionManager::registerRpc(Nui::Window& wnd, Nui::RpcHub& hub)
 {
     registerRpcConnect(wnd, hub);
diff --git a/backend/test/backend/test_download_operation.hpp b/backend/test/backend/test_download_operation.hpp
index aac4cacd..a03a4267 100644
--- a/backend/test/backend/test_download_operation.hpp
+++ b/backend/test/backend/test_download_operation.hpp
@@ -8,11 +8,9 @@
 
 #include <gtest/gtest.h>
 
-#include <thread>
+#include <queue>
 #include <string>
 #include <memory>
-#include <tuple>
-#include <vector>
 
 using namespace std::chrono_literals;
 using namespace std::string_literals;
@@ -60,10 +58,11 @@ namespace Test
                     [size = size.value()]()
                         -> std::future<std::expected<SecureShell::FileInformation, SecureShell::SftpError>> {
                         std::promise<std::expected<SecureShell::FileInformation, SecureShell::SftpError>> promise;
-                        promise.set_value(SecureShell::FileInformation{{
-                            .size = size,
-                            .permissions = std::filesystem::perms::owner_all,
-                        }});
+                        promise.set_value(
+                            SecureShell::FileInformation{{
+                                .size = size,
+                                .permissions = std::filesystem::perms::owner_all,
+                            }});
                         return promise.get_future();
                     });
         }
@@ -76,41 +75,45 @@ namespace Test
                         -> std::future<std::expected<std::size_t, SecureShell::SftpError>> {
                         onRead_ = std::move(cb);
                         readPromise_ = {};
+                        if (!readCycleQueue_.empty())
+                        {
+                            readCycleQueue_.front()();
+                            readCycleQueue_.pop();
+                        }
                         return readPromise_.get_future();
                     });
         }
 
-        void fakeReadCycle(std::optional<std::size_t> chunkSizeOpt)
+        void enqueueFakeReadCycle(std::optional<std::size_t> chunkSizeOpt = std::nullopt)
         {
-            auto chunkSize = fakeFileContent_.size();
-            if (chunkSizeOpt)
-                chunkSize = chunkSizeOpt.value();
-
-            if (readOffset_ + chunkSize > fakeFileContent_.size())
-                chunkSize = fakeFileContent_.size() - readOffset_;
-
-            // EOF:
-            if (chunkSize == 0)
-            {
-                readPromise_.set_value(readOffset_);
-                onReadResult_ = onRead_({});
-                return;
-            }
-
-            if (onRead_)
-            {
-                onReadResult_ = onRead_(std::string_view{fakeFileContent_}.substr(readOffset_, chunkSize));
-                readOffset_ += chunkSize;
-                if (!onReadResult_)
+            readCycleQueue_.push([this, chunkSizeOpt]() {
+                auto chunkSize = fakeFileContent_.size();
+                if (chunkSizeOpt)
+                    chunkSize = chunkSizeOpt.value();
+
+                if (readOffset_ + chunkSize > fakeFileContent_.size())
+                    chunkSize = fakeFileContent_.size() - readOffset_;
+
+                // EOF:
+                if (chunkSize == 0)
                 {
                     readPromise_.set_value(readOffset_);
+                    onReadResult_ = onRead_({});
                     return;
                 }
-            }
-            else
-            {
-                throw std::runtime_error("No read callback set.");
-            }
+
+                if (onRead_)
+                {
+                    onReadResult_ = onRead_(std::string_view{fakeFileContent_}.substr(readOffset_, chunkSize));
+                    readOffset_ += chunkSize;
+                    readPromise_.set_value(readOffset_);
+                    return;
+                }
+                else
+                {
+                    throw std::runtime_error("No read callback set.");
+                }
+            });
         }
 
         std::string readFile(std::filesystem::path const& path)
@@ -127,6 +130,7 @@ namespace Test
         std::promise<std::expected<std::size_t, SecureShell::SftpError>> readPromise_{};
         std::function<bool(std::string_view data)> onRead_{};
         std::size_t readOffset_{0};
+        std::queue<std::function<void()>> readCycleQueue_{};
         bool onReadResult_{true};
     };
 
@@ -190,9 +194,11 @@ namespace Test
 
         EXPECT_CALL(*fileStream, stat()).WillOnce([]() -> std::future<std::expected<FileInformation, SftpError>> {
             std::promise<std::expected<FileInformation, SftpError>> promise;
-            promise.set_value(std::unexpected(SftpError{
-                .message = "Stat failed",
-            }));
+            promise.set_value(
+                std::unexpected(
+                    SftpError{
+                        .message = "Stat failed",
+                    }));
             return promise.get_future();
         });
 
@@ -217,9 +223,10 @@ namespace Test
         EXPECT_CALL(*fileStream, stat())
             .WillOnce([]() -> std::future<std::expected<FileInformation, SecureShell::SftpError>> {
                 std::promise<std::expected<FileInformation, SecureShell::SftpError>> promise;
-                promise.set_value(FileInformation{{
-                    .size = 0,
-                }});
+                promise.set_value(
+                    FileInformation{{
+                        .size = 0,
+                    }});
                 return promise.get_future();
             });
 
@@ -241,9 +248,10 @@ namespace Test
         EXPECT_CALL(*fileStream, stat())
             .WillOnce([]() -> std::future<std::expected<FileInformation, SecureShell::SftpError>> {
                 std::promise<std::expected<FileInformation, SecureShell::SftpError>> promise;
-                promise.set_value(FileInformation{{
-                    .size = 42,
-                }});
+                promise.set_value(
+                    FileInformation{{
+                        .size = 42,
+                    }});
                 return promise.get_future();
             });
 
@@ -265,9 +273,10 @@ namespace Test
         EXPECT_CALL(*fileStream, stat())
             .WillOnce([]() -> std::future<std::expected<FileInformation, SecureShell::SftpError>> {
                 std::promise<std::expected<FileInformation, SecureShell::SftpError>> promise;
-                promise.set_value(FileInformation{{
-                    .size = 42,
-                }});
+                promise.set_value(
+                    FileInformation{{
+                        .size = 42,
+                    }});
                 return promise.get_future();
             });
 
@@ -296,9 +305,10 @@ namespace Test
             EXPECT_CALL(*fileStream, stat())
                 .WillOnce([]() -> std::future<std::expected<FileInformation, SecureShell::SftpError>> {
                     std::promise<std::expected<FileInformation, SecureShell::SftpError>> promise;
-                    promise.set_value(FileInformation{{
-                        .size = 42,
-                    }});
+                    promise.set_value(
+                        FileInformation{{
+                            .size = 42,
+                        }});
                     return promise.get_future();
                 });
 
@@ -327,9 +337,10 @@ namespace Test
             EXPECT_CALL(*fileStream, stat())
                 .WillOnce([]() -> std::future<std::expected<FileInformation, SecureShell::SftpError>> {
                     std::promise<std::expected<FileInformation, SecureShell::SftpError>> promise;
-                    promise.set_value(FileInformation{{
-                        .size = 42,
-                    }});
+                    promise.set_value(
+                        FileInformation{{
+                            .size = 42,
+                        }});
                     return promise.get_future();
                 });
 
@@ -361,7 +372,7 @@ namespace Test
         EXPECT_TRUE(result.has_value());
         EXPECT_TRUE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
 
-        EXPECT_TRUE(operation.cancel().has_value());
+        EXPECT_TRUE(operation.cancel(true).has_value());
 
         EXPECT_TRUE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
     }
@@ -380,9 +391,10 @@ namespace Test
         EXPECT_CALL(*fileStream, stat())
             .WillOnce([]() -> std::future<std::expected<FileInformation, SecureShell::SftpError>> {
                 std::promise<std::expected<FileInformation, SecureShell::SftpError>> promise;
-                promise.set_value(FileInformation{{
-                    .size = 42,
-                }});
+                promise.set_value(
+                    FileInformation{{
+                        .size = 42,
+                    }});
                 return promise.get_future();
             });
 
@@ -392,42 +404,12 @@ namespace Test
         EXPECT_TRUE(result.has_value());
         EXPECT_TRUE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
 
-        EXPECT_TRUE(operation.cancel().has_value());
+        EXPECT_TRUE(operation.cancel(true).has_value());
 
         EXPECT_FALSE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
     }
 
-    TEST_F(DownloadOperationTests, CancelCallsTheCompletionHandler)
-    {
-        using namespace SecureShell;
-
-        std::promise<bool> completionPromise;
-
-        auto options = DownloadOperation::DownloadOperationOptions{
-            .onCompletionCallback =
-                [&completionPromise](bool success) {
-                    completionPromise.set_value(success);
-                },
-            .localPath = isolateDirectory_.path() / "file.txt",
-            .doCleanup = true,
-        };
-
-        const auto fileStream = makeFileStreamMock();
-        giveMockDefaultStat(fileStream);
-
-        DownloadOperation operation{fileStream, options};
-
-        auto result = operation.prepare();
-        EXPECT_TRUE(result.has_value());
-        EXPECT_TRUE(operation.cancel().has_value());
-
-        auto future = completionPromise.get_future();
-        ASSERT_EQ(future.wait_for(1s), std::future_status::ready);
-        // Cancel is a failure
-        EXPECT_FALSE(future.get());
-    }
-
-    TEST_F(DownloadOperationTests, StartWithEmptyRemoteFileSucceeds)
+    TEST_F(DownloadOperationTests, WorkWithEmptyRemoteFileSucceeds)
     {
         using namespace SecureShell;
 
@@ -439,29 +421,11 @@ namespace Test
         };
         DownloadOperation operation{fileStream, options};
 
-        auto result = operation.prepare();
-        EXPECT_TRUE(result.has_value());
-
-        result = operation.start();
+        const auto result = operation.work();
         EXPECT_TRUE(result.has_value());
     }
 
-    TEST_F(DownloadOperationTests, StartWithoutPrepareFails)
-    {
-        using namespace SecureShell;
-
-        auto fileStream = makeFileStreamMock();
-        auto options = DownloadOperation::DownloadOperationOptions{
-            .localPath = isolateDirectory_.path() / "file.txt",
-        };
-        DownloadOperation operation{fileStream, options};
-
-        auto result = operation.start();
-        EXPECT_FALSE(result.has_value());
-        EXPECT_EQ(result.error().type, DownloadOperation::ErrorType::OperationNotPrepared);
-    }
-
-    TEST_F(DownloadOperationTests, StartFailsWithExpiredFileStream)
+    TEST_F(DownloadOperationTests, WorkFailsWithExpiredFileStream)
     {
         using namespace SecureShell;
 
@@ -478,12 +442,12 @@ namespace Test
 
         fileStream.reset();
 
-        result = operation.start();
-        EXPECT_FALSE(result.has_value());
-        EXPECT_EQ(result.error().type, DownloadOperation::ErrorType::FileStreamExpired);
+        const auto workResult = operation.work();
+        EXPECT_FALSE(workResult.has_value());
+        EXPECT_EQ(workResult.error().type, DownloadOperation::ErrorType::FileStreamExpired);
     }
 
-    TEST_F(DownloadOperationTests, StartCallsReadOnFileStream)
+    TEST_F(DownloadOperationTests, WorkCallsReadOnFileStream)
     {
         using namespace SecureShell;
 
@@ -496,10 +460,9 @@ namespace Test
         };
         DownloadOperation operation{fileStream, options};
 
-        auto result = operation.prepare();
-        EXPECT_TRUE(result.has_value());
+        enqueueFakeReadCycle();
 
-        result = operation.start();
+        const auto result = operation.work();
         EXPECT_TRUE(result.has_value());
     }
 
@@ -521,7 +484,7 @@ namespace Test
         auto result = operation.prepare();
         EXPECT_TRUE(result.has_value());
 
-        EXPECT_TRUE(operation.cancel().has_value());
+        EXPECT_TRUE(operation.cancel(true).has_value());
 
         EXPECT_EQ(
             std::filesystem::file_size(options.localPath.generic_string() + ".filepart"), fakeFileContent_.size());
@@ -541,208 +504,17 @@ namespace Test
         };
         DownloadOperation operation{fileStream, options};
 
-        auto result = operation.prepare();
-        EXPECT_TRUE(result.has_value());
+        enqueueFakeReadCycle(5);
 
-        result = operation.start();
+        const auto result = operation.work();
         EXPECT_TRUE(result.has_value());
 
-        fakeReadCycle(5);
-        fakeReadCycle(0); // EOF Cycle
-
-        EXPECT_TRUE(operation.cancel().has_value());
+        EXPECT_TRUE(operation.cancel(false).has_value());
 
         EXPECT_EQ(std::filesystem::file_size(options.localPath.generic_string() + ".filepart"), 5);
         EXPECT_EQ(readFile(options.localPath.generic_string() + ".filepart"), fakeFileContent_.substr(0, 5));
     }
 
-    TEST_F(DownloadOperationTests, ReadWritesFileThroughMultipleCycles)
-    {
-        using namespace SecureShell;
-
-        auto fileStream = makeFileStreamMock();
-        giveMockDefaultStat(fileStream, fakeFileContent_.size());
-        giveMockExpectedRead(fileStream);
-
-        auto options = DownloadOperation::DownloadOperationOptions{
-            .localPath = isolateDirectory_.path() / "file.txt",
-            .doCleanup = false,
-        };
-        DownloadOperation operation{fileStream, options};
-
-        auto result = operation.prepare();
-        EXPECT_TRUE(result.has_value());
-
-        result = operation.start();
-        EXPECT_TRUE(result.has_value());
-
-        for (std::size_t i = 0; i < fakeFileContent_.size(); ++i)
-            fakeReadCycle(1);
-        fakeReadCycle(0); // EOF Cycle
-
-        EXPECT_TRUE(operation.cancel().has_value());
-
-        EXPECT_EQ(
-            std::filesystem::file_size(options.localPath.generic_string() + ".filepart"), fakeFileContent_.size());
-        EXPECT_EQ(readFile(options.localPath.generic_string() + ".filepart"), fakeFileContent_);
-    }
-
-    TEST_F(DownloadOperationTests, ReadWritesFileThroughSingleCycle)
-    {
-        using namespace SecureShell;
-
-        auto fileStream = makeFileStreamMock();
-        giveMockDefaultStat(fileStream, fakeFileContent_.size());
-        giveMockExpectedRead(fileStream);
-
-        auto options = DownloadOperation::DownloadOperationOptions{
-            .localPath = isolateDirectory_.path() / "file.txt",
-            .doCleanup = false,
-        };
-        DownloadOperation operation{fileStream, options};
-
-        auto result = operation.prepare();
-        EXPECT_TRUE(result.has_value());
-
-        result = operation.start();
-        EXPECT_TRUE(result.has_value());
-
-        fakeReadCycle(fakeFileContent_.size());
-        fakeReadCycle(0); // EOF Cycle
-
-        EXPECT_TRUE(operation.cancel().has_value());
-
-        EXPECT_EQ(
-            std::filesystem::file_size(options.localPath.generic_string() + ".filepart"), fakeFileContent_.size());
-        EXPECT_EQ(readFile(options.localPath.generic_string() + ".filepart"), fakeFileContent_);
-    }
-
-    TEST_F(DownloadOperationTests, CanPauseRead)
-    {
-        using namespace SecureShell;
-
-        auto fileStream = makeFileStreamMock();
-        giveMockDefaultStat(fileStream, fakeFileContent_.size());
-        giveMockExpectedRead(fileStream);
-
-        auto options = DownloadOperation::DownloadOperationOptions{
-            .localPath = isolateDirectory_.path() / "file.txt",
-            .doCleanup = false,
-        };
-        DownloadOperation operation{fileStream, options};
-
-        auto result = operation.prepare();
-        EXPECT_TRUE(result.has_value());
-
-        result = operation.start();
-        EXPECT_TRUE(result.has_value());
-
-        fakeReadCycle(5);
-
-        std::expected<void, DownloadOperation::Error> pauseResult;
-        std::promise<void> threadStarted;
-        std::thread asyncPause{[&operation, &pauseResult, &threadStarted]() {
-            threadStarted.set_value();
-            pauseResult = operation.pause();
-        }};
-        threadStarted.get_future().wait();
-        // dont know actually how to wait for the pause, except for burdening the wait on the user.
-        std::this_thread::sleep_for(200ms);
-
-        // This one still goes through but now signals a stop to the read.
-        fakeReadCycle(5);
-
-        asyncPause.join();
-
-        EXPECT_TRUE(operation.cancel().has_value());
-
-        EXPECT_EQ(onReadResult_, false);
-        EXPECT_EQ(std::filesystem::file_size(options.localPath.generic_string() + ".filepart"), 10);
-        EXPECT_EQ(readFile(options.localPath.generic_string() + ".filepart"), fakeFileContent_.substr(0, 10));
-    }
-
-    TEST_F(DownloadOperationTests, CanContinueReadingAfterPause)
-    {
-        using namespace SecureShell;
-
-        auto fileStream = makeFileStreamMock();
-        giveMockDefaultStat(fileStream, fakeFileContent_.size());
-        giveMockExpectedRead(fileStream);
-
-        auto options = DownloadOperation::DownloadOperationOptions{
-            .localPath = isolateDirectory_.path() / "file.txt",
-            .doCleanup = false,
-        };
-        DownloadOperation operation{fileStream, options};
-
-        auto result = operation.prepare();
-        EXPECT_TRUE(result.has_value());
-
-        result = operation.start();
-        EXPECT_TRUE(result.has_value());
-
-        fakeReadCycle(5);
-
-        std::expected<void, DownloadOperation::Error> pauseResult;
-        std::promise<void> threadStarted;
-        std::thread asyncPause{[&operation, &pauseResult, &threadStarted]() {
-            threadStarted.set_value();
-            pauseResult = operation.pause();
-        }};
-        threadStarted.get_future().wait();
-        // dont know actually how to wait for the pause, except for burdening the wait on the user.
-        std::this_thread::sleep_for(200ms);
-
-        // This one still goes through but now signals a stop to the read.
-        fakeReadCycle(5);
-
-        asyncPause.join();
-
-        EXPECT_EQ(onReadResult_, false);
-
-        result = operation.start();
-        EXPECT_TRUE(result.has_value());
-
-        // This one should go through and continue the read.
-        fakeReadCycle(fakeFileContent_.size() - 10);
-        fakeReadCycle(0); // EOF Cycle
-
-        result = operation.cancel();
-        EXPECT_TRUE(result.has_value());
-
-        EXPECT_EQ(onReadResult_, true);
-        EXPECT_EQ(
-            std::filesystem::file_size(options.localPath.generic_string() + ".filepart"), fakeFileContent_.size());
-        EXPECT_EQ(readFile(options.localPath.generic_string() + ".filepart"), fakeFileContent_);
-    }
-
-    TEST_F(DownloadOperationTests, CannotFinalizeWhileReading)
-    {
-        using namespace SecureShell;
-
-        auto fileStream = makeFileStreamMock();
-        giveMockDefaultStat(fileStream, fakeFileContent_.size());
-        giveMockExpectedRead(fileStream);
-
-        auto options = DownloadOperation::DownloadOperationOptions{
-            .localPath = isolateDirectory_.path() / "file.txt",
-            .doCleanup = false,
-        };
-        DownloadOperation operation{fileStream, options};
-
-        auto result = operation.prepare();
-        EXPECT_TRUE(result.has_value());
-
-        result = operation.start();
-        EXPECT_TRUE(result.has_value());
-
-        fakeReadCycle(5);
-
-        auto fin = operation.finalize();
-        EXPECT_FALSE(fin.has_value());
-        EXPECT_EQ(fin.error().type, DownloadOperation::ErrorType::CannotFinalizeDuringRead);
-    }
-
     TEST_F(DownloadOperationTests, FinalizeFailsIfFileExistsButOverwriteIsForbidden)
     {
         using namespace SecureShell;
@@ -757,15 +529,11 @@ namespace Test
         };
         DownloadOperation operation{fileStream, options};
 
-        auto result = operation.prepare();
-        EXPECT_TRUE(result.has_value());
+        enqueueFakeReadCycle();
 
-        result = operation.start();
+        const auto result = operation.work();
         EXPECT_TRUE(result.has_value());
 
-        fakeReadCycle(fakeFileContent_.size());
-        fakeReadCycle(0); // EOF Cycle
-
         {
             std::ofstream file{options.localPath};
         }
@@ -775,36 +543,6 @@ namespace Test
         EXPECT_EQ(fin.error().type, DownloadOperation::ErrorType::FileExists);
     }
 
-    TEST_F(DownloadOperationTests, CanFinalizeOperation)
-    {
-        using namespace SecureShell;
-
-        auto fileStream = makeFileStreamMock();
-        giveMockDefaultStat(fileStream, fakeFileContent_.size());
-        giveMockExpectedRead(fileStream);
-
-        auto options = DownloadOperation::DownloadOperationOptions{
-            .localPath = isolateDirectory_.path() / "file.txt",
-            .mayOverwrite = false,
-        };
-        DownloadOperation operation{fileStream, options};
-
-        auto result = operation.prepare();
-        EXPECT_TRUE(result.has_value());
-
-        result = operation.start();
-        EXPECT_TRUE(result.has_value());
-
-        fakeReadCycle(fakeFileContent_.size());
-        fakeReadCycle(0); // EOF Cycle
-
-        auto fin = operation.finalize();
-        EXPECT_TRUE(fin.has_value());
-
-        EXPECT_EQ(readFile(options.localPath), fakeFileContent_);
-        EXPECT_FALSE(std::filesystem::exists(options.localPath.generic_string() + ".filepart"));
-    }
-
     TEST_F(DownloadOperationTests, FinalizeSucceedsIfFileExistsButOverwriteIsAllowed)
     {
         using namespace SecureShell;
@@ -819,21 +557,15 @@ namespace Test
         };
         DownloadOperation operation{fileStream, options};
 
-        auto result = operation.prepare();
-        EXPECT_TRUE(result.has_value());
-
-        result = operation.start();
-        EXPECT_TRUE(result.has_value());
-
-        fakeReadCycle(fakeFileContent_.size());
-        fakeReadCycle(0); // EOF Cycle
+        enqueueFakeReadCycle();
+        enqueueFakeReadCycle(0);
 
         {
             std::ofstream file{options.localPath};
         }
 
-        auto fin = operation.finalize();
-        EXPECT_TRUE(fin.has_value());
+        auto result = operation.work();
+        EXPECT_TRUE(result.has_value());
     }
 
     TEST_F(DownloadOperationTests, ProgressCallbackIsCalledDuringRead)
@@ -856,19 +588,23 @@ namespace Test
         };
         DownloadOperation operation{fileStream, options};
 
-        auto result = operation.prepare();
-        EXPECT_TRUE(result.has_value());
+        for (std::size_t i = 0; i < fakeFileContent_.size(); ++i)
+        {
+            enqueueFakeReadCycle(1);
+        }
+        enqueueFakeReadCycle(0);
 
-        result = operation.start();
-        EXPECT_TRUE(result.has_value());
+        decltype(operation.work()) result;
+        do
+        {
+            result = operation.work();
+            ASSERT_TRUE(result.has_value());
+        } while (result.value() == DownloadOperation::WorkStatus::MoreWork);
 
-        for (std::size_t i = 0; i < fakeFileContent_.size(); ++i)
-            fakeReadCycle(1);
-        fakeReadCycle(0); // EOF Cycle
+        EXPECT_TRUE(operation.cancel(true).has_value());
 
-        EXPECT_TRUE(operation.cancel().has_value());
+        ASSERT_EQ(progressCalls.size(), fakeFileContent_.size());
 
-        EXPECT_EQ(progressCalls.size(), fakeFileContent_.size());
         for (std::size_t i = 0; i < fakeFileContent_.size(); ++i)
         {
             EXPECT_EQ(std::get<0>(progressCalls[i]), 0);
@@ -880,39 +616,4 @@ namespace Test
         EXPECT_EQ(std::get<1>(progressCalls.back()), fakeFileContent_.size());
         EXPECT_EQ(std::get<2>(progressCalls.back()), fakeFileContent_.size());
     }
-
-    TEST_F(DownloadOperationTests, CompletionCallbackIsCalled)
-    {
-        using namespace SecureShell;
-
-        std::promise<bool> completionPromise;
-
-        auto fileStream = makeFileStreamMock();
-        giveMockDefaultStat(fileStream, fakeFileContent_.size());
-        giveMockExpectedRead(fileStream);
-
-        auto options = DownloadOperation::DownloadOperationOptions{
-            .onCompletionCallback =
-                [&completionPromise](bool success) {
-                    completionPromise.set_value(success);
-                },
-            .localPath = isolateDirectory_.path() / "file.txt",
-            .doCleanup = false,
-        };
-        DownloadOperation operation{fileStream, options};
-
-        auto result = operation.prepare();
-        EXPECT_TRUE(result.has_value());
-
-        result = operation.start();
-        EXPECT_TRUE(result.has_value());
-
-        for (std::size_t i = 0; i < fakeFileContent_.size(); ++i)
-            fakeReadCycle(1);
-        fakeReadCycle(0); // EOF Cycle
-
-        auto future = completionPromise.get_future();
-        ASSERT_EQ(future.wait_for(1s), std::future_status::ready);
-        EXPECT_TRUE(future.get());
-    }
 }
\ No newline at end of file
diff --git a/frontend/include/frontend/session_components/operation_queue.hpp b/frontend/include/frontend/session_components/operation_queue.hpp
index baa791f8..f4e06553 100644
--- a/frontend/include/frontend/session_components/operation_queue.hpp
+++ b/frontend/include/frontend/session_components/operation_queue.hpp
@@ -3,6 +3,7 @@
 #include <persistence/state_holder.hpp>
 #include <frontend/dialog/confirm_dialog.hpp>
 #include <frontend/events/frontend_events.hpp>
+#include <frontend/terminal/file_engine.hpp>
 
 #include <nui/frontend/element_renderer.hpp>
 #include <roar/detail/pimpl_special_functions.hpp>
@@ -15,10 +16,16 @@ class OperationQueue
         FrontendEvents* events,
         std::string persistenceSessionName,
         std::string id,
-        ConfirmDialog* confirmDialog);
+        ConfirmDialog* confirmDialog,
+        FileEngine* fileEngine);
 
     ROAR_PIMPL_SPECIAL_FUNCTIONS(OperationQueue);
 
+    void enqueueDownload(std::filesystem::path const& remotePath, std::filesystem::path const& localPath);
+    void enqueueUpload(std::filesystem::path const& localPath, std::filesystem::path const& remotePath);
+    void enqueueRename(std::filesystem::path const& oldPath, std::filesystem::path const& newPath);
+    void enqueueDelete(std::filesystem::path const& path);
+
     Nui::ElementRenderer operator()();
 
   private:
diff --git a/frontend/source/frontend/CMakeLists.txt b/frontend/source/frontend/CMakeLists.txt
index d2c6a3d6..679415ab 100644
--- a/frontend/source/frontend/CMakeLists.txt
+++ b/frontend/source/frontend/CMakeLists.txt
@@ -20,6 +20,7 @@ target_sources(
         terminal/ssh_engine.cpp
         terminal/user_control_engine.cpp
         terminal/ssh_channel.cpp
+        components/progress_bar.cpp
 )
 
 target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_SOURCE_DIR}/frontend/include)
diff --git a/frontend/source/frontend/session.cpp b/frontend/source/frontend/session.cpp
index 42ce16ec..c7e08d87 100644
--- a/frontend/source/frontend/session.cpp
+++ b/frontend/source/frontend/session.cpp
@@ -53,10 +53,6 @@ struct Session::Implementation
     InputDialog* inputDialog;
     ConfirmDialog* confirmDialog;
 
-    // Operation Queue for File Explorer
-    OperationQueue operationQueue;
-    std::shared_ptr<Nui::Dom::Element> operationQueueElement;
-
     // File Explorer Things:
     NuiFileExplorer::FileGrid fileGrid;
     std::shared_ptr<Nui::Dom::Element> fileExplorer;
@@ -64,6 +60,10 @@ struct Session::Implementation
     std::unique_ptr<FileEngine> fileEngine;
     std::filesystem::path preNavigatePath;
 
+    // Operation Queue for File Explorer
+    OperationQueue operationQueue;
+    std::shared_ptr<Nui::Dom::Element> operationQueueElement;
+
     // Layout Engine Related
     std::weak_ptr<Nui::Dom::BasicElement> layoutHost;
     std::optional<std::string> layoutName;
@@ -103,8 +103,6 @@ struct Session::Implementation
         , options{this->engine.terminalOptions.value()}
         , inputDialog{inputDialog}
         , confirmDialog{confirmDialog}
-        , operationQueue{this->stateHolder, this->events, this->initialName, this->id, this->confirmDialog}
-        , operationQueueElement{}
         , fileGrid{{
               .pathBarOnTop = uiOptions.fileGridPathBarOnTop,
           }}
@@ -112,6 +110,8 @@ struct Session::Implementation
         , currentPath{}
         , fileEngine{}
         , preNavigatePath{}
+        , operationQueue{this->stateHolder, this->events, this->initialName, this->id, this->confirmDialog, this->fileEngine.get()}
+        , operationQueueElement{}
         , layoutHost{}
         , layoutName{std::move(layoutName)}
         , terminal{}
diff --git a/frontend/source/frontend/session_components/operation_queue.cpp b/frontend/source/frontend/session_components/operation_queue.cpp
index 88943447..5235f57f 100644
--- a/frontend/source/frontend/session_components/operation_queue.cpp
+++ b/frontend/source/frontend/session_components/operation_queue.cpp
@@ -1,4 +1,5 @@
 #include <frontend/session_components/operation_queue.hpp>
+#include <frontend/components/progress_bar.hpp>
 
 #include <nui/frontend/attributes.hpp>
 #include <nui/frontend/elements.hpp>
@@ -11,18 +12,21 @@ struct OperationQueue::Implementation
     std::string persistenceSessionName;
     std::string id;
     ConfirmDialog* confirmDialog;
+    FileEngine* fileEngine;
 
     Implementation(
         Persistence::StateHolder* stateHolder,
         FrontendEvents* events,
         std::string persistenceSessionName,
         std::string id,
-        ConfirmDialog* confirmDialog)
+        ConfirmDialog* confirmDialog,
+        FileEngine* fileEngine)
         : stateHolder{stateHolder}
         , events{events}
         , persistenceSessionName{std::move(persistenceSessionName)}
         , id{std::move(id)}
         , confirmDialog{confirmDialog}
+        , fileEngine{fileEngine}
     {}
 };
 
@@ -31,14 +35,16 @@ OperationQueue::OperationQueue(
     FrontendEvents* events,
     std::string persistenceSessionName,
     std::string id,
-    ConfirmDialog* confirmDialog)
+    ConfirmDialog* confirmDialog,
+    FileEngine* fileEngine)
     : impl_{
           std::make_unique<Implementation>(
               stateHolder,
               events,
               std::move(persistenceSessionName),
               std::move(id),
-              confirmDialog),
+              confirmDialog,
+              fileEngine),
       }
 {}
 ROAR_PIMPL_SPECIAL_FUNCTIONS_IMPL(OperationQueue);
@@ -52,4 +58,13 @@ Nui::ElementRenderer OperationQueue::operator()()
     return div{
         style = "width: 100%; height: auto; display: block",
     }("OPERATION QUEUE HERE NEW");
-}
\ No newline at end of file
+}
+
+void OperationQueue::enqueueDownload(std::filesystem::path const& remotePath, std::filesystem::path const& localPath)
+{}
+void OperationQueue::enqueueUpload(std::filesystem::path const& localPath, std::filesystem::path const& remotePath)
+{}
+void OperationQueue::enqueueRename(std::filesystem::path const& oldPath, std::filesystem::path const& newPath)
+{}
+void OperationQueue::enqueueDelete(std::filesystem::path const& path)
+{}
\ No newline at end of file

From a7d1bece41186d9af3f30f24ff1483cffa88175a Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sat, 21 Jun 2025 18:21:06 +0200
Subject: [PATCH 17/42] Added progress bar class.

---
 .../frontend/components/progress_bar.hpp      |  33 +++
 .../frontend/components/progress_bar.cpp      | 209 ++++++++++++++++++
 2 files changed, 242 insertions(+)
 create mode 100644 frontend/include/frontend/components/progress_bar.hpp
 create mode 100644 frontend/source/frontend/components/progress_bar.cpp

diff --git a/frontend/include/frontend/components/progress_bar.hpp b/frontend/include/frontend/components/progress_bar.hpp
new file mode 100644
index 00000000..f4540060
--- /dev/null
+++ b/frontend/include/frontend/components/progress_bar.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <nui/frontend/element_renderer.hpp>
+#include <roar/detail/pimpl_special_functions.hpp>
+
+class ProgressBar
+{
+  public:
+    struct Settings
+    {
+        std::string id;
+        std::string height{"30px"};
+        long long min{0};
+        long long max{100};
+        bool showMinMax{false};
+        bool byteMode{false};
+    };
+    ProgressBar(Settings settings);
+
+    ROAR_PIMPL_SPECIAL_FUNCTIONS(ProgressBar);
+
+    Nui::ElementRenderer operator()();
+
+    /**
+     * Set the progress of the progress bar.
+     * Cannot be set if the progress bar is not mounted.
+     */
+    void setProgress(long long current);
+
+  private:
+    struct Implementation;
+    std::unique_ptr<Implementation> impl_;
+};
\ No newline at end of file
diff --git a/frontend/source/frontend/components/progress_bar.cpp b/frontend/source/frontend/components/progress_bar.cpp
new file mode 100644
index 00000000..bd5040ef
--- /dev/null
+++ b/frontend/source/frontend/components/progress_bar.cpp
@@ -0,0 +1,209 @@
+#include <frontend/components/progress_bar.hpp>
+
+#include <nui/frontend/attributes.hpp>
+#include <nui/frontend/elements.hpp>
+#include <nui/frontend/dom/basic_element.hpp>
+#include <fmt/format.h>
+
+#include <algorithm>
+
+// clang-format off
+#ifdef NUI_INLINE
+// @inline(css, scp-progress-bar)
+.progress-bar {
+    height: 30px;
+    background-color: #f1f1f1;
+    border-radius: 15px;
+    overflow: hidden;
+    position: relative;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+}
+
+.progress-bar:nth-child(1) {
+    height: 100%;
+    width: 0%;
+    transition: width 0.3s linear, background-color 0.3s linear;
+    background-color: #4CAF50;
+    position: absolute;
+    left: 0;
+}
+
+.progress-bar:nth-child(2) {
+    position: relative;
+    z-index: 1;
+    font-size: 16px;
+    font-weight: bold;
+    color: #303030;
+    text-shadow: 0 0 5px rgba(0, 0, 0, 0.5);
+}
+
+.progress-bar:nth-child(3) {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: linear-gradient(to right, transparent, rgba(255, 255, 255, 0.5), transparent);
+    animation: progress-shine 2s infinite;
+}
+
+.progress-bar:nth-child(3).hidden {
+    display: none;
+}
+
+@media (prefers-reduced-motion: reduce) {
+    .progress-bar:nth-child(3) {
+        animation: none;
+    }
+}
+
+@keyframes progress-shine {
+    0% {
+        transform: translateX(-100%);
+    }
+
+    100% {
+        transform: translateX(100%);
+    }
+}
+// @endinline
+#endif
+// clang-format on
+
+namespace
+{
+    enum class OrderOfMagnitude
+    {
+        None = 0,
+        Kilo,
+        Mega,
+        Giga,
+        Tera
+    };
+
+    int percentageBetween(long long current, long long min, long long max)
+    {
+        // Ensure min is less than or equal to max
+        if (min > max)
+            std::swap(min, max);
+
+        // Clamp current between min and max
+        current = std::clamp(current, min, max);
+
+        // Avoid division by zero if min == max
+        if (min == max)
+            return 100.0;
+
+        // Calculate percentage
+        return static_cast<int>(100. * static_cast<double>(current - min) / static_cast<double>(max - min));
+    }
+
+    OrderOfMagnitude determineOrderOfMagnitude(long long value)
+    {
+        if (value < 1000)
+            return OrderOfMagnitude::None;
+        else if (value < 1'000'000)
+            return OrderOfMagnitude::Kilo;
+        else if (value < 1'000'000'000)
+            return OrderOfMagnitude::Mega;
+        else if (value < 1'000'000'000'000)
+            return OrderOfMagnitude::Giga;
+        else
+            return OrderOfMagnitude::Tera;
+    }
+}
+
+struct ProgressBar::Implementation : public ProgressBar::Settings
+{
+    std::weak_ptr<Nui::Dom::BasicElement> progressBarElement;
+    OrderOfMagnitude magnitude;
+
+    Implementation(Settings settings)
+        : Settings{std::move(settings)}
+        , progressBarElement{}
+        , magnitude{determineOrderOfMagnitude(settings.max)}
+    {}
+};
+
+ProgressBar::ProgressBar(Settings settings)
+    : impl_{std::make_unique<Implementation>(std::move(settings))}
+{}
+
+ROAR_PIMPL_SPECIAL_FUNCTIONS_IMPL(ProgressBar);
+
+Nui::ElementRenderer ProgressBar::operator()()
+{
+    using namespace Nui::Elements;
+    using namespace Nui::Attributes;
+    using Nui::Elements::div;
+    using fmt::format;
+
+    // clang-format off
+    return div{
+        id = impl_->id,
+        class_ = "progress-bar",
+        reference = impl_->progressBarElement,
+    }(
+        div{}(),
+        div{}("0%"),
+        div{}()
+    );
+    // clang-format on
+}
+
+void ProgressBar::setProgress(long long current)
+{
+    const auto percent = percentageBetween(current, impl_->min, impl_->max);
+
+    auto element = impl_->progressBarElement.lock();
+    if (!element) // not mounted
+        return;
+
+    Nui::val progressBar = element->val();
+    Nui::val barFill = progressBar.call<Nui::val>("children")[0];
+    Nui::val percentageText = progressBar.call<Nui::val>("children")[1];
+
+    barFill["style"].set("width", fmt::format("{}%", static_cast<int>(percent)));
+
+    const auto text = [this, percent]() {
+        if (impl_->showMinMax)
+        {
+            if (impl_->byteMode)
+            {
+                const auto formatSize = [](long long value, OrderOfMagnitude magnitude) {
+                    switch (magnitude)
+                    {
+                        case OrderOfMagnitude::None:
+                            return fmt::format("{} B", value);
+                        case OrderOfMagnitude::Kilo:
+                            return fmt::format("{:.2f} KB", value / 1024.0);
+                        case OrderOfMagnitude::Mega:
+                            return fmt::format("{:.2f} MB", value / (1024.0 * 1024.0));
+                        case OrderOfMagnitude::Giga:
+                            return fmt::format("{:.2f} GB", value / (1024.0 * 1024.0 * 1024.0));
+                        case OrderOfMagnitude::Tera:
+                            return fmt::format("{:.2f} TB", value / (1024.0 * 1024.0 * 1024.0 * 1024.0));
+                    }
+                    return std::string{};
+                };
+
+                return fmt::format(
+                    "{} - {} ({})",
+                    formatSize(impl_->min, impl_->magnitude),
+                    formatSize(impl_->max, impl_->magnitude),
+                    percent);
+            }
+            else
+                return fmt::format("{} / {} ({})", impl_->min, impl_->max, percent);
+        }
+        else
+            return fmt::format("{}%", percent);
+    }();
+
+    percentageText.set("textContent", text);
+
+    const auto hue = std::max(5., 120. * std::pow(static_cast<double>(percent) / 100., 1.8));
+    barFill["style"].set("backgroundColor", fmt::format("hsl({}, 100%, 50%)", static_cast<int>(hue)));
+}
\ No newline at end of file

From caa14e8e64f729f736d0197dbec74172090a7ce2 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sat, 21 Jun 2025 18:21:20 +0200
Subject: [PATCH 18/42] Changed some formatting.

---
 nui-file-explorer/source/nui-file-explorer/file_grid.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/nui-file-explorer/source/nui-file-explorer/file_grid.cpp b/nui-file-explorer/source/nui-file-explorer/file_grid.cpp
index b465b3bb..ae2074ae 100644
--- a/nui-file-explorer/source/nui-file-explorer/file_grid.cpp
+++ b/nui-file-explorer/source/nui-file-explorer/file_grid.cpp
@@ -605,7 +605,7 @@ namespace NuiFileExplorer
         return div {
             std::move(attributes)
         }(
-            [this]() -> Nui::ElementRenderer{
+            [this]() -> Nui::ElementRenderer {
                 if (impl_->settings.pathBarOnTop)
                     return pathBar();
                 return nil();
@@ -631,7 +631,7 @@ namespace NuiFileExplorer
                     }
                 )
             ),
-            [this]() -> Nui::ElementRenderer{
+            [this]() -> Nui::ElementRenderer {
                 if (!impl_->settings.pathBarOnTop)
                     return pathBar();
                 return nil();

From 062304a3ac0384e936412f4cb7dbd5bfb23aa0ef Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sat, 21 Jun 2025 18:21:35 +0200
Subject: [PATCH 19/42] Removed browser selection from file grid.

---
 nui-file-explorer/styles/file_grid.css | 1 +
 1 file changed, 1 insertion(+)

diff --git a/nui-file-explorer/styles/file_grid.css b/nui-file-explorer/styles/file_grid.css
index 3e080a7e..24c5f497 100644
--- a/nui-file-explorer/styles/file_grid.css
+++ b/nui-file-explorer/styles/file_grid.css
@@ -2,6 +2,7 @@
     height: 100%;
     display: flex;
     flex-direction: column;
+    user-select: none;
 }
 
 .nui-file-grid-icons {

From 6fc8aef504513fbe347e5764d1afe185234e3bfa Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Wed, 10 Sep 2025 00:56:37 +0200
Subject: [PATCH 20/42] Refactored session manager by adding session class.

---
 backend/include/backend/main.hpp              |   5 +-
 backend/include/backend/rpc_helper.hpp        | 293 +++++++
 backend/include/backend/session.hpp           | 186 ++++
 backend/include/backend/session_manager.hpp   |  82 ++
 .../include/backend/sftp/operation_queue.hpp  |   5 +-
 .../include/backend/ssh_session_manager.hpp   |  81 --
 backend/source/backend/CMakeLists.txt         |   4 +-
 backend/source/backend/main.cpp               |   6 +-
 backend/source/backend/session.cpp            | 380 +++++++++
 backend/source/backend/session_manager.cpp    | 221 +++++
 .../source/backend/sftp/operation_queue.cpp   |  19 +-
 .../source/backend/ssh_session_manager.cpp    | 807 ------------------
 .../session_components/operation_queue.hpp    |   2 +
 .../include/frontend/terminal/file_engine.hpp |  16 +
 frontend/source/frontend/session.cpp          |  12 +-
 frontend/source/frontend/session_area.cpp     |  59 +-
 .../session_components/operation_queue.cpp    |  24 +-
 .../frontend/terminal/sftp_file_engine.cpp    |  10 +-
 .../source/frontend/terminal/ssh_channel.cpp  |   6 +-
 .../source/frontend/terminal/ssh_engine.cpp   |  15 +-
 ids/include/ids/ids.hpp                       |   3 +-
 .../persistence/state/sftp_options.hpp        |   1 +
 .../include/persistence/state/state.hpp       |   2 +
 .../source/persistence/state/sftp_options.cpp |   6 +
 .../source/persistence/state/state.cpp        |  36 +
 ssh/test/ssh/utility/node.cpp                 |   2 +-
 ssh/test/ssh/utility/node.hpp                 |   2 +-
 27 files changed, 1310 insertions(+), 975 deletions(-)
 create mode 100644 backend/include/backend/rpc_helper.hpp
 create mode 100644 backend/include/backend/session.hpp
 create mode 100644 backend/include/backend/session_manager.hpp
 delete mode 100644 backend/include/backend/ssh_session_manager.hpp
 create mode 100644 backend/source/backend/session.cpp
 create mode 100644 backend/source/backend/session_manager.cpp
 delete mode 100644 backend/source/backend/ssh_session_manager.cpp

diff --git a/backend/include/backend/main.hpp b/backend/include/backend/main.hpp
index a0b503b1..e8a10b84 100644
--- a/backend/include/backend/main.hpp
+++ b/backend/include/backend/main.hpp
@@ -1,9 +1,10 @@
 #pragma once
 
 #include <backend/process/process_store.hpp>
-#include <backend/ssh_session_manager.hpp>
+#include <backend/session_manager.hpp>
 #include <persistence/state_holder.hpp>
 #include <backend/password/password_prompter.hpp>
+#include <ssh/async/processing_thread.hpp>
 
 #include <boost/asio/steady_timer.hpp>
 #include <nui/core.hpp>
@@ -37,7 +38,7 @@ class Main
     Nui::RpcHub hub_;
     ProcessStore processes_;
     PasswordPrompter prompter_;
-    std::shared_ptr<SshSessionManager> sshSessionManager_;
+    std::shared_ptr<SessionManager> sshSessionManager_;
     std::atomic_bool shuttingDown_;
     boost::asio::steady_timer childSignalTimer_;
 };
\ No newline at end of file
diff --git a/backend/include/backend/rpc_helper.hpp b/backend/include/backend/rpc_helper.hpp
new file mode 100644
index 00000000..3729751b
--- /dev/null
+++ b/backend/include/backend/rpc_helper.hpp
@@ -0,0 +1,293 @@
+#pragma once
+
+#include <nui/rpc.hpp>
+#include <nlohmann/json.hpp>
+#include <fmt/format.h>
+#include <log/log.hpp>
+#include <boost/asio/strand.hpp>
+#include <boost/asio/any_io_executor.hpp>
+#include <traits/functions.hpp>
+#include <mplex/tuple/pop_front.hpp>
+
+#include <string>
+#include <concepts>
+#include <ranges>
+#include <memory>
+
+// TODO: split and document this file!
+namespace RpcHelper
+{
+    namespace Detail
+    {
+        template <typename ArgsTuple>
+        struct CallOperatorApplyTypesOnly
+        {};
+
+        template <typename... Args>
+        struct CallOperatorApplyTypesOnly<std::tuple<Args...>>
+        {
+            template <typename F>
+            static void apply(F&& func)
+            {
+                return std::forward<F>(func).template operator()<Args...>();
+            }
+        };
+
+        template <typename>
+        struct DebugPrintType;
+    }
+
+    class RpcInCorrectThread
+    {
+      public:
+        RpcInCorrectThread(Nui::Window& wnd, Nui::RpcHub& hub, std::string const& responseId)
+            : wnd_{&wnd}
+            , hub_{&hub}
+            , responseId_{responseId}
+        {}
+        RpcInCorrectThread(RpcInCorrectThread&&) = default;
+        RpcInCorrectThread& operator=(RpcInCorrectThread&&) = default;
+        RpcInCorrectThread(RpcInCorrectThread const&) = default;
+        RpcInCorrectThread& operator=(RpcInCorrectThread const&) = default;
+        ~RpcInCorrectThread() = default;
+
+        void operator()(nlohmann::json&& json) const
+        {
+            wnd_->runInJavascriptThread([this, json = std::move(json)]() {
+                try
+                {
+                    hub_->callRemote(responseId_, json);
+                }
+                catch (const std::exception& e)
+                {
+                    Log::error("Failed to call rpc respond '{}': {}", responseId_, e.what());
+                }
+            });
+        }
+
+      protected:
+        Nui::Window* wnd_;
+        Nui::RpcHub* hub_;
+        std::string responseId_;
+    };
+
+    class RpcOnce
+    {
+      public:
+        RpcOnce(Nui::Window& wnd, Nui::RpcHub& hub, std::string const& responseId)
+            : wnd_{&wnd}
+            , hub_{&hub}
+            , responseId_{responseId}
+        {}
+        RpcOnce(RpcOnce&&) = default;
+        RpcOnce& operator=(RpcOnce&&) = default;
+        RpcOnce(RpcOnce const&) = delete;
+        RpcOnce& operator=(RpcOnce const&) = delete;
+        ~RpcOnce() = default;
+
+        void operator()(nlohmann::json&& json) const
+        {
+            if (called_)
+            {
+                Log::warn("RPC response with id '{}' already sent. Not sending: {}", responseId_, json.dump(4));
+                return;
+            }
+            called_ = true;
+
+            wnd_->runInJavascriptThread([hub = hub_, responseId = std::move(responseId_), json = std::move(json)]() {
+                try
+                {
+                    hub->callRemote(responseId, json);
+                }
+                catch (const std::exception& e)
+                {
+                    Log::error("Failed to call rpc respond '{}': {}", responseId, e.what());
+                }
+            });
+        }
+
+      private:
+        Nui::Window* wnd_;
+        Nui::RpcHub* hub_;
+        mutable std::string responseId_;
+        mutable bool called_{false};
+    };
+
+    class ParameterVerifyView
+    {
+      private:
+        RpcOnce& rpcOnce_;
+        nlohmann::json const& json_;
+        std::string const functionName_;
+
+      public:
+        ParameterVerifyView(RpcOnce& rpcOnce, std::string const& functionName, nlohmann::json const& json)
+            : rpcOnce_{rpcOnce}
+            , json_{json}
+            , functionName_{functionName}
+        {}
+        ~ParameterVerifyView() = default;
+        ParameterVerifyView(ParameterVerifyView const&) = delete;
+        ParameterVerifyView& operator=(ParameterVerifyView const&) = delete;
+
+        // Lets not have this view moveable somewhere, to avoid it being used after the original json is gone
+        ParameterVerifyView(ParameterVerifyView&&) = delete;
+        ParameterVerifyView& operator=(ParameterVerifyView&&) = delete;
+
+        template <typename KeyT, typename... KeysT>
+        requires(std::convertible_to<KeyT, std::string_view> && (std::convertible_to<KeysT, std::string_view> && ...))
+        bool hasValueDeep(KeyT&& key, KeysT&&... keys)
+        {
+            std::vector<std::string> keyChain{};
+
+            auto onFail = [this, &keyChain]() {
+                keyChain.pop_back();
+                rpcOnce_({
+                    {
+                        "error",
+                        fmt::format(
+                            "Missing parameter to function '{}': {}", functionName_, keyChain | std::views::join),
+                    },
+                });
+                return false;
+            };
+
+            auto iter = json_.find(key);
+            auto currentEnd = end(json_);
+
+            auto checkOnce = [&iter, &keyChain, &onFail, &currentEnd](std::string_view key) {
+                keyChain.push_back(std::string{key});
+                keyChain.push_back(".");
+                if (iter == currentEnd)
+                    return onFail();
+                currentEnd = end(*iter);
+                return true;
+            };
+
+            auto findNext = [&iter, &checkOnce](std::string_view key) {
+                iter = iter->find(key);
+                return checkOnce(key);
+            };
+
+            return checkOnce(key) && (findNext(keys) && ...);
+        }
+    };
+
+    template <typename FunctionT>
+    auto rpcSafe(RpcOnce&& rpcOnce, FunctionT&& func)
+    {
+        return [rpcOnce = std::make_shared<RpcOnce>(std::move(rpcOnce)),
+                func = std::forward<FunctionT>(func)](auto&&... args) mutable {
+            try
+            {
+                if constexpr (std::is_invocable_v<FunctionT, RpcOnce&&, decltype(args)...>)
+                    func(std::move(*rpcOnce), std::forward<decltype(args)>(args)...);
+                else if constexpr (std::is_invocable_v<FunctionT, decltype(args)...>)
+                    func(std::forward<decltype(args)>(args)...);
+                else
+                    static_assert(false, "FunctionT is not callable with the given arguments");
+            }
+            catch (const std::exception& e)
+            {
+                (*rpcOnce)({{"error", e.what()}});
+            }
+        };
+    }
+
+    class StrandRpc
+    {
+      public:
+        StrandRpc(boost::asio::any_io_executor executor, Nui::Window& wnd, Nui::RpcHub& hub)
+            : executor_{executor}
+            , strand_{std::make_shared<boost::asio::strand<boost::asio::any_io_executor>>(executor_)}
+            , wnd_{&wnd}
+            , hub_{&hub}
+        {}
+
+        StrandRpc(
+            boost::asio::any_io_executor executor,
+            std::shared_ptr<boost::asio::strand<boost::asio::any_io_executor>> strand,
+            Nui::Window& wnd,
+            Nui::RpcHub& hub)
+            : executor_{executor}
+            , strand_{std::move(strand)}
+            , wnd_{&wnd}
+            , hub_{&hub}
+        {}
+
+        virtual ~StrandRpc() = default;
+        StrandRpc(StrandRpc const&) = delete;
+        StrandRpc& operator=(StrandRpc const&) = delete;
+        StrandRpc(StrandRpc&&) = default;
+        StrandRpc& operator=(StrandRpc&&) = default;
+
+        template <typename FunctionT>
+        void registerOnStrand(std::string_view functionName, FunctionT&& func)
+        {
+            // (RpcReply&&, Param1, Param2, ...) => (Param1, Param2, ...)
+            using ArgsTuple = mplex::pop_front_t<typename Traits::FunctionTraits<std::decay_t<FunctionT>>::ArgsTuple>;
+
+            // Call lambda with template arguments FunctionT, Param1, Param2, ... and no parameters.
+            Detail::CallOperatorApplyTypesOnly<ArgsTuple>::apply([this,
+                                                                  functionName = std::string{functionName},
+                                                                  func = std::forward<FunctionT>(
+                                                                      func)]<typename... ParameterTs>() mutable {
+                // Register function that is wrapped in a strand execute call:
+                registeredFunctions_.emplace_back(hub_->autoRegisterFunction(
+                    functionName,
+                    [this, func = std::move(func), functionName](std::string responseId, ParameterTs&&... parameters) {
+                        strand_->execute([responseId = std::move(responseId),
+                                          ... parameters = std::forward<ParameterTs>(parameters),
+                                          func,
+                                          wnd = wnd_,
+                                          hub = hub_]() mutable {
+                            // Threadsafe do:
+                            RpcHelper::rpcSafe(
+                                RpcHelper::RpcOnce{*wnd, *hub, std::move(responseId)},
+                                [&parameters..., &func](RpcOnce&& reply) mutable {
+                                    // Call actual function
+                                    func(std::move(reply), std::forward<ParameterTs>(parameters)...);
+                                })();
+                        });
+                    }));
+            });
+        }
+
+        class Proxy
+        {
+          private:
+            StrandRpc* parent_;
+            std::string functionName;
+
+          public:
+            Proxy(StrandRpc* parent, std::string functionName)
+                : parent_(parent)
+                , functionName(std::move(functionName))
+            {}
+
+            template <typename... Args>
+            void perform(Args&&... args)
+            {
+                parent_->registerOnStrand(functionName, std::forward<Args>(args)...);
+            }
+        };
+        Proxy on(std::string_view functionName)
+        {
+            return Proxy{this, std::string{functionName}};
+        }
+
+        void within_strand_do(auto&& func) const
+        {
+            if (!strand_->running_in_this_thread())
+                return strand_->execute(std::forward<decltype(func)>(func));
+            func();
+        }
+
+      protected:
+        boost::asio::any_io_executor executor_{};
+        std::shared_ptr<boost::asio::strand<boost::asio::any_io_executor>> strand_;
+        Nui::Window* wnd_;
+        Nui::RpcHub* hub_;
+        std::vector<Nui::RpcHub::AutoUnregister> registeredFunctions_{};
+    };
+}
\ No newline at end of file
diff --git a/backend/include/backend/session.hpp b/backend/include/backend/session.hpp
new file mode 100644
index 00000000..f4206181
--- /dev/null
+++ b/backend/include/backend/session.hpp
@@ -0,0 +1,186 @@
+#pragma once
+
+#include <ssh/session.hpp>
+#include <ssh/sftp_session.hpp>
+#include <ids/ids.hpp>
+#include <backend/sftp/operation_queue.hpp>
+#include <backend/rpc_helper.hpp>
+#include <persistence/state_holder.hpp>
+
+#include <unordered_map>
+#include <memory>
+#include <optional>
+
+/**
+ * @brief This session is the implementation equivalent of one tab in the UI.
+ * A tab in the UI represents everything related to one server address and port.
+ *
+ * These sessions are managed by SessionManager. Each session has an id, as well as ssh channels, sftp channels and
+ */
+class Session : public RpcHelper::StrandRpc
+{
+  public:
+    constexpr static auto futureTimeout = std::chrono::seconds{10};
+
+    Session(
+        Ids::SessionId id,
+        std::unique_ptr<SecureShell::Session> session,
+        boost::asio::any_io_executor executor,
+        std::shared_ptr<boost::asio::strand<boost::asio::any_io_executor>> strand,
+        Nui::Window& wnd,
+        Nui::RpcHub& hub,
+        Persistence::SftpOptions const& sftpOptions);
+
+    Session(const Session&) = delete;
+    Session& operator=(const Session&) = delete;
+    Session(Session&&) = default;
+    Session& operator=(Session&&) = default;
+    ~Session() = default;
+
+    void start();
+
+  private:
+    /**
+     * Handles calls from the frontend to create a new channel with the following payload:
+     * {
+     *     engine: {
+     *         sshSessionOptions: Persistence::SshSessionOptions,
+     *         environment: std::unordered_map<std::string, std::string>
+     *     },
+     *     fileMode: boolean (optional, default false)
+     * }
+     *
+     */
+    void registerRpcCreateChannel();
+
+    /**
+     * Handles calls from the frontend to start reading from a channel with the following payload:
+     * {
+     *     channelId: string
+     * }
+     */
+    void registerRpcStartChannelRead();
+
+    /**
+     * Handles calls from the frontend to close a channel with the following payload:
+     * {
+     *     channelId: string
+     * }
+     */
+    void registerRpcChannelClose();
+
+    /**
+     * Handles calls from the frontend to write data to a channel with the following payload:
+     * {
+     *     channelId: string,
+     *     data: string (base64 encoded)
+     * }
+     */
+    void registerRpcChannelWrite();
+
+    /**
+     * Handles calls from the frontend to resize the pty of a channel with the following payload:
+     * {
+     *     channelId: string,
+     *     cols: int,
+     *     rows: int
+     * }
+     */
+    void registerRpcChannelPtyResize();
+
+    /**
+     * Handles calls from the frontend to list a directory over sftp with the following payload:
+     * {
+     *     sftpChannelId: string,
+     *     path: string
+     * }
+     */
+    void registerRpcSftpListDirectory();
+
+    /**
+     * Handles calls from the frontend to create a directory over sftp with the following payload:
+     * {
+     *     sftpChannelId: string,
+     *     path: string
+     * }
+     */
+    void registerRpcSftpCreateDirectory();
+
+    /**
+     * Handles calls from the frontend to create a file over sftp with the following payload:
+     * {
+     *     sftpChannelId: string,
+     *     path: string
+     * }
+     */
+    void registerRpcSftpCreateFile();
+
+    void registerRpcSftpAddDownloadOperation();
+
+    void removeChannel(Ids::ChannelId channelId);
+
+    void removeSftpChannel(Ids::ChannelId channelId);
+
+    template <typename FunctionT, typename ReplyCallable>
+    void withChannelDo(Ids::ChannelId channelId, FunctionT&& func, ReplyCallable&& reply)
+    {
+        within_strand_do([this,
+                          channelId = std::move(channelId),
+                          func = std::forward<FunctionT>(func),
+                          reply = std::forward<ReplyCallable>(reply)]() mutable {
+            if (auto iter = channels_.find(channelId); iter != channels_.end())
+            {
+                if (auto channel = iter->second.lock(); channel)
+                {
+                    func(std::move(reply), channel);
+                }
+                else
+                {
+                    Log::error("Failed to lock channel with id: {}", channelId.value());
+                    removeChannel(channelId);
+                    return reply({{"error", "Failed to lock channel"}});
+                }
+            }
+            else
+            {
+                Log::error("No channel found with id: {}", channelId.value());
+                return reply({{"error", "No channel found with id"}});
+            }
+        });
+    }
+
+    template <typename FunctionT, typename ReplyCallable>
+    void withSftpChannelDo(Ids::ChannelId channelId, FunctionT&& func, ReplyCallable&& reply)
+    {
+        within_strand_do([this,
+                          channelId = std::move(channelId),
+                          func = std::forward<FunctionT>(func),
+                          reply = std::forward<ReplyCallable>(reply)]() mutable {
+            if (auto iter = sftpChannels_.find(channelId); iter != sftpChannels_.end())
+            {
+                if (auto channel = iter->second.lock(); channel)
+                {
+                    func(std::move(reply), channel);
+                }
+                else
+                {
+                    Log::error("Failed to lock channel with id: {}", channelId.value());
+                    removeSftpChannel(channelId);
+                    return reply({{"error", "Failed to lock channel"}});
+                }
+            }
+            else
+            {
+                Log::error("No channel found with id: {}", channelId.value());
+                return reply({{"error", "No channel found with id"}});
+            }
+        });
+    }
+
+  private:
+    Ids::SessionId id_;
+    std::unique_ptr<SecureShell::Session> session_{};
+    std::unordered_map<Ids::ChannelId, std::weak_ptr<SecureShell::Channel>, Ids::IdHash> channels_{};
+    std::unordered_map<Ids::ChannelId, std::weak_ptr<SecureShell::SftpSession>, Ids::IdHash> sftpChannels_{};
+    std::unique_ptr<OperationQueue> operationQueue_;
+};
\ No newline at end of file
diff --git a/backend/include/backend/session_manager.hpp b/backend/include/backend/session_manager.hpp
new file mode 100644
index 00000000..6037766e
--- /dev/null
+++ b/backend/include/backend/session_manager.hpp
@@ -0,0 +1,82 @@
+#pragma once
+
+#include <backend/session.hpp>
+#include <backend/password/password_provider.hpp>
+#include <persistence/state/terminal_engine.hpp>
+#include <persistence/state_holder.hpp>
+#include <backend/rpc_helper.hpp>
+
+#include <nui/rpc.hpp>
+#include <libssh/libsshpp.hpp>
+#include <libssh/sftp.h>
+#include <boost/asio/any_io_executor.hpp>
+#include <boost/asio/strand.hpp>
+
+#include <memory>
+#include <map>
+#include <functional>
+#include <mutex>
+#include <thread>
+
+class SessionManager
+    : public std::enable_shared_from_this<SessionManager>
+    , public RpcHelper::StrandRpc
+{
+  public:
+    SessionManager(
+        boost::asio::any_io_executor executor,
+        Persistence::StateHolder& stateHolder,
+        Nui::Window& wnd,
+        Nui::RpcHub& hub);
+    ~SessionManager() = default;
+    SessionManager(SessionManager const&) = delete;
+    SessionManager& operator=(SessionManager const&) = delete;
+    SessionManager(SessionManager&&) = delete;
+    SessionManager& operator=(SessionManager&&) = delete;
+
+    void registerRpc();
+
+    void addPasswordProvider(int priority, PasswordProvider* provider);
+    void joinSessionAdder();
+    void addSession(
+        Persistence::SshTerminalEngine const& engine,
+        std::function<void(std::optional<Ids::SessionId> const&)> onComplete);
+
+    friend int askPassDefault(char const* prompt, char* buf, std::size_t length, int echo, int verify, void* userdata);
+
+    // void startUpdateDispatching();
+    // void stopUpdateDispatching();
+
+  private:
+    // void dispatchUpdates();
+
+    /**
+     * Handles calls from the frontend to connect to a new ssh server with the following payload:
+     * {
+     *     engine: Persistence::SshTerminalEngine
+     * }
+     */
+    void registerRpcSessionConnect();
+
+    /**
+     * Handles calls from the frontend to disconnect from an ssh server with the following payload:
+     * {
+     *     sessionId: string
+     * }
+     */
+    void registerRpcSessionDisconnect();
+
+    /// Removes a session and closes all its channels. Safe to call from any thread.
+    void removeSession(Ids::SessionId sessionId);
+
+  private:
+    Persistence::StateHolder* stateHolder_{};
+    std::unordered_map<Ids::SessionId, Session, Ids::IdHash> sessions_{};
+
+    std::map<int, PasswordProvider*> passwordProviders_{};
+    std::unique_ptr<std::thread> addSessionThread_{};
+    std::vector<SecureShell::PasswordCacheEntry> pwCache_{};
+    std::atomic_bool updateDispatchRunning_{false};
+};
+
+int askPassDefault(char const* prompt, char* buf, std::size_t length, int echo, int verify, void* userdata);
\ No newline at end of file
diff --git a/backend/include/backend/sftp/operation_queue.hpp b/backend/include/backend/sftp/operation_queue.hpp
index 33e1e6f9..a6b99d98 100644
--- a/backend/include/backend/sftp/operation_queue.hpp
+++ b/backend/include/backend/sftp/operation_queue.hpp
@@ -31,7 +31,7 @@ class OperationQueue
         std::optional<Operation::Error> error{std::nullopt};
     };
 
-    OperationQueue(int parallelism = 1);
+    OperationQueue(Persistence::SftpOptions sftpOpts, int parallelism = 1);
 
     using Error = OperationErrorType;
 
@@ -47,8 +47,6 @@ class OperationQueue
     bool update();
 
     std::expected<void, Operation::Error> addDownloadOperation(
-        Persistence::State const& state,
-        std::string const& sshSessionOptionsKey,
         SecureShell::SftpSession& sftp,
         Ids::OperationId id,
         std::filesystem::path const& localPath,
@@ -56,6 +54,7 @@ class OperationQueue
 
   private:
     std::mutex mutex_{};
+    Persistence::SftpOptions sftpOpts_{};
     std::deque<std::pair<Ids::OperationId, std::unique_ptr<Operation>>> operations_{};
     std::vector<CompletedOperation> completedOperations_{};
     int parallelism_{1};
diff --git a/backend/include/backend/ssh_session_manager.hpp b/backend/include/backend/ssh_session_manager.hpp
deleted file mode 100644
index 581806c9..00000000
--- a/backend/include/backend/ssh_session_manager.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-#pragma once
-
-#include <persistence/state/terminal_engine.hpp>
-#include <persistence/state_holder.hpp>
-#include <backend/password/password_provider.hpp>
-#include <backend/sftp/operation_queue.hpp>
-#include <ssh/session.hpp>
-#include <ssh/sftp_session.hpp>
-#include <ids/ids.hpp>
-
-#include <nui/rpc.hpp>
-#include <libssh/libsshpp.hpp>
-#include <libssh/sftp.h>
-#include <boost/asio/any_io_executor.hpp>
-
-#include <memory>
-#include <map>
-#include <mutex>
-#include <thread>
-
-class SshSessionManager : public std::enable_shared_from_this<SshSessionManager>
-{
-  public:
-    constexpr static auto futureTimeout = std::chrono::seconds{10};
-
-    SshSessionManager(boost::asio::any_io_executor exectutor, Persistence::StateHolder* stateHolder);
-    ~SshSessionManager();
-    SshSessionManager(SshSessionManager const&) = delete;
-    SshSessionManager& operator=(SshSessionManager const&) = delete;
-    SshSessionManager(SshSessionManager&&) = delete;
-    SshSessionManager& operator=(SshSessionManager&&) = delete;
-
-    void registerRpc(Nui::Window& wnd, Nui::RpcHub& rpcHub);
-
-    void addPasswordProvider(int priority, PasswordProvider* provider);
-    void joinSessionAdder();
-    void addSession(
-        Persistence::SshTerminalEngine const& engine,
-        std::function<void(std::optional<Ids::SessionId> const&)> onComplete);
-
-    friend int askPassDefault(char const* prompt, char* buf, std::size_t length, int echo, int verify, void* userdata);
-
-    void startUpdateDispatching();
-    void stopUpdateDispatching();
-
-  private:
-    void registerRpcConnect(Nui::Window& wnd, Nui::RpcHub& hub);
-    void registerRpcCreateChannel(Nui::Window& wnd, Nui::RpcHub& hub);
-    void registerRpcStartChannelRead(Nui::Window& wnd, Nui::RpcHub& hub);
-    void registerRpcChannelClose(Nui::Window& wnd, Nui::RpcHub& hub);
-    void registerRpcEndSession(Nui::Window&, Nui::RpcHub& hub);
-    void registerRpcChannelWrite(Nui::Window&, Nui::RpcHub& hub);
-    void registerRpcChannelPtyResize(Nui::Window&, Nui::RpcHub& hub);
-
-    // Sftp:
-    void registerRpcSftpListDirectory(Nui::Window&, Nui::RpcHub& hub);
-    void registerRpcSftpCreateDirectory(Nui::Window&, Nui::RpcHub& hub);
-    void registerRpcSftpCreateFile(Nui::Window&, Nui::RpcHub& hub);
-
-    // Sftp Files:
-    void registerRpcSftpAddDownloadOperation(Nui::Window&, Nui::RpcHub& hub);
-
-  private:
-    void dispatchUpdates();
-
-  private:
-    std::mutex passwordProvidersMutex_{};
-    std::mutex addSessionMutex_{};
-    boost::asio::any_io_executor executor_;
-    Persistence::StateHolder* stateHolder_{};
-    std::unordered_map<Ids::SessionId, std::unique_ptr<SecureShell::Session>, Ids::IdHash> sessions_{};
-    std::unordered_map<Ids::ChannelId, std::weak_ptr<SecureShell::Channel>, Ids::IdHash> channels_{};
-    std::unordered_map<Ids::ChannelId, std::weak_ptr<SecureShell::SftpSession>, Ids::IdHash> sftpChannels_{};
-    OperationQueue operationQueue_{};
-    std::map<int, PasswordProvider*> passwordProviders_{};
-    std::unique_ptr<std::thread> addSessionThread_{};
-    std::vector<SecureShell::PasswordCacheEntry> pwCache_{};
-    std::atomic_bool updateDispatchRunning_{false};
-};
-
-int askPassDefault(char const* prompt, char* buf, std::size_t length, int echo, int verify, void* userdata);
\ No newline at end of file
diff --git a/backend/source/backend/CMakeLists.txt b/backend/source/backend/CMakeLists.txt
index e0dad62a..a762a414 100644
--- a/backend/source/backend/CMakeLists.txt
+++ b/backend/source/backend/CMakeLists.txt
@@ -5,7 +5,8 @@ add_library(
         process/process.cpp
         process/process_store.cpp
         process/environment.cpp
-        ssh_session_manager.cpp
+        session_manager.cpp
+        session.cpp
         sftp/operation_queue.cpp
         sftp/download_operation.cpp
 )
@@ -44,6 +45,7 @@ target_link_libraries(
     backend
     PUBLIC
         nui-backend
+        mplex
         efsw-static
         Boost::filesystem
         Boost::asio
diff --git a/backend/source/backend/main.cpp b/backend/source/backend/main.cpp
index a758bccf..f254c23f 100644
--- a/backend/source/backend/main.cpp
+++ b/backend/source/backend/main.cpp
@@ -158,7 +158,7 @@ Main::Main(int const, char const* const* argv)
     , hub_{window_}
     , processes_{window_.getExecutor(), window_, hub_}
     , prompter_{hub_}
-    , sshSessionManager_{std::make_shared<SshSessionManager>(window_.getExecutor(), &stateHolder_)}
+    , sshSessionManager_{std::make_shared<SessionManager>(window_.getExecutor(), stateHolder_, window_, hub_)}
     , shuttingDown_{false}
     , childSignalTimer_{window_.getExecutor()}
 {
@@ -174,7 +174,7 @@ Main::Main(int const, char const* const* argv)
 Main::~Main()
 {
     shuttingDown_ = true;
-    sshSessionManager_->stopUpdateDispatching();
+    // sshSessionManager_->stopUpdateDispatching();
     childSignalTimer_.cancel();
 }
 
@@ -190,7 +190,7 @@ void Main::registerRpc()
     Log::setupBackendRpcHub(&hub_);
     stateHolder_.registerRpc(hub_);
     processes_.registerRpc(window_, hub_);
-    sshSessionManager_->registerRpc(window_, hub_);
+    sshSessionManager_->registerRpc();
 }
 
 void Main::show()
diff --git a/backend/source/backend/session.cpp b/backend/source/backend/session.cpp
new file mode 100644
index 00000000..fff4caff
--- /dev/null
+++ b/backend/source/backend/session.cpp
@@ -0,0 +1,380 @@
+#include <backend/session.hpp>
+
+#include <roar/utility/base64.hpp>
+
+Session::Session(
+    Ids::SessionId id,
+    std::unique_ptr<SecureShell::Session> session,
+    boost::asio::any_io_executor executor,
+    std::shared_ptr<boost::asio::strand<boost::asio::any_io_executor>> strand,
+    Nui::Window& wnd,
+    Nui::RpcHub& hub,
+    Persistence::SftpOptions const& sftpOptions)
+    : RpcHelper::StrandRpc{executor, std::move(strand), wnd, hub}
+    , id_{id}
+    , session_{std::move(session)}
+    , operationQueue_{std::make_unique<OperationQueue>(sftpOptions, sftpOptions.concurrency.value_or(1))}
+{}
+
+void Session::start()
+{
+    within_strand_do([this]() {
+        if (!session_)
+        {
+            Log::error("Session is not valid, cannot start");
+            return;
+        }
+
+        session_->start();
+        registerRpcCreateChannel();
+        registerRpcStartChannelRead();
+        registerRpcChannelClose();
+        registerRpcChannelWrite();
+        registerRpcChannelPtyResize();
+        registerRpcSftpListDirectory();
+        registerRpcSftpCreateDirectory();
+        registerRpcSftpCreateFile();
+        registerRpcSftpAddDownloadOperation();
+
+        Log::info("Session '{}' connected", id_.value());
+    });
+}
+
+void Session::removeChannel(Ids::ChannelId channelId)
+{
+    within_strand_do([this, channelId = std::move(channelId)]() {
+        auto iter = channels_.find(channelId);
+        if (iter != channels_.end())
+        {
+            if (auto locked = iter->second.lock(); locked)
+                locked->close();
+
+            channels_.erase(iter);
+        }
+        else
+        {
+            Log::warn("Cannot remove channel, no channel found with id: {}", channelId.value());
+        }
+    });
+}
+
+void Session::removeSftpChannel(Ids::ChannelId channelId)
+{
+    within_strand_do([this, channelId = std::move(channelId)]() {
+        auto iter = sftpChannels_.find(channelId);
+        if (iter != sftpChannels_.end())
+        {
+            if (auto locked = iter->second.lock(); locked)
+                locked->close();
+
+            sftpChannels_.erase(iter);
+        }
+        else
+        {
+            Log::warn("Cannot remove sftp channel, no channel found with id: {}", channelId.value());
+        }
+    });
+}
+
+void Session::registerRpcCreateChannel()
+{
+    on(fmt::format("Session::{}::Channel::create", id_.value()))
+        .perform([this](RpcHelper::RpcOnce&& reply, nlohmann::json const& parameters) {
+            RpcHelper::ParameterVerifyView verify{
+                reply, fmt::format("Session::{}::Channel::create", id_.value()), parameters};
+
+            if (!verify.hasValueDeep("engine"))
+                return;
+
+            const bool fileMode = parameters.contains("fileMode") && parameters["fileMode"].is_boolean() &&
+                parameters["fileMode"].get<bool>();
+
+            if (!fileMode)
+            {
+                Log::info("Creating pty channel for session '{}'", id_.value());
+
+                const auto sessionOptions =
+                    parameters["engine"]["sshSessionOptions"].get<Persistence::SshSessionOptions>();
+
+                const auto weakChannel = session_->createPtyChannel({.environment = sessionOptions.environment}).get();
+                if (!weakChannel.has_value())
+                {
+                    Log::error("Failed to create pty channel: {}", weakChannel.error());
+                    return reply({{"error", "Failed to create pty channel"}});
+                }
+
+                const auto channelId = Ids::generateChannelId();
+                channels_.emplace(channelId, std::move(weakChannel).value());
+
+                Log::info(
+                    "Created pty channel with id '{}', channel total is now '{}'.",
+                    channelId.value(),
+                    channels_.size());
+
+                return reply({{"id", channelId.value()}});
+            }
+            else
+            {
+                Log::info("Creating sftp channel for session '{}'", id_.value());
+
+                const auto weakChannel = session_->createSftpSession().get();
+                if (!weakChannel.has_value())
+                {
+                    Log::error("Failed to create sftp channel: {}", weakChannel.error().toString());
+                    return reply({{"error", "Failed to create sftp channel"}});
+                }
+
+                const auto channelId = Ids::generateChannelId();
+                sftpChannels_.emplace(channelId, std::move(weakChannel).value());
+
+                Log::info(
+                    "Created sftp channel with id '{}', sftp channel total is now '{}'.",
+                    channelId.value(),
+                    sftpChannels_.size());
+
+                return reply({{"id", channelId.value()}});
+            }
+        });
+}
+
+void Session::registerRpcStartChannelRead()
+{
+    on(fmt::format("Session::{}::Channel::startReading", id_.value()))
+        .perform([this](RpcHelper::RpcOnce&& reply, std::string const& channelIdString) {
+            const auto channelId = Ids::makeChannelId(channelIdString);
+            if (channels_.find(channelId) == channels_.end())
+            {
+                Log::error("No channel found with id: {}", channelId.value());
+                return reply({{"error", "No channel found with id"}});
+            }
+
+            auto locked = channels_[channelId].lock();
+            if (!locked)
+            {
+                Log::error("Failed to lock channel with id: {}", channelId.value());
+                removeChannel(channelId);
+                return reply({{"error", "Failed to lock channel"}});
+            }
+
+            // Do not use this in these functions, because they are called from a different thread,
+            // unless within_strand_do is used!
+            locked->startReading(
+                // Stdout
+                [sessionId = id_,
+                 channelId,
+                 stdOut =
+                     RpcHelper::RpcInCorrectThread{
+                         *wnd_,
+                         *hub_,
+                         fmt::format("sshTerminalStdout_{}", channelId.value()),
+                     }](std::string const& msg) {
+                    stdOut(
+                        nlohmann::json{
+                            {"sessionId", sessionId.value()},
+                            {"channelId", channelId.value()},
+                            {"data", Roar::base64Encode(msg)},
+                        });
+                },
+                // Stderr
+                [sessionId = id_,
+                 channelId,
+                 stdErr =
+                     RpcHelper::RpcInCorrectThread{
+                         *wnd_,
+                         *hub_,
+                         fmt::format("sshTerminalStderr_{}", channelId.value()),
+                     }](std::string const& data) {
+                    stdErr(
+                        nlohmann::json{
+                            {"sessionId", sessionId.value()},
+                            {"channelId", channelId.value()},
+                            {"data", Roar::base64Encode(data)},
+                        });
+                },
+                // On channel exit:
+                [removeChannel =
+                     [this, channelId]() {
+                         removeChannel(channelId);
+                     },
+                 sessionId = id_,
+                 channelId,
+                 onExit = RpcHelper::RpcInCorrectThread{
+                     *wnd_,
+                     *hub_,
+                     fmt::format("sshTerminalOnExit_{}", channelId.value()),
+                 }]() {
+                    Log::info("Channel for session '{}' lost with id: {}", sessionId.value(), channelId.value());
+                    removeChannel();
+                    onExit({{"sessionId", sessionId.value()}, {"channelId", channelId.value()}});
+                });
+
+            return reply({{"success", true}});
+        });
+}
+
+void Session::registerRpcChannelClose()
+{
+    on(fmt::format("Session::{}::Channel::close", id_.value()))
+        .perform([this](RpcHelper::RpcOnce&& reply, std::string const& channelIdString) {
+            removeChannel(Ids::makeChannelId(channelIdString));
+            return reply({{"success", true}});
+        });
+}
+
+void Session::registerRpcChannelWrite()
+{
+    on(fmt::format("Session::{}::Channel::write", id_.value()))
+        .perform([this](RpcHelper::RpcOnce&& reply, std::string const& channelIdString, std::string&& data) {
+            withChannelDo(
+                Ids::makeChannelId(channelIdString),
+                [data = std::move(data)](RpcHelper::RpcOnce&& reply, auto&& channel) {
+                    channel->write(Roar::base64Decode(data));
+                    reply({{"success", true}});
+                },
+                std::move(reply));
+        });
+}
+
+void Session::registerRpcChannelPtyResize()
+{
+    on(fmt::format("Session::{}::Channel::ptyResize", id_.value()))
+        .perform([this](RpcHelper::RpcOnce&& reply, std::string const& channelIdString, int cols, int rows) {
+            withChannelDo(
+                Ids::makeChannelId(channelIdString),
+                [cols, rows](RpcHelper::RpcOnce&& reply, auto channel) {
+                    channel->resizePty(cols, rows);
+                    reply({{"success", true}});
+                },
+                std::move(reply));
+        });
+}
+
+void Session::registerRpcSftpListDirectory()
+{
+    on(fmt::format("Session::{}::sftp::listDirectory", id_.value()))
+        .perform([this](RpcHelper::RpcOnce&& reply, std::string const& channelIdString, std::string const& path) {
+            withSftpChannelDo(
+                Ids::makeChannelId(channelIdString),
+                [path](RpcHelper::RpcOnce&& reply, auto channel) {
+                    auto fut = channel->listDirectory(path);
+                    if (fut.wait_for(futureTimeout) != std::future_status::ready)
+                        return reply({{"error", "Failed to list directory: timeout"}});
+
+                    const auto result = fut.get();
+                    if (!result.has_value())
+                        return reply({{"error", result.error().message}});
+
+                    Log::info("Listed directory '{}', got {} entries", path, result->size());
+                    reply({{"entries", *result}});
+                },
+                std::move(reply));
+        });
+}
+
+void Session::registerRpcSftpCreateDirectory()
+{
+    on(fmt::format("Session::{}::sftp::createDirectory", id_.value()))
+        .perform([this](RpcHelper::RpcOnce&& reply, std::string const& channelIdString, std::string const& path) {
+            withSftpChannelDo(
+                Ids::makeChannelId(channelIdString),
+                [path](RpcHelper::RpcOnce&& reply, auto channel) {
+                    auto fut = channel->createDirectory(path);
+                    if (fut.wait_for(futureTimeout) != std::future_status::ready)
+                        return reply({{"error", "Failed to create directory: timeout"}});
+
+                    const auto result = fut.get();
+                    if (!result.has_value())
+                        return reply({{"error", result.error().message}});
+
+                    Log::info("Created directory '{}'", path);
+                    reply({{"success", true}});
+                },
+                std::move(reply));
+        });
+}
+
+void Session::registerRpcSftpCreateFile()
+{
+    on(fmt::format("Session::{}::sftp::createFile", id_.value()))
+        .perform([this](RpcHelper::RpcOnce&& reply, std::string const& channelIdString, std::string const& path) {
+            withSftpChannelDo(
+                Ids::makeChannelId(channelIdString),
+                [path](RpcHelper::RpcOnce&& reply, auto channel) {
+                    auto fut = channel->createFile(path);
+                    if (fut.wait_for(futureTimeout) != std::future_status::ready)
+                        return reply({{"error", "Failed to create file: timeout"}});
+
+                    const auto result = fut.get();
+                    if (!result.has_value())
+                        return reply({{"error", result.error().message}});
+
+                    Log::info("Created file '{}'", path);
+                    reply({{"success", true}});
+                },
+                std::move(reply));
+        });
+}
+
+void Session::registerRpcSftpAddDownloadOperation()
+{
+    on(fmt::format("Session::{}::sftp::addDownload", id_.value()))
+        .perform([this](
+                     RpcHelper::RpcOnce&& reply,
+                     std::string const& channelIdString,
+                     std::string const& newOperationIdString,
+                     std::string const& localPath,
+                     std::string const& remotePath) {
+            withSftpChannelDo(
+                Ids::makeChannelId(channelIdString),
+                [newOperationIdString, localPath, remotePath](RpcHelper::RpcOnce&& reply, auto channel) {
+                    // TODO:
+
+                    // const auto result = operationQueues_->addDownloadOperation(
+                    //     Ids::makeOperationId(newOperationIdString), localPath, remotePath);
+
+                    // if (!result.has_value())
+                    //     return reply({{"error", result.error().toString()}});
+
+                    Log::info(
+                        "Added download operation with id '{}' for file '{}' to '{}'",
+                        newOperationIdString,
+                        remotePath,
+                        localPath);
+                    reply({{"success", true}});
+                },
+                std::move(reply));
+        });
+
+    // hub.registerFunction(
+    //     "SessionManager::sftp::addDownload",
+    //     [this, hub = &hub](
+    //         std::string const& responseId,
+    //         std::string const& sessionIdString,
+    //         std::string const& channelIdString,
+    //         std::string const& newOperationIdString,
+    //         std::string const& localPath,
+    //         std::string const& remotePath) {
+    //         auto const& state = stateHolder_->stateCache();
+
+    //         auto sftp = channel->second.lock();
+    //         if (!sftp)
+    //         {
+    //             Log::error("Failed to lock sftp channel with id: {}", channelId.value());
+    //             hub->callRemote(responseId, nlohmann::json{{"error", "Failed to lock sftp channel"}});
+    //             return;
+    //         }
+
+    //         const auto result = operationQueue_.addDownloadOperation(
+    //             *sftp, Ids::makeOperationId(newOperationIdString), localPath, remotePath);
+
+    //         if (!result.has_value())
+    //         {
+    //             Log::error("Failed to add download operation: {}", result.error().toString());
+    //             hub->callRemote(responseId, nlohmann::json{{"error", result.error().toString()}});
+    //             return;
+    //         }
+
+    //         dispatchUpdates();
+    //         hub->callRemote(responseId, nlohmann::json{{"success", true}});
+    //     });
+}
\ No newline at end of file
diff --git a/backend/source/backend/session_manager.cpp b/backend/source/backend/session_manager.cpp
new file mode 100644
index 00000000..f794efed
--- /dev/null
+++ b/backend/source/backend/session_manager.cpp
@@ -0,0 +1,221 @@
+#include <backend/session_manager.hpp>
+#include <log/log.hpp>
+
+#include <boost/uuid/uuid_generators.hpp>
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <boost/asio/dispatch.hpp>
+#include <libssh/libssh.h>
+#include <roar/utility/base64.hpp>
+#include <roar/filesystem/special_paths.hpp>
+
+#include <optional>
+#include <thread>
+#include <future>
+#include <mutex>
+#include <cstring>
+
+using namespace Detail;
+
+int askPassDefault(char const* prompt, char* buf, std::size_t length, int, int, void* userdata)
+{
+    std::pair<SessionManager*, std::string> const* data =
+        static_cast<std::pair<SessionManager*, std::string>*>(userdata);
+
+    auto* manager = data->first;
+    std::string whatFor = data->second;
+
+    if (!manager->strand_->running_in_this_thread())
+    {
+        throw std::runtime_error(
+            "askPassDefault called outside of strand - This critical bug will crash the application.");
+    }
+
+    std::promise<std::optional<std::string>> pwPromise{};
+    std::function<void(decltype(manager->passwordProviders_)::const_iterator)> askNextProvider;
+
+    askNextProvider = [end = manager->passwordProviders_.end(), &askNextProvider, prompt, &pwPromise, &whatFor](
+                          decltype(manager->passwordProviders_)::const_iterator iter) {
+        if (iter == end)
+        {
+            pwPromise.set_value(std::nullopt);
+            return;
+        }
+
+        iter->second->getPassword(
+            whatFor, prompt, [iter, &pwPromise, &askNextProvider](std::optional<std::string> pw) mutable {
+                if (pw.has_value())
+                    pwPromise.set_value(pw);
+                else
+                {
+                    ++iter;
+                    askNextProvider(iter);
+                }
+            });
+    };
+    askNextProvider(manager->passwordProviders_.begin());
+
+    const auto pw = pwPromise.get_future().get();
+
+    if (pw.has_value())
+    {
+        std::memset(buf, 0, length);
+        std::strncpy(buf, pw.value().c_str(), length - 1);
+        return 0;
+    }
+    return -1;
+}
+
+SessionManager::SessionManager(
+    boost::asio::any_io_executor executor,
+    Persistence::StateHolder& stateHolder,
+    Nui::Window& wnd,
+    Nui::RpcHub& hub)
+    : RpcHelper::StrandRpc{executor, wnd, hub}
+    , stateHolder_{&stateHolder}
+{}
+
+void SessionManager::addPasswordProvider(int priority, PasswordProvider* provider)
+{
+    within_strand_do([this, priority, provider]() {
+        passwordProviders_.emplace(priority, provider);
+    });
+}
+
+void SessionManager::addSession(
+    Persistence::SshTerminalEngine const& engine,
+    std::function<void(std::optional<Ids::SessionId> const&)> onComplete)
+{
+    within_strand_do([this, engine, onComplete = std::move(onComplete)]() {
+        std::pair<SessionManager*, std::string> askPassUserDataKeyPhrase{this, "Key phrase"};
+        std::pair<SessionManager*, std::string> askPassUserDataPassword{this, "Password"};
+        auto maybeSshSession =
+            makeSession(engine, askPassDefault, &askPassUserDataKeyPhrase, &askPassUserDataPassword, &pwCache_);
+
+        if (maybeSshSession)
+        {
+            const auto sessionId = Ids::SessionId{Ids::generateId()};
+            const auto emplaced = sessions_.emplace(
+                sessionId,
+                Session{
+                    sessionId,
+                    std::move(maybeSshSession).value(),
+                    executor_,
+                    strand_,
+                    *wnd_,
+                    *hub_,
+                    engine.sshSessionOptions->sftpOptions.value()});
+            if (!emplaced.second)
+            {
+                Log::error("Session id collision - This should never happen");
+                return onComplete(std::nullopt);
+            }
+
+            Log::info("Created session with id '{}', total is now '{}'.", sessionId.value(), sessions_.size());
+            emplaced.first->second.start();
+            onComplete(sessionId);
+        }
+        else
+        {
+            Log::error("Failed to create session: {}", maybeSshSession.error());
+            onComplete(std::nullopt);
+        }
+    });
+}
+
+void SessionManager::removeSession(Ids::SessionId sessionId)
+{
+    within_strand_do([this, sessionId]() {
+        if (auto iter = sessions_.find(sessionId); iter != sessions_.end())
+        {
+            Log::info("Removing session with id: {}", sessionId.value());
+            sessions_.erase(iter);
+        }
+        else
+        {
+            Log::warn("Cannot remove session, no session found with id: {}", sessionId.value());
+        }
+    });
+}
+
+void SessionManager::registerRpc()
+{
+    registerRpcSessionConnect();
+    registerRpcSessionDisconnect();
+}
+
+void SessionManager::registerRpcSessionConnect()
+{
+    on("SessionManager::connect").perform([this](RpcHelper::RpcOnce&& reply, nlohmann::json const& parameters) {
+        Log::info("Connecting to ssh server with parameters: {}", parameters.dump(4));
+
+        if (!RpcHelper::ParameterVerifyView{reply, "SessionManager::connect", parameters}.hasValueDeep(
+                "engine", "sshSessionOptions"))
+        {
+            return;
+        }
+
+        auto onComplete = rpcSafe(std::move(reply), [](auto const& reply, auto const& maybeId) {
+            if (!maybeId)
+            {
+                Log::error("Failed to connect to ssh server");
+                return reply({{"error", "Failed to connect to ssh server"}});
+            }
+
+            Log::info("Connected to ssh server with id: {}", maybeId->value());
+            return reply({{"id", maybeId->value()}});
+        });
+
+        addSession(parameters["engine"].get<Persistence::SshTerminalEngine>(), std::move(onComplete));
+    });
+}
+
+void SessionManager::registerRpcSessionDisconnect()
+{
+    on("SessionManager::disconnect").perform([this](RpcHelper::RpcOnce&& reply, nlohmann::json const& parameters) {
+        if (!RpcHelper::ParameterVerifyView{reply, "SessionManager::disconnect", parameters}.hasValueDeep("sessionId"))
+            return;
+
+        try
+        {
+            removeSession(Ids::makeSessionId(parameters["sessionId"].get<std::string>()));
+            return reply({{"success", true}});
+        }
+        catch (std::exception const& e)
+        {
+            Log::error("Error disconnecting to ssh server: {}", e.what());
+            return reply({{"error", e.what()}});
+        }
+    });
+}
+
+// void SessionManager::startUpdateDispatching()
+// {
+//     updateDispatchRunning_ = true;
+//     dispatchUpdates();
+// }
+// void SessionManager::stopUpdateDispatching()
+// {
+//     updateDispatchRunning_ = false;
+// }
+
+// void SessionManager::dispatchUpdates()
+// {
+//     if (!updateDispatchRunning_)
+//         return;
+
+//     boost::asio::dispatch(executor_, [weak = weak_from_this()]() {
+//         auto self = weak.lock();
+//         if (!self)
+//             return;
+
+//         if (!self->updateDispatchRunning_)
+//         {
+//             Log::info("Update dispatching stopped");
+//             return;
+//         }
+
+//         if (self->operationQueue_.update())
+//             self->dispatchUpdates();
+//     });
+// }
\ No newline at end of file
diff --git a/backend/source/backend/sftp/operation_queue.cpp b/backend/source/backend/sftp/operation_queue.cpp
index f2a1b287..d79c0e86 100644
--- a/backend/source/backend/sftp/operation_queue.cpp
+++ b/backend/source/backend/sftp/operation_queue.cpp
@@ -33,8 +33,9 @@ namespace
     }
 }
 
-OperationQueue::OperationQueue(int parallelism)
-    : parallelism_{parallelism}
+OperationQueue::OperationQueue(Persistence::SftpOptions sftpOpts, int parallelism)
+    : sftpOpts_{std::move(sftpOpts)}
+    , parallelism_{parallelism}
 {}
 
 void OperationQueue::cancelAll()
@@ -94,8 +95,6 @@ bool OperationQueue::update()
 }
 
 std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
-    Persistence::State const& state,
-    std::string const& sshSessionOptionsKey,
     SecureShell::SftpSession& sftp,
     Ids::OperationId id,
     std::filesystem::path const& localPath,
@@ -115,17 +114,7 @@ std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
         return std::unexpected(Operation::Error{.type = Operation::ErrorType::SftpError, .sftpError = result.error()});
     }
 
-    auto sessionOptsIter = state.sshSessionOptions.find(sshSessionOptionsKey);
-    if (sessionOptsIter == state.sshSessionOptions.end())
-    {
-        Log::error("No ssh session options found with key: {}", sshSessionOptionsKey);
-        return std::unexpected(Operation::Error{.type = Operation::ErrorType::InvalidOptionsKey});
-    }
-
-    auto sessionOpts = sessionOptsIter->second;
-    sessionOpts.sftpOptions.resolveWith(state.sftpOptions);
-    const auto& sftpOpts = sessionOpts.sftpOptions;
-    const auto transferOptions = sftpOpts->downloadOptions.value_or(Persistence::TransferOptions{});
+    const auto transferOptions = sftpOpts_.downloadOptions.value_or(Persistence::TransferOptions{});
     const auto defaultOptions = DownloadOperation::DownloadOperationOptions{};
 
     auto operation = std::make_unique<DownloadOperation>(
diff --git a/backend/source/backend/ssh_session_manager.cpp b/backend/source/backend/ssh_session_manager.cpp
deleted file mode 100644
index f473c3e5..00000000
--- a/backend/source/backend/ssh_session_manager.cpp
+++ /dev/null
@@ -1,807 +0,0 @@
-#include <backend/ssh_session_manager.hpp>
-#include <log/log.hpp>
-
-#include <boost/uuid/uuid_generators.hpp>
-#include <boost/uuid/uuid.hpp>
-#include <boost/uuid/uuid_io.hpp>
-#include <boost/asio/dispatch.hpp>
-#include <libssh/libssh.h>
-#include <roar/utility/base64.hpp>
-#include <roar/filesystem/special_paths.hpp>
-
-#include <optional>
-#include <thread>
-#include <future>
-#include <mutex>
-#include <cstring>
-
-using namespace Detail;
-
-int askPassDefault(char const* prompt, char* buf, std::size_t length, int, int, void* userdata)
-{
-    std::pair<SshSessionManager*, std::string> const* data =
-        static_cast<std::pair<SshSessionManager*, std::string>*>(userdata);
-    auto* manager = data->first;
-    std::string whatFor = data->second;
-
-    std::promise<std::optional<std::string>> pwPromise{};
-    std::lock_guard<std::mutex> lock{manager->passwordProvidersMutex_};
-    std::function<void(decltype(manager->passwordProviders_)::const_iterator)> askNextProvider;
-
-    askNextProvider = [end = manager->passwordProviders_.end(), &askNextProvider, prompt, &pwPromise, &whatFor](
-                          decltype(manager->passwordProviders_)::const_iterator iter) {
-        if (iter == end)
-        {
-            pwPromise.set_value(std::nullopt);
-            return;
-        }
-
-        iter->second->getPassword(
-            whatFor, prompt, [iter, &pwPromise, &askNextProvider](std::optional<std::string> pw) mutable {
-                if (pw.has_value())
-                    pwPromise.set_value(pw);
-                else
-                {
-                    ++iter;
-                    askNextProvider(iter);
-                }
-            });
-    };
-    askNextProvider(manager->passwordProviders_.begin());
-
-    const auto pw = pwPromise.get_future().get();
-
-    if (pw.has_value())
-    {
-        std::memset(buf, 0, length);
-        std::strncpy(buf, pw.value().c_str(), length - 1);
-        return 0;
-    }
-    return -1;
-}
-
-SshSessionManager::SshSessionManager(boost::asio::any_io_executor executor, Persistence::StateHolder* stateHolder)
-    : executor_{std::move(executor)}
-    , stateHolder_(stateHolder)
-{}
-
-SshSessionManager::~SshSessionManager()
-{
-    joinSessionAdder();
-}
-
-void SshSessionManager::registerRpcConnect(Nui::Window&, Nui::RpcHub& hub)
-{
-    /*
-    {
-        engine: {
-            sshSessionOptions: Persistence::SshSessionOptions,
-            environment: std::unordered_map<std::string, std::string>
-        },
-    }
-    */
-    hub.registerFunction(
-        "SshSessionManager::connect",
-        [this, hub = &hub](std::string const& responseId, nlohmann::json const& parameters) {
-            try
-            {
-                Log::info("Connecting to ssh server with parameters: {}", parameters.dump(4));
-                if (!parameters.contains("engine"))
-                {
-                    Log::error("No engine specified for ssh connection");
-                    hub->callRemote(responseId, nlohmann::json{{"error", "No engine specified for ssh connection"}});
-                    return;
-                }
-
-                const auto sessionOptions =
-                    parameters["engine"]["sshSessionOptions"].get<Persistence::SshSessionOptions>();
-
-                const auto engine = parameters["engine"].get<Persistence::SshTerminalEngine>();
-                joinSessionAdder();
-                addSession(engine, [responseId, hub](auto const& maybeId) {
-                    if (!maybeId)
-                    {
-                        Log::error("Failed to connect to ssh server");
-                        hub->callRemote(responseId, nlohmann::json{{"error", "Failed to connect to ssh server"}});
-                        return;
-                    }
-
-                    Log::info("Connected to ssh server with id: {}", maybeId->value());
-                    hub->callRemote(responseId, nlohmann::json{{"id", maybeId->value()}});
-                });
-            }
-            catch (std::exception const& e)
-            {
-                Log::error("Error connecting to ssh server: {}", e.what());
-                hub->callRemote(responseId, nlohmann::json{{"error", e.what()}});
-                return;
-            }
-        });
-}
-
-void SshSessionManager::registerRpcCreateChannel(Nui::Window&, Nui::RpcHub& hub)
-{
-    /*
-    {
-        sessionId: string,
-        engine: {
-            sshSessionOptions: Persistence::SshSessionOptions,
-            environment: std::unordered_map<std::string, std::string>
-        }
-    }
-    */
-    hub.registerFunction(
-        "SshSessionManager::Session::createChannel",
-        [this, hub = &hub](std::string const& responseId, nlohmann::json const& parameters) {
-            if (!parameters.contains("sessionId"))
-            {
-                Log::error("No session id specified for channel creation");
-                hub->callRemote(responseId, nlohmann::json{{"error", "No session id specified for channel creation"}});
-                return;
-            }
-
-            const auto sessionId = Ids::makeSessionId(parameters.at("sessionId").get<std::string>());
-
-            if (sessions_.find(sessionId) == sessions_.end())
-            {
-                Log::error("No session found with id: {}", sessionId.value());
-                hub->callRemote(responseId, nlohmann::json{{"error", "No session found with id"}});
-                return;
-            }
-
-            if (!parameters.contains("engine"))
-            {
-                Log::error("No engine specified for ssh channel");
-                hub->callRemote(responseId, nlohmann::json{{"error", "No engine specified for ssh connection"}});
-                return;
-            }
-
-            bool fileMode = false;
-            if (parameters.contains("fileMode") && parameters["fileMode"].is_boolean())
-            {
-                fileMode = parameters["fileMode"].get<bool>();
-            }
-
-            if (!fileMode)
-            {
-                const auto sessionOptions =
-                    parameters["engine"]["sshSessionOptions"].get<Persistence::SshSessionOptions>();
-                auto env = sessionOptions.environment;
-
-                const auto weakChannel = sessions_[sessionId]->createPtyChannel({.environment = env}).get();
-                if (!weakChannel.has_value())
-                {
-                    Log::error("Failed to create pty channel: {}", weakChannel.error());
-                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to create pty channel"}});
-                    return;
-                }
-
-                const auto channelId = Ids::generateChannelId();
-                channels_.emplace(channelId, std::move(weakChannel).value());
-
-                Log::info(
-                    "Created pty channel with id '{}', channel total is now '{}'.",
-                    channelId.value(),
-                    channels_.size());
-
-                hub->callRemote(responseId, nlohmann::json{{"id", channelId.value()}});
-            }
-            else
-            {
-                const auto weakChannel = sessions_[sessionId]->createSftpSession().get();
-                if (!weakChannel.has_value())
-                {
-                    Log::error("Failed to create sftp channel: {}", weakChannel.error().toString());
-                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to create sftp channel"}});
-                    return;
-                }
-
-                const auto channelId = Ids::generateChannelId();
-                sftpChannels_.emplace(channelId, std::move(weakChannel).value());
-
-                Log::info(
-                    "Created sftp channel with id '{}', sftp channel total is now '{}'.",
-                    channelId.value(),
-                    sftpChannels_.size());
-
-                hub->callRemote(responseId, nlohmann::json{{"id", channelId.value()}});
-            }
-        });
-}
-
-void SshSessionManager::registerRpcStartChannelRead(Nui::Window& wnd, Nui::RpcHub& hub)
-{
-    hub.registerFunction(
-        "SshSessionManager::Channel::startReading",
-        [this, hub = &hub, wnd = &wnd](
-            std::string const& responseId, std::string const& sessionIdString, std::string const& channelIdString) {
-            const auto sessionId = Ids::makeSessionId(sessionIdString);
-            const auto channelId = Ids::makeChannelId(channelIdString);
-
-            if (sessions_.find(sessionId) == sessions_.end())
-            {
-                Log::error("No session found with id: {}", sessionId.value());
-                hub->callRemote(responseId, nlohmann::json{{"error", "No session found with id"}});
-                return;
-            }
-
-            if (channels_.find(channelId) == channels_.end())
-            {
-                Log::error("No channel found with id: {}", channelId.value());
-                hub->callRemote(responseId, nlohmann::json{{"error", "No channel found with id"}});
-                return;
-            }
-
-            auto& channel = channels_[channelId];
-
-            auto locked = channel.lock();
-            if (!locked)
-            {
-                Log::error("Failed to lock channel with id: {}", channelId.value());
-                hub->callRemote(responseId, nlohmann::json{{"error", "Failed to lock channel"}});
-                return;
-            }
-
-            const std::string stdoutReceptacle{"sshTerminalStdout_" + channelId.value()};
-            const std::string stderrReceptacle{"sshTerminalStderr_" + channelId.value()};
-            const std::string exitReceptacle{"sshTerminalOnExit_" + channelId.value()};
-
-            locked->startReading(
-                [wnd, hub, sessionId, channelId, stdoutReceptacle](std::string const& msg) {
-                    wnd->runInJavascriptThread([hub, stdoutReceptacle, sessionId, channelId, msg]() {
-                        hub->callRemote(
-                            stdoutReceptacle,
-                            nlohmann::json{
-                                {"sessionId", sessionId.value()},
-                                {"channelId", channelId.value()},
-                                {"data", Roar::base64Encode(msg)}});
-                    });
-                },
-                [wnd, hub, sessionId, channelId, stderrReceptacle](std::string const& data) {
-                    wnd->runInJavascriptThread([hub, stderrReceptacle, sessionId, channelId, data]() {
-                        hub->callRemote(
-                            stderrReceptacle,
-                            nlohmann::json{
-                                {"sessionId", sessionId.value()},
-                                {"channelId", channelId.value()},
-                                {"data", Roar::base64Encode(data)}});
-                    });
-                },
-                [this, wnd, hub, sessionId, channelId, exitReceptacle]() {
-                    Log::info("Channel for session '{}' lost with id: {}", sessionId.value(), channelId.value());
-
-                    auto iter = channels_.find(channelId);
-                    if (iter != channels_.end())
-                    {
-                        if (auto locked = iter->second.lock(); locked)
-                        {
-                            locked->close();
-                        }
-                        channels_.erase(iter);
-                    }
-
-                    wnd->runInJavascriptThread([hub, sessionId, channelId, exitReceptacle]() {
-                        hub->callRemote(
-                            exitReceptacle,
-                            nlohmann::json{{"sessionId", sessionId.value()}, {"channelId", channelId.value()}});
-                    });
-                });
-
-            hub->callRemote(responseId, nlohmann::json{{"success", true}});
-        });
-}
-
-void SshSessionManager::registerRpcChannelClose(Nui::Window&, Nui::RpcHub& hub)
-{
-    hub.registerFunction(
-        "SshSessionManager::Session::closeChannel",
-        [this, hub = &hub](std::string const& responseId, std::string const& channelIdString) {
-            try
-            {
-                const auto channelId = Ids::makeChannelId(channelIdString);
-
-                if (auto iter = channels_.find(channelId); iter != channels_.end())
-                {
-                    if (auto channel = iter->second.lock(); channel)
-                    {
-                        channel->close();
-                    }
-                    channels_.erase(iter);
-                    Log::info(
-                        "Closed channel with id '{}', now remaining channels total '{}'.",
-                        channelId.value(),
-                        channels_.size());
-                }
-                else if (auto iter = sftpChannels_.find(channelId); iter != sftpChannels_.end())
-                {
-                    if (auto channel = iter->second.lock(); channel)
-                    {
-                        channel->close();
-                    }
-                    sftpChannels_.erase(iter);
-                    Log::info(
-                        "Closed sftp channel with id '{}', now remaining sftp channels total '{}'.",
-                        channelId.value(),
-                        sftpChannels_.size());
-                }
-                else
-                {
-                    Log::error("No channel found with id: {}", channelId.value());
-                    hub->callRemote(responseId, nlohmann::json{{"error", "No channel found with id"}});
-                    return;
-                }
-
-                hub->callRemote(responseId, nlohmann::json{{"success", true}});
-            }
-            catch (std::exception const& e)
-            {
-                Log::error("Error closing channel: {}", e.what());
-                hub->callRemote(responseId, nlohmann::json{{"error", e.what()}});
-                return;
-            }
-        });
-}
-
-void SshSessionManager::registerRpcEndSession(Nui::Window&, Nui::RpcHub& hub)
-{
-    hub.registerFunction(
-        "SshSessionManager::disconnect",
-        [this, hub = &hub](std::string const& responseId, std::string const& sessionIdString) {
-            try
-            {
-                const auto sessionId = Ids::makeSessionId(sessionIdString);
-
-                if (sessions_.find(sessionId) == sessions_.end())
-                {
-                    // Do not log this, because multi delete is not an error
-                    hub->callRemote(responseId, nlohmann::json{{"error", "No session found with id"}});
-                    return;
-                }
-                Log::info("Disconnecting from ssh server with id: {}", sessionId.value());
-                sessions_.erase(sessionId);
-                hub->callRemote(responseId, nlohmann::json{{"success", true}});
-            }
-            catch (std::exception const& e)
-            {
-                Log::error("Error disconnecting to ssh server: {}", e.what());
-                hub->callRemote(responseId, nlohmann::json{{"error", e.what()}});
-                return;
-            }
-        });
-}
-
-void SshSessionManager::registerRpcChannelWrite(Nui::Window&, Nui::RpcHub& hub)
-{
-    hub.registerFunction(
-        "SshSessionManager::Channel::write",
-        [this, hub = &hub](std::string const& responseId, std::string const& channelIdString, std::string const& data) {
-            try
-            {
-                const auto channelId = Ids::makeChannelId(channelIdString);
-
-                if (auto iter = channels_.find(channelId); iter != channels_.end())
-                {
-                    if (auto channel = iter->second.lock(); channel)
-                    {
-                        channel->write(Roar::base64Decode(data));
-                    }
-                    else
-                    {
-                        Log::error("Failed to get channel: {}", channelId.value());
-                        hub->callRemote(responseId, nlohmann::json{{"error", "Failed to get channel"}});
-                        return;
-                    }
-                }
-                else
-                {
-                    Log::error("No channel found with id: {}", channelId.value());
-                    hub->callRemote(responseId, nlohmann::json{{"error", "No channel found with id"}});
-                    return;
-                }
-            }
-            catch (std::exception const& e)
-            {
-                Log::error("Error writing to pty: {}", e.what());
-                hub->callRemote(responseId, nlohmann::json{{"error", e.what()}});
-                return;
-            }
-        });
-}
-
-void SshSessionManager::registerRpcChannelPtyResize(Nui::Window&, Nui::RpcHub& hub)
-{
-    hub.registerFunction(
-        "SshSessionManager::Channel::ptyResize",
-        [this, hub = &hub](std::string const& responseId, std::string const& channelIdString, int cols, int rows) {
-            try
-            {
-                const auto channelId = Ids::makeChannelId(channelIdString);
-
-                if (auto iter = channels_.find(channelId); iter != channels_.end())
-                {
-                    if (auto channel = iter->second.lock(); channel)
-                    {
-                        channel->resizePty(cols, rows);
-                        // FIXME: Why does this always fail?
-                        // if (fut.wait_for(std::chrono::milliseconds{500}) != std::future_status::ready)
-                        // {
-                        //     Log::error("Failed to resize pty: timeout");
-                        //     hub->callRemote(responseId, nlohmann::json{{"error", "Failed to resize pty:
-                        //     timeout"}}); return;
-                        // }
-                        // const auto result = fut.get();
-                        // if (result != 0)
-                        // {
-                        //     Log::error("Failed to resize pty: {}", result);
-                        //     hub->callRemote(responseId, nlohmann::json{{"error", "Failed to resize pty"}});
-                        //     return;
-                        // }
-                        hub->callRemote(responseId, nlohmann::json{{"success", true}});
-                    }
-                    else
-                    {
-                        Log::error("Failed to get channel: {}", channelId.value());
-                        hub->callRemote(responseId, nlohmann::json{{"error", "Failed to get channel"}});
-                        return;
-                    }
-                }
-                else
-                {
-                    Log::error("No channel found with id: {}", channelId.value());
-                    hub->callRemote(responseId, nlohmann::json{{"error", "No channel found with id"}});
-                    return;
-                }
-            }
-            catch (std::exception const& e)
-            {
-                Log::error("Error resizing pty: {}", e.what());
-                hub->callRemote(responseId, nlohmann::json{{"error", e.what()}});
-                return;
-            }
-        });
-}
-
-void SshSessionManager::registerRpcSftpListDirectory(Nui::Window&, Nui::RpcHub& hub)
-{
-    hub.registerFunction(
-        "SshSessionManager::sftp::listDirectory",
-        [this, hub = &hub](
-            std::string const& responseId,
-            std::string const& sessionIdString,
-            std::string const& channelIdString,
-            std::string const& path) {
-            try
-            {
-                const auto sessionId = Ids::makeSessionId(sessionIdString);
-                const auto channelId = Ids::makeChannelId(channelIdString);
-
-                if (sessions_.find(sessionId) == sessions_.end())
-                {
-                    Log::error("No session found with id: {}", sessionId.value());
-                    hub->callRemote(responseId, nlohmann::json{{"error", "No session found with id"}});
-                    return;
-                }
-
-                auto channel = sftpChannels_.find(channelId);
-                if (channel == sftpChannels_.end())
-                {
-                    Log::error("No sftp channel found with id: {}", channelId.value());
-                    hub->callRemote(responseId, nlohmann::json{{"error", "No sftp channel found with id"}});
-                    return;
-                }
-
-                auto locked = channel->second.lock();
-                if (!locked)
-                {
-                    Log::error("Failed to lock sftp channel with id: {}", channelId.value());
-                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to lock sftp channel"}});
-                    return;
-                }
-
-                auto fut = locked->listDirectory(path);
-                if (fut.wait_for(futureTimeout) != std::future_status::ready)
-                {
-                    Log::error("Failed to list directory: timeout");
-                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to list directory: timeout"}});
-                    return;
-                }
-
-                const auto result = fut.get();
-                if (!result.has_value())
-                {
-                    Log::error("Failed to list directory: {}", result.error().message);
-                    hub->callRemote(responseId, nlohmann::json{{"error", result.error().message}});
-                    return;
-                }
-
-                dispatchUpdates();
-                hub->callRemote(responseId, nlohmann::json{{"entries", *result}});
-            }
-            catch (std::exception const& e)
-            {
-                Log::error("Error listing directory: {}", e.what());
-                hub->callRemote(responseId, nlohmann::json{{"error", e.what()}});
-                return;
-            }
-        });
-}
-
-void SshSessionManager::registerRpcSftpCreateDirectory(Nui::Window&, Nui::RpcHub& hub)
-{
-    hub.registerFunction(
-        "SshSessionManager::sftp::createDirectory",
-        [this, hub = &hub](
-            std::string const& responseId,
-            std::string const& sessionIdString,
-            std::string const& channelIdString,
-            std::string const& path) {
-            try
-            {
-                const auto sessionId = Ids::makeSessionId(sessionIdString);
-                const auto channelId = Ids::makeChannelId(channelIdString);
-
-                if (sessions_.find(sessionId) == sessions_.end())
-                {
-                    Log::error("No session found with id: {}", sessionId.value());
-                    hub->callRemote(responseId, nlohmann::json{{"error", "No session found with id"}});
-                    return;
-                }
-
-                auto channel = sftpChannels_.find(channelId);
-                if (channel == sftpChannels_.end())
-                {
-                    Log::error("No sftp channel found with id: {}", channelId.value());
-                    hub->callRemote(responseId, nlohmann::json{{"error", "No sftp channel found with id"}});
-                    return;
-                }
-
-                auto locked = channel->second.lock();
-                if (!locked)
-                {
-                    Log::error("Failed to lock sftp channel with id: {}", channelId.value());
-                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to lock sftp channel"}});
-                    return;
-                }
-
-                auto fut = locked->createDirectory(path);
-                if (fut.wait_for(futureTimeout) != std::future_status::ready)
-                {
-                    Log::error("Failed to create directory: timeout");
-                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to create directory: timeout"}});
-                    return;
-                }
-
-                const auto result = fut.get();
-                if (!result.has_value())
-                {
-                    Log::error("Failed to create directory: {}", result.error().message);
-                    hub->callRemote(responseId, nlohmann::json{{"error", result.error().message}});
-                    return;
-                }
-
-                dispatchUpdates();
-                hub->callRemote(responseId, nlohmann::json{{"success", true}});
-            }
-            catch (std::exception const& e)
-            {
-                Log::error("Error creating directory: {}", e.what());
-                hub->callRemote(responseId, nlohmann::json{{"error", e.what()}});
-                return;
-            }
-        });
-}
-
-void SshSessionManager::registerRpcSftpCreateFile(Nui::Window&, Nui::RpcHub& hub)
-{
-    hub.registerFunction(
-        "SshSessionManager::sftp::createFile",
-        [this, hub = &hub](
-            std::string const& responseId,
-            std::string const& sessionIdString,
-            std::string const& channelIdString,
-            std::string const& path) {
-            try
-            {
-                const auto sessionId = Ids::makeSessionId(sessionIdString);
-                const auto channelId = Ids::makeChannelId(channelIdString);
-
-                if (sessions_.find(sessionId) == sessions_.end())
-                {
-                    Log::error("No session found with id: {}", sessionId.value());
-                    hub->callRemote(responseId, nlohmann::json{{"error", "No session found with id"}});
-                    return;
-                }
-
-                auto channel = sftpChannels_.find(channelId);
-                if (channel == sftpChannels_.end())
-                {
-                    Log::error("No sftp channel found with id: {}", channelId.value());
-                    hub->callRemote(responseId, nlohmann::json{{"error", "No sftp channel found with id"}});
-                    return;
-                }
-
-                auto locked = channel->second.lock();
-                if (!locked)
-                {
-                    Log::error("Failed to lock sftp channel with id: {}", channelId.value());
-                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to lock sftp channel"}});
-                    return;
-                }
-
-                auto fut = locked->createFile(path);
-                if (fut.wait_for(futureTimeout) != std::future_status::ready)
-                {
-                    Log::error("Failed to create file: timeout");
-                    hub->callRemote(responseId, nlohmann::json{{"error", "Failed to create file: timeout"}});
-                    return;
-                }
-
-                const auto result = fut.get();
-                if (!result.has_value())
-                {
-                    Log::error("Failed to create file: {}", result.error().message);
-                    hub->callRemote(responseId, nlohmann::json{{"error", result.error().message}});
-                    return;
-                }
-
-                dispatchUpdates();
-                hub->callRemote(responseId, nlohmann::json{{"success", true}});
-            }
-            catch (std::exception const& exc)
-            {
-                Log::error("Error creating file: {}", exc.what());
-                hub->callRemote(responseId, nlohmann::json{{"error", exc.what()}});
-                return;
-            }
-        });
-}
-
-void SshSessionManager::registerRpcSftpAddDownloadOperation(Nui::Window&, Nui::RpcHub& hub)
-{
-    hub.registerFunction(
-        "SshSessionManager::sftp::addDownload",
-        [this, hub = &hub](
-            std::string const& responseId,
-            std::string const& sessionIdString,
-            std::string const& channelIdString,
-            std::string const& newOperationIdString,
-            std::string const& sshSessionOptionsKey,
-            std::string const& localPath,
-            std::string const& remotePath) {
-            auto const& state = stateHolder_->stateCache();
-
-            const auto sessionId = Ids::makeSessionId(sessionIdString);
-            const auto channelId = Ids::makeChannelId(channelIdString);
-
-            if (sessions_.find(sessionId) == sessions_.end())
-            {
-                Log::error("No session found with id: {}", sessionId.value());
-                hub->callRemote(responseId, nlohmann::json{{"error", "No session found with id"}});
-                return;
-            }
-
-            auto channel = sftpChannels_.find(channelId);
-            if (channel == sftpChannels_.end())
-            {
-                Log::error("No sftp channel found with id: {}", channelId.value());
-                hub->callRemote(responseId, nlohmann::json{{"error", "No sftp channel found with id"}});
-                return;
-            }
-
-            auto sftp = channel->second.lock();
-            if (!sftp)
-            {
-                Log::error("Failed to lock sftp channel with id: {}", channelId.value());
-                hub->callRemote(responseId, nlohmann::json{{"error", "Failed to lock sftp channel"}});
-                return;
-            }
-
-            const auto result = operationQueue_.addDownloadOperation(
-                state, sshSessionOptionsKey, *sftp, Ids::makeOperationId(newOperationIdString), localPath, remotePath);
-
-            if (!result.has_value())
-            {
-                Log::error("Failed to add download operation: {}", result.error().toString());
-                hub->callRemote(responseId, nlohmann::json{{"error", result.error().toString()}});
-                return;
-            }
-
-            dispatchUpdates();
-            hub->callRemote(responseId, nlohmann::json{{"success", true}});
-        });
-}
-
-void SshSessionManager::startUpdateDispatching()
-{
-    updateDispatchRunning_ = true;
-    dispatchUpdates();
-}
-void SshSessionManager::stopUpdateDispatching()
-{
-    updateDispatchRunning_ = false;
-}
-
-void SshSessionManager::dispatchUpdates()
-{
-    if (!updateDispatchRunning_)
-        return;
-
-    boost::asio::dispatch(executor_, [weak = weak_from_this()]() {
-        auto self = weak.lock();
-        if (!self)
-            return;
-
-        if (!self->updateDispatchRunning_)
-        {
-            Log::info("Update dispatching stopped");
-            return;
-        }
-
-        if (self->operationQueue_.update())
-            self->dispatchUpdates();
-    });
-}
-
-void SshSessionManager::registerRpc(Nui::Window& wnd, Nui::RpcHub& hub)
-{
-    registerRpcConnect(wnd, hub);
-    registerRpcCreateChannel(wnd, hub);
-    registerRpcStartChannelRead(wnd, hub);
-    registerRpcChannelClose(wnd, hub);
-    registerRpcEndSession(wnd, hub);
-    registerRpcChannelWrite(wnd, hub);
-    registerRpcChannelPtyResize(wnd, hub);
-
-    registerRpcSftpListDirectory(wnd, hub);
-    registerRpcSftpCreateDirectory(wnd, hub);
-    registerRpcSftpCreateFile(wnd, hub);
-
-    registerRpcSftpAddDownloadOperation(wnd, hub);
-}
-
-void SshSessionManager::addPasswordProvider(int priority, PasswordProvider* provider)
-{
-    std::lock_guard lock{passwordProvidersMutex_};
-    passwordProviders_.emplace(priority, provider);
-}
-
-void SshSessionManager::joinSessionAdder()
-{
-    std::scoped_lock guard{addSessionMutex_};
-    if (addSessionThread_ && addSessionThread_->joinable())
-    {
-        addSessionThread_->join();
-        addSessionThread_.reset();
-    }
-}
-
-void SshSessionManager::addSession(
-    Persistence::SshTerminalEngine const& engine,
-    std::function<void(std::optional<Ids::SessionId> const&)> onComplete)
-{
-    std::scoped_lock guard{addSessionMutex_};
-    if (addSessionThread_ && addSessionThread_->joinable())
-    {
-        Log::error("Session creation already in progress");
-        onComplete(std::nullopt);
-    }
-
-    addSessionThread_ = std::make_unique<std::thread>([this, engine, onComplete = std::move(onComplete)]() {
-        std::pair<SshSessionManager*, std::string> askPassUserDataKeyPhrase{this, "Key phrase"};
-        std::pair<SshSessionManager*, std::string> askPassUserDataPassword{this, "Password"};
-        auto maybeSession =
-            makeSession(engine, askPassDefault, &askPassUserDataKeyPhrase, &askPassUserDataPassword, &pwCache_);
-        if (maybeSession)
-        {
-            const auto sessionId = Ids::SessionId{Ids::generateId()};
-            sessions_.emplace(sessionId, std::move(maybeSession).value());
-            sessions_[sessionId]->start();
-            onComplete(sessionId);
-        }
-        else
-        {
-            Log::error("Failed to create session: {}", maybeSession.error());
-            onComplete(std::nullopt);
-        }
-    });
-}
\ No newline at end of file
diff --git a/frontend/include/frontend/session_components/operation_queue.hpp b/frontend/include/frontend/session_components/operation_queue.hpp
index f4e06553..7e5b7634 100644
--- a/frontend/include/frontend/session_components/operation_queue.hpp
+++ b/frontend/include/frontend/session_components/operation_queue.hpp
@@ -22,7 +22,9 @@ class OperationQueue
     ROAR_PIMPL_SPECIAL_FUNCTIONS(OperationQueue);
 
     void enqueueDownload(std::filesystem::path const& remotePath, std::filesystem::path const& localPath);
+    void enqueueDownloadSet(std::vector<std::pair<std::filesystem::path, std::filesystem::path>> const& downloads);
     void enqueueUpload(std::filesystem::path const& localPath, std::filesystem::path const& remotePath);
+    void enqueueUploadSet(std::vector<std::pair<std::filesystem::path, std::filesystem::path>> const& uploads);
     void enqueueRename(std::filesystem::path const& oldPath, std::filesystem::path const& newPath);
     void enqueueDelete(std::filesystem::path const& path);
 
diff --git a/frontend/include/frontend/terminal/file_engine.hpp b/frontend/include/frontend/terminal/file_engine.hpp
index 5961cc67..329b8646 100644
--- a/frontend/include/frontend/terminal/file_engine.hpp
+++ b/frontend/include/frontend/terminal/file_engine.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <shared_data/directory_entry.hpp>
+#include <ids/ids.hpp>
 
 #include <filesystem>
 #include <vector>
@@ -23,5 +24,20 @@ class FileEngine
     virtual void createDirectory(std::filesystem::path const& path, std::function<void(bool)> onComplete) = 0;
     virtual void createFile(std::filesystem::path const& path, std::function<void(bool)> onComplete) = 0;
 
+    /**hub.registerFunction(
+    "SessionManager::sftp::addDownload",
+    [this, hub = &hub](
+        std::string const& responseId,
+        std::string const& sessionIdString,
+        std::string const& channelIdString,
+        std::string const& newOperationIdString,
+        std::string const& sshSessionOptionsKey,
+        std::string const& localPath,
+        std::string const& remotePath) */
+
+    // TODO:
+    // virtual Ids::OperationId
+    // addDownload(std::filesystem::path const& remotePath, std::filesystem::path const& localPath) = 0;
+
     virtual void dispose() = 0;
 };
\ No newline at end of file
diff --git a/frontend/source/frontend/session.cpp b/frontend/source/frontend/session.cpp
index c7e08d87..5331c0cc 100644
--- a/frontend/source/frontend/session.cpp
+++ b/frontend/source/frontend/session.cpp
@@ -301,8 +301,14 @@ void Session::setupFileGrid()
                      return;
                  }
 
+                 std::vector<std::pair<std::filesystem::path, std::filesystem::path>> downloadItems;
+                 std::transform(items.begin(), items.end(), std::back_inserter(downloadItems), [](auto const& item) {
+                     // TODO: Proper target path handling:
+                     return std::make_pair(item.path, "D:/DownloadTemp" / item.path.filename());
+                 });
+
                  Log::info("Downloading items");
-                 // TODO: ...
+                 impl_->operationQueue.enqueueDownloadSet(downloadItems);
              }});
     });
 
@@ -325,7 +331,7 @@ void Session::setupFileGrid()
             .headerText = "Rename " + item.path.filename().string(),
             .isPassword = false,
             .onConfirm =
-                [this, item](std::optional<std::string> const& name) {
+                [item](std::optional<std::string> const& name) {
                     if (!name)
                         return;
 
@@ -335,7 +341,7 @@ void Session::setupFileGrid()
         });
     });
 
-    impl_->fileGrid.onProperties([this](auto const& item) {
+    impl_->fileGrid.onProperties([](auto const& item) {
         Log::info("Properties requested: {}", item.path.generic_string());
 
         // TODO: ...
diff --git a/frontend/source/frontend/session_area.cpp b/frontend/source/frontend/session_area.cpp
index bb448b60..b69050f7 100644
--- a/frontend/source/frontend/session_area.cpp
+++ b/frontend/source/frontend/session_area.cpp
@@ -143,7 +143,7 @@ void SessionArea::addSession(std::string const& name)
         if (!success)
             return;
 
-        auto const& state = holder.stateCache();
+        auto const& state = holder.stateCache().fullyResolve();
 
         auto iter = state.sessions.find(name);
         if (iter == end(state.sessions))
@@ -154,44 +154,27 @@ void SessionArea::addSession(std::string const& name)
 
         auto [engineKey, engine] = *iter;
 
-        if (!engine.terminalOptions.resolveWith(state.terminalOptions))
-            Log::warn("Failed to resolve ref options for engine: {}", name);
-
-        if (!engine.termios.resolveWith(state.termios))
-            Log::warn("Failed to resolve ref termios for engine: {}", name);
-
-        if (std::holds_alternative<Persistence::SshTerminalEngine>(engine.engine))
-        {
-            auto& sshEngine = std::get<Persistence::SshTerminalEngine>(engine.engine);
-            auto& sshSessionOptions = sshEngine.sshSessionOptions;
-
-            if (!sshSessionOptions.resolveWith(state.sshSessionOptions))
-                Log::warn("Failed to resolve ref ssh session options for engine: {}", name);
-
-            if (!sshSessionOptions->sshOptions.resolveWith(state.sshOptions))
-                Log::warn("Failed to resolve ref ssh options for engine: {}", name);
-        }
-
         Log::info("Adding session: {} with layout {}", name, impl_->toolbar->selectedLayout());
-        impl_->sessions.emplace_back(std::make_unique<Session>(
-            impl_->stateHolder,
-            impl_->events,
-            engine,
-            state.uiOptions,
-            name,
-            impl_->toolbar->selectedLayout(),
-            impl_->newItemAskDialog,
-            impl_->confirmDialog,
-            [this](Session const* ptr) {
-                auto const index = std::distance(
-                    begin(impl_->sessions.value()),
-                    std::find_if(
-                        begin(impl_->sessions.value()), end(impl_->sessions.value()), [ptr](auto const& session) {
-                            return session.get() == ptr;
-                        }));
-                removeSession(index);
-            },
-            impl_->sessions.size() == 0));
+        impl_->sessions.emplace_back(
+            std::make_unique<Session>(
+                impl_->stateHolder,
+                impl_->events,
+                engine,
+                state.uiOptions,
+                name,
+                impl_->toolbar->selectedLayout(),
+                impl_->newItemAskDialog,
+                impl_->confirmDialog,
+                [this](Session const* ptr) {
+                    auto const index = std::distance(
+                        begin(impl_->sessions.value()),
+                        std::find_if(
+                            begin(impl_->sessions.value()), end(impl_->sessions.value()), [ptr](auto const& session) {
+                                return session.get() == ptr;
+                            }));
+                    removeSession(index);
+                },
+                impl_->sessions.size() == 0));
 
         if (impl_->selected >= 0 && impl_->selected < static_cast<int>(impl_->sessions.size()))
             impl_->sessions.value()[impl_->selected]->visible(false);
diff --git a/frontend/source/frontend/session_components/operation_queue.cpp b/frontend/source/frontend/session_components/operation_queue.cpp
index 5235f57f..4ec7513d 100644
--- a/frontend/source/frontend/session_components/operation_queue.cpp
+++ b/frontend/source/frontend/session_components/operation_queue.cpp
@@ -61,10 +61,30 @@ Nui::ElementRenderer OperationQueue::operator()()
 }
 
 void OperationQueue::enqueueDownload(std::filesystem::path const& remotePath, std::filesystem::path const& localPath)
-{}
+{
+    // fileEngine->
+}
 void OperationQueue::enqueueUpload(std::filesystem::path const& localPath, std::filesystem::path const& remotePath)
 {}
 void OperationQueue::enqueueRename(std::filesystem::path const& oldPath, std::filesystem::path const& newPath)
 {}
 void OperationQueue::enqueueDelete(std::filesystem::path const& path)
-{}
\ No newline at end of file
+{}
+void OperationQueue::enqueueDownloadSet(
+    std::vector<std::pair<std::filesystem::path, std::filesystem::path>> const& downloads)
+{
+    // TODO: Do this as a group operation. For now, just iterate and enqueue each one.
+    for (const auto& [remotePath, localPath] : downloads)
+    {
+        enqueueDownload(remotePath, localPath);
+    }
+}
+void OperationQueue::enqueueUploadSet(
+    std::vector<std::pair<std::filesystem::path, std::filesystem::path>> const& uploads)
+{
+    // TODO: Do this as a group operation. For now, just iterate and enqueue each one.
+    for (const auto& [remotePath, localPath] : uploads)
+    {
+        enqueueDownload(remotePath, localPath);
+    }
+}
\ No newline at end of file
diff --git a/frontend/source/frontend/terminal/sftp_file_engine.cpp b/frontend/source/frontend/terminal/sftp_file_engine.cpp
index f9001cb2..14f98a49 100644
--- a/frontend/source/frontend/terminal/sftp_file_engine.cpp
+++ b/frontend/source/frontend/terminal/sftp_file_engine.cpp
@@ -74,8 +74,9 @@ void SftpFileEngine::listDirectory(
 
         Log::info("Listing directory: {}", path.generic_string());
         Nui::RpcClient::callWithBackChannel(
-            "SshSessionManager::sftp::listDirectory",
+            fmt::format("Session::{}::sftp::listDirectory", impl_->engine->sshSessionId().value()),
             [onComplete = std::move(onComplete)](Nui::val val) {
+                Log::info("Received response for listing directory.");
                 Nui::Console::log(val);
 
                 if (val.hasOwnProperty("error") || !val.hasOwnProperty("entries"))
@@ -94,7 +95,6 @@ void SftpFileEngine::listDirectory(
 
                 onComplete(nlohmann::json::parse(Nui::JSON::stringify(val))["entries"]);
             },
-            impl_->engine->sshSessionId().value(),
             channelId.value().value(),
             path.generic_string());
     });
@@ -111,7 +111,7 @@ void SftpFileEngine::createDirectory(std::filesystem::path const& path, std::fun
 
         Log::info("Creating directory: {}", path.generic_string());
         Nui::RpcClient::callWithBackChannel(
-            "SshSessionManager::sftp::createDirectory",
+            fmt::format("Session::{}::sftp::createDirectory", impl_->engine->sshSessionId().value()),
             [onComplete = std::move(onComplete)](Nui::val val) {
                 Nui::Console::log(val);
 
@@ -124,7 +124,6 @@ void SftpFileEngine::createDirectory(std::filesystem::path const& path, std::fun
 
                 onComplete(true);
             },
-            impl_->engine->sshSessionId().value(),
             channelId.value().value(),
             path.generic_string());
     });
@@ -141,7 +140,7 @@ void SftpFileEngine::createFile(std::filesystem::path const& path, std::function
 
         Log::info("Creating file: {}", path.generic_string());
         Nui::RpcClient::callWithBackChannel(
-            "SshSessionManager::sftp::createFile",
+            fmt::format("Session::{}::sftp::createFile", impl_->engine->sshSessionId().value()),
             [onComplete = std::move(onComplete)](Nui::val val) {
                 Nui::Console::log(val);
 
@@ -154,7 +153,6 @@ void SftpFileEngine::createFile(std::filesystem::path const& path, std::function
 
                 onComplete(true);
             },
-            impl_->engine->sshSessionId().value(),
             channelId.value().value(),
             path.generic_string());
     });
diff --git a/frontend/source/frontend/terminal/ssh_channel.cpp b/frontend/source/frontend/terminal/ssh_channel.cpp
index c7c5765a..670ad035 100644
--- a/frontend/source/frontend/terminal/ssh_channel.cpp
+++ b/frontend/source/frontend/terminal/ssh_channel.cpp
@@ -64,7 +64,7 @@ void SshChannel::open(
 void SshChannel::write(std::string const& data)
 {
     Nui::RpcClient::callWithBackChannel(
-        "SshSessionManager::Channel::write",
+        fmt::format("Session::{}::Channel::write", sshSessionId_.value()),
         [](Nui::val) {
             // TODO: handle error
         },
@@ -74,7 +74,7 @@ void SshChannel::write(std::string const& data)
 void SshChannel::resize(int cols, int rows)
 {
     Nui::RpcClient::callWithBackChannel(
-        "SshSessionManager::Channel::ptyResize",
+        fmt::format("Session::{}::Channel::ptyResize", sshSessionId_.value()),
         [](Nui::val) {
             // TODO: handle error
         },
@@ -85,7 +85,7 @@ void SshChannel::resize(int cols, int rows)
 void SshChannel::dispose(std::function<void()> onExit)
 {
     Nui::RpcClient::callWithBackChannel(
-        "SshSessionManager::Session::closeChannel",
+        fmt::format("Session::{}::Channel::close", sshSessionId_.value()),
         [onExit = std::move(onExit)](Nui::val) {
             onExit();
         },
diff --git a/frontend/source/frontend/terminal/ssh_engine.cpp b/frontend/source/frontend/terminal/ssh_engine.cpp
index 55806745..59310597 100644
--- a/frontend/source/frontend/terminal/ssh_engine.cpp
+++ b/frontend/source/frontend/terminal/ssh_engine.cpp
@@ -54,11 +54,11 @@ void SshTerminalEngine::open(std::function<void(bool, std::string const&)> onOpe
     obj.set("engine", asVal(impl_->settings.engineOptions));
 
     Nui::RpcClient::callWithBackChannel(
-        "SshSessionManager::connect",
+        "SessionManager::connect",
         [this, onOpen = std::move(onOpen)](Nui::val val) {
             if (!val.hasOwnProperty("id"))
             {
-                Log::error("SshSessionManager::connect callback did not return an id");
+                Log::error("SessionManager::connect callback did not return an id");
                 std::string error = "";
                 if (val.hasOwnProperty("error"))
                     error = val["error"].as<std::string>();
@@ -77,7 +77,7 @@ void SshTerminalEngine::disconnect(std::function<void()> onDisconnect, bool from
         impl_->wasDisposed = true;
         Log::info("Disconnecting session: {}", impl_->sshSessionId.value());
         Nui::RpcClient::callWithBackChannel(
-            "SshSessionManager::disconnect",
+            "SessionManager::disconnect",
             [onDisconnect = std::move(onDisconnect)](Nui::val) {
                 // TODO: handle error
                 onDisconnect();
@@ -115,11 +115,11 @@ void SshTerminalEngine::createChannelImpl(
 
     Nui::val obj = Nui::val::object();
     obj.set("engine", asVal(impl_->settings.engineOptions));
-    obj.set("sessionId", impl_->sshSessionId.value());
     obj.set("fileMode", fileMode);
 
+    Log::info("Creating {} channel for session '{}'", fileMode ? "sftp" : "pty", impl_->sshSessionId.value());
     Nui::RpcClient::callWithBackChannel(
-        "SshSessionManager::Session::createChannel",
+        fmt::format("Session::{}::Channel::create", impl_->sshSessionId.value()),
         [this,
          onCreated = std::move(onCreated),
          handler = std::move(handler),
@@ -134,7 +134,7 @@ void SshTerminalEngine::createChannelImpl(
 
             if (!val.hasOwnProperty("id"))
             {
-                Log::error("SshSessionManager::Session::createChannel callback did not return an id");
+                Log::error("Session::Channel::create callback did not return an id");
                 onCreated(std::nullopt);
                 return;
             }
@@ -157,7 +157,7 @@ void SshTerminalEngine::createChannelImpl(
             if (!fileMode)
             {
                 Nui::RpcClient::callWithBackChannel(
-                    "SshSessionManager::Channel::startReading",
+                    fmt::format("Session::{}::Channel::startReading", impl_->sshSessionId.value()),
                     [this, channelId, onCreated](Nui::val val) {
                         if (val.hasOwnProperty("error"))
                         {
@@ -169,7 +169,6 @@ void SshTerminalEngine::createChannelImpl(
                         Log::info("Started reading: {}", channelId.value());
                         onCreated(channelId);
                     },
-                    impl_->sshSessionId.value(),
                     channelId.value());
             }
             else
diff --git a/ids/include/ids/ids.hpp b/ids/include/ids/ids.hpp
index 7b1e18ee..59f8785b 100644
--- a/ids/include/ids/ids.hpp
+++ b/ids/include/ids/ids.hpp
@@ -7,4 +7,5 @@ DEFINE_ID_TYPE(SessionFrontendId)
 DEFINE_ID_TYPE(ChannelId)
 DEFINE_ID_TYPE(UiSessionId)
 DEFINE_ID_TYPE(FileId)
-DEFINE_ID_TYPE(OperationId)
\ No newline at end of file
+DEFINE_ID_TYPE(OperationId)
+DEFINE_ID_TYPE(OperationQueueId)
\ No newline at end of file
diff --git a/persistence/include/persistence/state/sftp_options.hpp b/persistence/include/persistence/state/sftp_options.hpp
index e9775c87..d697e68e 100644
--- a/persistence/include/persistence/state/sftp_options.hpp
+++ b/persistence/include/persistence/state/sftp_options.hpp
@@ -27,6 +27,7 @@ namespace Persistence
     {
         std::optional<TransferOptions> downloadOptions{};
         std::optional<TransferOptions> uploadOptions{};
+        std::optional<int> concurrency{std::nullopt}; // How many parallel transfers are allowed?
 
         void useDefaultsFrom(SftpOptions const& other);
     };
diff --git a/persistence/include/persistence/state/state.hpp b/persistence/include/persistence/state/state.hpp
index 7743ed91..d16ea980 100644
--- a/persistence/include/persistence/state/state.hpp
+++ b/persistence/include/persistence/state/state.hpp
@@ -21,6 +21,8 @@ namespace Persistence
         std::unordered_map<std::string, SshSessionOptions> sshSessionOptions{};
         UiOptions uiOptions{};
         Log::Level logLevel{Log::Level::Info};
+
+        State fullyResolve() const;
     };
 
     void to_json(nlohmann::json& j, State const& state);
diff --git a/persistence/source/persistence/state/sftp_options.cpp b/persistence/source/persistence/state/sftp_options.cpp
index 30f42004..21c74096 100644
--- a/persistence/source/persistence/state/sftp_options.cpp
+++ b/persistence/source/persistence/state/sftp_options.cpp
@@ -60,6 +60,8 @@ namespace Persistence
             j["downloadOptions"] = *options.downloadOptions;
         if (options.uploadOptions)
             j["uploadOptions"] = *options.uploadOptions;
+        if (options.concurrency)
+            j["concurrency"] = *options.concurrency;
     }
     void from_json(nlohmann::json const& j, SftpOptions& options)
     {
@@ -67,6 +69,8 @@ namespace Persistence
             options.downloadOptions = j["downloadOptions"].get<TransferOptions>();
         if (j.contains("uploadOptions"))
             options.uploadOptions = j["uploadOptions"].get<TransferOptions>();
+        if (j.contains("concurrency"))
+            options.concurrency = j["concurrency"].get<int>();
     }
     void SftpOptions::useDefaultsFrom(SftpOptions const& other)
     {
@@ -74,5 +78,7 @@ namespace Persistence
             downloadOptions = other.downloadOptions;
         if (!uploadOptions)
             uploadOptions = other.uploadOptions;
+        if (!concurrency)
+            concurrency = other.concurrency;
     }
 }
\ No newline at end of file
diff --git a/persistence/source/persistence/state/state.cpp b/persistence/source/persistence/state/state.cpp
index 0e23156e..c5733f2e 100644
--- a/persistence/source/persistence/state/state.cpp
+++ b/persistence/source/persistence/state/state.cpp
@@ -1,5 +1,6 @@
 #include <persistence/state/state.hpp>
 #include <nlohmann/json.hpp>
+#include <utility/visit_overloaded.hpp>
 
 #include <tuple>
 
@@ -46,4 +47,39 @@ namespace Persistence
         if (j.contains("logLevel"))
             state.logLevel = Log::levelFromString(j.at("logLevel").get<std::string>());
     }
+
+    State State::fullyResolve() const
+    {
+        State resolved{*this};
+
+        auto fillDefaults = [](auto& target, auto const& source) {
+            if (!target.hasReference())
+                return;
+
+            if (auto iter = source.find(target.ref()); iter != source.end())
+                target.useDefaultsFrom(iter->second);
+        };
+
+        for (auto& [key, session] : resolved.sessions)
+        {
+            fillDefaults(session.terminalOptions, resolved.terminalOptions);
+            fillDefaults(session.termios, resolved.termios);
+
+            Utility::visitOverloaded(
+                session.engine,
+                [&](std::monostate) {
+                    // Nothing to do here
+                },
+                [&](ExecutingTerminalEngine&) {
+                    // Nothing to do here
+                },
+                [&](SshTerminalEngine& engine) {
+                    fillDefaults(engine.sshSessionOptions, resolved.sshSessionOptions);
+                    fillDefaults(engine.sshSessionOptions->sshOptions, resolved.sshOptions);
+                    fillDefaults(engine.sshSessionOptions->sftpOptions, resolved.sftpOptions);
+                });
+        }
+
+        return resolved;
+    }
 }
\ No newline at end of file
diff --git a/ssh/test/ssh/utility/node.cpp b/ssh/test/ssh/utility/node.cpp
index e4b136d9..7f46254b 100644
--- a/ssh/test/ssh/utility/node.cpp
+++ b/ssh/test/ssh/utility/node.cpp
@@ -102,7 +102,7 @@ namespace SecureShell::Test
         const auto nodeExecutable = boost::process::v2::filesystem::path{std::string{node}};
 
         auto result = std::make_shared<NodeProcessResult>(
-            boost::asio::deadline_timer{executor, boost::posix_time::seconds{processKillTimer.count()}},
+            boost::asio::steady_timer{executor, processKillTimer},
             boost::asio::writable_pipe{executor},
             boost::asio::readable_pipe{executor},
             boost::asio::readable_pipe{executor},
diff --git a/ssh/test/ssh/utility/node.hpp b/ssh/test/ssh/utility/node.hpp
index dda85759..56aa3c4d 100644
--- a/ssh/test/ssh/utility/node.hpp
+++ b/ssh/test/ssh/utility/node.hpp
@@ -22,7 +22,7 @@ namespace SecureShell::Test
 
     struct NodeProcessResult
     {
-        boost::asio::deadline_timer timer;
+        boost::asio::steady_timer timer;
         boost::asio::writable_pipe stdinPipe;
         boost::asio::readable_pipe stdoutPipe;
         boost::asio::readable_pipe stderrPipe;

From af43e6189086262c635f95cbcfb982e1779ef9a3 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Tue, 7 Oct 2025 22:11:45 +0200
Subject: [PATCH 21/42] Added missing header.

---
 ssh/include/ssh/async/processing_thread.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ssh/include/ssh/async/processing_thread.hpp b/ssh/include/ssh/async/processing_thread.hpp
index 1f6ec767..f531fb9b 100644
--- a/ssh/include/ssh/async/processing_thread.hpp
+++ b/ssh/include/ssh/async/processing_thread.hpp
@@ -8,6 +8,7 @@
 #include <map>
 #include <future>
 #include <memory>
+#include <vector>
 
 namespace SecureShell
 {

From 40a59557da69fab6e425e2f224f94dfb327b54ec Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Fri, 10 Oct 2025 16:31:10 +0200
Subject: [PATCH 22/42] Added timer function to rpc helper.

---
 backend/include/backend/rpc_helper.hpp | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/backend/include/backend/rpc_helper.hpp b/backend/include/backend/rpc_helper.hpp
index 3729751b..095a84fc 100644
--- a/backend/include/backend/rpc_helper.hpp
+++ b/backend/include/backend/rpc_helper.hpp
@@ -6,6 +6,7 @@
 #include <log/log.hpp>
 #include <boost/asio/strand.hpp>
 #include <boost/asio/any_io_executor.hpp>
+#include <boost/asio/steady_timer.hpp>
 #include <traits/functions.hpp>
 #include <mplex/tuple/pop_front.hpp>
 
@@ -13,6 +14,7 @@
 #include <concepts>
 #include <ranges>
 #include <memory>
+#include <chrono>
 
 // TODO: split and document this file!
 namespace RpcHelper
@@ -202,6 +204,7 @@ namespace RpcHelper
             , strand_{std::make_shared<boost::asio::strand<boost::asio::any_io_executor>>(executor_)}
             , wnd_{&wnd}
             , hub_{&hub}
+            , timer_{executor_}
         {}
 
         StrandRpc(
@@ -213,6 +216,7 @@ namespace RpcHelper
             , strand_{std::move(strand)}
             , wnd_{&wnd}
             , hub_{&hub}
+            , timer_{executor_}
         {}
 
         virtual ~StrandRpc() = default;
@@ -283,11 +287,31 @@ namespace RpcHelper
             func();
         }
 
+        void within_strand_do_no_recurse(auto&& func) const
+        {
+            return strand_->execute(std::forward<decltype(func)>(func));
+        }
+
+        void within_strand_do_delayed(auto&& func, std::chrono::steady_clock::duration delay)
+        {
+            timer_.expires_after(delay);
+            timer_.async_wait([func = std::forward<decltype(func)>(func)](auto const& ec) {
+                if (ec)
+                {
+                    Log::info("Timer canceled in within_strand_do_delayed: {}", ec.message());
+                    return;
+                }
+
+                func();
+            });
+        }
+
       protected:
         boost::asio::any_io_executor executor_{};
         std::shared_ptr<boost::asio::strand<boost::asio::any_io_executor>> strand_;
         Nui::Window* wnd_;
         Nui::RpcHub* hub_;
         std::vector<Nui::RpcHub::AutoUnregister> registeredFunctions_{};
+        boost::asio::steady_timer timer_;
     };
 }
\ No newline at end of file

From 6a0c53539fc9ce00703972cc30064dcd099c7f66 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Fri, 10 Oct 2025 16:31:24 +0200
Subject: [PATCH 23/42] Added strand getter.

---
 ssh/include/ssh/sftp_session.hpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/ssh/include/ssh/sftp_session.hpp b/ssh/include/ssh/sftp_session.hpp
index 3a5a2343..bf1116ec 100644
--- a/ssh/include/ssh/sftp_session.hpp
+++ b/ssh/include/ssh/sftp_session.hpp
@@ -164,6 +164,11 @@ namespace SecureShell
 
         std::future<std::expected<sftp_limits_struct, Error>> limits();
 
+        ProcessingStrand* strand() const
+        {
+            return strand_.get();
+        }
+
       private:
         void fileStreamRemoveItself(FileStream* stream, bool isBackElement);
         void removeAllFileStreams();

From 0adc4e723e50ede265151dea8b405b4e60be5532 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Fri, 10 Oct 2025 16:32:12 +0200
Subject: [PATCH 24/42] Moved and added classes to shared data.

---
 .../include/backend/sftp/operation_type.hpp   |  7 ---
 .../file_operations/operation_added.hpp       | 26 ++++++++++
 .../file_operations/operation_type.hpp        | 24 ++++++++++
 .../include/shared_data/shared_data.hpp       |  8 ++++
 shared_data/source/shared_data/CMakeLists.txt | 16 ++++++-
 .../file_operations/operation_added.cpp       | 17 +++++++
 .../file_operations/operation_added_val.cpp   | 21 +++++++++
 .../file_operations/operation_type.cpp        | 43 +++++++++++++++++
 .../file_operations/operation_type_val.cpp    | 47 +++++++++++++++++++
 9 files changed, 201 insertions(+), 8 deletions(-)
 delete mode 100644 backend/include/backend/sftp/operation_type.hpp
 create mode 100644 shared_data/include/shared_data/file_operations/operation_added.hpp
 create mode 100644 shared_data/include/shared_data/file_operations/operation_type.hpp
 create mode 100644 shared_data/include/shared_data/shared_data.hpp
 create mode 100644 shared_data/source/shared_data/file_operations/operation_added.cpp
 create mode 100644 shared_data/source/shared_data/file_operations/operation_added_val.cpp
 create mode 100644 shared_data/source/shared_data/file_operations/operation_type.cpp
 create mode 100644 shared_data/source/shared_data/file_operations/operation_type_val.cpp

diff --git a/backend/include/backend/sftp/operation_type.hpp b/backend/include/backend/sftp/operation_type.hpp
deleted file mode 100644
index 68b1d196..00000000
--- a/backend/include/backend/sftp/operation_type.hpp
+++ /dev/null
@@ -1,7 +0,0 @@
-#pragma once
-
-enum class OperationType
-{
-    Download,
-    Upload
-};
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/operation_added.hpp b/shared_data/include/shared_data/file_operations/operation_added.hpp
new file mode 100644
index 00000000..f70818c0
--- /dev/null
+++ b/shared_data/include/shared_data/file_operations/operation_added.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <ids/ids.hpp>
+#include <shared_data/file_operations/operation_type.hpp>
+
+#include <nlohmann/json.hpp>
+
+#include <filesystem>
+#include <string>
+
+namespace SharedData
+{
+    struct OperationAdded
+    {
+        Ids::OperationId operationId;
+        OperationType type;
+    };
+
+    void to_json(nlohmann::json& j, OperationAdded const& operationAdded);
+    void from_json(nlohmann::json const& j, OperationAdded& operationAdded);
+
+#ifdef NUI_FRONTEND
+    void to_val(Nui::val& v, OperationAdded const& operationAdded);
+    void from_val(Nui::val const& v, OperationAdded& operationAdded);
+#endif
+}
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/operation_type.hpp b/shared_data/include/shared_data/file_operations/operation_type.hpp
new file mode 100644
index 00000000..3050ddcb
--- /dev/null
+++ b/shared_data/include/shared_data/file_operations/operation_type.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <shared_data/shared_data.hpp>
+
+namespace SharedData
+{
+    enum class OperationType
+    {
+        Scan,
+        Download,
+        BulkDownload,
+        Upload,
+        Rename,
+        Delete
+    };
+
+    void to_json(nlohmann::json& j, OperationType const& operationType);
+    void from_json(nlohmann::json const& j, OperationType& operationType);
+
+#ifdef NUI_FRONTEND
+    void to_val(Nui::val& v, OperationType const& operationType);
+    void from_val(Nui::val const& v, OperationType& operationType);
+#endif
+}
\ No newline at end of file
diff --git a/shared_data/include/shared_data/shared_data.hpp b/shared_data/include/shared_data/shared_data.hpp
new file mode 100644
index 00000000..29bd1b23
--- /dev/null
+++ b/shared_data/include/shared_data/shared_data.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+#include <nui/core.hpp>
+#include <nlohmann/json.hpp>
+
+#ifdef NUI_FRONTEND
+#    include <nui/frontend/val.hpp>
+#endif
\ No newline at end of file
diff --git a/shared_data/source/shared_data/CMakeLists.txt b/shared_data/source/shared_data/CMakeLists.txt
index a321c9c4..868b75f5 100644
--- a/shared_data/source/shared_data/CMakeLists.txt
+++ b/shared_data/source/shared_data/CMakeLists.txt
@@ -2,8 +2,22 @@ add_library(
     shared_data
     STATIC
         directory_entry.cpp
+        file_operations/operation_type.cpp
+        file_operations/operation_added.cpp
 )
 
 target_include_directories(shared_data PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/../../include")
 
-target_link_libraries(shared_data PUBLIC utility)
\ No newline at end of file
+target_link_libraries(shared_data PUBLIC utility ids)
+
+if (EMSCRIPTEN)
+    target_link_libraries(shared_data PUBLIC nui-frontend)
+    target_sources(
+        shared_data
+        PRIVATE
+            file_operations/operation_type_val.cpp
+            file_operations/operation_added_val.cpp
+    )
+else()
+    target_link_libraries(shared_data PUBLIC nui-backend)
+endif()
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_added.cpp b/shared_data/source/shared_data/file_operations/operation_added.cpp
new file mode 100644
index 00000000..79dc7dc9
--- /dev/null
+++ b/shared_data/source/shared_data/file_operations/operation_added.cpp
@@ -0,0 +1,17 @@
+#include <shared_data/file_operations/operation_added.hpp>
+
+namespace SharedData
+{
+    void to_json(nlohmann::json& j, OperationAdded const& operationAdded)
+    {
+        j = nlohmann::json{
+            {"operationId", operationAdded.operationId},
+            {"type", operationAdded.type},
+        };
+    }
+    void from_json(nlohmann::json const& j, OperationAdded& operationAdded)
+    {
+        j.at("operationId").get_to(operationAdded.operationId);
+        j.at("type").get_to(operationAdded.type);
+    }
+}
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_added_val.cpp b/shared_data/source/shared_data/file_operations/operation_added_val.cpp
new file mode 100644
index 00000000..946cabcd
--- /dev/null
+++ b/shared_data/source/shared_data/file_operations/operation_added_val.cpp
@@ -0,0 +1,21 @@
+#include <shared_data/file_operations/operation_added.hpp>
+
+namespace SharedData
+{
+    void to_val(Nui::val& v, OperationAdded const& operationAdded)
+    {
+        v = Nui::val::object();
+        Nui::val operationIdVal;
+        to_val(operationIdVal, operationAdded.operationId);
+        v.set("operationId", operationIdVal);
+
+        Nui::val typeVal;
+        to_val(typeVal, operationAdded.type);
+        v.set("type", typeVal);
+    }
+    void from_val(Nui::val const& v, OperationAdded& operationAdded)
+    {
+        from_val(v["operationId"], operationAdded.operationId);
+        from_val(v["type"], operationAdded.type);
+    }
+}
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_type.cpp b/shared_data/source/shared_data/file_operations/operation_type.cpp
new file mode 100644
index 00000000..11e5720e
--- /dev/null
+++ b/shared_data/source/shared_data/file_operations/operation_type.cpp
@@ -0,0 +1,43 @@
+#include <shared_data/file_operations/operation_type.hpp>
+
+namespace SharedData
+{
+    void to_json(nlohmann::json& j, OperationType const& operationType)
+    {
+        switch (operationType)
+        {
+            case OperationType::Download:
+                j = "Download";
+                break;
+            case OperationType::Upload:
+                j = "Upload";
+                break;
+            case OperationType::Rename:
+                j = "Rename";
+                break;
+            case OperationType::Delete:
+                j = "Delete";
+                break;
+            case OperationType::Scan:
+                j = "Scan";
+                break;
+            case OperationType::BulkDownload:
+                j = "BulkDownload";
+                break;
+        }
+    }
+    void from_json(nlohmann::json const& j, OperationType& operationType)
+    {
+        auto const& str = j.get<std::string>();
+        if (str == "Download")
+            operationType = OperationType::Download;
+        else if (str == "Upload")
+            operationType = OperationType::Upload;
+        else if (str == "Rename")
+            operationType = OperationType::Rename;
+        else if (str == "Delete")
+            operationType = OperationType::Delete;
+        else
+            throw std::runtime_error("Invalid OperationType string: " + str);
+    }
+}
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_type_val.cpp b/shared_data/source/shared_data/file_operations/operation_type_val.cpp
new file mode 100644
index 00000000..57992b3b
--- /dev/null
+++ b/shared_data/source/shared_data/file_operations/operation_type_val.cpp
@@ -0,0 +1,47 @@
+#include <shared_data/file_operations/operation_type.hpp>
+
+namespace SharedData
+{
+    void to_val(Nui::val& v, OperationType const& operationType)
+    {
+        switch (operationType)
+        {
+            case OperationType::Download:
+                v = Nui::val::u8string("Download");
+                break;
+            case OperationType::Upload:
+                v = Nui::val::u8string("Upload");
+                break;
+            case OperationType::Rename:
+                v = Nui::val::u8string("Rename");
+                break;
+            case OperationType::Delete:
+                v = Nui::val::u8string("Delete");
+                break;
+            case OperationType::Scan:
+                v = Nui::val::u8string("Scan");
+                break;
+            case OperationType::BulkDownload:
+                v = Nui::val::u8string("BulkDownload");
+                break;
+        }
+    }
+    void from_val(Nui::val const& v, OperationType& operationType)
+    {
+        auto const str = v.template as<std::string>();
+        if (str == "Download")
+            operationType = OperationType::Download;
+        else if (str == "Upload")
+            operationType = OperationType::Upload;
+        else if (str == "Rename")
+            operationType = OperationType::Rename;
+        else if (str == "Delete")
+            operationType = OperationType::Delete;
+        else if (str == "Scan")
+            operationType = OperationType::Scan;
+        else if (str == "BulkDownload")
+            operationType = OperationType::BulkDownload;
+        else
+            throw std::runtime_error("Invalid OperationType string: " + str);
+    }
+}
\ No newline at end of file

From e2c45d10af76b1b55fceab0e5b301e4c63e72684 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Fri, 10 Oct 2025 16:32:36 +0200
Subject: [PATCH 25/42] Added legible type checker to directory entry.

---
 .../include/shared_data/directory_entry.hpp   | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/shared_data/include/shared_data/directory_entry.hpp b/shared_data/include/shared_data/directory_entry.hpp
index 63d68bac..775a9537 100644
--- a/shared_data/include/shared_data/directory_entry.hpp
+++ b/shared_data/include/shared_data/directory_entry.hpp
@@ -37,6 +37,43 @@ namespace SharedData
         std::uint64_t mtime = 0;
         std::uint32_t mtimeNsec = 0;
         std::string acl = "";
+
+        bool isDirectory() const
+        {
+            return type == 2;
+        }
+        bool isRegularFile() const
+        {
+            return type == 1;
+        }
+        bool isSymlink() const
+        {
+            return type == 3;
+        }
+        bool isSpecial() const
+        {
+            return type == 4;
+        }
+        bool isUnknown() const
+        {
+            return type == 5;
+        }
+        bool isSocket() const
+        {
+            return type == 6;
+        }
+        bool isCharDevice() const
+        {
+            return type == 7;
+        }
+        bool isBlockDevice() const
+        {
+            return type == 8;
+        }
+        bool isFifo() const
+        {
+            return type == 9;
+        }
     };
 
     void to_json(nlohmann::json& j, DirectoryEntry const& entry);

From acc19df27b95f696f505a2419a08fe3fa8ae5cef Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Fri, 10 Oct 2025 16:32:55 +0200
Subject: [PATCH 26/42] Added timeout to sftp options.

---
 persistence/include/persistence/state/sftp_options.hpp | 1 +
 persistence/source/persistence/state/sftp_options.cpp  | 6 ++++++
 2 files changed, 7 insertions(+)

diff --git a/persistence/include/persistence/state/sftp_options.hpp b/persistence/include/persistence/state/sftp_options.hpp
index d697e68e..ff6070c1 100644
--- a/persistence/include/persistence/state/sftp_options.hpp
+++ b/persistence/include/persistence/state/sftp_options.hpp
@@ -28,6 +28,7 @@ namespace Persistence
         std::optional<TransferOptions> downloadOptions{};
         std::optional<TransferOptions> uploadOptions{};
         std::optional<int> concurrency{std::nullopt}; // How many parallel transfers are allowed?
+        std::chrono::seconds operationTimeout{5};
 
         void useDefaultsFrom(SftpOptions const& other);
     };
diff --git a/persistence/source/persistence/state/sftp_options.cpp b/persistence/source/persistence/state/sftp_options.cpp
index 21c74096..fb9cd213 100644
--- a/persistence/source/persistence/state/sftp_options.cpp
+++ b/persistence/source/persistence/state/sftp_options.cpp
@@ -62,6 +62,7 @@ namespace Persistence
             j["uploadOptions"] = *options.uploadOptions;
         if (options.concurrency)
             j["concurrency"] = *options.concurrency;
+        j["operationTimeout"] = options.operationTimeout.count();
     }
     void from_json(nlohmann::json const& j, SftpOptions& options)
     {
@@ -71,6 +72,11 @@ namespace Persistence
             options.uploadOptions = j["uploadOptions"].get<TransferOptions>();
         if (j.contains("concurrency"))
             options.concurrency = j["concurrency"].get<int>();
+
+        if (j.contains("operationTimeout"))
+            options.operationTimeout = std::chrono::seconds{j["operationTimeout"].get<int>()};
+        else
+            options.operationTimeout = SftpOptions{}.operationTimeout;
     }
     void SftpOptions::useDefaultsFrom(SftpOptions const& other)
     {

From 7be2e5f7d6a58900e6afececbe73bd192197642d Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Fri, 10 Oct 2025 16:33:06 +0200
Subject: [PATCH 27/42] Removed unused id.

---
 ids/include/ids/ids.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/ids/include/ids/ids.hpp b/ids/include/ids/ids.hpp
index 59f8785b..7b1e18ee 100644
--- a/ids/include/ids/ids.hpp
+++ b/ids/include/ids/ids.hpp
@@ -7,5 +7,4 @@ DEFINE_ID_TYPE(SessionFrontendId)
 DEFINE_ID_TYPE(ChannelId)
 DEFINE_ID_TYPE(UiSessionId)
 DEFINE_ID_TYPE(FileId)
-DEFINE_ID_TYPE(OperationId)
-DEFINE_ID_TYPE(OperationQueueId)
\ No newline at end of file
+DEFINE_ID_TYPE(OperationId)
\ No newline at end of file

From 6c804a12afca9926df124a343a6a727bfafbdb9a Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Fri, 10 Oct 2025 16:33:22 +0200
Subject: [PATCH 28/42] Made ids json convertible.

---
 ids/include/ids/id.hpp | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/ids/include/ids/id.hpp b/ids/include/ids/id.hpp
index d266996e..b05b55a1 100644
--- a/ids/include/ids/id.hpp
+++ b/ids/include/ids/id.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+#include <nlohmann/json.hpp>
 
 #ifdef __EMSCRIPTEN__
 #    include <nui/frontend/val.hpp>
@@ -82,6 +83,20 @@ namespace Ids
 #endif
 }
 
+#ifdef __EMSCRIPTEN__
+#    define VAL_CONVERTER(name) \
+        inline void to_val(Nui::val& v, name const& id) \
+        { \
+            v = Nui::val::u8string(id.value().c_str()); \
+        } \
+        inline void from_val(Nui::val const& v, name& id) \
+        { \
+            id = make##name(v.template as<std::string>()); \
+        }
+#else
+#    define VAL_CONVERTER(name)
+#endif
+
 #define DEFINE_ID_TYPE(name) \
     namespace Ids \
     { \
@@ -114,4 +129,13 @@ namespace Ids
         { \
             return name{str}; \
         } \
+        inline void to_json(nlohmann::json& j, name const& id) \
+        { \
+            j = id.value(); \
+        } \
+        inline void from_json(nlohmann::json const& j, name& id) \
+        { \
+            id = make##name(j.get<std::string>()); \
+        } \
+        VAL_CONVERTER(name) \
     }
\ No newline at end of file

From 414db4bb699bf704652bac81ce5ea4c707da381c Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Fri, 10 Oct 2025 16:33:33 +0200
Subject: [PATCH 29/42] Added missing virtual.

---
 frontend/source/frontend/terminal/terminal.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/frontend/source/frontend/terminal/terminal.cpp b/frontend/source/frontend/terminal/terminal.cpp
index ee9464d5..a4c669d6 100644
--- a/frontend/source/frontend/terminal/terminal.cpp
+++ b/frontend/source/frontend/terminal/terminal.cpp
@@ -189,7 +189,7 @@ struct GenericTerminalChannel
         };
     }
 
-    ~GenericTerminalChannel() = default;
+    virtual ~GenericTerminalChannel() = default;
 };
 
 struct TerminalChannel::Implementation : public GenericTerminalChannel

From 23f622cfb6f8d6c1b89f81687b2d025ce304570f Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Fri, 10 Oct 2025 16:34:16 +0200
Subject: [PATCH 30/42] Added thread uml for bulk download.

---
 diagrams/bulk_download.puml | 38 +++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 diagrams/bulk_download.puml

diff --git a/diagrams/bulk_download.puml b/diagrams/bulk_download.puml
new file mode 100644
index 00000000..14753994
--- /dev/null
+++ b/diagrams/bulk_download.puml
@@ -0,0 +1,38 @@
+@startuml
+participant "UI Thread"
+participant "Session Strand"
+participant "SSH Thread"
+
+"UI Thread" -> "Session Strand" : start download on directory
+activate "Session Strand"
+"Session Strand" -> "SSH Thread" : stat remote path
+activate "Session Strand" #orange
+"Session Strand" -> "Session Strand" : blocking wait
+"SSH Thread" -> "Session Strand" : stat result
+deactivate "Session Strand"
+"Session Strand" -> "Session Strand" : process stat result (here: directory)
+"Session Strand" -> "Session Strand" : create scan operation
+group Scan Operation
+    loop work loop on strand
+        "Session Strand" -> "SSH Thread": list directory (current)
+        activate "Session Strand" #orange
+        "Session Strand" -> "Session Strand": blocking wait
+        "SSH Thread" -> "Session Strand": list directory result
+        deactivate "Session Strand"
+        "Session Strand" -> "Session Strand": process list result
+        "Session Strand" -> "UI Thread": progress update
+    end
+end
+group Bulk Download Operation
+    loop work loop
+        "Session Strand" -> "SSH Thread": download some bytes
+        activate "Session Strand" #orange
+        "Session Strand" -> "Session Strand": blocking wait
+        "SSH Thread" -> "Session Strand": download result
+        deactivate "Session Strand"
+        "Session Strand" -> "Session Strand": process download result
+        "Session Strand" -> "UI Thread": progress update
+    end
+end
+deactivate "Session Strand"
+@enduml
\ No newline at end of file

From 9cc105f7ad7246fd55750833b4913ace930fc3db Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Fri, 10 Oct 2025 16:34:41 +0200
Subject: [PATCH 31/42] Added virtual dtor to TerminalChannel class.

---
 frontend/include/frontend/terminal/terminal.hpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/frontend/include/frontend/terminal/terminal.hpp b/frontend/include/frontend/terminal/terminal.hpp
index 4c4c476c..8e9742f7 100644
--- a/frontend/include/frontend/terminal/terminal.hpp
+++ b/frontend/include/frontend/terminal/terminal.hpp
@@ -11,7 +11,11 @@ class TerminalChannel
 {
   public:
     TerminalChannel(MultiChannelTerminalEngine* engine, Ids::ChannelId channelId);
-    ROAR_PIMPL_SPECIAL_FUNCTIONS(TerminalChannel);
+    virtual ~TerminalChannel();
+    TerminalChannel(TerminalChannel const&) = delete;
+    TerminalChannel(TerminalChannel&&);
+    TerminalChannel& operator=(TerminalChannel const&) = delete;
+    TerminalChannel& operator=(TerminalChannel&&);
 
     void open(
         Nui::val host,

From 98791315d9c0d6ce21d90a733e08074f7d4c4600 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Fri, 10 Oct 2025 18:32:32 +0200
Subject: [PATCH 32/42] Made progress on downloading.

---
 CMakeLists.txt                                |   1 +
 _cmake/common_options.cmake                   |  10 +-
 backend/include/backend/session.hpp           |  20 +-
 backend/include/backend/session_manager.hpp   |   2 +-
 .../include/backend/sftp/all_operations.hpp   |  12 +-
 .../backend/sftp/bulk_download_operation.hpp  |  65 ++++
 .../backend/sftp/download_operation.hpp       |  20 +-
 backend/include/backend/sftp/operation.hpp    |  36 ++-
 .../include/backend/sftp/operation_queue.hpp  |  31 +-
 .../include/backend/sftp/scan_operation.hpp   |  68 ++++
 backend/source/backend/CMakeLists.txt         |   2 +
 backend/source/backend/session.cpp            | 293 +++++++++++-------
 backend/source/backend/session_manager.cpp    |  54 +---
 .../backend/sftp/bulk_download_operation.cpp  |  49 +++
 .../backend/sftp/download_operation.cpp       |  17 +-
 .../source/backend/sftp/operation_queue.cpp   | 185 ++++++++---
 .../source/backend/sftp/scan_operation.cpp    | 123 ++++++++
 events/source/events/CMakeLists.txt           |  13 +-
 .../session_components/operation_queue.hpp    |  28 +-
 .../frontend/terminal/channel_interface.hpp   |   2 +-
 .../include/frontend/terminal/file_engine.hpp |   7 +-
 .../frontend/terminal/sftp_file_engine.hpp    |   5 +
 frontend/source/frontend/CMakeLists.txt       |  24 ++
 frontend/source/frontend/session.cpp          |  23 +-
 .../session_components/operation_queue.cpp    |  98 ++++--
 .../frontend/terminal/sftp_file_engine.cpp    |  42 +++
 log/source/log/CMakeLists.txt                 |   6 +
 .../source/nui-file-explorer/CMakeLists.txt   |   9 +-
 28 files changed, 970 insertions(+), 275 deletions(-)
 create mode 100644 backend/include/backend/sftp/bulk_download_operation.hpp
 create mode 100644 backend/include/backend/sftp/scan_operation.hpp
 create mode 100644 backend/source/backend/sftp/bulk_download_operation.cpp
 create mode 100644 backend/source/backend/sftp/scan_operation.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4e7f68e4..18bd658c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -6,6 +6,7 @@ set(NUI_FETCH_ROAR OFF CACHE BOOL "Dont fetch roar, use local copy" FORCE)
 set(NUI_FETCH_NLOHMANN_JSON OFF CACHE BOOL "Dont fetch nlohmann, use local copy" FORCE)
 set(ROAR_EXTERNAL_NLOHMANN_JSON ON CACHE BOOL "Use an external nlohmann_json library (provide it manually)" FORCE)
 set(SPDLOG_BUILD_SHARED OFF CACHE BOOL "Dont build shared spdlog" FORCE)
+set(NUI_FILE_EXPLORER_MEMORY64 ON CACHE BOOL "Enable MEMORY64 for nui-file-explorer" FORCE)
 
 option(BUILD_SHARED_LIBS "Do not build shared libraries" OFF)
 option(BUILD_STATIC_LIBS "Build static libraries" ON)
diff --git a/_cmake/common_options.cmake b/_cmake/common_options.cmake
index a036205e..5ab709ea 100644
--- a/_cmake/common_options.cmake
+++ b/_cmake/common_options.cmake
@@ -5,6 +5,12 @@ if (${MSVC})
 else()
     target_compile_options(core-target INTERFACE -Wall -Wextra -Wpedantic)
 endif()
-target_compile_options(core-target INTERFACE -Wbad-function-cast -Wcast-function-type -fexceptions -pedantic $<$<CONFIG:DEBUG>:-g;-Werror=return-type> $<$<CONFIG:RELEASE>:-O3>)
-target_link_options(core-target INTERFACE $<$<CONFIG:RELEASE>:-s;-static-libgcc;-static-libstdc++>)
+
+set(MEM64 "")
+if (EMSCRIPTEN)
+    set(MEM64 "-sMEMORY64=1")
+endif()
+
+target_compile_options(core-target INTERFACE -Wbad-function-cast -Wcast-function-type -fexceptions -pedantic $<$<CONFIG:DEBUG>:-g;-Werror=return-type> $<$<CONFIG:RELEASE>:-O3> ${MEM64})
+target_link_options(core-target INTERFACE $<$<CONFIG:RELEASE>:-s;-static-libgcc;-static-libstdc++> ${MEM64})
 target_compile_features(core-target INTERFACE cxx_std_23)
\ No newline at end of file
diff --git a/backend/include/backend/session.hpp b/backend/include/backend/session.hpp
index f4206181..b8ffd073 100644
--- a/backend/include/backend/session.hpp
+++ b/backend/include/backend/session.hpp
@@ -9,6 +9,7 @@
 
 #include <unordered_map>
 #include <memory>
+#include <atomic>
 #include <optional>
 
 /**
@@ -17,7 +18,9 @@
  *
  * These sessions are managed by SessionManager. Each session has an id, as well as ssh channels, sftp channels and
  */
-class Session : public RpcHelper::StrandRpc
+class Session
+    : public RpcHelper::StrandRpc
+    , public std::enable_shared_from_this<Session>
 {
   public:
     constexpr static auto futureTimeout = std::chrono::seconds{10};
@@ -33,11 +36,12 @@ class Session : public RpcHelper::StrandRpc
 
     Session(const Session&) = delete;
     Session& operator=(const Session&) = delete;
-    Session(Session&&) = default;
-    Session& operator=(Session&&) = default;
+    Session(Session&&) = delete;
+    Session& operator=(Session&&) = delete;
     ~Session() = default;
 
     void start();
+    void stop();
 
   private:
     /**
@@ -132,7 +136,7 @@ class Session : public RpcHelper::StrandRpc
             {
                 if (auto channel = iter->second.lock(); channel)
                 {
-                    func(std::move(reply), channel);
+                    func(std::move(reply), std::move(channel));
                 }
                 else
                 {
@@ -160,7 +164,7 @@ class Session : public RpcHelper::StrandRpc
             {
                 if (auto channel = iter->second.lock(); channel)
                 {
-                    func(std::move(reply), channel);
+                    func(std::move(reply), std::move(channel));
                 }
                 else
                 {
@@ -177,10 +181,14 @@ class Session : public RpcHelper::StrandRpc
         });
     }
 
+    void doOperationQueueWork();
+
   private:
     Ids::SessionId id_;
+    std::atomic_bool running_;
+    std::chrono::milliseconds operationThrottle_{5};
     std::unique_ptr<SecureShell::Session> session_{};
     std::unordered_map<Ids::ChannelId, std::weak_ptr<SecureShell::Channel>, Ids::IdHash> channels_{};
     std::unordered_map<Ids::ChannelId, std::weak_ptr<SecureShell::SftpSession>, Ids::IdHash> sftpChannels_{};
-    std::unique_ptr<OperationQueue> operationQueue_;
+    std::shared_ptr<OperationQueue> operationQueue_;
 };
\ No newline at end of file
diff --git a/backend/include/backend/session_manager.hpp b/backend/include/backend/session_manager.hpp
index 6037766e..e85f1051 100644
--- a/backend/include/backend/session_manager.hpp
+++ b/backend/include/backend/session_manager.hpp
@@ -71,7 +71,7 @@ class SessionManager
 
   private:
     Persistence::StateHolder* stateHolder_{};
-    std::unordered_map<Ids::SessionId, Session, Ids::IdHash> sessions_{};
+    std::unordered_map<Ids::SessionId, std::shared_ptr<Session>, Ids::IdHash> sessions_{};
 
     std::map<int, PasswordProvider*> passwordProviders_{};
     std::unique_ptr<std::thread> addSessionThread_{};
diff --git a/backend/include/backend/sftp/all_operations.hpp b/backend/include/backend/sftp/all_operations.hpp
index 9552b549..c0a48093 100644
--- a/backend/include/backend/sftp/all_operations.hpp
+++ b/backend/include/backend/sftp/all_operations.hpp
@@ -1,16 +1,26 @@
 #include <backend/sftp/operation.hpp>
 #include <backend/sftp/download_operation.hpp>
+#include <backend/sftp/scan_operation.hpp>
+#include <backend/sftp/bulk_download_operation.hpp>
 
 template <typename FunctionT>
 auto Operation::visit(FunctionT&& func) const
 {
-    using enum OperationType;
+    using enum SharedData::OperationType;
     switch (type())
     {
         case Download:
         {
             return func(static_cast<DownloadOperation const&>(*this));
         }
+        case Scan:
+        {
+            return func(static_cast<ScanOperation const&>(*this));
+        }
+        case BulkDownload:
+        {
+            return func(static_cast<BulkDownloadOperation const&>(*this));
+        }
         default:
         {
             Log::error("Operation: Unknown operation type: {}", static_cast<int>(type()));
diff --git a/backend/include/backend/sftp/bulk_download_operation.hpp b/backend/include/backend/sftp/bulk_download_operation.hpp
new file mode 100644
index 00000000..a4e76af6
--- /dev/null
+++ b/backend/include/backend/sftp/bulk_download_operation.hpp
@@ -0,0 +1,65 @@
+#pragma once
+
+#include <backend/sftp/operation.hpp>
+#include <ssh/file_stream.hpp>
+#include <nui/utility/move_detector.hpp>
+#include <backend/sftp/download_operation.hpp>
+
+#include <filesystem>
+#include <fstream>
+#include <string>
+
+// TODO: concurrent downloads!
+class BulkDownloadOperation : public Operation
+{
+  public:
+    struct BulkDownloadOperationOptions
+    {
+        std::function<void(
+            std::filesystem::path const& currentFile,
+            std::uint64_t fileCurrentIndex,
+            std::uint64_t fileCount,
+            std::uint64_t bytesCurrent,
+            std::uint64_t bytesTotal)>
+            overallProgressCallback = [](auto const&, auto, auto, auto, auto) {};
+
+        // TODO: as tar, do compress tar?
+        DownloadOperation::DownloadOperationOptions individualOptions = {};
+    };
+
+    BulkDownloadOperation(SecureShell::SftpSession& sftp, BulkDownloadOperationOptions options);
+    ~BulkDownloadOperation() override;
+    BulkDownloadOperation(BulkDownloadOperation const&) = delete;
+    BulkDownloadOperation(BulkDownloadOperation&&) = delete;
+    BulkDownloadOperation& operator=(BulkDownloadOperation const&) = delete;
+    BulkDownloadOperation& operator=(BulkDownloadOperation&&) = delete;
+
+    std::expected<WorkStatus, Error> work() override;
+    SharedData::OperationType type() const override;
+    std::expected<void, Error> cancel(bool adoptCancelState) override;
+
+    void setScanResult(std::vector<SharedData::DirectoryEntry>&& entries);
+
+    bool isBarrier() const noexcept override
+    {
+        return false;
+    }
+
+    // TODO: can do more than 1.
+    int parallelWorkDoable(int) const noexcept override
+    {
+        return 1;
+    }
+
+    SecureShell::ProcessingStrand* strand() const override;
+
+  private:
+    SecureShell::SftpSession* sftp_;
+    BulkDownloadOperationOptions options_;
+    std::unique_ptr<DownloadOperation> currentDownload_;
+    std::vector<SharedData::DirectoryEntry> entries_;
+    std::uint64_t totalBytes_{0};
+    std::uint64_t currentIndex_{0};
+    std::uint64_t currentBytes_{0};
+    std::chrono::seconds futureTimeout_{5};
+};
\ No newline at end of file
diff --git a/backend/include/backend/sftp/download_operation.hpp b/backend/include/backend/sftp/download_operation.hpp
index b0792ecd..9479e2c0 100644
--- a/backend/include/backend/sftp/download_operation.hpp
+++ b/backend/include/backend/sftp/download_operation.hpp
@@ -43,9 +43,25 @@ class DownloadOperation : public Operation
 
     std::expected<WorkStatus, Error> work() override;
 
-    OperationType type() const override
+    bool isBarrier() const noexcept override
     {
-        return OperationType::Download;
+        return false;
+    }
+
+    /**
+     * @brief How much parallel work does this operation do.
+     *
+     * @param parallel Maximum parallelism allowed.
+     * @return The amount of parallel work that can be done maxed by parallel parameter.
+     */
+    int parallelWorkDoable(int) const noexcept override
+    {
+        return 1;
+    }
+
+    SharedData::OperationType type() const override
+    {
+        return SharedData::OperationType::Download;
     }
 
     std::filesystem::path remotePath() const
diff --git a/backend/include/backend/sftp/operation.hpp b/backend/include/backend/sftp/operation.hpp
index 8966edb7..f339359b 100644
--- a/backend/include/backend/sftp/operation.hpp
+++ b/backend/include/backend/sftp/operation.hpp
@@ -2,7 +2,7 @@
 
 #include <ssh/sftp_error.hpp>
 #include <utility/describe.hpp>
-#include <backend/sftp/operation_type.hpp>
+#include <shared_data/file_operations/operation_type.hpp>
 #include <ssh/async/processing_strand.hpp>
 #include <log/log.hpp>
 
@@ -30,7 +30,10 @@ BOOST_DEFINE_ENUM_CLASS(
     TargetFileNotGood,
     CannotWorkCompletedOperation,
     CannotWorkFailedOperation,
-    UnknownWorkState);
+    CannotWorkCanceledOperation,
+    UnknownWorkState,
+    InvalidOperationState,
+    OperationNotPossibleOnFileType);
 
 class Operation
 {
@@ -47,7 +50,7 @@ class Operation
 
     using ErrorType = OperationErrorType;
 
-    virtual OperationType type() const = 0;
+    virtual SharedData::OperationType type() const = 0;
 
     template <typename FunctionT>
     auto visit(FunctionT&& func) const;
@@ -71,8 +74,6 @@ class Operation
     template <typename FunctionT>
     bool perform(FunctionT&& func)
     {
-        std::scoped_lock lock{mutex_};
-
         if (auto* theStrand = strand(); theStrand)
             return theStrand->pushTask(std::forward<FunctionT>(func));
         else
@@ -101,10 +102,25 @@ class Operation
 
     OperationState state() const
     {
-        std::scoped_lock lock{mutex_};
         return state_;
     }
 
+    /**
+     * @brief Can parallel actions go beyond this operation?
+     *
+     * @return true Cannot progress beyond this operation.
+     * @return false Can progress beyond this operation.
+     */
+    virtual bool isBarrier() const noexcept = 0;
+
+    /**
+     * @brief How much parallel work does this operation do.
+     *
+     * @param parallel Maximum parallelism allowed.
+     * @return The amount of parallel work that can be done maxed by parallel parameter.
+     */
+    virtual int parallelWorkDoable(int parallel) const noexcept = 0;
+
     enum class WorkStatus
     {
         MoreWork,
@@ -128,7 +144,6 @@ class Operation
     template <typename T = void>
     std::expected<T, Error> enterErrorState(Error error)
     {
-        std::scoped_lock lock{mutex_};
         state_ = OperationState::Failed;
         error_ = std::move(error);
         const auto cancelResult = cancel(false);
@@ -141,7 +156,12 @@ class Operation
     }
 
   protected:
-    mutable std::recursive_mutex mutex_{};
+    void enterState(OperationState newState)
+    {
+        state_ = newState;
+    }
+
+  protected:
     OperationState state_{OperationState::NotStarted};
     std::optional<Error> error_{std::nullopt};
 
diff --git a/backend/include/backend/sftp/operation_queue.hpp b/backend/include/backend/sftp/operation_queue.hpp
index a6b99d98..119dc1cd 100644
--- a/backend/include/backend/sftp/operation_queue.hpp
+++ b/backend/include/backend/sftp/operation_queue.hpp
@@ -3,7 +3,9 @@
 #include <backend/sftp/all_operations.hpp>
 #include <persistence/state/state.hpp>
 #include <ssh/sftp_session.hpp>
+#include <nui/rpc.hpp>
 #include <ids/ids.hpp>
+#include <backend/rpc_helper.hpp>
 
 #include <vector>
 #include <deque>
@@ -12,6 +14,8 @@
 #include <utility>
 
 class OperationQueue
+    : public RpcHelper::StrandRpc
+    , public std::enable_shared_from_this<OperationQueue>
 {
   public:
     enum class CompletionReason
@@ -31,7 +35,14 @@ class OperationQueue
         std::optional<Operation::Error> error{std::nullopt};
     };
 
-    OperationQueue(Persistence::SftpOptions sftpOpts, int parallelism = 1);
+    OperationQueue(
+        boost::asio::any_io_executor executor,
+        std::shared_ptr<boost::asio::strand<boost::asio::any_io_executor>> strand,
+        Nui::Window& wnd,
+        Nui::RpcHub& hub,
+        Persistence::SftpOptions sftpOpts,
+        Ids::SessionId sessionId,
+        int parallelism = 1);
 
     using Error = OperationErrorType;
 
@@ -44,17 +55,29 @@ class OperationQueue
      * @return true
      * @return false
      */
-    bool update();
+    bool work();
 
     std::expected<void, Operation::Error> addDownloadOperation(
         SecureShell::SftpSession& sftp,
-        Ids::OperationId id,
+        Ids::OperationId operationId,
         std::filesystem::path const& localPath,
         std::filesystem::path const& remotePath);
 
   private:
-    std::mutex mutex_{};
+    template <typename T>
+    void call(std::string event, Ids::OperationId id, T&& data)
+    {
+        hub_->callRemote(
+            fmt::format("OperationQueue::{}::{}", sessionId_.value(), event),
+            nlohmann::json{
+                {"operationId", id.value()},
+                {"payload", std::forward<T>(data)},
+            });
+    }
+
+  private:
     Persistence::SftpOptions sftpOpts_{};
+    Ids::SessionId sessionId_{};
     std::deque<std::pair<Ids::OperationId, std::unique_ptr<Operation>>> operations_{};
     std::vector<CompletedOperation> completedOperations_{};
     int parallelism_{1};
diff --git a/backend/include/backend/sftp/scan_operation.hpp b/backend/include/backend/sftp/scan_operation.hpp
new file mode 100644
index 00000000..72ed7552
--- /dev/null
+++ b/backend/include/backend/sftp/scan_operation.hpp
@@ -0,0 +1,68 @@
+#pragma once
+
+#include <ssh/file_stream.hpp>
+#include <backend/sftp/operation.hpp>
+#include <nui/utility/move_detector.hpp>
+
+#include <filesystem>
+#include <fstream>
+#include <string>
+#include <cstdint>
+
+class ScanOperation : public Operation
+{
+  public:
+    struct ScanOperationOptions
+    {
+        std::function<void(std::uint64_t totalBytes, std::uint64_t currentIndex, std::uint64_t totalScanned)>
+            progressCallback = [](auto, auto, auto) {};
+        std::filesystem::path remotePath{};
+        std::chrono::seconds futureTimeout{5};
+    };
+
+    SecureShell::ProcessingStrand* strand() const override;
+
+    ScanOperation(SecureShell::SftpSession& sftp, ScanOperationOptions options);
+    ~ScanOperation() override;
+    ScanOperation(ScanOperation const&) = delete;
+    ScanOperation(ScanOperation&&) = delete;
+    ScanOperation& operator=(ScanOperation const&) = delete;
+    ScanOperation& operator=(ScanOperation&&) = delete;
+
+    std::expected<WorkStatus, Error> work() override;
+
+    SharedData::OperationType type() const override
+    {
+        return SharedData::OperationType::Scan;
+    }
+
+    bool isBarrier() const noexcept override
+    {
+        return true;
+    }
+
+    int parallelWorkDoable(int) const noexcept override
+    {
+        return 1;
+    }
+
+    std::filesystem::path remotePath() const
+    {
+        return remotePath_;
+    }
+
+    std::expected<void, Error> cancel(bool adoptCancelState) override;
+
+  private:
+    std::expected<void, ScanOperation::Error> scanOnce(std::filesystem::path const& path);
+
+  private:
+    SecureShell::SftpSession* sftp_;
+    std::filesystem::path remotePath_;
+    std::function<void(std::uint64_t totalBytes, std::uint64_t currentIndex, std::uint64_t totalScanned)>
+        progressCallback_;
+    std::chrono::seconds futureTimeout_;
+    std::vector<SharedData::DirectoryEntry> entries_{};
+    std::uint64_t currentIndex_{0};
+    std::uint64_t totalBytes_{0};
+};
\ No newline at end of file
diff --git a/backend/source/backend/CMakeLists.txt b/backend/source/backend/CMakeLists.txt
index a762a414..c08aeec6 100644
--- a/backend/source/backend/CMakeLists.txt
+++ b/backend/source/backend/CMakeLists.txt
@@ -9,6 +9,8 @@ add_library(
         session.cpp
         sftp/operation_queue.cpp
         sftp/download_operation.cpp
+        sftp/scan_operation.cpp
+        sftp/bulk_download_operation.cpp
 )
 
 if (WIN32)
diff --git a/backend/source/backend/session.cpp b/backend/source/backend/session.cpp
index fff4caff..fadd1210 100644
--- a/backend/source/backend/session.cpp
+++ b/backend/source/backend/session.cpp
@@ -2,6 +2,8 @@
 
 #include <roar/utility/base64.hpp>
 
+using namespace std::chrono_literals;
+
 Session::Session(
     Ids::SessionId id,
     std::unique_ptr<SecureShell::Session> session,
@@ -11,45 +13,95 @@ Session::Session(
     Nui::RpcHub& hub,
     Persistence::SftpOptions const& sftpOptions)
     : RpcHelper::StrandRpc{executor, std::move(strand), wnd, hub}
-    , id_{id}
+    , id_{std::move(id)}
     , session_{std::move(session)}
-    , operationQueue_{std::make_unique<OperationQueue>(sftpOptions, sftpOptions.concurrency.value_or(1))}
+    , operationQueue_{std::make_shared<
+          OperationQueue>(executor_, strand_, wnd, hub, sftpOptions, id_, sftpOptions.concurrency.value_or(1))}
 {}
 
 void Session::start()
 {
-    within_strand_do([this]() {
-        if (!session_)
+    within_strand_do([weak = weak_from_this()]() {
+        auto self = weak.lock();
+        if (!self)
+            return;
+
+        if (!self->session_)
         {
             Log::error("Session is not valid, cannot start");
             return;
         }
 
-        session_->start();
-        registerRpcCreateChannel();
-        registerRpcStartChannelRead();
-        registerRpcChannelClose();
-        registerRpcChannelWrite();
-        registerRpcChannelPtyResize();
-        registerRpcSftpListDirectory();
-        registerRpcSftpCreateDirectory();
-        registerRpcSftpCreateFile();
-        registerRpcSftpAddDownloadOperation();
-
-        Log::info("Session '{}' connected", id_.value());
+        self->session_->start();
+        self->registerRpcCreateChannel();
+        self->registerRpcStartChannelRead();
+        self->registerRpcChannelClose();
+        self->registerRpcChannelWrite();
+        self->registerRpcChannelPtyResize();
+        self->registerRpcSftpListDirectory();
+        self->registerRpcSftpCreateDirectory();
+        self->registerRpcSftpCreateFile();
+        self->registerRpcSftpAddDownloadOperation();
+
+        Log::info("Session '{}' connected", self->id_.value());
+
+        self->running_ = true;
+        self->doOperationQueueWork();
+    });
+}
+
+void Session::stop()
+{
+    running_ = false;
+    timer_.cancel();
+}
+
+void Session::doOperationQueueWork()
+{
+    within_strand_do_no_recurse([weak = weak_from_this()]() {
+        auto self = weak.lock();
+        if (!self)
+            return;
+
+        if (!self->running_)
+            return;
+
+        if (self->operationQueue_ && self->operationQueue_->work())
+        {
+            self->doOperationQueueWork();
+            self->operationThrottle_ = 5ms;
+        }
+        else
+        {
+            if (self->operationThrottle_ < 1s)
+                self->operationThrottle_ *= 2;
+            else
+                self->operationThrottle_ = 1s;
+
+            self->within_strand_do_delayed(
+                [weak = self->weak_from_this()]() {
+                    if (auto self = weak.lock(); self)
+                        self->doOperationQueueWork();
+                },
+                self->operationThrottle_);
+        }
     });
 }
 
 void Session::removeChannel(Ids::ChannelId channelId)
 {
-    within_strand_do([this, channelId = std::move(channelId)]() {
-        auto iter = channels_.find(channelId);
-        if (iter != channels_.end())
+    within_strand_do([weak = weak_from_this(), channelId = std::move(channelId)]() {
+        auto self = weak.lock();
+        if (!self)
+            return;
+
+        auto iter = self->channels_.find(channelId);
+        if (iter != self->channels_.end())
         {
             if (auto locked = iter->second.lock(); locked)
                 locked->close();
 
-            channels_.erase(iter);
+            self->channels_.erase(iter);
         }
         else
         {
@@ -60,14 +112,18 @@ void Session::removeChannel(Ids::ChannelId channelId)
 
 void Session::removeSftpChannel(Ids::ChannelId channelId)
 {
-    within_strand_do([this, channelId = std::move(channelId)]() {
-        auto iter = sftpChannels_.find(channelId);
-        if (iter != sftpChannels_.end())
+    within_strand_do([weak = weak_from_this(), channelId = std::move(channelId)]() {
+        auto self = weak.lock();
+        if (!self)
+            return;
+
+        auto iter = self->sftpChannels_.find(channelId);
+        if (iter != self->sftpChannels_.end())
         {
             if (auto locked = iter->second.lock(); locked)
                 locked->close();
 
-            sftpChannels_.erase(iter);
+            self->sftpChannels_.erase(iter);
         }
         else
         {
@@ -79,9 +135,13 @@ void Session::removeSftpChannel(Ids::ChannelId channelId)
 void Session::registerRpcCreateChannel()
 {
     on(fmt::format("Session::{}::Channel::create", id_.value()))
-        .perform([this](RpcHelper::RpcOnce&& reply, nlohmann::json const& parameters) {
+        .perform([weak = weak_from_this()](RpcHelper::RpcOnce&& reply, nlohmann::json const& parameters) {
+            auto self = weak.lock();
+            if (!self)
+                return reply({{"error", "Session no longer exists"}});
+
             RpcHelper::ParameterVerifyView verify{
-                reply, fmt::format("Session::{}::Channel::create", id_.value()), parameters};
+                reply, fmt::format("Session::{}::Channel::create", self->id_.value()), parameters};
 
             if (!verify.hasValueDeep("engine"))
                 return;
@@ -91,12 +151,13 @@ void Session::registerRpcCreateChannel()
 
             if (!fileMode)
             {
-                Log::info("Creating pty channel for session '{}'", id_.value());
+                Log::info("Creating pty channel for session '{}'", self->id_.value());
 
                 const auto sessionOptions =
                     parameters["engine"]["sshSessionOptions"].get<Persistence::SshSessionOptions>();
 
-                const auto weakChannel = session_->createPtyChannel({.environment = sessionOptions.environment}).get();
+                const auto weakChannel =
+                    self->session_->createPtyChannel({.environment = sessionOptions.environment}).get();
                 if (!weakChannel.has_value())
                 {
                     Log::error("Failed to create pty channel: {}", weakChannel.error());
@@ -104,20 +165,20 @@ void Session::registerRpcCreateChannel()
                 }
 
                 const auto channelId = Ids::generateChannelId();
-                channels_.emplace(channelId, std::move(weakChannel).value());
+                self->channels_.emplace(channelId, std::move(weakChannel).value());
 
                 Log::info(
                     "Created pty channel with id '{}', channel total is now '{}'.",
                     channelId.value(),
-                    channels_.size());
+                    self->channels_.size());
 
                 return reply({{"id", channelId.value()}});
             }
             else
             {
-                Log::info("Creating sftp channel for session '{}'", id_.value());
+                Log::info("Creating sftp channel for session '{}'", self->id_.value());
 
-                const auto weakChannel = session_->createSftpSession().get();
+                const auto weakChannel = self->session_->createSftpSession().get();
                 if (!weakChannel.has_value())
                 {
                     Log::error("Failed to create sftp channel: {}", weakChannel.error().toString());
@@ -125,12 +186,12 @@ void Session::registerRpcCreateChannel()
                 }
 
                 const auto channelId = Ids::generateChannelId();
-                sftpChannels_.emplace(channelId, std::move(weakChannel).value());
+                self->sftpChannels_.emplace(channelId, std::move(weakChannel).value());
 
                 Log::info(
                     "Created sftp channel with id '{}', sftp channel total is now '{}'.",
                     channelId.value(),
-                    sftpChannels_.size());
+                    self->sftpChannels_.size());
 
                 return reply({{"id", channelId.value()}});
             }
@@ -140,19 +201,23 @@ void Session::registerRpcCreateChannel()
 void Session::registerRpcStartChannelRead()
 {
     on(fmt::format("Session::{}::Channel::startReading", id_.value()))
-        .perform([this](RpcHelper::RpcOnce&& reply, std::string const& channelIdString) {
+        .perform([weak = weak_from_this()](RpcHelper::RpcOnce&& reply, std::string const& channelIdString) {
+            auto self = weak.lock();
+            if (!self)
+                return reply({{"error", "Session no longer exists"}});
+
             const auto channelId = Ids::makeChannelId(channelIdString);
-            if (channels_.find(channelId) == channels_.end())
+            if (self->channels_.find(channelId) == self->channels_.end())
             {
                 Log::error("No channel found with id: {}", channelId.value());
                 return reply({{"error", "No channel found with id"}});
             }
 
-            auto locked = channels_[channelId].lock();
+            auto locked = self->channels_[channelId].lock();
             if (!locked)
             {
                 Log::error("Failed to lock channel with id: {}", channelId.value());
-                removeChannel(channelId);
+                self->removeChannel(channelId);
                 return reply({{"error", "Failed to lock channel"}});
             }
 
@@ -160,12 +225,12 @@ void Session::registerRpcStartChannelRead()
             // unless within_strand_do is used!
             locked->startReading(
                 // Stdout
-                [sessionId = id_,
+                [sessionId = self->id_,
                  channelId,
                  stdOut =
                      RpcHelper::RpcInCorrectThread{
-                         *wnd_,
-                         *hub_,
+                         *self->wnd_,
+                         *self->hub_,
                          fmt::format("sshTerminalStdout_{}", channelId.value()),
                      }](std::string const& msg) {
                     stdOut(
@@ -176,12 +241,12 @@ void Session::registerRpcStartChannelRead()
                         });
                 },
                 // Stderr
-                [sessionId = id_,
+                [sessionId = self->id_,
                  channelId,
                  stdErr =
                      RpcHelper::RpcInCorrectThread{
-                         *wnd_,
-                         *hub_,
+                         *self->wnd_,
+                         *self->hub_,
                          fmt::format("sshTerminalStderr_{}", channelId.value()),
                      }](std::string const& data) {
                     stdErr(
@@ -193,14 +258,15 @@ void Session::registerRpcStartChannelRead()
                 },
                 // On channel exit:
                 [removeChannel =
-                     [this, channelId]() {
-                         removeChannel(channelId);
+                     [weak = self->weak_from_this(), channelId]() {
+                         if (auto self = weak.lock(); self)
+                             self->removeChannel(channelId);
                      },
-                 sessionId = id_,
+                 sessionId = self->id_,
                  channelId,
                  onExit = RpcHelper::RpcInCorrectThread{
-                     *wnd_,
-                     *hub_,
+                     *self->wnd_,
+                     *self->hub_,
                      fmt::format("sshTerminalOnExit_{}", channelId.value()),
                  }]() {
                     Log::info("Channel for session '{}' lost with id: {}", sessionId.value(), channelId.value());
@@ -215,8 +281,12 @@ void Session::registerRpcStartChannelRead()
 void Session::registerRpcChannelClose()
 {
     on(fmt::format("Session::{}::Channel::close", id_.value()))
-        .perform([this](RpcHelper::RpcOnce&& reply, std::string const& channelIdString) {
-            removeChannel(Ids::makeChannelId(channelIdString));
+        .perform([weak = weak_from_this()](RpcHelper::RpcOnce&& reply, std::string const& channelIdString) {
+            auto self = weak.lock();
+            if (!self)
+                return reply({{"error", "Session no longer exists"}});
+
+            self->removeChannel(Ids::makeChannelId(channelIdString));
             return reply({{"success", true}});
         });
 }
@@ -224,8 +294,13 @@ void Session::registerRpcChannelClose()
 void Session::registerRpcChannelWrite()
 {
     on(fmt::format("Session::{}::Channel::write", id_.value()))
-        .perform([this](RpcHelper::RpcOnce&& reply, std::string const& channelIdString, std::string&& data) {
-            withChannelDo(
+        .perform([weak = weak_from_this()](
+                     RpcHelper::RpcOnce&& reply, std::string const& channelIdString, std::string&& data) {
+            auto self = weak.lock();
+            if (!self)
+                return reply({{"error", "Session no longer exists"}});
+
+            self->withChannelDo(
                 Ids::makeChannelId(channelIdString),
                 [data = std::move(data)](RpcHelper::RpcOnce&& reply, auto&& channel) {
                     channel->write(Roar::base64Decode(data));
@@ -238,10 +313,15 @@ void Session::registerRpcChannelWrite()
 void Session::registerRpcChannelPtyResize()
 {
     on(fmt::format("Session::{}::Channel::ptyResize", id_.value()))
-        .perform([this](RpcHelper::RpcOnce&& reply, std::string const& channelIdString, int cols, int rows) {
-            withChannelDo(
+        .perform([weak = weak_from_this()](
+                     RpcHelper::RpcOnce&& reply, std::string const& channelIdString, int cols, int rows) {
+            auto self = weak.lock();
+            if (!self)
+                return reply({{"error", "Session no longer exists"}});
+
+            self->withChannelDo(
                 Ids::makeChannelId(channelIdString),
-                [cols, rows](RpcHelper::RpcOnce&& reply, auto channel) {
+                [cols, rows](RpcHelper::RpcOnce&& reply, auto&& channel) {
                     channel->resizePty(cols, rows);
                     reply({{"success", true}});
                 },
@@ -252,10 +332,15 @@ void Session::registerRpcChannelPtyResize()
 void Session::registerRpcSftpListDirectory()
 {
     on(fmt::format("Session::{}::sftp::listDirectory", id_.value()))
-        .perform([this](RpcHelper::RpcOnce&& reply, std::string const& channelIdString, std::string const& path) {
-            withSftpChannelDo(
+        .perform([weak = weak_from_this()](
+                     RpcHelper::RpcOnce&& reply, std::string const& channelIdString, std::string const& path) {
+            auto self = weak.lock();
+            if (!self)
+                return reply({{"error", "Session no longer exists"}});
+
+            self->withSftpChannelDo(
                 Ids::makeChannelId(channelIdString),
-                [path](RpcHelper::RpcOnce&& reply, auto channel) {
+                [path](RpcHelper::RpcOnce&& reply, auto&& channel) {
                     auto fut = channel->listDirectory(path);
                     if (fut.wait_for(futureTimeout) != std::future_status::ready)
                         return reply({{"error", "Failed to list directory: timeout"}});
@@ -274,10 +359,15 @@ void Session::registerRpcSftpListDirectory()
 void Session::registerRpcSftpCreateDirectory()
 {
     on(fmt::format("Session::{}::sftp::createDirectory", id_.value()))
-        .perform([this](RpcHelper::RpcOnce&& reply, std::string const& channelIdString, std::string const& path) {
-            withSftpChannelDo(
+        .perform([weak = weak_from_this()](
+                     RpcHelper::RpcOnce&& reply, std::string const& channelIdString, std::string const& path) {
+            auto self = weak.lock();
+            if (!self)
+                return reply({{"error", "Session no longer exists"}});
+
+            self->withSftpChannelDo(
                 Ids::makeChannelId(channelIdString),
-                [path](RpcHelper::RpcOnce&& reply, auto channel) {
+                [path](RpcHelper::RpcOnce&& reply, auto&& channel) {
                     auto fut = channel->createDirectory(path);
                     if (fut.wait_for(futureTimeout) != std::future_status::ready)
                         return reply({{"error", "Failed to create directory: timeout"}});
@@ -296,10 +386,15 @@ void Session::registerRpcSftpCreateDirectory()
 void Session::registerRpcSftpCreateFile()
 {
     on(fmt::format("Session::{}::sftp::createFile", id_.value()))
-        .perform([this](RpcHelper::RpcOnce&& reply, std::string const& channelIdString, std::string const& path) {
-            withSftpChannelDo(
+        .perform([weak = weak_from_this()](
+                     RpcHelper::RpcOnce&& reply, std::string const& channelIdString, std::string const& path) {
+            auto self = weak.lock();
+            if (!self)
+                return reply({{"error", "Session no longer exists"}});
+
+            self->withSftpChannelDo(
                 Ids::makeChannelId(channelIdString),
-                [path](RpcHelper::RpcOnce&& reply, auto channel) {
+                [path](RpcHelper::RpcOnce&& reply, auto&& channel) {
                     auto fut = channel->createFile(path);
                     if (fut.wait_for(futureTimeout) != std::future_status::ready)
                         return reply({{"error", "Failed to create file: timeout"}});
@@ -318,63 +413,45 @@ void Session::registerRpcSftpCreateFile()
 void Session::registerRpcSftpAddDownloadOperation()
 {
     on(fmt::format("Session::{}::sftp::addDownload", id_.value()))
-        .perform([this](
+        .perform([weak = weak_from_this()](
                      RpcHelper::RpcOnce&& reply,
                      std::string const& channelIdString,
                      std::string const& newOperationIdString,
-                     std::string const& localPath,
-                     std::string const& remotePath) {
-            withSftpChannelDo(
+                     std::string const& remotePath,
+                     std::string const& localPath) {
+            auto self = weak.lock();
+            if (!self)
+                return reply({{"error", "Session no longer exists"}});
+
+            self->withSftpChannelDo(
                 Ids::makeChannelId(channelIdString),
-                [newOperationIdString, localPath, remotePath](RpcHelper::RpcOnce&& reply, auto channel) {
-                    // TODO:
+                [weak = self->weak_from_this(), newOperationIdString, localPath, remotePath](
+                    RpcHelper::RpcOnce&& reply, auto&& channel) {
+                    auto self = weak.lock();
+                    if (!self)
+                        return reply({{"error", "Session no longer exists"}});
 
-                    // const auto result = operationQueues_->addDownloadOperation(
-                    //     Ids::makeOperationId(newOperationIdString), localPath, remotePath);
+                    const auto result = self->operationQueue_->addDownloadOperation(
+                        *channel, Ids::makeOperationId(newOperationIdString), localPath, remotePath);
 
-                    // if (!result.has_value())
-                    //     return reply({{"error", result.error().toString()}});
+                    if (!result.has_value())
+                    {
+                        Log::error(
+                            "Failed to add download operation for file '{}' to '{}': {}",
+                            remotePath,
+                            localPath,
+                            result.error().toString());
+                        return reply({{"error", result.error().toString()}});
+                    }
 
                     Log::info(
                         "Added download operation with id '{}' for file '{}' to '{}'",
                         newOperationIdString,
                         remotePath,
                         localPath);
+
                     reply({{"success", true}});
                 },
                 std::move(reply));
         });
-
-    // hub.registerFunction(
-    //     "SessionManager::sftp::addDownload",
-    //     [this, hub = &hub](
-    //         std::string const& responseId,
-    //         std::string const& sessionIdString,
-    //         std::string const& channelIdString,
-    //         std::string const& newOperationIdString,
-    //         std::string const& localPath,
-    //         std::string const& remotePath) {
-    //         auto const& state = stateHolder_->stateCache();
-
-    //         auto sftp = channel->second.lock();
-    //         if (!sftp)
-    //         {
-    //             Log::error("Failed to lock sftp channel with id: {}", channelId.value());
-    //             hub->callRemote(responseId, nlohmann::json{{"error", "Failed to lock sftp channel"}});
-    //             return;
-    //         }
-
-    //         const auto result = operationQueue_.addDownloadOperation(
-    //             *sftp, Ids::makeOperationId(newOperationIdString), localPath, remotePath);
-
-    //         if (!result.has_value())
-    //         {
-    //             Log::error("Failed to add download operation: {}", result.error().toString());
-    //             hub->callRemote(responseId, nlohmann::json{{"error", result.error().toString()}});
-    //             return;
-    //         }
-
-    //         dispatchUpdates();
-    //         hub->callRemote(responseId, nlohmann::json{{"success", true}});
-    //     });
 }
\ No newline at end of file
diff --git a/backend/source/backend/session_manager.cpp b/backend/source/backend/session_manager.cpp
index f794efed..31427827 100644
--- a/backend/source/backend/session_manager.cpp
+++ b/backend/source/backend/session_manager.cpp
@@ -95,24 +95,23 @@ void SessionManager::addSession(
         if (maybeSshSession)
         {
             const auto sessionId = Ids::SessionId{Ids::generateId()};
-            const auto emplaced = sessions_.emplace(
+            const auto session = std::make_shared<Session>(
                 sessionId,
-                Session{
-                    sessionId,
-                    std::move(maybeSshSession).value(),
-                    executor_,
-                    strand_,
-                    *wnd_,
-                    *hub_,
-                    engine.sshSessionOptions->sftpOptions.value()});
+                std::move(maybeSshSession).value(),
+                executor_,
+                strand_,
+                *wnd_,
+                *hub_,
+                engine.sshSessionOptions->sftpOptions.value());
+            const auto emplaced = sessions_.emplace(sessionId, session);
             if (!emplaced.second)
             {
-                Log::error("Session id collision - This should never happen");
+                Log::error("Session id collision - This should never happen.");
                 return onComplete(std::nullopt);
             }
 
             Log::info("Created session with id '{}', total is now '{}'.", sessionId.value(), sessions_.size());
-            emplaced.first->second.start();
+            session->start();
             onComplete(sessionId);
         }
         else
@@ -187,35 +186,4 @@ void SessionManager::registerRpcSessionDisconnect()
             return reply({{"error", e.what()}});
         }
     });
-}
-
-// void SessionManager::startUpdateDispatching()
-// {
-//     updateDispatchRunning_ = true;
-//     dispatchUpdates();
-// }
-// void SessionManager::stopUpdateDispatching()
-// {
-//     updateDispatchRunning_ = false;
-// }
-
-// void SessionManager::dispatchUpdates()
-// {
-//     if (!updateDispatchRunning_)
-//         return;
-
-//     boost::asio::dispatch(executor_, [weak = weak_from_this()]() {
-//         auto self = weak.lock();
-//         if (!self)
-//             return;
-
-//         if (!self->updateDispatchRunning_)
-//         {
-//             Log::info("Update dispatching stopped");
-//             return;
-//         }
-
-//         if (self->operationQueue_.update())
-//             self->dispatchUpdates();
-//     });
-// }
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/backend/source/backend/sftp/bulk_download_operation.cpp b/backend/source/backend/sftp/bulk_download_operation.cpp
new file mode 100644
index 00000000..675f62e5
--- /dev/null
+++ b/backend/source/backend/sftp/bulk_download_operation.cpp
@@ -0,0 +1,49 @@
+#include <backend/sftp/bulk_download_operation.hpp>
+#include <ssh/sftp_session.hpp>
+#include <log/log.hpp>
+
+BulkDownloadOperation::BulkDownloadOperation(SecureShell::SftpSession& sftp, BulkDownloadOperationOptions options)
+    : Operation{}
+    , sftp_{&sftp}
+    , options_{std::move(options)}
+    , currentDownload_{nullptr}
+    , entries_{}
+    , totalBytes_{0}
+    , currentIndex_{0}
+    , currentBytes_{0}
+    , futureTimeout_{options_.individualOptions.futureTimeout}
+{}
+
+BulkDownloadOperation::~BulkDownloadOperation() = default;
+
+std::expected<BulkDownloadOperation::WorkStatus, BulkDownloadOperation::Error> BulkDownloadOperation::work()
+{
+    using enum OperationState;
+
+    // TODO: Not implemented yet
+
+    return enterErrorState<WorkStatus>({.type = Operation::ErrorType::CannotWorkFailedOperation});
+}
+
+SharedData::OperationType BulkDownloadOperation::type() const
+{
+    return SharedData::OperationType::BulkDownload;
+}
+
+void BulkDownloadOperation::setScanResult(std::vector<SharedData::DirectoryEntry>&& entries)
+{
+    entries_ = std::move(entries);
+    totalBytes_ = 0;
+}
+
+std::expected<void, BulkDownloadOperation::Error> BulkDownloadOperation::cancel(bool adoptCancelState)
+{
+    if (adoptCancelState)
+        enterState(OperationState::Canceled);
+    return {};
+}
+
+SecureShell::ProcessingStrand* BulkDownloadOperation::strand() const
+{
+    return sftp_->strand();
+}
\ No newline at end of file
diff --git a/backend/source/backend/sftp/download_operation.cpp b/backend/source/backend/sftp/download_operation.cpp
index 31d9e6ee..0f3c2d37 100644
--- a/backend/source/backend/sftp/download_operation.cpp
+++ b/backend/source/backend/sftp/download_operation.cpp
@@ -120,8 +120,6 @@ std::expected<DownloadOperation::WorkStatus, DownloadOperation::Error> DownloadO
 
 std::expected<bool, DownloadOperation::Error> DownloadOperation::readOnce()
 {
-    std::scoped_lock lock{mutex_};
-
     if (state_ < OperationState::Prepared)
     {
         Log::error("DownloadOperation: Operation not prepared.");
@@ -151,6 +149,9 @@ std::expected<bool, DownloadOperation::Error> DownloadOperation::readOnce()
     const auto futureStatus =
         stream
             ->read([this, &doContinue](std::string_view data) {
+                // No locking, because concurrent access is not possible, the only
+                // other executing thread is blocked right now.
+
                 if (data.size() == 0)
                 {
                     Log::info("DownloadOperation: Remote file read complete or error.");
@@ -161,7 +162,6 @@ std::expected<bool, DownloadOperation::Error> DownloadOperation::readOnce()
                 std::uint64_t fileSize = 0;
                 bool good = true;
                 {
-                    std::scoped_lock lock{mutex_};
                     localFile_.write(data.data(), data.size());
                     tellp = static_cast<uint64_t>(localFile_.tellp());
                     fileSize = fileSize_;
@@ -171,7 +171,7 @@ std::expected<bool, DownloadOperation::Error> DownloadOperation::readOnce()
                 if (!good)
                 {
                     Log::error("DownloadOperation read cycle stopped: localFile_.good() == false");
-                    std::ignore = this->enterErrorState({
+                    std::ignore = enterErrorState({
                         .type = OperationErrorType::TargetFileNotGood,
                     });
                     return doContinue = false;
@@ -191,8 +191,6 @@ std::expected<bool, DownloadOperation::Error> DownloadOperation::readOnce()
 
 std::expected<void, DownloadOperation::Error> DownloadOperation::openOrAdoptFile(SecureShell::IFileStream& stream)
 {
-    std::scoped_lock lock{mutex_};
-
     const auto tempPath = localPath_.generic_string() + tempFileSuffix_;
 
     if (tryContinue_ && std::filesystem::exists(tempPath))
@@ -245,8 +243,6 @@ std::expected<void, DownloadOperation::Error> DownloadOperation::openOrAdoptFile
 
 std::expected<void, Operation::Error> DownloadOperation::prepare()
 {
-    std::scoped_lock lock{mutex_};
-
     if (localPath_.empty())
     {
         Log::error("DownloadOperation: Invalid local path.");
@@ -312,8 +308,6 @@ std::expected<void, Operation::Error> DownloadOperation::prepare()
 
 std::expected<void, DownloadOperation::Error> DownloadOperation::cancel(bool adoptCancelState)
 {
-    std::scoped_lock lock{mutex_};
-
     Log::info(
         "DownloadOperation: Download of '{}' to '{}' canceled.",
         remotePath_.generic_string(),
@@ -328,7 +322,6 @@ std::expected<void, DownloadOperation::Error> DownloadOperation::cancel(bool ado
 
 void DownloadOperation::cleanup()
 {
-    std::scoped_lock lock{mutex_};
     localFile_.close();
 
     if (doCleanup_ && std::filesystem::exists(localPath_.generic_string() + tempFileSuffix_))
@@ -340,8 +333,6 @@ void DownloadOperation::cleanup()
 
 std::expected<void, DownloadOperation::Error> DownloadOperation::finalize()
 {
-    std::scoped_lock lock{mutex_};
-
     if (state_ == OperationState::Running)
     {
         Log::error("DownloadOperation: Cannot finalize while reading.");
diff --git a/backend/source/backend/sftp/operation_queue.cpp b/backend/source/backend/sftp/operation_queue.cpp
index d79c0e86..d31c6c39 100644
--- a/backend/source/backend/sftp/operation_queue.cpp
+++ b/backend/source/backend/sftp/operation_queue.cpp
@@ -23,6 +23,23 @@ namespace
                         .error = error,
                     };
                 },
+                [reason, id, error](ScanOperation const& op) {
+                    return OperationQueue::CompletedOperation{
+                        .reason = reason,
+                        .id = id,
+                        .completionTime = std::chrono::system_clock::now(),
+                        .remotePath = op.remotePath(),
+                        .error = error,
+                    };
+                },
+                [reason, id, error](BulkDownloadOperation const&) {
+                    return OperationQueue::CompletedOperation{
+                        .reason = reason,
+                        .id = id,
+                        .completionTime = std::chrono::system_clock::now(),
+                        .error = error,
+                    };
+                },
                 [reason, id](std::nullopt_t) {
                     return OperationQueue::CompletedOperation{
                         .reason = reason,
@@ -33,35 +50,53 @@ namespace
     }
 }
 
-OperationQueue::OperationQueue(Persistence::SftpOptions sftpOpts, int parallelism)
-    : sftpOpts_{std::move(sftpOpts)}
+OperationQueue::OperationQueue(
+    boost::asio::any_io_executor executor,
+    std::shared_ptr<boost::asio::strand<boost::asio::any_io_executor>> strand,
+    Nui::Window& wnd,
+    Nui::RpcHub& hub,
+    Persistence::SftpOptions sftpOpts,
+    Ids::SessionId sessionId,
+    int parallelism)
+    : RpcHelper::StrandRpc{executor, strand, wnd, hub}
+    , sftpOpts_{std::move(sftpOpts)}
+    , sessionId_{std::move(sessionId)}
     , parallelism_{parallelism}
 {}
 
 void OperationQueue::cancelAll()
 {
-    std::scoped_lock lock{mutex_};
-    operations_.clear();
-    Log::info("All operations in the queue have been canceled.");
+    within_strand_do([weak = weak_from_this()]() {
+        auto self = weak.lock();
+        if (!self)
+            return;
+
+        self->operations_.clear();
+        Log::info("All operations in the queue have been canceled.");
+    });
 }
 void OperationQueue::cancel(Ids::OperationId id)
 {
-    std::scoped_lock lock{mutex_};
-    std::erase_if(operations_, [id](const auto& op) {
-        return op.first == id;
+    within_strand_do([weak = weak_from_this(), id = std::move(id)]() {
+        auto self = weak.lock();
+        if (!self)
+            return;
+
+        std::erase_if(self->operations_, [id](const auto& op) {
+            return op.first == id;
+        });
     });
 }
 
-bool OperationQueue::update()
+bool OperationQueue::work()
 {
-    std::scoped_lock lock{mutex_};
+    // Assumed in strand
+
     const auto updateCount = std::min(operations_.size(), static_cast<std::size_t>(parallelism_));
 
     bool moreWork = false;
     if (updateCount == 0)
-    {
         return false;
-    }
 
     for (std::size_t i = 0; i < updateCount; ++i)
     {
@@ -96,43 +131,117 @@ bool OperationQueue::update()
 
 std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
     SecureShell::SftpSession& sftp,
-    Ids::OperationId id,
+    Ids::OperationId operationId,
     std::filesystem::path const& localPath,
     std::filesystem::path const& remotePath)
 {
-    auto fut = sftp.openFile(remotePath, SecureShell::SftpSession::OpenType::Read, std::filesystem::perms::unknown);
-    if (fut.wait_for(std::chrono::seconds{5}) != std::future_status::ready)
+    // Assumed in strand
+
+    auto fut = sftp.stat(remotePath);
+    if (fut.wait_for(sftpOpts_.operationTimeout) != std::future_status::ready)
     {
-        Log::error("Failed to open remote sftp file: timeout");
-        return std::unexpected(Operation::Error{.type = Operation::ErrorType::OpenFailure});
+        Log::error("Failed to stat remote sftp file: timeout");
+        return std::unexpected(Operation::Error{.type = Operation::ErrorType::FutureTimeout});
     }
 
     const auto result = fut.get();
     if (!result.has_value())
     {
-        Log::error("Failed to open remote sftp file: {}", result.error().message);
+        Log::error("Failed to stat remote sftp file: {}", result.error().message);
         return std::unexpected(Operation::Error{.type = Operation::ErrorType::SftpError, .sftpError = result.error()});
     }
 
-    const auto transferOptions = sftpOpts_.downloadOptions.value_or(Persistence::TransferOptions{});
-    const auto defaultOptions = DownloadOperation::DownloadOperationOptions{};
-
-    auto operation = std::make_unique<DownloadOperation>(
-        std::move(result).value(),
-        DownloadOperation::DownloadOperationOptions{
-            .remotePath = remotePath,
-            .localPath = localPath,
-            .tempFileSuffix = transferOptions.tempFileSuffix.value_or(defaultOptions.tempFileSuffix),
-            .mayOverwrite = transferOptions.mayOverwrite.value_or(defaultOptions.mayOverwrite),
-            .reserveSpace = transferOptions.reserveSpace.value_or(defaultOptions.reserveSpace),
-            .tryContinue = transferOptions.tryContinue.value_or(defaultOptions.tryContinue),
-            .inheritPermissions = transferOptions.inheritPermissions.value_or(defaultOptions.inheritPermissions),
-            .doCleanup = transferOptions.doCleanup.value_or(defaultOptions.doCleanup),
-            .permissions =
-                transferOptions.customPermissions ? transferOptions.customPermissions : defaultOptions.permissions,
-        });
+    if (result->isRegularFile())
+    {
+        auto fut = sftp.openFile(remotePath, SecureShell::SftpSession::OpenType::Read, std::filesystem::perms::unknown);
+        if (fut.wait_for(std::chrono::seconds{5}) != std::future_status::ready)
+        {
+            Log::error("Failed to open remote sftp file: timeout");
+            return std::unexpected(Operation::Error{.type = Operation::ErrorType::OpenFailure});
+        }
+
+        const auto result = fut.get();
+        if (!result.has_value())
+        {
+            Log::error("Failed to open remote sftp file: {}", result.error().message);
+            return std::unexpected(
+                Operation::Error{.type = Operation::ErrorType::SftpError, .sftpError = result.error()});
+        }
+
+        const auto transferOptions = sftpOpts_.downloadOptions.value_or(Persistence::TransferOptions{});
+        const auto defaultOptions = DownloadOperation::DownloadOperationOptions{};
 
-    std::scoped_lock lock{mutex_};
-    operations_.emplace_back(id, std::move(operation));
-    return {};
+        auto operation = std::make_unique<DownloadOperation>(
+            std::move(result).value(),
+            DownloadOperation::DownloadOperationOptions{
+                .progressCallback =
+                    [weak = weak_from_this(), operationId](auto min, auto max, auto current) {
+                        // TODO:
+                        auto self = weak.lock();
+                        if (!self)
+                            return;
+
+                        self->call(
+                            "progress", operationId, nlohmann::json{{"min", min}, {"max", max}, {"current", current}});
+
+                        Log::info(
+                            "Downloaded {} / {} bytes ({}%)",
+                            current - min,
+                            max - min,
+                            (current - min) * 100 / (max - min));
+                    },
+                .remotePath = remotePath,
+                .localPath = localPath,
+                .tempFileSuffix = transferOptions.tempFileSuffix.value_or(defaultOptions.tempFileSuffix),
+                .mayOverwrite = transferOptions.mayOverwrite.value_or(defaultOptions.mayOverwrite),
+                .reserveSpace = transferOptions.reserveSpace.value_or(defaultOptions.reserveSpace),
+                .tryContinue = transferOptions.tryContinue.value_or(defaultOptions.tryContinue),
+                .inheritPermissions = transferOptions.inheritPermissions.value_or(defaultOptions.inheritPermissions),
+                .doCleanup = transferOptions.doCleanup.value_or(defaultOptions.doCleanup),
+                .permissions =
+                    transferOptions.customPermissions ? transferOptions.customPermissions : defaultOptions.permissions,
+            });
+
+        operations_.emplace_back(operationId, std::move(operation));
+        return {};
+    }
+    else if (result->isDirectory())
+    {
+        auto scan = std::make_unique<ScanOperation>(
+            sftp,
+            ScanOperation::ScanOperationOptions{
+                .progressCallback =
+                    [](auto, auto, auto) {
+                        // TODO:
+                    },
+                .remotePath = remotePath,
+                .futureTimeout = std::chrono::seconds{5},
+            });
+
+        auto bulk = std::make_unique<BulkDownloadOperation>(
+            sftp,
+            BulkDownloadOperation::BulkDownloadOperationOptions{
+                .overallProgressCallback =
+                    [](auto const&, auto, auto, auto, auto) {
+                        // TODO:
+                    },
+                .individualOptions =
+                    DownloadOperation::DownloadOperationOptions{
+                        .progressCallback =
+                            [](auto, auto, auto) {
+                                // TODO:
+                            },
+                        .remotePath = remotePath,
+                        .localPath = localPath,
+                    },
+            });
+
+        operations_.emplace_back(operationId, std::move(scan));
+        return {};
+    }
+    else
+    {
+        Log::error("Remote path is neither a file nor a directory: {}.", result->type);
+        return std::unexpected(Operation::Error{.type = Operation::ErrorType::OperationNotPossibleOnFileType});
+    }
 }
\ No newline at end of file
diff --git a/backend/source/backend/sftp/scan_operation.cpp b/backend/source/backend/sftp/scan_operation.cpp
new file mode 100644
index 00000000..5ead80e1
--- /dev/null
+++ b/backend/source/backend/sftp/scan_operation.cpp
@@ -0,0 +1,123 @@
+#include <backend/sftp/scan_operation.hpp>
+#include <log/log.hpp>
+
+#include <ssh/sftp_session.hpp>
+
+ScanOperation::ScanOperation(SecureShell::SftpSession& sftp, ScanOperationOptions options)
+    : sftp_(&sftp)
+    , remotePath_{std::move(options.remotePath)}
+    , progressCallback_{std::move(options.progressCallback)}
+    , futureTimeout_{options.futureTimeout}
+{}
+
+ScanOperation::~ScanOperation() = default;
+
+std::expected<void, ScanOperation::Error> ScanOperation::scanOnce(std::filesystem::path const& path)
+{
+    auto fut = sftp_->listDirectory(path);
+    fut.wait_for(futureTimeout_);
+    if (fut.wait_for(futureTimeout_) != std::future_status::ready)
+        return enterErrorState<void>({.type = ErrorType::FutureTimeout});
+
+    const auto result = fut.get();
+    if (!result.has_value())
+        return enterErrorState<void>({.type = ErrorType::SftpError, .sftpError = result.error()});
+
+    entries_.insert(entries_.end(), result->begin(), result->end());
+    return {};
+}
+
+std::expected<ScanOperation::WorkStatus, ScanOperation::Error> ScanOperation::work()
+{
+    using enum OperationState;
+
+    switch (state_)
+    {
+        case (NotStarted):
+        {
+            state_ = Running;
+            totalBytes_ = 0;
+            currentIndex_ = 0;
+            Log::info("ScanOperation: Starting scan of '{}'.", remotePath_.generic_string());
+            const auto result = scanOnce(remotePath_);
+            if (!result.has_value())
+            {
+                Log::error("ScanOperation: Failed to scan directory: {}", result.error().toString());
+                return enterErrorState<WorkStatus>(result.error());
+            }
+            progressCallback_(totalBytes_, currentIndex_, static_cast<std::uint64_t>(entries_.size()));
+            break;
+        }
+        case (Running):
+        {
+            if (currentIndex_ >= static_cast<std::uint64_t>(entries_.size()))
+            {
+                Log::info("ScanOperation: Scan of '{}' completed.", remotePath_.generic_string());
+                state_ = Completed;
+                return WorkStatus::Complete;
+            }
+
+            if (entries_[currentIndex_].isDirectory())
+            {
+                const auto result = scanOnce(entries_[currentIndex_].path);
+                if (!result.has_value())
+                {
+                    Log::error(
+                        "ScanOperation: Failed to scan directory '{}': {}",
+                        entries_[currentIndex_].path.generic_string(),
+                        result.error().toString());
+                    return enterErrorState<WorkStatus>(result.error());
+                }
+                ++currentIndex_;
+            }
+
+            for (; currentIndex_ < static_cast<std::uint64_t>(entries_.size()); ++currentIndex_)
+            {
+                auto& entry = entries_[currentIndex_];
+                if (entry.isRegularFile())
+                    totalBytes_ += entry.size;
+                else if (entry.isDirectory())
+                    return WorkStatus::MoreWork;
+            }
+
+            progressCallback_(totalBytes_, currentIndex_, static_cast<std::uint64_t>(entries_.size()));
+            return WorkStatus::MoreWork;
+        }
+        case (Prepared):
+        case (Preparing):
+        case (Finalizing):
+            Log::error("ScanOperation: Invalid state: {}", static_cast<int>(state_));
+            return enterErrorState<WorkStatus>({.type = ErrorType::InvalidOperationState});
+        case (Completed):
+        {
+            Log::warn("ScanOperation: Operation already completed.");
+            // Dont enter error state here, it would overwrite the success state.
+            return std::unexpected(Error{.type = ErrorType::CannotWorkCompletedOperation});
+        }
+        case (Failed):
+        {
+            Log::warn("ScanOperation: Operation already failed.");
+            // Do not enter error state here, it would overwrite the error state.
+            return std::unexpected(Error{.type = ErrorType::CannotWorkFailedOperation});
+        }
+        case (Canceled):
+        {
+            Log::warn("ScanOperation: Cannot work on canceled operation.");
+            return std::unexpected(Error{.type = ErrorType::CannotWorkCanceledOperation});
+        }
+    }
+    return enterErrorState<WorkStatus>({.type = ErrorType::UnknownWorkState});
+}
+
+std::expected<void, ScanOperation::Error> ScanOperation::cancel(bool adoptCancelState)
+{
+    Log::info("ScanOperation: Scan of '{}' canceled.", remotePath_.generic_string());
+    if (adoptCancelState)
+        enterState(OperationState::Canceled);
+    return {};
+}
+
+SecureShell::ProcessingStrand* ScanOperation::strand() const
+{
+    return sftp_->strand();
+}
\ No newline at end of file
diff --git a/events/source/events/CMakeLists.txt b/events/source/events/CMakeLists.txt
index 839eb72a..543ac5cd 100644
--- a/events/source/events/CMakeLists.txt
+++ b/events/source/events/CMakeLists.txt
@@ -1,6 +1,15 @@
 add_library(events STATIC app_event_context.cpp)
 
-target_include_directories(events 
+target_include_directories(events
     PUBLIC "${CMAKE_CURRENT_LIST_DIR}/../../include")
 
-target_link_libraries(events PUBLIC nui-events PRIVATE core-target)
\ No newline at end of file
+target_link_libraries(events PUBLIC nui-events PRIVATE core-target)
+
+if (EMSCRIPTEN)
+    set_target_properties(
+        nui-events
+        PROPERTIES
+            LINK_FLAGS "-sMEMORY64=1"
+            COMPILE_FLAGS "-sMEMORY64=1"
+    )
+endif()
\ No newline at end of file
diff --git a/frontend/include/frontend/session_components/operation_queue.hpp b/frontend/include/frontend/session_components/operation_queue.hpp
index 7e5b7634..1ad1842d 100644
--- a/frontend/include/frontend/session_components/operation_queue.hpp
+++ b/frontend/include/frontend/session_components/operation_queue.hpp
@@ -15,18 +15,28 @@ class OperationQueue
         Persistence::StateHolder* stateHolder,
         FrontendEvents* events,
         std::string persistenceSessionName,
-        std::string id,
-        ConfirmDialog* confirmDialog,
-        FileEngine* fileEngine);
+        std::string sessionId,
+        ConfirmDialog* confirmDialog);
 
     ROAR_PIMPL_SPECIAL_FUNCTIONS(OperationQueue);
 
-    void enqueueDownload(std::filesystem::path const& remotePath, std::filesystem::path const& localPath);
-    void enqueueDownloadSet(std::vector<std::pair<std::filesystem::path, std::filesystem::path>> const& downloads);
-    void enqueueUpload(std::filesystem::path const& localPath, std::filesystem::path const& remotePath);
-    void enqueueUploadSet(std::vector<std::pair<std::filesystem::path, std::filesystem::path>> const& uploads);
-    void enqueueRename(std::filesystem::path const& oldPath, std::filesystem::path const& newPath);
-    void enqueueDelete(std::filesystem::path const& path);
+    void setFileEngine(FileEngine* fileEngine);
+
+    void enqueueDownload(
+        std::filesystem::path const& remotePath,
+        std::filesystem::path const& localPath,
+        std::function<void(std::optional<Ids::OperationId> const&)> onComplete);
+    void enqueueUpload(
+        std::filesystem::path const& localPath,
+        std::filesystem::path const& remotePath,
+        std::function<void(std::optional<Ids::OperationId> const&)> onComplete);
+    void enqueueRename(
+        std::filesystem::path const& oldPath,
+        std::filesystem::path const& newPath,
+        std::function<void(std::optional<Ids::OperationId> const&)> onComplete);
+    void enqueueDelete(
+        std::filesystem::path const& path,
+        std::function<void(std::optional<Ids::OperationId> const&)> onComplete);
 
     Nui::ElementRenderer operator()();
 
diff --git a/frontend/include/frontend/terminal/channel_interface.hpp b/frontend/include/frontend/terminal/channel_interface.hpp
index e52b9770..b8dbded0 100644
--- a/frontend/include/frontend/terminal/channel_interface.hpp
+++ b/frontend/include/frontend/terminal/channel_interface.hpp
@@ -17,5 +17,5 @@ class ChannelInterface
     virtual void resize(int cols, int rows) = 0;
     virtual void dispose(std::function<void()> onExit) = 0;
     virtual Ids::ChannelId channelId() const = 0;
-    ~ChannelInterface() = default;
+    virtual ~ChannelInterface() = default;
 };
\ No newline at end of file
diff --git a/frontend/include/frontend/terminal/file_engine.hpp b/frontend/include/frontend/terminal/file_engine.hpp
index 329b8646..aa47ada5 100644
--- a/frontend/include/frontend/terminal/file_engine.hpp
+++ b/frontend/include/frontend/terminal/file_engine.hpp
@@ -35,9 +35,10 @@ class FileEngine
         std::string const& localPath,
         std::string const& remotePath) */
 
-    // TODO:
-    // virtual Ids::OperationId
-    // addDownload(std::filesystem::path const& remotePath, std::filesystem::path const& localPath) = 0;
+    virtual void addDownload(
+        std::filesystem::path const& remotePath,
+        std::filesystem::path const& localPath,
+        std::function<void(std::optional<Ids::OperationId>)> onOperationCreated) = 0;
 
     virtual void dispose() = 0;
 };
\ No newline at end of file
diff --git a/frontend/include/frontend/terminal/sftp_file_engine.hpp b/frontend/include/frontend/terminal/sftp_file_engine.hpp
index 9f86f43c..7981a503 100644
--- a/frontend/include/frontend/terminal/sftp_file_engine.hpp
+++ b/frontend/include/frontend/terminal/sftp_file_engine.hpp
@@ -18,6 +18,11 @@ class SftpFileEngine : public FileEngine
 
     std::optional<Ids::ChannelId> release();
 
+    void addDownload(
+        std::filesystem::path const& remotePath,
+        std::filesystem::path const& localPath,
+        std::function<void(std::optional<Ids::OperationId>)> onOperationCreated) override;
+
   private:
     void lazyOpen(std::function<void(std::optional<Ids::ChannelId> const&)> const& onOpen);
 
diff --git a/frontend/source/frontend/CMakeLists.txt b/frontend/source/frontend/CMakeLists.txt
index 679415ab..6040f8fe 100644
--- a/frontend/source/frontend/CMakeLists.txt
+++ b/frontend/source/frontend/CMakeLists.txt
@@ -29,6 +29,7 @@ target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_SOURCE_DIR}/frontend/
 target_link_libraries(
     ${PROJECT_NAME}
     PRIVATE
+        core-target
         nui-frontend
         nui-file-explorer
         ui5
@@ -42,6 +43,26 @@ target_link_libraries(
         ids
 )
 
+function(set_memory64_flags)
+    cmake_parse_arguments(
+        MEM64
+        ""
+        "TARGETS"
+        ""
+        ${ARGN}
+    )
+    foreach(target IN LISTS MEM64_TARGETS)
+        set_target_properties(
+            ${target}
+            PROPERTIES
+                LINK_FLAGS "-sMEMORY64=1"
+                COMPILE_FLAGS "-sMEMORY64=1"
+        )
+    endforeach()
+endfunction()
+
+set_memory64_flags(TARGETS nui-frontend nlohmann_json::nlohmann_json)
+
 nui_prepare_emscripten_target(
     TARGET
         ${PROJECT_NAME}
@@ -55,12 +76,15 @@ nui_prepare_emscripten_target(
     EMSCRIPTEN_LINK_OPTIONS
         -sEXPORTED_FUNCTIONS=_frontendMain
         -sALLOW_MEMORY_GROWTH=1
+        -sMEMORY64=1
+        -sWASM_BIGINT
         -fexceptions
         # -O2
         -g
         # or other options, see emscripten docs.
     EMSCRIPTEN_COMPILE_OPTIONS
         # -O3
+        -sMEMORY64=1
         -g
     CXX_STANDARD
         23
diff --git a/frontend/source/frontend/session.cpp b/frontend/source/frontend/session.cpp
index 5331c0cc..322fda68 100644
--- a/frontend/source/frontend/session.cpp
+++ b/frontend/source/frontend/session.cpp
@@ -110,7 +110,7 @@ struct Session::Implementation
         , currentPath{}
         , fileEngine{}
         , preNavigatePath{}
-        , operationQueue{this->stateHolder, this->events, this->initialName, this->id, this->confirmDialog, this->fileEngine.get()}
+        , operationQueue{this->stateHolder, this->events, this->initialName, this->id, this->confirmDialog}
         , operationQueueElement{}
         , layoutHost{}
         , layoutName{std::move(layoutName)}
@@ -308,7 +308,25 @@ void Session::setupFileGrid()
                  });
 
                  Log::info("Downloading items");
-                 impl_->operationQueue.enqueueDownloadSet(downloadItems);
+                 for (const auto& item : downloadItems)
+                 {
+                     Log::info("Downloading '{}' to '{}'", item.first.generic_string(), item.second.generic_string());
+                     impl_->operationQueue.enqueueDownload(
+                         item.first, item.second, [this](std::optional<Ids::OperationId> const& opId) {
+                             if (!opId)
+                             {
+                                 Log::error("Failed to create download operation");
+                                 impl_->confirmDialog->open({
+                                     .state = ConfirmDialog::State::Negative,
+                                     .headerText = "Download Failed",
+                                     .text = "Failed to create download operation",
+                                     .buttons = ConfirmDialog::Button::Ok,
+                                 });
+                                 return;
+                             }
+                             Log::info("Download operation created with id: {}", opId->value());
+                         });
+                 }
              }});
     });
 
@@ -544,6 +562,7 @@ void Session::openSftp()
             Log::info("Opening SFTP by default");
             impl_->fileEngine =
                 std::make_unique<SftpFileEngine>(static_cast<SshTerminalEngine*>(&impl_->terminal.value()->engine()));
+            impl_->operationQueue.setFileEngine(impl_->fileEngine.get());
             navigateTo(opts.defaultDirectory.value_or("/"));
         }
     }
diff --git a/frontend/source/frontend/session_components/operation_queue.cpp b/frontend/source/frontend/session_components/operation_queue.cpp
index 4ec7513d..647a1d3e 100644
--- a/frontend/source/frontend/session_components/operation_queue.cpp
+++ b/frontend/source/frontend/session_components/operation_queue.cpp
@@ -1,8 +1,10 @@
 #include <frontend/session_components/operation_queue.hpp>
 #include <frontend/components/progress_bar.hpp>
 
+#include <log/log.hpp>
 #include <nui/frontend/attributes.hpp>
 #include <nui/frontend/elements.hpp>
+#include <nui/rpc.hpp>
 #include <fmt/format.h>
 
 struct OperationQueue::Implementation
@@ -10,45 +12,54 @@ struct OperationQueue::Implementation
     Persistence::StateHolder* stateHolder;
     FrontendEvents* events;
     std::string persistenceSessionName;
-    std::string id;
+    std::string sessionId;
     ConfirmDialog* confirmDialog;
     FileEngine* fileEngine;
 
+    Nui::RpcClient::AutoUnregister onUpdate;
+
     Implementation(
         Persistence::StateHolder* stateHolder,
         FrontendEvents* events,
         std::string persistenceSessionName,
-        std::string id,
-        ConfirmDialog* confirmDialog,
-        FileEngine* fileEngine)
+        std::string sessionId,
+        ConfirmDialog* confirmDialog)
         : stateHolder{stateHolder}
         , events{events}
         , persistenceSessionName{std::move(persistenceSessionName)}
-        , id{std::move(id)}
+        , sessionId{std::move(sessionId)}
         , confirmDialog{confirmDialog}
-        , fileEngine{fileEngine}
-    {}
+        , fileEngine{nullptr}
+    {
+        onUpdate =
+            Nui::RpcClient::autoRegisterFunction("OperationQueue::" + sessionId + "::onOperationAdded", [](Nui::val) {
+                // TODO:
+            });
+    }
 };
 
 OperationQueue::OperationQueue(
     Persistence::StateHolder* stateHolder,
     FrontendEvents* events,
     std::string persistenceSessionName,
-    std::string id,
-    ConfirmDialog* confirmDialog,
-    FileEngine* fileEngine)
+    std::string sessionId,
+    ConfirmDialog* confirmDialog)
     : impl_{
           std::make_unique<Implementation>(
               stateHolder,
               events,
               std::move(persistenceSessionName),
-              std::move(id),
-              confirmDialog,
-              fileEngine),
+              std::move(sessionId),
+              confirmDialog),
       }
 {}
 ROAR_PIMPL_SPECIAL_FUNCTIONS_IMPL(OperationQueue);
 
+void OperationQueue::setFileEngine(FileEngine* fileEngine)
+{
+    impl_->fileEngine = fileEngine;
+}
+
 Nui::ElementRenderer OperationQueue::operator()()
 {
     using namespace Nui::Elements;
@@ -60,31 +71,56 @@ Nui::ElementRenderer OperationQueue::operator()()
     }("OPERATION QUEUE HERE NEW");
 }
 
-void OperationQueue::enqueueDownload(std::filesystem::path const& remotePath, std::filesystem::path const& localPath)
+void OperationQueue::enqueueDownload(
+    std::filesystem::path const& remotePath,
+    std::filesystem::path const& localPath,
+    std::function<void(std::optional<Ids::OperationId> const&)> onComplete)
+{
+    if (!impl_->fileEngine)
+    {
+        Log::error("No file engine set for operation queue, cannot enqueue download");
+        onComplete(std::nullopt);
+        return;
+    }
+
+    Log::info("Frontend Operation Queue download: {} -> {}", remotePath.generic_string(), localPath.generic_string());
+    impl_->fileEngine->addDownload(remotePath, localPath, std::move(onComplete));
+}
+void OperationQueue::enqueueUpload(
+    std::filesystem::path const& localPath,
+    std::filesystem::path const& remotePath,
+    std::function<void(std::optional<Ids::OperationId> const&)> onComplete)
 {
-    // fileEngine->
+    if (!impl_->fileEngine)
+    {
+        Log::error("No file engine set for operation queue, cannot enqueue download");
+        onComplete(std::nullopt);
+        return;
+    }
+    // TODO: Implement
 }
-void OperationQueue::enqueueUpload(std::filesystem::path const& localPath, std::filesystem::path const& remotePath)
-{}
-void OperationQueue::enqueueRename(std::filesystem::path const& oldPath, std::filesystem::path const& newPath)
-{}
-void OperationQueue::enqueueDelete(std::filesystem::path const& path)
-{}
-void OperationQueue::enqueueDownloadSet(
-    std::vector<std::pair<std::filesystem::path, std::filesystem::path>> const& downloads)
+void OperationQueue::enqueueRename(
+    std::filesystem::path const& oldPath,
+    std::filesystem::path const& newPath,
+    std::function<void(std::optional<Ids::OperationId> const&)> onComplete)
 {
-    // TODO: Do this as a group operation. For now, just iterate and enqueue each one.
-    for (const auto& [remotePath, localPath] : downloads)
+    if (!impl_->fileEngine)
     {
-        enqueueDownload(remotePath, localPath);
+        Log::error("No file engine set for operation queue, cannot enqueue download");
+        onComplete(std::nullopt);
+        return;
     }
+    // TODO: Implement
 }
-void OperationQueue::enqueueUploadSet(
-    std::vector<std::pair<std::filesystem::path, std::filesystem::path>> const& uploads)
+void OperationQueue::enqueueDelete(
+    std::filesystem::path const& path,
+    std::function<void(std::optional<Ids::OperationId> const&)> onComplete)
 {
-    // TODO: Do this as a group operation. For now, just iterate and enqueue each one.
-    for (const auto& [remotePath, localPath] : uploads)
+    if (!impl_->fileEngine)
     {
-        enqueueDownload(remotePath, localPath);
+        Log::error("No file engine set for operation queue, cannot enqueue download");
+        onComplete(std::nullopt);
+        return;
     }
+    // TODO: Implement
 }
\ No newline at end of file
diff --git a/frontend/source/frontend/terminal/sftp_file_engine.cpp b/frontend/source/frontend/terminal/sftp_file_engine.cpp
index 14f98a49..80a3d5eb 100644
--- a/frontend/source/frontend/terminal/sftp_file_engine.cpp
+++ b/frontend/source/frontend/terminal/sftp_file_engine.cpp
@@ -156,4 +156,46 @@ void SftpFileEngine::createFile(std::filesystem::path const& path, std::function
             channelId.value().value(),
             path.generic_string());
     });
+}
+
+void SftpFileEngine::addDownload(
+    std::filesystem::path const& remotePath,
+    std::filesystem::path const& localPath,
+    std::function<void(std::optional<Ids::OperationId>)> onOperationCreated)
+{
+    Log::info("Requesting to add download: {} -> {}", remotePath.generic_string(), localPath.generic_string());
+    lazyOpen([this, remotePath, localPath, onOperationCreated = std::move(onOperationCreated)](auto const& channelId) {
+        if (!channelId)
+        {
+            Log::error("Cannot add download, no channel");
+            onOperationCreated(std::nullopt);
+            return;
+        }
+
+        const auto operationId = Ids::generateOperationId();
+
+        Log::info(
+            "Adding download (with ID '{}'): {} -> {}",
+            operationId.value(),
+            remotePath.generic_string(),
+            localPath.generic_string());
+
+        Nui::RpcClient::callWithBackChannel(
+            fmt::format("Session::{}::sftp::addDownload", impl_->engine->sshSessionId().value()),
+            [onOperationCreated = std::move(onOperationCreated), operationId](Nui::val val) {
+                Nui::Console::log(val);
+
+                if (val.hasOwnProperty("error"))
+                {
+                    Log::error("(Frontend) Failed to add download: {}", val["error"].as<std::string>());
+                    onOperationCreated(std::nullopt);
+                    return;
+                }
+                onOperationCreated(operationId);
+            },
+            channelId.value().value(),
+            operationId.value(),
+            remotePath.generic_string(),
+            localPath.generic_string());
+    });
 }
\ No newline at end of file
diff --git a/log/source/log/CMakeLists.txt b/log/source/log/CMakeLists.txt
index d46e2430..c3c144fd 100644
--- a/log/source/log/CMakeLists.txt
+++ b/log/source/log/CMakeLists.txt
@@ -14,6 +14,12 @@ if (EMSCRIPTEN)
             fmt
             nui-frontend
     )
+    set_target_properties(
+        fmt
+        PROPERTIES
+            LINK_FLAGS "-sMEMORY64=1"
+            COMPILE_FLAGS "-sMEMORY64=1"
+    )
 else()
     target_link_libraries(
         log
diff --git a/nui-file-explorer/source/nui-file-explorer/CMakeLists.txt b/nui-file-explorer/source/nui-file-explorer/CMakeLists.txt
index c218852c..cea4d443 100644
--- a/nui-file-explorer/source/nui-file-explorer/CMakeLists.txt
+++ b/nui-file-explorer/source/nui-file-explorer/CMakeLists.txt
@@ -1,3 +1,5 @@
+option(NUI_FILE_EXPLORER_MEMORY64 "Enable MEMORY64 for nui-file-explorer" OFF)
+
 add_library(
     nui-file-explorer
     STATIC
@@ -15,4 +17,9 @@ target_include_directories(
     nui-file-explorer
     PUBLIC
         ${CMAKE_CURRENT_LIST_DIR}/../../include
-)
\ No newline at end of file
+)
+
+if (NUI_FILE_EXPLORER_MEMORY64)
+    target_compile_options(nui-file-explorer PRIVATE -sMEMORY64=1)
+    target_link_options(nui-file-explorer PRIVATE -sMEMORY64=1)
+endif()
\ No newline at end of file

From acd5c961ca038354fb4aa7de59f3c3c5c8612366 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sat, 11 Oct 2025 22:51:43 +0200
Subject: [PATCH 33/42] Added enum string converter.

---
 .../include/utility/enum_string_convert.hpp   | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 utility/include/utility/enum_string_convert.hpp

diff --git a/utility/include/utility/enum_string_convert.hpp b/utility/include/utility/enum_string_convert.hpp
new file mode 100644
index 00000000..dc51d8d1
--- /dev/null
+++ b/utility/include/utility/enum_string_convert.hpp
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <utility/describe.hpp>
+
+#include <string>
+#include <stdexcept>
+
+namespace Utility
+{
+    template <typename EnumType>
+    std::string enumToString(EnumType const& enumValue)
+    {
+        char const* result = nullptr;
+        boost::mp11::mp_for_each<boost::describe::describe_enumerators<EnumType>>([&result, &enumValue](auto desc) {
+            if (enumValue == desc.value)
+                result = desc.name;
+        });
+
+        if (result == nullptr)
+            throw std::invalid_argument("Invalid enum value");
+        return result;
+    }
+
+    template <typename EnumType>
+    EnumType enumFromString(std::string const& str)
+    {
+        EnumType enumValue;
+        bool found = false;
+        boost::mp11::mp_for_each<boost::describe::describe_enumerators<EnumType>>(
+            [&found, &enumValue, &str](auto desc) {
+                if (str == desc.name)
+                {
+                    enumValue = desc.value;
+                    found = true;
+                }
+            });
+
+        if (!found)
+            throw std::invalid_argument("Invalid enum string: " + str);
+
+        return enumValue;
+    }
+}
\ No newline at end of file

From a212f717fa77b696a0f175a007482c45b46fa4d6 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sat, 11 Oct 2025 22:51:51 +0200
Subject: [PATCH 34/42] Added include.

---
 utility/include/utility/describe.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/utility/include/utility/describe.hpp b/utility/include/utility/describe.hpp
index 59cc6af8..0a08f6e3 100644
--- a/utility/include/utility/describe.hpp
+++ b/utility/include/utility/describe.hpp
@@ -1,4 +1,5 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
 #include <boost/describe.hpp>
+#include <boost/mp11/algorithm.hpp>
 #pragma clang diagnostic pop
\ No newline at end of file

From 49a7993606d34dcca3c6e972528fc8bce54cfc27 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sat, 11 Oct 2025 22:52:02 +0200
Subject: [PATCH 35/42] Added utility to convert naming convention.

---
 .../utility/convert_naming_convention.hpp     | 193 ++++++++++++++++++
 1 file changed, 193 insertions(+)
 create mode 100644 utility/include/utility/convert_naming_convention.hpp

diff --git a/utility/include/utility/convert_naming_convention.hpp b/utility/include/utility/convert_naming_convention.hpp
new file mode 100644
index 00000000..63f6d17a
--- /dev/null
+++ b/utility/include/utility/convert_naming_convention.hpp
@@ -0,0 +1,193 @@
+#pragma once
+
+#include <vector>
+#include <string>
+
+namespace Utility
+{
+    struct SegmentedString
+    {
+        std::vector<std::string> normalizedSegments;
+
+        std::string camelCase() const
+        {
+            if (normalizedSegments.empty())
+                return {};
+
+            std::string result = normalizedSegments[0];
+            for (size_t i = 1; i < normalizedSegments.size(); ++i)
+            {
+                if (!normalizedSegments[i].empty())
+                {
+                    result += std::toupper(normalizedSegments[i][0]);
+                    result += normalizedSegments[i].substr(1);
+                }
+            }
+            return result;
+        }
+
+        std::string pascalCase() const
+        {
+            if (normalizedSegments.empty())
+                return {};
+
+            std::string result;
+            for (const auto& segment : normalizedSegments)
+            {
+                if (!segment.empty())
+                {
+                    result += std::toupper(segment[0]);
+                    result += segment.substr(1);
+                }
+            }
+            return result;
+        }
+
+        std::string snakeCase() const
+        {
+            if (normalizedSegments.empty())
+                return {};
+
+            std::string result = normalizedSegments[0];
+            for (size_t i = 1; i < normalizedSegments.size(); ++i)
+            {
+                result += '_';
+                result += normalizedSegments[i];
+            }
+            return result;
+        }
+
+        std::string screamingSnakeCase() const
+        {
+            if (normalizedSegments.empty())
+                return {};
+
+            std::string result = normalizedSegments[0];
+            for (size_t i = 1; i < normalizedSegments.size(); ++i)
+            {
+                result += '_';
+                for (auto const& ch : normalizedSegments[i])
+                    result += std::toupper(ch);
+            }
+            return result;
+        }
+
+        std::string kebabCase() const
+        {
+            if (normalizedSegments.empty())
+                return {};
+
+            std::string result = normalizedSegments[0];
+            for (size_t i = 1; i < normalizedSegments.size(); ++i)
+            {
+                result += '-';
+                result += normalizedSegments[i];
+            }
+            return result;
+        }
+
+        std::string joined(const std::string& delimiter) const
+        {
+            if (normalizedSegments.empty())
+                return {};
+
+            std::string result = normalizedSegments[0];
+            for (size_t i = 1; i < normalizedSegments.size(); ++i)
+            {
+                result += delimiter;
+                result += normalizedSegments[i];
+            }
+            return result;
+        }
+    };
+
+    inline SegmentedString splitByCamelCase(std::string const& input)
+    {
+        SegmentedString result;
+        if (input.empty())
+            return result;
+
+        std::string currentSegment{};
+        for (auto const& ch : input)
+        {
+            if (std::isupper(ch) && !currentSegment.empty())
+            {
+                result.normalizedSegments.push_back(currentSegment);
+                currentSegment.clear();
+            }
+            currentSegment += std::tolower(ch);
+        }
+        if (!currentSegment.empty())
+            result.normalizedSegments.push_back(currentSegment);
+        return result;
+    }
+
+    inline SegmentedString splitByPascalCase(std::string const& input)
+    {
+        SegmentedString result;
+        if (input.empty())
+            return result;
+
+        std::string currentSegment{};
+        for (auto const& ch : input)
+        {
+            if (std::isupper(ch) && !currentSegment.empty())
+            {
+                result.normalizedSegments.push_back(currentSegment);
+                currentSegment.clear();
+            }
+            currentSegment += std::tolower(ch);
+        }
+        if (!currentSegment.empty())
+            result.normalizedSegments.push_back(currentSegment);
+        return result;
+    }
+
+    inline SegmentedString splitBySnakeCase(std::string const& input)
+    {
+        SegmentedString result;
+        if (input.empty())
+            return result;
+
+        std::string currentSegment{};
+        for (auto const& ch : input)
+        {
+            if (ch == '_')
+            {
+                result.normalizedSegments.push_back(currentSegment);
+                currentSegment.clear();
+            }
+            else
+            {
+                currentSegment += std::tolower(ch);
+            }
+        }
+        if (!currentSegment.empty())
+            result.normalizedSegments.push_back(currentSegment);
+        return result;
+    }
+
+    inline SegmentedString splitByKebabCase(std::string const& input)
+    {
+        SegmentedString result;
+        if (input.empty())
+            return result;
+
+        std::string currentSegment{};
+        for (auto const& ch : input)
+        {
+            if (ch == '-')
+            {
+                result.normalizedSegments.push_back(currentSegment);
+                currentSegment.clear();
+            }
+            else
+            {
+                currentSegment += std::tolower(ch);
+            }
+        }
+        if (!currentSegment.empty())
+            result.normalizedSegments.push_back(currentSegment);
+        return result;
+    }
+}
\ No newline at end of file

From 104aa761fcbb9f59f55f47e2f0f6334ecab64749 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sat, 11 Oct 2025 22:52:28 +0200
Subject: [PATCH 36/42] Introduced spaceship operator to id.

---
 ids/include/ids/id.hpp | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/ids/include/ids/id.hpp b/ids/include/ids/id.hpp
index b05b55a1..1ba3b566 100644
--- a/ids/include/ids/id.hpp
+++ b/ids/include/ids/id.hpp
@@ -39,10 +39,7 @@ namespace Ids
             return id_;
         }
 
-        friend bool operator==(Id const& lhs, Id const& rhs)
-        {
-            return lhs.id_ == rhs.id_;
-        }
+        friend std::strong_ordering operator<=>(Id const& lhs, Id const& rhs) = default;
 
         bool isValid() const
         {

From 3e9e8ca93d964dee55e16dfbcc6cabf6e2c21112 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sat, 11 Oct 2025 22:52:46 +0200
Subject: [PATCH 37/42] Made progress bar work properly.

---
 frontend/include/frontend/components/progress_bar.hpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/frontend/include/frontend/components/progress_bar.hpp b/frontend/include/frontend/components/progress_bar.hpp
index f4540060..3eb497c1 100644
--- a/frontend/include/frontend/components/progress_bar.hpp
+++ b/frontend/include/frontend/components/progress_bar.hpp
@@ -8,7 +8,6 @@ class ProgressBar
   public:
     struct Settings
     {
-        std::string id;
         std::string height{"30px"};
         long long min{0};
         long long max{100};
@@ -19,7 +18,7 @@ class ProgressBar
 
     ROAR_PIMPL_SPECIAL_FUNCTIONS(ProgressBar);
 
-    Nui::ElementRenderer operator()();
+    Nui::ElementRenderer operator()() const;
 
     /**
      * Set the progress of the progress bar.
@@ -27,6 +26,9 @@ class ProgressBar
      */
     void setProgress(long long current);
 
+  private:
+    void updateText();
+
   private:
     struct Implementation;
     std::unique_ptr<Implementation> impl_;

From b3d148e6a4e4f75cab16fc6787eb09e867685b8a Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sat, 11 Oct 2025 22:53:18 +0200
Subject: [PATCH 38/42] Made Initial download operation ui happen.

---
 .../backend/sftp/download_operation.hpp       |   4 +-
 backend/include/backend/sftp/operation.hpp    |  56 +-
 .../include/backend/sftp/operation_queue.hpp  |  36 +-
 .../backend/sftp/download_operation.cpp       |   4 +-
 .../source/backend/sftp/operation_queue.cpp   | 108 +++-
 .../frontend/observed_random_access_map.hpp   | 100 ++++
 .../session_components/operation_queue.hpp    |   3 +-
 .../session_components/session_options.hpp    |   2 +-
 .../frontend/components/progress_bar.cpp      |  70 +--
 frontend/source/frontend/session.cpp          |  23 +-
 .../session_components/operation_queue.cpp    | 479 +++++++++++++++++-
 .../session_components/session_options.cpp    |  12 +-
 .../file_operations/download_progress.hpp     |  24 +
 .../file_operations/operation_added.hpp       |  12 +-
 .../file_operations/operation_completed.hpp   |  83 +++
 .../file_operations/operation_error.hpp       |  95 ++++
 .../file_operations/operation_error_type.hpp  |  49 ++
 .../file_operations/operation_state.hpp       |  33 ++
 .../file_operations/operation_type.hpp        |  24 +-
 shared_data/source/shared_data/CMakeLists.txt |  14 +-
 .../file_operations/download_progress.cpp     |  21 +
 .../file_operations/operation_added.cpp       |   5 +
 .../file_operations/operation_added_val.cpp   |  21 -
 .../file_operations/operation_completed.cpp   |  54 ++
 .../file_operations/operation_error.cpp       |  49 ++
 .../file_operations/operation_state.cpp       |  13 +
 .../file_operations/operation_type.cpp        |  34 +-
 .../file_operations/operation_type_val.cpp    |  47 --
 static/styles/main.css                        |   1 +
 static/styles/operation_queue.css             | 185 +++++++
 30 files changed, 1352 insertions(+), 309 deletions(-)
 create mode 100644 frontend/include/frontend/observed_random_access_map.hpp
 create mode 100644 shared_data/include/shared_data/file_operations/download_progress.hpp
 create mode 100644 shared_data/include/shared_data/file_operations/operation_completed.hpp
 create mode 100644 shared_data/include/shared_data/file_operations/operation_error.hpp
 create mode 100644 shared_data/include/shared_data/file_operations/operation_error_type.hpp
 create mode 100644 shared_data/include/shared_data/file_operations/operation_state.hpp
 create mode 100644 shared_data/source/shared_data/file_operations/download_progress.cpp
 delete mode 100644 shared_data/source/shared_data/file_operations/operation_added_val.cpp
 create mode 100644 shared_data/source/shared_data/file_operations/operation_completed.cpp
 create mode 100644 shared_data/source/shared_data/file_operations/operation_error.cpp
 create mode 100644 shared_data/source/shared_data/file_operations/operation_state.cpp
 delete mode 100644 shared_data/source/shared_data/file_operations/operation_type_val.cpp
 create mode 100644 static/styles/operation_queue.css

diff --git a/backend/include/backend/sftp/download_operation.hpp b/backend/include/backend/sftp/download_operation.hpp
index 9479e2c0..199525e1 100644
--- a/backend/include/backend/sftp/download_operation.hpp
+++ b/backend/include/backend/sftp/download_operation.hpp
@@ -13,7 +13,7 @@ class DownloadOperation : public Operation
   public:
     struct DownloadOperationOptions
     {
-        std::function<void(std::int64_t min, std::int64_t max, std::int64_t current)> progressCallback =
+        std::function<void(std::uint64_t min, std::uint64_t max, std::uint64_t current)> progressCallback =
             [](auto, auto, auto) {};
         std::filesystem::path remotePath{};
         std::filesystem::path localPath{};
@@ -92,7 +92,7 @@ class DownloadOperation : public Operation
     std::filesystem::path remotePath_;
     std::filesystem::path localPath_;
     std::string tempFileSuffix_;
-    std::function<void(std::int64_t min, std::int64_t max, std::int64_t current)> progressCallback_;
+    std::function<void(std::uint64_t min, std::uint64_t max, std::uint64_t current)> progressCallback_;
     bool mayOverwrite_;
     bool reserveSpace_;
     bool tryContinue_;
diff --git a/backend/include/backend/sftp/operation.hpp b/backend/include/backend/sftp/operation.hpp
index f339359b..751eb805 100644
--- a/backend/include/backend/sftp/operation.hpp
+++ b/backend/include/backend/sftp/operation.hpp
@@ -3,6 +3,9 @@
 #include <ssh/sftp_error.hpp>
 #include <utility/describe.hpp>
 #include <shared_data/file_operations/operation_type.hpp>
+#include <shared_data/file_operations/operation_error_type.hpp>
+#include <shared_data/file_operations/operation_error.hpp>
+#include <shared_data/file_operations/operation_state.hpp>
 #include <ssh/async/processing_strand.hpp>
 #include <log/log.hpp>
 
@@ -10,30 +13,6 @@
 
 #include <optional>
 #include <expected>
-#include <mutex>
-
-BOOST_DEFINE_ENUM_CLASS(
-    OperationErrorType,
-    FileExists,
-    FileNotFound,
-    OpenFailure,
-    FileStreamExpired,
-    FileStatFailed,
-    SftpError,
-    InvalidPath,
-    RenameFailure,
-    CannotSetFilePermissions,
-    FutureTimeout,
-    OperationNotPrepared,
-    CannotFinalizeDuringRead,
-    InvalidOptionsKey,
-    TargetFileNotGood,
-    CannotWorkCompletedOperation,
-    CannotWorkFailedOperation,
-    CannotWorkCanceledOperation,
-    UnknownWorkState,
-    InvalidOperationState,
-    OperationNotPossibleOnFileType);
 
 class Operation
 {
@@ -48,7 +27,8 @@ class Operation
 
     virtual ~Operation() = default;
 
-    using ErrorType = OperationErrorType;
+    using ErrorType = SharedData::OperationErrorType;
+    using Error = SharedData::OperationError;
 
     virtual SharedData::OperationType type() const = 0;
 
@@ -57,20 +37,6 @@ class Operation
 
     virtual SecureShell::ProcessingStrand* strand() const = 0;
 
-    struct Error
-    {
-        ErrorType type;
-        std::optional<SecureShell::SftpError> sftpError = std::nullopt;
-
-        std::string toString() const
-        {
-            const auto enumString = boost::describe::enum_to_string(type, "INVALID_ENUM_VALUE");
-            if (sftpError.has_value())
-                return fmt::format("{}: {}", enumString, sftpError->toString());
-            return enumString;
-        }
-    };
-
     template <typename FunctionT>
     bool perform(FunctionT&& func)
     {
@@ -88,17 +54,7 @@ class Operation
         return id_;
     }
 
-    enum class OperationState
-    {
-        NotStarted,
-        Preparing,
-        Prepared,
-        Running,
-        Finalizing,
-        Completed,
-        Canceled,
-        Failed,
-    };
+    using OperationState = SharedData::OperationState;
 
     OperationState state() const
     {
diff --git a/backend/include/backend/sftp/operation_queue.hpp b/backend/include/backend/sftp/operation_queue.hpp
index 119dc1cd..903ea2e8 100644
--- a/backend/include/backend/sftp/operation_queue.hpp
+++ b/backend/include/backend/sftp/operation_queue.hpp
@@ -6,8 +6,8 @@
 #include <nui/rpc.hpp>
 #include <ids/ids.hpp>
 #include <backend/rpc_helper.hpp>
+#include <shared_data/file_operations/operation_completed.hpp>
 
-#include <vector>
 #include <deque>
 #include <filesystem>
 #include <memory>
@@ -18,23 +18,11 @@ class OperationQueue
     , public std::enable_shared_from_this<OperationQueue>
 {
   public:
-    enum class CompletionReason
-    {
-        Completed,
-        Canceled,
-        Failed
-    };
-
-    struct CompletedOperation
-    {
-        CompletionReason reason;
-        Ids::OperationId id;
-        std::chrono::system_clock::time_point completionTime;
-        std::optional<std::filesystem::path> localPath{std::nullopt};
-        std::optional<std::filesystem::path> remotePath{std::nullopt};
-        std::optional<Operation::Error> error{std::nullopt};
-    };
+    using Error = SharedData::OperationErrorType;
+    using OperationCompleted = SharedData::OperationCompleted;
+    using CompletionReason = SharedData::OperationCompletionReason;
 
+  public:
     OperationQueue(
         boost::asio::any_io_executor executor,
         std::shared_ptr<boost::asio::strand<boost::asio::any_io_executor>> strand,
@@ -44,8 +32,6 @@ class OperationQueue
         Ids::SessionId sessionId,
         int parallelism = 1);
 
-    using Error = OperationErrorType;
-
     void cancelAll();
     void cancel(Ids::OperationId id);
 
@@ -64,21 +50,11 @@ class OperationQueue
         std::filesystem::path const& remotePath);
 
   private:
-    template <typename T>
-    void call(std::string event, Ids::OperationId id, T&& data)
-    {
-        hub_->callRemote(
-            fmt::format("OperationQueue::{}::{}", sessionId_.value(), event),
-            nlohmann::json{
-                {"operationId", id.value()},
-                {"payload", std::forward<T>(data)},
-            });
-    }
+    void completeOperation(OperationCompleted&& operationCompleted);
 
   private:
     Persistence::SftpOptions sftpOpts_{};
     Ids::SessionId sessionId_{};
     std::deque<std::pair<Ids::OperationId, std::unique_ptr<Operation>>> operations_{};
-    std::vector<CompletedOperation> completedOperations_{};
     int parallelism_{1};
 };
diff --git a/backend/source/backend/sftp/download_operation.cpp b/backend/source/backend/sftp/download_operation.cpp
index 0f3c2d37..2c32788a 100644
--- a/backend/source/backend/sftp/download_operation.cpp
+++ b/backend/source/backend/sftp/download_operation.cpp
@@ -166,13 +166,13 @@ std::expected<bool, DownloadOperation::Error> DownloadOperation::readOnce()
                     tellp = static_cast<uint64_t>(localFile_.tellp());
                     fileSize = fileSize_;
                     good = localFile_.good();
-                    progressCallback_(0, fileSize, tellp);
+                    progressCallback_(0ull, fileSize, tellp);
                 }
                 if (!good)
                 {
                     Log::error("DownloadOperation read cycle stopped: localFile_.good() == false");
                     std::ignore = enterErrorState({
-                        .type = OperationErrorType::TargetFileNotGood,
+                        .type = SharedData::OperationErrorType::TargetFileNotGood,
                     });
                     return doContinue = false;
                 }
diff --git a/backend/source/backend/sftp/operation_queue.cpp b/backend/source/backend/sftp/operation_queue.cpp
index d31c6c39..141fa2a6 100644
--- a/backend/source/backend/sftp/operation_queue.cpp
+++ b/backend/source/backend/sftp/operation_queue.cpp
@@ -1,49 +1,52 @@
 #include <backend/sftp/operation_queue.hpp>
+#include <shared_data/file_operations/download_progress.hpp>
+#include <shared_data/file_operations/operation_added.hpp>
+#include <shared_data/file_operations/operation_completed.hpp>
 
 #include <log/log.hpp>
 #include <utility/overloaded.hpp>
 
 namespace
 {
-    OperationQueue::CompletedOperation makeCompletedOperation(
+    OperationQueue::OperationCompleted makeCompletedOperation(
         OperationQueue::CompletionReason reason,
-        Ids::OperationId id,
+        Ids::OperationId operationId,
         Operation const& operation,
         std::optional<Operation::Error> error = std::nullopt)
     {
         return operation.visit(
             Utility::overloaded(
-                [reason, id, error](DownloadOperation const& op) {
-                    return OperationQueue::CompletedOperation{
+                [reason, operationId, error](DownloadOperation const& op) {
+                    return OperationQueue::OperationCompleted{
                         .reason = reason,
-                        .id = id,
+                        .operationId = operationId,
                         .completionTime = std::chrono::system_clock::now(),
                         .localPath = op.localPath(),
                         .remotePath = op.remotePath(),
                         .error = error,
                     };
                 },
-                [reason, id, error](ScanOperation const& op) {
-                    return OperationQueue::CompletedOperation{
+                [reason, operationId, error](ScanOperation const& op) {
+                    return OperationQueue::OperationCompleted{
                         .reason = reason,
-                        .id = id,
+                        .operationId = operationId,
                         .completionTime = std::chrono::system_clock::now(),
                         .remotePath = op.remotePath(),
                         .error = error,
                     };
                 },
-                [reason, id, error](BulkDownloadOperation const&) {
-                    return OperationQueue::CompletedOperation{
+                [reason, operationId, error](BulkDownloadOperation const&) {
+                    return OperationQueue::OperationCompleted{
                         .reason = reason,
-                        .id = id,
+                        .operationId = operationId,
                         .completionTime = std::chrono::system_clock::now(),
                         .error = error,
                     };
                 },
-                [reason, id](std::nullopt_t) {
-                    return OperationQueue::CompletedOperation{
+                [reason, operationId](std::nullopt_t) {
+                    return OperationQueue::OperationCompleted{
                         .reason = reason,
-                        .id = id,
+                        .operationId = operationId,
                         .completionTime = std::chrono::system_clock::now(),
                     };
                 }));
@@ -88,6 +91,29 @@ void OperationQueue::cancel(Ids::OperationId id)
     });
 }
 
+void OperationQueue::completeOperation(SharedData::OperationCompleted&& operationCompleted)
+{
+    within_strand_do([weak = weak_from_this(), operationCompleted = std::move(operationCompleted)]() {
+        auto self = weak.lock();
+        if (!self)
+            return;
+
+        if (operationCompleted.error)
+            Log::error("Operation failed: {}", operationCompleted.error->toString());
+
+        self->hub_->callRemote(
+            fmt::format("OperationQueue::{}::onOperationCompleted", self->sessionId_.value()),
+            SharedData::OperationCompleted{
+                .reason = operationCompleted.reason,
+                .operationId = operationCompleted.operationId,
+                .completionTime = operationCompleted.completionTime,
+                .localPath = operationCompleted.localPath,
+                .remotePath = operationCompleted.remotePath,
+                .error = operationCompleted.error,
+            });
+    });
+}
+
 bool OperationQueue::work()
 {
     // Assumed in strand
@@ -104,18 +130,18 @@ bool OperationQueue::work()
         const auto workResult = operation->work();
         if (!workResult.has_value())
         {
-            Log::error("Operation failed: {}", workResult.error().toString());
-            completedOperations_.push_back(
+            completeOperation(
                 makeCompletedOperation(OperationQueue::CompletionReason::Failed, id, *operation, workResult.error()));
-            continue;
+            operations_.erase(operations_.begin() + static_cast<std::ptrdiff_t>(i));
+            // Exit loop and avoid any offset math. Just do another update cycle.
+            return true;
         }
 
         const auto workStatus = workResult.value();
         if (workStatus == Operation::WorkStatus::Complete)
         {
             Log::info("Operation completed successfully: {}", id.value());
-            completedOperations_.push_back(
-                makeCompletedOperation(OperationQueue::CompletionReason::Completed, id, *operation));
+            completeOperation(makeCompletedOperation(OperationQueue::CompletionReason::Completed, id, *operation));
             operations_.pop_front();
             // Exit loop and avoid any offset math. Just do another update cycle.
             return true;
@@ -153,6 +179,8 @@ std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
 
     if (result->isRegularFile())
     {
+        const auto fileSize = result->size;
+
         auto fut = sftp.openFile(remotePath, SecureShell::SftpSession::OpenType::Read, std::filesystem::perms::unknown);
         if (fut.wait_for(std::chrono::seconds{5}) != std::future_status::ready)
         {
@@ -160,19 +188,19 @@ std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
             return std::unexpected(Operation::Error{.type = Operation::ErrorType::OpenFailure});
         }
 
-        const auto result = fut.get();
-        if (!result.has_value())
+        const auto openResult = fut.get();
+        if (!openResult.has_value())
         {
-            Log::error("Failed to open remote sftp file: {}", result.error().message);
+            Log::error("Failed to open remote sftp file: {}", openResult.error().message);
             return std::unexpected(
-                Operation::Error{.type = Operation::ErrorType::SftpError, .sftpError = result.error()});
+                Operation::Error{.type = Operation::ErrorType::SftpError, .sftpError = openResult.error()});
         }
 
         const auto transferOptions = sftpOpts_.downloadOptions.value_or(Persistence::TransferOptions{});
         const auto defaultOptions = DownloadOperation::DownloadOperationOptions{};
 
         auto operation = std::make_unique<DownloadOperation>(
-            std::move(result).value(),
+            std::move(openResult).value(),
             DownloadOperation::DownloadOperationOptions{
                 .progressCallback =
                     [weak = weak_from_this(), operationId](auto min, auto max, auto current) {
@@ -181,8 +209,14 @@ std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
                         if (!self)
                             return;
 
-                        self->call(
-                            "progress", operationId, nlohmann::json{{"min", min}, {"max", max}, {"current", current}});
+                        self->hub_->callRemote(
+                            fmt::format("OperationQueue::{}::onDownloadProgress", self->sessionId_.value()),
+                            SharedData::DownloadProgress{
+                                .operationId = operationId,
+                                .min = min,
+                                .max = max,
+                                .current = current,
+                            });
 
                         Log::info(
                             "Downloaded {} / {} bytes ({}%)",
@@ -203,6 +237,13 @@ std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
             });
 
         operations_.emplace_back(operationId, std::move(operation));
+
+        Log::info("Calling OperationQueue::{}::onOperationAdded", sessionId_.value());
+        hub_->callRemote(
+            fmt::format("OperationQueue::{}::onOperationAdded", sessionId_.value()),
+            SharedData::OperationAdded{
+                .operationId = operationId, .type = SharedData::OperationType::Download, .totalBytes = fileSize});
+
         return {};
     }
     else if (result->isDirectory())
@@ -237,6 +278,21 @@ std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
             });
 
         operations_.emplace_back(operationId, std::move(scan));
+        operations_.emplace_back(operationId, std::move(bulk));
+
+        hub_->callRemote(
+            fmt::format("OperationQueue::{}::{}", sessionId_.value(), "onOperationAdded"),
+            SharedData::OperationAdded{
+                .operationId = operationId,
+                .type = SharedData::OperationType::Scan,
+            });
+        hub_->callRemote(
+            fmt::format("OperationQueue::{}::{}", sessionId_.value(), "onOperationAdded"),
+            SharedData::OperationAdded{
+                .operationId = operationId,
+                .type = SharedData::OperationType::BulkDownload,
+            });
+
         return {};
     }
     else
diff --git a/frontend/include/frontend/observed_random_access_map.hpp b/frontend/include/frontend/observed_random_access_map.hpp
new file mode 100644
index 00000000..acca6639
--- /dev/null
+++ b/frontend/include/frontend/observed_random_access_map.hpp
@@ -0,0 +1,100 @@
+#pragma once
+
+#include <nui/event_system/observed_value.hpp>
+
+#include <deque>
+#include <stdexcept>
+
+template <typename KeyT, typename ValueT, template <typename, typename> typename MapT>
+class ObservedRandomAccessMap
+{
+  public:
+    ObservedRandomAccessMap() = default;
+
+    void insert(KeyT const& key, ValueT const& value)
+    {
+        if (keyToIndexMap_.find(key) != keyToIndexMap_.end())
+            throw std::invalid_argument("Key already exists in ObservedRandomAccessMap");
+
+        observedValues_.push_back(value);
+        keyToIndexMap_[key] = observedValues_.value().size() - 1;
+    }
+
+    void insert(KeyT const& key, ValueT&& value)
+    {
+        if (keyToIndexMap_.find(key) != keyToIndexMap_.end())
+            throw std::invalid_argument("Key already exists in ObservedRandomAccessMap");
+
+        observedValues_.push_back(std::move(value));
+        keyToIndexMap_[key] = observedValues_.value().size() - 1;
+    }
+
+    void pop_back()
+    {
+        if (observedValues_.value().empty())
+            return;
+
+        keyToIndexMap_.erase(observedValues_.value().back().key());
+        observedValues_.pop_back();
+    }
+
+    void pop_front()
+    {
+        if (observedValues_.empty())
+            return;
+        observedValues_.pop_front();
+
+        // TODO: be more clever here:
+        rebuildIndexMap();
+    }
+
+    void erase(KeyT const& key)
+    {
+        auto it = keyToIndexMap_.find(key);
+        if (it == keyToIndexMap_.end())
+            throw std::out_of_range("Key not found in ObservedRandomAccessMap");
+
+        observedValues_.erase(observedValues_.begin() + it->second);
+
+        // TODO: be more clever here:
+        rebuildIndexMap();
+    }
+
+    Nui::Observed<std::deque<ValueT>>& observedValues()
+    {
+        return observedValues_;
+    }
+
+    ValueT* at(KeyT const& key)
+    {
+        auto it = keyToIndexMap_.find(key);
+        if (it == keyToIndexMap_.end())
+            return nullptr;
+
+        return &observedValues_.value().at(it->second);
+    }
+
+    template <typename FunctionT>
+    void modify(KeyT const& key, FunctionT const& modifier)
+    {
+        auto it = keyToIndexMap_.find(key);
+        if (it == keyToIndexMap_.end())
+            throw std::out_of_range("Key not found in ObservedRandomAccessMap");
+
+        modifier(observedValues_[it->second]);
+    }
+
+  private:
+    void rebuildIndexMap()
+    {
+        keyToIndexMap_.clear();
+        for (std::size_t i = 0; i < observedValues_.value().size(); ++i)
+        {
+            keyToIndexMap_[observedValues_.value().at(i).key()] = i;
+        }
+    }
+
+  private:
+    Nui::Observed<std::deque<ValueT>> observedValues_;
+    MapT<KeyT, std::size_t> keyToIndexMap_;
+};
\ No newline at end of file
diff --git a/frontend/include/frontend/session_components/operation_queue.hpp b/frontend/include/frontend/session_components/operation_queue.hpp
index 1ad1842d..2a9f9bb7 100644
--- a/frontend/include/frontend/session_components/operation_queue.hpp
+++ b/frontend/include/frontend/session_components/operation_queue.hpp
@@ -15,12 +15,11 @@ class OperationQueue
         Persistence::StateHolder* stateHolder,
         FrontendEvents* events,
         std::string persistenceSessionName,
-        std::string sessionId,
         ConfirmDialog* confirmDialog);
 
     ROAR_PIMPL_SPECIAL_FUNCTIONS(OperationQueue);
 
-    void setFileEngine(FileEngine* fileEngine);
+    void activate(FileEngine* fileEngine, Ids::SessionId sessionId);
 
     void enqueueDownload(
         std::filesystem::path const& remotePath,
diff --git a/frontend/include/frontend/session_components/session_options.hpp b/frontend/include/frontend/session_components/session_options.hpp
index dd0c0fff..28f26a68 100644
--- a/frontend/include/frontend/session_components/session_options.hpp
+++ b/frontend/include/frontend/session_components/session_options.hpp
@@ -14,7 +14,7 @@ class SessionOptions
         Persistence::StateHolder* stateHolder,
         FrontendEvents* events,
         std::string persistenceSessionName,
-        std::string id,
+        std::string sessionLayoutId,
         ConfirmDialog* confirmDialog);
     ROAR_PIMPL_SPECIAL_FUNCTIONS(SessionOptions);
 
diff --git a/frontend/source/frontend/components/progress_bar.cpp b/frontend/source/frontend/components/progress_bar.cpp
index bd5040ef..07b3ada2 100644
--- a/frontend/source/frontend/components/progress_bar.cpp
+++ b/frontend/source/frontend/components/progress_bar.cpp
@@ -21,7 +21,7 @@
     align-items: center;
 }
 
-.progress-bar:nth-child(1) {
+.progress-bar > div:nth-child(1) {
     height: 100%;
     width: 0%;
     transition: width 0.3s linear, background-color 0.3s linear;
@@ -30,7 +30,7 @@
     left: 0;
 }
 
-.progress-bar:nth-child(2) {
+.progress-bar > div:nth-child(2) {
     position: relative;
     z-index: 1;
     font-size: 16px;
@@ -39,7 +39,7 @@
     text-shadow: 0 0 5px rgba(0, 0, 0, 0.5);
 }
 
-.progress-bar:nth-child(3) {
+.progress-bar > div:nth-child(3) {
     position: absolute;
     top: 0;
     left: 0;
@@ -49,12 +49,12 @@
     animation: progress-shine 2s infinite;
 }
 
-.progress-bar:nth-child(3).hidden {
+.progress-bar > div:nth-child(3).hidden {
     display: none;
 }
 
 @media (prefers-reduced-motion: reduce) {
-    .progress-bar:nth-child(3) {
+    .progress-bar > div:nth-child(3) {
         animation: none;
     }
 }
@@ -117,12 +117,13 @@ namespace
 
 struct ProgressBar::Implementation : public ProgressBar::Settings
 {
-    std::weak_ptr<Nui::Dom::BasicElement> progressBarElement;
+    Nui::Observed<long long> progress{0};
+    Nui::Observed<std::string> text{"0%"};
+    Nui::Observed<std::string> backgroundColor{"#a0a0a0"};
     OrderOfMagnitude magnitude;
 
     Implementation(Settings settings)
         : Settings{std::move(settings)}
-        , progressBarElement{}
         , magnitude{determineOrderOfMagnitude(settings.max)}
     {}
 };
@@ -133,7 +134,7 @@ ProgressBar::ProgressBar(Settings settings)
 
 ROAR_PIMPL_SPECIAL_FUNCTIONS_IMPL(ProgressBar);
 
-Nui::ElementRenderer ProgressBar::operator()()
+Nui::ElementRenderer ProgressBar::operator()() const
 {
     using namespace Nui::Elements;
     using namespace Nui::Attributes;
@@ -142,32 +143,32 @@ Nui::ElementRenderer ProgressBar::operator()()
 
     // clang-format off
     return div{
-        id = impl_->id,
         class_ = "progress-bar",
-        reference = impl_->progressBarElement,
+        style = Style {
+            "height"_style = impl_->height,
+        },
     }(
-        div{}(),
-        div{}("0%"),
+        // bar fill
+        div{
+            style = Style{
+                "width"_style = observe(impl_->progress).generate([this]() {
+                    return format("{}%", percentageBetween(impl_->progress.value(), impl_->min, impl_->max));
+                }),
+                "height"_style = impl_->height,
+                "background-color"_style = impl_->backgroundColor
+            },
+        }(),
+        // text
+        div{}(impl_->text),
+        // shine animation
         div{}()
     );
     // clang-format on
 }
 
-void ProgressBar::setProgress(long long current)
+void ProgressBar::updateText()
 {
-    const auto percent = percentageBetween(current, impl_->min, impl_->max);
-
-    auto element = impl_->progressBarElement.lock();
-    if (!element) // not mounted
-        return;
-
-    Nui::val progressBar = element->val();
-    Nui::val barFill = progressBar.call<Nui::val>("children")[0];
-    Nui::val percentageText = progressBar.call<Nui::val>("children")[1];
-
-    barFill["style"].set("width", fmt::format("{}%", static_cast<int>(percent)));
-
-    const auto text = [this, percent]() {
+    impl_->text = [this, percent = percentageBetween(impl_->progress.value(), impl_->min, impl_->max)]() {
         if (impl_->showMinMax)
         {
             if (impl_->byteMode)
@@ -191,19 +192,26 @@ void ProgressBar::setProgress(long long current)
 
                 return fmt::format(
                     "{} - {} ({})",
-                    formatSize(impl_->min, impl_->magnitude),
+                    formatSize(impl_->progress.value(), impl_->magnitude),
                     formatSize(impl_->max, impl_->magnitude),
                     percent);
             }
             else
-                return fmt::format("{} / {} ({})", impl_->min, impl_->max, percent);
+                return fmt::format("{} / {} ({})", impl_->progress.value(), impl_->max, percent);
         }
         else
             return fmt::format("{}%", percent);
     }();
+}
 
-    percentageText.set("textContent", text);
-
+void ProgressBar::setProgress(long long current)
+{
+    const auto percent = percentageBetween(current, impl_->min, impl_->max);
     const auto hue = std::max(5., 120. * std::pow(static_cast<double>(percent) / 100., 1.8));
-    barFill["style"].set("backgroundColor", fmt::format("hsl({}, 100%, 50%)", static_cast<int>(hue)));
+
+    impl_->progress = current;
+    impl_->backgroundColor = fmt::format("hsl({}, 100%, 50%)", static_cast<int>(hue));
+    updateText();
+
+    Nui::globalEventContext.executeActiveEventsImmediately();
 }
\ No newline at end of file
diff --git a/frontend/source/frontend/session.cpp b/frontend/source/frontend/session.cpp
index 322fda68..d2c35d14 100644
--- a/frontend/source/frontend/session.cpp
+++ b/frontend/source/frontend/session.cpp
@@ -40,7 +40,7 @@ struct Session::Implementation
     // Session Ui Tab related:
     std::string initialName;
     std::shared_ptr<Nui::Observed<std::string>> tabTitle;
-    std::string id;
+    std::string sessionLayoutId;
     std::function<void(Session const*)> closeSelf;
     Nui::Observed<bool> isVisible;
     Persistence::UiOptions uiOptions;
@@ -95,7 +95,7 @@ struct Session::Implementation
         , events{events}
         , initialName{std::move(initialName)}
         , tabTitle{std::make_shared<Nui::Observed<std::string>>(this->initialName)}
-        , id{Nui::val::global("generateId")().as<std::string>()}
+        , sessionLayoutId{Nui::val::global("generateId")().as<std::string>()}
         , closeSelf{std::move(closeSelf)}
         , isVisible{visible}
         , uiOptions{uiOptions}
@@ -110,14 +110,14 @@ struct Session::Implementation
         , currentPath{}
         , fileEngine{}
         , preNavigatePath{}
-        , operationQueue{this->stateHolder, this->events, this->initialName, this->id, this->confirmDialog}
+        , operationQueue{this->stateHolder, this->events, this->initialName, this->confirmDialog}
         , operationQueueElement{}
         , layoutHost{}
         , layoutName{std::move(layoutName)}
         , terminal{}
         , channelElements{}
         , sessionOptionsElement{}
-        , sessionOptions{stateHolder, events, this->initialName, this->id, confirmDialog}
+        , sessionOptions{stateHolder, events, this->initialName, this->sessionLayoutId, confirmDialog}
     {}
 };
 
@@ -560,9 +560,9 @@ void Session::openSftp()
         if (opts.openSftpByDefault)
         {
             Log::info("Opening SFTP by default");
-            impl_->fileEngine =
-                std::make_unique<SftpFileEngine>(static_cast<SshTerminalEngine*>(&impl_->terminal.value()->engine()));
-            impl_->operationQueue.setFileEngine(impl_->fileEngine.get());
+            auto* engine = static_cast<SshTerminalEngine*>(&impl_->terminal.value()->engine());
+            impl_->fileEngine = std::make_unique<SftpFileEngine>(engine);
+            impl_->operationQueue.activate(impl_->fileEngine.get(), engine->sshSessionId());
             navigateTo(opts.defaultDirectory.value_or("/"));
         }
     }
@@ -706,7 +706,7 @@ void Session::managerShutdown(std::function<void()> onShutdown)
     else
     {
         Log::info("Session shutdown is already complete");
-        Nui::val::global("contentPanelManager").call<void>("removePanel", impl_->id);
+        Nui::val::global("contentPanelManager").call<void>("removePanel", impl_->sessionLayoutId);
         onShutdown();
     }
 }
@@ -716,7 +716,7 @@ void Session::closeSelf()
     if (impl_->onShutdownComplete)
     {
         Log::info("Session shutdown complete");
-        Nui::val::global("contentPanelManager").call<void>("removePanel", impl_->id);
+        Nui::val::global("contentPanelManager").call<void>("removePanel", impl_->sessionLayoutId);
 
         impl_->onShutdownComplete();
         return;
@@ -773,8 +773,7 @@ void Session::onChannelClosedByUser(Ids::ChannelId const& channelId)
         const auto val = elem->val();
         if (val.template call<bool>("hasAttribute", "data-channelid"s))
         {
-            const auto id = val.template call<std::string>("getAttribute", "data-channelid"s);
-            return id == channelId.value();
+            return val.template call<std::string>("getAttribute", "data-channelid"s) == channelId.value();
         }
         else
         {
@@ -826,7 +825,7 @@ void Session::initializeLayout()
         .call<void>(
             "addPanel",
             element,
-            impl_->id,
+            impl_->sessionLayoutId,
             layout.value_or(""),
             Nui::bind([this]() -> Nui::val {
                 Nui::Console::log("Channel factory content panel manager");
diff --git a/frontend/source/frontend/session_components/operation_queue.cpp b/frontend/source/frontend/session_components/operation_queue.cpp
index 647a1d3e..97fc0ddb 100644
--- a/frontend/source/frontend/session_components/operation_queue.cpp
+++ b/frontend/source/frontend/session_components/operation_queue.cpp
@@ -1,63 +1,439 @@
 #include <frontend/session_components/operation_queue.hpp>
 #include <frontend/components/progress_bar.hpp>
+#include <frontend/observed_random_access_map.hpp>
+#include <shared_data/file_operations/download_progress.hpp>
+#include <shared_data/file_operations/operation_added.hpp>
+#include <shared_data/file_operations/operation_type.hpp>
+#include <shared_data/file_operations/operation_error_type.hpp>
+#include <shared_data/file_operations/operation_error.hpp>
+#include <shared_data/file_operations/operation_state.hpp>
+#include <shared_data/file_operations/operation_completed.hpp>
+#include <utility/convert_naming_convention.hpp>
+#include <utility/visit_overloaded.hpp>
 
 #include <log/log.hpp>
 #include <nui/frontend/attributes.hpp>
 #include <nui/frontend/elements.hpp>
+#include <nui/frontend/svg.hpp>
 #include <nui/rpc.hpp>
 #include <fmt/format.h>
 
+#include <variant>
+#include <map>
+#include <cstdint>
+#include <chrono>
+
+namespace
+{
+    namespace Svgs
+    {
+        Nui::ElementRenderer play()
+        {
+            namespace svg = Nui::Elements::Svg;
+            namespace svga = Nui::Attributes::Svg;
+
+            // clang-format off
+            return svg::svg {
+                svga::viewBox = "0 0 24 24",
+                svga::fill = "none",
+            }(
+                svg::path {
+                    svga::d = "M8 5v14l11-7L8 5z",
+                    svga::fill = "currentColor"
+                }()
+            );
+            // clang-format on
+        }
+
+        Nui::ElementRenderer pause()
+        {
+            namespace svg = Nui::Elements::Svg;
+            namespace svga = Nui::Attributes::Svg;
+
+            // clang-format off
+            return svg::svg {
+                svga::viewBox = "0 0 24 24",
+                svga::fill = "none",
+            }(
+                svg::path {
+                    svga::d = "M6 5h4v14H6zM14 5h4v14h-4z",
+                    svga::fill = "currentColor"
+                }()
+            );
+            // clang-format on
+        }
+
+        Nui::ElementRenderer download()
+        {
+            namespace svg = Nui::Elements::Svg;
+            namespace svga = Nui::Attributes::Svg;
+
+            // clang-format off
+            return svg::svg {
+                svga::viewBox = "0 0 24 24",
+                svga::fill = "none",
+            }(
+                svg::path {
+                    svga::d = "M12 3v10m0 0 4-4m-4 4-4-4M5 21h14",
+                    svga::stroke = "currentColor",
+                    svga::strokeWidth = "1.6",
+                    svga::strokeLinecap = "round",
+                    svga::strokeLinejoin = "round"
+                }()
+            );
+            // clang-format on
+        }
+
+        Nui::ElementRenderer upload()
+        {
+            namespace svg = Nui::Elements::Svg;
+            namespace svga = Nui::Attributes::Svg;
+
+            // clang-format off
+            return svg::svg {
+                svga::viewBox = "0 0 24 24",
+                svga::fill = "none",
+            }(
+                svg::path {
+                    svga::d = "M12 21V11m0 0 4 4m-4-4-4 4M19 3H5",
+                    svga::stroke = "currentColor",
+                    svga::strokeWidth = "1.6",
+                    svga::strokeLinecap = "round",
+                    svga::strokeLinejoin = "round"
+                }()
+            );
+            // clang-format on
+        }
+
+        Nui::ElementRenderer scan()
+        {
+            namespace svg = Nui::Elements::Svg;
+            namespace svga = Nui::Attributes::Svg;
+
+            // clang-format off
+            return svg::svg {
+                svga::viewBox = "0 0 24 24",
+                svga::fill = "none",
+            }(
+                svg::path {
+                    svga::d = "M3 7v4a4 4 0 0 0 4 4h10",
+                    svga::stroke = "currentColor",
+                    svga::strokeWidth = "1.6",
+                    svga::strokeLinecap = "round",
+                    svga::strokeLinejoin = "round"
+                }(),
+                svg::path {
+                    svga::d = "M21 17v-4a4 4 0 0 0-4-4H7",
+                    svga::stroke = "currentColor",
+                    svga::strokeWidth = "1.6",
+                    svga::strokeLinecap = "round",
+                    svga::strokeLinejoin = "round"
+                }()
+            );
+            // clang-format on
+        }
+    }
+
+    template <typename Derived>
+    class OperationCard
+    {
+      public:
+        explicit OperationCard(SharedData::OperationType type)
+            : type_{type}
+        {}
+
+        std::string formattedState() const
+        {
+            return Utility::splitByPascalCase(Utility::enumToString(state_.value())).joined(" ");
+        }
+
+        void state(SharedData::OperationState newState)
+        {
+            state_ = newState;
+        }
+
+        SharedData::OperationState state() const
+        {
+            return state_.value();
+        }
+
+        Nui::ElementRenderer operator()() const
+        {
+            using namespace Nui::Elements;
+            using namespace Nui::Attributes;
+            using Nui::Elements::div;
+            using Nui::Elements::span;
+
+            // clang-format off
+            return section{
+                class_ = "opq-card"
+            }(
+                div {
+                    class_ = "opq-header",
+                }(
+                    div {
+                        class_ = "type"
+                    }(
+                        [this]() -> Nui::ElementRenderer {
+                            if (type_ == SharedData::OperationType::Download)
+                                return Svgs::download();
+                            else if (type_ == SharedData::OperationType::Upload)
+                                return Svgs::upload();
+                            else if (type_ == SharedData::OperationType::Rename)
+                                return Svgs::scan();
+                            else if (type_ == SharedData::OperationType::Delete)
+                                return Svgs::scan();
+                            else
+                                return div{}("UnknownType");
+                        }()
+                    ),
+                    div {
+                        class_ = "opq-title"
+                    }(
+                        div{}(title_),
+                        div {
+                            class_ = "opq-muted"
+                        // TODO: Build this string correctly
+                        }(
+                            Nui::observe(state_),
+                            [this]() -> std::string {
+                                return fmt::format("id: {} • status: {}", operationId_.value(), formattedState());
+                            }
+                        )
+                    ),
+                    button {
+                        class_ = "opq-btn opq-cancel-btn",
+                    }(
+                        "Cancel"
+                    )
+                ),
+                static_cast<Derived const*>(this)->body()
+            );
+            // clang-format on
+        }
+
+        Nui::ElementRenderer elapsedTime() const
+        {
+            using namespace Nui::Elements;
+            using namespace Nui::Attributes;
+            using Nui::Elements::div;
+
+            return div{style = "margin-top: 8px, font-size: 13px; color: var(--muted);"}(
+                // TODO:
+                "Elapsed: 0s");
+        }
+
+      protected:
+        std::chrono::steady_clock::time_point startTime_{std::chrono::steady_clock::now()};
+        Nui::Observed<SharedData::OperationState> state_{SharedData::OperationState::NotStarted};
+        SharedData::OperationType type_;
+        Ids::OperationId operationId_;
+        Nui::Observed<std::string> title_{"Not started"};
+    };
+
+    class DisplayedDownloadOperation : public OperationCard<DisplayedDownloadOperation>
+    {
+      public:
+        DisplayedDownloadOperation(long long min, long long max)
+            : OperationCard{SharedData::OperationType::Download}
+            , progressBar_{{
+                  .height = "10px",
+                  .min = min,
+                  .max = max,
+                  .showMinMax = true,
+                  .byteMode = true,
+              }}
+        {}
+
+        Nui::ElementRenderer body() const
+        {
+            using namespace Nui::Elements;
+            using namespace Nui::Attributes;
+            using Nui::Elements::div;
+            using Nui::Elements::span;
+
+            // clang-format off
+            return div{
+                class_ = "opq-body",
+            }(
+                div{
+                    class_ = "opq-muted"
+                }("Dynamic content area — this would show progress, nested items, details, etc."),
+                progressBar_()
+            );
+            // clang-format on
+        }
+
+        void setProgress(long long current)
+        {
+            progressBar_.setProgress(current);
+        }
+
+      private:
+        ProgressBar progressBar_;
+    };
+
+    struct DisplayedOperation
+    {
+        Ids::OperationId operationId;
+        SharedData::OperationType type;
+        std::variant<std::monostate, DisplayedDownloadOperation> details;
+
+        Ids::OperationId key() const
+        {
+            return operationId;
+        }
+    };
+}
+
 struct OperationQueue::Implementation
 {
     Persistence::StateHolder* stateHolder;
     FrontendEvents* events;
     std::string persistenceSessionName;
-    std::string sessionId;
+    Ids::SessionId sessionId;
     ConfirmDialog* confirmDialog;
     FileEngine* fileEngine;
 
-    Nui::RpcClient::AutoUnregister onUpdate;
+    std::vector<Nui::RpcClient::AutoUnregister> onUpdate;
+    ObservedRandomAccessMap<Ids::OperationId, DisplayedOperation, std::map> operations;
 
     Implementation(
         Persistence::StateHolder* stateHolder,
         FrontendEvents* events,
         std::string persistenceSessionName,
-        std::string sessionId,
         ConfirmDialog* confirmDialog)
         : stateHolder{stateHolder}
         , events{events}
         , persistenceSessionName{std::move(persistenceSessionName)}
-        , sessionId{std::move(sessionId)}
+        , sessionId{}
         , confirmDialog{confirmDialog}
         , fileEngine{nullptr}
-    {
-        onUpdate =
-            Nui::RpcClient::autoRegisterFunction("OperationQueue::" + sessionId + "::onOperationAdded", [](Nui::val) {
-                // TODO:
-            });
-    }
+        , onUpdate{}
+        , operations{}
+    {}
 };
 
 OperationQueue::OperationQueue(
     Persistence::StateHolder* stateHolder,
     FrontendEvents* events,
     std::string persistenceSessionName,
-    std::string sessionId,
     ConfirmDialog* confirmDialog)
     : impl_{
-          std::make_unique<Implementation>(
-              stateHolder,
-              events,
-              std::move(persistenceSessionName),
-              std::move(sessionId),
-              confirmDialog),
+          std::make_unique<Implementation>(stateHolder, events, std::move(persistenceSessionName), confirmDialog),
       }
 {}
 ROAR_PIMPL_SPECIAL_FUNCTIONS_IMPL(OperationQueue);
 
-void OperationQueue::setFileEngine(FileEngine* fileEngine)
+void OperationQueue::activate(FileEngine* fileEngine, Ids::SessionId sessionId)
 {
     impl_->fileEngine = fileEngine;
+    impl_->sessionId = std::move(sessionId);
+
+    impl_->onUpdate.push_back(
+        Nui::RpcClient::autoRegisterFunction(
+            fmt::format("OperationQueue::{}::onOperationAdded", impl_->sessionId.value()),
+            [this](SharedData::OperationAdded const& added) {
+                impl_->operations.insert(
+                    added.operationId,
+                    DisplayedOperation{
+                        .operationId = added.operationId,
+                        .type = added.type,
+                        .details = [&added]() -> decltype(DisplayedOperation::details) {
+                            if (added.type == SharedData::OperationType::Download)
+                                return DisplayedDownloadOperation{
+                                    0, added.totalBytes ? static_cast<long long>(*added.totalBytes) : 0};
+                            return std::monostate{};
+                        }()});
+                Nui::globalEventContext.executeActiveEventsImmediately();
+            }));
+
+    impl_->onUpdate.push_back(
+        Nui::RpcClient::autoRegisterFunction(
+            fmt::format("OperationQueue::{}::onDownloadProgress", impl_->sessionId.value()),
+            [this](SharedData::DownloadProgress const& progress) {
+                Log::info(
+                    "Received download progress for operation id: {} - {}/{}",
+                    progress.operationId.value(),
+                    progress.current - progress.min,
+                    progress.max - progress.min);
+
+                auto* operation = impl_->operations.at(progress.operationId);
+                if (!operation)
+                {
+                    Log::error("Received download progress for unknown operation id: {}", progress.operationId.value());
+                    return;
+                }
+                if (operation->type != SharedData::OperationType::Download)
+                {
+                    Log::error(
+                        "Received download progress for operation id: {} which is not a download",
+                        progress.operationId.value());
+                    return;
+                }
+                auto* details = std::get_if<DisplayedDownloadOperation>(&operation->details);
+                if (!details)
+                {
+                    Log::error(
+                        "Received download progress for operation id: {} which has no download details",
+                        progress.operationId.value());
+                    return;
+                }
+                details->setProgress(progress.current - progress.min);
+            }));
+
+    impl_->onUpdate.push_back(
+        Nui::RpcClient::autoRegisterFunction(
+            fmt::format("OperationQueue::{}::onOperationCompleted", impl_->sessionId.value()),
+            [this](SharedData::OperationCompleted const& completed) {
+                Log::info("Received operation completed for operation id: {}", completed.operationId.value());
+                auto* operation = impl_->operations.at(completed.operationId);
+                if (!operation)
+                {
+                    Log::error(
+                        "Received operation completed for unknown operation id: {}", completed.operationId.value());
+                    return;
+                }
+                switch (completed.reason)
+                {
+                    case (SharedData::OperationCompletionReason::Completed):
+                    {
+                        Utility::visitOverloaded(
+                            operation->details,
+                            [](auto& op) {
+                                op.state(SharedData::OperationState::Completed);
+                            },
+                            [](std::monostate) {
+                                // Nothing to do
+                            });
+                        break;
+                    }
+                    case (SharedData::OperationCompletionReason::Canceled):
+                    {
+                        Utility::visitOverloaded(
+                            operation->details,
+                            [](auto& op) {
+                                op.state(SharedData::OperationState::Canceled);
+                            },
+                            [](std::monostate) {
+                                // Nothing to do
+                            });
+                        break;
+                    }
+                    case (SharedData::OperationCompletionReason::Failed):
+                    {
+                        Utility::visitOverloaded(
+                            operation->details,
+                            [](auto& op) {
+                                op.state(SharedData::OperationState::Failed);
+                            },
+                            [](std::monostate) {
+                                // Nothing to do
+                            });
+                        break;
+                    }
+                }
+            }));
 }
 
 Nui::ElementRenderer OperationQueue::operator()()
@@ -65,10 +441,75 @@ Nui::ElementRenderer OperationQueue::operator()()
     using namespace Nui::Elements;
     using namespace Nui::Attributes;
     using Nui::Elements::div;
+    using Nui::Elements::span;
+
+    auto operationsMapper = [](auto, auto const& element) {
+        return div{}(std::visit(
+            [](auto const& details) -> Nui::ElementRenderer {
+                if constexpr (std::is_same_v<std::decay_t<decltype(details)>, std::monostate>)
+                {
+                    return div{}("Unknown operation type");
+                }
+                else
+                {
+                    return details();
+                }
+            },
+            element.details));
+    };
 
+    // clang-format off
     return div{
+        class_ = "operation-queue",
         style = "width: 100%; height: auto; display: block",
-    }("OPERATION QUEUE HERE NEW");
+    }(
+        header{
+            class_ = "opq-controls"
+        }(
+            div{
+                class_ = "opq-play-toggle",
+                // TODO: remove id
+                id = "playToggle",
+                role = "button",
+                tabIndex = "0",
+                "aria-pressed"_prop = "false"
+            }(
+                div{
+                    class_ = "icon",
+                    // TODO: remove id
+                    id = "playIcon",
+                    "aria-hidden"_prop = "true"
+                }(
+                    // svg replaced by js
+                ),
+                div{
+                    class_ = "label",
+                    id = "playLabel"
+                }("Processing")
+            ),
+            div{
+                class_ = "opq-pill",
+                id = "queueState",
+            }(
+                span{}("Queue: "),
+                strong{id = "queueCount"}("0")
+            ),
+            div{
+                class_ = "summary",
+                id = "summaryText"
+            }("No operations yet")
+        ),
+        // Main content
+        div{}(
+            div{
+                class_ = "opq-list",
+                id = "operationList"
+            }(
+                impl_->operations.observedValues().map(operationsMapper)
+            )
+        )
+    );
+    // clang-format on
 }
 
 void OperationQueue::enqueueDownload(
diff --git a/frontend/source/frontend/session_components/session_options.cpp b/frontend/source/frontend/session_components/session_options.cpp
index 48426382..4197d6dd 100644
--- a/frontend/source/frontend/session_components/session_options.cpp
+++ b/frontend/source/frontend/session_components/session_options.cpp
@@ -16,7 +16,7 @@ struct SessionOptions::Implementation
     Persistence::StateHolder* stateHolder;
     FrontendEvents* events;
     std::string persistenceSessionName;
-    std::string id;
+    std::string sessionLayoutId;
     ConfirmDialog* confirmDialog;
 
     std::string selectedLayout;
@@ -26,12 +26,12 @@ struct SessionOptions::Implementation
         Persistence::StateHolder* stateHolder,
         FrontendEvents* events,
         std::string persistenceSessionName,
-        std::string id,
+        std::string sessionLayoutId,
         ConfirmDialog* confirmDialog)
         : stateHolder{stateHolder}
         , events{events}
         , persistenceSessionName{std::move(persistenceSessionName)}
-        , id{std::move(id)}
+        , sessionLayoutId{std::move(sessionLayoutId)}
         , confirmDialog{confirmDialog}
         , selectedLayout{}
     {}
@@ -64,13 +64,13 @@ SessionOptions::SessionOptions(
     Persistence::StateHolder* stateHolder,
     FrontendEvents* events,
     std::string persistenceSessionName,
-    std::string id,
+    std::string sessionLayoutId,
     ConfirmDialog* confirmDialog)
     : impl_{std::make_unique<Implementation>(
           stateHolder,
           events,
           std::move(persistenceSessionName),
-          std::move(id),
+          std::move(sessionLayoutId),
           confirmDialog)}
 {
     loadLayoutNames();
@@ -125,7 +125,7 @@ Nui::ElementRenderer SessionOptions::operator()()
                             return;
                         }
 
-                        auto layout = Nui::val::global("contentPanelManager").call<Nui::val>("getPanelLayout", impl_->id);
+                        auto layout = Nui::val::global("contentPanelManager").call<Nui::val>("getPanelLayout", impl_->sessionLayoutId);
                         if (layout.isUndefined())
                         {
                             Log::error("Failed to get layout");
diff --git a/shared_data/include/shared_data/file_operations/download_progress.hpp b/shared_data/include/shared_data/file_operations/download_progress.hpp
new file mode 100644
index 00000000..d3b3a5e3
--- /dev/null
+++ b/shared_data/include/shared_data/file_operations/download_progress.hpp
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <ids/ids.hpp>
+#include <shared_data/shared_data.hpp>
+#include <utility/describe.hpp>
+
+#include <nlohmann/json.hpp>
+
+#include <cstdint>
+
+namespace SharedData
+{
+    struct DownloadProgress
+    {
+        Ids::OperationId operationId;
+        std::uint64_t min;
+        std::uint64_t max;
+        std::uint64_t current;
+    };
+    BOOST_DESCRIBE_STRUCT(DownloadProgress, (), (operationId, min, max, current))
+
+    void to_json(nlohmann::json& j, DownloadProgress const& downloadProgress);
+    void from_json(nlohmann::json const& j, DownloadProgress& downloadProgress);
+}
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/operation_added.hpp b/shared_data/include/shared_data/file_operations/operation_added.hpp
index f70818c0..cf1c9a3d 100644
--- a/shared_data/include/shared_data/file_operations/operation_added.hpp
+++ b/shared_data/include/shared_data/file_operations/operation_added.hpp
@@ -1,26 +1,22 @@
 #pragma once
 
 #include <ids/ids.hpp>
+#include <shared_data/shared_data.hpp>
 #include <shared_data/file_operations/operation_type.hpp>
+#include <utility/describe.hpp>
 
 #include <nlohmann/json.hpp>
 
-#include <filesystem>
-#include <string>
-
 namespace SharedData
 {
     struct OperationAdded
     {
         Ids::OperationId operationId;
         OperationType type;
+        std::optional<std::uint64_t> totalBytes{std::nullopt};
     };
+    BOOST_DESCRIBE_STRUCT(OperationAdded, (), (operationId, type, totalBytes))
 
     void to_json(nlohmann::json& j, OperationAdded const& operationAdded);
     void from_json(nlohmann::json const& j, OperationAdded& operationAdded);
-
-#ifdef NUI_FRONTEND
-    void to_val(Nui::val& v, OperationAdded const& operationAdded);
-    void from_val(Nui::val const& v, OperationAdded& operationAdded);
-#endif
 }
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/operation_completed.hpp b/shared_data/include/shared_data/file_operations/operation_completed.hpp
new file mode 100644
index 00000000..c20267dd
--- /dev/null
+++ b/shared_data/include/shared_data/file_operations/operation_completed.hpp
@@ -0,0 +1,83 @@
+#pragma once
+
+#include <ids/ids.hpp>
+#include <shared_data/shared_data.hpp>
+#include <shared_data/file_operations/operation_error.hpp>
+#include <utility/describe.hpp>
+#include <utility/enum_string_convert.hpp>
+
+#include <nlohmann/json.hpp>
+
+#include <string>
+
+namespace SharedData
+{
+    BOOST_DEFINE_ENUM_CLASS(OperationCompletionReason, Completed, Canceled, Failed)
+
+    void to_json(nlohmann::json& j, OperationCompletionReason const& operationCompletionReason);
+    void from_json(nlohmann::json const& j, OperationCompletionReason& operationCompletionReason);
+
+#ifdef __EMSCRIPTEN__
+    inline void to_val(Nui::val& v, OperationCompletionReason const& operationCompletionReason)
+    {
+        v = Nui::val::u8string(Utility::enumToString<OperationCompletionReason>(operationCompletionReason).c_str());
+    }
+    inline void from_val(Nui::val const& v, OperationCompletionReason& operationCompletionReason)
+    {
+        operationCompletionReason = Utility::enumFromString<OperationCompletionReason>(v.template as<std::string>());
+    }
+#endif
+
+    struct OperationCompleted
+    {
+        OperationCompletionReason reason;
+        Ids::OperationId operationId;
+        std::chrono::system_clock::time_point completionTime;
+        std::optional<std::filesystem::path> localPath{std::nullopt};
+        std::optional<std::filesystem::path> remotePath{std::nullopt};
+        std::optional<OperationError> error{std::nullopt};
+    };
+
+    void to_json(nlohmann::json& j, OperationCompleted const& operationCompleted);
+    void from_json(nlohmann::json const& j, OperationCompleted& operationCompleted);
+
+#ifdef __EMSCRIPTEN__
+    inline void to_val(Nui::val& v, OperationCompleted const& operationCompleted)
+    {
+        v = Nui::val::object();
+        v.set("reason", operationCompleted.reason);
+        v.set("operationId", operationCompleted.operationId);
+        v.set(
+            "completionTime",
+            static_cast<int64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(
+                                     operationCompleted.completionTime.time_since_epoch())
+                                     .count()));
+        if (operationCompleted.localPath.has_value())
+            v.set("localPath", Nui::val::u8string(operationCompleted.localPath->generic_string().c_str()));
+        else
+            v.set("localPath", Nui::val::null());
+        if (operationCompleted.remotePath.has_value())
+            v.set("remotePath", Nui::val::u8string(operationCompleted.remotePath->generic_string().c_str()));
+        else
+            v.set("remotePath", Nui::val::null());
+        if (operationCompleted.error.has_value())
+            v.set("error", Nui::val(operationCompleted.error.value()));
+        else
+            v.set("error", Nui::val::null());
+    }
+    inline void from_val(Nui::val const& v, OperationCompleted& operationCompleted)
+    {
+        operationCompleted.reason = v["reason"].template as<OperationCompletionReason>();
+        operationCompleted.operationId = v["operationId"].template as<Ids::OperationId>();
+        operationCompleted.completionTime = std::chrono::system_clock::time_point{
+            std::chrono::milliseconds{v["completionTime"].template as<int64_t>()}};
+
+        if (v.hasOwnProperty("localPath") && !v["localPath"].isNull())
+            operationCompleted.localPath = std::filesystem::path{v["localPath"].template as<std::string>()};
+        if (v.hasOwnProperty("remotePath") && !v["remotePath"].isNull())
+            operationCompleted.remotePath = std::filesystem::path{v["remotePath"].template as<std::string>()};
+        if (v.hasOwnProperty("error") && !v["error"].isNull())
+            operationCompleted.error = v["error"].template as<OperationError>();
+    }
+#endif
+}
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/operation_error.hpp b/shared_data/include/shared_data/file_operations/operation_error.hpp
new file mode 100644
index 00000000..6578f626
--- /dev/null
+++ b/shared_data/include/shared_data/file_operations/operation_error.hpp
@@ -0,0 +1,95 @@
+#pragma once
+
+#include <shared_data/shared_data.hpp>
+#include <shared_data/file_operations/operation_error_type.hpp>
+#include <ssh/sftp_error.hpp>
+
+namespace SecureShell
+{
+    BOOST_DESCRIBE_ENUM(WrapperErrors, None, OwnerNull, SharedPtrDestroyed, ShortWrite, FileNull)
+    BOOST_DESCRIBE_STRUCT(SftpError, (), (message, sshError, sftpError, wrapperError))
+
+    void to_json(nlohmann::json& j, WrapperErrors const& wrapperErrors);
+    void from_json(nlohmann::json const& j, WrapperErrors& wrapperErrors);
+
+    void to_json(nlohmann::json& j, SftpError const& sftpError);
+    void from_json(nlohmann::json const& j, SftpError& sftpError);
+
+#ifdef __EMSCRIPTEN__
+    inline void to_val(Nui::val& v, WrapperErrors const& wrapperErrors)
+    {
+        v = Nui::val::u8string(Utility::enumToString<WrapperErrors>(wrapperErrors).c_str());
+    }
+    inline void from_val(Nui::val const& v, WrapperErrors& wrapperErrors)
+    {
+        wrapperErrors = Utility::enumFromString<WrapperErrors>(v.template as<std::string>());
+    }
+    inline void to_val(Nui::val& v, SftpError const& sftpError)
+    {
+        v = Nui::val::object();
+        v.set("message", Nui::val::u8string(sftpError.message.c_str()));
+        v.set("sshError", sftpError.sshError);
+        v.set("sftpError", sftpError.sftpError);
+        v.set("wrapperError", Nui::val::u8string(Utility::enumToString<WrapperErrors>(sftpError.wrapperError).c_str()));
+    }
+    inline void from_val(Nui::val const& v, SftpError& sftpError)
+    {
+        sftpError.message = v["message"].template as<std::string>();
+        sftpError.sshError = v["sshError"].template as<int>();
+        sftpError.sftpError = v["sftpError"].template as<int>();
+        sftpError.wrapperError = Utility::enumFromString<WrapperErrors>(v["wrapperError"].template as<std::string>());
+    }
+#endif
+}
+
+namespace SharedData
+{
+    struct OperationError
+    {
+        OperationErrorType type;
+        std::optional<SecureShell::SftpError> sftpError = std::nullopt;
+
+        std::string toString() const
+        {
+            const auto enumString = boost::describe::enum_to_string(type, "INVALID_ENUM_VALUE");
+            if (sftpError.has_value())
+                return fmt::format("{}: {}", enumString, sftpError->toString());
+            return enumString;
+        }
+    };
+
+    void to_json(nlohmann::json& j, OperationError const& operationError);
+    void from_json(nlohmann::json const& j, OperationError& operationError);
+
+#ifdef __EMSCRIPTEN__
+    inline void to_val(Nui::val& v, OperationError const& operationError)
+    {
+        v = Nui::val::object();
+        v.set("type", Nui::val::u8string(Utility::enumToString<OperationErrorType>(operationError.type).c_str()));
+        if (operationError.sftpError.has_value())
+        {
+            Nui::val sftpErrorVal;
+            to_val(sftpErrorVal, operationError.sftpError.value());
+            v.set("sftpError", sftpErrorVal);
+        }
+        else
+        {
+            v.set("sftpError", Nui::val::undefined());
+        }
+    }
+    inline void from_val(Nui::val const& v, OperationError& operationError)
+    {
+        operationError.type = Utility::enumFromString<OperationErrorType>(v["type"].template as<std::string>());
+        if (v.hasOwnProperty("sftpError") && !v["sftpError"].isUndefined())
+        {
+            SecureShell::SftpError sftpError;
+            from_val(v["sftpError"], sftpError);
+            operationError.sftpError = sftpError;
+        }
+        else
+        {
+            operationError.sftpError = std::nullopt;
+        }
+    }
+#endif
+}
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/operation_error_type.hpp b/shared_data/include/shared_data/file_operations/operation_error_type.hpp
new file mode 100644
index 00000000..367ef517
--- /dev/null
+++ b/shared_data/include/shared_data/file_operations/operation_error_type.hpp
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <shared_data/shared_data.hpp>
+#include <utility/describe.hpp>
+#include <utility/enum_string_convert.hpp>
+
+#include <nlohmann/json.hpp>
+
+#include <string>
+
+namespace SharedData
+{
+    BOOST_DEFINE_ENUM_CLASS(
+        OperationErrorType,
+        FileExists,
+        FileNotFound,
+        OpenFailure,
+        FileStreamExpired,
+        FileStatFailed,
+        SftpError,
+        InvalidPath,
+        RenameFailure,
+        CannotSetFilePermissions,
+        FutureTimeout,
+        OperationNotPrepared,
+        CannotFinalizeDuringRead,
+        InvalidOptionsKey,
+        TargetFileNotGood,
+        CannotWorkCompletedOperation,
+        CannotWorkFailedOperation,
+        CannotWorkCanceledOperation,
+        UnknownWorkState,
+        InvalidOperationState,
+        OperationNotPossibleOnFileType);
+
+    void to_json(nlohmann::json& j, OperationErrorType const& operationErrorType);
+    void from_json(nlohmann::json const& j, OperationErrorType& operationErrorType);
+
+#ifdef __EMSCRIPTEN__
+    inline void to_val(Nui::val& v, OperationErrorType const& operationErrorType)
+    {
+        v = Nui::val::u8string(Utility::enumToString<OperationErrorType>(operationErrorType).c_str());
+    }
+    inline void from_val(Nui::val const& v, OperationErrorType& operationErrorType)
+    {
+        operationErrorType = Utility::enumFromString<OperationErrorType>(v.template as<std::string>());
+    }
+#endif
+}
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/operation_state.hpp b/shared_data/include/shared_data/file_operations/operation_state.hpp
new file mode 100644
index 00000000..b20c4dd1
--- /dev/null
+++ b/shared_data/include/shared_data/file_operations/operation_state.hpp
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <shared_data/shared_data.hpp>
+#include <utility/enum_string_convert.hpp>
+#include <utility/describe.hpp>
+
+namespace SharedData
+{
+    BOOST_DEFINE_ENUM_CLASS(
+        OperationState,
+        NotStarted,
+        Preparing,
+        Prepared,
+        Running,
+        Finalizing,
+        Completed,
+        Canceled,
+        Failed)
+
+    void to_json(nlohmann::json& j, OperationState const& operationState);
+    void from_json(nlohmann::json const& j, OperationState& operationState);
+
+#ifdef __EMSCRIPTEN__
+    inline void to_val(Nui::val& v, OperationState const& operationState)
+    {
+        v = Nui::val::u8string(Utility::enumToString<OperationState>(operationState).c_str());
+    }
+    inline void from_val(Nui::val const& v, OperationState& operationState)
+    {
+        operationState = Utility::enumFromString<OperationState>(v.template as<std::string>());
+    }
+#endif
+}
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/operation_type.hpp b/shared_data/include/shared_data/file_operations/operation_type.hpp
index 3050ddcb..d1353b2a 100644
--- a/shared_data/include/shared_data/file_operations/operation_type.hpp
+++ b/shared_data/include/shared_data/file_operations/operation_type.hpp
@@ -1,24 +1,24 @@
 #pragma once
 
 #include <shared_data/shared_data.hpp>
+#include <utility/enum_string_convert.hpp>
+#include <utility/describe.hpp>
 
 namespace SharedData
 {
-    enum class OperationType
-    {
-        Scan,
-        Download,
-        BulkDownload,
-        Upload,
-        Rename,
-        Delete
-    };
+    BOOST_DEFINE_ENUM_CLASS(OperationType, Scan, Download, BulkDownload, Upload, Rename, Delete)
 
     void to_json(nlohmann::json& j, OperationType const& operationType);
     void from_json(nlohmann::json const& j, OperationType& operationType);
 
-#ifdef NUI_FRONTEND
-    void to_val(Nui::val& v, OperationType const& operationType);
-    void from_val(Nui::val const& v, OperationType& operationType);
+#ifdef __EMSCRIPTEN__
+    inline void to_val(Nui::val& v, OperationType const& operationType)
+    {
+        v = Nui::val::u8string(Utility::enumToString<OperationType>(operationType).c_str());
+    }
+    inline void from_val(Nui::val const& v, OperationType& operationType)
+    {
+        operationType = Utility::enumFromString<OperationType>(v.template as<std::string>());
+    }
 #endif
 }
\ No newline at end of file
diff --git a/shared_data/source/shared_data/CMakeLists.txt b/shared_data/source/shared_data/CMakeLists.txt
index 868b75f5..d53cb272 100644
--- a/shared_data/source/shared_data/CMakeLists.txt
+++ b/shared_data/source/shared_data/CMakeLists.txt
@@ -4,20 +4,18 @@ add_library(
         directory_entry.cpp
         file_operations/operation_type.cpp
         file_operations/operation_added.cpp
+        file_operations/download_progress.cpp
+        file_operations/operation_completed.cpp
+        file_operations/operation_error.cpp
+        file_operations/operation_state.cpp
 )
 
-target_include_directories(shared_data PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/../../include")
+target_include_directories(shared_data PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/../../include" "${CMAKE_CURRENT_SOURCE_DIR}/../../../ssh/include")
 
-target_link_libraries(shared_data PUBLIC utility ids)
+target_link_libraries(shared_data PUBLIC utility ids fmt)
 
 if (EMSCRIPTEN)
     target_link_libraries(shared_data PUBLIC nui-frontend)
-    target_sources(
-        shared_data
-        PRIVATE
-            file_operations/operation_type_val.cpp
-            file_operations/operation_added_val.cpp
-    )
 else()
     target_link_libraries(shared_data PUBLIC nui-backend)
 endif()
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/download_progress.cpp b/shared_data/source/shared_data/file_operations/download_progress.cpp
new file mode 100644
index 00000000..6b890b29
--- /dev/null
+++ b/shared_data/source/shared_data/file_operations/download_progress.cpp
@@ -0,0 +1,21 @@
+#include <shared_data/file_operations/download_progress.hpp>
+
+namespace SharedData
+{
+    void to_json(nlohmann::json& j, DownloadProgress const& downloadProgress)
+    {
+        j = nlohmann::json{
+            {"operationId", downloadProgress.operationId},
+            {"min", downloadProgress.min},
+            {"max", downloadProgress.max},
+            {"current", downloadProgress.current},
+        };
+    }
+    void from_json(nlohmann::json const& j, DownloadProgress& downloadProgress)
+    {
+        j.at("operationId").get_to(downloadProgress.operationId);
+        j.at("min").get_to(downloadProgress.min);
+        j.at("max").get_to(downloadProgress.max);
+        j.at("current").get_to(downloadProgress.current);
+    }
+}
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_added.cpp b/shared_data/source/shared_data/file_operations/operation_added.cpp
index 79dc7dc9..11a36fe6 100644
--- a/shared_data/source/shared_data/file_operations/operation_added.cpp
+++ b/shared_data/source/shared_data/file_operations/operation_added.cpp
@@ -8,10 +8,15 @@ namespace SharedData
             {"operationId", operationAdded.operationId},
             {"type", operationAdded.type},
         };
+
+        if (operationAdded.totalBytes.has_value())
+            j["totalBytes"] = operationAdded.totalBytes.value();
     }
     void from_json(nlohmann::json const& j, OperationAdded& operationAdded)
     {
         j.at("operationId").get_to(operationAdded.operationId);
         j.at("type").get_to(operationAdded.type);
+        if (j.contains("totalBytes") && !j.at("totalBytes").is_null())
+            j.at("totalBytes").get_to(*operationAdded.totalBytes);
     }
 }
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_added_val.cpp b/shared_data/source/shared_data/file_operations/operation_added_val.cpp
deleted file mode 100644
index 946cabcd..00000000
--- a/shared_data/source/shared_data/file_operations/operation_added_val.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <shared_data/file_operations/operation_added.hpp>
-
-namespace SharedData
-{
-    void to_val(Nui::val& v, OperationAdded const& operationAdded)
-    {
-        v = Nui::val::object();
-        Nui::val operationIdVal;
-        to_val(operationIdVal, operationAdded.operationId);
-        v.set("operationId", operationIdVal);
-
-        Nui::val typeVal;
-        to_val(typeVal, operationAdded.type);
-        v.set("type", typeVal);
-    }
-    void from_val(Nui::val const& v, OperationAdded& operationAdded)
-    {
-        from_val(v["operationId"], operationAdded.operationId);
-        from_val(v["type"], operationAdded.type);
-    }
-}
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_completed.cpp b/shared_data/source/shared_data/file_operations/operation_completed.cpp
new file mode 100644
index 00000000..9f3246a8
--- /dev/null
+++ b/shared_data/source/shared_data/file_operations/operation_completed.cpp
@@ -0,0 +1,54 @@
+#include <shared_data/file_operations/operation_completed.hpp>
+
+namespace SharedData
+{
+    void to_json(nlohmann::json& j, OperationCompletionReason const& operationCompletionReason)
+    {
+        j = Utility::enumToString<OperationCompletionReason>(operationCompletionReason);
+    }
+    void from_json(nlohmann::json const& j, OperationCompletionReason& operationCompletionReason)
+    {
+        operationCompletionReason = Utility::enumFromString<OperationCompletionReason>(j.template get<std::string>());
+    }
+
+    void to_json(nlohmann::json& j, OperationCompleted const& operationCompleted)
+    {
+        j = nlohmann::json{
+            {"reason", operationCompleted.reason},
+            {"operationId", operationCompleted.operationId},
+            {"completionTime",
+             static_cast<int64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(
+                                      operationCompleted.completionTime.time_since_epoch())
+                                      .count())},
+        };
+
+        if (operationCompleted.localPath.has_value())
+            j["localPath"] = operationCompleted.localPath->generic_string();
+
+        if (operationCompleted.remotePath.has_value())
+            j["remotePath"] = operationCompleted.remotePath->generic_string();
+
+        if (operationCompleted.error.has_value())
+            j["error"] = *operationCompleted.error;
+    }
+    void from_json(nlohmann::json const& j, OperationCompleted& operationCompleted)
+    {
+        j.at("reason").get_to(operationCompleted.reason);
+        j.at("operationId").get_to(operationCompleted.operationId);
+        operationCompleted.completionTime =
+            std::chrono::system_clock::time_point{std::chrono::milliseconds{j.at("completionTime").get<int64_t>()}};
+
+        if (j.contains("localPath"))
+            operationCompleted.localPath = j.at("localPath").get<std::filesystem::path>();
+        else
+            operationCompleted.localPath = std::nullopt;
+        if (j.contains("remotePath"))
+            operationCompleted.remotePath = j.at("remotePath").get<std::filesystem::path>();
+        else
+            operationCompleted.remotePath = std::nullopt;
+        if (j.contains("error"))
+            operationCompleted.error = j.at("error").get<OperationError>();
+        else
+            operationCompleted.error = std::nullopt;
+    }
+}
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_error.cpp b/shared_data/source/shared_data/file_operations/operation_error.cpp
new file mode 100644
index 00000000..2d57d0a3
--- /dev/null
+++ b/shared_data/source/shared_data/file_operations/operation_error.cpp
@@ -0,0 +1,49 @@
+#include <shared_data/file_operations/operation_error.hpp>
+
+namespace SecureShell
+{
+    void to_json(nlohmann::json& j, WrapperErrors const& wrapperErrors)
+    {
+        j = Utility::enumToString<WrapperErrors>(wrapperErrors);
+    }
+    void from_json(nlohmann::json const& j, WrapperErrors& wrapperErrors)
+    {
+        wrapperErrors = Utility::enumFromString<WrapperErrors>(j.template get<std::string>());
+    }
+
+    void to_json(nlohmann::json& j, SftpError const& sftpError)
+    {
+        j = nlohmann::json::object();
+        j["message"] = sftpError.message;
+        j["sshError"] = sftpError.sshError;
+        j["sftpError"] = sftpError.sftpError;
+        j["wrapperError"] = Utility::enumToString<WrapperErrors>(sftpError.wrapperError);
+    }
+
+    void from_json(nlohmann::json const& j, SftpError& sftpError)
+    {
+        sftpError.message = j.at("message").get<std::string>();
+        sftpError.sshError = j.at("sshError").get<int>();
+        sftpError.sftpError = j.at("sftpError").get<int>();
+        sftpError.wrapperError = Utility::enumFromString<WrapperErrors>(j.at("wrapperError").get<std::string>());
+    }
+}
+
+namespace SharedData
+{
+    void to_json(nlohmann::json& j, OperationError const& operationError)
+    {
+        j = nlohmann::json::object();
+        j["type"] = Utility::enumToString<OperationErrorType>(operationError.type);
+        if (operationError.sftpError.has_value())
+            j["sftpError"] = operationError.sftpError.value();
+    }
+    void from_json(nlohmann::json const& j, OperationError& operationError)
+    {
+        operationError.type = Utility::enumFromString<OperationErrorType>(j.at("type").get<std::string>());
+        if (j.contains("sftpError"))
+            operationError.sftpError = j.at("sftpError").get<SecureShell::SftpError>();
+        else
+            operationError.sftpError = std::nullopt;
+    }
+}
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_state.cpp b/shared_data/source/shared_data/file_operations/operation_state.cpp
new file mode 100644
index 00000000..2e108e77
--- /dev/null
+++ b/shared_data/source/shared_data/file_operations/operation_state.cpp
@@ -0,0 +1,13 @@
+#include <shared_data/file_operations/operation_state.hpp>
+
+namespace SharedData
+{
+    void to_json(nlohmann::json& j, OperationState const& operationState)
+    {
+        j = Utility::enumToString(operationState);
+    }
+    void from_json(nlohmann::json const& j, OperationState& operationState)
+    {
+        operationState = Utility::enumFromString<OperationState>(j.get<std::string>());
+    }
+}
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_type.cpp b/shared_data/source/shared_data/file_operations/operation_type.cpp
index 11e5720e..a0f062cd 100644
--- a/shared_data/source/shared_data/file_operations/operation_type.cpp
+++ b/shared_data/source/shared_data/file_operations/operation_type.cpp
@@ -4,40 +4,10 @@ namespace SharedData
 {
     void to_json(nlohmann::json& j, OperationType const& operationType)
     {
-        switch (operationType)
-        {
-            case OperationType::Download:
-                j = "Download";
-                break;
-            case OperationType::Upload:
-                j = "Upload";
-                break;
-            case OperationType::Rename:
-                j = "Rename";
-                break;
-            case OperationType::Delete:
-                j = "Delete";
-                break;
-            case OperationType::Scan:
-                j = "Scan";
-                break;
-            case OperationType::BulkDownload:
-                j = "BulkDownload";
-                break;
-        }
+        j = Utility::enumToString<OperationType>(operationType);
     }
     void from_json(nlohmann::json const& j, OperationType& operationType)
     {
-        auto const& str = j.get<std::string>();
-        if (str == "Download")
-            operationType = OperationType::Download;
-        else if (str == "Upload")
-            operationType = OperationType::Upload;
-        else if (str == "Rename")
-            operationType = OperationType::Rename;
-        else if (str == "Delete")
-            operationType = OperationType::Delete;
-        else
-            throw std::runtime_error("Invalid OperationType string: " + str);
+        operationType = Utility::enumFromString<OperationType>(j.get<std::string>());
     }
 }
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_type_val.cpp b/shared_data/source/shared_data/file_operations/operation_type_val.cpp
deleted file mode 100644
index 57992b3b..00000000
--- a/shared_data/source/shared_data/file_operations/operation_type_val.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#include <shared_data/file_operations/operation_type.hpp>
-
-namespace SharedData
-{
-    void to_val(Nui::val& v, OperationType const& operationType)
-    {
-        switch (operationType)
-        {
-            case OperationType::Download:
-                v = Nui::val::u8string("Download");
-                break;
-            case OperationType::Upload:
-                v = Nui::val::u8string("Upload");
-                break;
-            case OperationType::Rename:
-                v = Nui::val::u8string("Rename");
-                break;
-            case OperationType::Delete:
-                v = Nui::val::u8string("Delete");
-                break;
-            case OperationType::Scan:
-                v = Nui::val::u8string("Scan");
-                break;
-            case OperationType::BulkDownload:
-                v = Nui::val::u8string("BulkDownload");
-                break;
-        }
-    }
-    void from_val(Nui::val const& v, OperationType& operationType)
-    {
-        auto const str = v.template as<std::string>();
-        if (str == "Download")
-            operationType = OperationType::Download;
-        else if (str == "Upload")
-            operationType = OperationType::Upload;
-        else if (str == "Rename")
-            operationType = OperationType::Rename;
-        else if (str == "Delete")
-            operationType = OperationType::Delete;
-        else if (str == "Scan")
-            operationType = OperationType::Scan;
-        else if (str == "BulkDownload")
-            operationType = OperationType::BulkDownload;
-        else
-            throw std::runtime_error("Invalid OperationType string: " + str);
-    }
-}
\ No newline at end of file
diff --git a/static/styles/main.css b/static/styles/main.css
index 626b5d3d..2c3cad30 100644
--- a/static/styles/main.css
+++ b/static/styles/main.css
@@ -5,6 +5,7 @@
 @import "./session.css";
 @import "./sidebar.css";
 @import "./toolbar.css";
+@import "./operation_queue.css";
 @import "../../../../../nui-file-explorer/styles/file_grid.css";
 @import "../../../../../nui-file-explorer/styles/dropdown_menu.css";
 
diff --git a/static/styles/operation_queue.css b/static/styles/operation_queue.css
new file mode 100644
index 00000000..02230661
--- /dev/null
+++ b/static/styles/operation_queue.css
@@ -0,0 +1,185 @@
+.operation-queue {
+    max-width: 920px;
+    margin: 36px auto;
+    padding: 20px
+}
+
+header.opq-controls {
+    display: flex;
+    gap: 12px;
+    align-items: center;
+    margin-bottom: 16px
+}
+
+.opq-play-toggle {
+    display: inline-flex;
+    align-items: center;
+    gap: 8px;
+    padding: 8px 12px;
+    border-radius: 10px;
+    border: 1px solid var(--border);
+    background: linear-gradient(180deg, rgba(255, 255, 255, 0.02), transparent);
+    cursor: pointer
+}
+
+.opq-play-toggle .opq-icon {
+    width: 18px;
+    height: 18px;
+    display: inline-grid;
+    place-items: center
+}
+
+.opq-play-toggle .opq-label {
+    font-weight: 600
+}
+
+.opq-summary {
+    margin-left: auto;
+    color: var(--muted);
+    font-size: 14px
+}
+
+.opq-list {
+    display: flex;
+    flex-direction: column;
+    gap: 12px
+}
+
+.opq-card {
+    border: 1px solid var(--border);
+    background: linear-gradient(180deg, rgba(255, 255, 255, 0.01), transparent);
+    border-radius: 12px;
+    overflow: hidden;
+    transition: box-shadow .18s ease
+}
+
+.opq-card:hover {
+    box-shadow: 0 8px 30px rgba(0, 0, 0, 0.45)
+}
+
+.opq-header {
+    display: flex;
+    gap: 12px;
+    padding: 12px 14px;
+    align-items: center
+}
+
+.opq-type {
+    width: 36px;
+    height: 36px;
+    border-radius: 8px;
+    display: grid;
+    place-items: center;
+    font-weight: 700;
+    border: 1px solid rgba(255, 255, 255, 0.03)
+}
+
+.opq-title {
+    flex: 1
+}
+
+.opq-actions {
+    display: flex;
+    gap: 8px;
+    align-items: center
+}
+
+.opq-btn {
+    padding: 6px 10px;
+    border-radius: 8px;
+    border: 1px solid var(--border);
+    background: transparent;
+    color: var(--muted);
+    cursor: pointer;
+    font-size: 13px
+}
+
+.opq-btn[aria-pressed="true"] {
+    background: rgba(255, 255, 255, 0.02);
+    color: var(--accent)
+}
+
+.opq-cancel-btn {
+    color: #ffb3b3
+}
+
+/* dynamic content area */
+.opq-body {
+    padding: 10px 14px;
+    border-top: 1px dashed rgba(255, 255, 255, 0.03);
+    overflow: hidden;
+    transition: max-height .35s cubic-bezier(.2, .9, .2, 1), opacity .25s ease;
+    padding-bottom: 12px
+}
+
+.opq-body.opq-collapsed {
+    max-height: 0;
+    padding-top: 0;
+    padding-bottom: 0;
+    opacity: 0
+}
+
+/* states */
+.opq-completed .opq-header {
+    background: linear-gradient(90deg, rgba(126, 231, 135, 0.06), transparent)
+}
+
+.opq-completed .opq-type {
+    background: rgba(126, 231, 135, 0.07);
+    border-color: rgba(126, 231, 135, 0.12);
+    color: var(--lime)
+}
+
+.opq-failed .opq-header {
+    background: linear-gradient(90deg, rgba(255, 107, 107, 0.06), transparent)
+}
+
+.opq-failed .opq-type {
+    background: rgba(255, 107, 107, 0.06);
+    border-color: rgba(255, 107, 107, 0.12);
+    color: var(--red)
+}
+
+.opq-canceled .opq-header {
+    background: linear-gradient(90deg, rgba(153, 153, 153, 0.04), transparent)
+}
+
+.opq-canceled .opq-type {
+    background: rgba(153, 153, 153, 0.04);
+    border-color: rgba(153, 153, 153, 0.12);
+    color: var(--gray)
+}
+
+/* pending state (default) */
+.opq-pending .opq-header {
+    background: transparent
+}
+
+/* collapse animation for header when finishing: shrink padding and reduce height subtly */
+.opq-card.opq-folded .opq-header {
+    padding-top: 8px;
+    padding-bottom: 8px
+}
+
+/* small helper */
+.opq-muted {
+    color: var(--muted);
+    font-size: 13px
+}
+
+/* tiny icons as simple shapes */
+.opq-icon-play,
+.opq-icon-pause,
+.opq-icon-download,
+.opq-icon-upload,
+.opq-icon-scan {
+    width: 16px;
+    height: 16px
+}
+
+.opq-pill {
+    padding: 4px 8px;
+    border-radius: 999px;
+    border: 1px solid rgba(255, 255, 255, 0.03);
+    font-size: 12px
+}
\ No newline at end of file

From 1a2687a128ce4c90239a8cd03fdcc46c41a3cfd7 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sun, 12 Oct 2025 02:55:04 +0200
Subject: [PATCH 39/42] Made download progress work and look better.

---
 .../backend/sftp/download_operation.cpp       |  13 +-
 .../source/backend/sftp/operation_queue.cpp   |   8 +-
 .../source/backend/sftp/scan_operation.cpp    |   4 +-
 .../session_components/operation_queue.cpp    | 130 ++++++++++++------
 .../file_operations/operation_added.hpp       |   4 +-
 .../file_operations/operation_completed.hpp   |  32 ++++-
 .../file_operations/operation_error.hpp       |   6 +
 .../include/shared_data/shared_data.hpp       |   1 +
 .../file_operations/operation_added.cpp       |  17 +++
 static/styles/main.css                        |  11 +-
 static/styles/operation_queue.css             |  22 +--
 11 files changed, 180 insertions(+), 68 deletions(-)

diff --git a/backend/source/backend/sftp/download_operation.cpp b/backend/source/backend/sftp/download_operation.cpp
index 2c32788a..b45b97b7 100644
--- a/backend/source/backend/sftp/download_operation.cpp
+++ b/backend/source/backend/sftp/download_operation.cpp
@@ -30,7 +30,7 @@ DownloadOperation::DownloadOperation(
 
 DownloadOperation::~DownloadOperation()
 {
-    std::ignore = cancel(true);
+    std::ignore = cancel(false);
 
     if (auto stream = fileStream_.lock(); stream)
     {
@@ -308,13 +308,14 @@ std::expected<void, Operation::Error> DownloadOperation::prepare()
 
 std::expected<void, DownloadOperation::Error> DownloadOperation::cancel(bool adoptCancelState)
 {
-    Log::info(
-        "DownloadOperation: Download of '{}' to '{}' canceled.",
-        remotePath_.generic_string(),
-        localPath_.generic_string());
-
     if (adoptCancelState)
+    {
+        Log::info(
+            "DownloadOperation: Download of '{}' to '{}' canceled.",
+            remotePath_.generic_string(),
+            localPath_.generic_string());
         state_ = OperationState::Canceled;
+    }
 
     cleanup();
     return {};
diff --git a/backend/source/backend/sftp/operation_queue.cpp b/backend/source/backend/sftp/operation_queue.cpp
index 141fa2a6..f6a18fc0 100644
--- a/backend/source/backend/sftp/operation_queue.cpp
+++ b/backend/source/backend/sftp/operation_queue.cpp
@@ -218,7 +218,7 @@ std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
                                 .current = current,
                             });
 
-                        Log::info(
+                        Log::debug(
                             "Downloaded {} / {} bytes ({}%)",
                             current - min,
                             max - min,
@@ -242,7 +242,11 @@ std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
         hub_->callRemote(
             fmt::format("OperationQueue::{}::onOperationAdded", sessionId_.value()),
             SharedData::OperationAdded{
-                .operationId = operationId, .type = SharedData::OperationType::Download, .totalBytes = fileSize});
+                .operationId = operationId,
+                .type = SharedData::OperationType::Download,
+                .totalBytes = fileSize,
+                .localPath = localPath,
+                .remotePath = remotePath});
 
         return {};
     }
diff --git a/backend/source/backend/sftp/scan_operation.cpp b/backend/source/backend/sftp/scan_operation.cpp
index 5ead80e1..0c0bf6c1 100644
--- a/backend/source/backend/sftp/scan_operation.cpp
+++ b/backend/source/backend/sftp/scan_operation.cpp
@@ -111,9 +111,11 @@ std::expected<ScanOperation::WorkStatus, ScanOperation::Error> ScanOperation::wo
 
 std::expected<void, ScanOperation::Error> ScanOperation::cancel(bool adoptCancelState)
 {
-    Log::info("ScanOperation: Scan of '{}' canceled.", remotePath_.generic_string());
     if (adoptCancelState)
+    {
+        Log::info("ScanOperation: Scan of '{}' canceled.", remotePath_.generic_string());
         enterState(OperationState::Canceled);
+    }
     return {};
 }
 
diff --git a/frontend/source/frontend/session_components/operation_queue.cpp b/frontend/source/frontend/session_components/operation_queue.cpp
index 97fc0ddb..d9962ad6 100644
--- a/frontend/source/frontend/session_components/operation_queue.cpp
+++ b/frontend/source/frontend/session_components/operation_queue.cpp
@@ -25,6 +25,8 @@
 
 namespace
 {
+    constexpr std::string_view progressHeight = "15px";
+
     namespace Svgs
     {
         Nui::ElementRenderer play()
@@ -138,8 +140,9 @@ namespace
     class OperationCard
     {
       public:
-        explicit OperationCard(SharedData::OperationType type)
+        explicit OperationCard(SharedData::OperationType type, Ids::OperationId operationId)
             : type_{type}
+            , operationId_{std::move(operationId)}
         {}
 
         std::string formattedState() const
@@ -166,13 +169,23 @@ namespace
 
             // clang-format off
             return section{
-                class_ = "opq-card"
+                class_ = observe(state_).generate([this](){
+                    const auto state = state_.value();
+                    if (state == SharedData::OperationState::Completed)
+                        return "opq-card opq-completed opq-folded";
+                    else if (state == SharedData::OperationState::Failed)
+                        return "opq-card opq-failed opq-folded";
+                    else if (state == SharedData::OperationState::Canceled)
+                        return "opq-card opq-canceled opq-folded";
+                    else
+                        return "opq-card";
+                }),
             }(
                 div {
                     class_ = "opq-header",
                 }(
                     div {
-                        class_ = "type"
+                        class_ = "opq-type"
                     }(
                         [this]() -> Nui::ElementRenderer {
                             if (type_ == SharedData::OperationType::Download)
@@ -190,7 +203,7 @@ namespace
                     div {
                         class_ = "opq-title"
                     }(
-                        div{}(title_),
+                        div{}(static_cast<Derived const*>(this)->title()),
                         div {
                             class_ = "opq-muted"
                         // TODO: Build this string correctly
@@ -228,21 +241,27 @@ namespace
         Nui::Observed<SharedData::OperationState> state_{SharedData::OperationState::NotStarted};
         SharedData::OperationType type_;
         Ids::OperationId operationId_;
-        Nui::Observed<std::string> title_{"Not started"};
     };
 
     class DisplayedDownloadOperation : public OperationCard<DisplayedDownloadOperation>
     {
       public:
-        DisplayedDownloadOperation(long long min, long long max)
-            : OperationCard{SharedData::OperationType::Download}
+        DisplayedDownloadOperation(
+            long long min,
+            long long max,
+            Ids::OperationId operationId,
+            std::filesystem::path localPath,
+            std::filesystem::path remotePath)
+            : OperationCard{SharedData::OperationType::Download, std::move(operationId)}
             , progressBar_{{
-                  .height = "10px",
+                  .height = std::string{progressHeight},
                   .min = min,
                   .max = max,
                   .showMinMax = true,
                   .byteMode = true,
               }}
+            , localPath_{std::move(localPath)}
+            , remotePath_{std::move(remotePath)}
         {}
 
         Nui::ElementRenderer body() const
@@ -254,11 +273,17 @@ namespace
 
             // clang-format off
             return div{
-                class_ = "opq-body",
+                class_ = observe(state_).generate([this](){
+                    const auto state = state_.value();
+                    if (state == SharedData::OperationState::Completed || state == SharedData::OperationState::Failed || state == SharedData::OperationState::Canceled)
+                        return "opq-body opq-collapsed";
+                    else
+                        return "opq-body";
+                }),
             }(
                 div{
                     class_ = "opq-muted"
-                }("Dynamic content area — this would show progress, nested items, details, etc."),
+                }("Dynamic content area - this would show progress, nested items, details, etc."),
                 progressBar_()
             );
             // clang-format on
@@ -269,8 +294,15 @@ namespace
             progressBar_.setProgress(current);
         }
 
+        std::string title() const
+        {
+            return fmt::format("Download '{}' to '{}'", remotePath_.generic_string(), localPath_.generic_string());
+        }
+
       private:
         ProgressBar progressBar_;
+        std::filesystem::path localPath_;
+        std::filesystem::path remotePath_;
     };
 
     struct DisplayedOperation
@@ -283,6 +315,28 @@ namespace
         {
             return operationId;
         }
+
+        SharedData::OperationState state() const
+        {
+            return Utility::visitOverloaded(
+                details,
+                [](auto const& op) {
+                    return op.state();
+                },
+                [](std::monostate) {
+                    return SharedData::OperationState::NotStarted;
+                });
+        }
+
+        void state(SharedData::OperationState newState)
+        {
+            return Utility::visitOverloaded(
+                details,
+                [newState](auto& op) {
+                    op.state(newState);
+                },
+                [](std::monostate) {});
+        }
     };
 }
 
@@ -334,6 +388,14 @@ void OperationQueue::activate(FileEngine* fileEngine, Ids::SessionId sessionId)
         Nui::RpcClient::autoRegisterFunction(
             fmt::format("OperationQueue::{}::onOperationAdded", impl_->sessionId.value()),
             [this](SharedData::OperationAdded const& added) {
+                if (!added.localPath || !added.remotePath)
+                {
+                    Log::error(
+                        "Received OperationAdded for operation id: {} without localPath or remotePath",
+                        added.operationId.value());
+                    return;
+                }
+
                 impl_->operations.insert(
                     added.operationId,
                     DisplayedOperation{
@@ -342,7 +404,11 @@ void OperationQueue::activate(FileEngine* fileEngine, Ids::SessionId sessionId)
                         .details = [&added]() -> decltype(DisplayedOperation::details) {
                             if (added.type == SharedData::OperationType::Download)
                                 return DisplayedDownloadOperation{
-                                    0, added.totalBytes ? static_cast<long long>(*added.totalBytes) : 0};
+                                    0,
+                                    added.totalBytes ? static_cast<long long>(*added.totalBytes) : 0,
+                                    added.operationId,
+                                    *added.localPath,
+                                    *added.remotePath};
                             return std::monostate{};
                         }()});
                 Nui::globalEventContext.executeActiveEventsImmediately();
@@ -352,7 +418,7 @@ void OperationQueue::activate(FileEngine* fileEngine, Ids::SessionId sessionId)
         Nui::RpcClient::autoRegisterFunction(
             fmt::format("OperationQueue::{}::onDownloadProgress", impl_->sessionId.value()),
             [this](SharedData::DownloadProgress const& progress) {
-                Log::info(
+                Log::debug(
                     "Received download progress for operation id: {} - {}/{}",
                     progress.operationId.value(),
                     progress.current - progress.min,
@@ -398,41 +464,21 @@ void OperationQueue::activate(FileEngine* fileEngine, Ids::SessionId sessionId)
                 {
                     case (SharedData::OperationCompletionReason::Completed):
                     {
-                        Utility::visitOverloaded(
-                            operation->details,
-                            [](auto& op) {
-                                op.state(SharedData::OperationState::Completed);
-                            },
-                            [](std::monostate) {
-                                // Nothing to do
-                            });
+                        operation->state(SharedData::OperationState::Completed);
                         break;
                     }
                     case (SharedData::OperationCompletionReason::Canceled):
                     {
-                        Utility::visitOverloaded(
-                            operation->details,
-                            [](auto& op) {
-                                op.state(SharedData::OperationState::Canceled);
-                            },
-                            [](std::monostate) {
-                                // Nothing to do
-                            });
+                        operation->state(SharedData::OperationState::Canceled);
                         break;
                     }
                     case (SharedData::OperationCompletionReason::Failed):
                     {
-                        Utility::visitOverloaded(
-                            operation->details,
-                            [](auto& op) {
-                                op.state(SharedData::OperationState::Failed);
-                            },
-                            [](std::monostate) {
-                                // Nothing to do
-                            });
+                        operation->state(SharedData::OperationState::Failed);
                         break;
                     }
                 }
+                Nui::globalEventContext.executeActiveEventsImmediately();
             }));
 }
 
@@ -458,10 +504,14 @@ Nui::ElementRenderer OperationQueue::operator()()
             element.details));
     };
 
+    auto makeSummaryText = [this]() -> std::string {
+        return fmt::format("{} total operations", impl_->operations.observedValues().value().size());
+    };
+
     // clang-format off
     return div{
         class_ = "operation-queue",
-        style = "width: 100%; height: auto; display: block",
+        style = "width: 100%; height: auto; display: block; overflow-y: scroll",
     }(
         header{
             class_ = "opq-controls"
@@ -495,9 +545,11 @@ Nui::ElementRenderer OperationQueue::operator()()
                 strong{id = "queueCount"}("0")
             ),
             div{
-                class_ = "summary",
+                class_ = "opq-summary",
                 id = "summaryText"
-            }("No operations yet")
+            }(
+                observe(impl_->operations.observedValues()).generate(makeSummaryText)
+            )
         ),
         // Main content
         div{}(
diff --git a/shared_data/include/shared_data/file_operations/operation_added.hpp b/shared_data/include/shared_data/file_operations/operation_added.hpp
index cf1c9a3d..8c05805d 100644
--- a/shared_data/include/shared_data/file_operations/operation_added.hpp
+++ b/shared_data/include/shared_data/file_operations/operation_added.hpp
@@ -14,8 +14,10 @@ namespace SharedData
         Ids::OperationId operationId;
         OperationType type;
         std::optional<std::uint64_t> totalBytes{std::nullopt};
+        std::optional<std::filesystem::path> localPath{};
+        std::optional<std::filesystem::path> remotePath{};
     };
-    BOOST_DESCRIBE_STRUCT(OperationAdded, (), (operationId, type, totalBytes))
+    BOOST_DESCRIBE_STRUCT(OperationAdded, (), (operationId, type, totalBytes, localPath, remotePath))
 
     void to_json(nlohmann::json& j, OperationAdded const& operationAdded);
     void from_json(nlohmann::json const& j, OperationAdded& operationAdded);
diff --git a/shared_data/include/shared_data/file_operations/operation_completed.hpp b/shared_data/include/shared_data/file_operations/operation_completed.hpp
index c20267dd..a0dfd315 100644
--- a/shared_data/include/shared_data/file_operations/operation_completed.hpp
+++ b/shared_data/include/shared_data/file_operations/operation_completed.hpp
@@ -45,39 +45,57 @@ namespace SharedData
     inline void to_val(Nui::val& v, OperationCompleted const& operationCompleted)
     {
         v = Nui::val::object();
-        v.set("reason", operationCompleted.reason);
-        v.set("operationId", operationCompleted.operationId);
+
+        v.set("reason", Nui::convertToVal(operationCompleted.reason));
+        v.set("operationId", Nui::convertToVal(operationCompleted.operationId));
+
         v.set(
             "completionTime",
             static_cast<int64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(
                                      operationCompleted.completionTime.time_since_epoch())
                                      .count()));
+
         if (operationCompleted.localPath.has_value())
             v.set("localPath", Nui::val::u8string(operationCompleted.localPath->generic_string().c_str()));
         else
             v.set("localPath", Nui::val::null());
+
         if (operationCompleted.remotePath.has_value())
             v.set("remotePath", Nui::val::u8string(operationCompleted.remotePath->generic_string().c_str()));
         else
             v.set("remotePath", Nui::val::null());
+
         if (operationCompleted.error.has_value())
-            v.set("error", Nui::val(operationCompleted.error.value()));
+        {
+            Nui::val error;
+            to_val(error, *operationCompleted.error);
+            v.set("error", error);
+        }
         else
             v.set("error", Nui::val::null());
     }
     inline void from_val(Nui::val const& v, OperationCompleted& operationCompleted)
     {
-        operationCompleted.reason = v["reason"].template as<OperationCompletionReason>();
-        operationCompleted.operationId = v["operationId"].template as<Ids::OperationId>();
+        if (!v.hasOwnProperty("reason") || !v.hasOwnProperty("operationId") || !v.hasOwnProperty("completionTime"))
+        {
+            throw std::runtime_error("Invalid OperationCompleted object");
+        }
+
+        Nui::val reason;
+        Nui::convertFromVal(v["reason"], operationCompleted.reason);
+        Nui::convertFromVal(v["operationId"], operationCompleted.operationId);
         operationCompleted.completionTime = std::chrono::system_clock::time_point{
-            std::chrono::milliseconds{v["completionTime"].template as<int64_t>()}};
+            std::chrono::milliseconds{v["completionTime"].template as<std::int64_t>()}};
 
         if (v.hasOwnProperty("localPath") && !v["localPath"].isNull())
             operationCompleted.localPath = std::filesystem::path{v["localPath"].template as<std::string>()};
         if (v.hasOwnProperty("remotePath") && !v["remotePath"].isNull())
             operationCompleted.remotePath = std::filesystem::path{v["remotePath"].template as<std::string>()};
         if (v.hasOwnProperty("error") && !v["error"].isNull())
-            operationCompleted.error = v["error"].template as<OperationError>();
+        {
+            operationCompleted.error = OperationError{};
+            Nui::convertFromVal(v["error"], operationCompleted.error.value());
+        }
     }
 #endif
 }
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/operation_error.hpp b/shared_data/include/shared_data/file_operations/operation_error.hpp
index 6578f626..2a155b2d 100644
--- a/shared_data/include/shared_data/file_operations/operation_error.hpp
+++ b/shared_data/include/shared_data/file_operations/operation_error.hpp
@@ -34,6 +34,12 @@ namespace SecureShell
     }
     inline void from_val(Nui::val const& v, SftpError& sftpError)
     {
+        if (!v.hasOwnProperty("message") || !v.hasOwnProperty("sshError") || !v.hasOwnProperty("sftpError") ||
+            !v.hasOwnProperty("wrapperError"))
+        {
+            throw std::runtime_error("Invalid SftpError object");
+        }
+
         sftpError.message = v["message"].template as<std::string>();
         sftpError.sshError = v["sshError"].template as<int>();
         sftpError.sftpError = v["sftpError"].template as<int>();
diff --git a/shared_data/include/shared_data/shared_data.hpp b/shared_data/include/shared_data/shared_data.hpp
index 29bd1b23..e0b0f002 100644
--- a/shared_data/include/shared_data/shared_data.hpp
+++ b/shared_data/include/shared_data/shared_data.hpp
@@ -5,4 +5,5 @@
 
 #ifdef NUI_FRONTEND
 #    include <nui/frontend/val.hpp>
+#    include <nui/frontend/utility/val_conversion.hpp>
 #endif
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_added.cpp b/shared_data/source/shared_data/file_operations/operation_added.cpp
index 11a36fe6..42b4ad6c 100644
--- a/shared_data/source/shared_data/file_operations/operation_added.cpp
+++ b/shared_data/source/shared_data/file_operations/operation_added.cpp
@@ -11,12 +11,29 @@ namespace SharedData
 
         if (operationAdded.totalBytes.has_value())
             j["totalBytes"] = operationAdded.totalBytes.value();
+        if (operationAdded.localPath.has_value())
+            j["localPath"] = operationAdded.localPath->generic_string();
+        if (operationAdded.remotePath.has_value())
+            j["remotePath"] = operationAdded.remotePath->generic_string();
     }
     void from_json(nlohmann::json const& j, OperationAdded& operationAdded)
     {
         j.at("operationId").get_to(operationAdded.operationId);
         j.at("type").get_to(operationAdded.type);
+
         if (j.contains("totalBytes") && !j.at("totalBytes").is_null())
             j.at("totalBytes").get_to(*operationAdded.totalBytes);
+        else
+            operationAdded.totalBytes = std::nullopt;
+
+        if (j.contains("localPath") && !j.at("localPath").is_null())
+            operationAdded.localPath = j.at("localPath").get<std::string>();
+        else
+            operationAdded.localPath = std::nullopt;
+
+        if (j.contains("remotePath") && !j.at("remotePath").is_null())
+            operationAdded.remotePath = j.at("remotePath").get<std::string>();
+        else
+            operationAdded.remotePath = std::nullopt;
     }
 }
\ No newline at end of file
diff --git a/static/styles/main.css b/static/styles/main.css
index 2c3cad30..ad830157 100644
--- a/static/styles/main.css
+++ b/static/styles/main.css
@@ -41,7 +41,8 @@ body {
     margin: 0;
     background-color: var(--sapBackgroundColor);
     color: var(--sapTextColor);
-    font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
+    /* font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif; */
+    font-family: Inter, ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial;
     --resizeHandleColor: #707070;
     --brighterBackground: #404040;
 
@@ -61,4 +62,12 @@ body {
     --nui-file-grid-dropdown-item-color: var(--sapTextColor);
     --nui-file-grid-dropdown-content-font-size: var(--sapFontLargeSize);
     --nui-file-grid-context-menu-background: var(--sapGroup_ContentBackground);
+
+    --opq-card: #0b1220;
+    --opq-muted: #98a2b3;
+    --opq-lime: #7EE787;
+    --opq-red: #ff6b6b;
+    --opq-gray: #9aa0a6;
+    --opq-accent: #2563eb;
+    --opq-border: rgba(255, 255, 255, 0.06);
 }
\ No newline at end of file
diff --git a/static/styles/operation_queue.css b/static/styles/operation_queue.css
index 02230661..aaafd26a 100644
--- a/static/styles/operation_queue.css
+++ b/static/styles/operation_queue.css
@@ -1,6 +1,6 @@
 .operation-queue {
     max-width: 920px;
-    margin: 36px auto;
+    margin: auto auto;
     padding: 20px
 }
 
@@ -17,7 +17,7 @@ header.opq-controls {
     gap: 8px;
     padding: 8px 12px;
     border-radius: 10px;
-    border: 1px solid var(--border);
+    border: 1px solid var(--opq-border);
     background: linear-gradient(180deg, rgba(255, 255, 255, 0.02), transparent);
     cursor: pointer
 }
@@ -35,7 +35,7 @@ header.opq-controls {
 
 .opq-summary {
     margin-left: auto;
-    color: var(--muted);
+    color: var(--opq-muted);
     font-size: 14px
 }
 
@@ -46,7 +46,7 @@ header.opq-controls {
 }
 
 .opq-card {
-    border: 1px solid var(--border);
+    border: 1px solid var(--opq-border);
     background: linear-gradient(180deg, rgba(255, 255, 255, 0.01), transparent);
     border-radius: 12px;
     overflow: hidden;
@@ -87,16 +87,16 @@ header.opq-controls {
 .opq-btn {
     padding: 6px 10px;
     border-radius: 8px;
-    border: 1px solid var(--border);
+    border: 1px solid var(--opq-border);
     background: transparent;
-    color: var(--muted);
+    color: var(--opq-muted);
     cursor: pointer;
     font-size: 13px
 }
 
 .opq-btn[aria-pressed="true"] {
     background: rgba(255, 255, 255, 0.02);
-    color: var(--accent)
+    color: var(--opq-accent)
 }
 
 .opq-cancel-btn {
@@ -127,7 +127,7 @@ header.opq-controls {
 .opq-completed .opq-type {
     background: rgba(126, 231, 135, 0.07);
     border-color: rgba(126, 231, 135, 0.12);
-    color: var(--lime)
+    color: var(--opq-lime)
 }
 
 .opq-failed .opq-header {
@@ -137,7 +137,7 @@ header.opq-controls {
 .opq-failed .opq-type {
     background: rgba(255, 107, 107, 0.06);
     border-color: rgba(255, 107, 107, 0.12);
-    color: var(--red)
+    color: var(--opq-red)
 }
 
 .opq-canceled .opq-header {
@@ -147,7 +147,7 @@ header.opq-controls {
 .opq-canceled .opq-type {
     background: rgba(153, 153, 153, 0.04);
     border-color: rgba(153, 153, 153, 0.12);
-    color: var(--gray)
+    color: var(--opq-gray)
 }
 
 /* pending state (default) */
@@ -163,7 +163,7 @@ header.opq-controls {
 
 /* small helper */
 .opq-muted {
-    color: var(--muted);
+    color: var(--opq-muted);
     font-size: 13px
 }
 

From 8e303b09f4b7e1780858cb7e67e45f6da5cec99b Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Sun, 12 Oct 2025 19:24:09 +0200
Subject: [PATCH 40/42] Made single downloads work fully and cancelable.

---
 _cmake/dependencies/spdlog.cmake              |   2 +-
 backend/include/backend/rpc_helper.hpp        |   8 +-
 backend/include/backend/session.hpp           |  10 +-
 .../include/backend/sftp/operation_queue.hpp  |   7 +
 backend/source/backend/session.cpp            |  78 +++++--
 .../backend/sftp/download_operation.cpp       |   2 +-
 .../source/backend/sftp/operation_queue.cpp   |  59 ++++-
 .../test/backend/test_download_operation.hpp  |  15 +-
 .../frontend/components/progress_bar.hpp      |   7 +
 .../frontend/observed_random_access_map.hpp   |  29 +--
 .../session_components/operation_queue.hpp    |   4 +
 .../frontend/components/progress_bar.cpp      |   5 +
 .../session_components/operation_queue.cpp    | 206 ++++++++++++++----
 .../include/persistence/state_holder.hpp      |   1 -
 .../include/shared_data/error_or_success.hpp  | 102 +++++++++
 .../file_operations/download_progress.hpp     |   3 -
 .../file_operations/operation_added.hpp       |   3 -
 .../file_operations/operation_completed.hpp   |  81 +------
 .../file_operations/operation_error.hpp       |  81 ++-----
 .../file_operations/operation_error_type.hpp  |  14 --
 .../file_operations/operation_state.hpp       |  14 --
 .../file_operations/operation_type.hpp        |  14 --
 shared_data/include/shared_data/is_paused.hpp |  12 +
 .../include/shared_data/shared_data.hpp       |  90 +++++++-
 .../include/shared_data/time_point.hpp        |  64 ++++++
 shared_data/source/shared_data/CMakeLists.txt |   6 -
 .../file_operations/download_progress.cpp     |  21 --
 .../file_operations/operation_added.cpp       |  39 ----
 .../file_operations/operation_completed.cpp   |  54 -----
 .../file_operations/operation_error.cpp       |  49 -----
 .../file_operations/operation_state.cpp       |  13 --
 .../file_operations/operation_type.cpp        |  13 --
 ssh/include/ssh/file_stream.hpp               |  15 +-
 ssh/include/ssh/file_stream_interface.hpp     |  14 +-
 ssh/include/ssh/mocks/file_stream_mock.hpp    |   9 +-
 ssh/source/ssh/file_stream.cpp                |  48 ++--
 ssh/test/ssh/test_sftp.hpp                    |  12 +-
 static/styles/operation_queue.css             |  10 +-
 .../utility/traits_and_concepts/optional.hpp  |  32 +++
 39 files changed, 743 insertions(+), 503 deletions(-)
 create mode 100644 shared_data/include/shared_data/error_or_success.hpp
 create mode 100644 shared_data/include/shared_data/is_paused.hpp
 create mode 100644 shared_data/include/shared_data/time_point.hpp
 delete mode 100644 shared_data/source/shared_data/file_operations/download_progress.cpp
 delete mode 100644 shared_data/source/shared_data/file_operations/operation_added.cpp
 delete mode 100644 shared_data/source/shared_data/file_operations/operation_completed.cpp
 delete mode 100644 shared_data/source/shared_data/file_operations/operation_error.cpp
 delete mode 100644 shared_data/source/shared_data/file_operations/operation_state.cpp
 delete mode 100644 shared_data/source/shared_data/file_operations/operation_type.cpp
 create mode 100644 utility/include/utility/traits_and_concepts/optional.hpp

diff --git a/_cmake/dependencies/spdlog.cmake b/_cmake/dependencies/spdlog.cmake
index f64ef8e8..70055da2 100755
--- a/_cmake/dependencies/spdlog.cmake
+++ b/_cmake/dependencies/spdlog.cmake
@@ -4,7 +4,7 @@ include(FetchContent)
 FetchContent_Declare(
     spdlog
     GIT_REPOSITORY https://github.com/gabime/spdlog.git
-    GIT_TAG        ae1de0dc8cf480f54eaa425c4a9dc4fef29b28ba
+    GIT_TAG        v1.16.0
 )
 
 FetchContent_MakeAvailable(spdlog)
diff --git a/backend/include/backend/rpc_helper.hpp b/backend/include/backend/rpc_helper.hpp
index 095a84fc..c3693de4 100644
--- a/backend/include/backend/rpc_helper.hpp
+++ b/backend/include/backend/rpc_helper.hpp
@@ -148,7 +148,9 @@ namespace RpcHelper
                     {
                         "error",
                         fmt::format(
-                            "Missing parameter to function '{}': {}", functionName_, keyChain | std::views::join),
+                            "Missing parameter to function '{}': {}",
+                            functionName_,
+                            keyChain | std::views::join | std::ranges::to<std::string>()),
                     },
                 });
                 return false;
@@ -297,11 +299,9 @@ namespace RpcHelper
             timer_.expires_after(delay);
             timer_.async_wait([func = std::forward<decltype(func)>(func)](auto const& ec) {
                 if (ec)
-                {
                     Log::info("Timer canceled in within_strand_do_delayed: {}", ec.message());
-                    return;
-                }
 
+                // Run func anyway, if its because of a shutdown, it will stop early.
                 func();
             });
         }
diff --git a/backend/include/backend/session.hpp b/backend/include/backend/session.hpp
index b8ffd073..562e337c 100644
--- a/backend/include/backend/session.hpp
+++ b/backend/include/backend/session.hpp
@@ -24,6 +24,8 @@ class Session
 {
   public:
     constexpr static auto futureTimeout = std::chrono::seconds{10};
+    constexpr static auto queueStartThrottle = std::chrono::milliseconds{5};
+    constexpr static auto queueMaxThrottle = std::chrono::seconds{3};
 
     Session(
         Ids::SessionId id,
@@ -118,8 +120,8 @@ class Session
      * }
      */
     void registerRpcSftpCreateFile();
-
     void registerRpcSftpAddDownloadOperation();
+    void registerOperationQueuePauseUnpause();
 
     void removeChannel(Ids::ChannelId channelId);
 
@@ -183,10 +185,16 @@ class Session
 
     void doOperationQueueWork();
 
+  private:
+    void resetQueueThrottle();
+
   private:
     Ids::SessionId id_;
+    /// Has nothing to do with pause/unpause - this is used for shutdown of the session.
     std::atomic_bool running_;
     std::chrono::milliseconds operationThrottle_{5};
+    bool queueThrottleTimerIsRunning_{false};
+    int unthrottledLimitCounter_{0};
     std::unique_ptr<SecureShell::Session> session_{};
     std::unordered_map<Ids::ChannelId, std::weak_ptr<SecureShell::Channel>, Ids::IdHash> channels_{};
     std::unordered_map<Ids::ChannelId, std::weak_ptr<SecureShell::SftpSession>, Ids::IdHash> sftpChannels_{};
diff --git a/backend/include/backend/sftp/operation_queue.hpp b/backend/include/backend/sftp/operation_queue.hpp
index 903ea2e8..fa873c6e 100644
--- a/backend/include/backend/sftp/operation_queue.hpp
+++ b/backend/include/backend/sftp/operation_queue.hpp
@@ -12,6 +12,7 @@
 #include <filesystem>
 #include <memory>
 #include <utility>
+#include <atomic>
 
 class OperationQueue
     : public RpcHelper::StrandRpc
@@ -49,6 +50,11 @@ class OperationQueue
         std::filesystem::path const& localPath,
         std::filesystem::path const& remotePath);
 
+    void registerRpc();
+
+    bool paused() const;
+    void paused(bool pause);
+
   private:
     void completeOperation(OperationCompleted&& operationCompleted);
 
@@ -56,5 +62,6 @@ class OperationQueue
     Persistence::SftpOptions sftpOpts_{};
     Ids::SessionId sessionId_{};
     std::deque<std::pair<Ids::OperationId, std::unique_ptr<Operation>>> operations_{};
+    std::atomic_bool paused_{true};
     int parallelism_{1};
 };
diff --git a/backend/source/backend/session.cpp b/backend/source/backend/session.cpp
index fadd1210..ab5107f1 100644
--- a/backend/source/backend/session.cpp
+++ b/backend/source/backend/session.cpp
@@ -1,6 +1,7 @@
 #include <backend/session.hpp>
 
 #include <roar/utility/base64.hpp>
+#include <shared_data/error_or_success.hpp>
 
 using namespace std::chrono_literals;
 
@@ -42,6 +43,8 @@ void Session::start()
         self->registerRpcSftpCreateDirectory();
         self->registerRpcSftpCreateFile();
         self->registerRpcSftpAddDownloadOperation();
+        self->registerOperationQueuePauseUnpause();
+        self->operationQueue_->registerRpc();
 
         Log::info("Session '{}' connected", self->id_.value());
 
@@ -66,25 +69,46 @@ void Session::doOperationQueueWork()
         if (!self->running_)
             return;
 
-        if (self->operationQueue_ && self->operationQueue_->work())
+        if (self->operationQueue_ && !self->operationQueue_->paused() && self->operationQueue_->work())
         {
-            self->doOperationQueueWork();
-            self->operationThrottle_ = 5ms;
+            ++self->unthrottledLimitCounter_;
+            if (self->unthrottledLimitCounter_ < 10)
+            {
+                self->doOperationQueueWork();
+                self->operationThrottle_ = queueStartThrottle;
+                return;
+            }
+            self->unthrottledLimitCounter_ = 0;
         }
+
+        if (self->operationThrottle_ < queueMaxThrottle)
+            self->operationThrottle_ *= 2;
         else
-        {
-            if (self->operationThrottle_ < 1s)
-                self->operationThrottle_ *= 2;
-            else
-                self->operationThrottle_ = 1s;
+            self->operationThrottle_ = queueMaxThrottle;
 
-            self->within_strand_do_delayed(
-                [weak = self->weak_from_this()]() {
-                    if (auto self = weak.lock(); self)
-                        self->doOperationQueueWork();
-                },
-                self->operationThrottle_);
-        }
+        self->queueThrottleTimerIsRunning_ = true;
+        self->within_strand_do_delayed(
+            [weak = self->weak_from_this()]() {
+                if (auto self = weak.lock(); self)
+                {
+                    self->queueThrottleTimerIsRunning_ = false;
+                    self->doOperationQueueWork();
+                }
+            },
+            self->operationThrottle_);
+    });
+}
+
+void Session::resetQueueThrottle()
+{
+    within_strand_do([weak = weak_from_this()]() {
+        auto self = weak.lock();
+        if (!self)
+            return;
+
+        self->operationThrottle_ = queueStartThrottle;
+        if (self->queueThrottleTimerIsRunning_)
+            self->timer_.cancel();
     });
 }
 
@@ -450,8 +474,32 @@ void Session::registerRpcSftpAddDownloadOperation()
                         remotePath,
                         localPath);
 
+                    self->resetQueueThrottle();
                     reply({{"success", true}});
                 },
                 std::move(reply));
         });
+}
+
+void Session::registerOperationQueuePauseUnpause()
+{
+    on(fmt::format("OperationQueue::{}::pauseUnpause", id_.value()))
+        .perform([weak = weak_from_this()](RpcHelper::RpcOnce&& reply, bool pause) {
+            auto self = weak.lock();
+            if (!self)
+            {
+                Log::error("Session no longer exists, cannot pause/unpause operation queue");
+                return reply(SharedData::error("Session no longer exists"));
+            }
+
+            if (!self->operationQueue_)
+            {
+                Log::error("No operation queue available to pause/unpause");
+                return reply(SharedData::error("No operation queue available"));
+            }
+
+            self->operationQueue_->paused(pause);
+            self->resetQueueThrottle();
+            return reply(SharedData::success());
+        });
 }
\ No newline at end of file
diff --git a/backend/source/backend/sftp/download_operation.cpp b/backend/source/backend/sftp/download_operation.cpp
index b45b97b7..355a7c6f 100644
--- a/backend/source/backend/sftp/download_operation.cpp
+++ b/backend/source/backend/sftp/download_operation.cpp
@@ -148,7 +148,7 @@ std::expected<bool, DownloadOperation::Error> DownloadOperation::readOnce()
     bool doContinue = false;
     const auto futureStatus =
         stream
-            ->read([this, &doContinue](std::string_view data) {
+            ->readSome([this, &doContinue](std::string_view data) {
                 // No locking, because concurrent access is not possible, the only
                 // other executing thread is blocked right now.
 
diff --git a/backend/source/backend/sftp/operation_queue.cpp b/backend/source/backend/sftp/operation_queue.cpp
index f6a18fc0..56364f74 100644
--- a/backend/source/backend/sftp/operation_queue.cpp
+++ b/backend/source/backend/sftp/operation_queue.cpp
@@ -2,6 +2,8 @@
 #include <shared_data/file_operations/download_progress.hpp>
 #include <shared_data/file_operations/operation_added.hpp>
 #include <shared_data/file_operations/operation_completed.hpp>
+#include <shared_data/error_or_success.hpp>
+#include <shared_data/is_paused.hpp>
 
 #include <log/log.hpp>
 #include <utility/overloaded.hpp>
@@ -85,8 +87,11 @@ void OperationQueue::cancel(Ids::OperationId id)
         if (!self)
             return;
 
-        std::erase_if(self->operations_, [id](const auto& op) {
-            return op.first == id;
+        std::erase_if(self->operations_, [id](auto& op) {
+            bool isMatch = op.first == id;
+            if (isMatch)
+                op.second->cancel(true);
+            return isMatch;
         });
     });
 }
@@ -101,6 +106,12 @@ void OperationQueue::completeOperation(SharedData::OperationCompleted&& operatio
         if (operationCompleted.error)
             Log::error("Operation failed: {}", operationCompleted.error->toString());
 
+        Log::info(
+            "Operation completed: id={}, reason={}, localPath='{}', remotePath='{}'",
+            operationCompleted.operationId.value(),
+            static_cast<int>(operationCompleted.reason),
+            operationCompleted.localPath ? operationCompleted.localPath->generic_string() : "<none>",
+            operationCompleted.remotePath ? operationCompleted.remotePath->generic_string() : "<none>");
         self->hub_->callRemote(
             fmt::format("OperationQueue::{}::onOperationCompleted", self->sessionId_.value()),
             SharedData::OperationCompleted{
@@ -118,6 +129,9 @@ bool OperationQueue::work()
 {
     // Assumed in strand
 
+    if (paused_)
+        return false;
+
     const auto updateCount = std::min(operations_.size(), static_cast<std::size_t>(parallelism_));
 
     bool moreWork = false;
@@ -155,6 +169,21 @@ bool OperationQueue::work()
     return moreWork;
 }
 
+bool OperationQueue::paused() const
+{
+    return paused_;
+}
+void OperationQueue::paused(bool pause)
+{
+    within_strand_do([weak = weak_from_this(), pause]() {
+        auto self = weak.lock();
+        if (!self)
+            return;
+
+        self->paused_ = pause;
+    });
+}
+
 std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
     SecureShell::SftpSession& sftp,
     Ids::OperationId operationId,
@@ -204,7 +233,6 @@ std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
             DownloadOperation::DownloadOperationOptions{
                 .progressCallback =
                     [weak = weak_from_this(), operationId](auto min, auto max, auto current) {
-                        // TODO:
                         auto self = weak.lock();
                         if (!self)
                             return;
@@ -304,4 +332,29 @@ std::expected<void, Operation::Error> OperationQueue::addDownloadOperation(
         Log::error("Remote path is neither a file nor a directory: {}.", result->type);
         return std::unexpected(Operation::Error{.type = Operation::ErrorType::OperationNotPossibleOnFileType});
     }
+}
+
+void OperationQueue::registerRpc()
+{
+    on(fmt::format("OperationQueue::{}::isPaused", sessionId_.value()))
+        .perform([weak = weak_from_this()](RpcHelper::RpcOnce&& reply) {
+            auto self = weak.lock();
+            if (!self)
+                return reply(SharedData::error("OperationQueue no longer exists"));
+
+            return reply(
+                SharedData::ErrorOrSuccess{SharedData::IsPaused{
+                    .paused = self->paused(),
+                }});
+        });
+
+    on(fmt::format("OperationQueue::{}::cancel", sessionId_.value()))
+        .perform([weak = weak_from_this()](RpcHelper::RpcOnce&& reply, Ids::OperationId operationId) {
+            auto self = weak.lock();
+            if (!self)
+                return reply(SharedData::error("OperationQueue no longer exists"));
+
+            self->cancel(std::move(operationId));
+            return reply(SharedData::success());
+        });
 }
\ No newline at end of file
diff --git a/backend/test/backend/test_download_operation.hpp b/backend/test/backend/test_download_operation.hpp
index a03a4267..bf7ae4e9 100644
--- a/backend/test/backend/test_download_operation.hpp
+++ b/backend/test/backend/test_download_operation.hpp
@@ -69,7 +69,20 @@ namespace Test
 
         void giveMockExpectedRead(std::shared_ptr<::testing::NiceMock<SecureShell::Test::FileStreamMock>> const& mock)
         {
-            EXPECT_CALL(*mock, read(testing::_))
+            EXPECT_CALL(*mock, readAll(testing::_))
+                .WillRepeatedly(
+                    [this](std::function<bool(std::string_view data)> cb)
+                        -> std::future<std::expected<std::size_t, SecureShell::SftpError>> {
+                        onRead_ = std::move(cb);
+                        readPromise_ = {};
+                        if (!readCycleQueue_.empty())
+                        {
+                            readCycleQueue_.front()();
+                            readCycleQueue_.pop();
+                        }
+                        return readPromise_.get_future();
+                    });
+            EXPECT_CALL(*mock, readSome(testing::_))
                 .WillRepeatedly(
                     [this](std::function<bool(std::string_view data)> cb)
                         -> std::future<std::expected<std::size_t, SecureShell::SftpError>> {
diff --git a/frontend/include/frontend/components/progress_bar.hpp b/frontend/include/frontend/components/progress_bar.hpp
index 3eb497c1..ea5a8335 100644
--- a/frontend/include/frontend/components/progress_bar.hpp
+++ b/frontend/include/frontend/components/progress_bar.hpp
@@ -26,6 +26,13 @@ class ProgressBar
      */
     void setProgress(long long current);
 
+    /**
+     * @brief Get the maximum value of the progress bar.
+     *
+     * @return long long
+     */
+    long long max() const;
+
   private:
     void updateText();
 
diff --git a/frontend/include/frontend/observed_random_access_map.hpp b/frontend/include/frontend/observed_random_access_map.hpp
index acca6639..5ae8cf22 100644
--- a/frontend/include/frontend/observed_random_access_map.hpp
+++ b/frontend/include/frontend/observed_random_access_map.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <nui/event_system/observed_value.hpp>
+#include <log/log.hpp>
 
 #include <deque>
 #include <stdexcept>
@@ -11,21 +12,12 @@ class ObservedRandomAccessMap
   public:
     ObservedRandomAccessMap() = default;
 
-    void insert(KeyT const& key, ValueT const& value)
-    {
-        if (keyToIndexMap_.find(key) != keyToIndexMap_.end())
-            throw std::invalid_argument("Key already exists in ObservedRandomAccessMap");
-
-        observedValues_.push_back(value);
-        keyToIndexMap_[key] = observedValues_.value().size() - 1;
-    }
-
     void insert(KeyT const& key, ValueT&& value)
     {
         if (keyToIndexMap_.find(key) != keyToIndexMap_.end())
             throw std::invalid_argument("Key already exists in ObservedRandomAccessMap");
 
-        observedValues_.push_back(std::move(value));
+        observedValues_.push_back(std::make_unique<ValueT>(std::move(value)));
         keyToIndexMap_[key] = observedValues_.value().size() - 1;
     }
 
@@ -34,7 +26,7 @@ class ObservedRandomAccessMap
         if (observedValues_.value().empty())
             return;
 
-        keyToIndexMap_.erase(observedValues_.value().back().key());
+        keyToIndexMap_.erase(observedValues_.value().back()->key());
         observedValues_.pop_back();
     }
 
@@ -54,13 +46,14 @@ class ObservedRandomAccessMap
         if (it == keyToIndexMap_.end())
             throw std::out_of_range("Key not found in ObservedRandomAccessMap");
 
+        Log::info("Erasing key '{}' at index '{}'", key.value(), it->second);
         observedValues_.erase(observedValues_.begin() + it->second);
 
         // TODO: be more clever here:
         rebuildIndexMap();
     }
 
-    Nui::Observed<std::deque<ValueT>>& observedValues()
+    Nui::Observed<std::deque<std::unique_ptr<ValueT>>>& observedValues()
     {
         return observedValues_;
     }
@@ -71,7 +64,7 @@ class ObservedRandomAccessMap
         if (it == keyToIndexMap_.end())
             return nullptr;
 
-        return &observedValues_.value().at(it->second);
+        return observedValues_.value().at(it->second).get();
     }
 
     template <typename FunctionT>
@@ -81,20 +74,22 @@ class ObservedRandomAccessMap
         if (it == keyToIndexMap_.end())
             throw std::out_of_range("Key not found in ObservedRandomAccessMap");
 
-        modifier(observedValues_[it->second]);
+        modifier(*observedValues_[it->second].get());
     }
 
   private:
     void rebuildIndexMap()
     {
         keyToIndexMap_.clear();
-        for (std::size_t i = 0; i < observedValues_.value().size(); ++i)
+        std::size_t i = 0;
+        for (auto const& value : observedValues_.value())
         {
-            keyToIndexMap_[observedValues_.value().at(i).key()] = i;
+            keyToIndexMap_.emplace(value->key(), i);
+            ++i;
         }
     }
 
   private:
-    Nui::Observed<std::deque<ValueT>> observedValues_;
+    Nui::Observed<std::deque<std::unique_ptr<ValueT>>> observedValues_;
     MapT<KeyT, std::size_t> keyToIndexMap_;
 };
\ No newline at end of file
diff --git a/frontend/include/frontend/session_components/operation_queue.hpp b/frontend/include/frontend/session_components/operation_queue.hpp
index 2a9f9bb7..5b9d7802 100644
--- a/frontend/include/frontend/session_components/operation_queue.hpp
+++ b/frontend/include/frontend/session_components/operation_queue.hpp
@@ -39,6 +39,10 @@ class OperationQueue
 
     Nui::ElementRenderer operator()();
 
+  private:
+    template <typename OperationCard>
+    void cancelOperation(OperationCard const& operation);
+
   private:
     struct Implementation;
     std::unique_ptr<Implementation> impl_;
diff --git a/frontend/source/frontend/components/progress_bar.cpp b/frontend/source/frontend/components/progress_bar.cpp
index 07b3ada2..c2a61201 100644
--- a/frontend/source/frontend/components/progress_bar.cpp
+++ b/frontend/source/frontend/components/progress_bar.cpp
@@ -214,4 +214,9 @@ void ProgressBar::setProgress(long long current)
     updateText();
 
     Nui::globalEventContext.executeActiveEventsImmediately();
+}
+
+long long ProgressBar::max() const
+{
+    return impl_->max;
 }
\ No newline at end of file
diff --git a/frontend/source/frontend/session_components/operation_queue.cpp b/frontend/source/frontend/session_components/operation_queue.cpp
index d9962ad6..369f21f2 100644
--- a/frontend/source/frontend/session_components/operation_queue.cpp
+++ b/frontend/source/frontend/session_components/operation_queue.cpp
@@ -8,6 +8,8 @@
 #include <shared_data/file_operations/operation_error.hpp>
 #include <shared_data/file_operations/operation_state.hpp>
 #include <shared_data/file_operations/operation_completed.hpp>
+#include <shared_data/is_paused.hpp>
+#include <shared_data/error_or_success.hpp>
 #include <utility/convert_naming_convention.hpp>
 #include <utility/visit_overloaded.hpp>
 
@@ -20,7 +22,6 @@
 
 #include <variant>
 #include <map>
-#include <cstdint>
 #include <chrono>
 
 namespace
@@ -140,9 +141,13 @@ namespace
     class OperationCard
     {
       public:
-        explicit OperationCard(SharedData::OperationType type, Ids::OperationId operationId)
+        explicit OperationCard(
+            SharedData::OperationType type,
+            Ids::OperationId operationId,
+            std::function<void(OperationCard const& operation)> doRemoveSelf)
             : type_{type}
             , operationId_{std::move(operationId)}
+            , doRemoveSelf_{std::move(doRemoveSelf)}
         {}
 
         std::string formattedState() const
@@ -206,7 +211,6 @@ namespace
                         div{}(static_cast<Derived const*>(this)->title()),
                         div {
                             class_ = "opq-muted"
-                        // TODO: Build this string correctly
                         }(
                             Nui::observe(state_),
                             [this]() -> std::string {
@@ -216,8 +220,16 @@ namespace
                     ),
                     button {
                         class_ = "opq-btn opq-cancel-btn",
+                        onClick = [this](){
+                            cancel();
+                        }
                     }(
-                        "Cancel"
+                        observe(state_).generate([this]() -> std::string {
+                            if (isCompletedState())
+                                return "Remove";
+                            else
+                                return "Cancel";
+                        })
                     )
                 ),
                 static_cast<Derived const*>(this)->body()
@@ -225,6 +237,23 @@ namespace
             // clang-format on
         }
 
+        bool isCompletedState() const
+        {
+            const auto state = state_.value();
+            return state == SharedData::OperationState::Completed || state == SharedData::OperationState::Failed ||
+                state == SharedData::OperationState::Canceled;
+        }
+
+        void cancel() const
+        {
+            doRemoveSelf_(*this);
+        }
+
+        Ids::OperationId operationId() const
+        {
+            return operationId_;
+        }
+
         Nui::ElementRenderer elapsedTime() const
         {
             using namespace Nui::Elements;
@@ -236,26 +265,29 @@ namespace
                 "Elapsed: 0s");
         }
 
+        virtual bool warrantsCancelConfirm() const = 0;
+
       protected:
         std::chrono::steady_clock::time_point startTime_{std::chrono::steady_clock::now()};
         Nui::Observed<SharedData::OperationState> state_{SharedData::OperationState::NotStarted};
         SharedData::OperationType type_;
         Ids::OperationId operationId_;
+        std::function<void(OperationCard const& operation)> doRemoveSelf_;
     };
 
     class DisplayedDownloadOperation : public OperationCard<DisplayedDownloadOperation>
     {
       public:
         DisplayedDownloadOperation(
-            long long min,
             long long max,
             Ids::OperationId operationId,
             std::filesystem::path localPath,
-            std::filesystem::path remotePath)
-            : OperationCard{SharedData::OperationType::Download, std::move(operationId)}
+            std::filesystem::path remotePath,
+            std::function<void(OperationCard const& operation)> doRemoveSelf)
+            : OperationCard{SharedData::OperationType::Download, std::move(operationId), std::move(doRemoveSelf)}
             , progressBar_{{
                   .height = std::string{progressHeight},
-                  .min = min,
+                  .min = 0,
                   .max = max,
                   .showMinMax = true,
                   .byteMode = true,
@@ -299,6 +331,11 @@ namespace
             return fmt::format("Download '{}' to '{}'", remotePath_.generic_string(), localPath_.generic_string());
         }
 
+        bool warrantsCancelConfirm() const override
+        {
+            return !isCompletedState() && progressBar_.max() > 10'000'000; // 10 MB
+        }
+
       private:
         ProgressBar progressBar_;
         std::filesystem::path localPath_;
@@ -350,6 +387,7 @@ struct OperationQueue::Implementation
     FileEngine* fileEngine;
 
     std::vector<Nui::RpcClient::AutoUnregister> onUpdate;
+    Nui::Observed<bool> paused{true};
     ObservedRandomAccessMap<Ids::OperationId, DisplayedOperation, std::map> operations;
 
     Implementation(
@@ -379,6 +417,53 @@ OperationQueue::OperationQueue(
 {}
 ROAR_PIMPL_SPECIAL_FUNCTIONS_IMPL(OperationQueue);
 
+template <typename OperationCard>
+void OperationQueue::cancelOperation(OperationCard const& operation)
+{
+    if (operation.isCompletedState())
+    {
+        impl_->operations.erase(operation.operationId());
+        Nui::globalEventContext.executeActiveEventsImmediately();
+    }
+    else
+    {
+        auto doCancel = [this, operationId = operation.operationId()]() {
+            Nui::RpcClient::callWithBackChannel(
+                fmt::format("OperationQueue::{}::cancel", impl_->sessionId.value()),
+                [this, operationId](SharedData::ErrorOrSuccess<> const& result) {
+                    if (result)
+                    {
+                        auto* operation = impl_->operations.at(operationId);
+                        if (operation)
+                            operation->state(SharedData::OperationState::Canceled);
+                        Nui::globalEventContext.executeActiveEventsImmediately();
+                    }
+                    else
+                    {
+                        Log::error("Failed to cancel operation id {}: {}", operationId.value(), result.error.value());
+                    }
+                },
+                operationId);
+        };
+
+        if (operation.warrantsCancelConfirm())
+        {
+            impl_->confirmDialog->open(
+                {.headerText = "Cancel Operation",
+                 .text = fmt::format("Are you sure you want to cancel the operation?"),
+                 .buttons = ConfirmDialog::Button::Yes | ConfirmDialog::Button::No,
+                 .onClose = [doCancel](ConfirmDialog::Button buttonPressed) {
+                     if (buttonPressed == ConfirmDialog::Button::Yes)
+                         doCancel();
+                 }});
+        }
+        else
+        {
+            doCancel();
+        }
+    }
+}
+
 void OperationQueue::activate(FileEngine* fileEngine, Ids::SessionId sessionId)
 {
     impl_->fileEngine = fileEngine;
@@ -401,14 +486,16 @@ void OperationQueue::activate(FileEngine* fileEngine, Ids::SessionId sessionId)
                     DisplayedOperation{
                         .operationId = added.operationId,
                         .type = added.type,
-                        .details = [&added]() -> decltype(DisplayedOperation::details) {
+                        .details = [&added, this]() -> decltype(DisplayedOperation::details) {
                             if (added.type == SharedData::OperationType::Download)
                                 return DisplayedDownloadOperation{
-                                    0,
                                     added.totalBytes ? static_cast<long long>(*added.totalBytes) : 0,
                                     added.operationId,
                                     *added.localPath,
-                                    *added.remotePath};
+                                    *added.remotePath,
+                                    [this](OperationCard<DisplayedDownloadOperation> const& operation) {
+                                        cancelOperation(operation);
+                                    }};
                             return std::monostate{};
                         }()});
                 Nui::globalEventContext.executeActiveEventsImmediately();
@@ -450,8 +537,18 @@ void OperationQueue::activate(FileEngine* fileEngine, Ids::SessionId sessionId)
 
     impl_->onUpdate.push_back(
         Nui::RpcClient::autoRegisterFunction(
-            fmt::format("OperationQueue::{}::onOperationCompleted", impl_->sessionId.value()),
-            [this](SharedData::OperationCompleted const& completed) {
+            fmt::format("OperationQueue::{}::onOperationCompleted", impl_->sessionId.value()), [this](Nui::val val) {
+                SharedData::OperationCompleted completed{};
+                try
+                {
+                    Nui::convertFromVal(val, completed);
+                }
+                catch (std::exception const& e)
+                {
+                    Log::error("Failed to convert OperationCompleted: {}", e.what());
+                    return;
+                }
+
                 Log::info("Received operation completed for operation id: {}", completed.operationId.value());
                 auto* operation = impl_->operations.at(completed.operationId);
                 if (!operation)
@@ -477,9 +574,29 @@ void OperationQueue::activate(FileEngine* fileEngine, Ids::SessionId sessionId)
                         operation->state(SharedData::OperationState::Failed);
                         break;
                     }
+                    default:
+                        Log::warn(
+                            "Received operation completed for operation id: {} with unknown reason: {}",
+                            completed.operationId.value(),
+                            static_cast<int>(completed.reason));
                 }
                 Nui::globalEventContext.executeActiveEventsImmediately();
             }));
+
+    Nui::RpcClient::callWithBackChannel(
+        fmt::format("OperationQueue::{}::isPaused", impl_->sessionId.value()),
+        [this](SharedData::ErrorOrSuccess<SharedData::IsPaused> const& result) {
+            if (result)
+            {
+                Log::info("Initial pause state of operation queue is: {}", result.paused ? "paused" : "running");
+                impl_->paused = result.paused;
+                Nui::globalEventContext.executeActiveEventsImmediately();
+            }
+            else
+            {
+                Log::error("Failed to get initial paused state: {}", result.error.value());
+            }
+        });
 }
 
 Nui::ElementRenderer OperationQueue::operator()()
@@ -501,7 +618,7 @@ Nui::ElementRenderer OperationQueue::operator()()
                     return details();
                 }
             },
-            element.details));
+            element->details));
     };
 
     auto makeSummaryText = [this]() -> std::string {
@@ -518,35 +635,43 @@ Nui::ElementRenderer OperationQueue::operator()()
         }(
             div{
                 class_ = "opq-play-toggle",
-                // TODO: remove id
-                id = "playToggle",
                 role = "button",
                 tabIndex = "0",
-                "aria-pressed"_prop = "false"
+                onClick = [this](){
+                    Nui::RpcClient::callWithBackChannel(fmt::format("OperationQueue::{}::pauseUnpause", impl_->sessionId.value()), [this, requestToPauseUnpauseWas = !impl_->paused.value()](SharedData::ErrorOrSuccess<> const& result){
+                        if (result) {
+                            Log::info("{} operation queue successfully", requestToPauseUnpauseWas ? "Paused" : "Unpaused");
+                            impl_->paused = !impl_->paused.value();
+                            Nui::globalEventContext.executeActiveEventsImmediately();
+                        }
+                        else
+                            Log::error("Failed to {} operation queue: {}", requestToPauseUnpauseWas ? "pause" : "unpause", result.error.value());
+                    }, !impl_->paused.value());
+                }
             }(
                 div{
-                    class_ = "icon",
-                    // TODO: remove id
-                    id = "playIcon",
-                    "aria-hidden"_prop = "true"
+                    class_ = "opq-icon",
                 }(
-                    // svg replaced by js
+                    observe(impl_->paused).generate([this](){
+                        if (impl_->paused.value())
+                            return Svgs::play();
+                        else
+                            return Svgs::pause();
+                    })
                 ),
                 div{
-                    class_ = "label",
-                    id = "playLabel"
-                }("Processing")
-            ),
-            div{
-                class_ = "opq-pill",
-                id = "queueState",
-            }(
-                span{}("Queue: "),
-                strong{id = "queueCount"}("0")
+                    class_ = "opq-label",
+                }(
+                    observe(impl_->paused).generate([this]() -> std::string {
+                        if (!impl_->paused.value())
+                            return "Pause";
+                        else
+                            return "Continue";
+                    })
+                )
             ),
             div{
-                class_ = "opq-summary",
-                id = "summaryText"
+                class_ = "opq-summary"
             }(
                 observe(impl_->operations.observedValues()).generate(makeSummaryText)
             )
@@ -554,8 +679,7 @@ Nui::ElementRenderer OperationQueue::operator()()
         // Main content
         div{}(
             div{
-                class_ = "opq-list",
-                id = "operationList"
+                class_ = "opq-list"
             }(
                 impl_->operations.observedValues().map(operationsMapper)
             )
@@ -580,8 +704,8 @@ void OperationQueue::enqueueDownload(
     impl_->fileEngine->addDownload(remotePath, localPath, std::move(onComplete));
 }
 void OperationQueue::enqueueUpload(
-    std::filesystem::path const& localPath,
-    std::filesystem::path const& remotePath,
+    std::filesystem::path const&,
+    std::filesystem::path const&,
     std::function<void(std::optional<Ids::OperationId> const&)> onComplete)
 {
     if (!impl_->fileEngine)
@@ -593,8 +717,8 @@ void OperationQueue::enqueueUpload(
     // TODO: Implement
 }
 void OperationQueue::enqueueRename(
-    std::filesystem::path const& oldPath,
-    std::filesystem::path const& newPath,
+    std::filesystem::path const&,
+    std::filesystem::path const&,
     std::function<void(std::optional<Ids::OperationId> const&)> onComplete)
 {
     if (!impl_->fileEngine)
@@ -606,7 +730,7 @@ void OperationQueue::enqueueRename(
     // TODO: Implement
 }
 void OperationQueue::enqueueDelete(
-    std::filesystem::path const& path,
+    std::filesystem::path const&,
     std::function<void(std::optional<Ids::OperationId> const&)> onComplete)
 {
     if (!impl_->fileEngine)
diff --git a/persistence/include/persistence/state_holder.hpp b/persistence/include/persistence/state_holder.hpp
index 4a90dec9..8cc6bfad 100644
--- a/persistence/include/persistence/state_holder.hpp
+++ b/persistence/include/persistence/state_holder.hpp
@@ -8,7 +8,6 @@
 #include <persistence/state/state.hpp>
 
 #include <functional>
-#include <memory>
 
 namespace Persistence
 {
diff --git a/shared_data/include/shared_data/error_or_success.hpp b/shared_data/include/shared_data/error_or_success.hpp
new file mode 100644
index 00000000..985af11b
--- /dev/null
+++ b/shared_data/include/shared_data/error_or_success.hpp
@@ -0,0 +1,102 @@
+#pragma once
+
+#include <shared_data/shared_data.hpp>
+#include <utility/describe.hpp>
+
+#include <nlohmann/json.hpp>
+
+#include <optional>
+#include <string>
+
+namespace SharedData
+{
+    namespace Detail
+    {
+        struct Empty
+        {};
+        BOOST_DESCRIBE_STRUCT(Empty, (), ())
+    }
+
+    template <typename Data = Detail::Empty>
+    struct ErrorOrSuccess : public Data
+    {
+        std::optional<std::string> error{std::nullopt};
+        ErrorOrSuccess() = default;
+        ErrorOrSuccess(std::string const& error)
+            : Data{}
+            , error{error}
+        {}
+        ErrorOrSuccess(Data data)
+            : Data{std::move(data)}
+        {}
+        bool success() const
+        {
+            return !error.has_value();
+        }
+        explicit operator bool() const
+        {
+            return success();
+        }
+    };
+
+    template <typename Data = Detail::Empty>
+    inline ErrorOrSuccess<Data> success()
+    {
+        return ErrorOrSuccess<Data>{};
+    }
+    template <typename Data = Detail::Empty>
+    inline ErrorOrSuccess<Data> error(std::string msg)
+    {
+        return ErrorOrSuccess<Data>{std::move(msg)};
+    }
+
+    template <typename Data = Detail::Empty>
+    void to_json(nlohmann::json& j, ErrorOrSuccess<Data> const& o)
+    {
+        if (o.error.has_value())
+            j["error"] = o.error.value();
+        else
+        {
+            j = nlohmann::json::object();
+            to_json(j, static_cast<Data const&>(o));
+            j["success"] = true;
+        }
+    }
+    template <typename Data = Detail::Empty>
+    void from_json(nlohmann::json const& j, ErrorOrSuccess<Data>& o)
+    {
+        if (j.contains("error"))
+            o.error = j.at("error").get<std::string>();
+        else
+        {
+            from_json(j, static_cast<Data&>(o));
+            o.error = std::nullopt;
+        }
+    }
+
+#ifdef __EMSCRIPTEN__
+    template <typename Data = Detail::Empty>
+    inline void to_val(Nui::val& v, ErrorOrSuccess<Data> const& o)
+    {
+        if (o.error.has_value())
+            v = Nui::val::object().set("error", Nui::val::u8string(o.error->c_str()));
+        else
+        {
+            v = Nui::val::object();
+            Nui::convertToVal(v, static_cast<Data const&>(o));
+            v.set("success", true);
+        }
+    }
+    template <typename Data = Detail::Empty>
+    inline void from_val(Nui::val const& v, ErrorOrSuccess<Data>& o)
+    {
+        if (v.hasOwnProperty("error"))
+            o.error = v["error"].template as<std::string>();
+        else
+        {
+            Nui::convertFromVal(v, static_cast<Data&>(o));
+            o.error = std::nullopt;
+        }
+    }
+#endif
+}
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/download_progress.hpp b/shared_data/include/shared_data/file_operations/download_progress.hpp
index d3b3a5e3..36a4c256 100644
--- a/shared_data/include/shared_data/file_operations/download_progress.hpp
+++ b/shared_data/include/shared_data/file_operations/download_progress.hpp
@@ -18,7 +18,4 @@ namespace SharedData
         std::uint64_t current;
     };
     BOOST_DESCRIBE_STRUCT(DownloadProgress, (), (operationId, min, max, current))
-
-    void to_json(nlohmann::json& j, DownloadProgress const& downloadProgress);
-    void from_json(nlohmann::json const& j, DownloadProgress& downloadProgress);
 }
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/operation_added.hpp b/shared_data/include/shared_data/file_operations/operation_added.hpp
index 8c05805d..4e690b9d 100644
--- a/shared_data/include/shared_data/file_operations/operation_added.hpp
+++ b/shared_data/include/shared_data/file_operations/operation_added.hpp
@@ -18,7 +18,4 @@ namespace SharedData
         std::optional<std::filesystem::path> remotePath{};
     };
     BOOST_DESCRIBE_STRUCT(OperationAdded, (), (operationId, type, totalBytes, localPath, remotePath))
-
-    void to_json(nlohmann::json& j, OperationAdded const& operationAdded);
-    void from_json(nlohmann::json const& j, OperationAdded& operationAdded);
 }
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/operation_completed.hpp b/shared_data/include/shared_data/file_operations/operation_completed.hpp
index a0dfd315..4598d748 100644
--- a/shared_data/include/shared_data/file_operations/operation_completed.hpp
+++ b/shared_data/include/shared_data/file_operations/operation_completed.hpp
@@ -5,29 +5,18 @@
 #include <shared_data/file_operations/operation_error.hpp>
 #include <utility/describe.hpp>
 #include <utility/enum_string_convert.hpp>
+#include <shared_data/time_point.hpp>
 
 #include <nlohmann/json.hpp>
 
-#include <string>
+#include <optional>
+#include <filesystem>
+#include <chrono>
 
 namespace SharedData
 {
     BOOST_DEFINE_ENUM_CLASS(OperationCompletionReason, Completed, Canceled, Failed)
 
-    void to_json(nlohmann::json& j, OperationCompletionReason const& operationCompletionReason);
-    void from_json(nlohmann::json const& j, OperationCompletionReason& operationCompletionReason);
-
-#ifdef __EMSCRIPTEN__
-    inline void to_val(Nui::val& v, OperationCompletionReason const& operationCompletionReason)
-    {
-        v = Nui::val::u8string(Utility::enumToString<OperationCompletionReason>(operationCompletionReason).c_str());
-    }
-    inline void from_val(Nui::val const& v, OperationCompletionReason& operationCompletionReason)
-    {
-        operationCompletionReason = Utility::enumFromString<OperationCompletionReason>(v.template as<std::string>());
-    }
-#endif
-
     struct OperationCompleted
     {
         OperationCompletionReason reason;
@@ -37,65 +26,5 @@ namespace SharedData
         std::optional<std::filesystem::path> remotePath{std::nullopt};
         std::optional<OperationError> error{std::nullopt};
     };
-
-    void to_json(nlohmann::json& j, OperationCompleted const& operationCompleted);
-    void from_json(nlohmann::json const& j, OperationCompleted& operationCompleted);
-
-#ifdef __EMSCRIPTEN__
-    inline void to_val(Nui::val& v, OperationCompleted const& operationCompleted)
-    {
-        v = Nui::val::object();
-
-        v.set("reason", Nui::convertToVal(operationCompleted.reason));
-        v.set("operationId", Nui::convertToVal(operationCompleted.operationId));
-
-        v.set(
-            "completionTime",
-            static_cast<int64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(
-                                     operationCompleted.completionTime.time_since_epoch())
-                                     .count()));
-
-        if (operationCompleted.localPath.has_value())
-            v.set("localPath", Nui::val::u8string(operationCompleted.localPath->generic_string().c_str()));
-        else
-            v.set("localPath", Nui::val::null());
-
-        if (operationCompleted.remotePath.has_value())
-            v.set("remotePath", Nui::val::u8string(operationCompleted.remotePath->generic_string().c_str()));
-        else
-            v.set("remotePath", Nui::val::null());
-
-        if (operationCompleted.error.has_value())
-        {
-            Nui::val error;
-            to_val(error, *operationCompleted.error);
-            v.set("error", error);
-        }
-        else
-            v.set("error", Nui::val::null());
-    }
-    inline void from_val(Nui::val const& v, OperationCompleted& operationCompleted)
-    {
-        if (!v.hasOwnProperty("reason") || !v.hasOwnProperty("operationId") || !v.hasOwnProperty("completionTime"))
-        {
-            throw std::runtime_error("Invalid OperationCompleted object");
-        }
-
-        Nui::val reason;
-        Nui::convertFromVal(v["reason"], operationCompleted.reason);
-        Nui::convertFromVal(v["operationId"], operationCompleted.operationId);
-        operationCompleted.completionTime = std::chrono::system_clock::time_point{
-            std::chrono::milliseconds{v["completionTime"].template as<std::int64_t>()}};
-
-        if (v.hasOwnProperty("localPath") && !v["localPath"].isNull())
-            operationCompleted.localPath = std::filesystem::path{v["localPath"].template as<std::string>()};
-        if (v.hasOwnProperty("remotePath") && !v["remotePath"].isNull())
-            operationCompleted.remotePath = std::filesystem::path{v["remotePath"].template as<std::string>()};
-        if (v.hasOwnProperty("error") && !v["error"].isNull())
-        {
-            operationCompleted.error = OperationError{};
-            Nui::convertFromVal(v["error"], operationCompleted.error.value());
-        }
-    }
-#endif
+    BOOST_DESCRIBE_STRUCT(OperationCompleted, (), (reason, operationId, completionTime, localPath, remotePath, error))
 }
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/operation_error.hpp b/shared_data/include/shared_data/file_operations/operation_error.hpp
index 2a155b2d..85d09e98 100644
--- a/shared_data/include/shared_data/file_operations/operation_error.hpp
+++ b/shared_data/include/shared_data/file_operations/operation_error.hpp
@@ -9,41 +9,30 @@ namespace SecureShell
     BOOST_DESCRIBE_ENUM(WrapperErrors, None, OwnerNull, SharedPtrDestroyed, ShortWrite, FileNull)
     BOOST_DESCRIBE_STRUCT(SftpError, (), (message, sshError, sftpError, wrapperError))
 
-    void to_json(nlohmann::json& j, WrapperErrors const& wrapperErrors);
-    void from_json(nlohmann::json const& j, WrapperErrors& wrapperErrors);
-
-    void to_json(nlohmann::json& j, SftpError const& sftpError);
-    void from_json(nlohmann::json const& j, SftpError& sftpError);
-
-#ifdef __EMSCRIPTEN__
-    inline void to_val(Nui::val& v, WrapperErrors const& wrapperErrors)
+    inline void from_json(nlohmann::json const& json, WrapperErrors& error)
     {
-        v = Nui::val::u8string(Utility::enumToString<WrapperErrors>(wrapperErrors).c_str());
+        SharedData::from_json(json, error);
     }
-    inline void from_val(Nui::val const& v, WrapperErrors& wrapperErrors)
+    inline void to_json(nlohmann::json& json, WrapperErrors const& error)
     {
-        wrapperErrors = Utility::enumFromString<WrapperErrors>(v.template as<std::string>());
+        SharedData::to_json(json, error);
     }
-    inline void to_val(Nui::val& v, SftpError const& sftpError)
+    inline void from_json(nlohmann::json const& json, SftpError& error)
     {
-        v = Nui::val::object();
-        v.set("message", Nui::val::u8string(sftpError.message.c_str()));
-        v.set("sshError", sftpError.sshError);
-        v.set("sftpError", sftpError.sftpError);
-        v.set("wrapperError", Nui::val::u8string(Utility::enumToString<WrapperErrors>(sftpError.wrapperError).c_str()));
+        SharedData::from_json(json, error);
     }
-    inline void from_val(Nui::val const& v, SftpError& sftpError)
+    inline void to_json(nlohmann::json& json, SftpError const& error)
     {
-        if (!v.hasOwnProperty("message") || !v.hasOwnProperty("sshError") || !v.hasOwnProperty("sftpError") ||
-            !v.hasOwnProperty("wrapperError"))
-        {
-            throw std::runtime_error("Invalid SftpError object");
-        }
-
-        sftpError.message = v["message"].template as<std::string>();
-        sftpError.sshError = v["sshError"].template as<int>();
-        sftpError.sftpError = v["sftpError"].template as<int>();
-        sftpError.wrapperError = Utility::enumFromString<WrapperErrors>(v["wrapperError"].template as<std::string>());
+        SharedData::to_json(json, error);
+    }
+#ifdef __EMSCRIPTEN__
+    inline void from_val(Nui::val const& val, WrapperErrors& error)
+    {
+        SharedData::from_val(val, error);
+    }
+    inline void to_val(Nui::val& val, WrapperErrors const& error)
+    {
+        SharedData::to_val(val, error);
     }
 #endif
 }
@@ -63,39 +52,5 @@ namespace SharedData
             return enumString;
         }
     };
-
-    void to_json(nlohmann::json& j, OperationError const& operationError);
-    void from_json(nlohmann::json const& j, OperationError& operationError);
-
-#ifdef __EMSCRIPTEN__
-    inline void to_val(Nui::val& v, OperationError const& operationError)
-    {
-        v = Nui::val::object();
-        v.set("type", Nui::val::u8string(Utility::enumToString<OperationErrorType>(operationError.type).c_str()));
-        if (operationError.sftpError.has_value())
-        {
-            Nui::val sftpErrorVal;
-            to_val(sftpErrorVal, operationError.sftpError.value());
-            v.set("sftpError", sftpErrorVal);
-        }
-        else
-        {
-            v.set("sftpError", Nui::val::undefined());
-        }
-    }
-    inline void from_val(Nui::val const& v, OperationError& operationError)
-    {
-        operationError.type = Utility::enumFromString<OperationErrorType>(v["type"].template as<std::string>());
-        if (v.hasOwnProperty("sftpError") && !v["sftpError"].isUndefined())
-        {
-            SecureShell::SftpError sftpError;
-            from_val(v["sftpError"], sftpError);
-            operationError.sftpError = sftpError;
-        }
-        else
-        {
-            operationError.sftpError = std::nullopt;
-        }
-    }
-#endif
+    BOOST_DESCRIBE_STRUCT(OperationError, (), (type, sftpError))
 }
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/operation_error_type.hpp b/shared_data/include/shared_data/file_operations/operation_error_type.hpp
index 367ef517..5f09b986 100644
--- a/shared_data/include/shared_data/file_operations/operation_error_type.hpp
+++ b/shared_data/include/shared_data/file_operations/operation_error_type.hpp
@@ -32,18 +32,4 @@ namespace SharedData
         UnknownWorkState,
         InvalidOperationState,
         OperationNotPossibleOnFileType);
-
-    void to_json(nlohmann::json& j, OperationErrorType const& operationErrorType);
-    void from_json(nlohmann::json const& j, OperationErrorType& operationErrorType);
-
-#ifdef __EMSCRIPTEN__
-    inline void to_val(Nui::val& v, OperationErrorType const& operationErrorType)
-    {
-        v = Nui::val::u8string(Utility::enumToString<OperationErrorType>(operationErrorType).c_str());
-    }
-    inline void from_val(Nui::val const& v, OperationErrorType& operationErrorType)
-    {
-        operationErrorType = Utility::enumFromString<OperationErrorType>(v.template as<std::string>());
-    }
-#endif
 }
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/operation_state.hpp b/shared_data/include/shared_data/file_operations/operation_state.hpp
index b20c4dd1..e6563c24 100644
--- a/shared_data/include/shared_data/file_operations/operation_state.hpp
+++ b/shared_data/include/shared_data/file_operations/operation_state.hpp
@@ -16,18 +16,4 @@ namespace SharedData
         Completed,
         Canceled,
         Failed)
-
-    void to_json(nlohmann::json& j, OperationState const& operationState);
-    void from_json(nlohmann::json const& j, OperationState& operationState);
-
-#ifdef __EMSCRIPTEN__
-    inline void to_val(Nui::val& v, OperationState const& operationState)
-    {
-        v = Nui::val::u8string(Utility::enumToString<OperationState>(operationState).c_str());
-    }
-    inline void from_val(Nui::val const& v, OperationState& operationState)
-    {
-        operationState = Utility::enumFromString<OperationState>(v.template as<std::string>());
-    }
-#endif
 }
\ No newline at end of file
diff --git a/shared_data/include/shared_data/file_operations/operation_type.hpp b/shared_data/include/shared_data/file_operations/operation_type.hpp
index d1353b2a..7471cbbd 100644
--- a/shared_data/include/shared_data/file_operations/operation_type.hpp
+++ b/shared_data/include/shared_data/file_operations/operation_type.hpp
@@ -7,18 +7,4 @@
 namespace SharedData
 {
     BOOST_DEFINE_ENUM_CLASS(OperationType, Scan, Download, BulkDownload, Upload, Rename, Delete)
-
-    void to_json(nlohmann::json& j, OperationType const& operationType);
-    void from_json(nlohmann::json const& j, OperationType& operationType);
-
-#ifdef __EMSCRIPTEN__
-    inline void to_val(Nui::val& v, OperationType const& operationType)
-    {
-        v = Nui::val::u8string(Utility::enumToString<OperationType>(operationType).c_str());
-    }
-    inline void from_val(Nui::val const& v, OperationType& operationType)
-    {
-        operationType = Utility::enumFromString<OperationType>(v.template as<std::string>());
-    }
-#endif
 }
\ No newline at end of file
diff --git a/shared_data/include/shared_data/is_paused.hpp b/shared_data/include/shared_data/is_paused.hpp
new file mode 100644
index 00000000..e9a1dd7b
--- /dev/null
+++ b/shared_data/include/shared_data/is_paused.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+#include <shared_data/shared_data.hpp>
+
+namespace SharedData
+{
+    struct IsPaused
+    {
+        bool paused;
+    };
+    BOOST_DESCRIBE_STRUCT(IsPaused, (), (paused))
+}
\ No newline at end of file
diff --git a/shared_data/include/shared_data/shared_data.hpp b/shared_data/include/shared_data/shared_data.hpp
index e0b0f002..c8e0f1a5 100644
--- a/shared_data/include/shared_data/shared_data.hpp
+++ b/shared_data/include/shared_data/shared_data.hpp
@@ -2,8 +2,96 @@
 
 #include <nui/core.hpp>
 #include <nlohmann/json.hpp>
+#include <utility/describe.hpp>
+#include <utility/traits_and_concepts/optional.hpp>
+#include <utility/enum_string_convert.hpp>
 
 #ifdef NUI_FRONTEND
 #    include <nui/frontend/val.hpp>
 #    include <nui/frontend/utility/val_conversion.hpp>
-#endif
\ No newline at end of file
+#endif
+
+namespace SharedData
+{
+    template <typename EnumT, typename EnumDescription = boost::describe::describe_enumerators<EnumT>>
+    void to_json(nlohmann::json& j, EnumT const& e)
+    {
+        j = Utility::enumToString<EnumT>(e);
+    }
+    template <typename EnumT, typename EnumDescription = boost::describe::describe_enumerators<EnumT>>
+    void from_json(nlohmann::json const& j, EnumT& e)
+    {
+        e = Utility::enumFromString<EnumT>(j.template get<std::string>());
+    }
+
+#ifdef NUI_FRONTEND
+    template <typename EnumT, typename EnumDescription = boost::describe::describe_enumerators<EnumT>>
+    void to_val(Nui::val& v, EnumT const& e)
+    {
+        v = Nui::val::u8string(Utility::enumToString<EnumT>(e).c_str());
+    }
+    template <typename EnumT, typename EnumDescription = boost::describe::describe_enumerators<EnumT>>
+    void from_val(Nui::val const& v, EnumT& e)
+    {
+        e = Utility::enumFromString<EnumT>(v.template as<std::string>());
+    }
+#endif
+
+    template <
+        typename T,
+        class Bases = boost::describe::describe_bases<T, boost::describe::mod_any_access>,
+        class Members = boost::describe::describe_members<T, boost::describe::mod_any_access>,
+        class Enable = std::enable_if_t<!std::is_union_v<T>>>
+    void to_json(nlohmann::json& j, T const& obj)
+    {
+        j = nlohmann::json::object();
+
+        boost::mp11::mp_for_each<Bases>([&](auto&& base) {
+            using type = typename std::decay_t<decltype(base)>::type;
+            to_json(j, static_cast<type const&>(obj));
+        });
+        boost::mp11::mp_for_each<Members>([&](auto&& memAccessor) {
+            using memberType = std::decay_t<decltype(obj.*memAccessor.pointer)>;
+            if constexpr (Utility::OptionalType<memberType>)
+            {
+                if (obj.*memAccessor.pointer)
+                    j[memAccessor.name] = *(obj.*memAccessor.pointer);
+            }
+            else
+            {
+                j[memAccessor.name] = obj.*memAccessor.pointer;
+            }
+        });
+    }
+
+    template <
+        typename T,
+        class Bases = boost::describe::describe_bases<T, boost::describe::mod_any_access>,
+        class Members = boost::describe::describe_members<T, boost::describe::mod_any_access>,
+        class Enable = std::enable_if_t<!std::is_union_v<T>>>
+    void from_json(nlohmann::json const& j, T& obj)
+    {
+        boost::mp11::mp_for_each<Bases>([&](auto&& base) {
+            using type = typename std::decay_t<decltype(base)>::type;
+            from_json(j, static_cast<type&>(obj));
+        });
+        boost::mp11::mp_for_each<Members>([&](auto&& memAccessor) {
+            using memberType = std::decay_t<decltype(obj.*memAccessor.pointer)>;
+            if constexpr (Utility::OptionalType<memberType>)
+            {
+                if (j.contains(memAccessor.name))
+                    j.at(memAccessor.name).get_to(obj.*memAccessor.pointer);
+                else
+                    obj.*memAccessor.pointer = std::nullopt;
+            }
+            else
+            {
+                if (j.contains(memAccessor.name))
+                    j.at(memAccessor.name).get_to(obj.*memAccessor.pointer);
+                else
+                    throw std::runtime_error(
+                        std::string("Missing required field '") + memAccessor.name + "' in JSON object");
+            }
+        });
+    }
+}
\ No newline at end of file
diff --git a/shared_data/include/shared_data/time_point.hpp b/shared_data/include/shared_data/time_point.hpp
new file mode 100644
index 00000000..a0e0d240
--- /dev/null
+++ b/shared_data/include/shared_data/time_point.hpp
@@ -0,0 +1,64 @@
+#pragma once
+
+#include <chrono>
+
+#include <shared_data/shared_data.hpp>
+#include <fmt/format.h>
+#include <fmt/chrono.h>
+
+#include <sstream>
+
+namespace SharedData
+{
+#ifdef NUI_FRONTEND
+    inline void to_val(Nui::val& v, std::chrono::time_point<std::chrono::system_clock> const& tp)
+    {
+        v = Nui::val::u8string(fmt::format("{:%Y-%m-%d %H:%M:%S}", tp).c_str());
+    }
+    inline void from_val(Nui::val const& v, std::chrono::time_point<std::chrono::system_clock>& tp)
+    {
+        std::istringstream in{v.template as<std::string>()};
+        std::tm tm = {};
+        in >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S");
+        if (in.fail())
+            throw std::invalid_argument("Failed to parse time_point from string: " + v.template as<std::string>());
+        tp = std::chrono::system_clock::from_time_t(std::mktime(&tm));
+    }
+#endif
+    inline void to_json(nlohmann::json& j, std::chrono::time_point<std::chrono::system_clock> const& tp)
+    {
+        j = fmt::format("{:%Y-%m-%d %H:%M:%S}", tp);
+    }
+    inline void from_json(nlohmann::json const& j, std::chrono::time_point<std::chrono::system_clock>& tp)
+    {
+        std::istringstream in{j.get<std::string>()};
+        std::tm tm = {};
+        in >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S");
+        if (in.fail())
+            throw std::invalid_argument("Failed to parse time_point from string: " + j.get<std::string>());
+        tp = std::chrono::system_clock::from_time_t(std::mktime(&tm));
+    }
+}
+
+// Inject into STD for ADL:
+namespace std::chrono
+{
+#ifdef NUI_FRONTEND
+    inline void to_val(Nui::val& v, time_point<system_clock> const& tp)
+    {
+        SharedData::to_val(v, tp);
+    }
+    inline void from_val(Nui::val const& v, time_point<system_clock>& tp)
+    {
+        SharedData::from_val(v, tp);
+    }
+#endif
+    inline void to_json(nlohmann::json& j, time_point<system_clock> const& tp)
+    {
+        SharedData::to_json(j, tp);
+    }
+    inline void from_json(nlohmann::json const& j, time_point<system_clock>& tp)
+    {
+        SharedData::from_json(j, tp);
+    }
+}
\ No newline at end of file
diff --git a/shared_data/source/shared_data/CMakeLists.txt b/shared_data/source/shared_data/CMakeLists.txt
index d53cb272..d4eac9d6 100644
--- a/shared_data/source/shared_data/CMakeLists.txt
+++ b/shared_data/source/shared_data/CMakeLists.txt
@@ -2,12 +2,6 @@ add_library(
     shared_data
     STATIC
         directory_entry.cpp
-        file_operations/operation_type.cpp
-        file_operations/operation_added.cpp
-        file_operations/download_progress.cpp
-        file_operations/operation_completed.cpp
-        file_operations/operation_error.cpp
-        file_operations/operation_state.cpp
 )
 
 target_include_directories(shared_data PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/../../include" "${CMAKE_CURRENT_SOURCE_DIR}/../../../ssh/include")
diff --git a/shared_data/source/shared_data/file_operations/download_progress.cpp b/shared_data/source/shared_data/file_operations/download_progress.cpp
deleted file mode 100644
index 6b890b29..00000000
--- a/shared_data/source/shared_data/file_operations/download_progress.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <shared_data/file_operations/download_progress.hpp>
-
-namespace SharedData
-{
-    void to_json(nlohmann::json& j, DownloadProgress const& downloadProgress)
-    {
-        j = nlohmann::json{
-            {"operationId", downloadProgress.operationId},
-            {"min", downloadProgress.min},
-            {"max", downloadProgress.max},
-            {"current", downloadProgress.current},
-        };
-    }
-    void from_json(nlohmann::json const& j, DownloadProgress& downloadProgress)
-    {
-        j.at("operationId").get_to(downloadProgress.operationId);
-        j.at("min").get_to(downloadProgress.min);
-        j.at("max").get_to(downloadProgress.max);
-        j.at("current").get_to(downloadProgress.current);
-    }
-}
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_added.cpp b/shared_data/source/shared_data/file_operations/operation_added.cpp
deleted file mode 100644
index 42b4ad6c..00000000
--- a/shared_data/source/shared_data/file_operations/operation_added.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <shared_data/file_operations/operation_added.hpp>
-
-namespace SharedData
-{
-    void to_json(nlohmann::json& j, OperationAdded const& operationAdded)
-    {
-        j = nlohmann::json{
-            {"operationId", operationAdded.operationId},
-            {"type", operationAdded.type},
-        };
-
-        if (operationAdded.totalBytes.has_value())
-            j["totalBytes"] = operationAdded.totalBytes.value();
-        if (operationAdded.localPath.has_value())
-            j["localPath"] = operationAdded.localPath->generic_string();
-        if (operationAdded.remotePath.has_value())
-            j["remotePath"] = operationAdded.remotePath->generic_string();
-    }
-    void from_json(nlohmann::json const& j, OperationAdded& operationAdded)
-    {
-        j.at("operationId").get_to(operationAdded.operationId);
-        j.at("type").get_to(operationAdded.type);
-
-        if (j.contains("totalBytes") && !j.at("totalBytes").is_null())
-            j.at("totalBytes").get_to(*operationAdded.totalBytes);
-        else
-            operationAdded.totalBytes = std::nullopt;
-
-        if (j.contains("localPath") && !j.at("localPath").is_null())
-            operationAdded.localPath = j.at("localPath").get<std::string>();
-        else
-            operationAdded.localPath = std::nullopt;
-
-        if (j.contains("remotePath") && !j.at("remotePath").is_null())
-            operationAdded.remotePath = j.at("remotePath").get<std::string>();
-        else
-            operationAdded.remotePath = std::nullopt;
-    }
-}
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_completed.cpp b/shared_data/source/shared_data/file_operations/operation_completed.cpp
deleted file mode 100644
index 9f3246a8..00000000
--- a/shared_data/source/shared_data/file_operations/operation_completed.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-#include <shared_data/file_operations/operation_completed.hpp>
-
-namespace SharedData
-{
-    void to_json(nlohmann::json& j, OperationCompletionReason const& operationCompletionReason)
-    {
-        j = Utility::enumToString<OperationCompletionReason>(operationCompletionReason);
-    }
-    void from_json(nlohmann::json const& j, OperationCompletionReason& operationCompletionReason)
-    {
-        operationCompletionReason = Utility::enumFromString<OperationCompletionReason>(j.template get<std::string>());
-    }
-
-    void to_json(nlohmann::json& j, OperationCompleted const& operationCompleted)
-    {
-        j = nlohmann::json{
-            {"reason", operationCompleted.reason},
-            {"operationId", operationCompleted.operationId},
-            {"completionTime",
-             static_cast<int64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(
-                                      operationCompleted.completionTime.time_since_epoch())
-                                      .count())},
-        };
-
-        if (operationCompleted.localPath.has_value())
-            j["localPath"] = operationCompleted.localPath->generic_string();
-
-        if (operationCompleted.remotePath.has_value())
-            j["remotePath"] = operationCompleted.remotePath->generic_string();
-
-        if (operationCompleted.error.has_value())
-            j["error"] = *operationCompleted.error;
-    }
-    void from_json(nlohmann::json const& j, OperationCompleted& operationCompleted)
-    {
-        j.at("reason").get_to(operationCompleted.reason);
-        j.at("operationId").get_to(operationCompleted.operationId);
-        operationCompleted.completionTime =
-            std::chrono::system_clock::time_point{std::chrono::milliseconds{j.at("completionTime").get<int64_t>()}};
-
-        if (j.contains("localPath"))
-            operationCompleted.localPath = j.at("localPath").get<std::filesystem::path>();
-        else
-            operationCompleted.localPath = std::nullopt;
-        if (j.contains("remotePath"))
-            operationCompleted.remotePath = j.at("remotePath").get<std::filesystem::path>();
-        else
-            operationCompleted.remotePath = std::nullopt;
-        if (j.contains("error"))
-            operationCompleted.error = j.at("error").get<OperationError>();
-        else
-            operationCompleted.error = std::nullopt;
-    }
-}
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_error.cpp b/shared_data/source/shared_data/file_operations/operation_error.cpp
deleted file mode 100644
index 2d57d0a3..00000000
--- a/shared_data/source/shared_data/file_operations/operation_error.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#include <shared_data/file_operations/operation_error.hpp>
-
-namespace SecureShell
-{
-    void to_json(nlohmann::json& j, WrapperErrors const& wrapperErrors)
-    {
-        j = Utility::enumToString<WrapperErrors>(wrapperErrors);
-    }
-    void from_json(nlohmann::json const& j, WrapperErrors& wrapperErrors)
-    {
-        wrapperErrors = Utility::enumFromString<WrapperErrors>(j.template get<std::string>());
-    }
-
-    void to_json(nlohmann::json& j, SftpError const& sftpError)
-    {
-        j = nlohmann::json::object();
-        j["message"] = sftpError.message;
-        j["sshError"] = sftpError.sshError;
-        j["sftpError"] = sftpError.sftpError;
-        j["wrapperError"] = Utility::enumToString<WrapperErrors>(sftpError.wrapperError);
-    }
-
-    void from_json(nlohmann::json const& j, SftpError& sftpError)
-    {
-        sftpError.message = j.at("message").get<std::string>();
-        sftpError.sshError = j.at("sshError").get<int>();
-        sftpError.sftpError = j.at("sftpError").get<int>();
-        sftpError.wrapperError = Utility::enumFromString<WrapperErrors>(j.at("wrapperError").get<std::string>());
-    }
-}
-
-namespace SharedData
-{
-    void to_json(nlohmann::json& j, OperationError const& operationError)
-    {
-        j = nlohmann::json::object();
-        j["type"] = Utility::enumToString<OperationErrorType>(operationError.type);
-        if (operationError.sftpError.has_value())
-            j["sftpError"] = operationError.sftpError.value();
-    }
-    void from_json(nlohmann::json const& j, OperationError& operationError)
-    {
-        operationError.type = Utility::enumFromString<OperationErrorType>(j.at("type").get<std::string>());
-        if (j.contains("sftpError"))
-            operationError.sftpError = j.at("sftpError").get<SecureShell::SftpError>();
-        else
-            operationError.sftpError = std::nullopt;
-    }
-}
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_state.cpp b/shared_data/source/shared_data/file_operations/operation_state.cpp
deleted file mode 100644
index 2e108e77..00000000
--- a/shared_data/source/shared_data/file_operations/operation_state.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <shared_data/file_operations/operation_state.hpp>
-
-namespace SharedData
-{
-    void to_json(nlohmann::json& j, OperationState const& operationState)
-    {
-        j = Utility::enumToString(operationState);
-    }
-    void from_json(nlohmann::json const& j, OperationState& operationState)
-    {
-        operationState = Utility::enumFromString<OperationState>(j.get<std::string>());
-    }
-}
\ No newline at end of file
diff --git a/shared_data/source/shared_data/file_operations/operation_type.cpp b/shared_data/source/shared_data/file_operations/operation_type.cpp
deleted file mode 100644
index a0f062cd..00000000
--- a/shared_data/source/shared_data/file_operations/operation_type.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <shared_data/file_operations/operation_type.hpp>
-
-namespace SharedData
-{
-    void to_json(nlohmann::json& j, OperationType const& operationType)
-    {
-        j = Utility::enumToString<OperationType>(operationType);
-    }
-    void from_json(nlohmann::json const& j, OperationType& operationType)
-    {
-        operationType = Utility::enumFromString<OperationType>(j.get<std::string>());
-    }
-}
\ No newline at end of file
diff --git a/ssh/include/ssh/file_stream.hpp b/ssh/include/ssh/file_stream.hpp
index dd70aef7..f15e9e50 100644
--- a/ssh/include/ssh/file_stream.hpp
+++ b/ssh/include/ssh/file_stream.hpp
@@ -62,16 +62,25 @@ namespace SecureShell
          * @param bufferSize
          * @return std::future<std::expected<std::size_t, SftpError>>
          */
-        std::future<std::expected<std::size_t, SftpError>> read(std::byte* buffer, std::size_t bufferSize) override;
+        std::future<std::expected<std::size_t, SftpError>> readSome(std::byte* buffer, std::size_t bufferSize) override;
 
         /**
          * @brief Reads all bytes from the file.
          *
-         * @param onRead Let this function return false to stop reading.
+         * @param onRead Function called when data is read.
          * @return std::future<std::expected<std::size_t, SftpError>> The number of bytes read or an error.
          */
         std::future<std::expected<std::size_t, SftpError>>
-        read(std::function<bool(std::string_view data)> onRead) override;
+        readAll(std::function<bool(std::string_view data)> onRead) override;
+
+        /**
+         * @brief Reads some bytes from the file.
+         *
+         * @param onRead Function to call with read data. Return false to stop reading.
+         * @return std::future<std::expected<std::size_t, SftpError>>
+         */
+        std::future<std::expected<std::size_t, SftpError>>
+        readSome(std::function<bool(std::string_view data)> onRead) override;
 
         /**
          * @brief Writes some bytes to the file.
diff --git a/ssh/include/ssh/file_stream_interface.hpp b/ssh/include/ssh/file_stream_interface.hpp
index 4b47df28..5d63d45a 100644
--- a/ssh/include/ssh/file_stream_interface.hpp
+++ b/ssh/include/ssh/file_stream_interface.hpp
@@ -59,7 +59,8 @@ namespace SecureShell
          * @param bufferSize
          * @return std::future<std::expected<std::size_t, SftpError>>
          */
-        virtual std::future<std::expected<std::size_t, SftpError>> read(std::byte* buffer, std::size_t bufferSize) = 0;
+        virtual std::future<std::expected<std::size_t, SftpError>>
+        readSome(std::byte* buffer, std::size_t bufferSize) = 0;
 
         /**
          * @brief Reads all bytes from the file.
@@ -68,7 +69,16 @@ namespace SecureShell
          * @return std::future<std::expected<std::size_t, SftpError>> The number of bytes read or an error.
          */
         virtual std::future<std::expected<std::size_t, SftpError>>
-        read(std::function<bool(std::string_view data)> onRead) = 0;
+        readAll(std::function<bool(std::string_view data)> onRead) = 0;
+
+        /**
+         * @brief Reads some bytes from the file.
+         *
+         * @param onRead
+         * @return std::future<std::expected<std::size_t, SftpError>>
+         */
+        virtual std::future<std::expected<std::size_t, SftpError>>
+        readSome(std::function<bool(std::string_view data)> onRead) = 0;
 
         /**
          * @brief Writes some bytes to the file.
diff --git a/ssh/include/ssh/mocks/file_stream_mock.hpp b/ssh/include/ssh/mocks/file_stream_mock.hpp
index 1e8ba0f5..b65bddc9 100644
--- a/ssh/include/ssh/mocks/file_stream_mock.hpp
+++ b/ssh/include/ssh/mocks/file_stream_mock.hpp
@@ -22,12 +22,17 @@ namespace SecureShell::Test
         MOCK_METHOD((std::future<std::expected<void, SftpError>>), rewind, (), (override));
         MOCK_METHOD(
             (std::future<std::expected<std::size_t, SftpError>>),
-            read,
+            readSome,
             (std::byte * buffer, std::size_t bufferSize),
             (override));
         MOCK_METHOD(
             (std::future<std::expected<std::size_t, SftpError>>),
-            read,
+            readAll,
+            (std::function<bool(std::string_view data)> onRead),
+            (override));
+        MOCK_METHOD(
+            (std::future<std::expected<std::size_t, SftpError>>),
+            readSome,
             (std::function<bool(std::string_view data)> onRead),
             (override));
         MOCK_METHOD((std::future<std::expected<void, SftpError>>), write, (std::string_view data), (override));
diff --git a/ssh/source/ssh/file_stream.cpp b/ssh/source/ssh/file_stream.cpp
index 3478e7eb..3745a6d8 100644
--- a/ssh/source/ssh/file_stream.cpp
+++ b/ssh/source/ssh/file_stream.cpp
@@ -24,10 +24,12 @@ namespace SecureShell
 
         using ResultType = std::invoke_result_t<std::decay_t<FunctionT>>;
         std::promise<ResultType> promise{};
-        promise.set_value(std::unexpected(SftpError{
-            .message = "Owner is null",
-            .wrapperError = WrapperErrors::OwnerNull,
-        }));
+        promise.set_value(
+            std::unexpected(
+                SftpError{
+                    .message = "Owner is null",
+                    .wrapperError = WrapperErrors::OwnerNull,
+                }));
         return promise.get_future();
     }
 
@@ -132,7 +134,7 @@ namespace SecureShell
             };
         }
     }
-    std::future<std::expected<std::size_t, SftpError>> FileStream::read(std::byte* buffer, std::size_t bufferSize)
+    std::future<std::expected<std::size_t, SftpError>> FileStream::readSome(std::byte* buffer, std::size_t bufferSize)
     {
         return performPromise([this, buffer, bufferSize]() -> std::expected<std::size_t, SftpError> {
             VERIFY_FILE_STREAM();
@@ -144,7 +146,21 @@ namespace SecureShell
     }
 
     std::future<std::expected<std::size_t, SftpError>>
-    FileStream::read(std::function<bool(std::string_view data)> onReadFunc)
+    FileStream::readSome(std::function<bool(std::string_view data)> onRead)
+    {
+        return performPromise([this, onRead = std::move(onRead)]() -> std::expected<std::size_t, SftpError> {
+            VERIFY_FILE_STREAM();
+            std::array<char, 4096> buffer{};
+            const auto result = sftp_read(file_.get(), buffer.data(), buffer.size());
+            if (result < 0)
+                return std::unexpected(lastError());
+            onRead({buffer.data(), static_cast<std::size_t>(result)});
+            return static_cast<std::size_t>(result);
+        });
+    }
+
+    std::future<std::expected<std::size_t, SftpError>>
+    FileStream::readAll(std::function<bool(std::string_view data)> onReadFunc)
     {
         struct ReadState : public std::enable_shared_from_this<ReadState>
         {
@@ -194,10 +210,12 @@ namespace SecureShell
                 stream.perform([state = shared_from_this()]() {
                     if (!state->stream.file_)
                     {
-                        state->promise.set_value(std::unexpected(SftpError{
-                            .message = "File is null",
-                            .wrapperError = WrapperErrors::FileNull,
-                        }));
+                        state->promise.set_value(
+                            std::unexpected(
+                                SftpError{
+                                    .message = "File is null",
+                                    .wrapperError = WrapperErrors::FileNull,
+                                }));
                         return;
                     }
                     state->onRead(sftp_read(state->stream.file_.get(), state->buffer.data(), state->buffer.size()));
@@ -235,10 +253,12 @@ namespace SecureShell
 
             if (written == 0 && !toWrite.empty())
             {
-                return onWriteComplete(std::unexpected(SftpError{
-                    .message = "Failed to write any data",
-                    .wrapperError = WrapperErrors::ShortWrite,
-                }));
+                return onWriteComplete(
+                    std::unexpected(
+                        SftpError{
+                            .message = "Failed to write any data",
+                            .wrapperError = WrapperErrors::ShortWrite,
+                        }));
             }
 
             writePart(toWrite.substr(written), std::move(onWriteComplete));
diff --git a/ssh/test/ssh/test_sftp.hpp b/ssh/test/ssh/test_sftp.hpp
index fe756128..b79063ac 100644
--- a/ssh/test/ssh/test_sftp.hpp
+++ b/ssh/test/ssh/test_sftp.hpp
@@ -268,7 +268,7 @@ namespace SecureShell::Test
         ASSERT_TRUE(file);
 
         std::byte byte;
-        auto readFut = file->read(&byte, 1);
+        auto readFut = file->readSome(&byte, 1);
         ASSERT_EQ(readFut.wait_for(1s), std::future_status::ready);
         auto readResult = readFut.get();
         ASSERT_TRUE(readResult.has_value());
@@ -292,7 +292,7 @@ namespace SecureShell::Test
         ASSERT_TRUE(file);
 
         std::vector<std::byte> buffer(1024);
-        auto readFut = file->read(buffer.data(), buffer.size());
+        auto readFut = file->readSome(buffer.data(), buffer.size());
 
         ASSERT_EQ(readFut.wait_for(1s), std::future_status::ready);
         auto readResult = readFut.get();
@@ -318,7 +318,7 @@ namespace SecureShell::Test
         ASSERT_TRUE(file);
 
         std::string data;
-        auto readFut = file->read([&data](std::string_view chunk) {
+        auto readFut = file->readAll([&data](std::string_view chunk) {
             data.append(chunk);
             return true;
         });
@@ -346,7 +346,7 @@ namespace SecureShell::Test
         ASSERT_TRUE(file);
 
         std::string data;
-        auto readFut = file->read([&data](std::string_view chunk) {
+        auto readFut = file->readAll([&data](std::string_view chunk) {
             data.append(chunk);
             return true;
         });
@@ -375,7 +375,7 @@ namespace SecureShell::Test
 
         ASSERT_EQ(file->seek(2).wait_for(1s), std::future_status::ready);
         std::vector<std::byte> buffer(1024);
-        auto readFut2 = file->read(buffer.data(), buffer.size());
+        auto readFut2 = file->readSome(buffer.data(), buffer.size());
 
         ASSERT_EQ(readFut2.wait_for(1s), std::future_status::ready);
         auto readResult2 = readFut2.get();
@@ -403,7 +403,7 @@ namespace SecureShell::Test
         std::vector<std::byte> buffer(1024);
         ASSERT_EQ(file->seek(2).wait_for(1s), std::future_status::ready);
         ASSERT_EQ(file->rewind().wait_for(1s), std::future_status::ready);
-        auto readFut2 = file->read(buffer.data(), buffer.size());
+        auto readFut2 = file->readSome(buffer.data(), buffer.size());
 
         ASSERT_EQ(readFut2.wait_for(1s), std::future_status::ready);
         auto readResult2 = readFut2.get();
diff --git a/static/styles/operation_queue.css b/static/styles/operation_queue.css
index aaafd26a..f1538b48 100644
--- a/static/styles/operation_queue.css
+++ b/static/styles/operation_queue.css
@@ -19,7 +19,8 @@ header.opq-controls {
     border-radius: 10px;
     border: 1px solid var(--opq-border);
     background: linear-gradient(180deg, rgba(255, 255, 255, 0.02), transparent);
-    cursor: pointer
+    cursor: pointer;
+    user-select: none;
 }
 
 .opq-play-toggle .opq-icon {
@@ -175,11 +176,4 @@ header.opq-controls {
 .opq-icon-scan {
     width: 16px;
     height: 16px
-}
-
-.opq-pill {
-    padding: 4px 8px;
-    border-radius: 999px;
-    border: 1px solid rgba(255, 255, 255, 0.03);
-    font-size: 12px
 }
\ No newline at end of file
diff --git a/utility/include/utility/traits_and_concepts/optional.hpp b/utility/include/utility/traits_and_concepts/optional.hpp
new file mode 100644
index 00000000..11c0783c
--- /dev/null
+++ b/utility/include/utility/traits_and_concepts/optional.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <optional>
+#include <type_traits>
+
+namespace Utility
+{
+    template <typename T>
+    struct IsOptional : std::false_type
+    {};
+
+    template <typename T>
+    struct IsOptional<std::optional<T>> : std::true_type
+    {};
+
+    template <typename T>
+    struct StripOptional : public std::type_identity<T>
+    {};
+
+    template <typename T>
+    struct StripOptional<std::optional<T>> : public std::type_identity<T>
+    {};
+
+    template <typename T>
+    using StripOptional_t = typename StripOptional<T>::type;
+
+    template <typename T>
+    constexpr auto IsOptional_v = IsOptional<T>::value;
+
+    template <typename T>
+    concept OptionalType = IsOptional_v<T>;
+}
\ No newline at end of file

From d46ed8625c33d46b07ac34d3290bc8cc1ea37ccf Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Mon, 13 Oct 2025 19:23:36 +0200
Subject: [PATCH 41/42] Improved download buffering.

---
 .../backend/sftp/download_operation.hpp       |  1 +
 .../backend/sftp/download_operation.cpp       | 73 ++++++++++---------
 .../source/backend/sftp/operation_queue.cpp   |  1 +
 .../test/backend/test_download_operation.hpp  | 13 ----
 ssh/include/ssh/file_stream.hpp               | 11 +--
 ssh/include/ssh/file_stream_interface.hpp     | 12 +--
 ssh/include/ssh/mocks/file_stream_mock.hpp    |  7 +-
 ssh/source/ssh/file_stream.cpp                | 16 +---
 ssh/test/ssh/test_sftp.hpp                    |  8 +-
 9 files changed, 48 insertions(+), 94 deletions(-)

diff --git a/backend/include/backend/sftp/download_operation.hpp b/backend/include/backend/sftp/download_operation.hpp
index 199525e1..7459274a 100644
--- a/backend/include/backend/sftp/download_operation.hpp
+++ b/backend/include/backend/sftp/download_operation.hpp
@@ -102,4 +102,5 @@ class DownloadOperation : public Operation
     std::ofstream localFile_;
     std::uint64_t fileSize_;
     std::chrono::seconds futureTimeout_;
+    std::array<char, 8192> buffer_;
 };
\ No newline at end of file
diff --git a/backend/source/backend/sftp/download_operation.cpp b/backend/source/backend/sftp/download_operation.cpp
index 355a7c6f..b01cfe4c 100644
--- a/backend/source/backend/sftp/download_operation.cpp
+++ b/backend/source/backend/sftp/download_operation.cpp
@@ -145,40 +145,9 @@ std::expected<bool, DownloadOperation::Error> DownloadOperation::readOnce()
         return enterErrorState<bool>({.type = ErrorType::FileStreamExpired});
     }
 
-    bool doContinue = false;
-    const auto futureStatus =
-        stream
-            ->readSome([this, &doContinue](std::string_view data) {
-                // No locking, because concurrent access is not possible, the only
-                // other executing thread is blocked right now.
-
-                if (data.size() == 0)
-                {
-                    Log::info("DownloadOperation: Remote file read complete or error.");
-                    return doContinue = false;
-                }
-
-                std::uint64_t tellp = 0;
-                std::uint64_t fileSize = 0;
-                bool good = true;
-                {
-                    localFile_.write(data.data(), data.size());
-                    tellp = static_cast<uint64_t>(localFile_.tellp());
-                    fileSize = fileSize_;
-                    good = localFile_.good();
-                    progressCallback_(0ull, fileSize, tellp);
-                }
-                if (!good)
-                {
-                    Log::error("DownloadOperation read cycle stopped: localFile_.good() == false");
-                    std::ignore = enterErrorState({
-                        .type = SharedData::OperationErrorType::TargetFileNotGood,
-                    });
-                    return doContinue = false;
-                }
-                return doContinue = good && tellp < fileSize;
-            })
-            .wait_for(futureTimeout_);
+    auto future = stream->readSome(buffer_.data(), buffer_.size());
+
+    const auto futureStatus = future.wait_for(futureTimeout_);
 
     if (futureStatus != std::future_status::ready)
     {
@@ -186,7 +155,41 @@ std::expected<bool, DownloadOperation::Error> DownloadOperation::readOnce()
         return enterErrorState<bool>({.type = ErrorType::FutureTimeout});
     }
 
-    return doContinue;
+    const auto result = future.get();
+
+    if (!result.has_value())
+    {
+        Log::error("DownloadOperation: Failed to read from remote file: {}", result.error().message);
+        return enterErrorState<bool>({.type = ErrorType::SftpError, .sftpError = result.error()});
+    }
+
+    const auto readAmount = result.value();
+
+    if (readAmount == 0)
+    {
+        Log::info("DownloadOperation: Remote file read complete or error.");
+        return false;
+    }
+
+    std::uint64_t tellp = 0;
+    std::uint64_t fileSize = 0;
+    bool good = true;
+    {
+        localFile_.write(buffer_.data(), static_cast<std::streamsize>(readAmount));
+        tellp = static_cast<uint64_t>(localFile_.tellp());
+        fileSize = fileSize_;
+        good = localFile_.good();
+        progressCallback_(0ull, fileSize, tellp);
+    }
+    if (!good)
+    {
+        Log::error("DownloadOperation read cycle stopped: localFile_.good() == false");
+        std::ignore = enterErrorState({
+            .type = SharedData::OperationErrorType::TargetFileNotGood,
+        });
+        return false;
+    }
+    return good && tellp < fileSize;
 }
 
 std::expected<void, DownloadOperation::Error> DownloadOperation::openOrAdoptFile(SecureShell::IFileStream& stream)
diff --git a/backend/source/backend/sftp/operation_queue.cpp b/backend/source/backend/sftp/operation_queue.cpp
index 56364f74..5147181c 100644
--- a/backend/source/backend/sftp/operation_queue.cpp
+++ b/backend/source/backend/sftp/operation_queue.cpp
@@ -112,6 +112,7 @@ void OperationQueue::completeOperation(SharedData::OperationCompleted&& operatio
             static_cast<int>(operationCompleted.reason),
             operationCompleted.localPath ? operationCompleted.localPath->generic_string() : "<none>",
             operationCompleted.remotePath ? operationCompleted.remotePath->generic_string() : "<none>");
+
         self->hub_->callRemote(
             fmt::format("OperationQueue::{}::onOperationCompleted", self->sessionId_.value()),
             SharedData::OperationCompleted{
diff --git a/backend/test/backend/test_download_operation.hpp b/backend/test/backend/test_download_operation.hpp
index bf7ae4e9..abf7a01f 100644
--- a/backend/test/backend/test_download_operation.hpp
+++ b/backend/test/backend/test_download_operation.hpp
@@ -82,19 +82,6 @@ namespace Test
                         }
                         return readPromise_.get_future();
                     });
-            EXPECT_CALL(*mock, readSome(testing::_))
-                .WillRepeatedly(
-                    [this](std::function<bool(std::string_view data)> cb)
-                        -> std::future<std::expected<std::size_t, SecureShell::SftpError>> {
-                        onRead_ = std::move(cb);
-                        readPromise_ = {};
-                        if (!readCycleQueue_.empty())
-                        {
-                            readCycleQueue_.front()();
-                            readCycleQueue_.pop();
-                        }
-                        return readPromise_.get_future();
-                    });
         }
 
         void enqueueFakeReadCycle(std::optional<std::size_t> chunkSizeOpt = std::nullopt)
diff --git a/ssh/include/ssh/file_stream.hpp b/ssh/include/ssh/file_stream.hpp
index f15e9e50..bf1ea0f0 100644
--- a/ssh/include/ssh/file_stream.hpp
+++ b/ssh/include/ssh/file_stream.hpp
@@ -62,7 +62,7 @@ namespace SecureShell
          * @param bufferSize
          * @return std::future<std::expected<std::size_t, SftpError>>
          */
-        std::future<std::expected<std::size_t, SftpError>> readSome(std::byte* buffer, std::size_t bufferSize) override;
+        std::future<std::expected<std::size_t, SftpError>> readSome(char* buffer, std::size_t bufferSize) override;
 
         /**
          * @brief Reads all bytes from the file.
@@ -73,15 +73,6 @@ namespace SecureShell
         std::future<std::expected<std::size_t, SftpError>>
         readAll(std::function<bool(std::string_view data)> onRead) override;
 
-        /**
-         * @brief Reads some bytes from the file.
-         *
-         * @param onRead Function to call with read data. Return false to stop reading.
-         * @return std::future<std::expected<std::size_t, SftpError>>
-         */
-        std::future<std::expected<std::size_t, SftpError>>
-        readSome(std::function<bool(std::string_view data)> onRead) override;
-
         /**
          * @brief Writes some bytes to the file.
          * Makes sure that all data is written even if the data is larger than the write limit by breaking it into
diff --git a/ssh/include/ssh/file_stream_interface.hpp b/ssh/include/ssh/file_stream_interface.hpp
index 5d63d45a..3b1a50d9 100644
--- a/ssh/include/ssh/file_stream_interface.hpp
+++ b/ssh/include/ssh/file_stream_interface.hpp
@@ -59,8 +59,7 @@ namespace SecureShell
          * @param bufferSize
          * @return std::future<std::expected<std::size_t, SftpError>>
          */
-        virtual std::future<std::expected<std::size_t, SftpError>>
-        readSome(std::byte* buffer, std::size_t bufferSize) = 0;
+        virtual std::future<std::expected<std::size_t, SftpError>> readSome(char* buffer, std::size_t bufferSize) = 0;
 
         /**
          * @brief Reads all bytes from the file.
@@ -71,15 +70,6 @@ namespace SecureShell
         virtual std::future<std::expected<std::size_t, SftpError>>
         readAll(std::function<bool(std::string_view data)> onRead) = 0;
 
-        /**
-         * @brief Reads some bytes from the file.
-         *
-         * @param onRead
-         * @return std::future<std::expected<std::size_t, SftpError>>
-         */
-        virtual std::future<std::expected<std::size_t, SftpError>>
-        readSome(std::function<bool(std::string_view data)> onRead) = 0;
-
         /**
          * @brief Writes some bytes to the file.
          * Makes sure that all data is written even if the data is larger than the write limit by breaking it into
diff --git a/ssh/include/ssh/mocks/file_stream_mock.hpp b/ssh/include/ssh/mocks/file_stream_mock.hpp
index b65bddc9..3fb3d57c 100644
--- a/ssh/include/ssh/mocks/file_stream_mock.hpp
+++ b/ssh/include/ssh/mocks/file_stream_mock.hpp
@@ -23,18 +23,13 @@ namespace SecureShell::Test
         MOCK_METHOD(
             (std::future<std::expected<std::size_t, SftpError>>),
             readSome,
-            (std::byte * buffer, std::size_t bufferSize),
+            (char* buffer, std::size_t bufferSize),
             (override));
         MOCK_METHOD(
             (std::future<std::expected<std::size_t, SftpError>>),
             readAll,
             (std::function<bool(std::string_view data)> onRead),
             (override));
-        MOCK_METHOD(
-            (std::future<std::expected<std::size_t, SftpError>>),
-            readSome,
-            (std::function<bool(std::string_view data)> onRead),
-            (override));
         MOCK_METHOD((std::future<std::expected<void, SftpError>>), write, (std::string_view data), (override));
         MOCK_METHOD(std::size_t, writeLengthLimit, (), (const, override));
         MOCK_METHOD(std::size_t, readLengthLimit, (), (const, override));
diff --git a/ssh/source/ssh/file_stream.cpp b/ssh/source/ssh/file_stream.cpp
index 3745a6d8..ff1a3b7b 100644
--- a/ssh/source/ssh/file_stream.cpp
+++ b/ssh/source/ssh/file_stream.cpp
@@ -134,7 +134,7 @@ namespace SecureShell
             };
         }
     }
-    std::future<std::expected<std::size_t, SftpError>> FileStream::readSome(std::byte* buffer, std::size_t bufferSize)
+    std::future<std::expected<std::size_t, SftpError>> FileStream::readSome(char* buffer, std::size_t bufferSize)
     {
         return performPromise([this, buffer, bufferSize]() -> std::expected<std::size_t, SftpError> {
             VERIFY_FILE_STREAM();
@@ -145,20 +145,6 @@ namespace SecureShell
         });
     }
 
-    std::future<std::expected<std::size_t, SftpError>>
-    FileStream::readSome(std::function<bool(std::string_view data)> onRead)
-    {
-        return performPromise([this, onRead = std::move(onRead)]() -> std::expected<std::size_t, SftpError> {
-            VERIFY_FILE_STREAM();
-            std::array<char, 4096> buffer{};
-            const auto result = sftp_read(file_.get(), buffer.data(), buffer.size());
-            if (result < 0)
-                return std::unexpected(lastError());
-            onRead({buffer.data(), static_cast<std::size_t>(result)});
-            return static_cast<std::size_t>(result);
-        });
-    }
-
     std::future<std::expected<std::size_t, SftpError>>
     FileStream::readAll(std::function<bool(std::string_view data)> onReadFunc)
     {
diff --git a/ssh/test/ssh/test_sftp.hpp b/ssh/test/ssh/test_sftp.hpp
index b79063ac..2a2fa902 100644
--- a/ssh/test/ssh/test_sftp.hpp
+++ b/ssh/test/ssh/test_sftp.hpp
@@ -267,7 +267,7 @@ namespace SecureShell::Test
         auto file = fileWeak.lock();
         ASSERT_TRUE(file);
 
-        std::byte byte;
+        char byte;
         auto readFut = file->readSome(&byte, 1);
         ASSERT_EQ(readFut.wait_for(1s), std::future_status::ready);
         auto readResult = readFut.get();
@@ -291,7 +291,7 @@ namespace SecureShell::Test
         auto file = fileWeak.lock();
         ASSERT_TRUE(file);
 
-        std::vector<std::byte> buffer(1024);
+        std::vector<char> buffer(1024);
         auto readFut = file->readSome(buffer.data(), buffer.size());
 
         ASSERT_EQ(readFut.wait_for(1s), std::future_status::ready);
@@ -374,7 +374,7 @@ namespace SecureShell::Test
         ASSERT_TRUE(file);
 
         ASSERT_EQ(file->seek(2).wait_for(1s), std::future_status::ready);
-        std::vector<std::byte> buffer(1024);
+        std::vector<char> buffer(1024);
         auto readFut2 = file->readSome(buffer.data(), buffer.size());
 
         ASSERT_EQ(readFut2.wait_for(1s), std::future_status::ready);
@@ -400,7 +400,7 @@ namespace SecureShell::Test
         auto file = fileWeak.lock();
         ASSERT_TRUE(file);
 
-        std::vector<std::byte> buffer(1024);
+        std::vector<char> buffer(1024);
         ASSERT_EQ(file->seek(2).wait_for(1s), std::future_status::ready);
         ASSERT_EQ(file->rewind().wait_for(1s), std::future_status::ready);
         auto readFut2 = file->readSome(buffer.data(), buffer.size());

From 986e679cd6e963637390349727a8790610aba392 Mon Sep 17 00:00:00 2001
From: Tim Ebbeke <Tim06TR@gmail.com>
Date: Tue, 14 Oct 2025 19:46:39 +0200
Subject: [PATCH 42/42] Added operation auto removal.

---
 .../frontend/observed_random_access_map.hpp   |  12 ++
 .../session_components/operation_queue.hpp    |   4 +
 .../session_components/operation_queue.cpp    | 168 ++++++++++++++++--
 static/styles/operation_queue.css             |  31 +++-
 4 files changed, 190 insertions(+), 25 deletions(-)

diff --git a/frontend/include/frontend/observed_random_access_map.hpp b/frontend/include/frontend/observed_random_access_map.hpp
index 5ae8cf22..d86849aa 100644
--- a/frontend/include/frontend/observed_random_access_map.hpp
+++ b/frontend/include/frontend/observed_random_access_map.hpp
@@ -40,6 +40,13 @@ class ObservedRandomAccessMap
         rebuildIndexMap();
     }
 
+    ValueT* front()
+    {
+        if (observedValues_.value().empty())
+            return nullptr;
+        return observedValues_.value().front().get();
+    }
+
     void erase(KeyT const& key)
     {
         auto it = keyToIndexMap_.find(key);
@@ -77,6 +84,11 @@ class ObservedRandomAccessMap
         modifier(*observedValues_[it->second].get());
     }
 
+    bool empty() const
+    {
+        return observedValues_.value().empty();
+    }
+
   private:
     void rebuildIndexMap()
     {
diff --git a/frontend/include/frontend/session_components/operation_queue.hpp b/frontend/include/frontend/session_components/operation_queue.hpp
index 5b9d7802..10310862 100644
--- a/frontend/include/frontend/session_components/operation_queue.hpp
+++ b/frontend/include/frontend/session_components/operation_queue.hpp
@@ -8,9 +8,13 @@
 #include <nui/frontend/element_renderer.hpp>
 #include <roar/detail/pimpl_special_functions.hpp>
 
+#include <chrono>
+
 class OperationQueue
 {
   public:
+    constexpr static std::chrono::seconds autoRemoveTime{5};
+
     OperationQueue(
         Persistence::StateHolder* stateHolder,
         FrontendEvents* events,
diff --git a/frontend/source/frontend/session_components/operation_queue.cpp b/frontend/source/frontend/session_components/operation_queue.cpp
index 369f21f2..73f335ae 100644
--- a/frontend/source/frontend/session_components/operation_queue.cpp
+++ b/frontend/source/frontend/session_components/operation_queue.cpp
@@ -16,14 +16,20 @@
 #include <log/log.hpp>
 #include <nui/frontend/attributes.hpp>
 #include <nui/frontend/elements.hpp>
+#include <nui/frontend/api/timer.hpp>
 #include <nui/frontend/svg.hpp>
 #include <nui/rpc.hpp>
 #include <fmt/format.h>
 
+#include <ui5/components/switch.hpp>
+#include <ui5/components/button.hpp>
+
 #include <variant>
 #include <map>
 #include <chrono>
 
+using namespace std::chrono_literals;
+
 namespace
 {
     constexpr std::string_view progressHeight = "15px";
@@ -144,10 +150,12 @@ namespace
         explicit OperationCard(
             SharedData::OperationType type,
             Ids::OperationId operationId,
-            std::function<void(OperationCard const& operation)> doRemoveSelf)
+            std::function<void(OperationCard const& operation)> doRemoveSelf,
+            std::shared_ptr<Nui::Observed<bool>> doDeletionCountdown)
             : type_{type}
             , operationId_{std::move(operationId)}
             , doRemoveSelf_{std::move(doRemoveSelf)}
+            , doDeletionCountdown_{std::move(doDeletionCountdown)}
         {}
 
         std::string formattedState() const
@@ -169,6 +177,8 @@ namespace
         {
             using namespace Nui::Elements;
             using namespace Nui::Attributes;
+            namespace svg = Nui::Elements::Svg;
+            namespace svga = Nui::Attributes::Svg;
             using Nui::Elements::div;
             using Nui::Elements::span;
 
@@ -210,14 +220,52 @@ namespace
                     }(
                         div{}(static_cast<Derived const*>(this)->title()),
                         div {
-                            class_ = "opq-muted"
+                            class_ = "opq-muted",
+                            Nui::Attributes::title = fmt::format("id: {}", operationId_.value())
                         }(
                             Nui::observe(state_),
                             [this]() -> std::string {
-                                return fmt::format("id: {} • status: {}", operationId_.value(), formattedState());
+                                return fmt::format("status: {}", formattedState());
                             }
                         )
                     ),
+                    div{
+                        class_ = "opq-clock"
+                    }(
+                        observe(completionTime_, doDeletionCountdown_).generate([this]() -> Nui::ElementRenderer {
+                            if (isCompletedState() && *doDeletionCountdown_)
+                            {
+                                constexpr auto radius = 10;
+                                constexpr auto circumference = 2 * 3.14159 * radius;
+                                return svg::svg{
+                                    svga::viewBox = "0 0 24 24",
+                                    svga::fill = "none",
+                                    svga::width = "24",
+                                    svga::height = "24",
+                                }(
+                                    svg::circle{
+                                        svga::r = "10",
+                                        svga::cx = "12",
+                                        svga::cy = "12",
+                                        svga::fill = "none",
+                                        svga::stroke = "white",
+                                        svga::strokeWidth = "2",
+                                        svga::strokeDasharray = std::to_string(circumference),
+                                        svga::strokeLinecap = "round",
+                                        svga::transform = "rotate(-90 12 12)",
+                                    }(
+                                        svg::animate{
+                                            svga::attributeName = "stroke-dashoffset",
+                                            svga::values = fmt::format("{};0", circumference),
+                                            svga::dur = fmt::format("{}s", OperationQueue::autoRemoveTime.count()),
+                                            svga::repeatCount = "1",
+                                        }()
+                                    )
+                                );
+                            }
+                            return Nui::nil();
+                        })
+                    ),
                     button {
                         class_ = "opq-btn opq-cancel-btn",
                         onClick = [this](){
@@ -265,14 +313,32 @@ namespace
                 "Elapsed: 0s");
         }
 
+        std::chrono::steady_clock::time_point completionTime() const
+        {
+            return completionTime_.value();
+        }
+
+        void completionTime(std::chrono::steady_clock::time_point time)
+        {
+            completionTime_ = time;
+            Nui::globalEventContext.executeActiveEventsImmediately();
+        }
+
+        std::chrono::steady_clock::time_point startTime() const
+        {
+            return startTime_;
+        }
+
         virtual bool warrantsCancelConfirm() const = 0;
 
       protected:
         std::chrono::steady_clock::time_point startTime_{std::chrono::steady_clock::now()};
+        Nui::Observed<std::chrono::steady_clock::time_point> completionTime_{};
         Nui::Observed<SharedData::OperationState> state_{SharedData::OperationState::NotStarted};
         SharedData::OperationType type_;
         Ids::OperationId operationId_;
         std::function<void(OperationCard const& operation)> doRemoveSelf_;
+        std::shared_ptr<Nui::Observed<bool>> doDeletionCountdown_;
     };
 
     class DisplayedDownloadOperation : public OperationCard<DisplayedDownloadOperation>
@@ -283,8 +349,9 @@ namespace
             Ids::OperationId operationId,
             std::filesystem::path localPath,
             std::filesystem::path remotePath,
-            std::function<void(OperationCard const& operation)> doRemoveSelf)
-            : OperationCard{SharedData::OperationType::Download, std::move(operationId), std::move(doRemoveSelf)}
+            std::function<void(OperationCard const& operation)> doRemoveSelf,
+            std::shared_ptr<Nui::Observed<bool>> doDeletionCountdown)
+            : OperationCard{SharedData::OperationType::Download, std::move(operationId), std::move(doRemoveSelf), std::move(doDeletionCountdown)}
             , progressBar_{{
                   .height = std::string{progressHeight},
                   .min = 0,
@@ -313,9 +380,6 @@ namespace
                         return "opq-body";
                 }),
             }(
-                div{
-                    class_ = "opq-muted"
-                }("Dynamic content area - this would show progress, nested items, details, etc."),
                 progressBar_()
             );
             // clang-format on
@@ -371,9 +435,35 @@ namespace
                 details,
                 [newState](auto& op) {
                     op.state(newState);
+                    if (op.isCompletedState())
+                        op.completionTime(std::chrono::steady_clock::now());
                 },
                 [](std::monostate) {});
         }
+
+        bool isCompletedState() const
+        {
+            return Utility::visitOverloaded(
+                details,
+                [](auto const& op) {
+                    return op.isCompletedState();
+                },
+                [](std::monostate) {
+                    return false;
+                });
+        }
+
+        std::chrono::steady_clock::time_point completionTime() const
+        {
+            return Utility::visitOverloaded(
+                details,
+                [](auto const& op) {
+                    return op.completionTime();
+                },
+                [](std::monostate) {
+                    return std::chrono::steady_clock::now();
+                });
+        }
     };
 }
 
@@ -388,7 +478,9 @@ struct OperationQueue::Implementation
 
     std::vector<Nui::RpcClient::AutoUnregister> onUpdate;
     Nui::Observed<bool> paused{true};
+    std::shared_ptr<Nui::Observed<bool>> autoClean{std::make_shared<Nui::Observed<bool>>(false)};
     ObservedRandomAccessMap<Ids::OperationId, DisplayedOperation, std::map> operations;
+    Nui::TimerHandle autoCleanTimer;
 
     Implementation(
         Persistence::StateHolder* stateHolder,
@@ -403,6 +495,7 @@ struct OperationQueue::Implementation
         , fileEngine{nullptr}
         , onUpdate{}
         , operations{}
+        , autoCleanTimer{}
     {}
 };
 
@@ -414,7 +507,36 @@ OperationQueue::OperationQueue(
     : impl_{
           std::make_unique<Implementation>(stateHolder, events, std::move(persistenceSessionName), confirmDialog),
       }
-{}
+{
+    Nui::setInterval(
+        1000,
+        [this]() {
+            if (impl_->autoClean && !impl_->operations.empty())
+            {
+                auto now = std::chrono::steady_clock::now();
+                bool anyRemoved = false;
+                for (auto* front = impl_->operations.front(); front != nullptr; front = impl_->operations.front())
+                {
+                    if (front->isCompletedState())
+                    {
+                        auto duration = now - front->completionTime();
+                        if (duration >= autoRemoveTime)
+                        {
+                            impl_->operations.pop_front();
+                            anyRemoved = true;
+                            continue;
+                        }
+                    }
+                    break;
+                }
+                if (anyRemoved)
+                    Nui::globalEventContext.executeActiveEventsImmediately();
+            }
+        },
+        [this](Nui::TimerHandle&& handle) {
+            impl_->autoCleanTimer = std::move(handle);
+        });
+}
 ROAR_PIMPL_SPECIAL_FUNCTIONS_IMPL(OperationQueue);
 
 template <typename OperationCard>
@@ -495,7 +617,9 @@ void OperationQueue::activate(FileEngine* fileEngine, Ids::SessionId sessionId)
                                     *added.remotePath,
                                     [this](OperationCard<DisplayedDownloadOperation> const& operation) {
                                         cancelOperation(operation);
-                                    }};
+                                    },
+                                    impl_->autoClean,
+                                };
                             return std::monostate{};
                         }()});
                 Nui::globalEventContext.executeActiveEventsImmediately();
@@ -628,7 +752,6 @@ Nui::ElementRenderer OperationQueue::operator()()
     // clang-format off
     return div{
         class_ = "operation-queue",
-        style = "width: 100%; height: auto; display: block; overflow-y: scroll",
     }(
         header{
             class_ = "opq-controls"
@@ -677,12 +800,25 @@ Nui::ElementRenderer OperationQueue::operator()()
             )
         ),
         // Main content
-        div{}(
+        div{
+            class_ = "opq-list"
+        }(
+            impl_->operations.observedValues().map(operationsMapper)
+        ),
+        // Footer
+        div{
+            class_ = "opq-footer"
+        }(
+            ui5::switch_{
+                "checked"_prop = impl_->autoClean,
+                "design"_prop = "Graphical",
+                "change"_event = [this](Nui::val event) {
+                    *impl_->autoClean = event["target"]["checked"].as<bool>();
+                }
+            }(),
             div{
-                class_ = "opq-list"
-            }(
-                impl_->operations.observedValues().map(operationsMapper)
-            )
+                style = "font-size: 14px; color: var(--muted);"
+            }("Auto Remove Completed Operations")
         )
     );
     // clang-format on
diff --git a/static/styles/operation_queue.css b/static/styles/operation_queue.css
index f1538b48..82f7d694 100644
--- a/static/styles/operation_queue.css
+++ b/static/styles/operation_queue.css
@@ -1,21 +1,25 @@
 .operation-queue {
-    max-width: 920px;
     margin: auto auto;
-    padding: 20px
+    padding: 5px;
+    width: 100%;
+    height: 100%;
+    display: grid;
+    grid-template-rows: auto 1fr auto;
+    gap: 5px;
 }
 
 header.opq-controls {
     display: flex;
-    gap: 12px;
+    gap: 8px;
     align-items: center;
-    margin-bottom: 16px
+    margin-bottom: 8px
 }
 
 .opq-play-toggle {
     display: inline-flex;
     align-items: center;
     gap: 8px;
-    padding: 8px 12px;
+    padding: 4px 8px;
     border-radius: 10px;
     border: 1px solid var(--opq-border);
     background: linear-gradient(180deg, rgba(255, 255, 255, 0.02), transparent);
@@ -43,7 +47,16 @@ header.opq-controls {
 .opq-list {
     display: flex;
     flex-direction: column;
-    gap: 12px
+    overflow-y: auto;
+    gap: 5px
+}
+
+.opq-footer {
+    margin-top: 8px;
+    color: var(--opq-muted);
+    display: flex;
+    align-items: center;
+    gap: 12px;
 }
 
 .opq-card {
@@ -60,8 +73,8 @@ header.opq-controls {
 
 .opq-header {
     display: flex;
-    gap: 12px;
-    padding: 12px 14px;
+    gap: 8px;
+    padding: 8px 10px;
     align-items: center
 }
 
@@ -86,7 +99,7 @@ header.opq-controls {
 }
 
 .opq-btn {
-    padding: 6px 10px;
+    padding: 3px 5px;
     border-radius: 8px;
     border: 1px solid var(--opq-border);
     background: transparent;