dropshell release 2025.0521.2125

source/agent-local/agent-install.sh

@@ -50,7 +50,7 @@ function install_bb64() {
         _die "Curl is not installed. Curl is required for agent installation."
     fi
 
-    curl -fsSL "https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh" | bash -s -- "$AGENT_PATH" "$(id -u $USER):$(id -g $USER)"
+    curl -fsSL "https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh" | bash -s -- "$AGENT_LOCAL_PATH" "$(id -u $USER):$(id -g $USER)"
 
     # test result code from curl
     if [ $? -ne 0 ]; then
@@ -58,7 +58,7 @@ function install_bb64() {
     fi
 
     # test if bb64 is installed
-    "$AGENT_PATH/bb64" -v
+    "$AGENT_LOCAL_PATH/bb64" -v
     if [ $? -ne 0 ]; then
         _die "bb64 did not install correctly."
     fi
@@ -71,11 +71,11 @@ function install_bb64() {
 #-------------------------------------------------------------------------
 
 set -a
-AGENT_PATH="$SCRIPT_DIR"
+AGENT_LOCAL_PATH="$SCRIPT_DIR"
 set +a
 
-_check_required_env_vars "AGENT_PATH"
-echo "Installing host agent into $AGENT_PATH"
+_check_required_env_vars "AGENT_LOCAL_PATH"
+echo "Installing host agent into $AGENT_LOCAL_PATH"
 
 _check_docker_installed || _die "Docker is required."
 

source/src/commands/backupdata.cpp

@@ -102,7 +102,7 @@ namespace dropshell
             }
 
             // Create backups directory locally if it doesn't exist
-            std::string local_backups_dir = gConfig().get_local_backup_path();
+            std::string local_backups_dir = localpath::backups();
             if (local_backups_dir.empty())
             {
                 error << "Error: Local backups directory not found" << std::endl;

source/src/commands/create-server.cpp

@@ -0,0 +1,63 @@
+#include "command_registry.hpp"
+#include "config.hpp"
+#include "utils/utils.hpp"
+#include "utils/directories.hpp"
+#include "shared_commands.hpp"
+#include "version.hpp"
+
+#include <unistd.h>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <filesystem>
+#include "utils/assert.hpp"
+
+namespace dropshell {
+
+void create_server_autocomplete(const CommandContext& ctx);
+int create_server_handler(const CommandContext& ctx);
+
+static std::vector<std::string> create_server_name_list={"create-server"};
+
+// Static registration
+struct CreateServerCommandRegister {
+    CreateServerCommandRegister() {
+        CommandRegistry::instance().register_command({
+            create_server_name_list,
+            create_server_handler,
+            create_server_autocomplete,
+            false, // hidden
+            true, // requires_config
+            true, // requires_install
+            1,     // min_args (after command)
+            1,     // max_args (after command)
+            "create-server [SERVER]",
+            "Create a new server entry on this host.",
+            // heredoc
+            R"(
+            Create a new server entry on this host.
+            Note you will need to use   ds install SERVER   to prepare the service for use.
+
+            create-server SERVER
+            )"
+        });
+    }
+} create_server_command_register;
+
+
+void create_server_autocomplete(const CommandContext& ctx) {
+    return; // can't autocomplete as it's a new server!
+}
+
+
+int create_server_handler(const CommandContext& ctx) {
+    // create a new server entry on this host
+    if (ctx.args.size() == 0) {
+        error << "No server name provided" << std::endl;
+        return 1;
+    }
+    bool ok = create_server(ctx.args[0]);
+    return ok ? 0 : 1;
+}
+
+} // namespace dropshell

source/src/commands/create-template.cpp

@@ -0,0 +1,63 @@
+#include "command_registry.hpp"
+#include "config.hpp"
+#include "utils/utils.hpp"
+#include "utils/directories.hpp"
+#include "shared_commands.hpp"
+#include "version.hpp"
+#include "utils/assert.hpp"
+#include "templates.hpp"
+
+#include <unistd.h>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <filesystem>
+
+namespace dropshell {
+
+void create_template_autocomplete(const CommandContext& ctx);
+int create_template_handler(const CommandContext& ctx);
+
+static std::vector<std::string> create_template_name_list={"create-template"};
+
+// Static registration
+struct CreateTemplateCommandRegister {
+    CreateTemplateCommandRegister() {
+        CommandRegistry::instance().register_command({
+            create_template_name_list,
+            create_template_handler,
+            create_template_autocomplete,
+            false, // hidden
+            true, // requires_config
+            true, // requires_install
+            1,     // min_args (after command)
+            1,     // max_args (after command)
+            "create-template TEMPLATE",
+            "Create a new template.",
+            // heredoc
+            R"(
+            Create a new template.
+
+            create-template TEMPLATE
+            )"
+        });
+    }
+} create_template_command_register;
+
+
+void create_template_autocomplete(const CommandContext& ctx) {
+    return; // can't autocomplete as it's a new server!
+}
+
+
+int create_template_handler(const CommandContext& ctx) {
+    // create a new server entry on this host
+    if (ctx.args.size() == 0) {
+        error << "No template name provided" << std::endl;
+        return 1;
+    }
+    bool ok = gTemplateManager().create_template(ctx.args[0]);
+    return ok ? 0 : 1;
+}
+
+} // namespace dropshell

source/src/commands/destroy.cpp

@@ -14,7 +14,7 @@ namespace dropshell
 {
 
     int nuke_handler(const CommandContext &ctx);
-    static std::vector<std::string> nuke_name_list = {"nuke"};
+    static std::vector<std::string> nuke_name_list = {"destroy","nuke"};
 
     // Static registration
     struct NukeCommandRegister
@@ -29,15 +29,15 @@ namespace dropshell
                                                           true,  // requires_install
                                                           2,     // min_args (after command)
                                                           2,     // max_args (after command)
-                                                          "nuke SERVER SERVICE|all",
-                                                          "Nuke a service on a server. Destroys everything, both local and remote!",
+                                                          "destroy SERVER SERVICE|all",
+                                                          "Destroy a service on a server. Erases everything, both local and remote!",
                                                           // heredoc
                                                           R"(
             Nuke a service.
 
             Examples:
-            nuke SERVER SERVICE   nuke the given service on the given server.
-            nuke SERVER all       nuke all services on the given server.
+            destroy SERVER SERVICE   destroy the given service on the given server.
+            destroy SERVER all       destroy all services on the given server.
 
             Note: This command is destructive and will destroy all data and all configuration,
             both on the dropshell host and on the remote server.

source/src/commands/help.cpp

@@ -45,7 +45,7 @@ struct HelpCommandRegister {
 
 
 void help_autocomplete(const CommandContext& ctx) {
-    if (ctx.args.size() == 1) {
+    if (ctx.args.size() == 0) {
         // list all commands
         for (const auto& cmd : CommandRegistry::instance().list_primary_commands(false)) {
             rawout << cmd << std::endl;
@@ -148,6 +148,7 @@ int help_handler(const CommandContext& ctx) {
         info << std::endl;
         show_command("ssh");
         info << std::endl;
+        show_command("create-server");
         show_command("create-service");
     }
     return 0;

source/src/commands/install.cpp

@@ -40,7 +40,7 @@ namespace dropshell
                                                           0,     // min_args (after command)
                                                           2,     // max_args (after command)
                                                           "install [SERVER] [SERVICE|all]",
-                                                          "Install/reinstall host, remote servers, or service(s). Safe/non-destructive way to update.",
+                                                          "Install/reinstall host and remote servers, or service(s). Safe way to update.",
                                                           // heredoc
                                                           R"(
             Install components on a server. This is safe to re-run (non-destructive) and used to update
@@ -238,30 +238,22 @@ namespace dropshell
     {
         maketitle("Installing dropshell agent on this computer...");
 
-        std::vector<std::filesystem::path> paths = {
-            gConfig().get_local_template_cache_path(),
-            gConfig().get_local_backup_path(),
-            gConfig().get_local_tempfiles_path(),
-            localpath::agent()};
-        for (auto &p : gConfig().get_local_server_definition_paths())
-            paths.push_back(p);
+        // clear out old cruft.
+        std::filesystem::remove_all(localpath::agent_local());
+        std::filesystem::remove_all(localpath::agent_remote());
 
-        for (auto &p : paths)
-            if (!std::filesystem::exists(p))
-            {
-                info << "Creating directory: " << p << std::endl;
-                std::filesystem::create_directories(p);
-            }
+        // recreate the directories.
+        localpath::create_directories();
 
-        // create the agent-local directory.
-        recreate_agent_local::recreate_tree(localpath::agent());
+        // populate the agent-local directory.
+        recreate_agent_local::recreate_tree(localpath::agent_local());
 
         // run the local agent installer.
-            execute_local_command(localpath::agent(), "agent-install.sh",{}, nullptr, cMode::Defaults | cMode::NoBB64);
+        execute_local_command(localpath::agent_local(), "agent-install.sh",{}, nullptr, cMode::Defaults | cMode::NoBB64);
 
-        // create the agent-remote directory.
+        // populate the agent-remote directory.
         info << "Creating local files to copy to remote agents..." << std::endl;
-        recreate_agent_remote::recreate_tree(localpath::files_for_remote_agent());
+        recreate_agent_remote::recreate_tree(localpath::agent_remote());
 
         return 0;
     }
@@ -288,7 +280,7 @@ namespace dropshell
         // now create the agent.
         // copy across from the local agent files.
         info << "Copying local agent files to remote server... " << std::flush;
-        shared_commands::rsync_tree_to_remote(localpath::files_for_remote_agent(), agent_path, server_env, false);
+        shared_commands::rsync_tree_to_remote(localpath::agent_remote(), agent_path, server_env, false);
         info << "done." << std::endl;
 
         // run the agent installer. Can't use BB64 yet, as we're installing it on the remote server.

source/src/commands/restoredata.cpp

@@ -57,7 +57,7 @@ namespace dropshell
 
     std::vector<shared_commands::cBackupFileName> get_backup_files(const std::string &server, const std::string &match_service = "", const std::string &match_template_name = "")
     {
-        std::string local_backups_dir = gConfig().get_local_backup_path();
+        std::string local_backups_dir = localpath::backups();
         if (local_backups_dir.empty() || !std::filesystem::exists(local_backups_dir))
         {
             error << "Error: Local backups directory not found: " << local_backups_dir << std::endl;
@@ -137,7 +137,7 @@ namespace dropshell
         debug << "   Server:                      " << server << std::endl;
         debug << "   Service:                     " << service << std::endl;
 
-        std::string local_backups_dir = gConfig().get_local_backup_path();
+        std::string local_backups_dir = localpath::backups();
         if (local_backups_dir.empty() || !std::filesystem::exists(local_backups_dir))
         {
             error << "Error: Local backups directory not found: " << local_backups_dir << std::endl;

source/src/config.cpp

@@ -46,6 +46,15 @@ bool config::load_config() { // load json config file.
     return true;
 }
 
+void _append(std::vector<std::string> & a, const std::vector<std::string> & b) {
+    if (b.empty())
+        return;
+    if (a.empty())
+        a = b;
+    else
+        a.insert(std::end(a), std::begin(b), std::end(b));
+}
+
 bool config::save_config(bool create_aux_directories)
 {
     std::string config_path = localfile::dropshell_json();
@@ -61,37 +70,27 @@ bool config::save_config(bool create_aux_directories)
     if (!mIsConfigSet)
     {
         std::string homedir = localpath::current_user_home();
-        std::string dropshell_base = homedir + "/.dropshell";
-        mConfig["tempfiles"] = dropshell_base + "/tmp";
-        mConfig["backups"] = dropshell_base + "/backups";
-
-        mConfig["template_cache"] = dropshell_base + "/template_cache";
-        mConfig["template_registry_URLs"] = {
-            "https://templates.dropshell.app"
-        };
-        mConfig["template_local_paths"] = {
-            dropshell_base + "/local_templates"
-        };
+        std::string dropshell_base = homedir + "/.local/dropshell_files";
 
         mConfig["server_definition_paths"] = {
             dropshell_base + "/servers"
         };
-        mConfig["template_upload_registry_url"] = "https://templates.dropshell.app"; 
-        mConfig["template_upload_registry_token"] = "SECRETTOKEN";
+        mConfig["template_local_paths"] = {
+            dropshell_base + "/local_templates"
+        };
+        mConfig["template_registry_URLs"] = {
+            "https://templates.dropshell.app"
+        };        
+        mConfig["template_upload_token"] = "SECRETTOKEN";
     }   
 
     config_file << mConfig.dump(4);
     config_file.close();
 
     if (create_aux_directories) {
-        std::vector<std::filesystem::path> paths = {
-            get_local_template_cache_path(),
-            get_local_backup_path(),
-            get_local_tempfiles_path()
-        };
-        for (auto & p : get_local_server_definition_paths()) 
-            paths.push_back(p);
-
+        std::vector<std::string> paths;
+        _append(paths, get_local_template_paths());
+        _append(paths, get_local_server_definition_paths());
         for (auto & p : paths)
             if (!std::filesystem::exists(p))
             {
@@ -100,6 +99,11 @@ bool config::save_config(bool create_aux_directories)
             }
     }
 
+    debug << "Config paths: " << std::endl;
+    for (auto [key,value] : mConfig.items()) {
+        debug << "  " << key << ": " << value << std::endl;
+    }
+    
     return true;
 }
 
@@ -110,31 +114,20 @@ bool config::is_config_set() const
 
 bool config::is_agent_installed()
 {
-    return std::filesystem::exists(localpath::agent() + "/bb64");
-}
-
-std::string config::get_local_tempfiles_path() {
-    return mConfig["tempfiles"];
-}
-
-std::string config::get_local_backup_path() {
-    return mConfig["backups"];
-}
-
-std::string config::get_local_template_cache_path() {
-    return mConfig["template_cache"];
+    return std::filesystem::exists(localfile::bb64());
 }
 
 std::vector<std::string> config::get_template_registry_urls() {
     nlohmann::json template_registry_urls = mConfig["template_registry_URLs"];
     std::vector<std::string> urls;
     for (auto &url : template_registry_urls) {
+        if (url.is_string() && !url.empty())
             urls.push_back(url);
     }
     return urls;
 }
 
-std::vector<std::string> config::get_template_local_paths()
+std::vector<std::string> config::get_local_template_paths()
 {
     nlohmann::json template_local_paths = mConfig["template_local_paths"];
     std::vector<std::string> paths;
@@ -147,23 +140,40 @@ std::vector<std::string> config::get_template_local_paths()
 
 std::vector<std::string> config::get_local_server_definition_paths() {
     nlohmann::json server_definition_paths = mConfig["server_definition_paths"];
-
     std::vector<std::string> paths;
     for (auto &path : server_definition_paths) {
         if (path.is_string() && !path.empty())
             paths.push_back(path);
-        else
-            warning << "Invalid server definition path: " << path << std::endl;
     }
     return paths;
 }
 
-std::string config::get_template_upload_registry_url() {
-    return mConfig["template_upload_registry_url"];
+std::string config::get_server_create_path()
+{
+    std::vector<std::string> paths = get_local_server_definition_paths();
+    if (paths.empty())
+        return "";
+    return paths[0];
 }
 
-std::string config::get_template_upload_registry_token() {
-    return mConfig["template_upload_registry_token"];
+std::string config::get_template_create_path()
+{
+    std::vector<std::string> paths = get_local_template_paths();
+    if (paths.empty())
+        return "";
+    return paths[0];
+}
+
+std::string config::get_template_upload_url()
+{
+    std::vector<std::string> urls = get_template_registry_urls();
+    if (urls.empty())
+        return "";
+    return urls[0];
+}
+
+std::string config::get_template_upload_token() {
+    return mConfig["template_upload_token"];
 }
 
 } // namespace dropshell 

source/src/config.hpp

@@ -17,15 +17,14 @@ class config {
         bool is_config_set() const;
         static bool is_agent_installed();
 
-        std::string get_local_tempfiles_path();
-        std::string get_local_backup_path();
-        std::string get_local_template_cache_path();
         std::vector<std::string> get_template_registry_urls();
-        std::vector<std::string> get_template_local_paths();
+        std::vector<std::string> get_local_template_paths();
         std::vector<std::string> get_local_server_definition_paths();
 
-        std::string get_template_upload_registry_url();
-        std::string get_template_upload_registry_token();
+        std::string get_server_create_path();
+        std::string get_template_create_path(); 
+        std::string get_template_upload_url();  
+        std::string get_template_upload_token();
 
     private:
         nlohmann::json mConfig;

source/src/servers.cpp

@@ -7,6 +7,7 @@
 #include "config.hpp"
 #include "templates.hpp"
 #include "contrib/transwarp.hpp"
+#include "utils/output.hpp"
 
 #include <iostream>
 #include <fstream>
@@ -76,16 +77,16 @@ bool create_server(const std::string &server_name)
     // 1. check if server name already exists
     std::string server_existing_dir = localpath::server(server_name);
     if (!server_existing_dir.empty()) {
-        std::cerr << "Error: Server name already exists: " << server_name << std::endl;
-        std::cerr << "Current server path: " << server_existing_dir << std::endl;
+        error << "Error: Server name already exists: " << server_name << std::endl;
+        info << "Current server path: " << server_existing_dir << std::endl;
         return false;
     }
 
     // 2. create a new directory in the user config directory
     auto lsdp = gConfig().get_local_server_definition_paths();
     if (lsdp.empty() || lsdp[0].empty()) {
-        std::cerr << "Error: Local server definition path not found" << std::endl;
-        std::cerr << "Run 'dropshell edit' to configure DropShell" << std::endl;
+        error << "Error: Local server definition path not found" << std::endl;
+        info << "Run 'dropshell edit' to configure DropShell" << std::endl;
         return false;
     }
     std::string server_dir = lsdp[0] + "/" + server_name;
@@ -93,20 +94,20 @@ bool create_server(const std::string &server_name)
 
     // 3. create a template server.env file in the server directory
     std::string user = getenv("USER");
-    std::string server_env_path = server_dir + "/server.env";
+    std::string server_env_path = server_dir + "/server.json";
     std::ofstream server_env_file(server_env_path);
-    server_env_file << "SSH_HOST=" << server_name << std::endl;
-    server_env_file << "SSH_USER=" << user << std::endl;
-    server_env_file << "SSH_PORT=" << 22 << std::endl;
-    server_env_file << std::endl;
-    server_env_file << "DROPSHELL_DIR=/home/"+user+"/.dropshell" << std::endl;
+    server_env_file << "{" << std::endl;
+    server_env_file << "    \"SSH_HOST\": \"" << server_name << "\"," << std::endl;
+    server_env_file << "    \"SSH_USER\": \"" << user << "\"," << std::endl;
+    server_env_file << "    \"SSH_PORT\": " << 22 << "," << std::endl;
+    server_env_file << "    \"DROPSHELL_DIR\": \"" << "/home/"+user+"/.dropshell\"" << std::endl;
+    server_env_file << "}" << std::endl;
     server_env_file.close();
 
     std::cout << "Server created successfully: " << server_name << std::endl;
     std::cout << "Please complete the installation:" <<std::endl;
     std::cout << "1) edit the server configuration: dropshell edit " << server_name << std::endl;
-    std::cout << "2) test ssh is working:           dropshell ssh " << server_name << std::endl;
-    std::cout << "3) install the server:            dropshell install " << server_name << std::endl;
+    std::cout << "2) install the server:            dropshell install " << server_name << std::endl;
     std::cout << std::endl;
     return true;
 }

source/src/service_runner.cpp

@@ -1,529 +1,529 @@
 
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <cstdlib>
-#include <chrono>
-#include <iomanip>
-#include <filesystem>
-#include <unistd.h>
-#include "utils/assert.hpp"
+// #include <iostream>
+// #include <fstream>
+// #include <sstream>
+// #include <cstdlib>
+// #include <chrono>
+// #include <iomanip>
+// #include <filesystem>
+// #include <unistd.h>
+// #include "utils/assert.hpp"
 
-#include "config.hpp"
-#include "server_env_manager.hpp"
-#include "templates.hpp"
-#include "services.hpp"
-#include "utils/directories.hpp"
-#include "utils/utils.hpp"
-#include "command_registry.hpp"
-#include "shared_commands.hpp"
+// #include "config.hpp"
+// #include "server_env_manager.hpp"
+// #include "templates.hpp"
+// #include "services.hpp"
+// #include "utils/directories.hpp"
+// #include "utils/utils.hpp"
+// #include "command_registry.hpp"
+// #include "shared_commands.hpp"
 
 
 
 
-namespace dropshell {
+// namespace dropshell {
 
 
 
-class service_runner {
-    public:
-        service_runner(const std::string& server_name, const std::string& service_name);
-        bool isValid() const { return mValid; }
+// class service_runner {
+//     public:
+//         service_runner(const std::string& server_name, const std::string& service_name);
+//         bool isValid() const { return mValid; }
 
-        // run a command over ssh, using the credentials from server.env (via server_env.hpp)
-        // first check that the command corresponds to a valid .sh file in the service directory
-        // then run the command, passing the {service_name}.env file as an argument
-        // do a lot of checks, such as:
-        // checking that we can ssh to the server.
-        // checking whether the service directory exists on the server.
-        // checking that the command exists in the service directory.
-        // checking that the command is a valid .sh file.
-        // checking that the {service_name}.env file exists in the service directory.
-        bool run_command(const std::string& command, std::vector<std::string> additional_args={}, std::map<std::string, std::string> env_vars={});
+//         // run a command over ssh, using the credentials from server.env (via server_env.hpp)
+//         // first check that the command corresponds to a valid .sh file in the service directory
+//         // then run the command, passing the {service_name}.env file as an argument
+//         // do a lot of checks, such as:
+//         // checking that we can ssh to the server.
+//         // checking whether the service directory exists on the server.
+//         // checking that the command exists in the service directory.
+//         // checking that the command is a valid .sh file.
+//         // checking that the {service_name}.env file exists in the service directory.
+//         bool run_command(const std::string& command, std::vector<std::string> additional_args={}, std::map<std::string, std::string> env_vars={});
 
-        // check health of service. Silent.
-        // 1. run status.sh on the server
-        // 2. return the output of the status.sh script
+//         // check health of service. Silent.
+//         // 1. run status.sh on the server
+//         // 2. return the output of the status.sh script
 
-        //HealthStatus is_healthy();
+//         //HealthStatus is_healthy();
 
-        // std::string healthtick();
-        // std::string healthmark();
+//         // std::string healthtick();
+//         // std::string healthmark();
 
-    public:            
-        // backup and restore
-        bool backup(bool silent=false);
-        bool restore(std::string backup_file, bool silent=false);
+//     public:            
+//         // backup and restore
+//         bool backup(bool silent=false);
+//         bool restore(std::string backup_file, bool silent=false);
 
-        // nuke the service
-        bool nuke(bool silent=false); // nukes all data for this service on the remote server
-        bool fullnuke(); // nuke all data for this service on the remote server, and then nukes all the local service definitionfiles
+//         // nuke the service
+//         bool nuke(bool silent=false); // nukes all data for this service on the remote server
+//         bool fullnuke(); // nuke all data for this service on the remote server, and then nukes all the local service definitionfiles
 
-        // launch an interactive ssh session on a server or service
-        // replaces the current dropshell process with the ssh process
-        bool interactive_ssh_service();
+//         // launch an interactive ssh session on a server or service
+//         // replaces the current dropshell process with the ssh process
+//         bool interactive_ssh_service();
 
-        bool scp_file_to_remote(const std::string& local_path, const std::string& remote_path, bool silent=false);
-        bool scp_file_from_remote(const std::string& remote_path, const std::string& local_path, bool silent=false);
-    public:
-        // utility functions
-        static std::string get_latest_backup_file(const std::string& server, const std::string& service);
-        static bool interactive_ssh(const std::string & server_name, const std::string & command);
-        // static std::map<std::string, ServiceStatus> get_all_services_status(std::string server_name);
+//         bool scp_file_to_remote(const std::string& local_path, const std::string& remote_path, bool silent=false);
+//         bool scp_file_from_remote(const std::string& remote_path, const std::string& local_path, bool silent=false);
+//     public:
+//         // utility functions
+//         static std::string get_latest_backup_file(const std::string& server, const std::string& service);
+//         static bool interactive_ssh(const std::string & server_name, const std::string & command);
+//         // static std::map<std::string, ServiceStatus> get_all_services_status(std::string server_name);
 
-    private:
-        std::string mServer;
-        server_env_manager mServerEnv;
-        LocalServiceInfo mServiceInfo;
-        std::string mService;
-        bool mValid;
+//     private:
+//         std::string mServer;
+//         server_env_manager mServerEnv;
+//         LocalServiceInfo mServiceInfo;
+//         std::string mService;
+//         bool mValid;
 
-        // Helper methods
-    public:
-};
+//         // Helper methods
+//     public:
+// };
 
 
-} // namespace dropshell
+// } // namespace dropshell
 
 
 
-namespace fs = std::filesystem;
+// namespace fs = std::filesystem;
 
-namespace dropshell {
+// namespace dropshell {
 
 
-service_runner::service_runner(const std::string& server_name, const std::string& service_name) : 
-    mServerEnv(server_name), mServer(server_name), mService(service_name), mValid(false)
-{
-    if (server_name.empty() || service_name.empty())
-        return; 
+// service_runner::service_runner(const std::string& server_name, const std::string& service_name) : 
+//     mServerEnv(server_name), mServer(server_name), mService(service_name), mValid(false)
+// {
+//     if (server_name.empty() || service_name.empty())
+//         return; 
 
-    // Initialize server environment
-    if (!mServerEnv.is_valid()) 
-        return;
+//     // Initialize server environment
+//     if (!mServerEnv.is_valid()) 
+//         return;
 
-    mServiceInfo = get_service_info(server_name, service_name);
-    if (mServiceInfo.service_name.empty())
-        return;
+//     mServiceInfo = get_service_info(server_name, service_name);
+//     if (mServiceInfo.service_name.empty())
+//         return;
 
-    mService = mServiceInfo.service_name;
+//     mService = mServiceInfo.service_name;
     
-    mValid = !mServiceInfo.local_template_path.empty();
-}
+//     mValid = !mServiceInfo.local_template_path.empty();
+// }
 
 
 
-bool service_runner::nuke(bool silent)
-{
-    maketitle("Nuking " + mService + " (" + mServiceInfo.template_name + ") on " + mServer);
+// bool service_runner::nuke(bool silent)
+// {
+//     maketitle("Nuking " + mService + " (" + mServiceInfo.template_name + ") on " + mServer);
 
-    if (!mServerEnv.is_valid()) return false; // should never hit this.
+//     if (!mServerEnv.is_valid()) return false; // should never hit this.
 
-    std::string remote_service_path = remotepath::service(mServer, mService);
-
-    info << "Service " << mService << " successfully nuked from " << mServer << std::endl;
-
-    if (!silent) {
-        info << "There's nothing left on the remote server." << std::endl;
-        info << "You can remove the local files with:" << std::endl;
-        info << "   rm -rf " << localpath::service(mServer,mService) << std::endl;
-    }
-    return true;
-}
-
-bool service_runner::fullnuke()
-{
-    if (!nuke(true))
-    {
-        warning << "Nuke script failed, aborting." << std::endl;
-        return false;
-    }
-
-    std::string local_service_path = mServiceInfo.local_service_path;
-    if (local_service_path.empty() || !fs::exists(local_service_path)) {
-        error << "Service directory not found: " << local_service_path << std::endl;
-        return false;
-    }  
-    
-    std::string rm_cmd = "rm -rf " + quote(local_service_path);
-    if (!execute_local_command("", rm_cmd, {}, nullptr, cMode::Silent)) {
-        error << "Failed to remove service directory" << std::endl;
-        return false;
-    }
-    
-    return true;
-}
-
-
-// ------------------------------------------------------------------------------------------------
-// Run a command on the service.
-// ------------------------------------------------------------------------------------------------
-bool service_runner::run_command(const std::string& command, std::vector<std::string> additional_args, std::map<std::string, std::string> env_vars) {
-    if (!mServerEnv.is_valid()) {
-        std::cerr << "Error: Server service not initialized" << std::endl;
-        return false;
-    }
-    template_info tinfo = gTemplateManager().get_template_info(mServiceInfo.template_name);
-    if (!tinfo.is_set()) {
-        std::cerr << "Error: Template '" << mServiceInfo.template_name << "' not found" << std::endl;
-        return false;
-    }
-
-    if (command == "fullnuke") 
-        return fullnuke();
-
-    if (command == "nuke") 
-    {
-        std::cout << "Nuking " << mService << " (" << mServiceInfo.template_name << ") on " << mServer << std::endl;
-        return nuke();
-    }
-
-    if (!gTemplateManager().template_command_exists(mServiceInfo.template_name, command)) {
-        std::cout << "No command script for " << mServiceInfo.template_name << " : " << command << std::endl;
-        return true; // nothing to run.
-    }
-
-    // install doesn't require anything on the server yet.
-    // if (command == "install") 
-    //     return install_service(mServer, mService, false);
-
-    std::string script_path = remotepath::service_template(mServer, mService) + "/" + command + ".sh";
-    
-    // Check if service directory exists
-    if (!mServerEnv.check_remote_dir_exists(remotepath::service(mServer, mService))) {
-        std::cerr << "Error: Service is not installed: " << mService << std::endl;
-        return false;
-    }
-    
-    // Check if command script exists
-    if (!mServerEnv.check_remote_file_exists(script_path)) {
-        std::cerr << "Error: Remote command script not found: " << script_path << std::endl;
-        return false;
-    }
-
-    // Check if env file exists
-    if (!mServerEnv.check_remote_file_exists(remotefile::service_env(mServer, mService))) {
-        std::cerr << "Error: Service config file not found: " << remotefile::service_env(mServer, mService) << std::endl;
-        return false;
-    }
-
-    // if (command == "uninstall") 
-    //     return uninstall();
-
-    if (command == "ssh") {
-        interactive_ssh_service();
-        return true;
-    }
-    if (command == "restore") {
-        if (additional_args.size() < 1) {
-            std::cerr << "Error: restore requires a backup file:" << std::endl;
-            std::cerr << "dropshell restore <server> <service> <backup-file>" << std::endl;
-            return false;
-        }
-        return restore(additional_args[0], false);
-    }
-    if (command == "backup") {
-        return backup(false);
-    }
-
-    // Run the generic command
-    std::vector<std::string> args; // not passed through yet.
-    return mServerEnv.run_remote_template_command(mService, command, args, false, env_vars);
-}
-
-
-
-bool service_runner::interactive_ssh(const std::string & server_name, const std::string & command) {
-    std::string serverpath = localpath::server(server_name);
-    if (serverpath.empty()) {
-        std::cerr << "Error: Server not found: " << server_name << std::endl;
-        return false;
-    }
-    
-    server_env_manager env(server_name);
-    if (!env.is_valid()) {
-        std::cerr << "Error: Invalid server environment file: " << server_name << std::endl;
-        return false;
-    }
-    sCommand scommand("", "bash",{});
-    return execute_ssh_command(env.get_SSH_INFO(), scommand, cMode::Interactive);
-}
-
-
-
-bool service_runner::interactive_ssh_service()
-{
-    std::set<std::string> used_commands = get_used_commands(mServer, mService);
-    if (used_commands.find("ssh") == used_commands.end()) {
-        std::cerr << "Error: "<< mService <<" does not support ssh" << std::endl;
-        return false;
-    }
-
-    std::vector<std::string> args; // not passed through yet.
-    return mServerEnv.run_remote_template_command(mService, "ssh", args, false, {});
-}
-
-bool service_runner::scp_file_to_remote(const std::string &local_path, const std::string &remote_path, bool silent)
-{
-    std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " + quote(local_path) + " " + mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + quote(remote_path) + (silent ? " > /dev/null 2>&1" : "");
-    return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
-}
-
-bool service_runner::scp_file_from_remote(const std::string &remote_path, const std::string &local_path, bool silent)
-{
-    std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " + mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + quote(remote_path) + " " + quote(local_path) + (silent ? " > /dev/null 2>&1" : "");
-    return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
-}
-
-bool service_runner::restore(std::string backup_file, bool silent)
-{
-    if (backup_file.empty()) {
-        std::cerr << "Error: not enough arguments.  dropshell restore <server> <service> <backup-file>" << std::endl;
-        return false;
-    }
-
-    std::string local_backups_dir = gConfig().get_local_backup_path();
-
-    if (backup_file == "latest") {
-        // get the latest backup file from the server
-        backup_file = get_latest_backup_file(mServer, mService);
-    }
-
-    std::string local_backup_file_path = (std::filesystem::path(local_backups_dir) / backup_file).string();
-
-    if (! std::filesystem::exists(local_backup_file_path)) {
-        std::cerr << "Error: Backup file not found at " << local_backup_file_path << std::endl;
-        return false;
-    }
-
-    // split the backup filename into parts based on the magic string
-    std::vector<std::string> parts = dropshell::split(backup_file, "-_-");
-    if (parts.size() != 4) {
-        std::cerr << "Error: Backup file format is incompatible, - in one of the names?" << std::endl;
-        return false;
-    }
-
-    std::string backup_server_name = parts[0];
-    std::string backup_template_name = parts[1];
-    std::string backup_service_name = parts[2];
-    std::string backup_datetime = parts[3];
-
-    if (backup_template_name != mServiceInfo.template_name) {
-        std::cerr << "Error: Backup template does not match service template. Can't restore." << std::endl;
-        return false;
-    }
-
-    std::string nicedate = std::string(backup_datetime).substr(0, 10);
-
-    std::cout << "Restoring " << nicedate << " backup of " << backup_template_name << " taken from "<<backup_server_name<<", onto "<<mServer<<"/"<<mService<<std::endl;
-    std::cout << std::endl;
-    std::cout << "*** ALL DATA FOR "<<mServer<<"/"<<mService<<" WILL BE OVERWRITTEN! ***"<<std::endl;
-
-    // run the restore script
-    std::cout << "OK, here goes..." << std::endl;
-
-    { // backup existing service
-        maketitle("1) Backing up old service... ");
-        if (!backup(true)) // silent=true
-        {
-            std::cerr << std::endl;
-            std::cerr << "Error: Backup failed, restore aborted." << std::endl;
-            std::cerr << "You can try using   dropshell install "<<mServer<<" "<<mService<<"   to install the service afresh." << std::endl;
-            std::cerr << "Otherwise, stop the service, create and initialise a new one, then restore to that." << std::endl;
-            return false;
-        }
-        std::cout << "Backup complete." << std::endl;
-    }
-
-    { // uninstall service, then nuke it.
-        maketitle("2) Uninstalling old service...");
-        // if (!uninstall(true))
-        //     return false;
-
-        maketitle("3) Nuking old service...");
+//     std::string remote_service_path = remotepath::service(mServer, mService);
+
+//     info << "Service " << mService << " successfully nuked from " << mServer << std::endl;
+
+//     if (!silent) {
+//         info << "There's nothing left on the remote server." << std::endl;
+//         info << "You can remove the local files with:" << std::endl;
+//         info << "   rm -rf " << localpath::service(mServer,mService) << std::endl;
+//     }
+//     return true;
+// }
+
+// bool service_runner::fullnuke()
+// {
 //     if (!nuke(true))
-        //     return false;
-    }
-
-
-    { // restore service from backup
-        maketitle("4) Restoring service data from backup...");
-        std::string remote_backups_dir = remotepath::backups(mServer);
-        std::string remote_backup_file_path = remote_backups_dir + "/" + backup_file;
-
-        // Copy backup file from local to server
-        if (!scp_file_to_remote(local_backup_file_path, remote_backup_file_path, silent)) {
-            std::cerr << "Failed to copy backup file from local to server" << std::endl;
-            return false;
-        }
-
-        shared_commands::cRemoteTempFolder remote_temp_folder(mServerEnv);
-        mServerEnv.run_remote_template_command(mService, "restore", {}, silent, {{"BACKUP_FILE", remote_backup_file_path}, {"TEMP_DIR", remote_temp_folder.path()}});
-    } // dtor of remote_temp_folder will clean up the temp folder on the server
-
-
-    // { // installing fresh service
-    //     maketitle("5) Non-destructive install of fresh service...");
-    //     if (!install_service(mServer, mService, true))
+//     {
+//         warning << "Nuke script failed, aborting." << std::endl;
 //         return false;
 //     }
 
-    bool healthy = false;
-    {// healthcheck the service
-        maketitle("6) Healthchecking service...");
-        std::string green_tick = "\033[32m✓\033[0m";
-        std::string red_cross = "\033[31m✗\033[0m";    
-        healthy= (mServerEnv.run_remote_template_command(mService, "status", {}, silent, {}));
-        if (!silent)
-            std::cout << (healthy ? green_tick : red_cross) << " Service is " << (healthy ? "healthy" : "NOT healthy") << std::endl;
-    }
+//     std::string local_service_path = mServiceInfo.local_service_path;
+//     if (local_service_path.empty() || !fs::exists(local_service_path)) {
+//         error << "Service directory not found: " << local_service_path << std::endl;
+//         return false;
+//     }  
     
-    return healthy;
-}
+//     std::string rm_cmd = "rm -rf " + quote(local_service_path);
+//     if (!execute_local_command("", rm_cmd, {}, nullptr, cMode::Silent)) {
+//         error << "Failed to remove service directory" << std::endl;
+//         return false;
+//     }
+    
+//     return true;
+// }
 
 
-// backup the service over ssh, using the credentials from server.env (via server_env.hpp)
-// 1. run backup.sh on the server
-// 2. create a backup file with format server-service-datetime.tgz
-// 3. store it in the server's DROPSHELL_DIR/backups folder
-// 4. copy it to the local user_dir/backups folder
+// // ------------------------------------------------------------------------------------------------
+// // Run a command on the service.
+// // ------------------------------------------------------------------------------------------------
+// bool service_runner::run_command(const std::string& command, std::vector<std::string> additional_args, std::map<std::string, std::string> env_vars) {
+//     if (!mServerEnv.is_valid()) {
+//         std::cerr << "Error: Server service not initialized" << std::endl;
+//         return false;
+//     }
+//     template_info tinfo = gTemplateManager().get_template_info(mServiceInfo.template_name);
+//     if (!tinfo.is_set()) {
+//         std::cerr << "Error: Template '" << mServiceInfo.template_name << "' not found" << std::endl;
+//         return false;
+//     }
 
-// ------------------------------------------------------------------------------------------------
-// Backup the service.
-// ------------------------------------------------------------------------------------------------
-bool service_runner::backup(bool silent) {
-    auto service_info = get_service_info(mServer, mService);
-    if (service_info.local_service_path.empty()) {
-        std::cerr << "Error: Service not found" << std::endl;
-        return 1;
-    }
+//     if (command == "fullnuke") 
+//         return fullnuke();
 
-    const std::string command = "backup";
+//     if (command == "nuke") 
+//     {
+//         std::cout << "Nuking " << mService << " (" << mServiceInfo.template_name << ") on " << mServer << std::endl;
+//         return nuke();
+//     }
 
-    if (!gTemplateManager().template_command_exists(service_info.template_name, command)) {
-        std::cout << "No backup script for " << service_info.template_name << std::endl;
-        return true; // nothing to back up.
-    }
+//     if (!gTemplateManager().template_command_exists(mServiceInfo.template_name, command)) {
+//         std::cout << "No command script for " << mServiceInfo.template_name << " : " << command << std::endl;
+//         return true; // nothing to run.
+//     }
 
-    // Check if basic installed stuff is in place.
-    std::string remote_service_template_path = remotepath::service_template(mServer, mService);
-    std::string remote_command_script_file = remote_service_template_path + "/" + command + ".sh";
-    std::string remote_service_config_path = remotepath::service_config(mServer, mService);
-    if (!mServerEnv.check_remote_items_exist({
-        remotepath::service(mServer, mService),
-        remote_command_script_file,
-        remotefile::service_env(mServer, mService)})
-    )
-    {
-        std::cerr << "Error: Required service directories not found on remote server" << std::endl;
-        std::cerr << "Is the service installed?" << std::endl;
-        return false;
-    }
+//     // install doesn't require anything on the server yet.
+//     // if (command == "install") 
+//     //     return install_service(mServer, mService, false);
 
-    // Create backups directory on server if it doesn't exist
-    std::string remote_backups_dir = remotepath::backups(mServer);
-    if (!silent) std::cout << "Remote backups directory on "<< mServer <<": " << remote_backups_dir << std::endl;
-    std::string mkdir_cmd = "mkdir -p " + quote(remote_backups_dir);
-    if (!execute_ssh_command(mServerEnv.get_SSH_INFO(), sCommand("",mkdir_cmd, {}), cMode::Silent)) {
-        std::cerr << "Failed to create backups directory on server" << std::endl;
-        return false;
-    }
+//     std::string script_path = remotepath::service_template(mServer, mService) + "/" + command + ".sh";
     
-    // Create backups directory locally if it doesn't exist
-    std::string local_backups_dir = gConfig().get_local_backup_path();
-    if (local_backups_dir.empty()) {
-        std::cerr << "Error: Local backups directory not found" << std::endl;
-        std::cerr << "Run 'dropshell edit' to configure DropShell" << std::endl;
-        return false;
-    }
-    if (!std::filesystem::exists(local_backups_dir)) 
-        std::filesystem::create_directories(local_backups_dir);
+//     // Check if service directory exists
+//     if (!mServerEnv.check_remote_dir_exists(remotepath::service(mServer, mService))) {
+//         std::cerr << "Error: Service is not installed: " << mService << std::endl;
+//         return false;
+//     }
     
-    // Get current datetime for backup filename
-    auto now = std::chrono::system_clock::now();
-    auto time = std::chrono::system_clock::to_time_t(now);
-    std::stringstream datetime;
-    datetime << std::put_time(std::localtime(&time), "%Y-%m-%d_%H-%M-%S");
+//     // Check if command script exists
+//     if (!mServerEnv.check_remote_file_exists(script_path)) {
+//         std::cerr << "Error: Remote command script not found: " << script_path << std::endl;
+//         return false;
+//     }
 
-    // Construct backup filename
-    shared_commands::cBackupFileName backup_filename_construction(mServer, mService, service_info.template_name);
-    if (!backup_filename_construction.is_valid()) {
-        std::cerr << "Invalid backup filename" << std::endl;
-        return false;
-    }
-    std::string backup_filename = backup_filename_construction.get_filename();
-    std::string remote_backup_file_path = remote_backups_dir + "/" + backup_filename;
-    std::string local_backup_file_path = (std::filesystem::path(local_backups_dir) / backup_filename).string();
+//     // Check if env file exists
+//     if (!mServerEnv.check_remote_file_exists(remotefile::service_env(mServer, mService))) {
+//         std::cerr << "Error: Service config file not found: " << remotefile::service_env(mServer, mService) << std::endl;
+//         return false;
+//     }
 
-    // assert that the backup filename is valid - -_- appears exactly 3 times in local_backup_file_path.
-    ASSERT(3 == count_substring("-_-", local_backup_file_path), "Invalid backup filename");
+//     // if (command == "uninstall") 
+//     //     return uninstall();
 
-    {   // Run backup script
-        shared_commands::cRemoteTempFolder remote_temp_folder(mServerEnv);
-        if (!mServerEnv.run_remote_template_command(mService, command, {}, silent, {{"BACKUP_FILE", remote_backup_file_path}, {"TEMP_DIR", remote_temp_folder.path()}})) {
-            std::cerr << "Backup script failed on remote server: " << remote_backup_file_path << std::endl;
-            return false;
-        }
+//     if (command == "ssh") {
+//         interactive_ssh_service();
+//         return true;
+//     }
+//     if (command == "restore") {
+//         if (additional_args.size() < 1) {
+//             std::cerr << "Error: restore requires a backup file:" << std::endl;
+//             std::cerr << "dropshell restore <server> <service> <backup-file>" << std::endl;
+//             return false;
+//         }
+//         return restore(additional_args[0], false);
+//     }
+//     if (command == "backup") {
+//         return backup(false);
+//     }
 
-        // Copy backup file from server to local
-        if (!scp_file_from_remote(remote_backup_file_path, local_backup_file_path, silent)) {
-            std::cerr << "Failed to copy backup file from server" << std::endl;
-            return false;
-        }
-    } // dtor of remote_temp_folder will clean up the temp folder on the server
+//     // Run the generic command
+//     std::vector<std::string> args; // not passed through yet.
+//     return mServerEnv.run_remote_template_command(mService, command, args, false, env_vars);
+// }
 
-    if (!silent) {
-        std::cout << "Backup created successfully. Restore with:"<<std::endl;
-        std::cout << "   dropshell restore " << mServer << " " << mService << " " << backup_filename << std::endl;
-    }
-    return true;
-}
 
-// Helper function to get the latest backup file for a given server and service
-std::string service_runner::get_latest_backup_file(const std::string& server, const std::string& service) {
-    std::string local_backups_dir = gConfig().get_local_backup_path();
-    if (local_backups_dir.empty() || !std::filesystem::exists(local_backups_dir)) {
-        std::cerr << "Error: Local backups directory not found: " << local_backups_dir << std::endl;
-        return "";
-    }
 
-    // Get the template name for this service
-    LocalServiceInfo info = get_service_info(server, service);
-    if (info.template_name.empty()) {
-        std::cerr << "Error: Could not determine template name for service: " << service << std::endl;
-        return "";
-    }
+// bool service_runner::interactive_ssh(const std::string & server_name, const std::string & command) {
+//     std::string serverpath = localpath::server(server_name);
+//     if (serverpath.empty()) {
+//         std::cerr << "Error: Server not found: " << server_name << std::endl;
+//         return false;
+//     }
     
-    // Build the expected prefix for backup files
-    std::string prefix = server + "-_-" + info.template_name + "-_-" + service + "-_-";
-    std::string latest_file;
-    std::string latest_datetime;
+//     server_env_manager env(server_name);
+//     if (!env.is_valid()) {
+//         std::cerr << "Error: Invalid server environment file: " << server_name << std::endl;
+//         return false;
+//     }
+//     sCommand scommand("", "bash",{});
+//     return execute_ssh_command(env.get_SSH_INFO(), scommand, cMode::Interactive);
+// }
 
-    std::cout << "Looking for backup files in " << local_backups_dir << std::endl;
 
-    for (const auto& entry : std::filesystem::directory_iterator(local_backups_dir)) {
-        if (!entry.is_regular_file()) continue;
-        std::string filename = entry.path().filename().string();
-        if (filename.rfind(prefix, 0) == 0) { // starts with prefix
-            // Extract the datetime part
-            size_t dt_start = prefix.size();
-            size_t dt_end = filename.find(".tgz", dt_start);
-            if (dt_end == std::string::npos) continue;
-            std::string datetime = filename.substr(dt_start, dt_end - dt_start);
-            std::cout << "Found backup file: " << filename << " with datetime: " << datetime << std::endl;
-            if (datetime > latest_datetime) {
-                latest_datetime = datetime;
-                latest_file = filename;
-            }
-        }
-    }
 
-    if (latest_file.empty()) {
-        std::cerr << "Error: No backup files found for " << server << ", " << service << std::endl;
-    }
+// bool service_runner::interactive_ssh_service()
+// {
+//     std::set<std::string> used_commands = get_used_commands(mServer, mService);
+//     if (used_commands.find("ssh") == used_commands.end()) {
+//         std::cerr << "Error: "<< mService <<" does not support ssh" << std::endl;
+//         return false;
+//     }
 
-    std::cout << "Latest backup file: " << latest_file << std::endl;
-    return latest_file;
-}
+//     std::vector<std::string> args; // not passed through yet.
+//     return mServerEnv.run_remote_template_command(mService, "ssh", args, false, {});
+// }
 
-} // namespace dropshell
+// bool service_runner::scp_file_to_remote(const std::string &local_path, const std::string &remote_path, bool silent)
+// {
+//     std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " + quote(local_path) + " " + mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + quote(remote_path) + (silent ? " > /dev/null 2>&1" : "");
+//     return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
+// }
+
+// bool service_runner::scp_file_from_remote(const std::string &remote_path, const std::string &local_path, bool silent)
+// {
+//     std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " + mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + quote(remote_path) + " " + quote(local_path) + (silent ? " > /dev/null 2>&1" : "");
+//     return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
+// }
+
+// bool service_runner::restore(std::string backup_file, bool silent)
+// {
+//     if (backup_file.empty()) {
+//         std::cerr << "Error: not enough arguments.  dropshell restore <server> <service> <backup-file>" << std::endl;
+//         return false;
+//     }
+
+//     std::string local_backups_dir = gConfig().get_local_backup_path();
+
+//     if (backup_file == "latest") {
+//         // get the latest backup file from the server
+//         backup_file = get_latest_backup_file(mServer, mService);
+//     }
+
+//     std::string local_backup_file_path = (std::filesystem::path(local_backups_dir) / backup_file).string();
+
+//     if (! std::filesystem::exists(local_backup_file_path)) {
+//         std::cerr << "Error: Backup file not found at " << local_backup_file_path << std::endl;
+//         return false;
+//     }
+
+//     // split the backup filename into parts based on the magic string
+//     std::vector<std::string> parts = dropshell::split(backup_file, "-_-");
+//     if (parts.size() != 4) {
+//         std::cerr << "Error: Backup file format is incompatible, - in one of the names?" << std::endl;
+//         return false;
+//     }
+
+//     std::string backup_server_name = parts[0];
+//     std::string backup_template_name = parts[1];
+//     std::string backup_service_name = parts[2];
+//     std::string backup_datetime = parts[3];
+
+//     if (backup_template_name != mServiceInfo.template_name) {
+//         std::cerr << "Error: Backup template does not match service template. Can't restore." << std::endl;
+//         return false;
+//     }
+
+//     std::string nicedate = std::string(backup_datetime).substr(0, 10);
+
+//     std::cout << "Restoring " << nicedate << " backup of " << backup_template_name << " taken from "<<backup_server_name<<", onto "<<mServer<<"/"<<mService<<std::endl;
+//     std::cout << std::endl;
+//     std::cout << "*** ALL DATA FOR "<<mServer<<"/"<<mService<<" WILL BE OVERWRITTEN! ***"<<std::endl;
+
+//     // run the restore script
+//     std::cout << "OK, here goes..." << std::endl;
+
+//     { // backup existing service
+//         maketitle("1) Backing up old service... ");
+//         if (!backup(true)) // silent=true
+//         {
+//             std::cerr << std::endl;
+//             std::cerr << "Error: Backup failed, restore aborted." << std::endl;
+//             std::cerr << "You can try using   dropshell install "<<mServer<<" "<<mService<<"   to install the service afresh." << std::endl;
+//             std::cerr << "Otherwise, stop the service, create and initialise a new one, then restore to that." << std::endl;
+//             return false;
+//         }
+//         std::cout << "Backup complete." << std::endl;
+//     }
+
+//     { // uninstall service, then nuke it.
+//         maketitle("2) Uninstalling old service...");
+//         // if (!uninstall(true))
+//         //     return false;
+
+//         maketitle("3) Nuking old service...");
+//         // if (!nuke(true))
+//         //     return false;
+//     }
+
+
+//     { // restore service from backup
+//         maketitle("4) Restoring service data from backup...");
+//         std::string remote_backups_dir = remotepath::backups(mServer);
+//         std::string remote_backup_file_path = remote_backups_dir + "/" + backup_file;
+
+//         // Copy backup file from local to server
+//         if (!scp_file_to_remote(local_backup_file_path, remote_backup_file_path, silent)) {
+//             std::cerr << "Failed to copy backup file from local to server" << std::endl;
+//             return false;
+//         }
+
+//         shared_commands::cRemoteTempFolder remote_temp_folder(mServerEnv);
+//         mServerEnv.run_remote_template_command(mService, "restore", {}, silent, {{"BACKUP_FILE", remote_backup_file_path}, {"TEMP_DIR", remote_temp_folder.path()}});
+//     } // dtor of remote_temp_folder will clean up the temp folder on the server
+
+
+//     // { // installing fresh service
+//     //     maketitle("5) Non-destructive install of fresh service...");
+//     //     if (!install_service(mServer, mService, true))
+//     //         return false;
+//     // }
+
+//     bool healthy = false;
+//     {// healthcheck the service
+//         maketitle("6) Healthchecking service...");
+//         std::string green_tick = "\033[32m✓\033[0m";
+//         std::string red_cross = "\033[31m✗\033[0m";    
+//         healthy= (mServerEnv.run_remote_template_command(mService, "status", {}, silent, {}));
+//         if (!silent)
+//             std::cout << (healthy ? green_tick : red_cross) << " Service is " << (healthy ? "healthy" : "NOT healthy") << std::endl;
+//     }
+
+//     return healthy;
+// }
+
+
+// // backup the service over ssh, using the credentials from server.env (via server_env.hpp)
+// // 1. run backup.sh on the server
+// // 2. create a backup file with format server-service-datetime.tgz
+// // 3. store it in the server's DROPSHELL_DIR/backups folder
+// // 4. copy it to the local user_dir/backups folder
+
+// // ------------------------------------------------------------------------------------------------
+// // Backup the service.
+// // ------------------------------------------------------------------------------------------------
+// bool service_runner::backup(bool silent) {
+//     auto service_info = get_service_info(mServer, mService);
+//     if (service_info.local_service_path.empty()) {
+//         std::cerr << "Error: Service not found" << std::endl;
+//         return 1;
+//     }
+
+//     const std::string command = "backup";
+
+//     if (!gTemplateManager().template_command_exists(service_info.template_name, command)) {
+//         std::cout << "No backup script for " << service_info.template_name << std::endl;
+//         return true; // nothing to back up.
+//     }
+    
+//     // Check if basic installed stuff is in place.
+//     std::string remote_service_template_path = remotepath::service_template(mServer, mService);
+//     std::string remote_command_script_file = remote_service_template_path + "/" + command + ".sh";
+//     std::string remote_service_config_path = remotepath::service_config(mServer, mService);
+//     if (!mServerEnv.check_remote_items_exist({
+//         remotepath::service(mServer, mService),
+//         remote_command_script_file,
+//         remotefile::service_env(mServer, mService)})
+//     )
+//     {
+//         std::cerr << "Error: Required service directories not found on remote server" << std::endl;
+//         std::cerr << "Is the service installed?" << std::endl;
+//         return false;
+//     }
+
+//     // Create backups directory on server if it doesn't exist
+//     std::string remote_backups_dir = remotepath::backups(mServer);
+//     if (!silent) std::cout << "Remote backups directory on "<< mServer <<": " << remote_backups_dir << std::endl;
+//     std::string mkdir_cmd = "mkdir -p " + quote(remote_backups_dir);
+//     if (!execute_ssh_command(mServerEnv.get_SSH_INFO(), sCommand("",mkdir_cmd, {}), cMode::Silent)) {
+//         std::cerr << "Failed to create backups directory on server" << std::endl;
+//         return false;
+//     }
+
+//     // Create backups directory locally if it doesn't exist
+//     std::string local_backups_dir = gConfig().get_local_backup_path();
+//     if (local_backups_dir.empty()) {
+//         std::cerr << "Error: Local backups directory not found" << std::endl;
+//         std::cerr << "Run 'dropshell edit' to configure DropShell" << std::endl;
+//         return false;
+//     }
+//     if (!std::filesystem::exists(local_backups_dir)) 
+//         std::filesystem::create_directories(local_backups_dir);
+
+//     // Get current datetime for backup filename
+//     auto now = std::chrono::system_clock::now();
+//     auto time = std::chrono::system_clock::to_time_t(now);
+//     std::stringstream datetime;
+//     datetime << std::put_time(std::localtime(&time), "%Y-%m-%d_%H-%M-%S");
+    
+//     // Construct backup filename
+//     shared_commands::cBackupFileName backup_filename_construction(mServer, mService, service_info.template_name);
+//     if (!backup_filename_construction.is_valid()) {
+//         std::cerr << "Invalid backup filename" << std::endl;
+//         return false;
+//     }
+//     std::string backup_filename = backup_filename_construction.get_filename();
+//     std::string remote_backup_file_path = remote_backups_dir + "/" + backup_filename;
+//     std::string local_backup_file_path = (std::filesystem::path(local_backups_dir) / backup_filename).string();
+
+//     // assert that the backup filename is valid - -_- appears exactly 3 times in local_backup_file_path.
+//     ASSERT(3 == count_substring("-_-", local_backup_file_path), "Invalid backup filename");
+
+//     {   // Run backup script
+//         shared_commands::cRemoteTempFolder remote_temp_folder(mServerEnv);
+//         if (!mServerEnv.run_remote_template_command(mService, command, {}, silent, {{"BACKUP_FILE", remote_backup_file_path}, {"TEMP_DIR", remote_temp_folder.path()}})) {
+//             std::cerr << "Backup script failed on remote server: " << remote_backup_file_path << std::endl;
+//             return false;
+//         }
+
+//         // Copy backup file from server to local
+//         if (!scp_file_from_remote(remote_backup_file_path, local_backup_file_path, silent)) {
+//             std::cerr << "Failed to copy backup file from server" << std::endl;
+//             return false;
+//         }
+//     } // dtor of remote_temp_folder will clean up the temp folder on the server
+
+//     if (!silent) {
+//         std::cout << "Backup created successfully. Restore with:"<<std::endl;
+//         std::cout << "   dropshell restore " << mServer << " " << mService << " " << backup_filename << std::endl;
+//     }
+//     return true;
+// }
+
+// // Helper function to get the latest backup file for a given server and service
+// std::string service_runner::get_latest_backup_file(const std::string& server, const std::string& service) {
+//     std::string local_backups_dir = gConfig().get_local_backup_path();
+//     if (local_backups_dir.empty() || !std::filesystem::exists(local_backups_dir)) {
+//         std::cerr << "Error: Local backups directory not found: " << local_backups_dir << std::endl;
+//         return "";
+//     }
+
+//     // Get the template name for this service
+//     LocalServiceInfo info = get_service_info(server, service);
+//     if (info.template_name.empty()) {
+//         std::cerr << "Error: Could not determine template name for service: " << service << std::endl;
+//         return "";
+//     }
+
+//     // Build the expected prefix for backup files
+//     std::string prefix = server + "-_-" + info.template_name + "-_-" + service + "-_-";
+//     std::string latest_file;
+//     std::string latest_datetime;
+
+//     std::cout << "Looking for backup files in " << local_backups_dir << std::endl;
+
+//     for (const auto& entry : std::filesystem::directory_iterator(local_backups_dir)) {
+//         if (!entry.is_regular_file()) continue;
+//         std::string filename = entry.path().filename().string();
+//         if (filename.rfind(prefix, 0) == 0) { // starts with prefix
+//             // Extract the datetime part
+//             size_t dt_start = prefix.size();
+//             size_t dt_end = filename.find(".tgz", dt_start);
+//             if (dt_end == std::string::npos) continue;
+//             std::string datetime = filename.substr(dt_start, dt_end - dt_start);
+//             std::cout << "Found backup file: " << filename << " with datetime: " << datetime << std::endl;
+//             if (datetime > latest_datetime) {
+//                 latest_datetime = datetime;
+//                 latest_file = filename;
+//             }
+//         }
+//     }
+
+//     if (latest_file.empty()) {
+//         std::cerr << "Error: No backup files found for " << server << ", " << service << std::endl;
+//     }
+
+//     std::cout << "Latest backup file: " << latest_file << std::endl;
+//     return latest_file;
+// }
+
+// } // namespace dropshell

source/src/services.cpp

@@ -137,7 +137,7 @@ std::set<std::string> list_backups(const std::string &server_name, const std::st
         return backups;
     }
 
-    std::string backups_dir = gConfig().get_local_backup_path();
+    std::string backups_dir = localpath::backups();
     if (backups_dir.empty())
         return backups;
 

source/src/templates.cpp

@@ -185,7 +185,7 @@
             return false;
         }
 
-        auto local_template_paths = gConfig().get_template_local_paths();
+        auto local_template_paths = gConfig().get_local_template_paths();
         if (local_template_paths.empty()) {
             std::cerr << "Error: No local template paths found" << std::endl;
             std::cerr << "Run 'dropshell edit' to add one to the DropShell config" << std::endl;
@@ -252,7 +252,7 @@
         ASSERT(mSources.empty(), "Template manager already loaded (sources are not empty).");
         ASSERT(gConfig().is_config_set(), "Config not set.");
         ASSERT(!mLoaded, "Template manager already loaded.");
-        auto local_template_paths = gConfig().get_template_local_paths();
+        auto local_template_paths = gConfig().get_local_template_paths();
         if (local_template_paths.empty())
             return;
         for (const auto& path : local_template_paths) 

source/src/utils/directories.cpp

@@ -41,6 +41,16 @@ namespace localfile {
         return (servicepath.empty() ? "" : (fs::path(servicepath) / ".template_info.env").string());
     }
 
+    std::string template_example()
+    {
+        return localpath::agent_local() + "/template_example";
+    }
+
+    std::string bb64()
+    {
+        return localpath::agent_local() + "/bb64";
+    }
+
 } // namespace localfile
 
 
@@ -62,16 +72,17 @@ namespace localpath {
 
         std::string remote_versions(const std::string &server_name, const std::string &service_name)
         {
-            std::string template_cache_path = gConfig().get_local_template_cache_path();
+            std::string template_cache_path = localpath::template_cache();
             return ((template_cache_path.empty() || service_name.empty()) ? "" : 
                (template_cache_path+"/remote_versions/"+service_name+".json"));
         }
-        std::string agent(){
-            return current_user_home() + "/.local/dropshell_agent";
-        }
-        std::string files_for_remote_agent()
+        std::string agent_local()
         {
-            return agent() + "/files_for_remote_agent";
+            return current_user_home()+"/.local/dropshell_agent/agent-local";
+        }
+        std::string agent_remote()
+        {
+            return current_user_home() + "/.local/dropshell_agent/agent-remote";
         }
         std::string current_user_home()
         {
@@ -84,6 +95,50 @@ namespace localpath {
             warning << "Couldn't determine user directory" << std::endl;
             return std::string();
         }
+
+        std::string dropshell_files()
+        {
+            return current_user_home() + "/.local/dropshell_files";
+            return std::string();
+        }
+
+        std::string backups()
+        {
+            return dropshell_files() + "/backups";
+        }
+
+        std::string temp_files()
+        {
+            return dropshell_files() + "/temp_files";
+        }
+
+        std::string template_cache()
+        {
+            return dropshell_files() + "template_cache";
+        }
+
+        bool create_directories()
+        {
+            std::vector<std::filesystem::path> paths = {
+                dropshell_files(),
+                agent_local(),
+                agent_remote(),
+                template_cache(),
+                backups(),
+                temp_files()
+                };
+            for (auto &p : gConfig().get_local_server_definition_paths())
+                paths.push_back(p);
+
+            for (auto &p : paths)
+                if (!p.empty() && !std::filesystem::exists(p))
+                {
+                    info << "Creating directory: " << p << std::endl;
+                    std::filesystem::create_directories(p);
+                }
+            return false;
+        }
+
 } // namespace localpath
 
     //------------------------------------------------------------------------------------------------

source/src/utils/directories.hpp

@@ -14,25 +14,18 @@ namespace dropshell {
     // ~/.config/dropshell/dropshell.json
     
     // ~/.local/dropshell_agent
+    //    |-- agent-local
+    //        |-- agent-install.sh
     //        |-- bb64  (only used locally, as it's for the local machine's architecture!)
-    //    |-- files_for_remote_agent
-    //        |-- (other agent files, including _allservicesstatus.sh)
+    //        |-- template_example
+    //    |-- agent-remote
+    //        |-- (remote agent files, including _allservicesstatus.sh)
     
-    // server_definition_path
-    //    |-- <server_name>
-    //        |-- server.json
-    //        |-- services
-    //            |-- <service_name>
-    //                |-- service.env
-    //                |-- .template_info.env
-    //                |-- (...other config files for specific server&service...)
-    
-    // backup path
+    // ~/.local/dropshell_files
+    //    |-- backups
     //        |-- katie-_-squashkiwi-_-squashkiwi-test-_-2025-04-28_21-23-59.tgz
- 
-    // temp files path
-
-    // template cache path
+    //    |-- temp_files
+    //    |-- template_cache
     //        |-- templates
     //        |   |-- <template_name>.json
     //        |   |-- <template_name>
@@ -45,12 +38,25 @@ namespace dropshell {
     //        |-- remote_versions
     //        |   |-- server_name-service_name.json
 
+    // server_definition_path
+    //    |-- <server_name>
+    //        |-- server.json
+    //        |-- services
+    //            |-- <service_name>
+    //                |-- service.env
+    //                |-- .template_info.env
+    //                |-- (...other config files for specific server&service...)
+    
+
+
     namespace localfile {
         // ~/.config/dropshell/dropshell.json
         std::string dropshell_json();
         std::string server_json(const std::string &server_name);
         std::string service_env(const std::string &server_name, const std::string &service_name);
         std::string template_info_env(const std::string &server_name, const std::string &service_name);
+        std::string template_example();
+        std::string bb64();
     } // namespace localfile
 
     namespace localpath {
@@ -59,9 +65,16 @@ namespace dropshell {
 
         std::string remote_versions(const std::string &server_name, const std::string &service_name);
 
-        std::string agent();
-        std::string files_for_remote_agent();
+        std::string agent_local();
+        std::string agent_remote();
         std::string current_user_home();
+
+        std::string dropshell_files();
+        std::string backups();
+        std::string temp_files();
+        std::string template_cache();
+
+        bool create_directories();
     } // namespace local
 
 

source/src/utils/execute.cpp

@@ -29,7 +29,7 @@ namespace dropshell
     {
         if (command.get_command_to_run().empty())
             return false;
-        std::string full_command = command.construct_cmd(localpath::agent()+"/bb64"); // Get the command string
+        std::string full_command = command.construct_cmd(localfile::bb64()); // Get the command string
 
         pid_t pid = fork();
 
@@ -130,7 +130,7 @@ namespace dropshell
 
         std::string full_cmd;
         if (!hasFlag(mode, cMode::NoBB64))
-            full_cmd = command.construct_cmd(localpath::agent()+"/bb64");
+            full_cmd = command.construct_cmd(localfile::bb64());
         else
             full_cmd = command.construct_cmd("");