Added Remote SSH Support.

Author: TheCompez

.gitignore

@@ -33,6 +33,10 @@
 
 #Extra
 .DS_Store
+CMakeLists.txt.user
 
 # Final Output
-build/ProjectTemplate
+build/
+third-party/
+
+.cache

source/entrypoint/stl/main.cpp

@@ -1,4 +1,5 @@
 #include "fcli.hpp"
+#include "remoteexecutor.hpp" // Include the RemoteExecutor module
 
 /**
  * @brief Entry point for the FCLI application.
@@ -13,6 +14,35 @@
 auto main(int argc, char* argv[]) -> int {
     try {
         FCLI fcli;
+
+        // Check for remote execution flags
+        if (argc > 1) {
+            std::string mode = argv[1];
+            if (mode == "--remote-ssh" && argc == 6) {
+                std::string user = argv[2];
+                std::string host = argv[3];
+                std::string keyPath = argv[4];
+                std::string command = argv[5];
+
+                // Execute remote command via SSH
+                std::string output = RemoteExecutor::executeSSH(host, user, command, keyPath);
+                Logger::info("Remote SSH Execution Output:");
+                Logger::info(output);
+                return 0; // Success
+            } else if (mode == "--remote-api" && argc == 5) {
+                std::string url = argv[2];
+                std::string token = argv[3];
+                std::string command = argv[4];
+
+                // Execute remote command via API
+                std::string output = RemoteExecutor::executeAPI(url, command, token);
+                Logger::info("Remote API Execution Output:");
+                Logger::info(output);
+                return 0; // Success
+            }
+        }
+
+        // Standard CLI execution
         fcli.run(argc, argv);
     } catch (const std::exception& e) {
         Logger::error(std::format("An unexpected error occurred: {}", e.what()));

source/remoteexecutor.cpp

@@ -0,0 +1,45 @@
+#include "remoteexecutor.hpp"
+#include <iostream>
+#include <cstdlib>
+#include <sstream>
+
+std::string RemoteExecutor::executeSSH(const std::string& host, const std::string& user,
+                                       const std::string& command, const std::string& keyPath) {
+    std::ostringstream oss;
+    oss << "ssh -i " << keyPath << " " << user << "@" << host << " \"" << command << "\"";
+
+    FILE* pipe = popen(oss.str().c_str(), "r");
+    if (!pipe) {
+        throw std::runtime_error("Failed to execute SSH command");
+    }
+
+    char buffer[128];
+    std::string result;
+    while (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
+        result += buffer;
+    }
+
+    pclose(pipe);
+    return result;
+}
+
+std::string RemoteExecutor::executeAPI(const std::string& url, const std::string& command,
+                                       const std::string& token) {
+    std::ostringstream oss;
+    oss << "curl -X POST -H \"Authorization: Bearer " << token << "\" "
+        << "-d \"command=" << command << "\" " << url;
+
+    FILE* pipe = popen(oss.str().c_str(), "r");
+    if (!pipe) {
+        throw std::runtime_error("Failed to execute API command");
+    }
+
+    char buffer[128];
+    std::string result;
+    while (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
+        result += buffer;
+    }
+
+    pclose(pipe);
+    return result;
+}

source/remoteexecutor.hpp

@@ -0,0 +1,49 @@
+#ifndef REMOTE_EXECUTOR_HPP
+#define REMOTE_EXECUTOR_HPP
+
+#include <string>
+#include <stdexcept>
+
+/**
+ * @class RemoteExecutor
+ * @brief Provides functionality to execute commands remotely via SSH or API.
+ *
+ * This class offers static methods for executing shell commands on remote servers
+ * using SSH and interacting with APIs to execute commands remotely.
+ */
+class RemoteExecutor {
+public:
+    /**
+     * @brief Executes a command on a remote server via SSH.
+     *
+     * This method establishes an SSH connection to the specified host using the given
+     * user credentials and private key. It then executes the provided command remotely
+     * and captures the output.
+     *
+     * @param host The hostname or IP address of the remote server.
+     * @param user The username for the SSH connection.
+     * @param command The shell command to execute on the remote server.
+     * @param keyPath The path to the private key file for SSH authentication.
+     * @return The output of the command executed on the remote server.
+     * @throws std::runtime_error If the SSH command execution fails.
+     */
+    static std::string executeSSH(const std::string& host, const std::string& user,
+                                  const std::string& command, const std::string& keyPath);
+
+    /**
+     * @brief Executes a command via an API.
+     *
+     * This method sends a POST request to the specified API URL with the provided command
+     * as a parameter. Authentication is performed using a bearer token.
+     *
+     * @param url The API endpoint URL.
+     * @param command The command or data to send to the API for execution.
+     * @param token The bearer token for API authentication.
+     * @return The response from the API.
+     * @throws std::runtime_error If the API request fails.
+     */
+    static std::string executeAPI(const std::string& url, const std::string& command,
+                                  const std::string& token);
+};
+
+#endif // REMOTE_EXECUTOR_HPP