docs: Add 2 and update 2 files

source/src/commands/hostinfo.cpp

@@ -0,0 +1,171 @@
+#include "command_registry.hpp"
+#include "servers.hpp"
+#include "utils/output.hpp"
+#include "utils/execute.hpp"
+#include "utils/directories.hpp"
+#include "shared_commands.hpp"
+#include "tableprint.hpp"
+
+#include <nlohmann/json.hpp>
+#include <libassert/assert.hpp>
+#include <cstdio>
+
+namespace dropshell {
+
+int hostinfo_handler(const CommandContext &ctx);
+
+static std::vector<std::string> hostinfo_name_list = {"hostinfo", "sysinfo"};
+
+void hostinfo_autocomplete(const CommandContext &ctx) {
+    if (ctx.args.size() == 0) {
+        std::vector<ServerConfig> servers = get_configured_servers();
+        for (const auto &server : servers)
+            rawout << server.get_server_name() << std::endl;
+    }
+}
+
+struct HostinfoCommandRegister {
+    HostinfoCommandRegister() {
+        CommandRegistry::instance().register_command({
+            hostinfo_name_list,
+            hostinfo_handler,
+            hostinfo_autocomplete,
+            false, // hidden
+            true,  // requires_config
+            true,  // requires_install
+            1,     // min_args
+            1,     // max_args
+            "hostinfo SERVER",
+            "Display hardware and system information for a remote server.",
+            R"(
+Display hardware and system information for a remote server.
+  hostinfo SERVER    Show CPU, motherboard, GPU, RAM, disk usage,
+                     IP addresses, OS, kernel, uptime, and Docker version.
+            )"
+        });
+    }
+} hostinfo_command_register;
+
+int hostinfo_handler(const CommandContext &ctx) {
+    std::string server_name = ctx.args[0];
+
+    ServerConfig server_env(server_name);
+    if (!server_env.is_valid()) {
+        error << "Server '" << server_name << "' is not valid." << std::endl;
+        return 1;
+    }
+
+    ASSERT(server_env.get_users().size() > 0, "No users found for server " + server_name);
+    std::string user = server_env.get_users()[0].user;
+
+    std::string agent_path = remotepath(server_name, user).agent();
+    std::string script_path = agent_path + "/hostinfo.sh";
+
+    std::string output;
+    sCommand cmd(agent_path, script_path, {});
+    bool success = execute_ssh_command(server_env.get_SSH_INFO(user), cmd, cMode::Silent, &output);
+
+    if (!success || output.empty()) {
+        error << "Failed to retrieve host information from " << server_name << std::endl;
+        return 1;
+    }
+
+    nlohmann::json j;
+    try {
+        j = nlohmann::json::parse(output);
+    } catch (const nlohmann::json::parse_error &e) {
+        error << "Failed to parse host info: " << e.what() << std::endl;
+        debug << "Output was: " << output << std::endl;
+        return 1;
+    }
+
+    auto get_str = [&](const std::string &key) -> std::string {
+        if (j.contains(key) && j[key].is_string()) {
+            std::string val = j[key].get<std::string>();
+            return val.empty() ? "-" : val;
+        }
+        return "-";
+    };
+
+    // Format RAM as "X.X / Y.Y GB"
+    std::string ram_display = "-";
+    {
+        std::string used = get_str("ram_used_mb");
+        std::string total = get_str("ram_total_mb");
+        if (used != "-" && total != "-") {
+            try {
+                int used_mb = std::stoi(used);
+                int total_mb = std::stoi(total);
+                char buf[64];
+                snprintf(buf, sizeof(buf), "%.1f / %.1f GB",
+                         used_mb / 1024.0, total_mb / 1024.0);
+                ram_display = buf;
+            } catch (...) {}
+        }
+    }
+
+    // Format disk root
+    std::string disk_root_display = "-";
+    {
+        std::string used = get_str("disk_root_used_gb");
+        std::string total = get_str("disk_root_total_gb");
+        if (used != "-" && total != "-")
+            disk_root_display = used + " / " + total + " GB";
+    }
+
+    // Format disk /tank (only if present)
+    std::string disk_tank_display;
+    {
+        std::string used = get_str("disk_tank_used_gb");
+        std::string total = get_str("disk_tank_total_gb");
+        if (used != "-" && total != "-")
+            disk_tank_display = used + " / " + total + " GB";
+    }
+
+    // Format GPU list
+    std::string gpu_display = "-";
+    if (j.contains("gpu") && j["gpu"].is_array() && !j["gpu"].empty()) {
+        gpu_display.clear();
+        for (size_t i = 0; i < j["gpu"].size(); ++i) {
+            if (i > 0) gpu_display += ", ";
+            gpu_display += j["gpu"][i].get<std::string>();
+        }
+    }
+
+    // Format CPU with cores
+    std::string cpu_display = get_str("cpu");
+    std::string cores = get_str("cpu_cores");
+    if (cores != "-")
+        cpu_display += " (" + cores + " cores)";
+
+    // Format IP addresses on one line
+    std::string ip_display = get_str("ip_local");
+    {
+        std::string ts = get_str("ip_tailscale");
+        std::string pub = get_str("ip_public");
+        if (ts != "-") ip_display += "  ts:" + ts;
+        if (pub != "-") ip_display += "  pub:" + pub;
+    }
+
+    // Display
+    tableprint tp("Host Info: " + server_name, true);
+    tp.add_row({"Property", "Value"});
+    tp.add_row({"Hostname", get_str("hostname")});
+    tp.add_row({"OS", get_str("os")});
+    tp.add_row({"Kernel", get_str("kernel")});
+    tp.add_row({"Uptime", get_str("uptime")});
+    tp.add_row({"CPU", cpu_display});
+    tp.add_row({"Motherboard", get_str("motherboard")});
+    tp.add_row({"GPU", gpu_display});
+    tp.add_row({"RAM", ram_display});
+    tp.add_row({"Disk /", disk_root_display});
+    if (!disk_tank_display.empty())
+        tp.add_row({"Disk /tank", disk_tank_display});
+    tp.add_row({"IP Addresses", ip_display});
+    tp.add_row({"Docker", get_str("docker_version")});
+    tp.print();
+
+    return 0;
+}
+
+} // namespace dropshell