dropshell release 2025.0524.1149

.example/servers/localhost/_server.env

@@ -1,5 +1,5 @@
 SSH_ADDRESS=localhost
 SSH_PORT=22
-SSH_USER=$(whoami)
+SSH_UNPRIVILEGED_USER=$(whoami)
 
 

source/agent-local/template_example/TODO_ADD_TEMPLATE_EXAMPLE_HERE

@@ -0,0 +1 @@
+TODO!

source/agent-remote/_allservicesstatus.sh

@@ -23,7 +23,6 @@ SCRIPT_DIR="$(dirname "$0")"
     # //               |-- service.env (actual service config)
     # //               |-- .template_info.env
     # //           |-- template
-    # //               |-- _default.env
     # //               |-- (script files)
     # //               |-- config
     # //                   |-- service.env (default service config)
@@ -66,7 +65,6 @@ function run_command() {
     CURRENT_OUTPUT=$(
         set -a
 
-        load_dotenv "${service_path}/template/_default.env"
         load_dotenv "${service_path}/config/service.env"
         load_dotenv "${service_path}/config/.template_info.env"
 

source/src/autocomplete.cpp

@@ -59,7 +59,7 @@ bool autocomplete(const std::vector<std::string> &args)
     {
         auto servers = dropshell::get_configured_servers();
         for (const auto& server : servers) 
-            std::cout << server.name << std::endl;
+            std::cout << server.get_server_name() << std::endl;
         return true;
     }
 

source/src/commands/backupdata.cpp

@@ -11,7 +11,7 @@
 #include "config.hpp"
 #include "services.hpp"
 #include "servers.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "templates.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
@@ -53,14 +53,10 @@ namespace dropshell
     namespace shared_commands
     {
 
-        bool backupdata_service(const std::string &server, const std::string &service)
+        bool backupdata_service(const server_config &server_env, const std::string &service)
         {
-            server_env_manager server_env(server);
+            ASSERT(server_env.is_valid(), "Invalid server environment for " + server_env.get_server_name());
-            if (!server_env.is_valid())
+            std::string server = server_env.get_server_name();
-            {
-                error << "Server " << server << " is not valid" << std::endl;
-                return false;
-            }
 
             LocalServiceInfo sinfo = get_service_info(server, service);
             if (!SIvalid(sinfo))
@@ -78,13 +74,15 @@ namespace dropshell
                 return true; // nothing to back up.
             }
 
+            std::string user = server_env.get_user_for_service(service);
+
             // Check if basic installed stuff is in place.
-            std::string remote_service_template_path = remotepath::service_template(server, service);
+            std::string remote_service_template_path = remotepath(server, user).service_template(service);
             std::string remote_command_script_file = remote_service_template_path + "/" + command + ".sh";
-            std::string remote_service_config_path = remotepath::service_config(server, service);
+            std::string remote_service_config_path = remotepath(server, user).service_config(service);
-            if (!server_env.check_remote_items_exist({remotepath::service(server, service),
+            if (!server_env.check_remote_items_exist({remotepath(server, user).service(service),
                                                       remote_command_script_file,
-                                                      remotefile::service_env(server, service)}))
+                                                      remotefile(server, user).service_env(service)}, user))
             {
                 error << "Error: Required service directories not found on remote server" << std::endl;
                 info << "Is the service installed?" << std::endl;
@@ -92,10 +90,10 @@ namespace dropshell
             }
 
             // Create backups directory on server if it doesn't exist
-            std::string remote_backups_dir = remotepath::backups(server);
+            std::string remote_backups_dir = remotepath(server, user).backups();
             debug << "Remote backups directory on " << server << ": " << remote_backups_dir << std::endl;
             std::string mkdir_cmd = "mkdir -p " + quote(remote_backups_dir);
-            if (!execute_ssh_command(server_env.get_SSH_INFO(), sCommand("", mkdir_cmd, {}), cMode::Defaults))
+            if (!execute_ssh_command(server_env.get_SSH_INFO(user), sCommand("", mkdir_cmd, {}), cMode::Defaults))
             {
                 error << "Failed to create backups directory on server" << std::endl;
                 return false;
@@ -129,7 +127,7 @@ namespace dropshell
             ASSERT(3 == count_substring(magic_string(), local_backup_file_path), "Invalid backup filename");
 
             { // Run backup script
-                shared_commands::cRemoteTempFolder remote_temp_folder(server_env);
+                shared_commands::cRemoteTempFolder remote_temp_folder(server_env, user);
                 if (!server_env.run_remote_template_command(service, command, {}, false, {{"BACKUP_FILE", remote_backup_file_path}, {"TEMP_DIR", remote_temp_folder.path()}}))
                 {
                     error << "Backup script failed on remote server: " << remote_backup_file_path << std::endl;
@@ -137,7 +135,7 @@ namespace dropshell
                 }
 
                 // Copy backup file from server to local
-                if (!shared_commands::scp_file_from_remote(server_env, remote_backup_file_path, local_backup_file_path, false))
+                if (!shared_commands::scp_file_from_remote(server_env, remote_backup_file_path, local_backup_file_path, false, sinfo.user))
                 {
                     error << "Failed to copy backup file from server" << std::endl;
                     return false;

source/src/commands/create-service.cpp

@@ -67,7 +67,6 @@ namespace dropshell
     namespace shared_commands
     {
 
-        
         bool print_readme(const template_info &tinfo, std::string server, std::string service)
         {
             std::vector<std::string> variants_to_try = {"README.txt", "readme.txt", "ReadMe.txt", "README", "readme", "README.md", "readme.md"};
@@ -99,12 +98,18 @@ namespace dropshell
             return true;
         }
 
-
+        bool create_service(const std::string &server_name, const std::string &template_name, const std::string &service_name, std::string user_override/*=""*/)
-    bool create_service(const std::string &server_name, const std::string &template_name, const std::string &service_name)
         {
             if (server_name.empty() || template_name.empty() || service_name.empty())
                 return false;
 
+            server_config server_info(server_name);
+            if (!server_info.is_valid())
+            {
+                error << "Server " << server_name << " is not valid" << std::endl;
+                return false;
+            }
+
             std::string service_dir = localpath::service(server_name, service_name);
 
             if (service_dir.empty())
@@ -146,6 +151,82 @@ namespace dropshell
             // copy the template config files to the service directory
             recursive_copy(tinfo.local_template_path() / "config", service_dir);
 
+            // append TEMPLATE_HASH to the .template_info.env file
+            std::string template_info_env_file = service_dir + "/" + filenames::template_info_env;
+            std::ofstream template_info_env_file_out(template_info_env_file);
+            template_info_env_file_out << "TEMPLATE_HASH=" << tinfo.hash() << std::endl;
+            template_info_env_file_out.close();
+
+
+            // modify the SSH_USER to be nice.
+            // everything is created, so we can get the service info.
+            LocalServiceInfo service_info = get_service_info(server_name, service_name);
+            std::string sshuser = "root";
+            if (!user_override.empty())
+                sshuser = user_override;
+            else
+                if (!service_info.requires_host_root)
+                { // find a non-root user.
+                    auto users = server_info.get_users();
+                    auto it = std::find_if(users.begin(), users.end(), [&sshuser](const UserConfig &user)
+                                        { return user.user != "root"; });
+                    if (it != users.end())
+                        sshuser = it->user;
+                }
+
+            if (sshuser == "root" && !server_info.hasRootUser())
+            {
+                error << "Server " << server_name << " does not have a root user, but the service " << service_name << " requires it." << std::endl;
+                return false;
+            }
+            if (sshuser != "root" && service_info.requires_host_root)
+            {
+                error << "The service " << service_name << " requires a root user, but a non-root user was specified." << std::endl;
+                return false;
+            }
+            if (!server_info.hasUser(sshuser))
+            {
+                error << "User " << sshuser << "is not available on server " << server_name << std::endl;
+                return false;
+            }
+
+
+            info << "Setting SSH_USER to " << sshuser << " in the " << filenames::service_env << " file" << std::endl;
+            { // edit the service.env file to set the SSH_USER.
+                std::string template_service_env_file = tinfo.local_template_path() / "config" / filenames::service_env;
+                ASSERT(std::filesystem::exists(template_service_env_file), "Template service env file not found: " + template_service_env_file);
+                std::ifstream template_service_env_file_in(template_service_env_file);
+                std::ofstream service_env_file_out(localfile::template_info_env(server_name, service_name));
+                std::string line;
+                while (std::getline(template_service_env_file_in, line))
+                {
+                    if (line.find("SSH_USER") != std::string::npos)
+                        line = "SSH_USER=" + sshuser;
+                    service_env_file_out << line << std::endl;
+                }
+                template_service_env_file_in.close();
+                service_env_file_out.close();
+            }
+
+            // check docker.
+            if (service_info.requires_docker)
+            {
+                if (!server_info.hasDocker())
+                {
+                    error << "Server " << server_name << " does not have docker, but the service " << service_name << " requires it." << std::endl;
+                    return false;
+                }
+
+                if (service_info.requires_docker_root)
+                {
+                    if (!server_info.hasRootDocker())
+                    {
+                        error << "Server " << server_name << " does not have a root docker, but the service " << service_name << " requires it." << std::endl;
+                        return false;
+                    }
+                }
+            }
+
             info << "Service " << service_name << " created successfully" << std::endl;
 
             if (!print_readme(tinfo, server_name, service_name))
@@ -158,6 +239,23 @@ namespace dropshell
             return true;
         }
 
+
+        bool merge_updated_service_template(const std::string &server_name, const std::string &service_name)
+        { 
+            LocalServiceInfo service_info = get_service_info(server_name, service_name);
+            ASSERT(SIvalid(service_info), "Service info is not valid for " + service_name + " on " + server_name);
+
+            template_info tinfo = gTemplateManager().get_template_info(service_info.template_name);
+            ASSERT(tinfo.is_set(), "Failed to load template " + service_info.template_name);
+
+            // copy across .template_info.env file
+            std::string template_service_env_file = "";
+            std::string target_service_env_file = localfile::template_info_env(server_name, service_name);
+            ASSERT(std::filesystem::exists(template_service_env_file), "Template service env file not found: " + template_service_env_file);
+
+            return true;
+        }
+
     } // namespace shared_commands
 
 } // namespace dropshell

source/src/commands/destroy.cpp

@@ -2,7 +2,7 @@
 #include "shared_commands.hpp"
 #include "config.hpp"
 #include "services.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "utils/directories.hpp"
 #include "servers.hpp"
 #include "templates.hpp"
@@ -52,7 +52,7 @@ namespace dropshell
 
         bool nuke_service(const std::string &server, const std::string &service)
         {
-            server_env_manager server_env(server);
+            server_config server_env(server);
 
             // step 1 - nuke on remote server.
             if (server_env.is_valid())
@@ -63,7 +63,8 @@ namespace dropshell
                 if (!SIvalid(service_info))
                     error << "Invalid service: " << service << std::endl;
 
-                if (server_env.check_remote_dir_exists(remotepath::service(server, service)))
+                std::string user = server_env.get_user_for_service(service);
+                if (server_env.check_remote_dir_exists(remotepath(server, user).service(service), user))
                 {
                     // run the nuke script on the remote server if it exists.
                     // otherwise just uninstall.
@@ -82,16 +83,16 @@ namespace dropshell
                     }
 
                     // Remove the service directory from the server, running in a docker container as root.
-                    if (server_env.remove_remote_dir(remotepath::service(server, service), true))
+                    if (server_env.remove_remote_dir(remotepath(server, user).service(service), true, user))
                     {
-                        ASSERT(!server_env.check_remote_dir_exists(remotepath::service(server, service)), "Service directory still found on server after uninstall");
+                        ASSERT(!server_env.check_remote_dir_exists(remotepath(server, user).service(service), user), "Service directory still found on server after uninstall");
-                        info << "Remote service directory removed: " << remotepath::service(server, service) << std::endl;
+                        info << "Remote service directory removed: " << remotepath(server, user).service(service) << std::endl;
                     }
                     else
                         warning << "Failed to remove remote service directory" << std::endl;
                 }
                 else
-                    warning << "Service not found on remote server: " << remotepath::service(server, service) << std::endl;
+                    warning << "Service not found on remote server: " << remotepath(server, user).service(service) << std::endl;
             }
             else
                 warning << "Can't nuke the remote service as the server is invalid: " << server << std::endl;

source/src/commands/health.cpp

@@ -3,7 +3,7 @@
 #include "utils/utils.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "services.hpp"
 #include "servers.hpp"
 #include "transwarp.hpp"

source/src/commands/install.cpp

@@ -63,15 +63,22 @@ namespace dropshell
         // ------------------------------------------------------------------------------------------------
         // install service over ssh : SHARED COMMAND
         // ------------------------------------------------------------------------------------------------
-        bool install_service(const std::string &server, const std::string &service)
+        bool install_service(const server_config &server_env, const std::string &service)
         {
-            LocalServiceInfo service_info = get_service_info(server, service);
+            std::string server = server_env.get_server_name();
+            LocalServiceInfo service_info = get_service_info(server_env.get_server_name(), service);
             if (!SIvalid(service_info))
                 return false;
 
-            server_env_manager server_env(server);
+            if (!service_info.service_template_hash_match)
-            if (!server_env.is_valid())
+            {
+                warning << "Service " << service << " is using an old template. Updating. " << std::endl;
+                if (!merge_updated_service_template(server_env.get_server_name(), service))
+                {
+                    error << "Failed to merge updated service template. " << std::endl;
                     return false;
+                }
+            }
 
             maketitle("Installing " + service + " (" + service_info.template_name + ") on " + server);
 
@@ -90,9 +97,10 @@ namespace dropshell
             }
 
             // Create service directory
-            std::string remote_service_path = remotepath::service(server, service);
+            std::string user = server_env.get_user_for_service(service);
+            std::string remote_service_path = remotepath(server,user).service(service);
             std::string mkdir_cmd = "mkdir -p " + quote(remote_service_path);
-            if (!execute_ssh_command(server_env.get_SSH_INFO(), sCommand("", mkdir_cmd, {}), cMode::Silent))
+            if (!execute_ssh_command(server_env.get_SSH_INFO(user), sCommand("", mkdir_cmd, {}), cMode::Silent))
             {
                 std::cerr << "Failed to create service directory " << remote_service_path << std::endl;
                 return false;
@@ -100,7 +108,7 @@ namespace dropshell
 
             // Check if rsync is installed on remote host
             std::string check_rsync_cmd = "which rsync";
-            if (!execute_ssh_command(server_env.get_SSH_INFO(), sCommand("", check_rsync_cmd, {}), cMode::Silent))
+            if (!execute_ssh_command(server_env.get_SSH_INFO(user), sCommand("", check_rsync_cmd, {}), cMode::Silent))
             {
                 std::cerr << "rsync is not installed on the remote host" << std::endl;
                 return false;
@@ -108,9 +116,9 @@ namespace dropshell
 
             // Copy template files
             debug << "Copying: [LOCAL] " << tinfo.local_template_path() << std::endl
-                  << std::string(8, ' ') << "[REMOTE] " << remotepath::service_template(server, service) << "/" << std::endl;
+                  << std::string(8, ' ') << "[REMOTE] " << remotepath(server,user).service_template(service) << "/" << std::endl;
-            if (!shared_commands::rsync_tree_to_remote(tinfo.local_template_path().string(), remotepath::service_template(server, service),
+            if (!shared_commands::rsync_tree_to_remote(tinfo.local_template_path().string(), remotepath(server,user).service_template(service),
-                                                       server_env, false))
+                                                       server_env, false, service_info.user))
             {
                 std::cerr << "Failed to copy template files using rsync" << std::endl;
                 return false;
@@ -118,9 +126,9 @@ namespace dropshell
 
             // Copy service files
             debug << "Copying: [LOCAL] " << localpath::service(server, service) << std::endl
-                  << std::string(8, ' ') << "[REMOTE] " << remotepath::service_config(server, service) << std::endl;
+                  << std::string(8, ' ') << "[REMOTE] " << remotepath(server,user).service_config(service) << std::endl;
-            if (!shared_commands::rsync_tree_to_remote(localpath::service(server, service), remotepath::service_config(server, service),
+            if (!shared_commands::rsync_tree_to_remote(localpath::service(server, service), remotepath(server,user).service_config(service),
-                                                       server_env, false))
+                                                       server_env, false, service_info.user))
             {
                 std::cerr << "Failed to copy service files using rsync" << std::endl;
                 return false;
@@ -258,41 +266,36 @@ namespace dropshell
         return 0;
     }
 
-    int install_server(const std::string &server)
+    int install_server(const server_config &server)
     {
         // install the dropshell agent on the given server.
-        maketitle("Installing dropshell agent on " + server, sColour::INFO);
+        maketitle("Installing dropshell agent on " + server.get_server_name(), sColour::INFO);
 
-        std::string agent_path = remotepath::agent(server);
+        for (const auto &user : server.get_users())
-        if (agent_path.empty())
         {
-            error << "Failed to get agent path for " << server << std::endl;
+            info << "Installing agent for user " << user.user << " on " << server.get_server_name() << std::endl;
-            return 1;
-        }
 
-        server_env_manager server_env(server);
+            std::string agent_path = remotepath(server.get_server_name(),user.user).agent();
-        if (!server_env.is_valid())
+            ASSERT(agent_path == user.dir, "Agent path does not match user directory for "+user.user+"@" + server.get_server_name() + " : " + agent_path + " != " + user.dir);
-        {
+            ASSERT(!agent_path.empty(), "Agent path is empty for " + user.user + "@" + server.get_server_name());
-            error << "Invalid server environment for " << server << std::endl;
-            return 1;
-        }
 
             // 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::agent_remote(), agent_path, server_env, false);
+            shared_commands::rsync_tree_to_remote(localpath::agent_remote(), agent_path, server, false, user.user);
             info << "done." << std::endl;
 
             // run the agent installer. Can't use BB64 yet, as we're installing it on the remote server.
             
-        bool okay = execute_ssh_command(server_env.get_SSH_INFO(), sCommand(agent_path, "agent-install.sh",{}), cMode::Defaults | cMode::NoBB64, nullptr);
+            bool okay = execute_ssh_command(server.get_SSH_INFO(user.user), sCommand(agent_path, "agent-install.sh",{}), cMode::Defaults | cMode::NoBB64, nullptr);
             if (!okay)
             {
-            error << "ERROR: Failed to install remote agent on " << server << std::endl;
+                error << "ERROR: Failed to install remote agent on " << server.get_server_name() << std::endl;
                 return 1;
             }
 
-        info << "Installation on " << server << " complete." << std::endl;
+            info << "Installation on " << server.get_server_name() << " complete." << std::endl;
+        }
         return 0;
     }
 
@@ -313,10 +316,10 @@ namespace dropshell
             return rval;
 
         // install the dropshell agent on all servers.
-        std::vector<ServerInfo> servers = get_configured_servers();
+        std::vector<server_config> servers = get_configured_servers();
         for (const auto &server : servers)
         {
-            rval = install_server(server.name);
+            rval = install_server(server);
             if (rval != 0)
                 return rval;
         }
@@ -349,15 +352,24 @@ namespace dropshell
         }
 
         // install service(s)
+        if (!server_exists(server))
+        {
+            error << "Server " << server << " does not exist." << std::endl;
+            info << "Create it with: dropshell create-server " << server << std::endl;
+            return 1;
+        }
+
+        server_config server_env(server);
+        ASSERT(server_env.is_valid(), "Invalid server environment for " + server);
         if (safearg(ctx.args, 1) == "all")
         {
             // install all services on the server
             maketitle("Installing all services on " + server);
             bool okay = true;
             std::vector<LocalServiceInfo> services = get_server_services_info(server);
-            for (const auto &service : services)
+            for (const auto &lsi : services)
             {
-                if (!shared_commands::install_service(server, service.service_name))
+                if (!shared_commands::install_service(server_env, lsi.service_name))
                     okay = false;
             }
             return okay ? 0 : 1;
@@ -365,7 +377,7 @@ namespace dropshell
         else
         { // install the specific service.
             std::string service = safearg(ctx.args, 1);
-            return shared_commands::install_service(server, service) ? 0 : 1;
+            return shared_commands::install_service(server_env, service) ? 0 : 1;
         }
     }
 

source/src/commands/list.cpp

@@ -6,7 +6,7 @@
 #include "servers.hpp"
 #include "tableprint.hpp"
 #include "transwarp.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "services.hpp"
 
 #include <unistd.h>
@@ -81,14 +81,25 @@ void list_servers() {
     }
 
     tableprint tp("All DropShell Servers");
-    tp.add_row({"Name", "User", "Address", "Health", "Ports"});
+    tp.add_row({"Name", "Address", "User", "Health", "Ports"});
 
     info << "Checking "<<servers.size() << " servers: " << std::flush;
     int checked = 0;
 
     transwarp::parallel exec{servers.size()};
-    auto task = transwarp::for_each(exec, servers.begin(), servers.end(), [&](const ServerInfo& server) {
+    auto task = transwarp::for_each(exec, servers.begin(), servers.end(), [&](const server_config& server) {
-        std::map<std::string, shared_commands::ServiceStatus> status = shared_commands::get_all_services_status(server.name); 
+
+        server_config server_env(server.get_server_name());
+        if (!server_env.is_valid())
+        {
+            error << "Invalid server environment for " << server.get_server_name() << std::endl;
+            return;
+        }
+
+        int first=true;
+        for (const auto &user : server_env.get_users())
+            {
+            std::map<std::string, shared_commands::ServiceStatus> status = shared_commands::get_all_services_status(server.get_server_name(),user.user); 
 
             std::set<int> ports_used;
             std::string serviceticks = "";
@@ -100,7 +111,10 @@ void list_servers() {
             for (const auto& port : ports_used) 
                 ports_used_str += std::to_string(port) + " ";
 
-        tp.add_row({server.name, server.ssh_user, server.ssh_host, serviceticks, ports_used_str});
+            tp.add_row({(first ? server.get_server_name() : ""), (first ? server.get_SSH_HOST() : ""), user.user, serviceticks, ports_used_str});
+            first = false;
+            }
+
         ++checked;
         // print out a tick character for each server checked.
         info << checked << " ✓  " << std::flush;
@@ -114,7 +128,7 @@ void list_servers() {
 
 
 void show_server_details(const std::string& server_name) {
-    server_env_manager env(server_name);
+    server_config env(server_name);
     if (!env.is_valid()) {
         error << "Error: Invalid server environment file: " << server_name << std::endl;
         return;
@@ -122,37 +136,41 @@ void show_server_details(const std::string& server_name) {
 
     //---------------------
     // Check if server is reachable via SSH
-    std::string ssh_address = env.get_SSH_HOST();
+    ASSERT(env.get_users().size() > 0, "No users found for server " + server_name);
-    std::string ssh_user = env.get_SSH_USER();
+    sSSHInfo sshinfo = env.get_SSH_INFO(env.get_users()[0].user);
-    std::string ssh_port = env.get_SSH_PORT();
+    ASSERT(sshinfo.valid(), "Invalid SSH info for server " + server_name);
-    if (!ssh_address.empty()) {
+
     info << std::endl << "Server Status:" << std::endl;
     info << std::string(40, '-') << std::endl;
     
     // Try to connect to the server
-        std::string cmd = "ssh -o ConnectTimeout=5 " + ssh_user + "@" + ssh_address + " -p " + ssh_port + " 'true' 2>/dev/null";
+    std::string cmd = "ssh -o ConnectTimeout=5 " + sshinfo.get_user() + "@" + sshinfo.get_host() + " -p " + sshinfo.get_port() + " 'true' 2>/dev/null";
     int result = system(cmd.c_str());
     if (result == 0) {
         info << "Status: Online" << std::endl;
-            
-            // // Get uptime if possible
-            // cmd = "ssh " + ssh_address + " 'uptime' 2>/dev/null";
-            // int rval = system(cmd.c_str());
-            // if (rval != 0) {
-            //     std::cout << "Error: Failed to get uptime" << std::endl;
-            // } 
     } else {
         warning << "Status: Offline" << std::endl;
     }
-    }
     info << std::endl;
 
     //---------------------
     {
         std::cout << std::endl;
         tableprint tp("Server Configuration: " + server_name, true);
+
         tp.add_row({"Key", "Value"});
         for (const auto& [key, value] : env.get_variables()) {
+            if (key == "SSH_USERS")
+            {
+                int i=1;
+                for (const auto& user : env.get_users())
+                {
+                    tp.add_row({"USERS -> USER[" + std::to_string(i) + "]", user.user});
+                    tp.add_row({"USERS -> DIR[" + std::to_string(i) + "]", user.dir});
+                    i++;
+                }
+            }
+            else
                 tp.add_row({key, value});
         }
         tp.print();
@@ -164,7 +182,6 @@ void show_server_details(const std::string& server_name) {
         tableprint tp("Services: " + server_name, false);
         tp.add_row({"Status", "Service", "Template","Ports"});
 
-
         std::map<std::string, shared_commands::ServiceStatus> status = shared_commands::get_all_services_status(server_name); 
 
         std::set<int> ports_used;
@@ -176,7 +193,11 @@ void show_server_details(const std::string& server_name) {
             for (const auto& port : service_status.ports) 
                 ports_str += std::to_string(port) + " ";
 
-            tp.add_row({healthy, service_name, get_service_info(server_name,service_name).template_name, ports_str});
+            std::string template_name = get_service_info(server_name,service_name).template_name;
+            if (template_name.empty())
+                template_name = "Unknown";
+        
+            tp.add_row({healthy, service_name, template_name, ports_str});
         } // end of for (const auto& service : services)
         tp.print();
     } // end of list services

source/src/commands/restoredata.cpp

@@ -11,7 +11,7 @@
 #include "config.hpp"
 #include "services.hpp"
 #include "servers.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "templates.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
@@ -92,7 +92,7 @@ namespace dropshell
         std::string service = ctx.args[1];
         std::string backup_arg = ctx.args[2];
 
-        server_env_manager server_env(server);
+        server_config server_env(server);
         if (!server_env.is_valid())
         {
             error << "Server " << server << " is not valid" << std::endl;
@@ -183,31 +183,33 @@ namespace dropshell
 
         { // create the new service
             info << "3) Creating new service..." << std::endl;
-            if (!shared_commands::create_service(server, service_info.template_name, service))
+            if (!shared_commands::create_service(server, service_info.template_name, service, service_info.user))
                 return 1;
         }
 
         { // installing fresh service
             info << "4) Install of fresh service..." << std::endl;
-            if (!shared_commands::install_service(server, service))
+            server_config server_env(server);   
+            if (!shared_commands::install_service(server_env, service))
                 return 1;
         }
 
         { // restore service from backup
             info << "5) Restoring service data from backup..." << std::endl;
-            std::string remote_backups_dir = remotepath::backups(server);
+            std::string user = server_env.get_user_for_service(service);
+            std::string remote_backups_dir = remotepath(server, user).backups();
             std::string remote_backup_file_path = remote_backups_dir + "/" + backup_details->get_filename();
 
             debug << "Copying backup file from local to server: " << local_backup_file_path << " -> " << remote_backup_file_path << std::endl;
 
             // Copy backup file from local to server
-            if (!shared_commands::scp_file_to_remote(server_env, local_backup_file_path, remote_backup_file_path, false))
+            if (!shared_commands::scp_file_to_remote(server_env, local_backup_file_path, remote_backup_file_path, false, service_info.user))
             {
                 error << "Failed to copy backup file from local to server" << std::endl;
                 return 1;
             }
 
-            shared_commands::cRemoteTempFolder remote_temp_folder(server_env);
+            shared_commands::cRemoteTempFolder remote_temp_folder(server_env,user);
 
             debug << "Running restore script on server: " << server << std::endl;
             debug << "  BACKUP_FILE: " << remote_backup_file_path << std::endl;

source/src/commands/shared_commands.cpp

@@ -1,7 +1,7 @@
 #include "shared_commands.hpp"
 #include "utils/assert.hpp"
 #include "utils/utils.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "directories.hpp"
 #include "services.hpp"
 #include "servers.hpp"
@@ -21,10 +21,10 @@ namespace dropshell
             if (ctx.args.size() == 0)
             { // just the command, no args yet.
                 // list servers
-                std::vector<ServerInfo> servers = get_configured_servers();
+                std::vector<server_config> servers = get_configured_servers();
                 for (const auto &server : servers)
                 {
-                    rawout << server.name << std::endl;
+                    rawout << server.get_server_name() << std::endl;
                 }
             }
             else if (ctx.args.size() == 1)
@@ -54,14 +54,15 @@ namespace dropshell
         bool rsync_tree_to_remote(
             const std::string &local_path,
             const std::string &remote_path,
-            server_env_manager &server_env,
+            const server_config &server_env,
-            bool silent)
+            bool silent,
+            std::string user)
         {
             ASSERT(!local_path.empty() && !remote_path.empty(), "Local or remote path not specified. Can't rsync.");
 
             std::string rsync_cmd = "rsync --delete --mkpath -zrpc -e 'ssh -p " + server_env.get_SSH_PORT() + "' " +
                                     quote(local_path + "/") + " " +
-                                    quote(server_env.get_SSH_USER() + "@" + server_env.get_SSH_HOST() + ":" +
+                                    quote(user + "@" + server_env.get_SSH_HOST() + ":" +
                                           remote_path + "/");
             return execute_local_command("", rsync_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
         }
@@ -84,11 +85,12 @@ namespace dropshell
         // ------------------------------------------------------------------------------------------------
         // cRemoteTempFolder : SHARED CLASS
         // ------------------------------------------------------------------------------------------------
-        cRemoteTempFolder::cRemoteTempFolder(const server_env_manager &server_env) : mServerEnv(server_env)
+        cRemoteTempFolder::cRemoteTempFolder(const server_config &server_env, std::string user) : 
+        mServerEnv(server_env), mUser(user)
         {
-            std::string p = remotepath::temp_files(server_env.get_server_name()) + "/" + random_alphanumeric_string(10);
+            std::string p = remotepath(server_env.get_server_name(),user).temp_files() + "/" + random_alphanumeric_string(10);
             std::string mkdir_cmd = "mkdir -p " + quote(p);
-            if (!execute_ssh_command(server_env.get_SSH_INFO(), sCommand("", mkdir_cmd, {}), cMode::Silent))
+            if (!execute_ssh_command(server_env.get_SSH_INFO(user), sCommand("", mkdir_cmd, {}), cMode::Silent))
                 error << "Failed to create temp directory on server" << std::endl;
             else
                 mPath = p;
@@ -97,7 +99,7 @@ namespace dropshell
         cRemoteTempFolder::~cRemoteTempFolder()
         {
             std::string rm_cmd = "rm -rf " + quote(mPath);
-            execute_ssh_command(mServerEnv.get_SSH_INFO(), sCommand("", rm_cmd, {}), cMode::Silent);
+            execute_ssh_command(mServerEnv.get_SSH_INFO(mUser), sCommand("", rm_cmd, {}), cMode::Silent);
         }
 
         std::string cRemoteTempFolder::path() const
@@ -108,19 +110,24 @@ namespace dropshell
         // ------------------------------------------------------------------------------------------------
         // get_all_services_status : SHARED COMMAND
         // ------------------------------------------------------------------------------------------------
-        std::map<std::string, ServiceStatus> get_all_services_status(std::string server_name)
+        std::map<std::string, ServiceStatus> get_all_services_status(const server_config & server_env)
         {
             std::map<std::string, ServiceStatus> status;
-
+            for (const auto& user : server_env.get_users()) {
-            server_env_manager env(server_name);
+                status.merge(get_all_services_status(server_env, user.user));
-            if (!env.is_valid())
+            }
-            {
-                error << "Invalid server environment" << std::endl;
             return status;
         }
 
+        std::map<std::string, ServiceStatus> get_all_services_status(const server_config & server_env, std::string user)
+        {
+            std::map<std::string, ServiceStatus> status;
+            std::string server_name = server_env.get_server_name();
+
             std::string output;
-            if (!execute_ssh_command(env.get_SSH_INFO(), sCommand(remotepath::agent(server_name), "./_allservicesstatus.sh", {{"HOST_NAME", server_name}, {"SERVER", server_name}, {"AGENT_PATH", remotepath::agent(server_name)}}),
+            std::string agentpath = remotepath(server_name,user).agent();
+            if (!execute_ssh_command(server_env.get_SSH_INFO(user), 
+                sCommand(agentpath, "./_allservicesstatus.sh", {{"HOST_NAME", server_name}, {"SERVER", server_name}, {"AGENT_PATH", agentpath}}),
                 cMode::Silent,
                 &output))
                 return status;
@@ -162,6 +169,7 @@ namespace dropshell
                     }
                 }
             }
+
             return status;
         }
 
@@ -208,20 +216,22 @@ namespace dropshell
         // ------------------------------------------------------------------------------------------------
         HealthStatus is_healthy(const std::string &server, const std::string &service)
         {
-            server_env_manager env(server);
+            server_config env(server);
             if (!env.is_valid())
             {
                 error << "Server service not initialized" << std::endl;
                 return HealthStatus::ERROR;
             }
 
-            if (!env.check_remote_dir_exists(remotepath::service(server, service)))
+            std::string user = env.get_user_for_service(service);
+
+            if (!env.check_remote_dir_exists(remotepath(server,user).service(service), user))
             {
                 return HealthStatus::NOTINSTALLED;
             }
 
-            std::string script_path = remotepath::service_template(server, service) + "/status.sh";
+            std::string script_path = remotepath(server,user).service_template(service) + "/status.sh";
-            if (!env.check_remote_file_exists(script_path))
+            if (!env.check_remote_file_exists(script_path, user))
             {
                 return HealthStatus::UNKNOWN;
             }
@@ -299,7 +309,7 @@ namespace dropshell
         // ------------------------------------------------------------------------------------------------
         // scp_file_to_remote : SHARED COMMAND
         // ------------------------------------------------------------------------------------------------
-        bool scp_file_to_remote(const server_env_manager &server_env, const std::string &local_path, const std::string &remote_path, bool silent)
+        bool scp_file_to_remote(const server_config &server_env, const std::string &local_path, const std::string &remote_path, bool silent, std::string user)
         {
             if (!server_env.is_valid())
             {
@@ -307,14 +317,14 @@ namespace dropshell
                 return false;
             }
             ASSERT(!remote_path.empty() && !local_path.empty(), "Remote or local path not specified. Can't scp.");
-            std::string scp_cmd = "scp -P " + server_env.get_SSH_PORT() + " " + quote(local_path) + " " + server_env.get_SSH_USER() + "@" + server_env.get_SSH_HOST() + ":" + quote(remote_path) + (silent ? " > /dev/null 2>&1" : "");
+            std::string scp_cmd = "scp -P " + server_env.get_SSH_PORT() + " " + quote(local_path) + " " + user + "@" + server_env.get_SSH_HOST() + ":" + quote(remote_path) + (silent ? " > /dev/null 2>&1" : "");
             return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
         }
 
         // ------------------------------------------------------------------------------------------------
         // scp_file_from_remote : SHARED COMMAND
         // ------------------------------------------------------------------------------------------------
-        bool scp_file_from_remote(const server_env_manager &server_env, const std::string &remote_path, const std::string &local_path, bool silent)
+        bool scp_file_from_remote(const server_config &server_env, const std::string &remote_path, const std::string &local_path, bool silent, std::string user)
         {
             if (!server_env.is_valid())
             {
@@ -322,7 +332,7 @@ namespace dropshell
                 return false;
             }
             ASSERT(!remote_path.empty() && !local_path.empty(), "Remote or local path not specified. Can't scp.");
-            std::string scp_cmd = "scp -P " + server_env.get_SSH_PORT() + " " + server_env.get_SSH_USER() + "@" + server_env.get_SSH_HOST() + ":" + quote(remote_path) + " " + quote(local_path) + (silent ? " > /dev/null 2>&1" : "");
+            std::string scp_cmd = "scp -P " + server_env.get_SSH_PORT() + " " + user + "@" + server_env.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));
         }
 

source/src/commands/shared_commands.hpp

@@ -3,7 +3,7 @@
 
 #include "servers.hpp"
 #include "command_registry.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 
 namespace dropshell
 {
@@ -31,23 +31,26 @@ namespace dropshell
     class cRemoteTempFolder
     {
     public:
-        cRemoteTempFolder(const server_env_manager &server_env); // create a temp folder on the remote server
+        cRemoteTempFolder(const server_config &server_env, std::string user); // create a temp folder on the remote server
         ~cRemoteTempFolder();                                    // delete the temp folder on the remote server
         std::string path() const;                                // get the path to the temp folder on the remote server
     private:
         std::string mPath;
-        const server_env_manager &mServerEnv;
+        const server_config &mServerEnv;
+        std::string mUser;
     };
 
     bool rsync_tree_to_remote(
         const std::string &local_path,
         const std::string &remote_path,
-        server_env_manager &server_env,
+        const server_config &server_env,
-        bool silent);
+        bool silent,
+        std::string user);
 
     std::string get_arch();
 
-    std::map<std::string, ServiceStatus> get_all_services_status(std::string server_name);
+    std::map<std::string, ServiceStatus> get_all_services_status(const server_config & server_env);
+    std::map<std::string, ServiceStatus> get_all_services_status(const server_config & server_env, std::string user);
 
     std::string healthtick(const std::string &server, const std::string &service);
     std::string HealthStatus2String(HealthStatus status);
@@ -78,23 +81,24 @@ namespace dropshell
         std::string mDatetime;
     };
 
-    bool scp_file_to_remote(const server_env_manager &server_env, const std::string &local_path, const std::string &remote_path, bool silent);
+    bool scp_file_to_remote(const server_config &server_env, const std::string &local_path, const std::string &remote_path, bool silent, std::string user);
-    bool scp_file_from_remote(const server_env_manager &server_env, const std::string &remote_path, const std::string &local_path, bool silent);
+    bool scp_file_from_remote(const server_config &server_env, const std::string &remote_path, const std::string &local_path, bool silent, std::string user);
 
     // defined in backupdata.cpp, used by restoredata.cpp.
-    bool backupdata_service(const std::string& server, const std::string& service);
+    bool backupdata_service(const server_config &server_env, const std::string& service);
 
     // defined in uninstall.cpp
-    bool uninstall_service(const std::string &server, const std::string &service);
+    bool uninstall_service(const server_config &server_env, const std::string &service);
 
     // defined in nuke.cpp
     bool nuke_service(const std::string &server, const std::string &service);
 
     // defined in install.cpp
-    bool install_service(const std::string &server, const std::string &service);
+    bool install_service(const server_config &server_env, const std::string &service);
 
     // defined in create-service.cpp
-    bool create_service(const std::string &server_name, const std::string &template_name, const std::string &service_name);
+    bool create_service(const std::string &server_name, const std::string &template_name, const std::string &service_name, std::string user_override="");
+    bool merge_updated_service_template(const std::string &server_name, const std::string &service_name);
 
     } // namespace shared_commands
 } // namespace dropshell

source/src/commands/ssh.cpp

@@ -3,10 +3,11 @@
 #include "utils/utils.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "services.hpp"
 #include "servers.hpp"
 #include "templates.hpp"
+#include "assert.hpp"
 
 namespace dropshell
 {
@@ -34,27 +35,26 @@ namespace dropshell
                 
                 ssh SERVER SERVICE     SSH into a docker container for a service.
                 ssh SERVER             SSH into a server.
+                ssh USER@SERVER        SSH into a server as a specific user.
                 )"});
         }
     } ssh_command_register;
 
-
+    bool ssh_into_server(const std::string &server, std::string user)
-
-    bool ssh_into_server(const std::string &server)
     {
-        server_env_manager server_env(server);
+        server_config server_env(server);
         if (!server_env.is_valid())
         {
             error << "Server " << server << " is not valid" << std::endl;
             return false;
         }
-        execute_ssh_command(server_env.get_SSH_INFO(), sCommand(remotepath::DROPSHELL_DIR(server), "ls --color && bash", {}), cMode::Interactive);
+        execute_ssh_command(server_env.get_SSH_INFO(user), sCommand(remotepath(server, user).DROPSHELL_DIR(), "ls --color && bash", {}), cMode::Interactive);
         return true;
     }
 
     bool ssh_into_service(const std::string &server, const std::string &service)
     {
-        server_env_manager server_env(server);
+        server_config server_env(server);
         if (!server_env.is_valid())
         {
             error << "Server " << server << " is not valid" << std::endl;
@@ -92,18 +92,41 @@ namespace dropshell
             return 1;
         }
 
-        std::string server = safearg(ctx.args, 0);
+        // ssh into the server
-
         if (ctx.args.size() < 2)
         {
-            // ssh into the server
+            std::string arg1 = safearg(ctx.args, 0);
-            return ssh_into_server(server) ? 0 : 1;
+            std::string server, user;
+
+            // parse either user@server or server
+            if (arg1.find("@") != std::string::npos)
+            {
+                user = arg1.substr(0, arg1.find("@"));
+                server = arg1.substr(arg1.find("@") + 1);
+            }
+            else
+            {
+                server = arg1;
+
+                // get the first user from the server.env file, and ssh in as that user.
+                server_config server_env(server);
+                if (!server_env.is_valid())
+                {
+                    error << "Server " << server << " is not valid" << std::endl;
+                    return 1;
+                }
+                ASSERT(server_env.get_users().size() > 0, "Server " + server + " has no users");
+                user = server_env.get_users()[0].user;
             }
 
+            return ssh_into_server(server, user) ? 0 : 1;
+        }
+        else
+        { // ssh into a service on the server.
+            std::string server = safearg(ctx.args, 0);
             std::string service = safearg(ctx.args, 1);
-
-        // ssh into the specific service.
             return ssh_into_service(server, service) ? 0 : 1;
         }
+    }
 
 } // namespace dropshell

source/src/commands/start.cpp

@@ -3,7 +3,7 @@
 #include "utils/utils.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "services.hpp"
 #include "servers.hpp"
 #include "utils/output.hpp"
@@ -44,7 +44,7 @@ namespace dropshell
 
     bool start_service(const std::string &server, const std::string &service)
     {
-        server_env_manager server_env(server);
+        server_config server_env(server);
         if (!server_env.is_valid())
         {
             error << "Server " << server << " is not valid" << std::endl;

source/src/commands/stop.cpp

@@ -3,7 +3,7 @@
 #include "utils/utils.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "services.hpp"
 #include "servers.hpp"
 #include "utils/output.hpp"
@@ -44,7 +44,7 @@ namespace dropshell
 
     bool stop_service(const std::string &server, const std::string &service)
     {
-        server_env_manager server_env(server);
+        server_config server_env(server);
         if (!server_env.is_valid())
         {
             error << "Server " << server << " is not valid" << std::endl;

source/src/commands/uninstall.cpp

@@ -42,34 +42,31 @@ namespace dropshell
     } uninstall_command_register;
 
     namespace shared_commands {
-        bool uninstall_service(const std::string &server, const std::string &service)
+        bool uninstall_service(const server_config & server_env, const std::string &service)
         {
+            ASSERT(server_env.is_valid(), "Invalid server environment for " + server_env.get_server_name());
+            std::string server = server_env.get_server_name();
             maketitle("Uninstalling " + service + " on " + server);
 
-            server_env_manager server_env(server);
+            std::string user = server_env.get_user_for_service(service);
-            if (!server_env.is_valid())
-            {
-                error << "Invalid server: " << server << std::endl;
-                return false; // should never hit this.
-            }
 
             // 2. Check if service directory exists on server
-            if (!server_env.check_remote_dir_exists(remotepath::service(server, service)))
+            if (!server_env.check_remote_dir_exists(remotepath(server, user).service(service), user))
             {
                 error << "Service is not installed: " << service << std::endl;
                 return true; // Nothing to uninstall
             }
 
             // 3. Run uninstall script if it exists
-            std::string uninstall_script = remotepath::service_template(server, service) + "/uninstall.sh";
+            std::string uninstall_script = remotepath(server, user).service_template(service) + "/uninstall.sh";
             if (!server_env.run_remote_template_command(service, "uninstall", {}, false, {}))
                 warning << "Uninstall script failed, but continuing with directory removal" << std::endl;
 
             // 4. Remove the service directory from the server, running in a docker container as root.
-            if (server_env.remove_remote_dir(remotepath::service(server, service), false))
+            if (server_env.remove_remote_dir(remotepath(server, user).service(service), false, user))
             {
-                ASSERT(!server_env.check_remote_dir_exists(remotepath::service(server, service)), "Service directory still found on server after uninstall");
+                ASSERT(!server_env.check_remote_dir_exists(remotepath(server, user).service(service), user), "Service directory still found on server after uninstall");
-                info << "Removed remote service directory " << remotepath::service(server, service) << std::endl;
+                info << "Removed remote service directory " << remotepath(server, user).service(service) << std::endl;
             }
             else
                 warning << "Failed to remove remote service directory" << std::endl;

source/src/config.cpp

@@ -3,7 +3,6 @@
 #include <fstream>
 #include "config.hpp"
 #include "utils/utils.hpp"
-#include "utils/json.hpp"
 #include <filesystem>
 #include "utils/execute.hpp"
 #include "output.hpp"

source/src/config.hpp

@@ -2,7 +2,9 @@
 
 #include <string>
 #include <vector>
-#include "utils/json.hpp"
+
+#define JSON_INLINE_ALL
+#include "json.hpp"
 
 namespace dropshell {
 

source/src/server_env_manager.cpp

@@ -1,230 +0,0 @@
-#include "server_env_manager.hpp"
-#include "utils/directories.hpp"
-#include "utils/utils.hpp"
-#include "services.hpp"
-#include "templates.hpp"
-#include "utils/utils.hpp"
-#include "utils/json.hpp"
-#include "utils/execute.hpp"
-
-#include <iostream>
-#include <memory>
-#include <filesystem>
-#include <fstream>
-#include <sys/wait.h>
-#include <unistd.h>
-#include <vector>
-#include <string>
-#include <iostream>
-#include <wordexp.h> // For potential shell-like expansion if needed
-
-
-namespace dropshell {
-
-server_env_manager::server_env_manager(const std::string& server_name) : mValid(false), mServerName(server_name) {
-    if (server_name.empty())
-        return;
-        
-    // Construct the full path to server.env
-    std::string server_env_path = localfile::server_json(server_name);
-    
-    // Check if file exists
-    if (!std::filesystem::exists(server_env_path)) {
-        std::cerr << "Server environment file not found: " + server_env_path << " for server " << server_name << std::endl;
-        return;
-    }
-
-    try {
-        // Use envmanager to handle the environment file
-        nlohmann::json server_env_json = nlohmann::json::parse(std::ifstream(server_env_path));
-        if (server_env_json.empty()) {
-            std::cerr << "Error: Failed to parse server environment file: " + server_env_path << std::endl;
-            return;
-        }
-
-       // get the variables from the json
-       for (const auto& var : server_env_json.items()) {
-            std::string value;
-            if (var.value().is_string())
-                value = var.value();
-            else if (var.value().is_number_integer())
-                value = std::to_string(var.value().get<int>());
-            else if (var.value().is_boolean())
-                value = var.value() ? "true" : "false";
-            else
-                value = var.value().dump();
-
-            mVariables[var.key()] = replace_with_environment_variables_like_bash(value);
-       }
-
-        // Verify required variables exist
-        for (const auto& var : {"SSH_HOST", "SSH_USER", "SSH_PORT", "DROPSHELL_DIR"}) {
-            if (mVariables.find(var) == mVariables.end()) {
-                // Print the variables identified in the file
-                std::cout << "Variables identified in the file:" << std::endl;
-                for (const auto& v : mVariables) {
-                    std::cout << "    " << v.first << std::endl;
-                }
-                throw std::runtime_error("Missing required variable: " + std::string(var));
-            }
-        }
-        mValid = true;
-
-    } catch (const std::exception& e) {
-        std::cerr << "Failed to parse server environment file: " + std::string(e.what()) << std::endl;
-    }    
-}
-
-bool server_env_manager::create_server_env(const std::string &server_env_path, const std::string &SSH_HOST, const std::string &SSH_USER, const std::string &SSH_PORT, const std::string &DROPSHELL_DIR)
-{
-    nlohmann::json server_env_json;
-    server_env_json["SSH_HOST"] = SSH_HOST;
-    server_env_json["SSH_USER"] = SSH_USER;
-    server_env_json["SSH_PORT"] = SSH_PORT;
-    server_env_json["DROPSHELL_DIR"] = DROPSHELL_DIR;
-
-    try {
-        std::ofstream server_env_file(server_env_path);
-        server_env_file << server_env_json.dump(4);
-        server_env_file.close();
-        return true;
-    } catch (const std::exception& e) {
-        std::cerr << "Failed to create server environment file: " + std::string(e.what()) << std::endl;
-        return false;
-    }
-}
-
-std::string server_env_manager::get_variable(const std::string& name) const {
-    auto it = mVariables.find(name);
-    if (it == mVariables.end()) {
-        return "";
-    }
-    return it->second;
-}
-std::optional<sCommand> server_env_manager::construct_standard_template_run_cmd(const std::string &service_name, const std::string &command, const std::vector<std::string> args, const bool silent) const
-{
-    if (command.empty())
-        return std::nullopt;
-
-    std::string remote_service_template_path = remotepath::service_template(mServerName,service_name);
-    std::string script_path = remote_service_template_path + "/" + command + ".sh";
-
-    std::map<std::string, std::string> env_vars;
-    if (!get_all_service_env_vars(mServerName, service_name, env_vars)) {
-        std::cerr << "Error: Failed to get all service env vars for " << service_name << std::endl;
-        return std::nullopt;
-    }
-
-    std::string argstr = "";
-    for (const auto& arg : args) {
-        argstr += " " + quote(dequote(trim(arg)));
-    }
-
-    sCommand sc(
-        remote_service_template_path, 
-        quote(script_path) + argstr + (silent ? " > /dev/null 2>&1" : ""), 
-        env_vars
-    );
-
-    if (sc.empty()) {
-        std::cerr << "Error: Failed to construct command for " << service_name << " " << command << std::endl;
-        return std::nullopt;
-    }
-    return sc;
-}
-
-
-bool server_env_manager::check_remote_dir_exists(const std::string &dir_path) const
-{
-    sCommand scommand("", "test -d " + quote(dir_path),{});
-    return execute_ssh_command(get_SSH_INFO(), scommand, cMode::Silent);
-}
-
-bool server_env_manager::check_remote_file_exists(const std::string& file_path) const {
-    sCommand scommand("", "test -f " + quote(file_path),{});
-    return execute_ssh_command(get_SSH_INFO(), scommand, cMode::Silent);
-}
-
-bool server_env_manager::check_remote_items_exist(const std::vector<std::string> &file_paths) const
-{
-    // convert file_paths to a single string, separated by spaces
-    std::string file_paths_str;
-    std::string file_names_str;
-    for (const auto& file_path : file_paths) {
-        file_paths_str += quote(file_path) + " ";
-        file_names_str += std::filesystem::path(file_path).filename().string() + " ";
-    }
-    // check if all items in the vector exist on the remote server, in a single command.
-    sCommand scommand("", "for item in " + file_paths_str + "; do test -f $item; done",{});
-
-    bool okay = execute_ssh_command(get_SSH_INFO(), scommand, cMode::Silent);
-    if (!okay) {
-        std::cerr << "Error: Required items not found on remote server: " << file_names_str << std::endl;
-        return false;
-    }
-    return true;
-}
-
-bool server_env_manager::remove_remote_dir(const std::string &dir_path, bool silent) const
-{
-    std::filesystem::path path(dir_path);
-    std::filesystem::path parent_path = path.parent_path();
-    std::string target_dir = path.filename().string();
-
-    if (parent_path.empty()) 
-        parent_path="/";
-    
-    if (target_dir.empty())
-        return false;
-
-    if (!silent)
-        std::cout << "Removing remote directory " << target_dir << " in " << parent_path << " on " << mServerName << std::endl;
-    std::string remote_cmd =
-    "docker run --rm -v " + quote(parent_path.string()) + ":/parent " +
-        " alpine rm -rf \"/parent/" + target_dir + "\"";
-
-    // if (!silent)
-    //     std::cout << "Running command: " << remote_cmd << std::endl;
-
-    sCommand scommand("", remote_cmd,{});
-    cMode mode = (silent ? cMode::Silent : cMode::Defaults);
-
-    return execute_ssh_command(get_SSH_INFO(), scommand, mode);
-}
-
-bool server_env_manager::run_remote_template_command(const std::string &service_name, const std::string &command, std::vector<std::string> args, bool silent, std::map<std::string, std::string> extra_env_vars) const
-{
-    auto scommand = construct_standard_template_run_cmd(service_name, command, args, silent);
-    if (!scommand.has_value())
-        return false;
-
-    // add the extra env vars to the command
-    for (const auto& [key, value] : extra_env_vars) 
-        scommand->add_env_var(key, value);
-
-    if (scommand->get_command_to_run().empty())
-        return false;
-    cMode mode = (command=="ssh") ? (cMode::Interactive) : (silent ? cMode::Silent : cMode::Defaults);
-    return execute_ssh_command(get_SSH_INFO(), scommand.value(), mode);
-}
-
-bool server_env_manager::run_remote_template_command_and_capture_output(const std::string &service_name, const std::string &command, std::vector<std::string> args, std::string &output, bool silent, std::map<std::string, std::string> extra_env_vars) const
-{
-    auto scommand = construct_standard_template_run_cmd(service_name, command, args, false);
-    if (!scommand.has_value())
-        return false;
-
-    // add the extra env vars to the command
-    for (const auto& [key, value] : extra_env_vars) 
-        scommand->add_env_var(key, value);
-
-    return execute_ssh_command(get_SSH_INFO(), scommand.value(), cMode::Defaults, &output);
-}
-
-
-
-// base64 <<< "FOO=BAR WHEE=YAY bash ./test.sh"
-// echo YmFzaCAtYyAnRk9PPUJBUiBXSEVFPVlBWSBiYXNoIC4vdGVzdC5zaCcK | base64 -d | bash
-
-
-} // namespace dropshell

source/src/server_env_manager.hpp

@@ -1,77 +0,0 @@
-// server_env.hpp
-//
-// read the server.env file and provide a class to access the variables
-
-#ifndef __SERVER_ENV_HPP
-#define __SERVER_ENV_HPP
-
-#include <string>
-#include <map>
-#include <memory>
-#include <vector>
-#include "utils/execute.hpp"
-#include <optional>
-namespace dropshell {
-
-class server_env_manager;
-
-// ------------------------------------------------------------------------------------------------
-
-// reads path / server.env and provides a class to access the variables.
-// each env file is required to have the following variables:
-// SSH_HOST
-// SSH_USER
-// SSH_PORT
-// the following replacements are made in the values:
-// ${USER} -> the username of the user running dropshell
-class server_env_manager {
-    public:
-        server_env_manager(const std::string& server_name);
-        
-        static bool create_server_env(
-                 const std::string& server_env_path,
-                 const std::string& SSH_HOST,
-                 const std::string& SSH_USER,
-                 const std::string& SSH_PORT,
-                 const std::string& DROPSHELL_DIR);
-
-        std::string get_variable(const std::string& name) const;
-
-        // trivial getters.
-        const std::map<std::string, std::string>& get_variables() const { return mVariables; }
-        std::string get_SSH_HOST() const { return get_variable("SSH_HOST"); }
-        std::string get_SSH_USER() const { return get_variable("SSH_USER"); }
-        std::string get_SSH_PORT() const { return get_variable("SSH_PORT"); }
-        std::string get_DROPSHELL_DIR() const { return get_variable("DROPSHELL_DIR"); }
-        sSSHInfo get_SSH_INFO() const { return sSSHInfo{get_SSH_HOST(), get_SSH_USER(), get_SSH_PORT(), get_server_name()}; }
-        bool is_valid() const { return mValid; }
-        std::string get_server_name() const { return mServerName; }
-
-// helper functions
-    public:
-        bool check_remote_dir_exists(const std::string &dir_path) const;
-        bool check_remote_file_exists(const std::string& file_path) const;
-        bool check_remote_items_exist(const std::vector<std::string>& file_paths) const;
-
-        bool remove_remote_dir(const std::string &dir_path, bool silent) const;
-
-        bool run_remote_template_command(const std::string& service_name, const std::string& command, 
-            std::vector<std::string> args, bool silent, std::map<std::string, std::string> extra_env_vars) const;
-        bool run_remote_template_command_and_capture_output(const std::string& service_name, const std::string& command, 
-            std::vector<std::string> args, std::string & output, bool silent, std::map<std::string, std::string> extra_env_vars) const;
-
-    private:
-        std::optional<sCommand> construct_standard_template_run_cmd(const std::string& service_name, const std::string& command, const std::vector<std::string> args, const bool silent) const;
-
-    private:
-        std::string mServerName;
-        std::map<std::string, std::string> mVariables;
-        bool mValid;
-};
-
-
-
-} // namespace dropshell
-
-
-#endif // __SERVER_ENV_HPP  

source/src/servers.cpp

@@ -1,48 +1,379 @@
-#include "servers.hpp"
-#include "server_env_manager.hpp"
-#include "utils/tableprint.hpp"
-#include "utils/envmanager.hpp"
 #include "utils/directories.hpp"
+#include "utils/utils.hpp"
+#include "servers.hpp"
 #include "services.hpp"
-#include "config.hpp"
 #include "templates.hpp"
-#include "contrib/transwarp.hpp"
+#include "utils/utils.hpp"
-#include "utils/output.hpp"
+#include "utils/execute.hpp"
+#include "output.hpp"
+#include "utils/assert.hpp"
+#include "config.hpp"
 
 #include <iostream>
-#include <fstream>
+#include <memory>
-#include <iomanip>
 #include <filesystem>
+#include <fstream>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <vector>
+#include <string>
+#include <iostream>
+#include <wordexp.h> // For potential shell-like expansion if needed
 
-namespace dropshell {
+namespace dropshell
+{
 
-std::vector<ServerInfo> get_configured_servers() {
+    server_config::server_config(const std::string &server_name) : mValid(false), mServerName(server_name)
-    std::vector<ServerInfo> servers;
+    {
+        if (server_name.empty())
+            return;
+
+        std::string server_json_path = localfile::server_json(server_name);
+
+        // Check if file exists
+        if (!std::filesystem::exists(server_json_path))
+        {
+            std::cerr << "Server environment file not found: " + server_json_path << " for server " << server_name << std::endl;
+            return;
+        }
+
+        try
+        {
+            // Use envmanager to handle the environment file
+            nlohmann::json server_env_json = nlohmann::json::parse(std::ifstream(server_json_path));
+            if (server_env_json.empty())
+            {
+                error << "Failed to parse server environment file at "<< server_json_path << std::endl;
+                info << "The returned json was empty." << std::endl;
+                return;
+            }
+
+            // get the variables from the json, converting everything to strings.
+            for (const auto &var : server_env_json.items())
+            {
+                std::string value;
+                if (var.value().is_string())
+                    value = var.value();
+                else if (var.value().is_number_integer())
+                    value = std::to_string(var.value().get<int>());
+                else if (var.value().is_boolean())
+                    value = var.value() ? "true" : "false";
+                else
+                    value = var.value().dump();
+                mVariables[var.key()] = replace_with_environment_variables_like_bash(value);
+            }
+
+            // Verify required variables exist
+            for (const auto &var : {"SSH_HOST", "SSH_PORT", "SSH_USERS"})
+            {
+                if (mVariables.find(var) == mVariables.end())
+                {
+                    // Print the variables identified in the file
+                    info << "Variables identified in the file:" << std::endl;
+                    for (const auto &v : mVariables)
+                    {
+                        info << "    " << v.first << std::endl;
+                    }
+                    throw std::runtime_error("Missing required variable: " + std::string(var));
+                }
+            }
+
+            // Parse users array
+            if (!server_env_json.contains("SSH_USERS") || !server_env_json["SSH_USERS"].is_array())
+            {
+                error << "SSH_USERS array not found or invalid in server configuration" << std::endl;
+                return;
+            }
+
+            for (const auto &user_json : server_env_json["SSH_USERS"])
+            {
+                UserConfig user;
+                user.user = user_json["USER"].get<std::string>();
+                user.dir = user_json["DIR"].get<std::string>();
+                mUsers.push_back(user);
+            }
+
+            if (mUsers.empty())
+            {
+                error << "No users defined in server configuration " << server_json_path << std::endl;
+                return;
+            }
+
+            mValid = true;
+        }
+        catch (const std::exception &e)
+        {
+            error << "Failed to parse " << server_json_path << std::endl;
+            error << "Error: " << e.what() << std::endl;
+
+            mValid = false;
+        }
+    }
+
+    std::string server_config::get_SSH_HOST() const
+    {
+        return get_variable("SSH_HOST");
+    }
+
+    std::string server_config::get_SSH_PORT() const
+    {
+        return get_variable("SSH_PORT");
+    }
+
+    std::vector<UserConfig> server_config::get_users() const
+    {
+        return mUsers;
+    }
+
+    std::string server_config::get_user_dir(const std::string &user) const
+    {
+        for (const auto &u : mUsers)
+        {
+            if (u.user == user)
+            {
+                return u.dir;
+            }
+        }
+        return "";
+    }
+
+    std::string server_config::get_server_name() const
+    {
+        return mServerName;
+    }
+
+    std::string server_config::get_user_for_service(const std::string &service) const
+    {
+        return dropshell::get_user_for_service(mServerName, service);
+    }
+
+    std::string get_user_for_service(const std::string &server, const std::string &service)
+    {
+        auto services_info = get_server_services_info(server);
+        auto it = std::find_if(services_info.begin(), services_info.end(),
+                         [&service](const LocalServiceInfo &si)
+                         { return si.service_name == service; });
+        if (it != services_info.end() && SIvalid(*it))
+            return it->user;
+        return "";
+    }
+
+    sSSHInfo server_config::get_SSH_INFO(std::string user) const
+    {
+        ASSERT(!user.empty(), "User is empty, cannot get SSH info.");
+        // Find user in mUsers vector
+        auto it = std::find_if(mUsers.begin(), mUsers.end(),
+                               [&user](const UserConfig &u)
+                               { return u.user == user; });
+        ASSERT(it != mUsers.end(), ("User " + user + " not found in server environment."));
+        return sSSHInfo(get_SSH_HOST(), it->user, get_SSH_PORT(), get_server_name(), it->dir);
+    }
+
+    bool server_config::hasRootUser() const
+    {
+        auto it = std::find_if(mUsers.begin(), mUsers.end(),[](const UserConfig &u)
+                               { return u.user == "root"; });
+        return it != mUsers.end();
+    }
+
+    bool server_config::hasDocker() const
+    {
+        return get_variable("HAS_DOCKER") == "true";
+    }
+
+    bool server_config::hasRootDocker() const
+    {
+        return get_variable("DOCKER_ROOTLESS") == "false";
+    }
+
+    bool server_config::hasUser(const std::string &user) const
+    {
+        auto it = std::find_if(mUsers.begin(), mUsers.end(),
+                               [&user](const UserConfig &u)
+                               { return u.user == user; });
+        return it != mUsers.end();
+    }
+
+    bool server_config::check_remote_dir_exists(const std::string &dir_path, std::string user) const
+    {
+        sCommand scommand("", "test -d " + quote(dir_path), {});
+        return execute_ssh_command(get_SSH_INFO(user), scommand, cMode::Silent);
+    }
+
+    bool server_config::check_remote_file_exists(const std::string &file_path, std::string user) const
+    {
+        sCommand scommand("", "test -f " + quote(file_path), {});
+        return execute_ssh_command(get_SSH_INFO(user), scommand, cMode::Silent);
+    }
+
+    bool server_config::check_remote_items_exist(const std::vector<std::string> &file_paths, std::string user) const
+    {
+        // convert file_paths to a single string, separated by spaces
+        std::string file_paths_str;
+        std::string file_names_str;
+        for (const auto &file_path : file_paths)
+        {
+            file_paths_str += quote(file_path) + " ";
+            file_names_str += std::filesystem::path(file_path).filename().string() + " ";
+        }
+        // check if all items in the vector exist on the remote server, in a single command.
+        sCommand scommand("", "for item in " + file_paths_str + "; do test -f $item; done", {});
+
+        sSSHInfo sshinfo = get_SSH_INFO(user);
+        bool okay = execute_ssh_command(sshinfo, scommand, cMode::Silent);
+        if (!okay)
+        {
+            std::cerr << "Error: Required items not found on remote server: " << file_names_str << std::endl;
+            return false;
+        }
+        return true;
+    }
+
+    bool server_config::remove_remote_dir(
+        const std::string &dir_path, bool silent, std::string user) const
+    {
+        std::filesystem::path path(dir_path);
+        std::filesystem::path parent_path = path.parent_path();
+        std::string target_dir = path.filename().string();
+
+        if (parent_path.empty())
+            parent_path = "/";
+
+        if (target_dir.empty())
+            return false;
+
+        if (!silent)
+            std::cout << "Removing remote directory " << target_dir << " in " << parent_path << " on " << mServerName << std::endl;
+        std::string remote_cmd =
+            "docker run --rm -v " + quote(parent_path.string()) + ":/parent " +
+            " alpine rm -rf \"/parent/" + target_dir + "\"";
+
+        // if (!silent)
+        //     std::cout << "Running command: " << remote_cmd << std::endl;
+
+        sCommand scommand("", remote_cmd, {});
+        cMode mode = (silent ? cMode::Silent : cMode::Defaults);
+
+        sSSHInfo sshinfo = get_SSH_INFO(user);
+        return execute_ssh_command(sshinfo, scommand, mode);
+    }
+
+    bool server_config::run_remote_template_command(
+        const std::string &service_name,
+        const std::string &command,
+        std::vector<std::string> args,
+        bool silent,
+        std::map<std::string, std::string> extra_env_vars) const
+    {
+        std::string user = get_user_for_service(service_name);
+        auto scommand = construct_standard_template_run_cmd(service_name, command, args, silent);
+        if (!scommand.has_value())
+            return false;
+
+        // add the extra env vars to the command
+        for (const auto &[key, value] : extra_env_vars)
+            scommand->add_env_var(key, value);
+
+        if (scommand->get_command_to_run().empty())
+            return false;
+        cMode mode = (command == "ssh") ? (cMode::Interactive) : (silent ? cMode::Silent : cMode::Defaults);
+        return execute_ssh_command(get_SSH_INFO(user), scommand.value(), mode);
+    }
+
+    bool server_config::run_remote_template_command_and_capture_output(
+        const std::string &service_name,
+        const std::string &command,
+        std::vector<std::string> args,
+        std::string &output,
+        bool silent,
+        std::map<std::string, std::string> extra_env_vars) const
+    {
+        std::string user = get_user_for_service(service_name);
+        auto scommand = construct_standard_template_run_cmd(service_name, command, args, false);
+        if (!scommand.has_value())
+            return false;
+
+        // add the extra env vars to the command
+        for (const auto &[key, value] : extra_env_vars)
+            scommand->add_env_var(key, value);
+
+        return execute_ssh_command(get_SSH_INFO(user), scommand.value(), cMode::Defaults, &output);
+    }
+
+    std::string server_config::get_variable(const std::string &name) const
+    {
+        auto it = mVariables.find(name);
+        if (it == mVariables.end())
+        {
+            return "";
+        }
+        return it->second;
+    }
+
+    std::optional<sCommand> server_config::construct_standard_template_run_cmd(const std::string &service_name, const std::string &command, const std::vector<std::string> args, const bool silent) const
+    {
+        if (command.empty())
+            return std::nullopt;
+
+        std::string user = get_user_for_service(service_name);
+
+        std::string remote_service_template_path = remotepath(mServerName, user).service_template(service_name);
+        std::string script_path = remote_service_template_path + "/" + command + ".sh";
+
+        std::map<std::string, std::string> env_vars;
+        if (!get_all_service_env_vars(mServerName, service_name, env_vars))
+        {
+            std::cerr << "Error: Failed to get all service env vars for " << service_name << std::endl;
+            return std::nullopt;
+        }
+
+        std::string argstr = "";
+        for (const auto &arg : args)
+        {
+            argstr += " " + quote(dequote(trim(arg)));
+        }
+
+        sCommand sc(
+            remote_service_template_path,
+            quote(script_path) + argstr + (silent ? " > /dev/null 2>&1" : ""),
+            env_vars);
+
+        if (sc.empty())
+        {
+            std::cerr << "Error: Failed to construct command for " << service_name << " " << command << std::endl;
+            return std::nullopt;
+        }
+        return sc;
+    }
+
+    std::vector<server_config> get_configured_servers()
+    {
+        std::vector<server_config> servers;
 
         std::vector<std::string> lsdp = gConfig().get_local_server_definition_paths();
         if (lsdp.empty())
             return servers;
 
-    for (auto servers_dir : lsdp) {
+        for (auto servers_dir : lsdp)
-        if (!servers_dir.empty() && std::filesystem::exists(servers_dir)) {
+        {
-            for (const auto& entry : std::filesystem::directory_iterator(servers_dir)) {
+            if (!servers_dir.empty() && std::filesystem::exists(servers_dir))
-                if (std::filesystem::is_directory(entry)) {
+            {
+                for (const auto &entry : std::filesystem::directory_iterator(servers_dir))
+                {
+                    if (std::filesystem::is_directory(entry))
+                    {
                         std::string server_name = entry.path().filename().string();
 
                         if (server_name.empty() || server_name[0] == '.' || server_name[0] == '_')
                             continue;
 
-                    server_env_manager env(server_name);
+                        server_config env(server_name);
-                    if (!env.is_valid()) {
+                        if (!env.is_valid())
+                        {
                             std::cerr << "Error: Invalid server environment file: " << entry.path().string() << std::endl;
                             continue;
                         }
-                    servers.push_back({
+                        servers.push_back(env);
-                        server_name,
-                        env.get_SSH_HOST(),
-                        env.get_SSH_USER(),
-                        env.get_SSH_PORT()
-                    });
                     }
                 }
             }
@@ -51,32 +382,12 @@ std::vector<ServerInfo> get_configured_servers() {
         return servers;
     }
 
-ServerInfo get_server_info(const std::string &server_name)
-{
-    std::vector<std::string> lsdp = gConfig().get_local_server_definition_paths();
-    if (lsdp.empty())
-        return ServerInfo();
-
-    for (auto &config_dir : lsdp) {
-        std::string server_dir = config_dir + "/" + server_name;
-        if (std::filesystem::exists(server_dir)) {
-            server_env_manager env(server_name);
-            if (!env.is_valid()) {
-                std::cerr << "Error: Invalid server environment file: " << server_dir << std::endl;
-                continue;
-            }
-            return ServerInfo({server_name, env.get_SSH_HOST(), env.get_SSH_USER(), env.get_SSH_PORT()});
-        }
-    }
-    return ServerInfo();
-}
-
-
     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()) {
+        if (!server_existing_dir.empty())
+        {
             error << "Error: Server name already exists: " << server_name << std::endl;
             info << "Current server path: " << server_existing_dir << std::endl;
             return false;
@@ -84,7 +395,8 @@ bool create_server(const std::string &server_name)
 
         // 2. create a new directory in the user config directory
         auto lsdp = gConfig().get_local_server_definition_paths();
-    if (lsdp.empty() || lsdp[0].empty()) {
+        if (lsdp.empty() || lsdp[0].empty())
+        {
             error << "Error: Local server definition path not found" << std::endl;
             info << "Run 'dropshell edit' to configure DropShell" << std::endl;
             return false;
@@ -94,13 +406,17 @@ 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.json";
+        std::string server_env_path = server_dir + "/" + filenames::server_json;
         std::ofstream server_env_file(server_env_path);
         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 << "    \"SSH_USERS\": [" << std::endl;
+        server_env_file << "        {" << std::endl;
+        server_env_file << "            \"USER\": \"" << user << "\"," << std::endl;
+        server_env_file << "            \"DIR\": \"" << "/home/" + user << "/.dropshell\"" << std::endl;
+        server_env_file << "        }" << std::endl;
+        server_env_file << "    ]" << std::endl;
         server_env_file << "}" << std::endl;
         server_env_file.close();
 
@@ -114,13 +430,24 @@ bool create_server(const std::string &server_name)
 
     void get_all_used_commands(std::set<std::string> &commands)
     {
-    std::vector<ServerInfo> servers = get_configured_servers();
+        std::vector<server_config> servers = get_configured_servers();
         for (const auto &server : servers)
         {
-        auto services = dropshell::get_server_services_info(server.name);
+            auto services = get_server_services_info(server.get_server_name());
             for (const auto &service : services)
-            commands.merge(dropshell::get_used_commands(server.name, service.service_name));
+                commands.merge(get_used_commands(server.get_server_name(), service.service_name));
         }
     }
 
+    bool server_exists(const std::string &server_name)
+    {
+        std::string server_existing_dir = localpath::server(server_name);
+        if (server_existing_dir.empty())
+            return false;
+
+        if (std::filesystem::exists(server_existing_dir));
+            return true;
+        return false;
+    }
+
 } // namespace dropshell

source/src/servers.hpp

@@ -1,28 +1,104 @@
-#ifndef SERVERS_HPP
+// server_env.hpp
-#define SERVERS_HPP
+//
+// read the server.env file and provide a class to access the variables
+
+#ifndef __SERVER_ENV_HPP
+#define __SERVER_ENV_HPP
 
 #include <string>
-#include <set>
+#include <map>
+#include <memory>
 #include <vector>
+#include <set>
+#include <optional>
 
-namespace dropshell {
+#include "utils/execute.hpp"
 
-    // Server information structure
+namespace dropshell
-    struct ServerInfo {
+{
-        std::string name;
+
-        std::string ssh_host;
+    struct UserConfig
-        std::string ssh_user;
+    {
-        std::string ssh_port;
+        std::string user;
+        std::string dir;
     };
 
-    std::vector<ServerInfo> get_configured_servers();
+    // ------------------------------------------------------------------------------------------------
 
-    ServerInfo get_server_info(const std::string& server_name);
+    // reads path / server.env and provides a class to access the variables.
+    // each env file is required to have the following variables:
+    // SSH_HOST
+    // SSH_UNPRIVILEGED_USER
+    // SSH_PORT
+    // the following replacements are made in the values:
+    // ${USER} -> the username of the user running dropshell
+    class server_config
+    {
+    public:
+        server_config(const std::string &server_name);
+
+        bool is_valid() const { return mValid; }
+
+
+        // trivial getters.
+        const std::map<std::string, std::string> &get_variables() const { return mVariables; }
+        std::string get_variable(const std::string &name) const;
+
+        // ------------------------------------------------------------------------------------------------
+        // getters
+        // ------------------------------------------------------------------------------------------------
+        std::string get_SSH_HOST() const;
+        std::string get_SSH_PORT() const;
+        std::vector<UserConfig> get_users() const;
+        std::string get_user_dir(const std::string &user) const;
+        std::string get_server_name() const;
+        std::string get_user_for_service(const std::string &service) const;
+
+        sSSHInfo get_SSH_INFO(std::string user) const;
+
+        // server capabilities
+        bool hasRootUser() const;
+        bool hasDocker() const;
+        bool hasRootDocker() const;
+
+        // helper functions
+        bool hasUser(const std::string &user) const;
+
+    public:
+        bool check_remote_dir_exists(const std::string &dir_path, std::string user) const;
+        bool check_remote_file_exists(const std::string &file_path, std::string user) const;
+        bool check_remote_items_exist(const std::vector<std::string> &file_paths, std::string user) const;
+
+        bool remove_remote_dir(const std::string &dir_path, bool silent, std::string user) const;
+
+        bool run_remote_template_command(const std::string &service_name, const std::string &command,
+                                         std::vector<std::string> args, bool silent, std::map<std::string, std::string> extra_env_vars) const;
+
+        bool run_remote_template_command_and_capture_output(const std::string &service_name, const std::string &command,
+                                                            std::vector<std::string> args, std::string &output, bool silent, std::map<std::string, std::string> extra_env_vars) const;
+
+    private:
+        std::optional<sCommand> construct_standard_template_run_cmd(const std::string &service_name, const std::string &command, const std::vector<std::string> args, const bool silent) const;
+
+    private:
+        std::string mServerName;
+        std::map<std::string, std::string> mVariables;
+        std::vector<UserConfig> mUsers;
+        bool mValid;
+    }; // class server_config
+
+
+
+    std::vector<server_config> get_configured_servers();
+
+    std::string get_user_for_service(const std::string &server, const std::string &service);
 
     bool create_server(const std::string &server_name);
 
     void get_all_used_commands(std::set<std::string> &commands);
 
+    bool server_exists(const std::string &server_name);
+
 } // namespace dropshell
 
-#endif // SERVERS_HPP
+#endif // __SERVER_ENV_HPP

source/src/service_runner.cpp

@@ -10,7 +10,7 @@
 // #include "utils/assert.hpp"
 
 // #include "config.hpp"
-// #include "server_env_manager.hpp"
+// #include "servers.hpp"
 // #include "templates.hpp"
 // #include "services.hpp"
 // #include "utils/directories.hpp"
@@ -73,7 +73,7 @@
 
 //     private:
 //         std::string mServer;
-//         server_env_manager mServerEnv;
+//         server_config mServerEnv;
 //         LocalServiceInfo mServiceInfo;
 //         std::string mService;
 //         bool mValid;
@@ -240,7 +240,7 @@
 //         return false;
 //     }
     
-//     server_env_manager env(server_name);
+//     server_config env(server_name);
 //     if (!env.is_valid()) {
 //         std::cerr << "Error: Invalid server environment file: " << server_name << std::endl;
 //         return false;
@@ -265,13 +265,13 @@
 
 // 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" : "");
+//     std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " + quote(local_path) + " " + mServerEnv.get_SSH_UNPRIVILEGED_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" : "");
+//     std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " + mServerEnv.get_SSH_UNPRIVILEGED_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));
 // }
 

source/src/services.cpp

@@ -4,8 +4,6 @@
 #include "templates.hpp"
 #include "config.hpp"
 #include "utils/utils.hpp"
-#include "server_env_manager.hpp"
-#include "servers.hpp"
 #include "assert.hpp"
 
 #include <iostream>
@@ -13,33 +11,42 @@
 
 namespace fs = std::filesystem;
 
-namespace dropshell {   
+namespace dropshell
+{
 
-    bool SIvalid(const LocalServiceInfo& service_info) {
+#pragma TODO : Smart test that the service is fully valid.
+    bool SIvalid(const LocalServiceInfo &service_info)
+    {
         return !service_info.service_name.empty() &&
                !service_info.template_name.empty() &&
                !service_info.local_service_path.empty() &&
-               !service_info.local_template_path.empty();
+               !service_info.local_template_path.empty() &&
+               !service_info.user.empty();
     }
 
-std::vector<LocalServiceInfo> get_server_services_info(const std::string& server_name) {
+    std::vector<LocalServiceInfo> get_server_services_info(const std::string &server_name)
+    {
         std::vector<LocalServiceInfo> services;
 
         if (server_name.empty())
             return services;
 
         std::vector<std::string> local_server_definition_paths = gConfig().get_local_server_definition_paths();
-    if (local_server_definition_paths.empty()) {
+        if (local_server_definition_paths.empty())
+        {
             std::cerr << "Error: No local server definition paths found" << std::endl;
             std::cerr << "Run 'dropshell edit' to configure DropShell" << std::endl;
             return services;
         }
 
-    for (const auto& server_definition_path : local_server_definition_paths) {
+        for (const auto &server_definition_path : local_server_definition_paths)
+        {
             fs::path serverpath = server_definition_path + "/" + server_name;
             if (fs::exists(serverpath)) // service is on that server...
-            for (const auto& entry : fs::directory_iterator(serverpath)) {
+                for (const auto &entry : fs::directory_iterator(serverpath))
-                if (fs::is_directory(entry)) {
+                {
+                    if (fs::is_directory(entry))
+                    {
                         std::string dirname = entry.path().filename().string();
                         if (dirname.empty() || dirname[0] == '.' || dirname[0] == '_')
                             continue;
@@ -55,6 +62,16 @@ std::vector<LocalServiceInfo> get_server_services_info(const std::string& server
         return services;
     }
 
+    bool get_bool_variable(const std::map<std::string, std::string> &variables, const std::string &variable_name)
+    {
+        auto it = variables.find(variable_name);
+        if (it == variables.end())
+        {
+            error << "Variable " << variable_name << " not found in the service " << filenames::template_info_env << std::endl;
+            return false;
+        }
+        return it->second == "true";
+    }
 
     LocalServiceInfo get_service_info(const std::string &server_name, const std::string &service_name)
     {
@@ -81,23 +98,52 @@ LocalServiceInfo get_service_info(const std::string &server_name, const std::str
         if (!get_all_service_env_vars(server_name, service_name, variables))
             return LocalServiceInfo();
 
-    // confirm TEMPLATE is defined.
+        { // confirm TEMPLATE is defined.
             auto it = variables.find("TEMPLATE");
-    if (it == variables.end()) {
+            if (it == variables.end())
-        std::cerr << "Error: TEMPLATE variable not defined in service " << service_name << " on server " << server_name << std::endl;
+            {
+                error << "Error: TEMPLATE variable not defined in service " << service_name << " on server " << server_name << std::endl;
                 return LocalServiceInfo();
             }
             service.template_name = it->second;
+        }
 
         template_info tinfo = gTemplateManager().get_template_info(service.template_name);
-    if (!tinfo.is_set()) {
+        if (!tinfo.is_set())
-        std::cerr << "Error: Template '" << service.template_name << "' not found" << std::endl;
+        {
+            error << "Template specified '" << service.template_name << "' could not be found" << std::endl;
             return LocalServiceInfo();
         }
 
         // find the template path
         service.local_template_path = tinfo.local_template_path();
 
+        { // set the user.
+            auto it = variables.find("SSH_USER");
+            if (it == variables.end())
+            {
+                error << "SSH_USER variable not defined in service " << service_name << " on server " << server_name << std::endl;
+                return LocalServiceInfo();
+            }
+            service.user = it->second;
+        }
+
+        // set the host root and docker requirements.
+        service.requires_host_root = get_bool_variable(variables, "REQUIRES_HOST_ROOT");
+        service.requires_docker = get_bool_variable(variables, "REQUIRES_DOCKER");
+        service.requires_docker_root = get_bool_variable(variables, "REQUIRES_DOCKER_ROOT");
+
+        { // determine if the service template hash matches the template hash.
+            auto it = variables.find("TEMPLATE_HASH");
+            if (it == variables.end())
+            {
+                error << "TEMPLATE_HASH variable not defined in service " << service_name << " on server " << server_name << std::endl;
+                return LocalServiceInfo();
+            }
+            uint64_t service_template_hash = std::stoull(it->second);
+            service.service_template_hash_match = (service_template_hash == tinfo.hash());
+        }
+
         return service;
     }
 
@@ -109,14 +155,16 @@ std::set<std::string> get_used_commands(const std::string &server_name, const st
             return commands;
 
         auto service_info = get_service_info(server_name, service_name);
-    if (service_info.local_template_path.empty()) {
+        if (service_info.local_template_path.empty())
+        {
             std::cerr << "Error: Service not found: " << service_name << std::endl;
             return commands;
         }
 
         // iterate over all files in the template path, and add the command name to the set.
         // commands are .sh files that don't begin with _
-    for (const auto& entry : fs::directory_iterator(service_info.local_template_path)) {
+        for (const auto &entry : fs::directory_iterator(service_info.local_template_path))
+        {
             if (fs::is_regular_file(entry) && entry.path().extension() == ".sh" && (entry.path().filename().string().rfind("_", 0) != 0))
                 commands.insert(entry.path().stem().string());
         }
@@ -132,7 +180,8 @@ std::set<std::string> list_backups(const std::string &server_name, const std::st
 
         // need to find the template for the service.
         auto service_info = get_service_info(server_name, service_name);
-    if (service_info.local_template_path.empty()) {
+        if (service_info.local_template_path.empty())
+        {
             std::cerr << "Error: Service not found: " << service_name << std::endl;
             return backups;
         }
@@ -141,8 +190,10 @@ std::set<std::string> list_backups(const std::string &server_name, const std::st
         if (backups_dir.empty())
             return backups;
 
-    if (fs::exists(backups_dir)) {
+        if (fs::exists(backups_dir))
-        for (const auto& entry : fs::directory_iterator(backups_dir)) {
+        {
+            for (const auto &entry : fs::directory_iterator(backups_dir))
+            {
                 if (fs::is_regular_file(entry) && entry.path().extension() == ".tgz")
                     if (entry.path().filename().string().find(service_info.template_name) != std::string::npos)
                     {
@@ -153,8 +204,6 @@ std::set<std::string> list_backups(const std::string &server_name, const std::st
         return backups;
     }
 
-
-
     bool get_all_service_env_vars(const std::string &server_name, const std::string &service_name, std::map<std::string, std::string> &all_env_vars)
     {
         all_env_vars.clear();
@@ -165,22 +214,11 @@ bool get_all_service_env_vars(const std::string &server_name, const std::string
             return false;
         }
 
-    ServerInfo server_info = get_server_info(server_name);
-    if (server_info.ssh_host.empty()) 
-        std::cerr << "Error: Server " << server_name << " not found - ssh_host empty, so HOST_NAME not set" << std::endl;
-
-    // add in some handy variables.
-    // if we change these, we also need to update agent/_allservicesstatus.sh
-    all_env_vars["CONFIG_PATH"] = remotepath::service_config(server_name,service_name);
-    all_env_vars["SERVER"] = server_name;
-    all_env_vars["SERVICE"] = service_name;
-    all_env_vars["AGENT_PATH"] = remotepath::agent(server_name);
-    all_env_vars["HOST_NAME"] = server_info.ssh_host;
-    all_env_vars["DOCKER_CLI_HINTS"] = "false"; // turn off docker junk.
-
         // Lambda function to load environment variables from a file
-    auto load_env_file = [&all_env_vars](const std::string& file) {
+        auto load_env_file = [&all_env_vars](const std::string &file)
-        if (!file.empty() && std::filesystem::exists(file)) {
+        {
+            if (!file.empty() && std::filesystem::exists(file))
+            {
                 std::map<std::string, std::string> env_vars;
                 envmanager env_manager(file);
                 env_manager.load();
@@ -195,28 +233,41 @@ bool get_all_service_env_vars(const std::string &server_name, const std::string
         load_env_file(localfile::service_env(server_name, service_name));
         load_env_file(localfile::template_info_env(server_name, service_name));
 
+        std::string user = all_env_vars["SSH_USER"];
+        if (user.empty())
+        {
+            error << "SSH_USER variable not defined in service " << service_name << " on server " << server_name << std::endl;
+            info << "This variable definition is always required, and usually set in the "<<filenames::service_env << " file." << std::endl;
+            info << "Please check " << localfile::service_env(server_name, service_name) << std::endl;
+            return false;
+        }
+
+        // add in some handy variables.
+        // if we change these, we also need to update agent/_allservicesstatus.sh
+        all_env_vars["CONFIG_PATH"] = remotepath(server_name, user).service_config(service_name);
+        all_env_vars["SERVER"] = server_name;
+        all_env_vars["SERVICE"] = service_name;
+        all_env_vars["AGENT_PATH"] = remotepath(server_name, user).agent();
+        all_env_vars["DOCKER_CLI_HINTS"] = "false"; // turn off docker junk.
+
         // determine template name.
         auto it = all_env_vars.find("TEMPLATE");
-    if (it == all_env_vars.end()) {
+        if (it == all_env_vars.end())
+        {
             error << "TEMPLATE variable not defined in service " << service_name << " on server " << server_name << std::endl;
             info << "The TEMPLATE variable is required to determine the template name." << std::endl;
-        info << "Please check the service.env file and the .template_info.env file in:" << std::endl;
+            info << "Please check the " << filenames::service_env << " file and the "<< filenames::template_info_env << " file in:" << std::endl;
-        info << "    " << localpath::service(server_name, service_name) << std::endl << std::endl;
+            info << "    " << localpath::service(server_name, service_name) << std::endl
+                 << std::endl;
             return false;
         }
         template_info tinfo = gTemplateManager().get_template_info(it->second);
-    if (!tinfo.is_set()) {
+        if (!tinfo.is_set())
+        {
             std::cerr << "Error: Template '" << it->second << "' not found" << std::endl;
             return false;
         }
 
-    std::string default_env_file = tinfo.local_template_path()/"_default.env";
-    if (!fs::exists(default_env_file)) {
-        std::cerr << "Error: Template default env file '" << default_env_file << "' not found" << std::endl;
-        return false;
-    }
-
-    load_env_file(default_env_file);
         return true;
     }
 

source/src/services.hpp

@@ -13,6 +13,11 @@ namespace dropshell {
         std::string template_name;
         std::string local_service_path;
         std::string local_template_path;
+        std::string user;
+        bool requires_host_root;
+        bool requires_docker;
+        bool requires_docker_root;
+        bool service_template_hash_match;
     };
     
     bool SIvalid(const LocalServiceInfo& service_info);
@@ -27,6 +32,7 @@ namespace dropshell {
 
     // list all backups for a given service (across all servers)
     std::set<std::string> list_backups(const std::string& server_name, const std::string& service_name);
+
 } // namespace dropshell
 
 #endif

source/src/templates.cpp

@@ -13,6 +13,7 @@
     #include "utils/utils.hpp"
     #include "templates.hpp"
     #include "config.hpp"   
+    #include "utils/hash.hpp"
 
     namespace dropshell {
 
@@ -219,9 +220,9 @@
         // modify the TEMPLATE=example line in the .template_info.env file to TEMPLATE=<template_name>
         std::string search_string = "TEMPLATE=";
         std::string replacement_line = "TEMPLATE=" + template_name;
-        std::string service_env_path = new_template_path + "/config/.template_info.env";
+        std::string service_env_path = new_template_path + "/config/" + filenames::template_info_env;
         if (!replace_line_in_file(service_env_path, search_string, replacement_line)) {
-            std::cerr << "Error: Failed to replace TEMPLATE= line in the .template_info.env file" << std::endl;
+            std::cerr << "Error: Failed to replace TEMPLATE= line in the " << filenames::template_info_env <<" file" << std::endl;
             return false;
         }
 
@@ -305,9 +306,8 @@
         std::string template_name = std::filesystem::path(template_path).filename().string();
 
         std::vector<std::string> required_files = {
-            "config/service.env",
+            "config/" + filenames::service_env,
-            "config/.template_info.env",
+            "config/" + filenames::template_info_env,
-            "_default.env",
             "install.sh",
             "uninstall.sh"
         };
@@ -331,8 +331,8 @@
         // check TEMPLATE= line.
         std::map<std::string, std::string> all_env_vars;
         std::vector<std::string> env_files = {
-            "config/service.env",
+            "config/" + filenames::service_env,
-            "config/.template_info.env"
+            "config/" + filenames::template_info_env
         };
         for (const auto& file : env_files) {
             { // load service.env from the service on this machine.
@@ -376,8 +376,16 @@
         mLocationID(location_id),
         mTemplateLocalPath(local_template_path),
         mTemplateValid(template_manager::test_template(local_template_path.string())),
-        mIsSet(!template_name.empty() && !location_id.empty() && !local_template_path.empty())
+        mIsSet(!template_name.empty() && !location_id.empty() && !local_template_path.empty()),\
+        mHash(0)
     {
+        if (!std::filesystem::exists(local_template_path))
+        {
+            error << "Template path does not exist: " << local_template_path << std::endl;
+            return;
+        }
+    
+        mHash = hash_directory_recursive(local_template_path);
     }
 
     } // namespace dropshell

source/src/templates.hpp

@@ -4,7 +4,9 @@
 #include <memory>
 #include <set>
 
-#include "utils/json.hpp"
+#define JSON_INLINE_ALL
+#include "json.hpp"
+
 
 namespace dropshell {
 
@@ -24,12 +26,15 @@ class template_info {
         std::string locationID() const { return mLocationID; }
         std::filesystem::path local_template_path() const { return mTemplateLocalPath; }
         bool template_valid() const { return mTemplateValid; }
+        uint64_t hash() const { return mHash; }
+
     private:
         std::string mTemplateName;
         std::string mLocationID;
         std::filesystem::path mTemplateLocalPath; // source or cache.
         bool mTemplateValid;
         bool mIsSet;
+        uint64_t mHash;
 };
 
 class template_source_interface {

source/src/utils/assert.hpp

@@ -9,4 +9,5 @@
         std::exit(1); \
     }
 
+
 #endif // ASSERT_HPP

source/src/utils/directories.cpp

@@ -1,6 +1,6 @@
 #include "directories.hpp"
 #include "config.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "output.hpp"
 
 #include <iostream>
@@ -19,7 +19,7 @@ namespace localfile {
         // Try ~/.config/dropshell/dropshell.json
         std::string homedir = localpath::current_user_home();
         if (!homedir.empty()) {
-            fs::path user_path = fs::path(homedir) / ".config" / "dropshell" /  "dropshell.json";
+            fs::path user_path = fs::path(homedir) / ".config" / "dropshell" / filenames::dropshell_json;
             return user_path.string();
         }
         return std::string();
@@ -27,18 +27,18 @@ namespace localfile {
 
     std::string server_json(const std::string &server_name) {
         std::string serverpath = localpath::server(server_name);
-        return (serverpath.empty() ? "" : (fs::path(serverpath) / "server.json").string());
+        return (serverpath.empty() ? "" : (fs::path(serverpath) / filenames::server_json).string());
     }
 
     std::string service_env(const std::string &server_name, const std::string &service_name) {
         std::string servicepath = localpath::service(server_name, service_name);
-        return (servicepath.empty() ? "" : (fs::path(servicepath) / "service.env").string());
+        return (servicepath.empty() ? "" : (fs::path(servicepath) / filenames::service_env).string());
     }
 
     std::string template_info_env(const std::string &server_name, const std::string &service_name)
     {
         std::string servicepath = localpath::service(server_name, service_name);
-        return (servicepath.empty() ? "" : (fs::path(servicepath) / ".template_info.env").string());
+        return (servicepath.empty() ? "" : (fs::path(servicepath) / filenames::template_info_env).string());
     }
 
     std::string template_example()
@@ -154,78 +154,70 @@ namespace localpath {
     //           |-- config
     //               |-- service.env (actual service config)
     //           |-- template
-    //               |-- _default.env
     //               |-- (script files)
     //               |-- config
     //                   |-- service.env (default service config)
     //                   |-- (other config files for specific server&service)
 
 
+    remotefile::remotefile(const std::string &server_name, const std::string &user) : 
+        mServer_name(server_name), mUser(user) {}
 
-namespace remotefile {
+    std::string remotefile::service_env(const std::string &service_name) const
-
-    std::string service_env(const std::string &server_name, const std::string &service_name)
     {
-        return remotepath::service_config(server_name, service_name) + "/service.env";
+        return remotepath(mServer_name,mUser).service_config(service_name) + "/" + filenames::service_env;
     }
 
+
+    remotepath::remotepath(const std::string &server_name, const std::string &user) : mServer_name(server_name), mUser(user) {}
+
+    std::string remotepath::DROPSHELL_DIR() const
+    {            
+        return server_config(mServer_name).get_user_dir(mUser);
     }
 
-namespace remotepath {
+    std::string remotepath::services() const
-    std::string DROPSHELL_DIR(const std::string &server_name)
     {
-        return server_env_manager(server_name).get_DROPSHELL_DIR();
+        std::string dsp = DROPSHELL_DIR();
-    }
-
-    std::string services(const std::string &server_name)
-    {
-        std::string dsp = DROPSHELL_DIR(server_name);
         return (dsp.empty() ? "" : (dsp + "/services"));
     }
 
-    std::string service(const std::string &server_name, const std::string &service_name)
+    std::string remotepath::service(const std::string &service_name) const
     {
-        std::string services_path = services(server_name);
+        std::string services_path = services();
         return (services_path.empty() ? "" : (services_path + "/" + service_name));
     }
 
-    std::string service_config(const std::string &server_name, const std::string &service_name) 
+    std::string remotepath::service_config(const std::string &service_name) const
     {
-        std::string service_path = service(server_name, service_name);
+        std::string service_path = service(service_name);
         return (service_path.empty() ? "" : (service_path + "/config"));
     }
 
-    std::string service_template(const std::string &server_name, const std::string &service_name) 
+    std::string remotepath::service_template(const std::string &service_name) const
     {
-        std::string service_path = service(server_name, service_name);
+        std::string service_path = service(service_name);
         return (service_path.empty() ? "" : (service_path + "/template"));
     }
 
-    std::string backups(const std::string &server_name) 
+    std::string remotepath::backups() const
     {
-        std::string dsp = DROPSHELL_DIR(server_name);
+        std::string dsp = DROPSHELL_DIR();
         return (dsp.empty() ? "" : (dsp + "/backups"));
     }
 
-    std::string temp_files(const std::string &server_name)
+    std::string remotepath::temp_files() const
     {
-        std::string dsp = DROPSHELL_DIR(server_name);
+        std::string dsp = DROPSHELL_DIR();
         return (dsp.empty() ? "" : (dsp + "/temp_files"));
     }
 
-    std::string agent(const std::string &server_name)
+    std::string remotepath::agent() const
     {
-        std::string dsp = DROPSHELL_DIR(server_name);
+        std::string dsp = DROPSHELL_DIR();
         return (dsp.empty() ? "" : (dsp + "/agent"));
     }
 
-    std::string service_env(const std::string &server_name, const std::string &service_name) 
-    {
-        std::string service_path = service_config(server_name, service_name);
-        return (service_path.empty() ? "" : (service_path + "/service.env"));
-    }
-} // namespace remotepath
-
 
 // ------------------------------------------------------------------------------------------
 // Utility functions

source/src/utils/directories.hpp

@@ -30,13 +30,10 @@ namespace dropshell {
     //        |   |-- <template_name>.json
     //        |   |-- <template_name>
     //        |       |-- (...script files...)
-    //        |       |-- _default.env
     //        |       |-- config
     //        |           |-- service.env
     //        |           |-- .template_info.env
     //        |           |-- (...other service config files...)
-    //        |-- remote_versions
-    //        |   |-- server_name-service_name.json
 
     // server_definition_path
     //    |-- <server_name>
@@ -47,7 +44,13 @@ namespace dropshell {
     //                |-- .template_info.env
     //                |-- (...other config files for specific server&service...)
     
-
+    namespace filenames {
+        static const std::string template_info_env = ".template_info.env";
+        static const std::string service_env = "service.env";
+        static const std::string readme = "README.txt";
+        static const std::string server_json = "server.json";
+        static const std::string dropshell_json = "dropshell.json";
+    } // namespace filenames.
 
     namespace localfile {
         // ~/.config/dropshell/dropshell.json
@@ -92,27 +95,36 @@ namespace dropshell {
     //               |-- service.env (actual service config)
     //               |-- .template_info.env
     //           |-- template
-    //               |-- _default.env
     //               |-- (script files)
     //               |-- config
     //                   |-- service.env (default service config)
     //                   |-- .template_info.env
     //                   |-- (other config files for specific server&service)
 
-    namespace remotefile {
+    class remotefile {
-        std::string service_env(const std::string &server_name, const std::string &service_name);
+        public:
-    } // namespace remotefile
+            remotefile(const std::string &server_name, const std::string &user);
+            std::string service_env(const std::string &service_name) const;
+        private:
+            std::string mServer_name;
+            std::string mUser;
+    };
 
-    namespace remotepath {
+    class remotepath {
-        std::string DROPSHELL_DIR(const std::string &server_name);
+        public: 
-        std::string services(const std::string &server_name);
+            remotepath(const std::string &server_name, const std::string &user);
-        std::string service(const std::string &server_name, const std::string &service_name);
+            std::string DROPSHELL_DIR() const;
-        std::string service_config(const std::string &server_name, const std::string &service_name);
+            std::string services() const;
-        std::string service_template(const std::string &server_name, const std::string &service_name);
+            std::string service(const std::string &service_name) const;
-        std::string backups(const std::string &server_name);
+            std::string service_config(const std::string &service_name) const;
-        std::string temp_files(const std::string &server_name);
+            std::string service_template(const std::string &service_name) const;
-        std::string agent(const std::string &server_name);
+            std::string backups() const;
-    } // namespace remotepath
+            std::string temp_files() const;
+            std::string agent() const;
+        private:
+            std::string mServer_name;
+            std::string mUser;
+    };
 
     //------------------------------------------------------------------------------------------------
     // utility functions

source/src/utils/execute.cpp

@@ -165,13 +165,13 @@ namespace dropshell
             return false;
 
         std::stringstream ssh_cmd;
-        ssh_cmd << "ssh -p " << ssh_info.port << " " << (hasFlag(mode, cMode::Interactive) ? "-tt " : "")
+        ssh_cmd << "ssh -p " << ssh_info.get_port() << " " << (hasFlag(mode, cMode::Interactive) ? "-tt " : "")
-                << ssh_info.user << "@" << ssh_info.host;
+                << ssh_info.get_user() << "@" << ssh_info.get_host();
 
         std::string remote_bb64_path;
 
         if (!hasFlag(mode, cMode::NoBB64))
-            remote_bb64_path = remotepath::agent(ssh_info.server_ID) + "/bb64";
+            remote_bb64_path = remotepath(ssh_info.get_server_ID(), ssh_info.get_user()).agent() + "/bb64";
 
         bool rval = execute_local_command(
             "",                                                                    // local directory to run in
@@ -237,4 +237,15 @@ namespace dropshell
         return cmdstr;
     }
 
+    bool sSSHInfo::valid() const
+    {
+    if (host.empty() || user.empty() || port.empty() || server_ID.empty() || user_dir.empty())
+        return false;
+
+    if (atoi(port.c_str()) == 0)
+        return false;
+
+    return true;
+    }
+
 } // namespace dropshell

source/src/utils/execute.hpp

@@ -24,12 +24,25 @@ inline cMode operator|=(cMode & lhs, cMode rhs) {return lhs = lhs | rhs;}
 inline bool hasFlag(cMode mode, cMode flag) {return (mode & flag) == flag;}
 
 
-typedef struct sSSHInfo {
+class sSSHInfo {
+    public:
+        sSSHInfo(std::string host, std::string user, std::string port, std::string server_ID, std::string user_dir) : 
+            host(host), user(user), port(port), server_ID(server_ID), user_dir(user_dir) {}
+
+        std::string get_host() const { return host; }
+        std::string get_user() const { return user; }
+        std::string get_port() const { return port; }
+        std::string get_server_ID() const { return server_ID; }
+        std::string get_user_dir() const { return user_dir; }
+
+        bool valid() const;
+    private:
         std::string host;
         std::string user;
         std::string port;
         std::string server_ID; // dropshell name for server.
-} sSSHInfo;
+        std::string user_dir; // dropshell directory for the user.
+};
 
 bool execute_local_command(std::string directory_to_run_in, std::string command_to_run, const std::map<std::string, std::string> & env_vars, std::string * output = nullptr, cMode mode = cMode::Defaults);
 bool execute_ssh_command(const sSSHInfo & ssh_info, const sCommand & remote_command, cMode mode = cMode::Defaults, std::string * output = nullptr);

source/src/utils/utils.cpp

@@ -9,6 +9,7 @@
 #include <random>
 #include <sys/ioctl.h>
 #include <unistd.h>
+#include <cctype>
 
 namespace dropshell {
 
@@ -432,4 +433,16 @@ std::string get_line_wrap(std::string &src, int maxchars)
     return remove_return(out) + '\n';
 }
 
+std::string tolower(const std::string& str) {
+    if (str.empty()) return str;
+    
+    std::string result;
+    result.reserve(str.size());  // Pre-allocate space for efficiency
+    
+    for (unsigned char c : str) {
+        result.push_back(std::tolower(c));
+    }
+    return result;
+}
+
 } // namespace dropshell 

source/src/utils/utils.hpp

@@ -59,4 +59,6 @@ int get_console_width();
 
 std::string get_line_wrap(std::string & src, int maxchars);
 
+std::string tolower(const std::string& str);
+
 } // namespace dropshell