exec command, and remote execution improvements!

source/src/commands/exec.cpp

@@ -0,0 +1,137 @@
+#include "command_registry.hpp"
+#include "config.hpp"
+#include "utils/utils.hpp"
+#include "utils/directories.hpp"
+#include "utils/execute.hpp"
+#include "shared_commands.hpp"
+#include "servers.hpp"
+#include "services.hpp"
+#include "templates.hpp"
+#include "utils/output.hpp"
+#include <libassert/assert.hpp>
+
+namespace dropshell
+{
+
+    int exec_handler(const CommandContext &ctx);
+
+    static std::vector<std::string> exec_name_list = {"exec"};
+
+    // Static registration
+    struct ExecCommandRegister
+    {
+        ExecCommandRegister()
+        {
+            CommandRegistry::instance().register_command({exec_name_list,
+                                                          exec_handler,
+                                                          shared_commands::std_autocomplete,
+                                                          false, // hidden
+                                                          true,  // requires_config
+                                                          true,  // requires_install
+                                                          3,     // min_args (server, service, command)
+                                                          -1,    // max_args (unlimited for command with args)
+                                                          "exec SERVER SERVICE COMMAND [ARGS...]",
+                                                          "Execute a command on a server within a service environment.",
+                                                          R"(
+                
+                exec SERVER SERVICE COMMAND [ARGS...]     Execute a command in the service's environment.
+                
+                This command runs a command on the remote server with the service's environment
+                variables loaded (including those from service.env and the usual variables).
+                The command is executed in the service's template directory context.
+                )"});
+        }
+    } exec_command_register;
+
+    int exec_handler(const CommandContext &ctx)
+    {
+        if (ctx.args.size() < 3)
+        {
+            error << "Server name, service name, and command are required" << std::endl;
+            return 1;
+        }
+
+        std::string server = safearg(ctx.args, 0);
+        std::string service = safearg(ctx.args, 1);
+        std::string command = safearg(ctx.args, 2);
+        
+        // Collect any additional arguments for the command
+        std::vector<std::string> command_args;
+        for (size_t i = 3; i < ctx.args.size(); ++i)
+        {
+            command_args.push_back(ctx.args[i]);
+        }
+
+        // Validate server
+        ServerConfig server_env(server);
+        if (!server_env.is_valid())
+        {
+            error << "Server " << server << " is not valid" << std::endl;
+            return 1;
+        }
+
+        // Validate service name
+        if (!legal_service_name(service))
+        {
+            error << "Service name contains illegal characters: " << service << std::endl;
+            return 1;
+        }
+
+        // Get service info to validate it exists
+        LocalServiceInfo sinfo = get_service_info(server, service);
+        if (!SIvalid(sinfo))
+        {
+            error << "Service " << service << " is not valid on server " << server << std::endl;
+            return 1;
+        }
+
+        // Get the user for this service
+        std::string user = server_env.get_user_for_service(service);
+        
+        // Get all service environment variables
+        std::map<std::string, std::string> env_vars;
+        if (!get_all_service_env_vars(server, service, env_vars))
+        {
+            error << "Failed to get environment variables for service " << service << std::endl;
+            return 1;
+        }
+        
+        // Add HOST_NAME like other commands do
+        env_vars["HOST_NAME"] = server_env.get_SSH_HOST();
+        
+        // Get the remote service template path for working directory
+        std::string remote_service_template_path = remotepath(server, user).service_template(service);
+        
+        // Build the command string with arguments
+        std::string full_command = command;
+        for (const auto &arg : command_args)
+        {
+            full_command += " " + quote(dequote(trim(arg)));
+        }
+        
+        // Create the command structure with environment variables
+        // Note: execute_ssh_command will automatically use bb64 to encode and execute this safely
+        sCommand scommand(remote_service_template_path, full_command, env_vars);
+        
+        // Execute the command on the remote server
+        info << "Executing command on " << server << "/" << service << ": " << command;
+        if (!command_args.empty())
+        {
+            rawout << " with args:";
+            for (const auto &arg : command_args)
+                rawout << " " << arg;
+        }
+        rawout << std::endl;
+        
+        bool success = execute_ssh_command(server_env.get_SSH_INFO(user), scommand, cMode::Interactive);
+        
+        if (!success)
+        {
+            error << "Command execution failed" << std::endl;
+            return 1;
+        }
+        
+        return 0;
+    }
+
+} // namespace dropshell