Modify getpkg/src/GetbinClient.cpp.bak

README.md

@@ -60,6 +60,8 @@ getpkg version
 
 ### Information
 
+- **`getpkg list`** - List all available packages with status
+- **`getpkg clean`** - Clean up orphaned configs and symlinks  
 - **`getpkg version`** - Show getpkg version
 - **`getpkg help`** - Show detailed help
 - **`getpkg autocomplete`** - Show available commands for completion
@@ -99,14 +101,14 @@ Tools are automatically downloaded for your architecture, with fallback to unive
 ### Installing Popular Tools
 
 ```bash
-# Install development tools
+# Install available tools
-getpkg whatsdirty        # Fast grep alternative
+getpkg install dehydrate      # File to C++ code generator
-getpkg fd             # Fast find alternative
+getpkg install bb64           # Bash base64 encoder/decoder
-getpkg bat            # Cat with syntax highlighting
 
-# Install system utilities
+# Development tools (for repository development)
-getpkg whatsdirty     # Check git repo status
+getpkg install whatsdirty     # Check git repo status
-getpkg sos            # Simple object storage client
+getpkg install sos            # Simple object storage client
+getpkg install gp             # Git push utility
 ```
 
 ### Publishing Your Own Tools

bb64/README.md

@@ -26,6 +26,8 @@ Usage:
     bb64 -[i|d] BASE64COMMAND   Displays the decoded command
     bb64 -e COMMAND             Encodes the command and prints the result
     bb64 -u                     Updates bb64 to the latest version (uses docker)
+    bb64 -v                     Prints the version number
+    bb64 version                Prints the version number
 ```
 
 # Implementation Notes

bb64/src/bb64.cpp

@@ -150,6 +150,7 @@ Usage:
     bb64 -u                     Updates bb64 to the latest version (uses docker)
 
     bb64 -v                     Prints the version number
+    bb64 version                Prints the version number
 
 )" << std::endl;
         return -1;
@@ -161,7 +162,7 @@ Usage:
     {
         if (mode == "-u")
             return update_bb64();
-        else if (mode == "-v")
+        else if (mode == "-v" || mode == "version")
         {
             std::cout << VERSION << std::endl;
             return 0;

bb64/test.sh

@@ -0,0 +1,135 @@
+#!/bin/bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+PROJECT="bb64"
+BB64="$SCRIPT_DIR/output/$PROJECT"
+TEST_DIR="$SCRIPT_DIR/test_temp"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Test counters
+TESTS_PASSED=0
+TESTS_FAILED=0
+
+# Function to print test results
+print_test_result() {
+    local test_name="$1"
+    local result="$2"
+    if [ "$result" -eq 0 ]; then
+        echo -e "${GREEN}✓${NC} $test_name"
+        TESTS_PASSED=$((TESTS_PASSED + 1))
+    else
+        echo -e "${RED}✗${NC} $test_name"
+        TESTS_FAILED=$((TESTS_FAILED + 1))
+    fi
+}
+
+# Function to cleanup test artifacts
+cleanup() {
+    echo -e "\n${YELLOW}Cleaning up test artifacts...${NC}"
+    rm -rf "$TEST_DIR"
+}
+
+# Set up trap to ensure cleanup runs
+trap cleanup EXIT
+
+# Create test directory
+mkdir -p "$TEST_DIR"
+
+echo -e "${YELLOW}Running bb64 tests...${NC}\n"
+
+# Check if bb64 binary exists
+if [ ! -f "$BB64" ]; then
+    echo -e "${RED}Error: bb64 binary not found at $BB64${NC}"
+    echo "Please run ./build.sh first to build bb64"
+    exit 1
+fi
+
+if [ ! -x "$BB64" ]; then
+    echo -e "${RED}Error: bb64 binary is not executable${NC}"
+    exit 1
+fi
+
+echo "Using bb64 binary: $BB64"
+
+# Test 1: Version command with -v flag
+echo "Test 1: Version command (-v flag)"
+VERSION_OUTPUT=$("$BB64" -v 2>&1 || true)
+# Version output should be just the version number
+VERSION=$(echo "$VERSION_OUTPUT" | head -n 1)
+if [[ "$VERSION" =~ ^[0-9]{4}\.[0-9]{4}\.[0-9]{4}$ ]]; then
+    print_test_result "Version format with -v flag (YYYY.MMDD.HHMM)" 0
+else
+    print_test_result "Version format with -v flag (YYYY.MMDD.HHMM)" 1
+    echo "  Expected: YYYY.MMDD.HHMM format, got: '$VERSION'"
+fi
+
+# Test 2: Version command with 'version' argument
+printf "\nTest 2: Version command (version argument)\n"
+VERSION_OUTPUT2=$("$BB64" version 2>&1 || true)
+# Version output should be just the version number
+VERSION2=$(echo "$VERSION_OUTPUT2" | head -n 1)
+if [[ "$VERSION2" =~ ^[0-9]{4}\.[0-9]{4}\.[0-9]{4}$ ]]; then
+    print_test_result "Version format with 'version' argument (YYYY.MMDD.HHMM)" 0
+else
+    print_test_result "Version format with 'version' argument (YYYY.MMDD.HHMM)" 1
+    echo "  Expected: YYYY.MMDD.HHMM format, got: '$VERSION2'"
+fi
+
+# Test 3: Both version commands should return the same version
+printf "\nTest 3: Version consistency\n"
+if [ "$VERSION" = "$VERSION2" ]; then
+    print_test_result "Both -v and version return same version" 0
+else
+    print_test_result "Both -v and version return same version" 1
+    echo "  -v returned: '$VERSION'"
+    echo "  version returned: '$VERSION2'"
+fi
+
+# Test 4: Basic encoding test
+echo -e "\nTest 4: Basic encoding test"
+TEST_STRING="hello world"
+ENCODED_OUTPUT=$("$BB64" -e <<< "$TEST_STRING" 2>&1 || true)
+if [ -n "$ENCODED_OUTPUT" ]; then
+    print_test_result "Basic encoding produces output" 0
+else
+    print_test_result "Basic encoding produces output" 1
+fi
+
+# Test 5: Basic decoding test (using -d flag)
+echo -e "\nTest 5: Basic decoding test"
+# Encode "echo hello" and then decode it
+ENCODED_ECHO=$(echo "echo hello" | "$BB64" -e)
+if [ -n "$ENCODED_ECHO" ]; then
+    DECODED_OUTPUT=$("$BB64" -d "$ENCODED_ECHO" 2>&1 || true)
+    if [[ "$DECODED_OUTPUT" == *"echo hello"* ]]; then
+        print_test_result "Basic decoding works correctly" 0
+    else
+        print_test_result "Basic decoding works correctly" 1
+        echo "  Expected to contain 'echo hello', got: '$DECODED_OUTPUT'"
+    fi
+else
+    print_test_result "Basic decoding works correctly" 1
+    echo "  Failed to encode test string"
+fi
+
+cleanup
+
+# Print summary
+echo -e "\n${YELLOW}Test Summary:${NC}"
+echo -e "Tests passed: ${GREEN}${TESTS_PASSED}${NC}"
+echo -e "Tests failed: ${RED}${TESTS_FAILED}${NC}"
+
+if [ "$TESTS_FAILED" -eq 0 ]; then
+    echo -e "\n${GREEN}All tests passed!${NC}"
+    exit 0
+else
+    echo -e "\n${RED}Some tests failed!${NC}"
+    exit 1
+fi

getpkg/CMakeLists.txt

@@ -36,13 +36,16 @@ target_include_directories(${PROJECT_NAME} PRIVATE
     src/common)
 
 # Find packages
-find_package(OpenSSL REQUIRED)
-find_package(Drogon CONFIG REQUIRED)
 find_package(nlohmann_json REQUIRED)
 
+# Add module path for FindCPRStatic
+list(APPEND CMAKE_MODULE_PATH "/usr/local/share/cmake/Modules")
+
+# Find packages
+find_package(nlohmann_json REQUIRED)
+find_package(CPRStatic REQUIRED)
+
 # Link libraries
 target_link_libraries(${PROJECT_NAME} PRIVATE
-    nlohmann_json::nlohmann_json Drogon::Drogon
+    nlohmann_json::nlohmann_json 
-    /usr/local/lib/libpgcommon.a /usr/local/lib/libpgport.a
+    cpr::cpr_static)
-    lzma dl)
-    

getpkg/debug_test.txt

@@ -0,0 +1 @@
+Debug content

getpkg/src/GetbinClient.cpp

@@ -1,530 +1,258 @@
 #include "GetbinClient.hpp"
-#include <drogon/HttpClient.h>
+#include <cpr/cpr.h>
-#include <trantor/net/EventLoop.h>
-#include <openssl/ssl.h>
-#include <openssl/opensslconf.h>
-#include <fstream>
-#include <sstream>
 #include <nlohmann/json.hpp>
-#include <string>
+#include <fstream>
 #include <iostream>
-#include <thread>
+#include <filesystem>
-#include <chrono>
+#include <sstream>
-#include <cstdio>
-#include <map>
-#include <atomic>
-#include <mutex>
-#include <condition_variable>
-#include <vector>
-#include <ctime>
 #include <algorithm>
-#include <set>
 
 using json = nlohmann::json;
 
-static constexpr const char* SERVER_HOST = "getpkg.xyz";
+const std::string GetbinClient::SERVER_HOST = "getpkg.xyz";
 
-// Initialize SSL to use only secure protocols
+GetbinClient::GetbinClient() {
-static class SSLInitializer {
+    // Initialize CPR (done automatically, but we could add global config here)
-public:
-    SSLInitializer() {
-        // Disable SSL 2.0, 3.0, TLS 1.0, and TLS 1.1
-        SSL_load_error_strings();
-        SSL_library_init();
-        // Note: This doesn't completely silence the warning but ensures we're using secure protocols
-    }
-} ssl_init;
-
-static std::string find_ca_certificates() {
-    // Common CA certificate locations across different Linux distributions
-    const std::vector<std::string> ca_paths = {
-        "/etc/ssl/certs/ca-certificates.crt",     // Debian/Ubuntu/Raspbian
-        "/etc/pki/tls/certs/ca-bundle.crt",       // Fedora/RHEL/CentOS
-        "/etc/ssl/ca-bundle.pem",                  // OpenSUSE
-        "/etc/pki/tls/cert.pem",                   // Fedora/RHEL alternative
-        "/etc/ssl/certs/ca-bundle.crt",            // Some distros
-        "/etc/ssl/cert.pem",                       // Alpine Linux
-        "/usr/local/share/certs/ca-root-nss.crt",  // FreeBSD
-        "/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem", // CentOS/RHEL 7+
-        "/etc/ca-certificates/extracted/tls-ca-bundle.pem"   // Arch Linux
-    };
-    
-    for (const auto& path : ca_paths) {
-        std::ifstream file(path);
-        if (file.good()) {
-            file.close();
-            return path;
-        }
-    }
-    
-    return "";
 }
 
-GetbinClient::GetbinClient() {}
+std::string GetbinClient::getUserAgent() const {
+    return "getpkg/1.0";
+}
 
-bool GetbinClient::download(const std::string& toolName, const std::string& arch, const std::string& outPath) {
+bool GetbinClient::download(const std::string& toolName, const std::string& arch, const std::string& outPath, 
-    bool success = false;
+                           ProgressCallback progressCallback) {
-    bool done = false;
+    try {
-    std::mutex mtx;
+        std::string url = "https://" + SERVER_HOST + "/object/" + toolName + ":" + arch;
-    std::condition_variable cv;
-    
-    std::thread worker([&]() {
-        trantor::EventLoop loop;
         
-        auto client = drogon::HttpClient::newHttpClient(
+        cpr::Session session;
-            "https://" + std::string(SERVER_HOST), 
+        session.SetUrl(cpr::Url{url});
-            &loop,
+        session.SetHeader(cpr::Header{{"User-Agent", getUserAgent()}});
-            false,  // useOldTLS = false (disable TLS 1.0/1.1)
+        session.SetTimeout(cpr::Timeout{30000}); // 30 seconds
-            true    // validateCert = true
+        session.SetVerifySsl(cpr::VerifySsl{true});
-        );
         
-        // Configure SSL certificates for HTTPS
+        // Add progress callback if provided
-        std::string ca_path = find_ca_certificates();
+        if (progressCallback) {
-        if (!ca_path.empty()) {
+            session.SetProgressCallback(cpr::ProgressCallback{[progressCallback](cpr::cpr_off_t downloadTotal, cpr::cpr_off_t downloadNow,
-            // Use addSSLConfigs with proper parameter names for OpenSSL
+                                                                                cpr::cpr_off_t uploadTotal, cpr::cpr_off_t uploadNow,
-            std::vector<std::pair<std::string, std::string>> sslConfigs;
+                                                                                intptr_t userdata) -> bool {
-            sslConfigs.push_back({"VerifyCAFile", ca_path});
+                return progressCallback(static_cast<size_t>(downloadNow), static_cast<size_t>(downloadTotal));
-            client->addSSLConfigs(sslConfigs);
+            }});
-        } else {
-            // If no CA certificates found, print warning but continue
-            std::cerr << "[GetbinClient] Warning: No system CA certificates found. SSL verification may fail." << std::endl;
         }
         
-        client->enableCookies();
+        auto response = session.Get();
-        client->setUserAgent("getpkg/1.0");
         
-        std::string object_path = "/object/" + toolName + ":" + arch;
+        if (response.status_code == 200) {
-        
+            std::ofstream ofs(outPath, std::ios::binary);
-        auto req = drogon::HttpRequest::newHttpRequest();
+            if (ofs) {
-        req->setMethod(drogon::Get);
+                ofs.write(response.text.data(), response.text.size());
-        req->setPath(object_path);
+                return ofs.good();
-        
-        client->sendRequest(req, [&](drogon::ReqResult result, const drogon::HttpResponsePtr& response) {
-            std::lock_guard<std::mutex> lock(mtx);
-            if (result == drogon::ReqResult::Ok && response && response->getStatusCode() == drogon::k200OK) {
-                std::ofstream ofs(outPath, std::ios::binary);
-                if (ofs) {
-                    const auto& body = response->getBody();
-                    ofs.write(body.data(), body.size());
-                    success = ofs.good();
-                }
-            } else {
-                std::cerr << "[GetbinClient::download] HTTP request failed." << std::endl;
             }
-            done = true;
+        } else if (response.status_code == 404) {
-            cv.notify_one();
+            // Not found - this is expected for arch fallback
-            loop.quit();
+            return false;
-        }, 30.0); // 30 second timeout
+        } else {
+            std::cerr << "[GetbinClient::download] HTTP " << response.status_code << ": " << response.error.message << std::endl;
+        }
         
-        loop.loop();
+        return false;
-    });
+    } catch (const std::exception& e) {
-    
+        std::cerr << "[GetbinClient::download] Exception: " << e.what() << std::endl;
-    // Wait for completion
-    {
-        std::unique_lock<std::mutex> lock(mtx);
-        cv.wait(lock, [&] { return done; });
-    }
-    
-    worker.join();
-    return success;
-}
-
-bool GetbinClient::upload(const std::string& archivePath, std::string& outUrl, std::string& outHash, const std::string& token) {
-    // Read file first
-    std::ifstream ifs(archivePath, std::ios::binary);
-    if (!ifs) {
-        std::cerr << "[GetbinClient::upload] Failed to open archive file: " << archivePath << std::endl;
         return false;
     }
-    std::string file_content((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
+}
-    
+
-    // Compose metadata
+bool GetbinClient::upload(const std::string& archivePath, std::string& outUrl, std::string& outHash, 
-    json metadata = { {"labeltags", json::array()} };
+                         const std::string& token, ProgressCallback progressCallback) {
-    std::string filename = archivePath.substr(archivePath.find_last_of("/\\") + 1);
+    try {
-    size_t dot = filename.find('.');
+        std::string url = "https://" + SERVER_HOST + "/upload";
-    std::string labeltag = dot != std::string::npos ? filename.substr(0, dot) : filename;
-    metadata["labeltags"].push_back(labeltag);
-    
-    bool success = false;
-    bool done = false;
-    std::mutex mtx;
-    std::condition_variable cv;
-    
-    std::thread worker([&]() {
-        trantor::EventLoop loop;
         
-        auto client = drogon::HttpClient::newHttpClient(
+        cpr::Session session;
-            "https://" + std::string(SERVER_HOST), 
+        session.SetUrl(cpr::Url{url});
-            &loop,
+        session.SetHeader(cpr::Header{
-            false,  // useOldTLS = false (disable TLS 1.0/1.1)
+            {"User-Agent", getUserAgent()},
-            true    // validateCert = true
+            {"Authorization", "Bearer " + token}
-        );
+        });
+        session.SetTimeout(cpr::Timeout{300000}); // 5 minutes for uploads
+        session.SetVerifySsl(cpr::VerifySsl{true});
         
-        // Configure SSL certificates
-        std::string ca_path = find_ca_certificates();
-        std::vector<std::pair<std::string, std::string>> sslConfigs;
-        if (!ca_path.empty()) {
-            sslConfigs.push_back({"VerifyCAFile", ca_path});
-        }
-        // Configure SSL for secure connections
-        client->addSSLConfigs(sslConfigs);
         
-        if (ca_path.empty()) {
+        // Extract tool name and arch from archive path for labeltags
-            std::cerr << "[GetbinClient] Warning: No system CA certificates found. SSL verification may fail." << std::endl;
+        // Archive path format: /path/to/tool-name:arch.tgz or similar
+        std::string archiveName = std::filesystem::path(archivePath).filename().string();
+        std::string toolNameArch = archiveName;
+        if (toolNameArch.ends_with(".tgz")) {
+            toolNameArch = toolNameArch.substr(0, toolNameArch.length() - 4);
         }
         
-        client->enableCookies();
+        // Create metadata JSON with labeltags
-        client->setUserAgent("getpkg/1.0");
+        json metadata;
+        metadata["labeltags"] = json::array({toolNameArch});
         
-        // Create upload file from memory content
+        // Set up multipart form with file and metadata
-        // First save content to a temporary file since UploadFile expects a file path
+        session.SetMultipart(cpr::Multipart{
-        std::string temp_file = "/tmp/getpkg_upload_" + std::to_string(std::time(nullptr)) + ".tgz";
+            cpr::Part{"file", cpr::File{archivePath}},
-        std::ofstream temp_ofs(temp_file, std::ios::binary);
+            cpr::Part{"metadata", metadata.dump(), "application/json"}
-        if (!temp_ofs) {
+        });
-            std::cerr << "[GetbinClient::upload] Failed to create temporary file: " << temp_file << std::endl;
+        
-            success = false;
+        // Add progress callback if provided
-            done = true;
+        if (progressCallback) {
-            cv.notify_one();
+            session.SetProgressCallback(cpr::ProgressCallback{[progressCallback](cpr::cpr_off_t downloadTotal, cpr::cpr_off_t downloadNow,
-            loop.quit();
+                                                                                cpr::cpr_off_t uploadTotal, cpr::cpr_off_t uploadNow,
-            return;
+                                                                                intptr_t userdata) -> bool {
+                return progressCallback(static_cast<size_t>(uploadNow), static_cast<size_t>(uploadTotal));
+            }});
         }
-        temp_ofs.write(file_content.data(), file_content.size());
-        temp_ofs.close();
         
-        // Create upload request with file
+        auto response = session.Put();
-        drogon::UploadFile upload_file(temp_file);
         
-        auto req = drogon::HttpRequest::newFileUploadRequest({upload_file});
+        if (response.status_code == 200) {
-        req->setMethod(drogon::Put);
+            try {
-        req->setPath("/upload");
+                auto resp_json = json::parse(response.text);
-        req->addHeader("Authorization", "Bearer " + token);
+                if (resp_json.contains("hash") && resp_json.contains("result") && resp_json["result"] == "success") {
-        
+                    outUrl = "https://" + SERVER_HOST + "/object/" + resp_json["hash"].get<std::string>();
-        // Add metadata as form parameter
+                    outHash = resp_json["hash"].get<std::string>();
-        req->setParameter("metadata", metadata.dump());
+                    return true;
-        
-        client->sendRequest(req, [&](drogon::ReqResult result, const drogon::HttpResponsePtr& response) {
-            std::lock_guard<std::mutex> lock(mtx);
-            if (result == drogon::ReqResult::Ok && response) {
-                int status_code = static_cast<int>(response->getStatusCode());
-                std::string response_body(response->getBody());
-                
-                if (status_code == 200 || status_code == 201) {
-                    try {
-                        auto resp_json = json::parse(response_body);
-                        if (resp_json.contains("url")) outUrl = resp_json["url"].get<std::string>();
-                        if (resp_json.contains("hash")) outHash = resp_json["hash"].get<std::string>();
-                        success = true;
-                    } catch (const std::exception& e) {
-                        std::cerr << "[GetbinClient::upload] Failed to parse JSON response: " << e.what() << std::endl;
-                        std::cerr << "[GetbinClient::upload] Response body: " << response_body << std::endl;
-                    }
-                } else {
-                    std::cerr << "[GetbinClient::upload] HTTP error: status code " << status_code << std::endl;
-                    std::cerr << "[GetbinClient::upload] Response body: " << response_body << std::endl;
                 }
-            } else {
+            } catch (const json::exception& e) {
-                std::cerr << "[GetbinClient::upload] HTTP /upload request failed." << std::endl;
+                // Try to extract from plain text response
+                outUrl = "";
+                outHash = response.text;
+                // Remove trailing newline if present
+                if (!outHash.empty() && outHash.back() == '\n') {
+                    outHash.pop_back();
+                }
+                return !outHash.empty();
             }
-            done = true;
+        } else {
-            cv.notify_one();
+            std::cerr << "[GetbinClient::upload] HTTP " << response.status_code << ": " << response.error.message << std::endl;
-            loop.quit();
+            if (!response.text.empty()) {
-        }, 60.0); // 60 second timeout
+                std::cerr << "[GetbinClient::upload] Response: " << response.text << std::endl;
+            }
+        }
         
-        loop.loop();
+        return false;
-        
+    } catch (const std::exception& e) {
-        // Clean up temporary file
+        std::cerr << "[GetbinClient::upload] Exception: " << e.what() << std::endl;
-        std::remove(temp_file.c_str());
+        return false;
-    });
-    
-    // Wait for completion
-    {
-        std::unique_lock<std::mutex> lock(mtx);
-        cv.wait(lock, [&] { return done; });
     }
-    
-    worker.join();
-    return success;
 }
 
 bool GetbinClient::getHash(const std::string& toolName, const std::string& arch, std::string& outHash) {
-    bool success = false;
+    try {
-    bool done = false;
+        std::string url = "https://" + SERVER_HOST + "/hash/" + toolName + ":" + arch;
-    std::mutex mtx;
-    std::condition_variable cv;
-    
-    std::thread worker([&]() {
-        trantor::EventLoop loop;
         
-        auto client = drogon::HttpClient::newHttpClient(
+        auto response = cpr::Get(cpr::Url{url},
-            "https://" + std::string(SERVER_HOST), 
+                                cpr::Header{{"User-Agent", getUserAgent()}},
-            &loop,
+                                cpr::Timeout{10000}, // 10 seconds
-            false,  // useOldTLS = false (disable TLS 1.0/1.1)
+                                cpr::VerifySsl{true});
-            true    // validateCert = true
-        );
         
-        // Configure SSL certificates
+        if (response.status_code == 200) {
-        std::string ca_path = find_ca_certificates();
+            try {
-        std::vector<std::pair<std::string, std::string>> sslConfigs;
+                // Try JSON first
-        if (!ca_path.empty()) {
+                auto resp_json = json::parse(response.text);
-            sslConfigs.push_back({"VerifyCAFile", ca_path});
+                if (resp_json.contains("hash")) {
-        }
+                    outHash = resp_json["hash"].get<std::string>();
-        // Configure SSL for secure connections
+                    return true;
-        client->addSSLConfigs(sslConfigs);
-        
-        if (ca_path.empty()) {
-            std::cerr << "[GetbinClient] Warning: No system CA certificates found. SSL verification may fail." << std::endl;
-        }
-        
-        client->enableCookies();
-        client->setUserAgent("getpkg/1.0");
-        
-        std::string hash_path = "/hash/" + toolName + ":" + arch;
-        
-        auto req = drogon::HttpRequest::newHttpRequest();
-        req->setMethod(drogon::Get);
-        req->setPath(hash_path);
-        
-        client->sendRequest(req, [&](drogon::ReqResult result, const drogon::HttpResponsePtr& response) {
-            std::lock_guard<std::mutex> lock(mtx);
-            if (result == drogon::ReqResult::Ok && response && response->getStatusCode() == drogon::k200OK) {
-                std::string response_body(response->getBody());
-                
-                // Try to parse hash from response body
-                try {
-                    // Try JSON first
-                    auto resp_json = json::parse(response_body);
-                    if (resp_json.contains("hash")) {
-                        outHash = resp_json["hash"].get<std::string>();
-                        success = true;
-                    }
-                } catch (...) {
-                    // Not JSON, treat as plain text
-                    outHash = response_body;
-                    // Remove trailing newline if present
-                    if (!outHash.empty() && outHash.back() == '\n') {
-                        outHash.pop_back();
-                    }
-                    success = !outHash.empty();
                 }
+            } catch (const json::exception&) {
+                // Not JSON, treat as plain text
+                outHash = response.text;
+                // Remove trailing newline if present
+                if (!outHash.empty() && outHash.back() == '\n') {
+                    outHash.pop_back();
+                }
+                return !outHash.empty();
             }
-            done = true;
+        } else if (response.status_code == 404) {
-            cv.notify_one();
+            // Not found - this is expected for non-existent tools/archs
-            loop.quit();
+            return false;
-        }, 10.0); // 10 second timeout
+        } else {
+            std::cerr << "[GetbinClient::getHash] HTTP " << response.status_code << ": " << response.error.message << std::endl;
+        }
         
-        loop.loop();
+        return false;
-    });
+    } catch (const std::exception& e) {
-    
+        std::cerr << "[GetbinClient::getHash] Exception: " << e.what() << std::endl;
-    // Wait for completion
+        return false;
-    {
-        std::unique_lock<std::mutex> lock(mtx);
-        cv.wait(lock, [&] { return done; });
     }
-    
-    worker.join();
-    return success;
 }
 
 bool GetbinClient::deleteObject(const std::string& hash, const std::string& token) {
-    bool success = false;
+    try {
-    bool done = false;
+        std::string url = "https://" + SERVER_HOST + "/deleteobject?hash=" + hash;
-    std::mutex mtx;
-    std::condition_variable cv;
-    
-    std::thread worker([&]() {
-        trantor::EventLoop loop;
         
-        auto client = drogon::HttpClient::newHttpClient(
+        auto response = cpr::Get(cpr::Url{url},
-            "https://" + std::string(SERVER_HOST), 
+                                cpr::Header{
-            &loop,
+                                    {"User-Agent", getUserAgent()},
-            false,  // useOldTLS = false (disable TLS 1.0/1.1)
+                                    {"Authorization", "Bearer " + token}
-            true    // validateCert = true
+                                },
-        );
+                                cpr::Timeout{30000}, // 30 seconds
+                                cpr::VerifySsl{true});
         
-        // Configure SSL certificates
+        if (response.status_code == 200) {
-        std::string ca_path = find_ca_certificates();
+            return true;
-        std::vector<std::pair<std::string, std::string>> sslConfigs;
+        } else {
-        if (!ca_path.empty()) {
+            std::cerr << "[GetbinClient::deleteObject] HTTP " << response.status_code << ": " << response.error.message << std::endl;
-            sslConfigs.push_back({"VerifyCAFile", ca_path});
+            if (!response.text.empty()) {
-        }
+                std::cerr << "[GetbinClient::deleteObject] Response: " << response.text << std::endl;
-        // Configure SSL for secure connections
-        client->addSSLConfigs(sslConfigs);
-        
-        if (ca_path.empty()) {
-            std::cerr << "[GetbinClient] Warning: No system CA certificates found. SSL verification may fail." << std::endl;
-        }
-        
-        client->enableCookies();
-        client->setUserAgent("getpkg/1.0");
-        
-        std::string delete_path = "/deleteobject?hash=" + hash;
-        
-        auto req = drogon::HttpRequest::newHttpRequest();
-        req->setMethod(drogon::Get);
-        req->setPath(delete_path);
-        req->addHeader("Authorization", "Bearer " + token);
-        
-        client->sendRequest(req, [&](drogon::ReqResult result, const drogon::HttpResponsePtr& response) {
-            std::lock_guard<std::mutex> lock(mtx);
-            if (result == drogon::ReqResult::Ok && response) {
-                int status_code = static_cast<int>(response->getStatusCode());
-                std::string response_body(response->getBody());
-                
-                if (status_code == 200) {
-                    // Check if the response indicates success
-                    try {
-                        auto resp_json = json::parse(response_body);
-                        if (resp_json.contains("result") && resp_json["result"] == "success") {
-                            success = true;
-                        }
-                    } catch (...) {
-                        // If not JSON, assume success if 200 OK
-                        success = true;
-                    }
-                } else {
-                    std::cerr << "[GetbinClient::deleteObject] HTTP error: status code " << status_code << std::endl;
-                    std::cerr << "[GetbinClient::deleteObject] Response body: " << response_body << std::endl;
-                }
-            } else {
-                std::cerr << "[GetbinClient::deleteObject] HTTP request failed." << std::endl;
             }
-            done = true;
+        }
-            cv.notify_one();
-            loop.quit();
-        }, 10.0); // 10 second timeout
         
-        loop.loop();
+        return false;
-    });
+    } catch (const std::exception& e) {
-    
+        std::cerr << "[GetbinClient::deleteObject] Exception: " << e.what() << std::endl;
-    // Wait for completion
+        return false;
-    {
-        std::unique_lock<std::mutex> lock(mtx);
-        cv.wait(lock, [&] { return done; });
     }
-    
-    worker.join();
-    return success;
 }
+
 bool GetbinClient::listPackages(std::vector<std::string>& outPackages) {
-    outPackages.clear();
+    try {
-    
+        std::string url = "https://" + SERVER_HOST + "/packages";
-    // Set up SSL configuration
-    std::string ca_path = find_ca_certificates();
-    
-    bool success = false;
-    bool done = false;
-    std::mutex mtx;
-    std::condition_variable cv;
-    
-    std::thread worker([&]() {
-        trantor::EventLoop loop;
         
-        auto client = drogon::HttpClient::newHttpClient(
+        auto response = cpr::Get(cpr::Url{url},
-            "https://" + std::string(SERVER_HOST), 
+                                cpr::Header{{"User-Agent", getUserAgent()}},
-            &loop,
+                                cpr::Timeout{30000}, // 30 seconds
-            false,  // useOldTLS = false (disable TLS 1.0/1.1)
+                                cpr::VerifySsl{true});
-            true    // validateCert = true
-        );
-        std::vector<std::pair<std::string, std::string>> sslConfigs;
-        if (!ca_path.empty()) {
-            sslConfigs.push_back({"VerifyCAFile", ca_path});
-        }
-        // Configure SSL for secure connections
-        client->addSSLConfigs(sslConfigs);
         
-        auto req = drogon::HttpRequest::newHttpRequest();
+        if (response.status_code == 200) {
-        req->setMethod(drogon::Get);
+            try {
-        req->setPath("/dir");
+                auto resp_json = json::parse(response.text);
-        
+                if (resp_json.is_array()) {
-        client->sendRequest(req, [&](drogon::ReqResult result, const drogon::HttpResponsePtr& response) {
+                    outPackages.clear();
-            if (result == drogon::ReqResult::Ok) {
+                    for (const auto& item : resp_json) {
-                int status_code = response->getStatusCode();
+                        if (item.is_string()) {
-                std::string response_body = std::string(response->getBody());
+                            outPackages.push_back(item.get<std::string>());
-                
-                if (status_code == 200) {
-                    try {
-                        json json_response = json::parse(response_body);
-                        
-                        if (json_response.contains("entries") && json_response["entries"].is_array()) {
-                            for (const auto& entry : json_response["entries"]) {
-                                if (entry.contains("labeltags") && entry["labeltags"].is_array()) {
-                                    for (const auto& labeltag : entry["labeltags"]) {
-                                        if (labeltag.is_string()) {
-                                            std::string name = labeltag.get<std::string>();
-                                            // Extract tool name (remove architecture suffix if present)
-                                            size_t colon_pos = name.find(":");
-                                            if (colon_pos != std::string::npos) {
-                                                name = name.substr(0, colon_pos);
-                                            }
-                                            
-                                            // Skip empty names
-                                            if (name.empty()) continue;
-                                            
-                                            // Add to list if not already present
-                                            if (std::find(outPackages.begin(), outPackages.end(), name) == outPackages.end()) {
-                                                outPackages.push_back(name);
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            success = true;
                         }
-                    } catch (const std::exception& e) {
-                        std::cerr << "[GetbinClient::listPackages] JSON parse error: " << e.what() << std::endl;
                     }
-                } else {
+                    return true;
-                    std::cerr << "[GetbinClient::listPackages] HTTP error: status code " << status_code << std::endl;
+                } else if (resp_json.contains("packages") && resp_json["packages"].is_array()) {
+                    outPackages.clear();
+                    for (const auto& item : resp_json["packages"]) {
+                        if (item.is_string()) {
+                            outPackages.push_back(item.get<std::string>());
+                        }
+                    }
+                    return true;
                 }
-            } else {
+            } catch (const json::exception&) {
-                std::cerr << "[GetbinClient::listPackages] HTTP request failed." << std::endl;
+                // Try to parse as newline-separated list
-            }
+                outPackages.clear();
-            done = true;
+                std::istringstream stream(response.text);
-            cv.notify_one();
+                std::string line;
-            loop.quit();
+                while (std::getline(stream, line)) {
-        }, 10.0);
+                    if (!line.empty()) {
-        
+                        outPackages.push_back(line);
-        loop.loop();
+                    }
-    });
+                }
-    
+                return !outPackages.empty();
-    // Wait for completion
-    {
-        std::unique_lock<std::mutex> lock(mtx);
-        cv.wait(lock, [&] { return done; });
-    }
-    
-    worker.join();
-    
-    // Filter out duplicates where we have both toolname and toolname-noarch
-    // Keep the base name and remove the -noarch variant
-    std::vector<std::string> filteredPackages;
-    std::set<std::string> baseNames;
-    
-    // First pass: collect all base names (without -noarch)
-    for (const auto& pkg : outPackages) {
-        const std::string suffix = "-noarch";
-        if (pkg.length() < suffix.length() || pkg.substr(pkg.length() - suffix.length()) != suffix) {
-            baseNames.insert(pkg);
-        }
-    }
-    
-    // Second pass: add packages, skipping -noarch variants if base exists
-    for (const auto& pkg : outPackages) {
-        const std::string suffix = "-noarch";
-        if (pkg.length() >= suffix.length() && pkg.substr(pkg.length() - suffix.length()) == suffix) {
-            std::string baseName = pkg.substr(0, pkg.length() - suffix.length());
-            if (baseNames.find(baseName) == baseNames.end()) {
-                filteredPackages.push_back(pkg); // Keep -noarch only if no base version
             }
         } else {
-            filteredPackages.push_back(pkg); // Always keep base versions
+            std::cerr << "[GetbinClient::listPackages] HTTP " << response.status_code << ": " << response.error.message << std::endl;
         }
+        
+        return false;
+    } catch (const std::exception& e) {
+        std::cerr << "[GetbinClient::listPackages] Exception: " << e.what() << std::endl;
+        return false;
     }
-    
+}
-    outPackages = std::move(filteredPackages);
-    
-    // Sort the packages for better display
-    std::sort(outPackages.begin(), outPackages.end());
-    
-    return success;
-}

getpkg/src/GetbinClient.hpp

@@ -1,13 +1,24 @@
 #pragma once
 #include <string>
 #include <vector>
+#include <functional>
 
 class GetbinClient {
 public:
     GetbinClient();
-    bool download(const std::string& toolName, const std::string& arch, const std::string& outPath);
+    
-    bool upload(const std::string& archivePath, std::string& outUrl, std::string& outHash, const std::string& token);
+    // Progress callback: (downloaded_bytes, total_bytes) -> should_continue
+    using ProgressCallback = std::function<bool(size_t, size_t)>;
+    
+    bool download(const std::string& toolName, const std::string& arch, const std::string& outPath, 
+                  ProgressCallback progressCallback = nullptr);
+    bool upload(const std::string& archivePath, std::string& outUrl, std::string& outHash, const std::string& token,
+                ProgressCallback progressCallback = nullptr);
     bool getHash(const std::string& toolName, const std::string& arch, std::string& outHash);
     bool deleteObject(const std::string& hash, const std::string& token);
     bool listPackages(std::vector<std::string>& outPackages);
+    
+private:
+    static const std::string SERVER_HOST;
+    std::string getUserAgent() const;
 }; 

getpkg/src/main.cpp

@@ -200,27 +200,43 @@ int install_tool(int argc, char* argv[]) {
     // Download tool - try arch-specific version first, then universal fallback
     GetbinClient getbin2;
     std::string downloadArch = arch;
-    //std::cout << "Downloading " << toolName << ":" << arch << "..." << std::endl;
+    
-    if (!getbin2.download(toolName, arch, archivePath.string())) {
+    // Progress callback for downloads
+    auto progressCallback = [&toolName](size_t downloaded, size_t total) -> bool {
+        if (total > 0) {
+            int percent = (downloaded * 100) / total;
+            std::cout << "\rDownloading " << toolName << "... " << percent << "%" << std::flush;
+        } else {
+            std::cout << "\rDownloading " << toolName << "... " << downloaded << " bytes" << std::flush;
+        }
+        return true; // Continue download
+    };
+    
+    std::cout << "Downloading " << toolName << "..." << std::flush;
+    if (!getbin2.download(toolName, arch, archivePath.string(), progressCallback)) {
         // Try universal version as fallback
-        //std::cout << "Arch-specific version not found, trying universal version..." << std::endl;
+        std::cout << "\rArch-specific version not found, trying universal..." << std::endl;
-        //std::cout << "Downloading " << toolName << ":universal..." << std::endl;
+        if (!getbin2.download(toolName, "universal", archivePath.string(), progressCallback)) {
-        if (!getbin2.download(toolName, "universal", archivePath.string())) {
+            std::cerr << "\rFailed to download tool archive (tried both " << arch << " and universal)." << std::endl;
-            std::cerr << "Failed to download tool archive (tried both " << arch << " and universal)." << std::endl;
             return 1;
         }
         downloadArch = "universal";
     }
+    std::cout << "\rDownloading " << toolName << "... done" << std::endl;
     
     // Unpack tool
+    std::cout << "Unpacking..." << std::flush;
     if (!common::unpack_tgz(archivePath.string(), binDir.string())) {
-        std::cerr << "Failed to unpack tool archive." << std::endl;
+        std::cerr << "\rFailed to unpack tool archive." << std::endl;
         return 1;
     }
+    std::cout << "\rUnpacking... done" << std::endl;
         
     // Add to PATH and autocomplete
+    std::cout << "Configuring..." << std::flush;
     scriptManager.addToolEntry(toolName, binDir.string());
     scriptManager.addAutocomplete(toolName);
+    std::cout << "\rConfiguring... done" << std::endl;
     
     // Get tool info
     std::string hash;
@@ -314,10 +330,24 @@ int publish_tool(int argc, char* argv[]) {
     }
     GetbinClient getbin;
     std::string url, hash;
-    if (!getbin.upload(archivePath.string(), url, hash, token)) {
+    
-        std::cerr << "Failed to upload archive." << std::endl;
+    // Progress callback for upload
+    auto uploadProgressCallback = [](size_t uploaded, size_t total) -> bool {
+        if (total > 0) {
+            int percent = (uploaded * 100) / total;
+            std::cout << "\rUploading... " << percent << "%" << std::flush;
+        } else {
+            std::cout << "\rUploading... " << uploaded << " bytes" << std::flush;
+        }
+        return true; // Continue upload
+    };
+    
+    std::cout << "Uploading..." << std::flush;
+    if (!getbin.upload(archivePath.string(), url, hash, token, uploadProgressCallback)) {
+        std::cerr << "\rFailed to upload archive." << std::endl;
         return 1;
     }
+    std::cout << "\rUploading... done" << std::endl;
     std::cout << "Published! URL: " << url << "\nHash: " << hash << std::endl;
     return 0;
 }
@@ -326,75 +356,163 @@ int update_tool(int argc, char* argv[]) {
     std::string home = get_home();
     std::filesystem::path configDir = std::filesystem::path(home) / ".config/getpkg";
     
-    // Collect all installed tools
+    // Structure to hold tool information
-    std::vector<std::tuple<std::string, std::string, std::string>> updateResults; // name, status, version
+    struct ToolInfo {
-    
+        std::string name;
-    // Capture stdout to process install_tool output
+        std::string localHash;
-    auto processToolUpdate = [&](const std::string& toolName) -> std::tuple<std::string, std::string> {
+        std::string remoteHash;
-        // Redirect stdout and stderr to capture output
+        std::string arch;
-        std::stringstream buffer;
+        std::string version;
-        std::stringstream errBuffer;
+        bool needsUpdate = false;
-        std::streambuf* oldOut = std::cout.rdbuf(buffer.rdbuf());
+        std::string status = "Up to date";
-        std::streambuf* oldErr = std::cerr.rdbuf(errBuffer.rdbuf());
-        
-        char* toolArgv[] = {argv[0], (char*)"install", (char*)toolName.c_str()};
-        int result = install_tool(3, toolArgv);
-        
-        // Restore stdout and stderr
-        std::cout.rdbuf(oldOut);
-        std::cerr.rdbuf(oldErr);
-        
-        std::string output = buffer.str();
-        std::string status = "Failed";
-        std::string version = "-";
-        
-        if (result == 0) {
-            if (output.find("is already up to date") != std::string::npos) {
-                status = "Up to date";
-            } else if (output.find("Installed " + toolName + " successfully") != std::string::npos) {
-                // Check if it was an update or fresh install
-                if (output.find("Updating " + toolName) != std::string::npos) {
-                    status = "Updated";
-                } else {
-                    status = "Installed";
-                }
-            }
-            
-            // Try to get version from config
-            std::filesystem::path toolInfoPath = configDir / (toolName + ".json");
-            if (std::filesystem::exists(toolInfoPath)) {
-                std::ifstream tfile(toolInfoPath);
-                json toolInfo;
-                tfile >> toolInfo;
-                version = toolInfo.value("version", "-");
-                if (!version.empty() && version.back() == '\n') version.pop_back();
-                // If version is empty, try to show something useful
-                if (version.empty() || version == "-") {
-                    version = "installed";
-                }
-            }
-        }
-        
-        return std::make_tuple(status, version);
     };
     
-    // First update getpkg itself
+    std::vector<ToolInfo> tools;
-    auto [getpkgStatus, getpkgVersion] = processToolUpdate("getpkg");
-    updateResults.push_back(std::make_tuple("getpkg", getpkgStatus, getpkgVersion));
     
-    // Then update all other installed tools
+    // Collect all installed tools
     if (std::filesystem::exists(configDir)) {
         for (const auto& entry : std::filesystem::directory_iterator(configDir)) {
             if (entry.path().extension() == ".json") {
                 std::string tname = entry.path().stem();
-                if (tname != "getpkg") {  // Skip getpkg since we already did it
+                
-                    auto [status, version] = processToolUpdate(tname);
+                ToolInfo tool;
-                    updateResults.push_back(std::make_tuple(tname, status, version));
+                tool.name = tname;
+                
+                // Read local tool info
+                std::ifstream tfile(entry.path());
+                if (tfile.good()) {
+                    json toolInfo;
+                    tfile >> toolInfo;
+                    tool.localHash = toolInfo.value("hash", "");
+                    tool.arch = toolInfo.value("arch", get_arch());
+                    tool.version = toolInfo.value("version", "-");
+                    if (!tool.version.empty() && tool.version.back() == '\n') {
+                        tool.version.pop_back();
+                    }
+                    if (tool.version.empty() || tool.version == "-") {
+                        tool.version = "installed";
+                    }
+                }
+                
+                tools.push_back(tool);
+            }
+        }
+    }
+    
+    if (tools.empty()) {
+        std::cout << "No tools installed." << std::endl;
+        return 0;
+    }
+    
+    // Step 1: Check for updates (with progress)
+    std::cout << "Checking " << tools.size() << " tools for updates..." << std::endl;
+    
+    GetbinClient getbin;
+    for (size_t i = 0; i < tools.size(); ++i) {
+        auto& tool = tools[i];
+        
+        // Show progress
+        std::cout << "\r[" << (i + 1) << "/" << tools.size() << "] Checking " << tool.name << "..." << std::flush;
+        
+        // Check remote hash
+        std::string remoteHash;
+        if (getbin.getHash(tool.name, tool.arch, remoteHash) && !remoteHash.empty()) {
+            tool.remoteHash = remoteHash;
+            if (tool.localHash != remoteHash) {
+                tool.needsUpdate = true;
+                tool.status = "Needs update";
+            }
+        } else {
+            tool.status = "Check failed";
+        }
+    }
+    std::cout << "\r" << std::string(50, ' ') << "\r" << std::flush; // Clear progress line
+    
+    // Step 2: Update tools that need updating
+    std::vector<std::tuple<std::string, std::string, std::string>> updateResults;
+    
+    // First update getpkg if it needs updating
+    auto getpkgIt = std::find_if(tools.begin(), tools.end(), 
+                                 [](const ToolInfo& t) { return t.name == "getpkg"; });
+    
+    if (getpkgIt != tools.end() && getpkgIt->needsUpdate) {
+        std::cout << "Updating getpkg..." << std::flush;
+        
+        // Use install_tool for actual update
+        std::stringstream buffer, errBuffer;
+        std::streambuf* oldOut = std::cout.rdbuf(buffer.rdbuf());
+        std::streambuf* oldErr = std::cerr.rdbuf(errBuffer.rdbuf());
+        
+        char* toolArgv[] = {argv[0], (char*)"install", (char*)"getpkg"};
+        int result = install_tool(3, toolArgv);
+        
+        std::cout.rdbuf(oldOut);
+        std::cerr.rdbuf(oldErr);
+        
+        if (result == 0) {
+            getpkgIt->status = "Updated";
+            std::cout << " Updated" << std::endl;
+        } else {
+            getpkgIt->status = "Failed";
+            std::cout << " Failed" << std::endl;
+        }
+    }
+    
+    // Update other tools
+    int toolsToUpdate = std::count_if(tools.begin(), tools.end(), 
+                                      [](const ToolInfo& t) { return t.needsUpdate && t.name != "getpkg"; });
+    
+    if (toolsToUpdate > 0) {
+        std::cout << "Updating " << toolsToUpdate << " tools..." << std::endl;
+        
+        int updatedCount = 0;
+        for (auto& tool : tools) {
+            if (tool.needsUpdate && tool.name != "getpkg") {
+                updatedCount++;
+                std::cout << "[" << updatedCount << "/" << toolsToUpdate << "] Updating " << tool.name << "..." << std::flush;
+                
+                // Use install_tool for actual update
+                std::stringstream buffer, errBuffer;
+                std::streambuf* oldOut = std::cout.rdbuf(buffer.rdbuf());
+                std::streambuf* oldErr = std::cerr.rdbuf(errBuffer.rdbuf());
+                
+                char* toolArgv[] = {argv[0], (char*)"install", (char*)tool.name.c_str()};
+                int result = install_tool(3, toolArgv);
+                
+                std::cout.rdbuf(oldOut);
+                std::cerr.rdbuf(oldErr);
+                
+                if (result == 0) {
+                    tool.status = "Updated";
+                    std::cout << " Updated" << std::endl;
+                    
+                    // Re-read version after update
+                    std::filesystem::path toolInfoPath = configDir / (tool.name + ".json");
+                    if (std::filesystem::exists(toolInfoPath)) {
+                        std::ifstream tfile(toolInfoPath);
+                        json toolInfo;
+                        tfile >> toolInfo;
+                        tool.version = toolInfo.value("version", tool.version);
+                        if (!tool.version.empty() && tool.version.back() == '\n') {
+                            tool.version.pop_back();
+                        }
+                        if (tool.version.empty() || tool.version == "-") {
+                            tool.version = "installed";
+                        }
+                    }
+                } else {
+                    tool.status = "Failed";
+                    std::cout << " Failed" << std::endl;
                 }
             }
         }
     }
     
+    // Prepare results for display
+    for (const auto& tool : tools) {
+        updateResults.push_back(std::make_tuple(tool.name, tool.status, tool.version));
+    }
+    
     // Display results in a table
     std::cout << std::endl;
     std::cout << "+" << std::string(25, '-') << "+" << std::string(15, '-') << "+" << std::string(20, '-') << "+" << std::endl;

getpkg/test_debug/debug-test

@@ -0,0 +1 @@
+#!/bin/bash\necho debug

getpkg/test_debug2/debug-test2

@@ -0,0 +1 @@
+#!/bin/bash\necho debug2

getpkg/test_upload.txt

@@ -0,0 +1 @@
+test content