Modify dehydrate/build.sh

.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]

bb64/clean.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+PROJECT="bb64"
+
+echo "Cleaning ${PROJECT}..."
+
+# Remove output directory
+if [ -d "${SCRIPT_DIR}/output" ]; then
+    echo "Removing output directory..."
+    rm -rf "${SCRIPT_DIR}/output"
+fi
+
+# Remove Docker images related to this project
+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"

bb64/publish.sh

@@ -20,7 +20,14 @@ echo "Building version $VERSION" >&2
 # build release version
 export CMAKE_BUILD_TYPE="Release"
 
+# 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}" \

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'
@@ -119,7 +109,7 @@ function buildtestpublish() {
     # Add to projects list
     PROJECTS+=("$TOOLNAME")
 
-    cd "$dir" || echo "Failed to cd to $dir"
+    #cd "$dir" || echo "Failed to cd to $dir"
 
     subtitle "🔨 BUILDING $TOOLNAME_UPPER 🔨"
     if dothis build "$dir" "$TOOLNAME"; then
@@ -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

clean.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+
+echo "🧹 CLEANING ALL PROJECTS 🧹"
+echo
+
+# Get all project directories
+PROJECT_DIRS=$(find "$SCRIPT_DIR" -maxdepth 1 -type d \
+    -not -name ".*" \
+    -not -path "$SCRIPT_DIR" | sort)
+
+for dir in $PROJECT_DIRS; do
+    PROJECT_NAME=$(basename "$dir")
+    
+    if [ -f "$dir/clean.sh" ]; then
+        echo "Cleaning $PROJECT_NAME..."
+        cd "$dir"
+        ./clean.sh
+        echo
+    else
+        echo "⚠️  No clean.sh found for $PROJECT_NAME, skipping..."
+        echo
+    fi
+done
+
+# Global Docker cleanup
+echo "🐳 Global Docker cleanup..."
+echo "Removing unused Docker images..."
+docker image prune -f
+
+echo "Removing unused Docker containers..."
+docker container prune -f
+
+echo "Removing unused Docker networks..."
+docker network prune -f
+
+echo "Removing unused Docker volumes..."
+docker volume prune -f
+
+echo
+echo "✅ All projects cleaned successfully!"

dehydrate/Dockerfile.dropshell-build

@@ -1,65 +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 build files
-COPY CMakeLists.txt ./
-COPY src/version.hpp.in src/
-
-# Copy source files
-COPY src/ src/
-COPY contrib/ contrib/
-
-# Configure project
-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" \
-    -DCMAKE_C_FLAGS="-g -fno-omit-frame-pointer" \
-    -DPROJECT_NAME="${PROJECT}" \
-    -DCMAKE_STRIP=OFF \
-    ${CMAKE_TOOLCHAIN_FILE:+-DCMAKE_TOOLCHAIN_FILE=$CMAKE_TOOLCHAIN_FILE}
-
-# Build project
-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 the actual binary from the regular directory
-COPY --from=builder /output/${PROJECT} /${PROJECT}

dehydrate/build.sh

@@ -1,29 +1,26 @@
 #!/bin/bash
-
 set -euo pipefail
 
+# Get script directory - handle different execution contexts
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
-PROJECT="dehydrate"
+PROJECT="$(basename "$(dirname "${SCRIPT_DIR}")")"
 
-export CMAKE_BUILD_TYPE="Debug"
+# Debug output for CI
+echo "${PROJECT} build script running from: ${SCRIPT_DIR}"
 
-rm -rf "${SCRIPT_DIR}/output" 
-mkdir -p "${SCRIPT_DIR}/output"
+# 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 && \
+                cp ./build/${PROJECT} ./output/"
 
-# make sure we have the latest base image.
-docker pull gitea.jde.nz/public/dropshell-build-base:latest
+  echo "Building in new docker container"
+  docker run --rm \
+    --user "$(id -u):$(id -g)" \
+    -v "${SCRIPT_DIR}:/app" \
+    -e CMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE:-Debug}" \
+    gitea.jde.nz/public/dropshell-build-base:latest \
+    bash -c "cd /app && ${COMMAND_TO_RUN}"
 
-# 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 "${SCRIPT_DIR}/output" \
-  "${SCRIPT_DIR}"
+echo "Build complete"

dehydrate/clean.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+PROJECT="$(basename "$(dirname "${SCRIPT_DIR}")")"
+
+echo "Cleaning ${PROJECT}..."
+
+# Remove output and build directories
+for dir in "output" "build"; do
+    if [ -d "${SCRIPT_DIR}/${dir}" ]; then
+        echo "Removing ${dir} directory..."
+        rm -rf "${SCRIPT_DIR:?}/${dir}"
+    fi
+done
+
+echo "✓ ${PROJECT} cleaned successfully"

dehydrate/publish.sh

@@ -35,14 +35,7 @@ heading "Building ${PROJECT}"
 
 # build release version
 export CMAKE_BUILD_TYPE="Release"
-
-docker build \
-  -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}"
+"${SCRIPT_DIR}/build.sh"
 
 [ -f "${OUTPUT}/${PROJECT}" ] || die "Build failed."
 

dehydrate/test/build_dehydrate_test.sh

@@ -4,7 +4,7 @@
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 PROJECT_DIR="$( cd "$SCRIPT_DIR/.." && pwd )"
 
-cd "$SCRIPT_DIR"
+cd "$SCRIPT_DIR" || exit 1
 
 # Clean up old test data and any existing binaries
 # Force removal with chmod to handle permission issues

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,26 @@
 #!/bin/bash
-
 set -euo pipefail
 
+# Get script directory - handle different execution contexts
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+PROJECT="$(basename "$(dirname "${SCRIPT_DIR}")")"
 
+# Debug output for CI
+echo "${PROJECT} build script running from: ${SCRIPT_DIR}"
 
-export CMAKE_BUILD_TYPE="Debug"
+# 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 && \
+                cp ./build/${PROJECT} ./output/"
 
-rm -rf "${SCRIPT_DIR}/output" 
-mkdir -p "${SCRIPT_DIR}/output"
-
-PROJECT="getpkg"
-
-# make sure we have the latest base image.
-docker pull gitea.jde.nz/public/dropshell-build-base:latest
-
-# 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 "${SCRIPT_DIR}/output" \
-  "${SCRIPT_DIR}"
+  echo "Building in new docker container"
+  docker run --rm \
+    --user "$(id -u):$(id -g)" \
+    -v "${SCRIPT_DIR}:/app" \
+    -e CMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE:-Debug}" \
+    gitea.jde.nz/public/dropshell-build-base:latest \
+    bash -c "cd /app && ${COMMAND_TO_RUN}"
 
+echo "Build complete"

getpkg/clean.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+PROJECT="$(basename "$(dirname "${SCRIPT_DIR}")")"
+
+echo "Cleaning ${PROJECT}..."
+
+# Remove output and build directories
+for dir in "output" "build"; do
+    if [ -d "${SCRIPT_DIR}/${dir}" ]; then
+        echo "Removing ${dir} directory..."
+        rm -rf "${SCRIPT_DIR:?}/${dir}"
+    fi
+done
+
+echo "✓ ${PROJECT} cleaned successfully"

getpkg/publish.sh

@@ -34,15 +34,7 @@ heading "Building ${PROJECT}"
 
 # build release version
 export CMAKE_BUILD_TYPE="Release"
-
-docker build \
-  -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}"
-
+"${SCRIPT_DIR}/build.sh"
 [ -f "${OUTPUT}/${PROJECT}" ] || die "Build failed."
 
 #--------------------------------------------------------------------------------

getpkg/src/main.cpp

@@ -76,6 +76,17 @@
 namespace {
 using json = nlohmann::json;
 
+// Clear current line and reset cursor to beginning
+void clearLine() {
+    std::cout << "\r\033[K" << std::flush;
+}
+
+// Clear current line and print message
+void clearAndPrint(const std::string& message) {
+    clearLine();
+    std::cout << message << std::flush;
+}
+
 // Compare versions (returns true if v1 < v2)
 bool isVersionOlder(const std::string& v1, const std::string& v2) {
     // Simple version comparison - assumes versions are in YYYY.MMDD.HHMM format
@@ -215,14 +226,14 @@ int install_tool(int argc, char* argv[]) {
     std::cout << "Downloading " << toolName << "..." << std::flush;
     if (!getbin2.download(toolName, arch, archivePath.string(), progressCallback)) {
         // Try universal version as fallback
-        std::cout << "\rArch-specific version not found, trying universal..." << std::endl;
+        clearAndPrint("Arch-specific version not found, trying universal...\n");
         if (!getbin2.download(toolName, "universal", archivePath.string(), progressCallback)) {
             std::cerr << "\rFailed to download tool archive (tried both " << arch << " and universal)." << std::endl;
             return 1;
         }
         downloadArch = "universal";
     }
-    std::cout << "\rDownloading " << toolName << "... done" << std::endl;
+    clearAndPrint("Downloading " + toolName + "... done\n");
     
     // Unpack tool
     std::cout << "Unpacking..." << std::flush;
@@ -230,13 +241,13 @@ int install_tool(int argc, char* argv[]) {
         std::cerr << "\rFailed to unpack tool archive." << std::endl;
         return 1;
     }
-    std::cout << "\rUnpacking... done" << std::endl;
+    clearAndPrint("Unpacking... done\n");
         
     // Add to PATH and autocomplete
     std::cout << "Configuring..." << std::flush;
     scriptManager.addToolEntry(toolName, binDir.string());
     scriptManager.addAutocomplete(toolName);
-    std::cout << "\rConfiguring... done" << std::endl;
+    clearAndPrint("Configuring... done\n");
     
     // Get tool info
     std::string hash;
@@ -347,7 +358,7 @@ int publish_tool(int argc, char* argv[]) {
         std::cerr << "\rFailed to upload archive." << std::endl;
         return 1;
     }
-    std::cout << "\rUploading... done" << std::endl;
+    clearAndPrint("Uploading... done\n");
     std::cout << "Published! URL: " << url << "\nHash: " << hash << std::endl;
     return 0;
 }
@@ -426,7 +437,7 @@ int update_tool(int argc, char* argv[]) {
             tool.status = "Check failed";
         }
     }
-    std::cout << "\r" << std::string(50, ' ') << "\r" << std::flush; // Clear progress line
+    clearLine(); // Clear progress line
     
     // Step 2: Update tools that need updating
     std::vector<std::tuple<std::string, std::string, std::string>> updateResults;
@@ -484,7 +495,7 @@ int update_tool(int argc, char* argv[]) {
                 
                 if (result == 0) {
                     tool.status = "Updated";
-                    std::cout << " Updated" << std::endl;
+                    clearAndPrint("Updated\n");
                     
                     // Re-read version after update
                     std::filesystem::path toolInfoPath = configDir / (tool.name + ".json");
@@ -502,7 +513,7 @@ int update_tool(int argc, char* argv[]) {
                     }
                 } else {
                     tool.status = "Failed";
-                    std::cout << " Failed" << std::endl;
+                    clearAndPrint("Failed\n");
                 }
             }
         }

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

sos/clean.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+PROJECT="sos"
+
+echo "Cleaning ${PROJECT}..."
+
+# Remove output directory (if it exists)
+if [ -d "${SCRIPT_DIR}/output" ]; then
+    echo "Removing output directory..."
+    rm -rf "${SCRIPT_DIR}/output"
+fi
+
+# Remove any temporary files
+echo "Removing temporary files..."
+find "${SCRIPT_DIR}" -name "*.tmp" -o -name "*.temp" -o -name "*~" | xargs -r rm -f
+
+echo "✓ ${PROJECT} cleaned successfully"