'Generic Commit'

.gitea/workflows/test.yaml

@@ -14,14 +14,26 @@ jobs:
         uses: actions/checkout@v4
       - name: Install build dependencies
         run: |
-          cd ${{ gitea.workspace }}/source
+          cd source
           ./install_build_prerequisites.sh
-      - name: Build
+      - name: Build Native
         run: |
-          cd ${{ gitea.workspace }}/source
+          cd source
-          ./multibuild.sh
+          ./build_native.sh
       - name: Test
         run: |
-          cd ${{ gitea.workspace }}/source/output
+          cd source
-          ./dropshell_x86_64 list
+          ./test.sh
-          ./dropshell_x86_64 help
+      - name: Build Production
+        run: |
+          cd source
+          ./build_production.sh
+      - name: Test
+        run: |
+          cd source
+          ./test.sh
+      - name: Publish
+        run: |
+          cd source
+          ./publish.sh
+  

dropshell-install.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+set -euo pipefail
+
+# download and install dropshell
+
+# 1. Determine architecture
+# ----------------------------------------------------------------------------- 
+
+ARCH=$(uname -m)
+
+TARGET_PATH="${HOME}/.local/bin/dropshell"
+[ ! -f "${TARGET_PATH}" ] || rm -f "${TARGET_PATH}"
+mkdir -p "$(dirname "${TARGET_PATH}")"
+curl -L -s -o "${TARGET_PATH}" "https://getbin.xyz/dropshell.${ARCH}" || die "Failed to download dropshell for ${ARCH}"
+chmod +x "${TARGET_PATH}"
+echo "dropshell installed successfully to $TARGET_PATH"
+echo " "
+
+echo "Please:"
+echo "1. run '${TARGET_PATH} edit' to edit the configuration."
+echo "2. run '${TARGET_PATH} install' to install dropshell components on this computer."
+echo "3. run 'source ~/.bashrc' to add to your path and autocomplete for the current shell."

install.sh

@@ -1,49 +0,0 @@
-#!/bin/bash
-set -e
-
-# download and install dropshell
-
-# 1. Determine architecture
-# ----------------------------------------------------------------------------- 
-
-ARCH=$(uname -m)
-if [[ "$ARCH" == "x86_64" ]]; then
-    BIN=dropshell.x86_64
-elif [[ "$ARCH" == "aarch64" || "$ARCH" == "arm64" ]]; then
-    BIN=dropshell.aarch64
-else
-    echo "Unsupported architecture: $ARCH" >&2
-    exit 1
-fi
-
-
-# 2. Download the appropriate binary to a temp directory
-# -----------------------------------------------------------------------------
-TMPDIR=$(mktemp -d)
-trap 'rm -rf "$TMPDIR"' EXIT
-URL="https://gitea.jde.nz/public/dropshell/releases/download/latest/$BIN"
-echo "Downloading $BIN from $URL..."
-
-TARGET_PATH="${HOME}/.local/bin/dropshell"
-
-mkdir -p "${HOME}/.local/bin"
-
-curl -fsSL -o "$TARGET_PATH" "$URL"
-
-if [ ! -f "$TARGET_PATH" ]; then
-    echo "Failed to download dropshell" >&2
-    exit 1
-fi
-
-chmod +x "$TARGET_PATH"
-
-if [ ! -f "${HOME}/.local/bin/ds" ]; then
-    ln -s "$TARGET_PATH" "${HOME}/.local/bin/ds"
-fi
-
-echo "dropshell installed successfully to $TARGET_PATH"
-
-echo "Please:"
-echo "1. run '${TARGET_PATH} edit' to edit the configuration."
-echo "2. run '${TARGET_PATH} install' to install dropshell components on this computer."
-echo "3. run 'source ~/.bashrc' to add to your path and autocomplete for the current shell."

source/agent-remote/agent-install.sh

@@ -21,16 +21,13 @@ fi
 _check_required_env_vars "AGENT_PATH"
 
 function install_bb64() {    
-    curl -fsSL "https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh" | bash -s -- "$AGENT_PATH" "$(id -u $USER):$(id -g $USER)"
+    if ! curl -fsSL "https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh" | \
-
+            bash -s -- "$AGENT_PATH" "$(id -u "$USER"):$(id -g "$USER")"; then
-    # test result code from curl
-    if [ $? -ne 0 ]; then
         _die "Failed to install bb64. Curl returned non-zero exit code."
     fi
 
     # test if bb64 is installed
-    VER=$("$AGENT_PATH/bb64" -v)
+    if ! VER=$("$AGENT_PATH/bb64" -v); then
-    if [ $? -ne 0 ]; then
         _die "bb64 did not install correctly."
     fi
 

source/agent-remote/common.sh

@@ -153,7 +153,7 @@ _get_container_logs() {
 _check_required_env_vars() {
     local required_vars=("$@")
     for var in "${required_vars[@]}"; do
-        if [ -z "${!var}" ]; then
+        if [ -z "${!var:-}" ]; then
             _die "Required environment variable $var is not set"
         fi
     done

source/agent-remote/datacommands.sh

@@ -118,8 +118,8 @@ _autocommandrun_file() {
             echo "Restoring file ${filepath}"
             local file_name;
             file_name=$(basename "${filepath}")
-            rm -f "${filepath}" || die "Unable to remove existing file ${filepath}, restore failed."
+            rm -f "${filepath}" || return_die "Unable to remove existing file ${filepath}, restore failed."
-            cp "${backup_folder}/${file_name}" "${filepath}" || die "Unable to copy file ${backup_folder}/${file_name} to ${filepath}, restore failed."
+            cp "${backup_folder}/${file_name}" "${filepath}" || return_die "Unable to copy file ${backup_folder}/${file_name} to ${filepath}, restore failed."
             ;;
     esac
 }

source/build_native.sh

@@ -6,7 +6,14 @@ INSTALL_DIR=${HOME}/.local/bin
 mkdir -p "${OUTPUT_DIR}"
 
 # Exit on error
-set -e
+set -euo pipefail
+
+ARCH=$(uname -m)
+if [ "$ARCH" != "x86_64" ] && [ "$ARCH" != "aarch64" ]; then
+    echo "Unsupported architecture: $ARCH"
+    exit 1
+fi
+
 
 function build_native() {
     local BUILDDIR=${SCRIPT_DIR}/build/native
@@ -16,8 +23,8 @@ function build_native() {
     mkdir -p "${BUILDDIR}"
     cd "${SCRIPT_DIR}" || exit 1
 
-    CC="${HOME}/.musl-cross/x86_64-linux-musl-native/bin/x86_64-linux-musl-gcc"
+    CC="${HOME}/.musl-cross/${ARCH}-linux-musl-native/bin/${ARCH}-linux-musl-gcc"
-    CXX="${HOME}/.musl-cross/x86_64-linux-musl-native/bin/x86_64-linux-musl-g++"
+    CXX="${HOME}/.musl-cross/${ARCH}-linux-musl-native/bin/${ARCH}-linux-musl-g++"
 
 
     cmake -B "${BUILDDIR}" -G Ninja \
@@ -32,15 +39,15 @@ function build_native() {
     ninja -j"$JOBS"
 
     #upx ${BUILDDIR}/dropshell
-    cp "${BUILDDIR}/dropshell" "${OUTPUT_DIR}/dropshell.native"
+    cp "${BUILDDIR}/dropshell" "${OUTPUT_DIR}/dropshell.${ARCH}"
 
     cd "${PREVDIR}" || exit 1
 }
 
 build_native
 
+
 echo "Auto-installing dropshell locally..."
 mkdir -p "${INSTALL_DIR}"
-cp "${OUTPUT_DIR}/dropshell.native" "${INSTALL_DIR}/dropshell"
+cp "${OUTPUT_DIR}/dropshell.${ARCH}" "${INSTALL_DIR}/dropshell"
-ds version
 echo "Build process completed!" 

source/build_production.sh

@@ -1,15 +1,15 @@
 #!/bin/bash
-
+set -euo pipefail
 SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
 
 # Create output directory
-mkdir -p ${SCRIPT_DIR}/output
+mkdir -p "${SCRIPT_DIR}/output"
-
+PREV_DIR=$(pwd)
+cd "${SCRIPT_DIR}"
+trap 'cd "${PREV_DIR}"' EXIT
 
 function build_arch() {
     local arch=$1
-    local PREVDIR=$PWD
-    cd ${SCRIPT_DIR}
 
     if [ ! -f "${HOME}/.musl-cross/${arch}-linux-musl-cross/bin/${arch}-linux-musl-c++" ]; then
         echo "Musl cross compiler for ${arch} not found. Please run install_build_prerequisites.sh first."
@@ -20,16 +20,14 @@ function build_arch() {
     CC="${HOME}/.musl-cross/${arch}-linux-musl-cross/bin/${arch}-linux-musl-gcc"
     CXX="${HOME}/.musl-cross/${arch}-linux-musl-cross/bin/${arch}-linux-musl-g++"
 
-    BUILDDIR=${SCRIPT_DIR}/build/${arch}
+    BUILDDIR="${SCRIPT_DIR}/build/${arch}"
-    mkdir -p ${BUILDDIR}
+    mkdir -p "${BUILDDIR}"  
 
-    cmake -B ${BUILDDIR} -G Ninja -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DCMAKE_C_COMPILER=${CC} -DCMAKE_CXX_COMPILER=${CXX}
+    cmake -B "${BUILDDIR}" -G Ninja -DCMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}" -DCMAKE_C_COMPILER="${CC}" -DCMAKE_CXX_COMPILER="${CXX}"
-    cmake --build ${BUILDDIR}
+    cmake --build "${BUILDDIR}"
 
-    upx ${BUILDDIR}/dropshell
+    upx "${BUILDDIR}/dropshell"
-    cp ${BUILDDIR}/dropshell ${SCRIPT_DIR}/output/dropshell.${arch}
+    cp "${BUILDDIR}/dropshell" "${SCRIPT_DIR}/output/dropshell.${arch}"
-    
-    cd ${PREVDIR}
 }
 
 build_arch x86_64

source/install_build_prerequisites.sh

@@ -64,7 +64,9 @@ esac
 # Function to check if a package is installed
 is_package_installed() {
     if [ "$OS" = "Alpine Linux" ]; then
-        apk info | grep -q "^$1$"
+        # Use apk info <pkg> and check exit status
+        apk info "$1" >/dev/null 2>&1
+        return $?
     else
         dpkg -l "$1" 2>/dev/null | grep -q "^ii"
     fi

source/publish.sh

@@ -9,74 +9,21 @@ echo "Script directory: $SCRIPT_DIR"
 TOKEN="${GITEA_TOKEN_DEPLOY:-${GITEA_TOKEN}}"
 [ -z "$TOKEN" ] && { echo "Neither GITEA_TOKEN_DEPLOY nor GITEA_TOKEN environment variable set!" >&2; exit 1; }
 
-"$SCRIPT_DIR/multibuild.sh"
-#BUILD_DIR=$SCRIPT_DIR/build
-
 OLD_PWD="$PWD"
 cd "$SCRIPT_DIR" || exit 1
+TEMP_DIR=$(mktemp -d)
+trap 'rm -rf "$TEMP_DIR" && cd "$OLD_PWD"' EXIT
 
-# Check for required binaries
+ARCH=$(uname -m)
-REQUIRED_BINARIES=("dropshell.x86_64" "dropshell.aarch64")
+TAG=$("$SCRIPT_DIR/output/dropshell.${ARCH}" --version)
-for binary in "${REQUIRED_BINARIES[@]}"; do
+[ -z "$TAG" ] && echo "Failed to get version from dropshell.${ARCH}" >&2 && exit 1
-    if [ ! -f "output/$binary" ]; then
-        echo "output/$binary not found!" >&2
-        echo "Please run multibuild.sh first." >&2
-        exit 1
-    fi
-done
-
-TAG=$("$SCRIPT_DIR/output/dropshell.x86_64" --version)
-[ -z "$TAG" ] && echo "Failed to get version from dropshell.x86_64" >&2 && exit 1
-
 echo "Publishing dropshell version $TAG"
 
-# make sure we've commited.
-git add "$SCRIPT_DIR/../" && git commit -m "dropshell release $TAG" && git push
 
-
+function die() {
-# Find repo info from .git/config
+    echo "$@" >&2
-REPO_URL=$(git config --get remote.origin.url)
-if [[ ! $REPO_URL =~ gitea ]]; then
-    echo "Remote origin is not a Gitea repository: $REPO_URL" >&2
     exit 1
-fi
-
-# Extract base URL, owner, and repo
-# Example: https://gitea.example.com/username/reponame.git
-BASE_URL=$(echo "$REPO_URL" | sed -E 's#(https?://[^/]+)/.*#\1#')
-OWNER=$(echo "$REPO_URL" | sed -E 's#.*/([^/]+)/[^/]+(\.git)?$#\1#')
-REPO=$(echo "$REPO_URL" | sed -E 's#.*/([^/]+)(\.git)?$#\1#')
-
-API_URL="$BASE_URL/api/v1/repos/$OWNER/$REPO"
-
-# Create release
-RELEASE_DATA=$(cat <<EOF
-{
-  "tag_name": "$TAG",
-  "name": "$TAG",
-  "body": "dropshell release $TAG",
-  "draft": false,
-  "prerelease": false
 }
-EOF
-)
-
-# Capture stdout and stderr of the curl command
-CURL_OUTPUT=$(curl -X POST "$API_URL/releases" \
-    -H "Content-Type: application/json" \
-    -H "Authorization: token $TOKEN" \
-    -d "$RELEASE_DATA" 2>&1)
-
-# Extract the release ID from the captured output
-RELEASE_ID=$(echo "$CURL_OUTPUT" | grep -o '"id":[0-9]*' | head -1 | cut -d: -f2)
-
-if [ -z "$RELEASE_ID" ]; then
-    echo "Failed to create release on Gitea." >&2
-    echo "Release ID returned: $RELEASE_ID" >&2
-    echo "Curl Output/Error:" >&2
-    echo "$CURL_OUTPUT" >&2
-    exit 1
-fi
 
 # Function to find file in specified locations
 find_file() {
@@ -94,25 +41,17 @@ find_file() {
     return 1
 }
 
+curl -L -s -o "${TEMP_DIR}/sos" "https://getbin.xyz/sos" || die "Failed to download sos"
+chmod +x "${TEMP_DIR}/sos"
+
+
 # Upload binaries and install.sh
-for FILE in dropshell.x86_64 dropshell.aarch64 install.sh server_autosetup.sh; do
+for FILE in dropshell.x86_64 dropshell.aarch64 dropshell-install.sh dropshell-server-autosetup.sh; do
     # Pass the locations directly to the find_file function
     filetoupload=$(find_file "$FILE" "output" "../" ".")
-    if [ -z "$filetoupload" ]; then
+    [ -z "$filetoupload" ] && die "File $FILE not found in expected locations!"
-        echo "File $FILE not found in expected locations!" >&2
-        continue
-    fi
 
-    # Auto-detect content type
+    "${TEMP_DIR}/sos" upload getbin.xyz "$filetoupload" "$FILE:latest" "$FILE:TAG"
-    ctype=$(file --mime-type -b "$filetoupload")
-
-    curl -X POST "$API_URL/releases/$RELEASE_ID/assets?name=$FILE" \
-        -H "Content-Type: $ctype" \
-        -H "Authorization: token $TOKEN" \
-        --data-binary @"$filetoupload"
-    echo "Uploaded $FILE to release $TAG as $ctype."
 done
 
-echo "Published dropshell version $TAG to $REPO_URL (tag $TAG) with binaries."
+echo "Published dropshell $TAG to getbin.xyz"
-
-cd "$OLD_PWD" || exit 1

source/src/commands/create-service.cpp

@@ -103,6 +103,11 @@ namespace dropshell
             if (server_name.empty() || template_name.empty() || service_name.empty())
                 return false;
 
+            if (!legal_service_name(service_name)) {
+                error << "Service name contains illegal characters: " << service_name << std::endl;
+                return false;
+            }
+
             ServerConfig server_info(server_name);
             if (!server_info.is_valid())
             {

source/src/commands/edit.cpp

@@ -94,11 +94,11 @@ int edit_config()
 
     std::string config_file = localfile::dropshell_json();
     if (!edit_file(config_file, false) || !std::filesystem::exists(config_file))
-        return die("Failed to edit config file.");
+        return return_die("Failed to edit config file.");
 
     gConfig().load_config();
     if (!gConfig().is_config_set())
-        return die("Failed to load and parse edited config file!");
+        return return_die("Failed to load and parse edited config file!");
 
     gConfig().save_config(true);
 

source/src/commands/hash.cpp

@@ -0,0 +1,83 @@
+#include "command_registry.hpp"
+#include "config.hpp"
+#include "utils/utils.hpp"
+#include "utils/directories.hpp"
+#include "shared_commands.hpp"
+#include "version.hpp"
+#include "hash.hpp"
+
+#include <unistd.h>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <filesystem>
+#include <libassert/assert.hpp>
+
+namespace dropshell {
+
+void hash_autocomplete(const CommandContext& ctx);
+int hash_handler(const CommandContext& ctx);
+
+static std::vector<std::string> hash_name_list={"hash"};
+
+// Static registration
+struct HashCommandRegister {
+    HashCommandRegister() {
+        CommandRegistry::instance().register_command({
+            hash_name_list,
+            hash_handler,
+            hash_autocomplete,
+            false, // hidden
+            false, // requires_config
+            false, // requires_install
+            0,     // min_args (after command)
+            1,     // max_args (after command)
+            "hash [FILE|DIRECTORY]",
+            "Hash a file or directory.",
+            // heredoc
+            R"(
+            Hash a file or directory recursively.
+            )"
+        });
+    }
+} hash_command_register;
+
+
+void hash_autocomplete(const CommandContext& ctx) {
+    if (ctx.args.size() == 0) {
+        // list all files and directories in the current directory
+        for (const auto& entry : std::filesystem::directory_iterator(".")) {
+            rawout << entry.path().string() << std::endl;
+        }
+    }
+    return;
+}
+
+int hash_handler(const CommandContext& ctx) {
+    std::filesystem::path path = safearg(ctx.args, 0);
+    if (path.empty())
+      path=std::filesystem::current_path();
+
+    if (!std::filesystem::exists(path))
+    {
+        error << "Does not exist: " << path.string() << std::endl;
+        return 1;
+    }
+
+    if (std::filesystem::is_directory(path))
+    {
+        // hash the directory recursively
+        uint64_t hash = hash_directory_recursive(path.string());
+        std::cout << hash << std::endl;
+    }
+    else
+    {
+        // hash the file
+        uint64_t hash = hash_file(path.string());
+        std::cout << hash << std::endl;
+    }
+    return 0;
+}
+
+
+} // namespace dropshell

source/src/commands/install.cpp

@@ -310,7 +310,7 @@ complete -F _dropshell_completions ds
         std::filesystem::remove(exe_path.parent_path() / "dropshell.old");
 
         // execute the new version
-        execlp("bash", "bash", "-c", (parent_path / "dropshell").c_str(), "install", (char *)nullptr);
+        execlp("bash", "bash", "-c", (exe_path.parent_path() / "dropshell").string() + "install", (char *)nullptr);
         error << "Failed to execute new version of dropshell." << std::endl;
         return -1;
     }

source/src/commands/ssh.cpp

@@ -61,6 +61,12 @@ namespace dropshell
             return false;
         }
 
+        if (!legal_service_name(service))
+        {
+            error << "Service name contains illegal characters: " << service << std::endl;
+            return false;
+        }
+
         LocalServiceInfo sinfo = get_service_info(server, service);
         if (!SIvalid(sinfo))
         {

source/src/commands/start.cpp

@@ -51,6 +51,12 @@ namespace dropshell
             return false;
         }
 
+        if (!legal_service_name(service))
+        {
+            error << "Service name contains illegal characters: " << service << std::endl;
+            return false;
+        }
+
         // run the start script.
         bool started = server_env.run_remote_template_command(service, "start", {}, false, {});
 

source/src/commands/stop.cpp

@@ -51,6 +51,12 @@ namespace dropshell
             return false;
         }
 
+        if (!legal_service_name(service))
+        {
+            error << "Service name contains illegal characters: " << service << std::endl;
+            return false;
+        }
+
         // run the stop script.
         bool stopped = server_env.run_remote_template_command(service, "stop", {}, false, {});
 

source/src/servers.cpp

@@ -149,12 +149,20 @@ namespace dropshell
 
     std::string get_user_for_service(const std::string &server, const std::string &service)
     {
+        if (!legal_service_name(service))
+        {
+            error << "Service name contains illegal characters: " + service << std::endl;
+            return "";
+        }
+
         auto services_info = get_server_services_info(server);
         auto it = std::find_if(services_info.begin(), services_info.end(),
                          [&service](const LocalServiceInfo &si)
                          { return si.service_name == service; });
         if (it != services_info.end() && SIvalid(*it))
             return it->user;
+
+        debug << "Couldn't find user for service \"" << service << "\" on server \"" << server << "\"" << std::endl;
         return "";
     }
 

source/src/services.cpp

@@ -80,6 +80,9 @@ namespace dropshell
         if (server_name.empty() || service_name.empty())
             return LocalServiceInfo();
 
+        if (!legal_service_name(service_name))
+            return LocalServiceInfo();
+
         service.service_name = service_name;
 
         service.local_service_path = localpath::service(server_name, service_name);

source/src/templates.cpp

@@ -171,6 +171,11 @@
 
     bool template_manager::create_template(const std::string &template_name) const
     {
+        if (!legal_service_name(template_name)) {
+            error << "Template name contains illegal characters: " << template_name << std::endl;
+            return false;
+        }
+
         // 1. Create a new directory in the user templates directory
         std::vector<std::string> local_server_definition_paths = gConfig().get_local_server_definition_paths();
         

source/src/utils/utils.cpp

@@ -312,7 +312,7 @@ std::string requote(std::string str) {
 }
 
 
-int die(const std::string & msg) {
+int return_die(const std::string & msg) {
     error << "Fatal error:" << std::endl;
     error << msg << std::endl;
     return 1;
@@ -650,4 +650,24 @@ bool file_replace_or_add_segment(std::string filepath, std::string segment)
     return true;
 }
 
+bool legal_service_name(const std::string &service_name) {
+    static bool initialized = false;
+    static bool legal_chars[256] = {false};  // Initialize all to false
+
+    // One-time initialization
+    if (!initialized) {
+        // Set true for valid characters
+        for (unsigned char c : "0123456789"
+                              "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                              "abcdefghijklmnopqrstuvwxyz"
+                              "._-") {
+            legal_chars[c] = true;
+        }
+        initialized = true;
+    }
+
+    return std::all_of(service_name.begin(), service_name.end(),
+        [](unsigned char c) { return legal_chars[c]; });
+}
+
 } // namespace dropshell 

source/src/utils/utils.hpp

@@ -45,7 +45,7 @@ int count_substring(const std::string &substring, const std::string &text);
 
 std::string random_alphanumeric_string(int length);
 
-int die(const std::string & msg);
+int return_die(const std::string & msg);
 std::string safearg(int argc, char *argv[], int index);
 std::string safearg(const std::vector<std::string> & args, int index);
 
@@ -75,4 +75,7 @@ constexpr unsigned int switchhash(const char *s, int off = 0)
     return !s[off] ? 5381 : (switchhash(s, off + 1) * 33) ^ s[off];
 }
 
+bool legal_service_name(const std::string & service_name);
+
+
 } // namespace dropshell 

source/test.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+set -euo pipefail
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+
+ARCH=$(uname -m)
+
+PREV_DIR=$(pwd)
+trap 'cd "$PREV_DIR"' EXIT
+
+"$SCRIPT_DIR/output/dropshell.${ARCH}" hash "${SCRIPT_DIR}/test.sh"
+"$SCRIPT_DIR/output/dropshell.${ARCH}" help
+