Modify getpkg/src/main.cpp

.gitea/workflows/BuildTestPublish.yaml

@@ -26,7 +26,10 @@ jobs:
           password: ${{ secrets.DOCKER_PUSH_TOKEN }}
       - name: Build Test Publish All
         run: |
-          SOS_WRITE_TOKEN=${{ secrets.SOS_WRITE_TOKEN }} RELEASE_WRITE_TOKEN=${{ secrets.RELEASE_WRITE_TOKEN }} ./buildtestpublish_all.sh --no-cache
+          SOS_WRITE_TOKEN=${{ secrets.SOS_WRITE_TOKEN }} \
+          RELEASE_WRITE_TOKEN=${{ secrets.RELEASE_WRITE_TOKEN }} \
+          GITEA_CONTAINER_NAME=${{ env.JOB_CONTAINER_NAME }} \
+          ./buildtestpublish_all.sh
 
   test-install-from-scratch:
     needs: [build]

buildtestpublish_all.sh

@@ -2,16 +2,6 @@
 set -uo pipefail  # Remove -e to handle errors manually
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
 
-# Parse command line arguments
-NO_CACHE=false
-if [[ "$*" == *"--no-cache"* ]]; then
-    NO_CACHE=true
-    export NO_CACHE
-fi
-
-docker builder prune -f
-
-
 # Colors for output
 RED='\033[0;31m'
 GREEN='\033[0;32m'
@@ -244,15 +234,17 @@ function print_summary() {
     echo
 }
 
-title "🔨 BUILDING ALL TOOLS 🔨"
+title "🔨 BUILDING GETPKG 🔨"
 
-getpkg/build.sh
+"${SCRIPT_DIR}/getpkg/build.sh"
 export GETPKG="${SCRIPT_DIR}/getpkg/output/getpkg"
 if [ ! -f "$GETPKG" ]; then
     echo "Build failed."
     exit 1
 fi
 
+title "🔨 BUILDING ALL TOOLS 🔨"
+
 buildtestpublish_all
 
 print_summary

dehydrate/build.sh

@@ -1,26 +1,52 @@
 #!/bin/bash
-# build.sh using docker run approach
+set -euo pipefail
 
+# Get script directory - handle different execution contexts
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
-PROJECT="dehydrate"
+PROJECT="$(basename "${SCRIPT_DIR}")"
 
-# Create persistent build directory
+# Debug output for CI
-mkdir -p "${SCRIPT_DIR}/build"
+echo "${PROJECT} build script running from: ${SCRIPT_DIR}"
-mkdir -p "${SCRIPT_DIR}/output"
+
+# handle running locally, or docker in docker via gitea runner.
+if [ -n "${GITEA_CONTAINER_NAME:-}" ]; then
+  echo "We're in a gitea container: ${GITEA_CONTAINER_NAME}"
+  VOLUME_OPTS=("--volumes-from=${GITEA_CONTAINER_NAME}")
+  WORKING_DIR=("-w" "${GITHUB_WORKSPACE}/${PROJECT}")
+  BUILD_DIR="${GITHUB_WORKSPACE}/${PROJECT}/build"
+  OUTPUT_DIR="${GITHUB_WORKSPACE}/${PROJECT}/output"
+else
+  VOLUME_OPTS=("-v" "${SCRIPT_DIR}:/app")
+  WORKING_DIR=("-w" "/app")
+  BUILD_DIR="${SCRIPT_DIR}/build"
+  OUTPUT_DIR="${SCRIPT_DIR}/output"
+fi
+
+# Create output directory
+mkdir -p "${OUTPUT_DIR}"
 
 # Run build in container with mounted directories
-docker run --rm \
+COMMAND_TO_RUN="cmake -G Ninja -S . -B ./build \
-  --user "$(id -u):$(id -g)" \
-  -v "${SCRIPT_DIR}:/src:ro" \
-  -v "${SCRIPT_DIR}/build:/build" \
-  -v "${SCRIPT_DIR}/output:/output" \
-  -e CMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE:-Debug}" \
-  gitea.jde.nz/public/dropshell-build-base:latest \
-  bash -c "
-    cd /build && \
-    cmake -G Ninja -S /src -B . \
                 -DCMAKE_BUILD_TYPE=\${CMAKE_BUILD_TYPE} \
                 -DPROJECT_NAME=${PROJECT} && \
-    cmake --build . && \
+                cmake --build ./build" 
-    cp ${PROJECT} /output/
+
-  "
+echo "Building in new docker container"
+docker run --rm \
+  --user "$(id -u):$(id -g)" \
+  "${VOLUME_OPTS[@]}" \
+  "${WORKING_DIR[@]}" \
+  -e CMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE:-Debug}" \
+  gitea.jde.nz/public/dropshell-build-base:latest \
+  bash -c "${COMMAND_TO_RUN}"
+
+# Copy built executable to output directory
+if [ -f "${BUILD_DIR}/${PROJECT}" ]; then
+  cp "${BUILD_DIR}/${PROJECT}" "${OUTPUT_DIR}/"
+  echo "✓ Build successful - ${PROJECT} copied to ${OUTPUT_DIR}/"
+else
+  echo "✗ Build failed - ${PROJECT} not found in ${BUILD_DIR}/"
+  exit 1
+fi
+
+echo "Build complete"

dehydrate/clean.sh

@@ -3,7 +3,7 @@
 set -euo pipefail
 
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
-PROJECT="dehydrate"
+PROJECT="$(basename "$(dirname "${SCRIPT_DIR}")")"
 
 echo "Cleaning ${PROJECT}..."
 

dehydrate/test.sh

@@ -4,8 +4,20 @@ set -euo pipefail
 
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 PROJECT="dehydrate"
-DEHYDRATE="${SCRIPT_DIR}/output/${PROJECT}"
+
-TEST_DIR="${SCRIPT_DIR}/test_temp"
+# Handle running locally or in Gitea runner
+if [ -n "${GITEA_CONTAINER_NAME:-}" ]; then
+    echo "Running in Gitea CI environment"
+    echo "GITHUB_WORKSPACE: ${GITHUB_WORKSPACE}"
+    echo "Current directory: $(pwd)"
+    OUTPUT_DIR="${GITHUB_WORKSPACE}/dehydrate/output"
+    TEST_DIR="${GITHUB_WORKSPACE}/dehydrate/test_temp"
+else
+    OUTPUT_DIR="${SCRIPT_DIR}/output"
+    TEST_DIR="${SCRIPT_DIR}/test_temp"
+fi
+
+DEHYDRATE="${OUTPUT_DIR}/${PROJECT}"
 
 # Colors for output
 RED='\033[0;31m'
@@ -45,10 +57,31 @@ mkdir -p "$TEST_DIR"
 
 echo -e "${YELLOW}Running dehydrate tests...${NC}\n"
 
+# Debug output
+echo "Looking for dehydrate at: $DEHYDRATE"
+echo "Workspace structure:"
+ls -la "${GITHUB_WORKSPACE}" 2>/dev/null || echo "Workspace not found"
+echo "Dehydrate directory contents:"
+ls -la "${GITHUB_WORKSPACE}/dehydrate" 2>/dev/null || echo "Dehydrate directory not found"
+echo "Output directory contents:"
+ls -la "$OUTPUT_DIR" 2>/dev/null || echo "Output directory not found"
+
 # Check if dehydrate binary exists
 if [ ! -f "$DEHYDRATE" ]; then
     echo -e "${RED}Error: dehydrate binary not found at $DEHYDRATE${NC}"
     echo "Please run ./build.sh first to build dehydrate"
+    
+    if [ -n "${GITEA_CONTAINER_NAME:-}" ]; then
+        echo "Checking if build directory exists..."
+        BUILD_DIR="${GITHUB_WORKSPACE}/dehydrate/build"
+        if [ -d "$BUILD_DIR" ]; then
+            echo "Build directory exists, checking contents:"
+            ls -la "$BUILD_DIR"
+        else
+            echo "Build directory $BUILD_DIR does not exist"
+        fi
+    fi
+    
     exit 1
 fi
 

getpkg/Dockerfile.dropshell-build

@@ -1,76 +0,0 @@
-ARG IMAGE_TAG
-FROM gitea.jde.nz/public/dropshell-build-base:latest AS builder
-
-ARG PROJECT
-ARG CMAKE_BUILD_TYPE=Debug
-
-# Set working directory
-WORKDIR /app
-
-SHELL ["/bin/bash", "-c"]
-
-# Create cache directories
-RUN mkdir -p /ccache
-
-# Set up ccache
-ENV CCACHE_DIR=/ccache
-ENV CCACHE_COMPILERCHECK=content
-ENV CCACHE_MAXSIZE=2G
-
-# Copy only build files first (for better layer caching)
-COPY CMakeLists.txt cmake_prebuild.sh ./
-COPY src/version.hpp.in src/
-
-# Run prebuild script early (this rarely changes)
-RUN bash cmake_prebuild.sh
-
-# Copy source files (this invalidates cache when source changes)
-COPY src/ src/
-
-# Configure project (this step is cached unless CMakeLists.txt changes)
-RUN --mount=type=cache,target=/ccache \
-    --mount=type=cache,target=/build \
-    mkdir -p /build && \
-    cmake -G Ninja -S /app -B /build \
-    -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} \
-    -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-    -DCMAKE_C_COMPILER_LAUNCHER=ccache \
-    -DCMAKE_EXE_LINKER_FLAGS="-fuse-ld=mold -static -g" \
-    -DCMAKE_CXX_FLAGS="-g -fno-omit-frame-pointer" \
-    -DPROJECT_NAME="${PROJECT}" \
-    -DCMAKE_STRIP=OFF \
-    ${CMAKE_TOOLCHAIN_FILE:+-DCMAKE_TOOLCHAIN_FILE=$CMAKE_TOOLCHAIN_FILE}
-
-# Run prebuild script
-RUN --mount=type=cache,target=/ccache \
-    --mount=type=cache,target=/build \
-    cmake --build /build --target run_prebuild_script
-
-# Build project (ccache will help here when only some files change)
-RUN --mount=type=cache,target=/ccache \
-    --mount=type=cache,target=/build \
-    cmake --build /build
-
-# Copy the built executable to a regular directory for the final stage
-RUN --mount=type=cache,target=/build \
-    mkdir -p /output && \
-    find /build -type f -executable -name "*${PROJECT}*" -exec cp {} /output/${PROJECT} \; || \
-    find /build -type f -executable -exec cp {} /output/${PROJECT} \;
-
-
-# if we're a release build, then run upx on the binary.
-RUN if [ "${CMAKE_BUILD_TYPE}" = "Release" ]; then \
-        upx /output/${PROJECT}; \
-    fi
-
-# Final stage that only contains the binary
-FROM scratch AS project
-
-ARG PROJECT
-
-# Copy CA certificates for SSL validation
-#COPY --from=builder /etc/ssl/certs/ /etc/ssl/certs/
-
-# Copy the actual binary from the regular directory
-COPY --from=builder /output/${PROJECT} /${PROJECT}
-

getpkg/build.sh

@@ -1,32 +1,52 @@
 #!/bin/bash
-
 set -euo pipefail
 
+# Get script directory - handle different execution contexts
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+PROJECT="$(basename "${SCRIPT_DIR}")"
 
+# Debug output for CI
+echo "${PROJECT} build script running from: ${SCRIPT_DIR}"
 
-export CMAKE_BUILD_TYPE="Debug"
+# handle running locally, or docker in docker via gitea runner.
-
+if [ -n "${GITEA_CONTAINER_NAME:-}" ]; then
-rm -rf "${SCRIPT_DIR}/output" 
+  echo "We're in a gitea container: ${GITEA_CONTAINER_NAME}"
-mkdir -p "${SCRIPT_DIR}/output"
+  VOLUME_OPTS=("--volumes-from=${GITEA_CONTAINER_NAME}")
-
+  WORKING_DIR=("-w" "${GITHUB_WORKSPACE}/${PROJECT}")
-PROJECT="getpkg"
+  BUILD_DIR="${GITHUB_WORKSPACE}/${PROJECT}/build"
-
+  OUTPUT_DIR="${GITHUB_WORKSPACE}/${PROJECT}/output"
-# make sure we have the latest base image.
+else
-docker pull gitea.jde.nz/public/dropshell-build-base:latest
+  VOLUME_OPTS=("-v" "${SCRIPT_DIR}:/app")
-
+  WORKING_DIR=("-w" "/app")
-# Build with or without cache based on NO_CACHE environment variable
+  BUILD_DIR="${SCRIPT_DIR}/build"
-CACHE_FLAG=""
+  OUTPUT_DIR="${SCRIPT_DIR}/output"
-if [ "${NO_CACHE:-false}" = "true" ]; then
-    CACHE_FLAG="--no-cache"
 fi
 
-docker build \
+# Create output directory
-  ${CACHE_FLAG} \
+mkdir -p "${OUTPUT_DIR}"
-  -t "${PROJECT}-build" \
-  -f "${SCRIPT_DIR}/Dockerfile.dropshell-build" \
-  --build-arg PROJECT="${PROJECT}" \
-  --build-arg CMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}" \
-  --output "${SCRIPT_DIR}/output" \
-  "${SCRIPT_DIR}"
 
+# Run build in container with mounted directories
+COMMAND_TO_RUN="cmake -G Ninja -S . -B ./build \
+                -DCMAKE_BUILD_TYPE=\${CMAKE_BUILD_TYPE} \
+                -DPROJECT_NAME=${PROJECT} && \
+                cmake --build ./build" 
+
+echo "Building in new docker container"
+docker run --rm \
+  --user "$(id -u):$(id -g)" \
+  "${VOLUME_OPTS[@]}" \
+  "${WORKING_DIR[@]}" \
+  -e CMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE:-Debug}" \
+  gitea.jde.nz/public/dropshell-build-base:latest \
+  bash -c "${COMMAND_TO_RUN}"
+
+# Copy built executable to output directory
+if [ -f "${BUILD_DIR}/${PROJECT}" ]; then
+  cp "${BUILD_DIR}/${PROJECT}" "${OUTPUT_DIR}/"
+  echo "✓ Build successful - ${PROJECT} copied to ${OUTPUT_DIR}/"
+else
+  echo "✗ Build failed - ${PROJECT} not found in ${BUILD_DIR}/"
+  exit 1
+fi
+
+echo "Build complete"

getpkg/clean.sh

@@ -3,22 +3,16 @@
 set -euo pipefail
 
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
-PROJECT="getpkg"
+PROJECT="$(basename "$(dirname "${SCRIPT_DIR}")")"
 
 echo "Cleaning ${PROJECT}..."
 
-# Remove output directory
+# Remove output and build directories
-if [ -d "${SCRIPT_DIR}/output" ]; then
+for dir in "output" "build"; do
-    echo "Removing output directory..."
+    if [ -d "${SCRIPT_DIR}/${dir}" ]; then
-    rm -rf "${SCRIPT_DIR}/output"
+        echo "Removing ${dir} directory..."
-fi
+        rm -rf "${SCRIPT_DIR:?}/${dir}"
-
+    fi
-# Remove Docker images related to this project
+done
-echo "Removing Docker images..."
-docker images --filter "reference=${PROJECT}-build*" -q | xargs -r docker rmi -f
-
-# Remove Docker build cache
-echo "Pruning Docker build cache..."
-docker builder prune -f
 
 echo "✓ ${PROJECT} cleaned successfully"

getpkg/publish.sh

@@ -34,22 +34,7 @@ heading "Building ${PROJECT}"
 
 # build release version
 export CMAKE_BUILD_TYPE="Release"
-
+"${SCRIPT_DIR}/build.sh"
-# Build with or without cache based on NO_CACHE environment variable
-CACHE_FLAG=""
-if [ "${NO_CACHE:-false}" = "true" ]; then
-    CACHE_FLAG="--no-cache"
-fi
-
-docker build \
-  ${CACHE_FLAG} \
-  -t "${PROJECT}-build" \
-  -f "${SCRIPT_DIR}/Dockerfile.dropshell-build" \
-  --build-arg PROJECT="${PROJECT}" \
-  --build-arg CMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}" \
-  --output "${OUTPUT}" \
-  "${SCRIPT_DIR}"
-
 [ -f "${OUTPUT}/${PROJECT}" ] || die "Build failed."
 
 #--------------------------------------------------------------------------------

getpkg/src/main.cpp

@@ -1150,6 +1150,85 @@ void show_help() {
     std::cout << "  ~/.local/bin/getpkg/                  Installed tool binaries" << std::endl;
 }
 
+int autocomplete_command(int argc, char* argv[]) {
+    std::vector<std::string> args(argv + 2, argv + argc);
+    
+    // If no arguments, return all commands
+    if (args.empty()) {
+        std::cout << "install\n";
+        std::cout << "uninstall\n";
+        std::cout << "publish\n";
+        std::cout << "unpublish\n";
+        std::cout << "update\n";
+        std::cout << "version\n";
+        std::cout << "create\n";
+        std::cout << "hash\n";
+        std::cout << "list\n";
+        std::cout << "clean\n";
+        std::cout << "help\n";
+        return 0;
+    }
+    
+    const std::string& subcommand = args[0];
+    
+    // Handle autocompletion for specific commands
+    if (subcommand == "install") {
+        // For install, we could suggest popular packages or recently published ones
+        // For now, just return empty (no specific completions)
+        return 0;
+    } else if (subcommand == "uninstall") {
+        // For uninstall, list installed tools
+        std::filesystem::path configDir = std::filesystem::path(std::getenv("HOME")) / ".config" / "getpkg";
+        if (std::filesystem::exists(configDir)) {
+            for (const auto& entry : std::filesystem::directory_iterator(configDir)) {
+                if (entry.path().extension() == ".json") {
+                    std::string toolName = entry.path().stem().string();
+                    std::cout << toolName << "\n";
+                }
+            }
+        }
+        return 0;
+    } else if (subcommand == "publish") {
+        // For publish, suggest architecture suffixes after tool name
+        if (args.size() >= 2) {
+            // If we have tool_name already, suggest architectures
+            std::cout << "x86_64\n";
+            std::cout << "aarch64\n";
+            std::cout << "universal\n";
+        }
+        return 0;
+    } else if (subcommand == "unpublish") {
+        // For unpublish, list installed tools (similar to uninstall)
+        std::filesystem::path configDir = std::filesystem::path(std::getenv("HOME")) / ".config" / "getpkg";
+        if (std::filesystem::exists(configDir)) {
+            for (const auto& entry : std::filesystem::directory_iterator(configDir)) {
+                if (entry.path().extension() == ".json") {
+                    std::string toolName = entry.path().stem().string();
+                    std::cout << toolName << "\n";
+                    // Also suggest with architecture suffixes
+                    std::cout << toolName << ":x86_64\n";
+                    std::cout << toolName << ":aarch64\n";
+                    std::cout << toolName << ":universal\n";
+                }
+            }
+        }
+        return 0;
+    } else if (subcommand == "create") {
+        // For create, no specific completions (tool name and directory are user-defined)
+        return 0;
+    } else if (subcommand == "hash") {
+        // For hash, suggest file extensions
+        if (args.size() >= 2) {
+            std::cout << "*.tgz\n";
+            std::cout << "*.tar.gz\n";
+        }
+        return 0;
+    }
+    
+    // No specific completions for other commands
+    return 0;
+}
+
 } // end anonymous namespace
 
 int main(int argc, char* argv[]) {
@@ -1169,19 +1248,7 @@ int main(int argc, char* argv[]) {
     } else if (command == "update") {
         return update_tool(argc, argv);
     } else if (command == "autocomplete") {
-        std::vector<std::string> args(argv + 2, argv + argc);
+        return autocomplete_command(argc, argv);
-        if (args.empty()) std::cout << R"(install
-uninstall
-publish
-unpublish
-update
-version
-create
-hash
-list
-clean
-help
-)";
     } else if (command == "version") {
         std::cout << dropshell::VERSION << std::endl;
     } else if (command == "create") {

getpkg/test.sh

@@ -455,12 +455,13 @@ EOF
             CONFIG_EXISTS=false
             TOOL_DIR_EXISTS=false
             SYMLINK_EXISTS=false
-            HELPER_SYMLINK_EXISTS=false
+            # HELPER_SYMLINK_EXISTS=false
             
             [ -f ~/.config/getpkg/"${TEST_UNINSTALL_TOOL}.json" ] && CONFIG_EXISTS=true
             [ -d ~/.getpkg/"$TEST_UNINSTALL_TOOL" ] && TOOL_DIR_EXISTS=true
             [ -L ~/.local/bin/getpkg/"$TEST_UNINSTALL_TOOL" ] && SYMLINK_EXISTS=true
-            [ -L ~/.local/bin/getpkg/"${TEST_UNINSTALL_TOOL}-helper" ] && HELPER_SYMLINK_EXISTS=true
+            # Check if helper symlink exists (not currently used in validation)
+            # [ -L ~/.local/bin/getpkg/"${TEST_UNINSTALL_TOOL}-helper" ] && HELPER_SYMLINK_EXISTS=true
             
             if $CONFIG_EXISTS && $TOOL_DIR_EXISTS && $SYMLINK_EXISTS; then
                 # Now uninstall
@@ -589,7 +590,7 @@ echo "Universal arch unpublish test"' > "$UNPUBLISH_TEST_DIR/$UNPUBLISH_TOOL_CUS
         UNPUBLISH_CUSTOM_OUTPUT=$("$GETPKG" unpublish "$UNPUBLISH_TOOL_CUSTOM" 2>&1)
         UNPUBLISH_CUSTOM_EXIT_CODE=$?
         
-        if [ $UNPUBLISH_CUSTOM_EXIT_CODE -eq 0 ] && [[ "$UNPUBLISH_CUSTOM_OUTPUT" =~ "Found ${UNPUBLISH_TOOL_CUSTOM}:universal" ]]; then
+        if [ $UNPUBLISH_CUSTOM_EXIT_CODE -eq 0 ] && [[ "$UNPUBLISH_CUSTOM_OUTPUT" =~ Found\ ${UNPUBLISH_TOOL_CUSTOM}:universal ]]; then
             print_test_result "Unpublish finds universal architecture" 0
         else
             print_test_result "Unpublish finds universal architecture" 1