.

src/utils/execute.cpp

@@ -32,7 +32,8 @@ bool execute_local_command_interactive(const sCommand &command, bool silent)
         return false;
     } else if (pid == 0) {
         // Child process
-        std::vector<const char *> commandvec = {"bash", "-c", full_command.c_str(),NULL};
+        ASSERT(full_command.find("'") == std::string::npos, "Raw command must not contain single quotes");
+        std::vector<const char *> commandvec = {"bash", "-c", halfquote(full_command).c_str(),NULL};
 
         if (!silent) {
             std::cout << "Executing command: ";
@@ -121,28 +122,17 @@ bool execute_ssh_command(const sSSHInfo &ssh_info, const sCommand &command, cMod
     ssh_cmd << "ssh -p " << ssh_info.port << " " << (hasFlag(mode, cMode::Interactive) ? "-tt " : "")
             << ssh_info.user << "@" << ssh_info.host;
 
-    std::string cmdstr;
+    std::string cmdstr = command.construct_cmd(is_raw(mode) ? cStyle::Raw : cStyle::Safe);
-    if (!is_raw(mode)) 
+    ASSERT(cmdstr.find("'") == std::string::npos, "Raw command must not contain single quotes");
-        cmdstr = quote("bash -c " + command.construct_cmd(cStyle::Safe));
+    cmdstr = "bash -c " + halfquote(cmdstr);    
-    else
-    {
-        std::string raw_cmd = command.construct_cmd(cStyle::Raw);
-        ASSERT(raw_cmd.find("'") == std::string::npos, "Raw command must not contain single quotes");
-        cmdstr = "bash -c "+ halfquote(raw_cmd);
-    }
-
     sCommand ssh_command(ssh_cmd.str() + " " + cmdstr);
 
     bool rval = execute_local_command(ssh_command, mode, output);
 
     if (!rval) {
         std::cerr <<std::endl<<std::endl;
-        std::cerr << "Error: Failed to execute ssh command: { [" << ssh_command.get_directory_to_run_in() << "], [";
+        std::cerr << "Error: Failed to execute ssh command:" << std::endl;
-        std::cerr << ssh_command.get_command_to_run() << "], [";
+        std::cerr << "\033[90m" << ssh_command.get_command_to_run() << "\033[0m" << std::endl;
-        for (const auto& env_var : ssh_command.get_env_vars()) {
-            std::cerr << env_var.first << "=" << env_var.second << ", ";
-        }
-        std::cerr << "] }" << std::endl;
         std::cerr <<std::endl<<std::endl;
     }
     return rval;

src/utils/runner.cpp

@@ -1,363 +0,0 @@
-#include "runner.hpp"
-#include <cstdlib>
-#include <sstream>
-#include <iostream>
-#include <unistd.h>
-#include <sys/wait.h>
-#include <fcntl.h>
-#include <libssh/libssh.h>
-#include <libssh/callbacks.h>
-#include <termios.h>
-#include <sys/select.h>
-#include <algorithm>
-#include <cctype>
-
-namespace runner {
-
-namespace {
-
-// String trimming functions
-void ltrim(std::string& s) {
-    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {
-        return !std::isspace(ch);
-    }));
-}
-
-void rtrim(std::string& s) {
-    s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) {
-        return !std::isspace(ch);
-    }).base(), s.end());
-}
-
-void trim(std::string& s) {
-    ltrim(s);
-    rtrim(s);
-}
-
-// Safe version that handles nullptr
-void trim(std::string* s) {
-    if (s) {
-        trim(*s);
-    }
-}
-
-ssh_session ssh_connect_and_auth(const sSSHInfo* sshinfo, const std::map<std::string, std::string>& env, std::string* error) {
-    ssh_session session = ssh_new();
-    if (!session) {
-        if (error) *error = "Failed to create SSH session.";
-        return nullptr;
-    }
-    ssh_options_set(session, SSH_OPTIONS_HOST, sshinfo->host.c_str());
-    if (!sshinfo->port.empty()) {
-        int port = std::stoi(sshinfo->port);
-        ssh_options_set(session, SSH_OPTIONS_PORT, &port);
-    }
-    if (!sshinfo->user.empty()) {
-        ssh_options_set(session, SSH_OPTIONS_USER, sshinfo->user.c_str());
-    }
-    int rc = ssh_connect(session);
-    if (rc != SSH_OK) {
-        if (error) *error = std::string("SSH connection failed: ") + ssh_get_error(session);
-        ssh_free(session);
-        return nullptr;
-    }
-    rc = ssh_userauth_publickey_auto(session, nullptr, nullptr);
-    if (rc != SSH_AUTH_SUCCESS) {
-        auto it = env.find("SSHPASS");
-        if (it != env.end()) {
-            rc = ssh_userauth_password(session, nullptr, it->second.c_str());
-        }
-    }
-    if (rc != SSH_AUTH_SUCCESS) {
-        if (error) *error = std::string("SSH authentication failed: ") + ssh_get_error(session);
-        ssh_disconnect(session);
-        ssh_free(session);
-        return nullptr;
-    }
-    return session;
-}
-
-} // namespace runner
-
-// runner_local: non-interactive local command execution
-bool runner_local::execute() {
-    pid_t pid = fork();
-    if (pid == -1) {
-        std::cerr << "Failed to fork" << std::endl;
-        mReturnCode = -1;
-        return false;
-    }
-    if (pid == 0) {
-        // Child process
-        if (!mWorkingDir.empty()) {
-            if (chdir(mWorkingDir.c_str()) != 0) {
-                perror("chdir");
-                exit(127);
-            }
-        }
-        // Set environment variables
-        for (const auto& [k, v] : mEnv) {
-            setenv(k.c_str(), v.c_str(), 1);
-        }
-        // Build argv
-        std::vector<char*> argv;
-        argv.push_back(const_cast<char*>(mCommand.c_str()));
-        for (auto& arg : mArgs) argv.push_back(const_cast<char*>(arg.c_str()));
-        argv.push_back(nullptr);
-        if (mSilent) {
-            int fd = open("/dev/null", O_WRONLY);
-            if (fd != -1) {
-                dup2(fd, STDOUT_FILENO);
-                dup2(fd, STDERR_FILENO);
-                close(fd);
-            }
-        }
-
-        std::cout << "Executing command: " << mCommand << std::endl;    
-        std::cout << "Args: ";
-            for (auto& arg : mArgs) std::cout << "[" << arg << "] ";
-        std::cout << std::endl;
-
-        execvp(mCommand.c_str(), argv.data());
-        perror("execvp");
-        exit(127);
-    } else {
-        int status = 0;
-        waitpid(pid, &status, 0);
-        if (WIFEXITED(status)) {
-            mReturnCode = WEXITSTATUS(status);
-        } else {
-            mReturnCode = -1;
-        }
-        return mReturnCode == 0;
-    }
-}
-
-// runner_local_interactive: interactive local command execution
-bool runner_local_interactive::execute() {
-    pid_t pid = fork();
-    if (pid == -1) {
-        std::cerr << "Failed to fork" << std::endl;
-        mReturnCode = -1;
-        return false;
-    }
-    if (pid == 0) {
-        if (!mWorkingDir.empty()) {
-            if (chdir(mWorkingDir.c_str()) != 0) {
-                perror("chdir");
-                exit(127);
-            }
-        }
-        for (const auto& [k, v] : mEnv) {
-            setenv(k.c_str(), v.c_str(), 1);
-        }
-        std::vector<char*> argv;
-        argv.push_back(const_cast<char*>(mCommand.c_str()));
-        for (auto& arg : mArgs) argv.push_back(const_cast<char*>(arg.c_str()));
-        argv.push_back(nullptr);
-        // Attach to terminal (no redirection)
-        execvp(mCommand.c_str(), argv.data());
-        perror("execvp");
-        exit(127);
-    } else {
-        int status = 0;
-        waitpid(pid, &status, 0);
-        if (WIFEXITED(status)) {
-            mReturnCode = WEXITSTATUS(status);
-        } else {
-            mReturnCode = -1;
-        }
-        return mReturnCode == 0;
-    }
-}
-
-// runner_ssh: non-interactive SSH command execution
-bool runner_ssh::execute() {
-    std::string error;
-    ssh_session session = ssh_connect_and_auth(&mSSHInfo, mEnv, &error);
-    if (!session) {
-        std::cerr << error << std::endl;
-        mReturnCode = -1;
-        return false;
-    }
-    ssh_channel channel = ssh_channel_new(session);
-    if (!channel) {
-        std::cerr << "Failed to create SSH channel." << std::endl;
-        ssh_disconnect(session);
-        ssh_free(session);
-        mReturnCode = -1;
-        return false;
-    }
-    if (ssh_channel_open_session(channel) != SSH_OK) {
-        std::cerr << "Failed to open SSH channel: " << ssh_get_error(session) << std::endl;
-        ssh_channel_free(channel);
-        ssh_disconnect(session);
-        ssh_free(session);
-        mReturnCode = -1;
-        return false;
-    }
-    std::stringstream cmd;
-    cmd << mCommand;
-    for (const auto& arg : mArgs) {
-        cmd << " '" << arg << "'";
-    }
-    int rc = ssh_channel_request_exec(channel, cmd.str().c_str());
-    if (rc != SSH_OK) {
-        std::cerr << "SSH exec failed: " << ssh_get_error(session) << std::endl;
-        ssh_channel_close(channel);
-        ssh_channel_free(channel);
-        ssh_disconnect(session);
-        ssh_free(session);
-        mReturnCode = -1;
-        return false;
-    }
-    char buffer[256];
-    int nbytes;
-    while ((nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0)) > 0) {
-        if (!mSilent) std::cout.write(buffer, nbytes);
-    }
-    mReturnCode = ssh_channel_get_exit_status(channel);
-    ssh_channel_send_eof(channel);
-    ssh_channel_close(channel);
-    ssh_channel_free(channel);
-    ssh_disconnect(session);
-    ssh_free(session);
-    return mReturnCode == 0;
-}
-
-// runner_ssh_interactive: interactive SSH command execution
-bool runner_ssh_interactive::execute() {
-    std::string error;
-    ssh_session session = ssh_connect_and_auth(&mSSHInfo, mEnv, &error);
-    if (!session) {
-        std::cerr << error << std::endl;
-        mReturnCode = -1;
-        return false;
-    }
-    ssh_channel channel = ssh_channel_new(session);
-    if (!channel) {
-        std::cerr << "Failed to create SSH channel." << std::endl;
-        ssh_disconnect(session);
-        ssh_free(session);
-        mReturnCode = -1;
-        return false;
-    }
-    if (ssh_channel_open_session(channel) != SSH_OK) {
-        std::cerr << "Failed to open SSH channel: " << ssh_get_error(session) << std::endl;
-        ssh_channel_free(channel);
-        ssh_disconnect(session);
-        ssh_free(session);
-        mReturnCode = -1;
-        return false;
-    }
-    std::stringstream cmd;
-    cmd << mCommand;
-    for (const auto& arg : mArgs) {
-        cmd << " '" << arg << "'";
-    }
-    int rc = ssh_channel_request_pty(channel);
-    if (rc != SSH_OK) {
-        std::cerr << "Failed to request PTY: " << ssh_get_error(session) << std::endl;
-        ssh_channel_close(channel);
-        ssh_channel_free(channel);
-        ssh_disconnect(session);
-        ssh_free(session);
-        mReturnCode = -1;
-        return false;
-    }
-    rc = ssh_channel_request_shell(channel);
-    if (rc != SSH_OK) {
-        std::cerr << "Failed to request shell: " << ssh_get_error(session) << std::endl;
-        ssh_channel_close(channel);
-        ssh_channel_free(channel);
-        ssh_disconnect(session);
-        ssh_free(session);
-        mReturnCode = -1;
-        return false;
-    }
-    // Forward input/output between user and SSH channel
-    fd_set fds;
-    char buffer[256];
-    while (true) {
-        FD_ZERO(&fds);
-        FD_SET(0, &fds); // stdin
-        int ssh_fd = ssh_get_fd(session);
-        FD_SET(ssh_fd, &fds);
-        int maxfd = std::max(0, ssh_fd) + 1;
-        int ret = select(maxfd, &fds, nullptr, nullptr, nullptr);
-        if (ret < 0) break;
-        if (FD_ISSET(0, &fds)) {
-            int n = read(0, buffer, sizeof(buffer));
-            if (n > 0) ssh_channel_write(channel, buffer, n);
-        }
-        if (FD_ISSET(ssh_fd, &fds)) {
-            int n = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
-            if (n > 0) write(1, buffer, n);
-            else if (n == 0) break;
-        }
-        if (ssh_channel_is_closed(channel)) break;
-    }
-    mReturnCode = ssh_channel_get_exit_status(channel);
-    ssh_channel_send_eof(channel);
-    ssh_channel_close(channel);
-    ssh_channel_free(channel);
-    ssh_disconnect(session);
-    ssh_free(session);
-    return mReturnCode == 0;
-}
-
-// runner_ssh_capture: SSH command execution with output capture
-bool runner_ssh_capture::execute() {
-    std::string error;
-    ssh_session session = ssh_connect_and_auth(&mSSHInfo, mEnv, &error);
-    if (!session) {
-        std::cerr << error << std::endl;
-        mReturnCode = -1;
-        return false;
-    }
-    ssh_channel channel = ssh_channel_new(session);
-    if (!channel) {
-        std::cerr << "Failed to create SSH channel." << std::endl;
-        ssh_disconnect(session);
-        ssh_free(session);
-        mReturnCode = -1;
-        return false;
-    }
-    if (ssh_channel_open_session(channel) != SSH_OK) {
-        std::cerr << "Failed to open SSH channel: " << ssh_get_error(session) << std::endl;
-        ssh_channel_free(channel);
-        ssh_disconnect(session);
-        ssh_free(session);
-        mReturnCode = -1;
-        return false;
-    }
-    std::stringstream cmd;
-    cmd << mCommand;
-    for (const auto& arg : mArgs) {
-        cmd << " '" << arg << "'";
-    }
-    int rc = ssh_channel_request_exec(channel, cmd.str().c_str());
-    if (rc != SSH_OK) {
-        std::cerr << "SSH exec failed: " << ssh_get_error(session) << std::endl;
-        ssh_channel_close(channel);
-        ssh_channel_free(channel);
-        ssh_disconnect(session);
-        ssh_free(session);
-        mReturnCode = -1;
-        return false;
-    }
-    char buffer[256];
-    int nbytes;
-    mOutput.clear();
-    while ((nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0)) > 0) {
-        mOutput.append(buffer, nbytes);
-    }
-    mReturnCode = ssh_channel_get_exit_status(channel);
-    ssh_channel_send_eof(channel);
-    ssh_channel_close(channel);
-    ssh_channel_free(channel);
-    ssh_disconnect(session);
-    ssh_free(session);
-    return mReturnCode == 0;
-}
-} // namespace runner

src/utils/runner.hpp

@@ -1,81 +0,0 @@
-#ifndef RUNNER_HPP
-#define RUNNER_HPP
-
-
-#include <string>
-#include <vector>
-#include <map>
-
-namespace runner {
-
-struct sSSHInfo {
-    std::string host;
-    std::string user;
-    std::string port;
-};
-
-class runner {
-    public:
-        runner(std::string command, std::vector<std::string> args={}, std::string working_dir="", std::map<std::string, std::string> env={}, bool silent=false) :
-            mCommand(command),
-            mArgs(args),
-            mWorkingDir(working_dir),
-            mEnv(env),
-            mSilent(silent),
-            mReturnCode(0) {}
-        virtual ~runner() {}
-
-        virtual bool execute() = 0;
-
-        int return_code() const { return mReturnCode; }
-    protected:
-        std::string mCommand;
-        std::vector<std::string> mArgs;
-        std::string mWorkingDir;
-        std::map<std::string, std::string> mEnv;
-        bool mSilent;
-        int mReturnCode;
-};
-
-class runner_local : public runner {
-    public:
-        runner_local(std::string command, std::vector<std::string> args={}, std::string working_dir="", std::map<std::string, std::string> env={}, bool silent=false) : 
-            runner(command, args, working_dir, env, silent) {}
-        bool execute() override;
-};
-
-class runner_local_interactive : public runner {
-    public:
-        runner_local_interactive(std::string command, std::vector<std::string> args={}, std::string working_dir="", std::map<std::string, std::string> env={}) : 
-            runner(command, args, working_dir, env, false) {}
-        bool execute() override;
-};
-
-class runner_ssh : public runner {
-    public:
-        runner_ssh(const sSSHInfo sshinfo, std::string command, std::vector<std::string> args={}, std::string working_dir="", std::map<std::string, std::string> env={}, bool silent=false) : 
-            runner(command, args, working_dir, env, silent), mSSHInfo(sshinfo) {}   
-        bool execute() override;
-    protected:
-        const sSSHInfo mSSHInfo;
-};
-
-class runner_ssh_interactive : public runner_ssh {
-    public:
-        runner_ssh_interactive(const sSSHInfo sshinfo, std::string command, std::vector<std::string> args={}, std::string working_dir="", std::map<std::string, std::string> env={}, bool silent=true) : 
-            runner_ssh(sshinfo, command, args, working_dir, env, silent) {}
-        bool execute() override;
-};
-
-class runner_ssh_capture : public runner_ssh {
-    public:
-        runner_ssh_capture(const sSSHInfo sshinfo, std::string output, std::string command, std::vector<std::string> args={}, std::string working_dir="", std::map<std::string, std::string> env={}) : 
-            runner_ssh(sshinfo, command, args, working_dir, env, true), mOutput(output) {}
-        bool execute() override;
-    protected:
-        std::string & mOutput;
-};
-
-} // namespace runner
-
-#endif // RUNNER_HPP

templates/simple-object-storage/ports.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 source "${AGENT_PATH}/_common.sh"
-_check_required_env_vars
+_check_required_env_vars "CONFIG_PATH"
 
 # PORT SCRIPT
 # The port script is OPTIONAL.