'Generic Commit'

.example/servers/localhost/_server.env

@@ -1,5 +1,5 @@
 SSH_ADDRESS=localhost
 SSH_PORT=22
-SSH_USER=$(whoami)
+SSH_UNPRIVILEGED_USER=$(whoami)
 
 

.gitea/workflows/test.yaml

@@ -12,12 +12,28 @@ jobs:
           sudo apt-get install -y openssh-server
       - name: Check out repository code
         uses: actions/checkout@v4
-      - name: Build
+      - name: Install build dependencies
         run: |
-          cd ${{ gitea.workspace }}/docker
+          cd source
-          ./compile.sh
+          ./install_build_prerequisites.sh
+      - name: Build Native
+        run: |
+          cd source
+          ./build_native.sh
       - name: Test
         run: |
-          cd ${{ gitea.workspace }}/docker/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
+  

.gitignore

@@ -7,6 +7,7 @@ out/
 bin/
 lib/
 output/
+autogen/
 
 # Compiled Object files
 *.o
@@ -38,7 +39,6 @@ cmake_install.cmake
 Makefile
 
 # IDE specific files
-.vscode/
 .idea/
 *.swp
 *.swo

.vscode/c_cpp_properties.json

@@ -0,0 +1,17 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "${workspaceFolder}/source/build/src/autogen"
+            ],
+            "defines": [],
+            "compilerPath": "/usr/bin/g++",
+            "cStandard": "c23",
+            "cppStandard": "c++23",
+            "intelliSenseMode": "linux-gcc-x64"
+        }
+    ],
+    "version": 4
+}

.vscode/settings.json

@@ -0,0 +1,103 @@
+{
+    "files.associations": {
+        "*.inja": "jinja-html",
+        "*.ipp": "cpp",
+        "random": "cpp",
+        "ostream": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "csetjmp": "cpp",
+        "csignal": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "any": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "strstream": "cpp",
+        "bit": "cpp",
+        "*.tcc": "cpp",
+        "bitset": "cpp",
+        "cfenv": "cpp",
+        "charconv": "cpp",
+        "chrono": "cpp",
+        "cinttypes": "cpp",
+        "codecvt": "cpp",
+        "compare": "cpp",
+        "complex": "cpp",
+        "concepts": "cpp",
+        "condition_variable": "cpp",
+        "cstdint": "cpp",
+        "deque": "cpp",
+        "forward_list": "cpp",
+        "list": "cpp",
+        "map": "cpp",
+        "set": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "unordered_set": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "expected": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "ratio": "cpp",
+        "regex": "cpp",
+        "source_location": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "fstream": "cpp",
+        "future": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "ranges": "cpp",
+        "scoped_allocator": "cpp",
+        "semaphore": "cpp",
+        "shared_mutex": "cpp",
+        "span": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "stop_token": "cpp",
+        "streambuf": "cpp",
+        "thread": "cpp",
+        "typeindex": "cpp",
+        "typeinfo": "cpp",
+        "valarray": "cpp",
+        "variant": "cpp",
+        "format": "cpp",
+        "stdfloat": "cpp",
+        "__nullptr": "cpp",
+        "__node_handle": "cpp",
+        "__split_buffer": "cpp",
+        "filesystem": "cpp",
+        "queue": "cpp",
+        "stack": "cpp",
+        "__bit_reference": "cpp",
+        "__functional_base": "cpp",
+        "__memory": "cpp",
+        "locale": "cpp",
+        "stacktrace": "cpp",
+        "__locale": "cpp"
+    }
+}

README.md

@@ -5,15 +5,23 @@ A system management tool for server operations, written in C++.
 ## Installation
 
 ```
-curl -fsSL https://gitea.jde.nz/public/dropshell/releases/download/latest/install.sh | sudo bash
+curl -fsSL https://gitea.jde.nz/public/dropshell/releases/download/latest/install.sh | bash
 ```
 
-This installs as dropshell, with a symlink ds if the ds command does not already exist.
+This installs as dropshell for the local user, with a symbolic link ds.
+You'll need to run:
+```
+~/.local/bin/dropshell edit
+~/.local/bin/dropshell install
+source ~/.bashrc
+```
+to configure dropshell and install the local components.
 
-## Installation of Agent
+## Remote Server Setup
 
-Install the Agent on each server you wish to manage. Supports amd64 (x86_64) and arm64 (aarch64) architectures.
+### Initial setup
 
+Auto setup script which creates a dropshell user, and includes installing docker if not already present:
 ```
 curl -fsSL https://gitea.jde.nz/public/dropshell/releases/download/latest/server_autosetup.sh | sudo bash
 ```
@@ -26,7 +34,21 @@ Manual steps:
 1. Test ssh'ing into the server.
 
 
-## Install Services
+### Configure and Use Remote Server
 
-Set up a server and install a service:
+#### Add to local dropshell configuration, and install remote agent
-1. `ds create-server SERVERNAME`
+Back on the dropshell host:
+1. `dropshell create-server SERVERNAME`
+1. `dropshell edit SERVERNAME`
+1. `dropshell install SERVERNAME`
+
+#### Install Services
+Create and install a service
+1. `ds template list`  -- see what templates are available to install.
+1. `ds create-service SERVERNAME SERVICENAME TEMPLATE`
+1. `ds edit SERVERNAME SERVICENAME`
+1. Edit other config files if needed.
+1. `ds install SERVERNAME SERVICENAME`
+1. `ds list`
+
+The service should now be seen to be running.

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

dropshell-server-autosetup.sh

@@ -1,4 +1,6 @@
-# can you make this script run in bash, but fall back to sh if bash is not installed?
+#!/bin/bash
+
+# set up a remote server for use with dropshell.
 
 # check if we are running as root
 if [ "$(id -u)" -ne 0 ]; then

install.sh

@@ -1,50 +0,0 @@
-#!/bin/bash
-set -e
-
-# download and install dropshell
-
-# Check if running as root
-if [ "$EUID" -ne 0 ]; then
-    echo "Please run this script as root (use sudo)"
-    exit 1
-fi
-
-# 1. Determine architecture
-# ----------------------------------------------------------------------------- 
-
-ARCH=$(uname -m)
-if [[ "$ARCH" == "x86_64" ]]; then
-    BIN=dropshell.amd64
-elif [[ "$ARCH" == "aarch64" || "$ARCH" == "arm64" ]]; then
-    BIN=dropshell.arm64
-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..."
-
-curl -fsSL -o "$TMPDIR/dropshell" "$URL"
-
-if [ ! -f "$TMPDIR/dropshell" ]; then
-    echo "Failed to download dropshell" >&2
-    exit 1
-fi
-
-chmod +x "$TMPDIR/dropshell"
-
-cp "$TMPDIR/dropshell" /usr/local/bin/dropshell
-if [ -f /usr/local/bin/ds ]; then
-    rm -f /usr/local/bin/ds
-fi
-ln -s /usr/local/bin/dropshell /usr/local/bin/ds
-rm -rf "$TMPDIR"
-
-echo "dropshell installed successfully to /usr/local/bin/dropshell"
-

source/CMakeLists.txt

@@ -1,7 +1,17 @@
 cmake_minimum_required(VERSION 3.10)
 project(dropshell VERSION 1.0.0 LANGUAGES CXX)
 
+# Force static linking globally
+set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static")
+set(CMAKE_FIND_LIBRARY_SUFFIXES ".a")
+set(BUILD_SHARED_LIBS OFF CACHE BOOL "Build shared libraries" FORCE)
+set(CMAKE_POSITION_INDEPENDENT_CODE OFF)
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -static")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static")
+set(ZLIB_USE_STATIC_LIBS "ON")
+
 set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_C_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # Set default build type to Release if not specified
@@ -36,17 +46,29 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 file(GLOB_RECURSE SOURCES "src/*.cpp")
 file(GLOB_RECURSE HEADERS "src/*.hpp")
 
-# Add custom target to run make_createagent.sh at the start of the build process
+# Add custom target to run cmake_prebuild.sh at the start of the build process
-add_custom_target(run_createagent ALL
+add_custom_target(run_prebuild_script ALL
-    COMMAND ${CMAKE_COMMAND} -E echo "Running make_createagent.sh..."
+    COMMAND ${CMAKE_COMMAND} -E echo "Running cmake_prebuild.sh..."
-    COMMAND ${CMAKE_COMMAND} -E env bash ${CMAKE_CURRENT_SOURCE_DIR}/make_createagent.sh
+    COMMAND ${CMAKE_COMMAND} -E env bash ${CMAKE_CURRENT_SOURCE_DIR}/cmake_prebuild.sh
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    COMMENT "Running make_createagent.sh before build"
 )
 
 # Add executable
 add_executable(dropshell ${SOURCES})
-add_dependencies(dropshell run_createagent)
+add_dependencies(dropshell run_prebuild_script)
+
+# Mark the generated files as GENERATED so CMake knows they'll be created during build
+set_source_files_properties(
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/autogen/_agent-remote.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/autogen/_agent-local.cpp
+    PROPERTIES GENERATED TRUE
+)
+
+# Explicitly add the generated agent files, as they might not be in the source directory when globbed at the start.
+target_sources(dropshell PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/autogen/_agent-remote.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/autogen/_agent-local.cpp
+)
 
 # Set include directories
 # build dir goes first so that we can use the generated version.hpp
@@ -67,79 +89,45 @@ if(WIN32)
   )
 endif()
 
+# Configure libassert
+include(FetchContent)
+FetchContent_Declare(
+  libassert
+  GIT_REPOSITORY https://github.com/jeremy-rifkin/libassert.git
+  GIT_TAG        v2.1.5
+)
+FetchContent_MakeAvailable(libassert)
+
+# Add cpptrace
+FetchContent_Declare(
+  cpptrace
+  GIT_REPOSITORY https://github.com/jeremy-rifkin/cpptrace.git
+  GIT_TAG        v0.8.3
+)
+FetchContent_MakeAvailable(cpptrace)
+
+# Add nlohmann/json
+FetchContent_Declare(
+  nlohmann_json
+  GIT_REPOSITORY https://github.com/nlohmann/json.git
+  GIT_TAG        v3.11.3
+)
+FetchContent_MakeAvailable(nlohmann_json)
+
 # Link libraries
 target_link_libraries(dropshell PRIVATE
+    libassert::assert
+    cpptrace::cpptrace
+    nlohmann_json::nlohmann_json
+)
+
+# Set static linking flags
+set_target_properties(dropshell PROPERTIES
+    LINK_FLAGS "-static"
 )
 
 # Install targets
 install(TARGETS dropshell
-    RUNTIME DESTINATION bin
+    RUNTIME DESTINATION $ENV{HOME}/.local/bin
 )
 
-# Create symbolic link 'ds' pointing to 'dropshell'
-install(CODE "
-    message(STATUS \"Checking if 'ds' command already exists...\")
-    execute_process(
-        COMMAND which ds
-        RESULT_VARIABLE DS_NOT_EXISTS
-        OUTPUT_QUIET
-        ERROR_QUIET
-    )
-    if(DS_NOT_EXISTS)
-        message(STATUS \"Command 'ds' does not exist. Creating symlink.\")
-        execute_process(
-            COMMAND ${CMAKE_COMMAND} -E create_symlink 
-            \${CMAKE_INSTALL_PREFIX}/bin/dropshell
-            \${CMAKE_INSTALL_PREFIX}/bin/ds
-        )
-    else()
-        message(STATUS \"Command 'ds' already exists. Skipping symlink creation.\")
-    endif()
-")
-
-# Install completion script
-install(FILES src/dropshell-completion.bash
-    DESTINATION /etc/bash_completion.d
-    RENAME dropshell
-)
-
-# Create a symlink for the completion script to work with 'ds' command
-install(CODE "
-    # First check if 'ds' command exists after our installation
-    execute_process(
-        COMMAND which ds
-        RESULT_VARIABLE DS_NOT_EXISTS
-        OUTPUT_VARIABLE DS_PATH
-        ERROR_QUIET
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-    )
-    
-    # Only proceed if 'ds' exists
-    if(NOT DS_NOT_EXISTS)
-        # Check if 'ds' is a symlink pointing to dropshell
-        execute_process(
-            COMMAND readlink -f \${DS_PATH}
-            RESULT_VARIABLE READLINK_FAILED
-            OUTPUT_VARIABLE REAL_PATH
-            ERROR_QUIET
-            OUTPUT_STRIP_TRAILING_WHITESPACE
-        )
-        
-        # Get the path to our dropshell binary
-        set(DROPSHELL_PATH \${CMAKE_INSTALL_PREFIX}/bin/dropshell)
-        
-        # Check if the real path is our dropshell binary
-        if(NOT READLINK_FAILED AND \"\${REAL_PATH}\" STREQUAL \"\${DROPSHELL_PATH}\")
-            message(STATUS \"Command 'ds' exists and points to dropshell. Creating completion script symlink.\")
-            execute_process(
-                COMMAND ${CMAKE_COMMAND} -E create_symlink 
-                /etc/bash_completion.d/dropshell
-                /etc/bash_completion.d/ds
-            )
-        else()
-            message(STATUS \"Command 'ds' exists but doesn't point to dropshell. Skipping completion symlink.\")
-        endif()
-    else()
-        message(STATUS \"Command 'ds' not found. Skipping completion symlink.\")
-    endif()
-")

source/Dockerfile

@@ -0,0 +1,65 @@
+FROM --platform=$BUILDPLATFORM alpine:latest AS builder
+
+# Add build arguments for platform
+ARG TARGETPLATFORM
+ARG BUILDPLATFORM
+
+# Install build dependencies
+RUN apk add --no-cache \
+    build-base \
+    cmake \
+    git \
+    musl-dev \
+    curl \
+    bash \
+    musl \
+    g++ \
+    ninja \
+    linux-headers
+
+# Install cross-compilation tools for ARM64
+RUN if [ "$TARGETPLATFORM" = "linux/arm64" ]; then \
+    apk add --no-cache \
+    crossbuild-essential-arm64 \
+    gcc-aarch64-linux-gnu \
+    g++-aarch64-linux-gnu; \
+    fi
+
+# Set working directory
+WORKDIR /build
+
+# Copy source files
+COPY . .
+
+# Configure and build
+RUN mkdir -p build_static
+
+# Set up cross-compilation environment for ARM64
+RUN if [ "$TARGETPLATFORM" = "linux/arm64" ]; then \
+    export CC=aarch64-linux-gnu-gcc \
+    export CXX=aarch64-linux-gnu-g++ \
+    export CMAKE_TOOLCHAIN_FILE=/build/toolchain.cmake; \
+    fi
+
+# Create toolchain file for ARM64
+RUN if [ "$TARGETPLATFORM" = "linux/arm64" ]; then \
+    echo "set(CMAKE_SYSTEM_NAME Linux)" > toolchain.cmake && \
+    echo "set(CMAKE_SYSTEM_PROCESSOR aarch64)" >> toolchain.cmake && \
+    echo "set(CMAKE_C_COMPILER aarch64-linux-gnu-gcc)" >> toolchain.cmake && \
+    echo "set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)" >> toolchain.cmake && \
+    echo "set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)" >> toolchain.cmake && \
+    echo "set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)" >> toolchain.cmake && \
+    echo "set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)" >> toolchain.cmake; \
+    fi
+
+RUN cmake -G Ninja -B build_static -DCMAKE_BUILD_TYPE=Release \
+    -DCMAKE_EXE_LINKER_FLAGS="-static" \
+    -DCMAKE_FIND_LIBRARY_SUFFIXES=".a" \
+    -DBUILD_SHARED_LIBS=OFF \
+    ${CMAKE_TOOLCHAIN_FILE:+-DCMAKE_TOOLCHAIN_FILE=$CMAKE_TOOLCHAIN_FILE}
+
+RUN cmake --build build_static
+
+# Final stage that only contains the binary
+FROM scratch AS dropshell
+COPY --from=builder /build/build_static/dropshell /dropshell 

source/agent-local/agent-install.sh

@@ -1,5 +1,8 @@
 #!/bin/bash
 
+# install the dropshell host agent on this computer.
+# (not for remote servers)
+
 SCRIPT_DIR=$(dirname "$0")
 
 echo "Installing dropshell host agent on this computer..."
@@ -22,27 +25,6 @@ _check_required_env_vars() {
     done
 }
 
-# Checks if Docker is installed, running, and user has permission. Returns 1 on failure.
-_check_docker_installed() {
-    if ! command -v docker &> /dev/null; then
-        echo "Docker is not installed"
-        return 1
-    fi
-
-    # check if docker daemon is running
-    if ! docker info &> /dev/null; then
-        echo "Docker daemon is not running"
-        return 1
-    fi
-
-    # check if user has permission to run docker
-    if ! docker run --rm hello-world &> /dev/null; then
-        echo "User does not have permission to run docker"
-        return 1
-    fi
-
-    return 0
-}
 
 function install_bb64() {    
     # check curl installed
@@ -50,7 +32,7 @@ function install_bb64() {
         _die "Curl is not installed. Curl is required for agent installation."
     fi
 
-    curl -fsSL "https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh" | bash -s -- "$AGENT_PATH" "$(id -u $USER):$(id -g $USER)"
+    curl -fsSL "https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh" | bash -s -- "$AGENT_LOCAL_PATH" "$(id -u $USER):$(id -g $USER)"
 
     # test result code from curl
     if [ $? -ne 0 ]; then
@@ -58,7 +40,7 @@ function install_bb64() {
     fi
 
     # test if bb64 is installed
-    "$AGENT_PATH/bb64" -v
+    "$AGENT_LOCAL_PATH/bb64" -v
     if [ $? -ne 0 ]; then
         _die "bb64 did not install correctly."
     fi
@@ -71,13 +53,11 @@ function install_bb64() {
 #-------------------------------------------------------------------------
 
 set -a
-AGENT_PATH="$SCRIPT_DIR"
+AGENT_LOCAL_PATH="$SCRIPT_DIR"
 set +a
 
-_check_required_env_vars "AGENT_PATH"
+_check_required_env_vars "AGENT_LOCAL_PATH"
-echo "Installing host agent into $AGENT_PATH"
+echo "Installing host agent into $AGENT_LOCAL_PATH"
-
-_check_docker_installed || _die "Docker is required."
 
 install_bb64
 

source/agent-local/template_example/TODO_ADD_TEMPLATE_EXAMPLE_HERE

@@ -0,0 +1 @@
+TODO!

source/agent-remote/_allservicesstatus.sh

@@ -23,7 +23,6 @@ SCRIPT_DIR="$(dirname "$0")"
     # //               |-- service.env (actual service config)
     # //               |-- .template_info.env
     # //           |-- template
-    # //               |-- _default.env
     # //               |-- (script files)
     # //               |-- config
     # //                   |-- service.env (default service config)
@@ -39,6 +38,7 @@ CURRENT_EXIT_CODE=0
 load_dotenv(){
     local file_path=$1
     if [ -f "${file_path}" ]; then
+    # shellcheck source=/dev/null
         source "${file_path}"
     fi
 }
@@ -66,14 +66,13 @@ function run_command() {
     CURRENT_OUTPUT=$(
         set -a
 
-        load_dotenv "${service_path}/template/_default.env"
         load_dotenv "${service_path}/config/service.env"
         load_dotenv "${service_path}/config/.template_info.env"
 
         # update the main variables.
-        CONFIG_PATH="${service_path}/config"
+        export CONFIG_PATH="${service_path}/config"
-        SERVICE="${SERVICE_NAME}"
+        export SERVICE="${SERVICE_NAME}"
-        DOCKER_CLI_HINTS=false
+        export DOCKER_CLI_HINTS=false
 
         set +a
 

source/agent-remote/agent-install.sh

@@ -21,45 +21,65 @@ fi
 _check_required_env_vars "AGENT_PATH"
 
 function install_bb64() {    
-    # check curl installed
+    if ! curl -fsSL "https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh" | \
-    if ! command -v curl &> /dev/null; then
+            bash -s -- "$AGENT_PATH" "$(id -u "$USER"):$(id -g "$USER")"; then
-        _die "Curl is not installed. Curl is required for agent installation."
-    fi
-
-    curl -fsSL "https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh" | bash -s -- "$AGENT_PATH" "$(id -u $USER):$(id -g $USER)"
-
-    # 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
-    "$AGENT_PATH/bb64" -v
+    if ! VER=$("$AGENT_PATH/bb64" -v); then
-    if [ $? -ne 0 ]; then
         _die "bb64 did not install correctly."
     fi
 
-    echo "bb64 installed successfully."
+    echo "bb64 v$VER installed."
     return 0;
 }
 
+#-------------------------------------------------------------------------
+
+# Check pre-requisites
+
+# Check if curl is installed
+if ! command -v curl &> /dev/null; then
+    _die "Curl is not installed. Curl is required for agent installation."
+fi
+
+# check docker installation
+if ! command -v docker &> /dev/null; then
+    echo "Docker is not installed. Docker is required for agent installation."
+    exit 1
+fi
+
+# check rsync installation
+if ! command -v rsync &> /dev/null; then
+    echo "Rsync is not installed. Rsync is required for agent installation."
+    exit 1
+fi
+
+
 #-------------------------------------------------------------------------
 
 echo "Installing dropshell agent..."
 
 install_bb64
 
-
-
 #-------------------------------------------------------------------------
 
-echo "Running remote agent self-test..."
+# confirm we're in a good state.
 
+required_files=(
+    "$AGENT_PATH/bb64"
+    "$AGENT_PATH/_allservicesstatus.sh"
+    "$AGENT_PATH/common.sh"
+    "$AGENT_PATH/datacommands.sh"
+)
 
-#-------------------------------------------------------------------------
+# check if all files exist
-
+for file in "${required_files[@]}"; do
-echo "Completed remote agent self-test."
+    if [ ! -f "$file" ]; then
-
+        _die "$file does not exist. Please check the installation."
+    fi
+done
 
 #-------------------------------------------------------------------------
 

source/agent-remote/common.sh

@@ -41,18 +41,18 @@ _create_and_start_container() {
     local run_cmd="$1"
     local container_name="$2"
 
-    if _is_container_exists $container_name; then
+    if _is_container_exists "$container_name"; then
-        _is_container_running $container_name && return 0
+        _is_container_running "$container_name" && return 0
-        _start_container $container_name
+        _start_container "$container_name"
     else
         $run_cmd
     fi
 
-    if ! _is_container_running $container_name; then
+    if ! _is_container_running "$container_name"; then
         _die "Container ${container_name} failed to start"
     fi
 
-    ID=$(_get_container_id $container_name)
+    ID=$(_get_container_id "$container_name")
     echo "Container ${container_name} is running with ID ${ID}"
 }
 
@@ -93,6 +93,7 @@ _check_docker_installed() {
 
 # Checks if a container (any state) exists. Returns 1 if not found.
 _is_container_exists() {
+    [ -n "${1:-}" ] || { echo "_is_container_exists: Container name is empty" >&2; return 1; }
     if ! docker ps -a --format "{{.Names}}" | grep -q "^$1$"; then
         return 1
     fi
@@ -101,6 +102,7 @@ _is_container_exists() {
 
 # Checks if a container is currently running. Returns 1 if not running.
 _is_container_running() {
+    [ -n "${1:-}" ] || { echo "_is_container_running: Container name is empty" >&2; return 1; }
     if ! docker ps --format "{{.Names}}" | grep -q "^$1$"; then
         return 1
     fi
@@ -119,39 +121,39 @@ _get_container_status() {
 
 # Starts an existing, stopped container.
 _start_container() {
-    _is_container_exists $1 || return 1
+    _is_container_exists "$1" || return 1
-    _is_container_running $1 && return 0
+    _is_container_running "$1" && return 0
-    docker start $1
+    docker start "$1"
 }
 
 # Stops a running container.
 _stop_container() {
-    _is_container_running $1 || return 0;
+    _is_container_running "$1" || return 0;
-    docker stop $1
+    docker stop "$1"
 }   
 
 # Stops (if needed) and removes a container.
 _remove_container() {
-    _stop_container $1
+    _stop_container "$1"
-    _is_container_exists $1 || return 0;
+    _is_container_exists "$1" || return 0;
-    docker rm $1
+    docker rm "$1"
 }
 
 # Prints the logs for a container.
 _get_container_logs() {
-    if ! _is_container_exists $1; then
+    if ! _is_container_exists "$1"; then
         echo "Container $1 does not exist"
         return 1
     fi
 
-    docker logs $1
+    docker logs "$1"
 }
 
 # Checks if listed environment variables are set; calls _die() if any are missing.
 _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

@@ -12,22 +12,26 @@ _autocommandrun_volume() {
 
     case "$command" in
         create)
+            if docker volume ls | grep -q "${volume_name}"; then
+                echo "Volume ${volume_name} already exists - leaving unchanged"
+                return
+            fi
             echo "Creating volume ${volume_name}"
-            docker volume create ${volume_name}
+            docker volume create "${volume_name}"
             ;;
-        nuke)
+        destroy)
-            echo "Nuking volume ${volume_name}"
+            echo "Destroying volume ${volume_name}"
-            docker volume rm ${volume_name}
+            docker volume rm "${volume_name}"
             ;;
         backup)
             echo "Backing up volume ${volume_name}"
-            docker run --rm -v ${volume_name}:/volume -v ${backup_folder}:/backup debian bash -c "tar -czvf /backup/backup.tgz -C /volume . && chown -R $MYID:$MYGRP /backup"
+            docker run --rm -v "${volume_name}":/volume -v "${backup_folder}":/backup debian bash -c "tar -czvf /backup/backup.tgz -C /volume . && chown -R $MYID:$MYGRP /backup"
             ;;
         restore)
             echo "Restoring volume ${volume_name}"
-            docker volume rm ${volume_name}
+            docker volume rm "${volume_name}"
-            docker volume create ${volume_name}
+            docker volume create "${volume_name}"
-            docker run --rm -v ${volume_name}:/volume -v ${backup_folder}:/backup debian bash -c "tar -xzvf /backup/backup.tgz -C /volume --strip-components=1"
+            docker run --rm -v "${volume_name}":/volume -v "${backup_folder}":/backup debian bash -c "tar -xzvf /backup/backup.tgz -C /volume --strip-components=1"
             ;;
     esac
 }   
@@ -39,23 +43,29 @@ _autocommandrun_path() {
 
     case "$command" in
         create)
+            if [ -d "${path}" ]; then
+                echo "Path ${path} already exists - unchanged"
+                return
+            fi
             echo "Creating path ${path}"
-            mkdir -p ${path}
+            mkdir -p "${path}"
             ;;
-        nuke)
+        destroy)
-            echo "Nuking path ${path}"
+            echo "Destroying path ${path}"
-            local path_parent=$(dirname ${path})
+            local path_parent;
-            local path_child=$(basename ${path})
+            path_parent=$(dirname "${path}")
+            local path_child;
+            path_child=$(basename "${path}")
             if [ -d "${path_parent}/${path_child}" ]; then
-                docker run --rm -v ${path_parent}:/volume debian bash -c "rm -rfv /volume/${path_child}" || echo "Failed to nuke path ${path}"
+                docker run --rm -v "${path_parent}":/volume debian bash -c "rm -rfv /volume/${path_child}" || echo "Failed to destroy path ${path}"
             else
-                echo "Path ${path} does not exist - nothing to nuke"
+                echo "Path ${path} does not exist - nothing to destroy"
             fi
             ;;
         backup)
             echo "Backing up path ${path}"
             if [ -d "${path}" ]; then
-                docker run --rm -v ${path}:/path -v ${backup_folder}:/backup debian bash -c "tar -czvf /backup/backup.tgz -C /path . && chown -R $MYID:$MYGRP /backup"
+                docker run --rm -v "${path}":/path -v "${backup_folder}":/backup debian bash -c "tar -czvf /backup/backup.tgz -C /path . && chown -R $MYID:$MYGRP /backup"
             else
                 echo "Path ${path} does not exist - nothing to backup"
             fi
@@ -65,9 +75,9 @@ _autocommandrun_path() {
                 echo "Backup file ${backup_folder}/backup.tgz does not exist - nothing to restore"
             else
                 echo "Clearing existing data in path ${path}"
-                docker run --rm -v ${path}:/path debian bash -c "rm -rfv /path/{*,.*}"
+                docker run --rm -v "${path}":/path debian bash -c "rm -rfv /path/{*,.*}"
                 echo "Restoring path ${path} from backup file ${backup_folder}/backup.tgz"
-                tar -xzvf ${backup_folder}/backup.tgz -C ${path} --strip-components=1
+                tar -xzvf "${backup_folder}/backup.tgz" -C "${path}" --strip-components=1
             fi
             ;;
     esac
@@ -80,25 +90,36 @@ _autocommandrun_file() {
 
     case "$command" in
         create)
+            local file_parent;
+            file_parent=$(dirname "${filepath}")
+            local file_name;
+            file_name=$(basename "${filepath}")
+            if [ ! -d "${file_parent}" ]; then
+                echo "Parent directory ${file_parent} of ${file_name} does not exist - creating"
+                mkdir -p "${file_parent}"
+            fi
             ;;
-        nuke)
+        destroy)
-            rm -f ${filepath}
+            rm -f "${filepath}"
             ;;
         backup)
             echo "Backing up file ${filepath}"
-            local file_parent=$(dirname ${filepath})
+            local file_parent;
-            local file_name=$(basename ${filepath})
+            file_parent=$(dirname "${filepath}")
+            local file_name;
+            file_name=$(basename "${filepath}")
             if [ -f "${file_parent}/${file_name}" ]; then
-                docker run --rm -v ${file_parent}:/volume -v ${backup_folder}:/backup debian bash -c "cp /volume/${file_name} /backup/${file_name} && chown -R $MYID:$MYGRP /backup"
+                docker run --rm -v "${file_parent}":/volume -v "${backup_folder}":/backup debian bash -c "cp /volume/${file_name} /backup/${file_name} && chown -R $MYID:$MYGRP /backup"
             else
                 echo "File ${filepath} does not exist - nothing to backup"
             fi
             ;;
         restore)
             echo "Restoring file ${filepath}"
-            local file_name=$(basename ${filepath})
+            local file_name;
-            rm -f ${filepath} || die "Unable to remove existing file ${filepath}, restore failed."
+            file_name=$(basename "${filepath}")
-            cp ${backup_folder}/${file_name} ${filepath} || die "Unable to copy file ${backup_folder}/${file_name} to ${filepath}, restore failed."
+            rm -f "${filepath}" || return_die "Unable to remove existing file ${filepath}, restore failed."
+            cp "${backup_folder}/${file_name}" "${filepath}" || return_die "Unable to copy file ${backup_folder}/${file_name} to ${filepath}, restore failed."
             ;;
     esac
 }
@@ -139,9 +160,10 @@ _autocommandparse() {
         local value="${pair#*=}"
 
         # create backup folder unique to key/value.
-        local bfolder=$(echo "${key}_${value}" | tr -cd '[:alnum:]_-')
+        local bfolder;
+        bfolder=$(echo "${key}_${value}" | tr -cd '[:alnum:]_-')
         local targetpath="${backup_temp_path}/${bfolder}"
-        mkdir -p ${targetpath}
+        mkdir -p "${targetpath}"
 
         # Key must be one of volume, path or file
         case "$key" in
@@ -167,8 +189,8 @@ datacreate() {
 }
 
 
-datanuke() {
+datadestroy() {
-    _autocommandparse nuke none "$@"
+    _autocommandparse destroy none "$@"
 }
 
 databackup() {
@@ -177,7 +199,7 @@ databackup() {
 
 
     mkdir -p "$BACKUP_TEMP_PATH"
-    echo "_autocommandparse [backup] [$BACKUP_TEMP_PATH] [$@]"
+    echo "_autocommandparse [backup] [$BACKUP_TEMP_PATH]" "$@"
     _autocommandparse backup "$BACKUP_TEMP_PATH" "$@"
 
     tar zcvf "$BACKUP_FILE" -C "$BACKUP_TEMP_PATH" .
@@ -187,7 +209,7 @@ datarestore() {
     _check_required_env_vars "BACKUP_FILE" "TEMP_DIR"
     BACKUP_TEMP_PATH="$TEMP_DIR/restore"
 
-    echo "_autocommandparse [restore] [$BACKUP_TEMP_PATH] [$@]"
+    echo "_autocommandparse [restore] [$BACKUP_TEMP_PATH]" "$@"
 
     mkdir -p "$BACKUP_TEMP_PATH"
     tar zxvf "$BACKUP_FILE" -C "$BACKUP_TEMP_PATH" --strip-components=1

source/build.sh

@@ -1,105 +0,0 @@
-#!/bin/bash
-
-# Exit on error
-set -e
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-JOBS=4
-# Determine number of CPU cores for parallel build
-if command -v nproc >/dev/null 2>&1; then
-    JOBS=$(nproc)
-fi
-
-
-# Function to print status messages
-print_status() {
-    echo -e "${GREEN}[*] $1${NC}"
-}
-
-print_error() {
-    echo -e "${RED}[!] $1${NC}"
-}
-
-print_warning() {
-    echo -e "${YELLOW}[!] $1${NC}"
-}
-
-# ensure we have latest dehydrate.
-dehydrate -u
-
-# Check if build directory exists, if not create it
-if [ ! -d "build" ]; then
-    print_status "Creating build directory..."
-    mkdir build
-fi
-
-# Enter build directory
-cd build
-
-# Check if CMake is installed
-if ! command -v cmake &> /dev/null; then
-    print_error "CMake is not installed. Please install CMake first."
-    exit 1
-fi
-
-# Check if make is installed
-if ! command -v make &> /dev/null; then
-    print_error "Make is not installed. Please install Make first."
-    exit 1
-fi
-
-# Check if pkg-config is installed
-if ! command -v pkg-config &> /dev/null; then
-    print_error "pkg-config is not installed. Please install pkg-config first."
-    print_warning "On Ubuntu/Debian: sudo apt-get install pkg-config"
-    print_warning "On Fedora: sudo dnf install pkg-config"
-    print_warning "On Arch: sudo pacman -S pkg-config"
-    exit 1
-fi
-
-# Check if ncurses is installed
-if ! pkg-config --exists ncurses; then
-    print_error "ncurses is not installed. Please install ncurses first."
-    print_warning "On Ubuntu/Debian: sudo apt-get install libncurses-dev"
-    print_warning "On Fedora: sudo dnf install ncurses-devel"
-    print_warning "On Arch: sudo pacman -S ncurses"
-    exit 1
-fi
-
-# Configure with CMake
-print_status "Configuring with CMake..."
-cmake .. -DCMAKE_BUILD_TYPE=Debug
-#cmake .. -DCMAKE_BUILD_TYPE=Release
-
-# Build the project
-print_status "Building project..."
-make -j"$JOBS"
-
-# Check if build was successful
-if [ $? -eq 0 ]; then
-    print_status "Build successful!"
-    print_status "Binary location: $(pwd)/dropshell"
-else
-    print_error "Build failed!"
-    exit 1
-fi
-
-print_status "Auto-installing dropshell..."
-sudo make install
-if [ $? -eq 0 ]; then
-    print_status "Installation successful!"
-else
-    print_error "Installation failed!"
-    exit 1
-fi
-
-
-# Return to original directory
-cd ..
-
-print_status "Build process completed!" 

source/build_native.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+OUTPUT_DIR=${SCRIPT_DIR}/output
+INSTALL_DIR=${HOME}/.local/bin
+mkdir -p "${OUTPUT_DIR}"
+
+# Exit on error
+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
+    local PREVDIR=$PWD
+    local JOBS;
+    JOBS=$(nproc) # Set JOBS to the number of available CPU cores
+    mkdir -p "${BUILDDIR}"
+    cd "${SCRIPT_DIR}" || exit 1
+
+    CC="${HOME}/.musl-cross/${ARCH}-linux-musl-native/bin/${ARCH}-linux-musl-gcc"
+    CXX="${HOME}/.musl-cross/${ARCH}-linux-musl-native/bin/${ARCH}-linux-musl-g++"
+
+
+    cmake -B "${BUILDDIR}" -G Ninja \
+        -DCMAKE_BUILD_TYPE=Debug \
+        -DCMAKE_C_COMPILER_LAUNCHER=ccache \
+        -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+        -DCMAKE_LINKER=mold \
+        -DCMAKE_C_COMPILER="${CC}" \
+        -DCMAKE_CXX_COMPILER="${CXX}"
+
+    cd "${BUILDDIR}" || exit 1
+    ninja -j"$JOBS"
+
+    #upx ${BUILDDIR}/dropshell
+    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.${ARCH}" "${INSTALL_DIR}/dropshell"
+echo "Build process completed!" 

source/build_production.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+set -euo pipefail
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
+
+# Create output directory
+mkdir -p "${SCRIPT_DIR}/output"
+PREV_DIR=$(pwd)
+cd "${SCRIPT_DIR}"
+trap 'cd "${PREV_DIR}"' EXIT
+
+function build_arch() {
+    local arch=$1
+
+    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."
+        exit 1
+    fi
+
+    CMAKE_BUILD_TYPE=Release
+    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}"
+    mkdir -p "${BUILDDIR}"  
+
+    cmake -B "${BUILDDIR}" -G Ninja -DCMAKE_BUILD_TYPE="${CMAKE_BUILD_TYPE}" -DCMAKE_C_COMPILER="${CC}" -DCMAKE_CXX_COMPILER="${CXX}"
+    cmake --build "${BUILDDIR}"
+
+    upx "${BUILDDIR}/dropshell"
+    cp "${BUILDDIR}/dropshell" "${SCRIPT_DIR}/output/dropshell.${arch}"
+}
+
+build_arch x86_64
+build_arch aarch64
+
+echo "Static binaries have been created:"
+ls -la output

source/cmake_prebuild.sh

@@ -1,18 +1,24 @@
 #!/bin/bash
 set -e
 
+# CMake pre-build script.
+# Runs before the build process.
+
 # This script creates two files:
 # src/utils/createagent.hpp
 # src/utils/createagent.cpp
 #
 
-SCRIPT_DIR=$(dirname "$0")
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
 # check if dehydrate is installed
 if ! command -v dehydrate &> /dev/null; then
     echo "dehydrate could not be found - installing"
     curl -fsSL https://gitea.jde.nz/public/dehydrate/releases/download/latest/install.sh | bash
+else
+    # ensure we have latest dehydrate.
+    dehydrate -u
 fi
 
+mkdir -p "${SCRIPT_DIR}/src/autogen"
 dehydrate "${SCRIPT_DIR}/agent-remote" "${SCRIPT_DIR}/src/autogen"
 dehydrate "${SCRIPT_DIR}/agent-local" "${SCRIPT_DIR}/src/autogen"

source/install_build_prerequisites.sh

@@ -37,11 +37,23 @@ fi
 
 print_status "Detected OS: $OS $VER"
 
+
+#----------------------------------------------------------------------------------------------------------
+# INSTALL PREREQUISITE PACKAGES
+#----------------------------------------------------------------------------------------------------------
+
 # Define packages based on distribution
 case $OS in
     "Ubuntu"|"Debian GNU/Linux")
         # Common packages for both Ubuntu and Debian
-        PACKAGES="cmake make g++ devscripts debhelper"
+        PACKAGES="bash cmake make g++ devscripts debhelper build-essential upx musl-tools wget tar ccache ninja-build"
+        INSTALLCMD="apt-get install -y"
+        UPDATECMD="apt-get update"
+        ;;
+    "Alpine Linux")
+        PACKAGES="bash build-base cmake git nlohmann-json wget tar curl ninja mold nodejs npm"
+        INSTALLCMD="apk add --no-cache"
+        UPDATECMD="apk update"
         ;;
     *)
         print_error "Unsupported distribution: $OS"
@@ -51,19 +63,29 @@ esac
 
 # Function to check if a package is installed
 is_package_installed() {
-    dpkg -l "$1" 2>/dev/null | grep -q "^ii"
+    if [ "$OS" = "Alpine Linux" ]; then
+        # 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
 }
 
-# Update package lists
+UPDATED=false
-print_status "Updating package lists..."
-apt-get update
 
 # Install missing packages
 print_status "Checking and installing required packages..."
 for pkg in $PACKAGES; do
     if ! is_package_installed "$pkg"; then
+        if [ "$UPDATED" = false ]; then
+            print_status "Updating package lists..."
+            $UPDATECMD
+            UPDATED=true
+        fi
+
         print_status "Installing $pkg..."
-        apt-get install -y "$pkg"
+        $INSTALLCMD "$pkg"
         if [ $? -ne 0 ]; then
             print_error "Failed to install $pkg"
             exit 1
@@ -73,78 +95,71 @@ for pkg in $PACKAGES; do
     fi
 done
 
-# Verify all required tools are installed
+# ----------------------------------------------------------------------------------------------------------
-print_status "Verifying installation..."
+# MUSL CROSS COMPILERS
-for tool in cmake make g++; do
+# ----------------------------------------------------------------------------------------------------------
-    if ! command -v "$tool" &> /dev/null; then
-        print_error "$tool is not installed properly"
-        exit 1
-    fi
-done
-
-
-
-# Install other required packages
-apt install -y musl-tools wget tar
 
 # Set install directory
 if [ -n "$SUDO_USER" ] && [ "$SUDO_USER" != "root" ]; then
-    USER_HOME=$(eval echo ~$SUDO_USER)
+    USER_HOME=$(eval echo "~$SUDO_USER")
 else
     USER_HOME="$HOME"
 fi
 INSTALL_DIR="$USER_HOME/.musl-cross"
 mkdir -p "$INSTALL_DIR"
 
-MUSL_CC_URL="https://musl.cc"
 TMPDIR=$(mktemp -d)
 trap 'rm -rf "$TMPDIR"' EXIT
 
-# x86_64
+function install_musl_cross() {
-if [ ! -d "$INSTALL_DIR/x86_64-linux-musl-cross" ]; then
+    local TOOLCHAIN="$1"
-    echo "Downloading x86_64 musl cross toolchain..."
+    local MUSL_CC_URL="https://musl.cc"
-    wget -nc -O "$TMPDIR/x86_64-linux-musl-cross.tgz" $MUSL_CC_URL/x86_64-linux-musl-cross.tgz
+    if [ ! -d "$INSTALL_DIR/$TOOLCHAIN" ]; then
-    tar -C "$INSTALL_DIR" -xvf "$TMPDIR/x86_64-linux-musl-cross.tgz"
+        echo "Downloading $TOOLCHAIN musl cross toolchain..."
-fi
+        wget -nc -O "$TMPDIR/$TOOLCHAIN.tgz" "$MUSL_CC_URL/$TOOLCHAIN.tgz"
+        tar -C "$INSTALL_DIR" -xvf "$TMPDIR/$TOOLCHAIN.tgz"
+    fi
+}
 
-# aarch64
+function check_path() {
-if [ ! -d "$INSTALL_DIR/aarch64-linux-musl-cross" ]; then
+    if [ -n "$SUDO_USER" ] && [ "$SUDO_USER" != "root" ]; then
-    echo "Downloading aarch64 musl cross toolchain..."
+        local BASHRC="$USER_HOME/.bashrc"
-    wget -nc -O "$TMPDIR/aarch64-linux-musl-cross.tgz" $MUSL_CC_URL/aarch64-linux-musl-cross.tgz
+        local TOOLCHAIN="$1"
-    tar -C "$INSTALL_DIR" -xvf "$TMPDIR/aarch64-linux-musl-cross.tgz"
+        local MUSL_PATH="$INSTALL_DIR/$TOOLCHAIN/bin"
-fi
+        if ! echo "$PATH" | grep -q "$MUSL_PATH"; then
+            echo "Adding $MUSL_PATH to PATH in $BASHRC"
+            PATH_LINE="export PATH=\"$MUSL_PATH:\$PATH\""
+            if ! grep -Fxq "$PATH_LINE" "$BASHRC"; then
+                echo "" >> "$BASHRC"
+                echo "# Add musl cross compilers to PATH for dropshell" >> "$BASHRC"
+                echo "$PATH_LINE" >> "$BASHRC"
+                echo "Added musl cross compilers to $BASHRC"
+                echo "You should run 'source ~/.bashrc' to update your PATH"
+            else
+                echo "You should run 'source ~/.bashrc' to update your PATH"
+            fi
+        fi
+    fi
+}
 
-# Print instructions for adding to PATH
-# cat <<EOF
 
-# To use the musl cross compilers, add the following to your shell:
+TOOLCHAIN_LIST=(
-# export PATH="$INSTALL_DIR/x86_64-linux-musl-cross/bin:$INSTALL_DIR/aarch64-linux-musl-cross/bin:$PATH"
+    "aarch64-linux-musl-cross"
+    "x86_64-linux-musl-cross"
+    "x86_64-linux-musl-native"
+)
 
-# Or run:
+for TOOLCHAIN in "${TOOLCHAIN_LIST[@]}"; do
-#     export PATH="$INSTALL_DIR/x86_64-linux-musl-cross/bin:$INSTALL_DIR/aarch64-linux-musl-cross/bin:\$PATH"
+    install_musl_cross "$TOOLCHAIN"
-
+    check_path "$TOOLCHAIN"
-# EOF
+done
 
 # Clean up
 rm -rf "$TMPDIR"
 
-# If run with sudo, add to invoking user's ~/.bashrc
+# ----------------------------------------------------------------------------------------------------------
-if [ -n "$SUDO_USER" ] && [ "$SUDO_USER" != "root" ]; then
+# COMPLETE
-    BASHRC="$USER_HOME/.bashrc"
+# ----------------------------------------------------------------------------------------------------------
-    EXPORT_LINE="export PATH=\"$INSTALL_DIR/x86_64-linux-musl-cross/bin:$INSTALL_DIR/aarch64-linux-musl-cross/bin:\$PATH\""
-    if ! grep -Fxq "$EXPORT_LINE" "$BASHRC"; then
-        echo "" >> "$BASHRC"
-        echo "# Add musl cross compilers to PATH for bb64" >> "$BASHRC"
-        echo "$EXPORT_LINE" >> "$BASHRC"
-        echo "Added musl cross compilers to $BASHRC"
-    else
-        echo "musl cross compiler PATH already present in $BASHRC"
-    fi
-fi
-
-
-
-
 
 print_status "All dependencies installed successfully!"
 print_status "You can now run ./build.sh to build the project" 

source/multibuild.sh

@@ -1,59 +0,0 @@
-#!/bin/bash
-
-# build amd64 and arm64 versions of dropshell, to:
-# build/dropshell.amd64
-# build/dropshell.arm64
-
-set -e
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-rm -f $SCRIPT_DIR/build_amd64/dropshell $SCRIPT_DIR/build_arm64/dropshell $SCRIPT_DIR/output/dropshell.amd64 $SCRIPT_DIR/output/dropshell.arm64
-
-# Determine number of CPU cores for parallel build
-if command -v nproc >/dev/null 2>&1; then
-    JOBS=$(nproc)
-else
-    JOBS=4 # fallback default
-fi
-
-PREV_PWD=$PWD
-cd $SCRIPT_DIR
-
-# Build for amd64 (musl)
-echo "Building for amd64 (musl)..."
-cmake -B build_amd64 -DCMAKE_BUILD_TYPE=Release \
-  -DCMAKE_C_COMPILER=x86_64-linux-musl-gcc \
-  -DCMAKE_CXX_COMPILER=x86_64-linux-musl-g++ \
-  -DCMAKE_EXE_LINKER_FLAGS="-static" \
-  -DCMAKE_CXX_FLAGS="-march=x86-64" .
-cmake --build build_amd64 --target dropshell --config Release -j"$JOBS"
-mkdir -p output
-cp build_amd64/dropshell output/dropshell.amd64
-
-# Build for arm64 (musl)
-echo "Building for arm64 (musl)..."
-cmake -B build_arm64 -DCMAKE_BUILD_TYPE=Release \
-  -DCMAKE_C_COMPILER=aarch64-linux-musl-gcc \
-  -DCMAKE_CXX_COMPILER=aarch64-linux-musl-g++ \
-  -DCMAKE_EXE_LINKER_FLAGS="-static" \
-  -DCMAKE_CXX_FLAGS="-march=armv8-a" \
-  -DCMAKE_SYSTEM_PROCESSOR=aarch64 .
-cmake --build build_arm64 --target dropshell --config Release -j"$JOBS"
-mkdir -p output
-cp build_arm64/dropshell output/dropshell.arm64
-
-if [ ! -f output/dropshell.amd64 ]; then
-    echo "output/dropshell.amd64 not found!" >&2
-    exit 1
-fi
-
-if [ ! -f output/dropshell.arm64 ]; then
-    echo "output/dropshell.arm64 not found!" >&2
-    exit 1
-fi
-
-echo "Builds complete:"
-ls -lh output/dropshell.*
-
-cd $PREV_PWD

source/publish.sh

@@ -6,103 +6,52 @@ SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 echo "Script directory: $SCRIPT_DIR"
 
 # Check for GITEA_TOKEN_DEPLOY or GITEA_TOKEN
-if [ -n "$GITEA_TOKEN_DEPLOY" ]; then
+TOKEN="${GITEA_TOKEN_DEPLOY:-${GITEA_TOKEN}}"
-    TOKEN="$GITEA_TOKEN_DEPLOY"
+[ -z "$TOKEN" ] && { echo "Neither GITEA_TOKEN_DEPLOY nor GITEA_TOKEN environment variable set!" >&2; exit 1; }
-elif [ -n "$GITEA_TOKEN" ]; then
-    TOKEN="$GITEA_TOKEN"
-else
-    echo "GITEA_TOKEN_DEPLOY or GITEA_TOKEN environment variable not set!" >&2
-    exit 1
-fi
 
-$SCRIPT_DIR/multibuild.sh
+OLD_PWD="$PWD"
-BUILD_DIR=$SCRIPT_DIR/build
+cd "$SCRIPT_DIR" || exit 1
-
+TEMP_DIR=$(mktemp -d)
-OLD_PWD=$PWD
+trap 'rm -rf "$TEMP_DIR" && cd "$OLD_PWD"' EXIT
-cd $SCRIPT_DIR
-
-
-if [ ! -f "output/dropshell.amd64" ]; then
-    echo "output/dropshell.amd64 not found!" >&2
-    echo "Please run multibuild.sh first." >&2
-    exit 1
-fi
-
-if [ ! -f "output/dropshell.arm64" ]; then
-    echo "output/dropshell.arm64 not found!" >&2
-    echo "Please run multibuild.sh first." >&2
-    exit 1
-fi
-
-TAG=$("$SCRIPT_DIR/output/dropshell.amd64" --version)
-[ -z "$TAG" ] && echo "Failed to get version from dropshell.amd64" >&2 && exit 1
 
+ARCH=$(uname -m)
+TAG=$("$SCRIPT_DIR/output/dropshell.${ARCH}" --version)
+[ -z "$TAG" ] && echo "Failed to get version from dropshell.${ARCH}" >&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
-)
 
-RELEASE_ID=$(curl -s -X POST "$API_URL/releases" \
+# Function to find file in specified locations
-    -H "Content-Type: application/json" \
+find_file() {
-    -H "Authorization: token $TOKEN" \
+    local filename="$1"
-    -d "$RELEASE_DATA" | grep -o '"id":[0-9]*' | head -1 | cut -d: -f2)
+    shift # remove filename from args
+    local locations=("$@") # grab the rest of the args as locations
+
+    for loc in "${locations[@]}"; do
+        if [ -f "$loc/$filename" ]; then
+            echo "$loc/$filename"
+            return 0 # Found the file, return success
+        fi
+    done
+    echo "" # Return empty string if not found
+    return 1
+}
+
+curl -L -s -o "${TEMP_DIR}/sos" "https://getbin.xyz/sos" || die "Failed to download sos"
+chmod +x "${TEMP_DIR}/sos"
 
-if [ -z "$RELEASE_ID" ]; then
-    echo "Failed to create release on Gitea." >&2
-    exit 1
-fi
 
 # Upload binaries and install.sh
-for FILE in dropshell.amd64 dropshell.arm64 install.sh server_autosetup.sh; do
+for FILE in dropshell.x86_64 dropshell.aarch64 dropshell-install.sh dropshell-server-autosetup.sh; do
-    if [ -f "output/$FILE" ]; then
+    # Pass the locations directly to the find_file function
-        filetoupload="output/$FILE"
+    filetoupload=$(find_file "$FILE" "output" "../" ".")
-    elif [ -f "../$FILE" ]; then
+    [ -z "$filetoupload" ] && die "File $FILE not found in expected locations!"
-        filetoupload="../$FILE"
-    elif [ -f "$FILE" ]; then
-        filetoupload="$FILE"
-    else
-        echo "File $FILE not found!" >&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 -s -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

source/src/autocomplete.cpp

@@ -5,7 +5,7 @@
 #include "services.hpp"
 #include "servers.hpp"
 
-#include <assert.hpp>
+#include <libassert/assert.hpp>
 #include <algorithm>
 #include <iostream>
 
@@ -14,9 +14,7 @@ namespace autocomplete {
     const std::set<std::string> system_commands_noargs = {"templates","autocomplete_list_servers","autocomplete_list_services","autocomplete_list_commands"};
     const std::set<std::string> system_commands_always_available = {"help","edit"};
     const std::set<std::string> system_commands_require_config = {"server","templates","create-service","create-template","create-server","ssh","list"};
-    const std::set<std::string> system_commands_hidden = {"nuke","_allservicesstatus"};
+    const std::set<std::string> system_commands_hidden = {"_allservicesstatus"};
-
-    const std::set<std::string> service_commands_require_config = {"ssh","edit","nuke","_allservicesstatus"};
 
     void merge_commands(std::set<std::string> &commands, const std::set<std::string> &new_commands)
     {
@@ -59,7 +57,7 @@ bool autocomplete(const std::vector<std::string> &args)
     {
         auto servers = dropshell::get_configured_servers();
         for (const auto& server : servers) 
-            std::cout << server.name << std::endl;
+            std::cout << server.get_server_name() << std::endl;
         return true;
     }
 

source/src/autogen/_agent-local.cpp

@@ -1,160 +0,0 @@
-#include <fstream>
-#include <filesystem>
-#include <string>
-#include <iostream>
-#include <cstring>
-
-/*
-
-   THIS FILE IS AUTO-GENERATED BY DEHYDRATE.
-   DO NOT EDIT THIS FILE.
-
-*/
-
-
-#include "_agent-local.hpp"
-namespace recreate_agent_local {
-
-
-// Tiny dependency-free FNV-1a 64-bit hash
-static uint64_t fnv1a_64(const void* data, size_t len) {
-    const uint8_t* p = static_cast<const uint8_t*>(data);
-    uint64_t h = 0xcbf29ce484222325ULL;
-    for (size_t i = 0; i < len; ++i)
-        h = (h ^ p[i]) * 0x100000001b3ULL;
-    return h;
-}
-
-
-// Base64 decoding function - no dependencies
-static void base64_decode(const char* encoded_data, size_t encoded_len, unsigned char* output, size_t* output_len) {
-    const char* base64_chars = 
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    size_t out_pos = 0;
-    int val = 0, valb = -8;
-    
-    for (size_t i = 0; i < encoded_len; i++) {
-        char c = encoded_data[i];
-        if (c == '=') break;
-        
-        // Find position in base64_chars
-        const char* pos = strchr(base64_chars, c);
-        if (pos == nullptr) continue; // Skip invalid characters
-        
-        val = (val << 6) + static_cast<int>(pos - base64_chars);
-        valb += 6;
-        if (valb >= 0) {
-            output[out_pos++] = static_cast<unsigned char>((val >> valb) & 0xFF);
-            valb -= 8;
-        }
-    }
-    
-    *output_len = out_pos;
-}
-
-// Utility function to recreate a file with proper permissions
-static bool _recreate_file_(const std::filesystem::path& outpath, uint64_t file_hash, std::filesystem::perms file_perms, const unsigned char* filedata, size_t filedata_len) {
-    namespace fs = std::filesystem;
-    bool needs_write = false;
-    
-    // Check if file exists and has correct hash
-    if (fs::exists(outpath)) {
-        // Check content hash
-        std::ifstream in(outpath, std::ios::binary);
-        std::ostringstream oss;
-        oss << in.rdbuf();
-        std::string data = oss.str();
-        uint64_t existing_hash = fnv1a_64(data.data(), data.size());
-        needs_write = existing_hash != file_hash;
-    } else {
-        needs_write = true; // File doesn't exist, need to create it
-    }
-
-    bool needs_permission_update = true;
-    if (!needs_write) { // we always update permissions if the file is written or changed. Othewise we check.
-        fs::perms current_perms = fs::status(outpath).permissions();
-        needs_permission_update = current_perms != file_perms;
-    }
-
-    if (needs_write) {
-        fs::create_directories(outpath.parent_path());
-        std::ofstream out(outpath, std::ios::binary);
-        out.write(reinterpret_cast<const char*>(filedata), filedata_len);
-        out.close();
-        // Set the file permissions
-        fs::permissions(outpath, file_perms);
-        
-        if (!fs::exists(outpath)) {
-            std::cout << "[dehydrate] " << outpath.filename() << ": created\n";
-        } else {
-            std::cout << "[dehydrate] " << outpath.filename() << ": updated (hash changed)\n";
-        }
-        return true;
-    } 
-    
-    if (needs_permission_update) {
-        // Update only permissions
-        fs::permissions(outpath, file_perms);
-        std::cout << "[dehydrate] " << outpath.filename() << ": updated (permissions changed)\n";
-        return true;
-    }
-    
-    return false;
-}
-
-bool recreate_tree(std::string destination_folder) {
-    namespace fs = std::filesystem;
-    bool any_written = false;
-    {
-        // File: agent-install.sh
-        fs::path outpath = fs::path(destination_folder) / "agent-install.sh";
-        static const char filedata_base64[] = "IyEvYmluL2Jhc2gKClNDUklQVF9ESVI9JChkaXJuYW1lICIkMCIpCgplY2hvICJJbnN0YWxsaW5n"\
-            "IGRyb3BzaGVsbCBob3N0IGFnZW50IG9uIHRoaXMgY29tcHV0ZXIuLi4iCgoKIyBQcmludHMgYW4g"\
-            "ZXJyb3IgbWVzc2FnZSBpbiByZWQgYW5kIGV4aXRzIHdpdGggc3RhdHVzIGNvZGUgMS4KX2RpZSgp"\
-            "IHsKICAgIGVjaG8gLWUgIkVycm9yOiAkMSIKICAgIGV4aXQgMQp9CgoKIyBDaGVja3MgaWYgbGlz"\
-            "dGVkIGVudmlyb25tZW50IHZhcmlhYmxlcyBhcmUgc2V0OyBjYWxscyBfZGllKCkgaWYgYW55IGFy"\
-            "ZSBtaXNzaW5nLgpfY2hlY2tfcmVxdWlyZWRfZW52X3ZhcnMoKSB7CiAgICBsb2NhbCByZXF1aXJl"\
-            "ZF92YXJzPSgiJEAiKQogICAgZm9yIHZhciBpbiAiJHtyZXF1aXJlZF92YXJzW0BdfSI7IGRvCiAg"\
-            "ICAgICAgaWYgWyAteiAiJHshdmFyfSIgXTsgdGhlbgogICAgICAgICAgICBfZGllICJSZXF1aXJl"\
-            "ZCBlbnZpcm9ubWVudCB2YXJpYWJsZSAkdmFyIGlzIG5vdCBzZXQiCiAgICAgICAgZmkKICAgIGRv"\
-            "bmUKfQoKIyBDaGVja3MgaWYgRG9ja2VyIGlzIGluc3RhbGxlZCwgcnVubmluZywgYW5kIHVzZXIg"\
-            "aGFzIHBlcm1pc3Npb24uIFJldHVybnMgMSBvbiBmYWlsdXJlLgpfY2hlY2tfZG9ja2VyX2luc3Rh"\
-            "bGxlZCgpIHsKICAgIGlmICEgY29tbWFuZCAtdiBkb2NrZXIgJj4gL2Rldi9udWxsOyB0aGVuCiAg"\
-            "ICAgICAgZWNobyAiRG9ja2VyIGlzIG5vdCBpbnN0YWxsZWQiCiAgICAgICAgcmV0dXJuIDEKICAg"\
-            "IGZpCgogICAgIyBjaGVjayBpZiBkb2NrZXIgZGFlbW9uIGlzIHJ1bm5pbmcKICAgIGlmICEgZG9j"\
-            "a2VyIGluZm8gJj4gL2Rldi9udWxsOyB0aGVuCiAgICAgICAgZWNobyAiRG9ja2VyIGRhZW1vbiBp"\
-            "cyBub3QgcnVubmluZyIKICAgICAgICByZXR1cm4gMQogICAgZmkKCiAgICAjIGNoZWNrIGlmIHVz"\
-            "ZXIgaGFzIHBlcm1pc3Npb24gdG8gcnVuIGRvY2tlcgogICAgaWYgISBkb2NrZXIgcnVuIC0tcm0g"\
-            "aGVsbG8td29ybGQgJj4gL2Rldi9udWxsOyB0aGVuCiAgICAgICAgZWNobyAiVXNlciBkb2VzIG5v"\
-            "dCBoYXZlIHBlcm1pc3Npb24gdG8gcnVuIGRvY2tlciIKICAgICAgICByZXR1cm4gMQogICAgZmkK"\
-            "CiAgICByZXR1cm4gMAp9CgpmdW5jdGlvbiBpbnN0YWxsX2JiNjQoKSB7ICAgIAogICAgIyBjaGVj"\
-            "ayBjdXJsIGluc3RhbGxlZAogICAgaWYgISBjb21tYW5kIC12IGN1cmwgJj4gL2Rldi9udWxsOyB0"\
-            "aGVuCiAgICAgICAgX2RpZSAiQ3VybCBpcyBub3QgaW5zdGFsbGVkLiBDdXJsIGlzIHJlcXVpcmVk"\
-            "IGZvciBhZ2VudCBpbnN0YWxsYXRpb24uIgogICAgZmkKCiAgICBjdXJsIC1mc1NMICJodHRwczov"\
-            "L2dpdGVhLmpkZS5uei9wdWJsaWMvYmI2NC9yZWxlYXNlcy9kb3dubG9hZC9sYXRlc3QvaW5zdGFs"\
-            "bC5zaCIgfCBiYXNoIC1zIC0tICIkQUdFTlRfUEFUSCIgIiQoaWQgLXUgJFVTRVIpOiQoaWQgLWcg"\
-            "JFVTRVIpIgoKICAgICMgdGVzdCByZXN1bHQgY29kZSBmcm9tIGN1cmwKICAgIGlmIFsgJD8gLW5l"\
-            "IDAgXTsgdGhlbgogICAgICAgIF9kaWUgIkZhaWxlZCB0byBpbnN0YWxsIGJiNjQuIEN1cmwgcmV0"\
-            "dXJuZWQgbm9uLXplcm8gZXhpdCBjb2RlLiIKICAgIGZpCgogICAgIyB0ZXN0IGlmIGJiNjQgaXMg"\
-            "aW5zdGFsbGVkCiAgICAiJEFHRU5UX1BBVEgvYmI2NCIgLXYKICAgIGlmIFsgJD8gLW5lIDAgXTsg"\
-            "dGhlbgogICAgICAgIF9kaWUgImJiNjQgZGlkIG5vdCBpbnN0YWxsIGNvcnJlY3RseS4iCiAgICBm"\
-            "aQoKICAgIGVjaG8gImJiNjQgaW5zdGFsbGVkIHN1Y2Nlc3NmdWxseS4iCiAgICByZXR1cm4gMDsK"\
-            "fQoKCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t"\
-            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tCgpzZXQgLWEKQUdFTlRfUEFUSD0iJFNDUklQVF9ESVIiCnNl"\
-            "dCArYQoKX2NoZWNrX3JlcXVpcmVkX2Vudl92YXJzICJBR0VOVF9QQVRIIgplY2hvICJJbnN0YWxs"\
-            "aW5nIGhvc3QgYWdlbnQgaW50byAkQUdFTlRfUEFUSCIKCl9jaGVja19kb2NrZXJfaW5zdGFsbGVk"\
-            "IHx8IF9kaWUgIkRvY2tlciBpcyByZXF1aXJlZC4iCgppbnN0YWxsX2JiNjQKCg==";
-
-        // Decode Base64 data
-        size_t decoded_size = (strlen(filedata_base64) * 3) / 4;
-        unsigned char* decoded_data = new unsigned char[decoded_size];
-        size_t actual_size;
-        base64_decode(filedata_base64, strlen(filedata_base64), decoded_data, &actual_size);
-
-        bool file_written = _recreate_file_(outpath, 14766786204011647584ULL, std::filesystem::perms(493), decoded_data, actual_size);
-        delete[] decoded_data;
-        any_written = any_written || file_written;
-    }
-    return any_written;
-}
-}

source/src/autogen/_agent-local.hpp

@@ -1,15 +0,0 @@
-
-#pragma once
-
-/*
-
-   THIS FILE IS AUTO-GENERATED BY DEHYDRATE.
-   DO NOT EDIT THIS FILE.
-
-*/
-
-
-#include <string>
-namespace recreate_agent_local {
-    bool recreate_tree(std::string destination_folder);
-}

source/src/autogen/_agent-remote.cpp

@@ -1,478 +0,0 @@
-#include <fstream>
-#include <filesystem>
-#include <string>
-#include <iostream>
-#include <cstring>
-
-/*
-
-   THIS FILE IS AUTO-GENERATED BY DEHYDRATE.
-   DO NOT EDIT THIS FILE.
-
-*/
-
-
-#include "_agent-remote.hpp"
-namespace recreate_agent_remote {
-
-
-// Tiny dependency-free FNV-1a 64-bit hash
-static uint64_t fnv1a_64(const void* data, size_t len) {
-    const uint8_t* p = static_cast<const uint8_t*>(data);
-    uint64_t h = 0xcbf29ce484222325ULL;
-    for (size_t i = 0; i < len; ++i)
-        h = (h ^ p[i]) * 0x100000001b3ULL;
-    return h;
-}
-
-
-// Base64 decoding function - no dependencies
-static void base64_decode(const char* encoded_data, size_t encoded_len, unsigned char* output, size_t* output_len) {
-    const char* base64_chars = 
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    size_t out_pos = 0;
-    int val = 0, valb = -8;
-    
-    for (size_t i = 0; i < encoded_len; i++) {
-        char c = encoded_data[i];
-        if (c == '=') break;
-        
-        // Find position in base64_chars
-        const char* pos = strchr(base64_chars, c);
-        if (pos == nullptr) continue; // Skip invalid characters
-        
-        val = (val << 6) + static_cast<int>(pos - base64_chars);
-        valb += 6;
-        if (valb >= 0) {
-            output[out_pos++] = static_cast<unsigned char>((val >> valb) & 0xFF);
-            valb -= 8;
-        }
-    }
-    
-    *output_len = out_pos;
-}
-
-// Utility function to recreate a file with proper permissions
-static bool _recreate_file_(const std::filesystem::path& outpath, uint64_t file_hash, std::filesystem::perms file_perms, const unsigned char* filedata, size_t filedata_len) {
-    namespace fs = std::filesystem;
-    bool needs_write = false;
-    
-    // Check if file exists and has correct hash
-    if (fs::exists(outpath)) {
-        // Check content hash
-        std::ifstream in(outpath, std::ios::binary);
-        std::ostringstream oss;
-        oss << in.rdbuf();
-        std::string data = oss.str();
-        uint64_t existing_hash = fnv1a_64(data.data(), data.size());
-        needs_write = existing_hash != file_hash;
-    } else {
-        needs_write = true; // File doesn't exist, need to create it
-    }
-
-    bool needs_permission_update = true;
-    if (!needs_write) { // we always update permissions if the file is written or changed. Othewise we check.
-        fs::perms current_perms = fs::status(outpath).permissions();
-        needs_permission_update = current_perms != file_perms;
-    }
-
-    if (needs_write) {
-        fs::create_directories(outpath.parent_path());
-        std::ofstream out(outpath, std::ios::binary);
-        out.write(reinterpret_cast<const char*>(filedata), filedata_len);
-        out.close();
-        // Set the file permissions
-        fs::permissions(outpath, file_perms);
-        
-        if (!fs::exists(outpath)) {
-            std::cout << "[dehydrate] " << outpath.filename() << ": created\n";
-        } else {
-            std::cout << "[dehydrate] " << outpath.filename() << ": updated (hash changed)\n";
-        }
-        return true;
-    } 
-    
-    if (needs_permission_update) {
-        // Update only permissions
-        fs::permissions(outpath, file_perms);
-        std::cout << "[dehydrate] " << outpath.filename() << ": updated (permissions changed)\n";
-        return true;
-    }
-    
-    return false;
-}
-
-bool recreate_tree(std::string destination_folder) {
-    namespace fs = std::filesystem;
-    bool any_written = false;
-    {
-        // File: datacommands.sh
-        fs::path outpath = fs::path(destination_folder) / "datacommands.sh";
-        static const char filedata_base64[] = "IyEvYmluL2Jhc2gKCiMgVGhpcyBzY3JpcHQgY29udGFpbnMgdGhlIGNvbW1vbiBjb2RlIGZvciB0"\
-            "aGUgYXV0b2NvbW1hbmRzLgoKTVlJRD0kKGlkIC11KQpNWUdSUD0kKGlkIC1nKQoKX2F1dG9jb21t"\
-            "YW5kcnVuX3ZvbHVtZSgpIHsKICAgIGxvY2FsIGNvbW1hbmQ9IiQxIgogICAgbG9jYWwgdm9sdW1l"\
-            "X25hbWU9IiQyIgogICAgbG9jYWwgYmFja3VwX2ZvbGRlcj0iJDMiCgogICAgY2FzZSAiJGNvbW1h"\
-            "bmQiIGluCiAgICAgICAgY3JlYXRlKQogICAgICAgICAgICBlY2hvICJDcmVhdGluZyB2b2x1bWUg"\
-            "JHt2b2x1bWVfbmFtZX0iCiAgICAgICAgICAgIGRvY2tlciB2b2x1bWUgY3JlYXRlICR7dm9sdW1l"\
-            "X25hbWV9CiAgICAgICAgICAgIDs7CiAgICAgICAgbnVrZSkKICAgICAgICAgICAgZWNobyAiTnVr"\
-            "aW5nIHZvbHVtZSAke3ZvbHVtZV9uYW1lfSIKICAgICAgICAgICAgZG9ja2VyIHZvbHVtZSBybSAk"\
-            "e3ZvbHVtZV9uYW1lfQogICAgICAgICAgICA7OwogICAgICAgIGJhY2t1cCkKICAgICAgICAgICAg"\
-            "ZWNobyAiQmFja2luZyB1cCB2b2x1bWUgJHt2b2x1bWVfbmFtZX0iCiAgICAgICAgICAgIGRvY2tl"\
-            "ciBydW4gLS1ybSAtdiAke3ZvbHVtZV9uYW1lfTovdm9sdW1lIC12ICR7YmFja3VwX2ZvbGRlcn06"\
-            "L2JhY2t1cCBkZWJpYW4gYmFzaCAtYyAidGFyIC1jenZmIC9iYWNrdXAvYmFja3VwLnRneiAtQyAv"\
-            "dm9sdW1lIC4gJiYgY2hvd24gLVIgJE1ZSUQ6JE1ZR1JQIC9iYWNrdXAiCiAgICAgICAgICAgIDs7"\
-            "CiAgICAgICAgcmVzdG9yZSkKICAgICAgICAgICAgZWNobyAiUmVzdG9yaW5nIHZvbHVtZSAke3Zv"\
-            "bHVtZV9uYW1lfSIKICAgICAgICAgICAgZG9ja2VyIHZvbHVtZSBybSAke3ZvbHVtZV9uYW1lfQog"\
-            "ICAgICAgICAgICBkb2NrZXIgdm9sdW1lIGNyZWF0ZSAke3ZvbHVtZV9uYW1lfQogICAgICAgICAg"\
-            "ICBkb2NrZXIgcnVuIC0tcm0gLXYgJHt2b2x1bWVfbmFtZX06L3ZvbHVtZSAtdiAke2JhY2t1cF9m"\
-            "b2xkZXJ9Oi9iYWNrdXAgZGViaWFuIGJhc2ggLWMgInRhciAteHp2ZiAvYmFja3VwL2JhY2t1cC50"\
-            "Z3ogLUMgL3ZvbHVtZSAtLXN0cmlwLWNvbXBvbmVudHM9MSIKICAgICAgICAgICAgOzsKICAgIGVz"\
-            "YWMKfSAgIAoKX2F1dG9jb21tYW5kcnVuX3BhdGgoKSB7CiAgICBsb2NhbCBjb21tYW5kPSIkMSIK"\
-            "ICAgIGxvY2FsIHBhdGg9IiQyIgogICAgbG9jYWwgYmFja3VwX2ZvbGRlcj0iJDMiCgogICAgY2Fz"\
-            "ZSAiJGNvbW1hbmQiIGluCiAgICAgICAgY3JlYXRlKQogICAgICAgICAgICBlY2hvICJDcmVhdGlu"\
-            "ZyBwYXRoICR7cGF0aH0iCiAgICAgICAgICAgIG1rZGlyIC1wICR7cGF0aH0KICAgICAgICAgICAg"\
-            "OzsKICAgICAgICBudWtlKQogICAgICAgICAgICBlY2hvICJOdWtpbmcgcGF0aCAke3BhdGh9Igog"\
-            "ICAgICAgICAgICBsb2NhbCBwYXRoX3BhcmVudD0kKGRpcm5hbWUgJHtwYXRofSkKICAgICAgICAg"\
-            "ICAgbG9jYWwgcGF0aF9jaGlsZD0kKGJhc2VuYW1lICR7cGF0aH0pCiAgICAgICAgICAgIGlmIFsg"\
-            "LWQgIiR7cGF0aF9wYXJlbnR9LyR7cGF0aF9jaGlsZH0iIF07IHRoZW4KICAgICAgICAgICAgICAg"\
-            "IGRvY2tlciBydW4gLS1ybSAtdiAke3BhdGhfcGFyZW50fTovdm9sdW1lIGRlYmlhbiBiYXNoIC1j"\
-            "ICJybSAtcmZ2IC92b2x1bWUvJHtwYXRoX2NoaWxkfSIgfHwgZWNobyAiRmFpbGVkIHRvIG51a2Ug"\
-            "cGF0aCAke3BhdGh9IgogICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICBlY2hvICJQYXRo"\
-            "ICR7cGF0aH0gZG9lcyBub3QgZXhpc3QgLSBub3RoaW5nIHRvIG51a2UiCiAgICAgICAgICAgIGZp"\
-            "CiAgICAgICAgICAgIDs7CiAgICAgICAgYmFja3VwKQogICAgICAgICAgICBlY2hvICJCYWNraW5n"\
-            "IHVwIHBhdGggJHtwYXRofSIKICAgICAgICAgICAgaWYgWyAtZCAiJHtwYXRofSIgXTsgdGhlbgog"\
-            "ICAgICAgICAgICAgICAgZG9ja2VyIHJ1biAtLXJtIC12ICR7cGF0aH06L3BhdGggLXYgJHtiYWNr"\
-            "dXBfZm9sZGVyfTovYmFja3VwIGRlYmlhbiBiYXNoIC1jICJ0YXIgLWN6dmYgL2JhY2t1cC9iYWNr"\
-            "dXAudGd6IC1DIC9wYXRoIC4gJiYgY2hvd24gLVIgJE1ZSUQ6JE1ZR1JQIC9iYWNrdXAiCiAgICAg"\
-            "ICAgICAgIGVsc2UKICAgICAgICAgICAgICAgIGVjaG8gIlBhdGggJHtwYXRofSBkb2VzIG5vdCBl"\
-            "eGlzdCAtIG5vdGhpbmcgdG8gYmFja3VwIgogICAgICAgICAgICBmaQogICAgICAgICAgICA7Owog"\
-            "ICAgICAgIHJlc3RvcmUpCiAgICAgICAgICAgIGlmIFsgISAtZiAiJHtiYWNrdXBfZm9sZGVyfS9i"\
-            "YWNrdXAudGd6IiBdOyB0aGVuCiAgICAgICAgICAgICAgICBlY2hvICJCYWNrdXAgZmlsZSAke2Jh"\
-            "Y2t1cF9mb2xkZXJ9L2JhY2t1cC50Z3ogZG9lcyBub3QgZXhpc3QgLSBub3RoaW5nIHRvIHJlc3Rv"\
-            "cmUiCiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgIGVjaG8gIkNsZWFyaW5nIGV4aXN0"\
-            "aW5nIGRhdGEgaW4gcGF0aCAke3BhdGh9IgogICAgICAgICAgICAgICAgZG9ja2VyIHJ1biAtLXJt"\
-            "IC12ICR7cGF0aH06L3BhdGggZGViaWFuIGJhc2ggLWMgInJtIC1yZnYgL3BhdGgveyosLip9Igog"\
-            "ICAgICAgICAgICAgICAgZWNobyAiUmVzdG9yaW5nIHBhdGggJHtwYXRofSBmcm9tIGJhY2t1cCBm"\
-            "aWxlICR7YmFja3VwX2ZvbGRlcn0vYmFja3VwLnRneiIKICAgICAgICAgICAgICAgIHRhciAteHp2"\
-            "ZiAke2JhY2t1cF9mb2xkZXJ9L2JhY2t1cC50Z3ogLUMgJHtwYXRofSAtLXN0cmlwLWNvbXBvbmVu"\
-            "dHM9MQogICAgICAgICAgICBmaQogICAgICAgICAgICA7OwogICAgZXNhYwp9CgpfYXV0b2NvbW1h"\
-            "bmRydW5fZmlsZSgpIHsKICAgIGxvY2FsIGNvbW1hbmQ9IiQxIgogICAgbG9jYWwgZmlsZXBhdGg9"\
-            "IiQyIgogICAgbG9jYWwgYmFja3VwX2ZvbGRlcj0iJDMiCgogICAgY2FzZSAiJGNvbW1hbmQiIGlu"\
-            "CiAgICAgICAgY3JlYXRlKQogICAgICAgICAgICA7OwogICAgICAgIG51a2UpCiAgICAgICAgICAg"\
-            "IHJtIC1mICR7ZmlsZXBhdGh9CiAgICAgICAgICAgIDs7CiAgICAgICAgYmFja3VwKQogICAgICAg"\
-            "ICAgICBlY2hvICJCYWNraW5nIHVwIGZpbGUgJHtmaWxlcGF0aH0iCiAgICAgICAgICAgIGxvY2Fs"\
-            "IGZpbGVfcGFyZW50PSQoZGlybmFtZSAke2ZpbGVwYXRofSkKICAgICAgICAgICAgbG9jYWwgZmls"\
-            "ZV9uYW1lPSQoYmFzZW5hbWUgJHtmaWxlcGF0aH0pCiAgICAgICAgICAgIGlmIFsgLWYgIiR7Zmls"\
-            "ZV9wYXJlbnR9LyR7ZmlsZV9uYW1lfSIgXTsgdGhlbgogICAgICAgICAgICAgICAgZG9ja2VyIHJ1"\
-            "biAtLXJtIC12ICR7ZmlsZV9wYXJlbnR9Oi92b2x1bWUgLXYgJHtiYWNrdXBfZm9sZGVyfTovYmFj"\
-            "a3VwIGRlYmlhbiBiYXNoIC1jICJjcCAvdm9sdW1lLyR7ZmlsZV9uYW1lfSAvYmFja3VwLyR7Zmls"\
-            "ZV9uYW1lfSAmJiBjaG93biAtUiAkTVlJRDokTVlHUlAgL2JhY2t1cCIKICAgICAgICAgICAgZWxz"\
-            "ZQogICAgICAgICAgICAgICAgZWNobyAiRmlsZSAke2ZpbGVwYXRofSBkb2VzIG5vdCBleGlzdCAt"\
-            "IG5vdGhpbmcgdG8gYmFja3VwIgogICAgICAgICAgICBmaQogICAgICAgICAgICA7OwogICAgICAg"\
-            "IHJlc3RvcmUpCiAgICAgICAgICAgIGVjaG8gIlJlc3RvcmluZyBmaWxlICR7ZmlsZXBhdGh9Igog"\
-            "ICAgICAgICAgICBsb2NhbCBmaWxlX25hbWU9JChiYXNlbmFtZSAke2ZpbGVwYXRofSkKICAgICAg"\
-            "ICAgICAgcm0gLWYgJHtmaWxlcGF0aH0gfHwgZGllICJVbmFibGUgdG8gcmVtb3ZlIGV4aXN0aW5n"\
-            "IGZpbGUgJHtmaWxlcGF0aH0sIHJlc3RvcmUgZmFpbGVkLiIKICAgICAgICAgICAgY3AgJHtiYWNr"\
-            "dXBfZm9sZGVyfS8ke2ZpbGVfbmFtZX0gJHtmaWxlcGF0aH0gfHwgZGllICJVbmFibGUgdG8gY29w"\
-            "eSBmaWxlICR7YmFja3VwX2ZvbGRlcn0vJHtmaWxlX25hbWV9IHRvICR7ZmlsZXBhdGh9LCByZXN0"\
-            "b3JlIGZhaWxlZC4iCiAgICAgICAgICAgIDs7CiAgICBlc2FjCn0KCl9hdXRvY29tbWFuZHBhcnNl"\
-            "KCkgewogICAgIyBmaXJzdCBhcmd1bWVudCBpcyB0aGUgY29tbWFuZAogICAgIyBpZiB0aGUgY29t"\
-            "bWFuZCBpcyBiYWNrdXAgb3IgcmVzdG9yZSwgdGhlbiB0aGUgbGFzdCB0d28gYXJndW1lbnRzIGFy"\
-            "ZSB0aGUgYmFja3VwIGZpbGUgYW5kIHRoZSB0ZW1wb3JhcnkgcGF0aAogICAgIyBhbGwgb3RoZXIg"\
-            "YXJndW1lbnRzIGFyZSBvZiBmb3JtOgogICAgIyBrZXk9dmFsdWUKICAgICMgd2hlcmUga2V5IGNh"\
-            "biBiZSBvbmUgb2Ygdm9sdW1lLCBwYXRoIG9yIGZpbGUuCiAgICAjIHZhbHVlIGlzIHRoZSBwYXRo"\
-            "IG9yIHZvbHVtZSBuYW1lLgoKICAgICMgd2UgaXRlcmF0ZSBvdmVyIHRoZSBrZXk9dmFsdWUgYXJn"\
-            "dW1lbnRzLCBhbmQgZm9yIGVhY2ggd2UgY2FsbDoKICAgICMgICAgYXV0b3J1biA8Y29tbWFuZD4g"\
-            "PGJhY2t1cGZpbGU+IDxrZXk+IDx2YWx1ZT4KCiAgICBsb2NhbCBjb21tYW5kPSIkMSIKICAgIHNo"\
-            "aWZ0CgogICAgbG9jYWwgYmFja3VwX3RlbXBfcGF0aD0iJDEiCiAgICBzaGlmdAoKICAgIGVjaG8g"\
-            "ImF1dG9jb21tYW5kcGFyc2U6IGNvbW1hbmQ9JGNvbW1hbmQgYmFja3VwX3RlbXBfcGF0aD0kYmFj"\
-            "a3VwX3RlbXBfcGF0aCIKCiAgICAjIEV4dHJhY3QgdGhlIGJhY2t1cCBmaWxlIGFuZCB0ZW1wIHBh"\
-            "dGggKGxhc3QgdHdvIGFyZ3VtZW50cykKICAgIGxvY2FsIGFyZ3M9KCIkQCIpCiAgICBsb2NhbCBh"\
-            "cmdfY291bnQ9JHsjYXJnc1tAXX0KICAgIAogICAgIyBQcm9jZXNzIGFsbCBrZXk9dmFsdWUgcGFp"\
-            "cnMKICAgIGZvciAoKGk9MDsgaTwkYXJnX2NvdW50OyBpKyspKTsgZG8KICAgICAgICBsb2NhbCBw"\
-            "YWlyPSIke2FyZ3NbJGldfSIKICAgICAgICAKICAgICAgICAjIFNraXAgaWYgbm90IGluIGtleT12"\
-            "YWx1ZSBmb3JtYXQKICAgICAgICBpZiBbWyAiJHBhaXIiICE9ICoiPSIqIF1dOyB0aGVuCiAgICAg"\
-            "ICAgICAgIGNvbnRpbnVlCiAgICAgICAgZmkKICAgICAgICAKICAgICAgICBsb2NhbCBrZXk9IiR7"\
-            "cGFpciUlPSp9IgogICAgICAgIGxvY2FsIHZhbHVlPSIke3BhaXIjKj19IgoKICAgICAgICAjIGNy"\
-            "ZWF0ZSBiYWNrdXAgZm9sZGVyIHVuaXF1ZSB0byBrZXkvdmFsdWUuCiAgICAgICAgbG9jYWwgYmZv"\
-            "bGRlcj0kKGVjaG8gIiR7a2V5fV8ke3ZhbHVlfSIgfCB0ciAtY2QgJ1s6YWxudW06XV8tJykKICAg"\
-            "ICAgICBsb2NhbCB0YXJnZXRwYXRoPSIke2JhY2t1cF90ZW1wX3BhdGh9LyR7YmZvbGRlcn0iCiAg"\
-            "ICAgICAgbWtkaXIgLXAgJHt0YXJnZXRwYXRofQoKICAgICAgICAjIEtleSBtdXN0IGJlIG9uZSBv"\
-            "ZiB2b2x1bWUsIHBhdGggb3IgZmlsZQogICAgICAgIGNhc2UgIiRrZXkiIGluCiAgICAgICAgICAg"\
-            "IHZvbHVtZSkKICAgICAgICAgICAgICAgIF9hdXRvY29tbWFuZHJ1bl92b2x1bWUgIiRjb21tYW5k"\
-            "IiAiJHZhbHVlIiAiJHRhcmdldHBhdGgiCiAgICAgICAgICAgICAgICA7OwogICAgICAgICAgICBw"\
-            "YXRoKQogICAgICAgICAgICAgICAgX2F1dG9jb21tYW5kcnVuX3BhdGggIiRjb21tYW5kIiAiJHZh"\
-            "bHVlIiAiJHRhcmdldHBhdGgiCiAgICAgICAgICAgICAgICA7OwogICAgICAgICAgICBmaWxlKQog"\
-            "ICAgICAgICAgICAgICAgX2F1dG9jb21tYW5kcnVuX2ZpbGUgIiRjb21tYW5kIiAiJHZhbHVlIiAi"\
-            "JHRhcmdldHBhdGgiCiAgICAgICAgICAgICAgICA7OwogICAgICAgICAgICAqKQogICAgICAgICAg"\
-            "ICAgICAgX2RpZSAiVW5rbm93biBrZXkgJGtleSBwYXNzZWQgdG8gYXV0byR7Y29tbWFuZH0uIFdl"\
-            "IG9ubHkgc3VwcG9ydCB2b2x1bWUsIHBhdGggYW5kIGZpbGUuIgogICAgICAgICAgICAgICAgOzsK"\
-            "ICAgICAgICBlc2FjCiAgICBkb25lCn0KCgpkYXRhY3JlYXRlKCkgewogICAgX2F1dG9jb21tYW5k"\
-            "cGFyc2UgY3JlYXRlIG5vbmUgIiRAIgp9CgoKZGF0YW51a2UoKSB7CiAgICBfYXV0b2NvbW1hbmRw"\
-            "YXJzZSBudWtlIG5vbmUgIiRAIgp9CgpkYXRhYmFja3VwKCkgewogICAgX2NoZWNrX3JlcXVpcmVk"\
-            "X2Vudl92YXJzICJCQUNLVVBfRklMRSIgIlRFTVBfRElSIgogICAgQkFDS1VQX1RFTVBfUEFUSD0i"\
-            "JFRFTVBfRElSL2JhY2t1cCIKCgogICAgbWtkaXIgLXAgIiRCQUNLVVBfVEVNUF9QQVRIIgogICAg"\
-            "ZWNobyAiX2F1dG9jb21tYW5kcGFyc2UgW2JhY2t1cF0gWyRCQUNLVVBfVEVNUF9QQVRIXSBbJEBd"\
-            "IgogICAgX2F1dG9jb21tYW5kcGFyc2UgYmFja3VwICIkQkFDS1VQX1RFTVBfUEFUSCIgIiRAIgoK"\
-            "ICAgIHRhciB6Y3ZmICIkQkFDS1VQX0ZJTEUiIC1DICIkQkFDS1VQX1RFTVBfUEFUSCIgLgp9Cgpk"\
-            "YXRhcmVzdG9yZSgpIHsKICAgIF9jaGVja19yZXF1aXJlZF9lbnZfdmFycyAiQkFDS1VQX0ZJTEUi"\
-            "ICJURU1QX0RJUiIKICAgIEJBQ0tVUF9URU1QX1BBVEg9IiRURU1QX0RJUi9yZXN0b3JlIgoKICAg"\
-            "IGVjaG8gIl9hdXRvY29tbWFuZHBhcnNlIFtyZXN0b3JlXSBbJEJBQ0tVUF9URU1QX1BBVEhdIFsk"\
-            "QF0iCgogICAgbWtkaXIgLXAgIiRCQUNLVVBfVEVNUF9QQVRIIgogICAgdGFyIHp4dmYgIiRCQUNL"\
-            "VVBfRklMRSIgLUMgIiRCQUNLVVBfVEVNUF9QQVRIIiAtLXN0cmlwLWNvbXBvbmVudHM9MQoKICAg"\
-            "IF9hdXRvY29tbWFuZHBhcnNlIHJlc3RvcmUgIiRCQUNLVVBfVEVNUF9QQVRIIiAiJEAiCn0K";
-
-        // Decode Base64 data
-        size_t decoded_size = (strlen(filedata_base64) * 3) / 4;
-        unsigned char* decoded_data = new unsigned char[decoded_size];
-        size_t actual_size;
-        base64_decode(filedata_base64, strlen(filedata_base64), decoded_data, &actual_size);
-
-        bool file_written = _recreate_file_(outpath, 12213965674971673660ULL, std::filesystem::perms(493), decoded_data, actual_size);
-        delete[] decoded_data;
-        any_written = any_written || file_written;
-    }
-    {
-        // File: agent-install.sh
-        fs::path outpath = fs::path(destination_folder) / "agent-install.sh";
-        static const char filedata_base64[] = "IyEvYmluL2Jhc2gKCiMgVGhpcyBzY3JpcHQgaXMgdXNlZCB0byBpbnN0YWxsIHRoZSBkcm9wc2hl"\
-            "bGwgYWdlbnQgb24gYSByZW1vdGUgc2VydmVyLgoKU0NSSVBUX0RJUj0kKGRpcm5hbWUgIiQwIikK"\
-            "CnNldCAtYQoKQUdFTlRfUEFUSD0iJFNDUklQVF9ESVIiCgpzZXQgK2EKCgppZiBbIC1mICIkU0NS"\
-            "SVBUX0RJUi9jb21tb24uc2giIF07IHRoZW4KICAgIHNvdXJjZSAiJFNDUklQVF9ESVIvY29tbW9u"\
-            "LnNoIgplbHNlCiAgICBlY2hvICJFcnJvcjogY29tbW9uLnNoIG5vdCBmb3VuZCBpbiAkU0NSSVBU"\
-            "X0RJUiIKICAgIGV4aXQgMQpmaQoKX2NoZWNrX3JlcXVpcmVkX2Vudl92YXJzICJBR0VOVF9QQVRI"\
-            "IgoKZnVuY3Rpb24gaW5zdGFsbF9iYjY0KCkgeyAgICAKICAgICMgY2hlY2sgY3VybCBpbnN0YWxs"\
-            "ZWQKICAgIGlmICEgY29tbWFuZCAtdiBjdXJsICY+IC9kZXYvbnVsbDsgdGhlbgogICAgICAgIF9k"\
-            "aWUgIkN1cmwgaXMgbm90IGluc3RhbGxlZC4gQ3VybCBpcyByZXF1aXJlZCBmb3IgYWdlbnQgaW5z"\
-            "dGFsbGF0aW9uLiIKICAgIGZpCgogICAgY3VybCAtZnNTTCAiaHR0cHM6Ly9naXRlYS5qZGUubnov"\
-            "cHVibGljL2JiNjQvcmVsZWFzZXMvZG93bmxvYWQvbGF0ZXN0L2luc3RhbGwuc2giIHwgYmFzaCAt"\
-            "cyAtLSAiJEFHRU5UX1BBVEgiICIkKGlkIC11ICRVU0VSKTokKGlkIC1nICRVU0VSKSIKCiAgICAj"\
-            "IHRlc3QgcmVzdWx0IGNvZGUgZnJvbSBjdXJsCiAgICBpZiBbICQ/IC1uZSAwIF07IHRoZW4KICAg"\
-            "ICAgICBfZGllICJGYWlsZWQgdG8gaW5zdGFsbCBiYjY0LiBDdXJsIHJldHVybmVkIG5vbi16ZXJv"\
-            "IGV4aXQgY29kZS4iCiAgICBmaQoKICAgICMgdGVzdCBpZiBiYjY0IGlzIGluc3RhbGxlZAogICAg"\
-            "IiRBR0VOVF9QQVRIL2JiNjQiIC12CiAgICBpZiBbICQ/IC1uZSAwIF07IHRoZW4KICAgICAgICBf"\
-            "ZGllICJiYjY0IGRpZCBub3QgaW5zdGFsbCBjb3JyZWN0bHkuIgogICAgZmkKCiAgICBlY2hvICJi"\
-            "YjY0IGluc3RhbGxlZCBzdWNjZXNzZnVsbHkuIgogICAgcmV0dXJuIDA7Cn0KCiMtLS0tLS0tLS0t"\
-            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t"\
-            "LS0tLS0tCgplY2hvICJJbnN0YWxsaW5nIGRyb3BzaGVsbCBhZ2VudC4uLiIKCmluc3RhbGxfYmI2"\
-            "NAoKCgojLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t"\
-            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoKZWNobyAiUnVubmluZyByZW1vdGUgYWdlbnQgc2VsZi10"\
-            "ZXN0Li4uIgoKCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t"\
-            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgplY2hvICJDb21wbGV0ZWQgcmVtb3RlIGFnZW50"\
-            "IHNlbGYtdGVzdC4iCgoKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t"\
-            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KCmVjaG8gIkNvbXBsZXRlZCBkcm9wc2hl"\
-            "bGwgYWdlbnQgaW5zdGFsbGF0aW9uLiIKCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t"\
-            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgpleGl0IDAK";
-
-        // Decode Base64 data
-        size_t decoded_size = (strlen(filedata_base64) * 3) / 4;
-        unsigned char* decoded_data = new unsigned char[decoded_size];
-        size_t actual_size;
-        base64_decode(filedata_base64, strlen(filedata_base64), decoded_data, &actual_size);
-
-        bool file_written = _recreate_file_(outpath, 8417440848759774142ULL, std::filesystem::perms(493), decoded_data, actual_size);
-        delete[] decoded_data;
-        any_written = any_written || file_written;
-    }
-    {
-        // File: _allservicesstatus.sh
-        fs::path outpath = fs::path(destination_folder) / "_allservicesstatus.sh";
-        static const char filedata_base64[] = "IyEvYmluL2Jhc2gKCiMgVGhpcyBzY3JpcHQgY2hlY2tzIEFMTCBzZXJ2aWNlcyBvbiB0aGUgc2Vy"\
-            "dmVyIGFuZCByZXR1cm5zIGEgc3RhdHVzIGZvciBlYWNoLgoKIyBSZXR1cm4gZm9ybWF0IGlzIHNp"\
-            "bXBsZSBFTlYgd2l0aCB0aGUgZm9sbG93aW5nIGZvcm1hdDoKIyBTRVJWSUNFX05BTUVfSEVBTFRI"\
-            "PWhlYWx0aHl8dW5oZWFsdGh5fHVua25vd24KIyBTRVJWSUNFX05BTUVfUE9SVFM9cG9ydDEscG9y"\
-            "dDIscG9ydDMKCiMgR2V0IGFsbCBzZXJ2aWNlcyBvbiB0aGUgc2VydmVyClNDUklQVF9ESVI9IiQo"\
-            "ZGlybmFtZSAiJDAiKSIKCiAgICAjIC8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t"\
-            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t"\
-            "LS0tLS0tCiAgICAjIC8vIHJlbW90ZSBwYXRocwogICAgIyAvLyBEUk9QU0hFTExfRElSCiAgICAj"\
-            "IC8vICAgfC0tIGJhY2t1cHMKICAgICMgLy8gICB8LS0gdGVtcF9maWxlcwogICAgIyAvLyAgIHwt"\
-            "LSBhZ2VudAogICAgIyAvLyAgIHwgICB8LS0gYmI2NAogICAgIyAvLyAgIHwgICB8LS0gKG90aGVy"\
-            "IGFnZW50IGZpbGVzLCBpbmNsdWRpbmcgX2FsbHNlcnZpY2Vzc3RhdHVzLnNoKQogICAgIyAvLyAg"\
-            "IHwtLSBzZXJ2aWNlcwogICAgIyAvLyAgICAgICB8LS0gc2VydmljZSBuYW1lCiAgICAjIC8vICAg"\
-            "ICAgICAgICB8LS0gY29uZmlnCiAgICAjIC8vICAgICAgICAgICAgICAgfC0tIHNlcnZpY2UuZW52"\
-            "IChhY3R1YWwgc2VydmljZSBjb25maWcpCiAgICAjIC8vICAgICAgICAgICAgICAgfC0tIC50ZW1w"\
-            "bGF0ZV9pbmZvLmVudgogICAgIyAvLyAgICAgICAgICAgfC0tIHRlbXBsYXRlCiAgICAjIC8vICAg"\
-            "ICAgICAgICAgICAgfC0tIF9kZWZhdWx0LmVudgogICAgIyAvLyAgICAgICAgICAgICAgIHwtLSAo"\
-            "c2NyaXB0IGZpbGVzKQogICAgIyAvLyAgICAgICAgICAgICAgIHwtLSBjb25maWcKICAgICMgLy8g"\
-            "ICAgICAgICAgICAgICAgICAgfC0tIHNlcnZpY2UuZW52IChkZWZhdWx0IHNlcnZpY2UgY29uZmln"\
-            "KQogICAgIyAvLyAgICAgICAgICAgICAgICAgICB8LS0gLnRlbXBsYXRlX2luZm8uZW52CiAgICAj"\
-            "IC8vICAgICAgICAgICAgICAgICAgIHwtLSAob3RoZXIgY29uZmlnIGZpbGVzIGZvciBzcGVjaWZp"\
-            "YyBzZXJ2ZXImc2VydmljZSkKCiMgR2V0IGFsbCBzZXJ2aWNlcyBvbiB0aGUgc2VydmVyClNFUlZJ"\
-            "Q0VTX1BBVEg9JChyZWFscGF0aCAiJHtTQ1JJUFRfRElSfS8uLi9zZXJ2aWNlcy8iKQoKQ1VSUkVO"\
-            "VF9PVVRQVVQ9IiIKQ1VSUkVOVF9FWElUX0NPREU9MAoKbG9hZF9kb3RlbnYoKXsKICAgIGxvY2Fs"\
-            "IGZpbGVfcGF0aD0kMQogICAgaWYgWyAtZiAiJHtmaWxlX3BhdGh9IiBdOyB0aGVuCiAgICAgICAg"\
-            "c291cmNlICIke2ZpbGVfcGF0aH0iCiAgICBmaQp9CgpfY2hlY2tfcmVxdWlyZWRfZW52X3ZhcnNf"\
-            "YWxsc2VydmljZXNzdGF0dXMoKSB7CiAgICBsb2NhbCByZXF1aXJlZF92YXJzPSgiJEAiKQogICAg"\
-            "Zm9yIHZhciBpbiAiJHtyZXF1aXJlZF92YXJzW0BdfSI7IGRvCiAgICAgICAgaWYgWyAteiAiJHsh"\
-            "dmFyfSIgXTsgdGhlbgogICAgICAgICAgICBfZGllICJSZXF1aXJlZCBlbnZpcm9ubWVudCB2YXJp"\
-            "YWJsZSAkdmFyIGlzIG5vdCBzZXQiCiAgICAgICAgZmkKICAgIGRvbmUKfQoKZnVuY3Rpb24gcnVu"\
-            "X2NvbW1hbmQoKSB7CiAgICBsb2NhbCBzZXJ2aWNlX3BhdGg9JDEKICAgIGxvY2FsIGNvbW1hbmQ9"\
-            "JDIKICAgIGxvY2FsIGNhcHR1cmVfb3V0cHV0PSR7MzotZmFsc2V9ICAjIGRlZmF1bHQgdG8gZmFs"\
-            "c2UgaWYgbm90IHNwZWNpZmllZAoKICAgICMgY2hlY2sgaWYgdGhlIGNvbW1hbmQgaXMgYSBmaWxl"\
-            "CiAgICBpZiBbICEgLWYgIiR7c2VydmljZV9wYXRofS90ZW1wbGF0ZS8ke2NvbW1hbmR9LnNoIiBd"\
-            "OyB0aGVuCiAgICAgICAgcmV0dXJuOwogICAgZmkKCiAgICAjIHJ1biB0aGUgY29tbWFuZCBpbiBh"\
-            "IHN1YnNoZWxsIHRvIHByZXZlbnQgZW52aXJvbm1lbnQgY2hhbmdlcwogICAgQ1VSUkVOVF9PVVRQ"\
-            "VVQ9JCgKICAgICAgICBzZXQgLWEKCiAgICAgICAgbG9hZF9kb3RlbnYgIiR7c2VydmljZV9wYXRo"\
-            "fS90ZW1wbGF0ZS9fZGVmYXVsdC5lbnYiCiAgICAgICAgbG9hZF9kb3RlbnYgIiR7c2VydmljZV9w"\
-            "YXRofS9jb25maWcvc2VydmljZS5lbnYiCiAgICAgICAgbG9hZF9kb3RlbnYgIiR7c2VydmljZV9w"\
-            "YXRofS9jb25maWcvLnRlbXBsYXRlX2luZm8uZW52IgoKICAgICAgICAjIHVwZGF0ZSB0aGUgbWFp"\
-            "biB2YXJpYWJsZXMuCiAgICAgICAgQ09ORklHX1BBVEg9IiR7c2VydmljZV9wYXRofS9jb25maWci"\
-            "CiAgICAgICAgU0VSVklDRT0iJHtTRVJWSUNFX05BTUV9IgogICAgICAgIERPQ0tFUl9DTElfSElO"\
-            "VFM9ZmFsc2UKCiAgICAgICAgc2V0ICthCgogICAgICAgIF9jaGVja19yZXF1aXJlZF9lbnZfdmFy"\
-            "c19hbGxzZXJ2aWNlc3N0YXR1cyAiQ09ORklHX1BBVEgiICJTRVJWRVIiICJTRVJWSUNFIiAiQUdF"\
-            "TlRfUEFUSCIgIkhPU1RfTkFNRSIgIlRFTVBMQVRFIgoKICAgICAgICBpZiBbICIkY2FwdHVyZV9v"\
-            "dXRwdXQiID0gInRydWUiIF07IHRoZW4KICAgICAgICAgICAgIyBDYXB0dXJlIGFuZCByZXR1cm4g"\
-            "b3V0cHV0CiAgICAgICAgICAgIGJhc2ggIiR7c2VydmljZV9wYXRofS90ZW1wbGF0ZS8ke2NvbW1h"\
-            "bmR9LnNoIiAyPiYxCiAgICAgICAgZWxzZQogICAgICAgICAgICAjIFJ1biBzaWxlbnRseSBhbmQg"\
-            "cmV0dXJuIGV4aXQgY29kZQogICAgICAgICAgICBiYXNoICIke3NlcnZpY2VfcGF0aH0vdGVtcGxh"\
-            "dGUvJHtjb21tYW5kfS5zaCIgPiAvZGV2L251bGwgMj4mMQogICAgICAgIGZpCiAgICApCiAgICBD"\
-            "VVJSRU5UX0VYSVRfQ09ERT0kPwp9CgpmdW5jdGlvbiBjb21tYW5kX2V4aXN0cygpIHsKICAgIGxv"\
-            "Y2FsIHNlcnZpY2VfcGF0aD0kMQogICAgbG9jYWwgY29tbWFuZD0kMgogICAgaWYgWyAhIC1mICIk"\
-            "e3NlcnZpY2VfcGF0aH0vdGVtcGxhdGUvJHtjb21tYW5kfS5zaCIgXTsgdGhlbgogICAgICAgIHJl"\
-            "dHVybiAxCiAgICBmaQogICAgcmV0dXJuIDAKfQoKCmlmIFsgISAtZCAiJHtTRVJWSUNFU19QQVRI"\
-            "fSIgXTsgdGhlbgogICAgZWNobyAiU2VydmljZXMgcGF0aCBkb2VzIG5vdCBleGlzdDogJHtTRVJW"\
-            "SUNFU19QQVRIfSIKICAgIGV4aXQgMApmaQoKIyBHZXQgYWxsIHNlcnZpY2UgbmFtZXMKU0VSVklD"\
-            "RV9OQU1FUz0kKGxzICIke1NFUlZJQ0VTX1BBVEh9IikKCiMgSXRlcmF0ZSBvdmVyIGFsbCBzZXJ2"\
-            "aWNlIG5hbWVzCmZvciBTRVJWSUNFX05BTUUgaW4gJHtTRVJWSUNFX05BTUVTfTsgZG8KCiAgICBT"\
-            "RVJWSUNFX1BBVEg9JChyZWFscGF0aCAiJHtTRVJWSUNFU19QQVRIfS8ke1NFUlZJQ0VfTkFNRX0i"\
-            "KQoKICAgICMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogICAgIyBHZXQgdGhlIHNl"\
-            "cnZpY2UgaGVhbHRoCiAgICBpZiAhIGNvbW1hbmRfZXhpc3RzICIke1NFUlZJQ0VfUEFUSH0iICJz"\
-            "dGF0dXMiOyB0aGVuCiAgICAgICAgU0VSVklDRV9IRUFMVEg9InVua25vd24iCiAgICBlbHNlCiAg"\
-            "ICAgICAgcnVuX2NvbW1hbmQgIiR7U0VSVklDRV9QQVRIfSIgInN0YXR1cyIgImZhbHNlIgogICAg"\
-            "ICAgIGlmIFsgIiR7Q1VSUkVOVF9FWElUX0NPREV9IiAtZXEgMCBdOyB0aGVuCiAgICAgICAgICAg"\
-            "IFNFUlZJQ0VfSEVBTFRIPSJoZWFsdGh5IgogICAgICAgIGVsc2UKICAgICAgICAgICAgU0VSVklD"\
-            "RV9IRUFMVEg9InVuaGVhbHRoeSIKICAgICAgICBmaQogICAgZmkKCiAgICAjLS0tLS0tLS0tLS0t"\
-            "LS0tLS0tLS0tLS0tLS0tLS0tLS0KICAgICMgR2V0IHRoZSBzZXJ2aWNlIHBvcnRzCiAgICBpZiAh"\
-            "IGNvbW1hbmRfZXhpc3RzICIke1NFUlZJQ0VfUEFUSH0iICJwb3J0cyI7IHRoZW4KICAgICAgICBT"\
-            "RVJWSUNFX1BPUlRTPSIiCiAgICBlbHNlCiAgICAgICAgcnVuX2NvbW1hbmQgIiR7U0VSVklDRV9Q"\
-            "QVRIfSIgInBvcnRzIiAidHJ1ZSIKICAgICAgICBTRVJWSUNFX1BPUlRTPSIke0NVUlJFTlRfT1VU"\
-            "UFVUfSIKICAgIGZpCgogICAgIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgICAj"\
-            "IHJldHVybiB0aGUgaGVhbHRoIGFuZCBwb3J0cwogICAgZWNobyAiJHtTRVJWSUNFX05BTUV9X0hF"\
-            "QUxUSD0ke1NFUlZJQ0VfSEVBTFRIfSIKICAgIGVjaG8gIiR7U0VSVklDRV9OQU1FfV9QT1JUUz0k"\
-            "e1NFUlZJQ0VfUE9SVFN9Igpkb25lCg==";
-
-        // Decode Base64 data
-        size_t decoded_size = (strlen(filedata_base64) * 3) / 4;
-        unsigned char* decoded_data = new unsigned char[decoded_size];
-        size_t actual_size;
-        base64_decode(filedata_base64, strlen(filedata_base64), decoded_data, &actual_size);
-
-        bool file_written = _recreate_file_(outpath, 4669115953916396805ULL, std::filesystem::perms(493), decoded_data, actual_size);
-        delete[] decoded_data;
-        any_written = any_written || file_written;
-    }
-    {
-        // File: common.sh
-        fs::path outpath = fs::path(destination_folder) / "common.sh";
-        static const char filedata_base64[] = "IyBDT01NT04gRlVOQ1RJT05TCiMgSkRFCiMgMjAyNS0wNS0wMwoKIyBUaGlzIGZpbGUgaXMgYXZh"\
-            "aWxhYmxlIFRPICoqKkFMTCoqKiB0ZW1wbGF0ZXMsIGFzICR7QUdFTlRfUEFUSH0vX2NvbW1vbi5z"\
-            "aAoKIyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t"\
-            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgoj"\
-            "IHN1bW1hcnkgb2YgZnVuY3Rpb25zOgojICAgX2RpZSAibWVzc2FnZSIgICAgICAgICAgICAgICAg"\
-            "ICAgICAgICAgOiBQcmludHMgYW4gZXJyb3IgbWVzc2FnZSBpbiByZWQgYW5kIGV4aXRzIHdpdGgg"\
-            "c3RhdHVzIGNvZGUgMS4KIyAgIF9ncmV5X3N0YXJ0ICAgICAgICAgICAgICAgICAgICAgICAgICAg"\
-            "IDogU3dpdGNoZXMgdGVybWluYWwgb3V0cHV0IGNvbG9yIHRvIGdyZXkuCiMgICBfZ3JleV9lbmQg"\
-            "ICAgICAgICAgICAgICAgICAgICAgICAgICAgICA6IFJlc2V0cyB0ZXJtaW5hbCBvdXRwdXQgY29s"\
-            "b3IgZnJvbSBncmV5LgojICAgX2NyZWF0ZV9hbmRfc3RhcnRfY29udGFpbmVyICI8cnVuX2NtZD4i"\
-            "IDxjb250YWluZXJfbmFtZT4gOiBDcmVhdGVzL3N0YXJ0cyBhIGNvbnRhaW5lciwgdmVyaWZ5aW5n"\
-            "IGl0IHJ1bnMuCiMgICBfY3JlYXRlX2ZvbGRlciA8Zm9sZGVyX3BhdGg+ICAgICAgICAgICA6IENy"\
-            "ZWF0ZXMgYSBkaXJlY3RvcnkgaWYgaXQgZG9lc24ndCBleGlzdCAoY2htb2QgNzc3KS4KIyAgIF9j"\
-            "aGVja19kb2NrZXJfaW5zdGFsbGVkICAgICAgICAgICAgICAgOiBDaGVja3MgaWYgRG9ja2VyIGlz"\
-            "IGluc3RhbGxlZCwgcnVubmluZywgYW5kIHVzZXIgaGFzIHBlcm1pc3Npb24uIFJldHVybnMgMSBv"\
-            "biBmYWlsdXJlLgojICAgX2lzX2NvbnRhaW5lcl9leGlzdHMgPGNvbnRhaW5lcl9uYW1lPiA6IENo"\
-            "ZWNrcyBpZiBhIGNvbnRhaW5lciAoYW55IHN0YXRlKSBleGlzdHMuIFJldHVybnMgMSBpZiBub3Qg"\
-            "Zm91bmQuCiMgICBfaXNfY29udGFpbmVyX3J1bm5pbmcgPGNvbnRhaW5lcl9uYW1lPjogQ2hlY2tz"\
-            "IGlmIGEgY29udGFpbmVyIGlzIGN1cnJlbnRseSBydW5uaW5nLiBSZXR1cm5zIDEgaWYgbm90IHJ1"\
-            "bm5pbmcuCiMgICBfZ2V0X2NvbnRhaW5lcl9pZCA8Y29udGFpbmVyX25hbWU+ICAgIDogUHJpbnRz"\
-            "IHRoZSBJRCBvZiB0aGUgbmFtZWQgY29udGFpbmVyLgojICAgX2dldF9jb250YWluZXJfc3RhdHVz"\
-            "IDxjb250YWluZXJfbmFtZT46IFByaW50cyB0aGUgc3RhdHVzIHN0cmluZyBvZiB0aGUgbmFtZWQg"\
-            "Y29udGFpbmVyLgojICAgX3N0YXJ0X2NvbnRhaW5lciA8Y29udGFpbmVyX25hbWU+ICAgICA6IFN0"\
-            "YXJ0cyBhbiBleGlzdGluZywgc3RvcHBlZCBjb250YWluZXIuCiMgICBfc3RvcF9jb250YWluZXIg"\
-            "PGNvbnRhaW5lcl9uYW1lPiAgICAgIDogU3RvcHMgYSBydW5uaW5nIGNvbnRhaW5lci4KIyAgIF9y"\
-            "ZW1vdmVfY29udGFpbmVyIDxjb250YWluZXJfbmFtZT4gICAgOiBTdG9wcyAoaWYgbmVlZGVkKSBh"\
-            "bmQgcmVtb3ZlcyBhIGNvbnRhaW5lci4KIyAgIF9nZXRfY29udGFpbmVyX2xvZ3MgPGNvbnRhaW5l"\
-            "cl9uYW1lPiAgOiBQcmludHMgdGhlIGxvZ3MgZm9yIGEgY29udGFpbmVyLgojICAgX2NoZWNrX3Jl"\
-            "cXVpcmVkX2Vudl92YXJzICJWQVIxIiAuLi4gICAgOiBDaGVja3MgaWYgbGlzdGVkIGVudmlyb25t"\
-            "ZW50IHZhcmlhYmxlcyBhcmUgc2V0OyBjYWxscyBfZGllKCkgaWYgYW55IGFyZSBtaXNzaW5nLgoj"\
-            "ICAgX3Jvb3RfcmVtb3ZlX3RyZWUgPHBhdGg+ICAgICAgICAgICAgICA6IFJlbW92ZXMgYSBwYXRo"\
-            "IHVzaW5nIGEgcm9vdCBEb2NrZXIgY29udGFpbmVyIChmb3IgcGVybWlzc2lvbnMpLgoKIyAtLS0t"\
-            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t"\
-            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgojIFByaW50cyBh"\
-            "biBlcnJvciBtZXNzYWdlIGluIHJlZCBhbmQgZXhpdHMgd2l0aCBzdGF0dXMgY29kZSAxLgpfZGll"\
-            "KCkgewogICAgZWNobyAtZSAiRXJyb3I6ICQxIgogICAgZXhpdCAxCn0KCiMgQ3JlYXRlcy9zdGFy"\
-            "dHMgYSBjb250YWluZXIsIHZlcmlmeWluZyBpdCBydW5zLgpfY3JlYXRlX2FuZF9zdGFydF9jb250"\
-            "YWluZXIoKSB7CiAgICBpZiBbIC16ICIkMSIgXSB8fCBbIC16ICIkMiIgXTsgdGhlbgogICAgICAg"\
-            "IF9kaWUgIlRlbXBsYXRlIGVycm9yOiBjcmVhdGVfYW5kX3N0YXJ0X2NvbnRhaW5lciA8cnVuX2Nt"\
-            "ZD4gPGNvbnRhaW5lcl9uYW1lPiIKICAgIGZpCgogICAgbG9jYWwgcnVuX2NtZD0iJDEiCiAgICBs"\
-            "b2NhbCBjb250YWluZXJfbmFtZT0iJDIiCgogICAgaWYgX2lzX2NvbnRhaW5lcl9leGlzdHMgJGNv"\
-            "bnRhaW5lcl9uYW1lOyB0aGVuCiAgICAgICAgX2lzX2NvbnRhaW5lcl9ydW5uaW5nICRjb250YWlu"\
-            "ZXJfbmFtZSAmJiByZXR1cm4gMAogICAgICAgIF9zdGFydF9jb250YWluZXIgJGNvbnRhaW5lcl9u"\
-            "YW1lCiAgICBlbHNlCiAgICAgICAgJHJ1bl9jbWQKICAgIGZpCgogICAgaWYgISBfaXNfY29udGFp"\
-            "bmVyX3J1bm5pbmcgJGNvbnRhaW5lcl9uYW1lOyB0aGVuCiAgICAgICAgX2RpZSAiQ29udGFpbmVy"\
-            "ICR7Y29udGFpbmVyX25hbWV9IGZhaWxlZCB0byBzdGFydCIKICAgIGZpCgogICAgSUQ9JChfZ2V0"\
-            "X2NvbnRhaW5lcl9pZCAkY29udGFpbmVyX25hbWUpCiAgICBlY2hvICJDb250YWluZXIgJHtjb250"\
-            "YWluZXJfbmFtZX0gaXMgcnVubmluZyB3aXRoIElEICR7SUR9Igp9CgojIENyZWF0ZXMgYSBkaXJl"\
-            "Y3RvcnkgaWYgaXQgZG9lc24ndCBleGlzdCAoY2htb2QgNzc3KS4KX2NyZWF0ZV9mb2xkZXIoKSB7"\
-            "CiAgICBsb2NhbCBmb2xkZXI9IiQxIgogICAgaWYgWyAtZCAiJGZvbGRlciIgXTsgdGhlbgogICAg"\
-            "ICAgIHJldHVybiAwCiAgICBmaQogICAgaWYgISBta2RpciAtcCAiJGZvbGRlciI7IHRoZW4KICAg"\
-            "ICAgICBfZGllICJGYWlsZWQgdG8gY3JlYXRlIGZvbGRlcjogJGZvbGRlciIKICAgIGZpCiAgICBj"\
-            "aG1vZCA3NzcgIiRmb2xkZXIiCiAgICBlY2hvICJGb2xkZXIgY3JlYXRlZDogJGZvbGRlciIKfQoK"\
-            "IyBDaGVja3MgaWYgRG9ja2VyIGlzIGluc3RhbGxlZCwgcnVubmluZywgYW5kIHVzZXIgaGFzIHBl"\
-            "cm1pc3Npb24uIFJldHVybnMgMSBvbiBmYWlsdXJlLgpfY2hlY2tfZG9ja2VyX2luc3RhbGxlZCgp"\
-            "IHsKICAgIGlmICEgY29tbWFuZCAtdiBkb2NrZXIgJj4gL2Rldi9udWxsOyB0aGVuCiAgICAgICAg"\
-            "ZWNobyAiRG9ja2VyIGlzIG5vdCBpbnN0YWxsZWQiCiAgICAgICAgcmV0dXJuIDEKICAgIGZpCgog"\
-            "ICAgIyBjaGVjayBpZiBkb2NrZXIgZGFlbW9uIGlzIHJ1bm5pbmcKICAgIGlmICEgZG9ja2VyIGlu"\
-            "Zm8gJj4gL2Rldi9udWxsOyB0aGVuCiAgICAgICAgZWNobyAiRG9ja2VyIGRhZW1vbiBpcyBub3Qg"\
-            "cnVubmluZyIKICAgICAgICByZXR1cm4gMQogICAgZmkKCiAgICAjIGNoZWNrIGlmIHVzZXIgaGFz"\
-            "IHBlcm1pc3Npb24gdG8gcnVuIGRvY2tlcgogICAgaWYgISBkb2NrZXIgcnVuIC0tcm0gaGVsbG8t"\
-            "d29ybGQgJj4gL2Rldi9udWxsOyB0aGVuCiAgICAgICAgZWNobyAiVXNlciBkb2VzIG5vdCBoYXZl"\
-            "IHBlcm1pc3Npb24gdG8gcnVuIGRvY2tlciIKICAgICAgICByZXR1cm4gMQogICAgZmkKCiAgICBy"\
-            "ZXR1cm4gMAp9CgojIENoZWNrcyBpZiBhIGNvbnRhaW5lciAoYW55IHN0YXRlKSBleGlzdHMuIFJl"\
-            "dHVybnMgMSBpZiBub3QgZm91bmQuCl9pc19jb250YWluZXJfZXhpc3RzKCkgewogICAgaWYgISBk"\
-            "b2NrZXIgcHMgLWEgLS1mb3JtYXQgInt7Lk5hbWVzfX0iIHwgZ3JlcCAtcSAiXiQxJCI7IHRoZW4K"\
-            "ICAgICAgICByZXR1cm4gMQogICAgZmkKICAgIHJldHVybiAwCn0KCiMgQ2hlY2tzIGlmIGEgY29u"\
-            "dGFpbmVyIGlzIGN1cnJlbnRseSBydW5uaW5nLiBSZXR1cm5zIDEgaWYgbm90IHJ1bm5pbmcuCl9p"\
-            "c19jb250YWluZXJfcnVubmluZygpIHsKICAgIGlmICEgZG9ja2VyIHBzIC0tZm9ybWF0ICJ7ey5O"\
-            "YW1lc319IiB8IGdyZXAgLXEgIl4kMSQiOyB0aGVuCiAgICAgICAgcmV0dXJuIDEKICAgIGZpCiAg"\
-            "ICByZXR1cm4gMAp9CgojIFByaW50cyB0aGUgSUQgb2YgdGhlIG5hbWVkIGNvbnRhaW5lci4KX2dl"\
-            "dF9jb250YWluZXJfaWQoKSB7CiAgICBkb2NrZXIgcHMgLS1mb3JtYXQgInt7LklEfX0iIC0tZmls"\
-            "dGVyICJuYW1lPSQxIgp9CgojIFByaW50cyB0aGUgc3RhdHVzIHN0cmluZyBvZiB0aGUgbmFtZWQg"\
-            "Y29udGFpbmVyLgpfZ2V0X2NvbnRhaW5lcl9zdGF0dXMoKSB7CiAgICBkb2NrZXIgcHMgLS1mb3Jt"\
-            "YXQgInt7LlN0YXR1c319IiAtLWZpbHRlciAibmFtZT0kMSIKfQoKIyBTdGFydHMgYW4gZXhpc3Rp"\
-            "bmcsIHN0b3BwZWQgY29udGFpbmVyLgpfc3RhcnRfY29udGFpbmVyKCkgewogICAgX2lzX2NvbnRh"\
-            "aW5lcl9leGlzdHMgJDEgfHwgcmV0dXJuIDEKICAgIF9pc19jb250YWluZXJfcnVubmluZyAkMSAm"\
-            "JiByZXR1cm4gMAogICAgZG9ja2VyIHN0YXJ0ICQxCn0KCiMgU3RvcHMgYSBydW5uaW5nIGNvbnRh"\
-            "aW5lci4KX3N0b3BfY29udGFpbmVyKCkgewogICAgX2lzX2NvbnRhaW5lcl9ydW5uaW5nICQxIHx8"\
-            "IHJldHVybiAwOwogICAgZG9ja2VyIHN0b3AgJDEKfSAgIAoKIyBTdG9wcyAoaWYgbmVlZGVkKSBh"\
-            "bmQgcmVtb3ZlcyBhIGNvbnRhaW5lci4KX3JlbW92ZV9jb250YWluZXIoKSB7CiAgICBfc3RvcF9j"\
-            "b250YWluZXIgJDEKICAgIF9pc19jb250YWluZXJfZXhpc3RzICQxIHx8IHJldHVybiAwOwogICAg"\
-            "ZG9ja2VyIHJtICQxCn0KCiMgUHJpbnRzIHRoZSBsb2dzIGZvciBhIGNvbnRhaW5lci4KX2dldF9j"\
-            "b250YWluZXJfbG9ncygpIHsKICAgIGlmICEgX2lzX2NvbnRhaW5lcl9leGlzdHMgJDE7IHRoZW4K"\
-            "ICAgICAgICBlY2hvICJDb250YWluZXIgJDEgZG9lcyBub3QgZXhpc3QiCiAgICAgICAgcmV0dXJu"\
-            "IDEKICAgIGZpCgogICAgZG9ja2VyIGxvZ3MgJDEKfQoKIyBDaGVja3MgaWYgbGlzdGVkIGVudmly"\
-            "b25tZW50IHZhcmlhYmxlcyBhcmUgc2V0OyBjYWxscyBfZGllKCkgaWYgYW55IGFyZSBtaXNzaW5n"\
-            "LgpfY2hlY2tfcmVxdWlyZWRfZW52X3ZhcnMoKSB7CiAgICBsb2NhbCByZXF1aXJlZF92YXJzPSgi"\
-            "JEAiKQogICAgZm9yIHZhciBpbiAiJHtyZXF1aXJlZF92YXJzW0BdfSI7IGRvCiAgICAgICAgaWYg"\
-            "WyAteiAiJHshdmFyfSIgXTsgdGhlbgogICAgICAgICAgICBfZGllICJSZXF1aXJlZCBlbnZpcm9u"\
-            "bWVudCB2YXJpYWJsZSAkdmFyIGlzIG5vdCBzZXQiCiAgICAgICAgZmkKICAgIGRvbmUKfQoKIyBS"\
-            "ZW1vdmVzIGEgcGF0aCB1c2luZyBhIHJvb3QgRG9ja2VyIGNvbnRhaW5lciAoZm9yIHBlcm1pc3Np"\
-            "b25zKS4KX3Jvb3RfcmVtb3ZlX3RyZWUoKSB7CiAgICBsb2NhbCB0b19yZW1vdmU9IiQxIgogICAg"\
-            "cGFyZW50PSQoZGlybmFtZSAiJHRvX3JlbW92ZSIpCiAgICBhYnNfcGFyZW50PSQocmVhbHBhdGgg"\
-            "IiRwYXJlbnQiKQogICAgY2hpbGQ9JChiYXNlbmFtZSAiJHRvX3JlbW92ZSIpCiAgICBkb2NrZXIg"\
-            "cnVuIC0tcm0gLXYgIiRhYnNfcGFyZW50IjovZGF0YSBhbHBpbmUgcm0gLXJmICIvZGF0YS8kY2hp"\
-            "bGQiCn0KCgojIExvYWQgYXV0b2NvbW1hbmRzCnNvdXJjZSAiJHtBR0VOVF9QQVRIfS9kYXRhY29t"\
-            "bWFuZHMuc2gi";
-
-        // Decode Base64 data
-        size_t decoded_size = (strlen(filedata_base64) * 3) / 4;
-        unsigned char* decoded_data = new unsigned char[decoded_size];
-        size_t actual_size;
-        base64_decode(filedata_base64, strlen(filedata_base64), decoded_data, &actual_size);
-
-        bool file_written = _recreate_file_(outpath, 6967493376886731479ULL, std::filesystem::perms(493), decoded_data, actual_size);
-        delete[] decoded_data;
-        any_written = any_written || file_written;
-    }
-    return any_written;
-}
-}

source/src/autogen/_agent-remote.hpp

@@ -1,15 +0,0 @@
-
-#pragma once
-
-/*
-
-   THIS FILE IS AUTO-GENERATED BY DEHYDRATE.
-   DO NOT EDIT THIS FILE.
-
-*/
-
-
-#include <string>
-namespace recreate_agent_remote {
-    bool recreate_tree(std::string destination_folder);
-}

source/src/autogen/version.hpp

@@ -1,11 +0,0 @@
-// version.hpp (dummy for linter/IntelliSense)
-#pragma once
-
-#include <string>
-
-namespace dropshell {
-    extern const std::string VERSION;
-    extern const std::string RELEASE_DATE;
-    extern const std::string AUTHOR;
-    extern const std::string LICENSE;
-}

source/src/commands/backupdata.cpp

@@ -5,13 +5,13 @@
 #include <filesystem>
 
 #include "utils/output.hpp"
-#include "utils/assert.hpp"
+#include <libassert/assert.hpp>
 #include "utils/utils.hpp"
 #include "command_registry.hpp"
 #include "config.hpp"
 #include "services.hpp"
 #include "servers.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "templates.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
@@ -53,14 +53,10 @@ namespace dropshell
     namespace shared_commands
     {
 
-        bool backupdata_service(const std::string &server, const std::string &service)
+        bool backupdata_service(const ServerConfig &server_env, const std::string &service)
         {
-            server_env_manager server_env(server);
+            ASSERT(server_env.is_valid(), "Invalid server environment for " + server_env.get_server_name());
-            if (!server_env.is_valid())
+            std::string server = server_env.get_server_name();
-            {
-                error << "Server " << server << " is not valid" << std::endl;
-                return false;
-            }
 
             LocalServiceInfo sinfo = get_service_info(server, service);
             if (!SIvalid(sinfo))
@@ -78,34 +74,36 @@ namespace dropshell
                 return true; // nothing to back up.
             }
 
+            std::string user = server_env.get_user_for_service(service);
+
             // Check if basic installed stuff is in place.
-            std::string remote_service_template_path = remotepath::service_template(server, service);
+            std::string remote_service_template_path = remotepath(server, user).service_template(service);
             std::string remote_command_script_file = remote_service_template_path + "/" + command + ".sh";
-            std::string remote_service_config_path = remotepath::service_config(server, service);
+            std::string remote_service_config_path = remotepath(server, user).service_config(service);
-            if (!server_env.check_remote_items_exist({remotepath::service(server, service),
+            if (!server_env.check_remote_items_exist({remotepath(server, user).service(service),
                                                       remote_command_script_file,
-                                                      remotefile::service_env(server, service)}))
+                                                      remotefile(server, user).service_env(service)}, user))
             {
-                error << "Error: Required service directories not found on remote server" << std::endl;
+                error << "Required service directories not found on remote server" << std::endl;
                 info << "Is the service installed?" << std::endl;
                 return false;
             }
 
             // Create backups directory on server if it doesn't exist
-            std::string remote_backups_dir = remotepath::backups(server);
+            std::string remote_backups_dir = remotepath(server, user).backups();
             debug << "Remote backups directory on " << server << ": " << remote_backups_dir << std::endl;
             std::string mkdir_cmd = "mkdir -p " + quote(remote_backups_dir);
-            if (!execute_ssh_command(server_env.get_SSH_INFO(), sCommand("", mkdir_cmd, {}), cMode::Defaults))
+            if (!execute_ssh_command(server_env.get_SSH_INFO(user), sCommand("", mkdir_cmd, {}), cMode::Defaults))
             {
                 error << "Failed to create backups directory on server" << std::endl;
                 return false;
             }
 
             // Create backups directory locally if it doesn't exist
-            std::string local_backups_dir = gConfig().get_local_backup_path();
+            std::string local_backups_dir = localpath::backups();
             if (local_backups_dir.empty())
             {
-                error << "Error: Local backups directory not found" << std::endl;
+                error << "Local backups directory not found" << std::endl;
                 info << "Run 'dropshell edit' to configure DropShell" << std::endl;
                 return false;
             }
@@ -129,7 +127,7 @@ namespace dropshell
             ASSERT(3 == count_substring(magic_string(), local_backup_file_path), "Invalid backup filename");
 
             { // Run backup script
-                shared_commands::cRemoteTempFolder remote_temp_folder(server_env);
+                shared_commands::cRemoteTempFolder remote_temp_folder(server_env, user);
                 if (!server_env.run_remote_template_command(service, command, {}, false, {{"BACKUP_FILE", remote_backup_file_path}, {"TEMP_DIR", remote_temp_folder.path()}}))
                 {
                     error << "Backup script failed on remote server: " << remote_backup_file_path << std::endl;
@@ -137,7 +135,7 @@ namespace dropshell
                 }
 
                 // Copy backup file from server to local
-                if (!shared_commands::scp_file_from_remote(server_env, remote_backup_file_path, local_backup_file_path, false))
+                if (!shared_commands::scp_file_from_remote(server_env, remote_backup_file_path, local_backup_file_path, false, sinfo.user))
                 {
                     error << "Failed to copy backup file from server" << std::endl;
                     return false;

source/src/commands/colours.cpp

@@ -1,7 +1,7 @@
 #include "command_registry.hpp"
 #include "config.hpp"
 #include "utils/output.hpp"
-#include "utils/assert.hpp"
+#include <libassert/assert.hpp>
 
 namespace dropshell {
 

source/src/commands/command_registry.cpp

@@ -20,6 +20,15 @@ void CommandRegistry::register_command(const CommandInfo& info) {
 const CommandInfo* CommandRegistry::find_command(const std::string& name) const {
     auto it = command_map_.find(name);
     if (it != command_map_.end()) return it->second.get();
+
+    // go deep now.
+    for (const auto& cmd : all_commands_) {
+        if (cmd->names.size() > 0) {
+            for (const auto& altname : cmd->names) {
+                if (name == altname) return cmd.get();
+            }
+        }
+    }
     return nullptr;
 }
 

source/src/commands/create-server.cpp

@@ -0,0 +1,63 @@
+#include "command_registry.hpp"
+#include "config.hpp"
+#include "utils/utils.hpp"
+#include "utils/directories.hpp"
+#include "shared_commands.hpp"
+#include "version.hpp"
+
+#include <unistd.h>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <filesystem>
+#include <libassert/assert.hpp>
+
+namespace dropshell {
+
+void create_server_autocomplete(const CommandContext& ctx);
+int create_server_handler(const CommandContext& ctx);
+
+static std::vector<std::string> create_server_name_list={"create-server"};
+
+// Static registration
+struct CreateServerCommandRegister {
+    CreateServerCommandRegister() {
+        CommandRegistry::instance().register_command({
+            create_server_name_list,
+            create_server_handler,
+            create_server_autocomplete,
+            false, // hidden
+            true, // requires_config
+            true, // requires_install
+            1,     // min_args (after command)
+            1,     // max_args (after command)
+            "create-server [SERVER]",
+            "Create a new server entry on this host.",
+            // heredoc
+            R"(
+            Create a new server entry on this host.
+            Note you will need to use   ds install SERVER   to prepare the service for use.
+
+            create-server SERVER
+            )"
+        });
+    }
+} create_server_command_register;
+
+
+void create_server_autocomplete(const CommandContext& ctx) {
+    return; // can't autocomplete as it's a new server!
+}
+
+
+int create_server_handler(const CommandContext& ctx) {
+    // create a new server entry on this host
+    if (ctx.args.size() == 0) {
+        error << "No server name provided" << std::endl;
+        return 1;
+    }
+    bool ok = create_server(ctx.args[0]);
+    return ok ? 0 : 1;
+}
+
+} // namespace dropshell

source/src/commands/create-service.cpp

@@ -3,10 +3,12 @@
 #include "shared_commands.hpp"
 #include "templates.hpp"
 
-#include "utils/assert.hpp"
+#include <libassert/assert.hpp>
 #include "utils/utils.hpp"
 #include "services.hpp"
 
+#include <fstream>
+
 namespace dropshell
 {
 
@@ -65,60 +67,212 @@ namespace dropshell
     namespace shared_commands
     {
 
-    bool create_service(const std::string &server_name, const std::string &template_name, const std::string &service_name)
+        bool print_readme(const template_info &tinfo, std::string server, std::string service)
-    {
-        if (server_name.empty() || template_name.empty() || service_name.empty())
-            return false;
-
-        std::string service_dir = localpath::service(server_name, service_name);
-
-        if (service_dir.empty())
         {
-            error << "Couldn't locate server " << server_name << " in any config directory" << std::endl;
+            std::vector<std::string> variants_to_try = {"README.txt", "readme.txt", "ReadMe.txt", "README", "readme", "README.md", "readme.md"};
-            info << "Please check the server name is correct and try again" << std::endl;
+            std::filesystem::path readme_path = tinfo.local_template_path();
-            info << "You can list all servers with 'dropshell servers'" << std::endl;
+            for (const auto &variant : variants_to_try)
-            info << "You can create a new server with 'dropshell create-server " << server_name << "'" << std::endl;
+            {
-            return false;
+                if (std::filesystem::exists(readme_path / variant))
+                {
+                    readme_path = readme_path / variant;
+                    break;
+                }
+            }
+
+            if (!std::filesystem::exists(readme_path))
+                return false;
+
+            std::map<std::string, std::string> all_env_vars;
+            get_all_service_env_vars(server, service, all_env_vars);
+            all_env_vars["LOCAL_CONFIG_PATH"] = localpath::service(server, service);
+            all_env_vars["LOCAL_TEMPLATE_PATH"] = tinfo.local_template_path().string();
+
+            info << std::endl;
+            std::ifstream readme_file(readme_path);
+            std::string line;
+            while (std::getline(readme_file, line))
+            {
+                rawout << substitute_provided_key_value_pairs(line, all_env_vars) << std::endl;
+            }
+            return true;
         }
 
-        if (std::filesystem::exists(service_dir))
+        bool create_service(const std::string &server_name, const std::string &template_name, const std::string &service_name, std::string user_override/*=""*/)
         {
-            error << "Service already exists: " << service_name << std::endl;
+            if (server_name.empty() || template_name.empty() || service_name.empty())
-            debug << "Current service path: " << service_dir << std::endl;
+                return false;
-            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())
+            {
+                error << "Server " << server_name << " is not valid" << std::endl;
+                return false;
+            }
+
+            std::string service_dir = localpath::service(server_name, service_name);
+
+            if (service_dir.empty())
+            {
+                error << "Couldn't locate server " << server_name << " in any config directory" << std::endl;
+                info << "Please check the server name is correct and try again" << std::endl;
+                info << "You can list all servers with 'dropshell servers'" << std::endl;
+                info << "You can create a new server with 'dropshell create-server " << server_name << "'" << std::endl;
+                return false;
+            }
+
+            if (std::filesystem::exists(service_dir))
+            {
+                error << "Service already exists: " << service_name << std::endl;
+                debug << "Current service path: " << service_dir << std::endl;
+                return false;
+            }
+
+            template_info tinfo = gTemplateManager().get_template_info(template_name);
+            if (!tinfo.is_set())
+            {
+                error << "Template '" << template_name << "' not found" << std::endl;
+                info << "Please check the template name is correct and try again" << std::endl;
+                info << "You can list all templates with 'dropshell templates'" << std::endl;
+                info << "You can create a new template with 'dropshell create-template " << template_name << "'" << std::endl;
+                return false;
+            }
+
+            // check template is all good.
+            if (!gTemplateManager().test_template(tinfo.local_template_path()))
+            {
+                error << "Template '" << template_name << "' is not valid" << std::endl;
+                return false;
+            }
+
+            // create the service directory
+            std::filesystem::create_directory(service_dir);
+
+            // copy the template config files to the service directory
+            recursive_copy(tinfo.local_template_path() / "config", service_dir);
+
+            // append TEMPLATE_HASH to the .template_info.env file
+            std::string template_info_env_file = localfile::template_info_env(server_name,service_name);
+            ASSERT(std::filesystem::exists(template_info_env_file), "Template info env file not found: " + template_info_env_file);
+            std::ofstream template_info_env_file_out(template_info_env_file, std::ios::app); // append to the file.
+            template_info_env_file_out << "TEMPLATE_HASH=" << tinfo.hash() << std::endl;
+            template_info_env_file_out.close();
+
+
+            // modify the SSH_USER to be nice.
+            // everything is created, so we can get the service info.
+            LocalServiceInfo service_info = get_service_info(server_name, service_name);
+            std::string sshuser = "root";
+            if (!user_override.empty())
+                sshuser = user_override;
+            else
+                if (!service_info.requires_host_root)
+                { // find a non-root user.
+                    auto users = server_info.get_users();
+                    auto it = std::find_if(users.begin(), users.end(), [&sshuser](const UserConfig &user)
+                                        { return user.user != "root"; });
+                    if (it != users.end())
+                        sshuser = it->user;
+                }
+
+            if (sshuser == "root" && !server_info.hasRootUser())
+            {
+                error << "Server " << server_name << " does not have a root user, but the service " << service_name << " requires it." << std::endl;
+                return false;
+            }
+            if (sshuser != "root" && service_info.requires_host_root)
+            {
+                error << "The service " << service_name << " requires a root user, but a non-root user was specified." << std::endl;
+                return false;
+            }
+            if (!server_info.hasUser(sshuser))
+            {
+                error << "User " << sshuser << "is not available on server " << server_name << std::endl;
+                return false;
+            }
+
+
+            info << "Setting SSH_USER to " << sshuser << " in the " << filenames::service_env << " file" << std::endl;
+            { // edit the service.env file to set the SSH_USER.
+                std::string source_service_env = tinfo.local_template_path() / "config" / filenames::service_env;
+                ASSERT(std::filesystem::exists(source_service_env), "Template service env file not found: " + source_service_env);
+                std::ifstream template_service_env_file_in(source_service_env);
+                std::ofstream service_env_file_out(localfile::service_env(server_name, service_name));
+                std::string line;
+                while (std::getline(template_service_env_file_in, line))
+                {
+                    if (line.find("SSH_USER") != std::string::npos)
+                        line = "SSH_USER=" + sshuser;
+                    service_env_file_out << line << std::endl;
+                }
+                template_service_env_file_in.close();
+                service_env_file_out.close();
+            }
+
+            // check docker.
+            if (service_info.requires_docker)
+            {
+                if (!server_info.hasDocker())
+                {
+                    error << "Server " << server_name << " does not have docker, but the service " << service_name << " requires it." << std::endl;
+                    return false;
+                }
+
+                if (service_info.requires_docker_root)
+                {
+                    if (!server_info.hasRootDocker())
+                    {
+                        error << "Server " << server_name << " does not have a root docker, but the service " << service_name << " requires it." << std::endl;
+                        return false;
+                    }
+                }
+            }
+
+            info << "Service " << service_name << " created successfully" << std::endl;
+
+            if (!print_readme(tinfo, server_name, service_name))
+            {
+                info << std::endl;
+                info << "To complete the installation, please:" << std::endl;
+                info << "1. edit the service config file:  dropshell edit " << server_name << " " << service_name << std::endl;
+                info << "2. install the remote service:    dropshell install " << server_name << " " << service_name << std::endl;
+            }
+            return true;
         }
 
-        template_info tinfo = gTemplateManager().get_template_info(template_name);
+
-        if (!tinfo.is_set())
+        bool merge_updated_service_template(const std::string &server_name, const std::string &service_name)
         { 
-            error << "Template '" << template_name << "' not found" << std::endl;
+            LocalServiceInfo service_info = get_service_info(server_name, service_name);
-            info << "Please check the template name is correct and try again" << std::endl;
+            ASSERT(SIvalid(service_info), "Service info is not valid for " + service_name + " on " + server_name);
-            info << "You can list all templates with 'dropshell templates'" << std::endl;
+
-            info << "You can create a new template with 'dropshell create-template " << template_name << "'" << std::endl;
+            template_info tinfo = gTemplateManager().get_template_info(service_info.template_name);
-            return false;
+            ASSERT(tinfo.is_set(), "Failed to load template " + service_info.template_name);
+
+            // copy across .template_info.env file
+            std::string template_info_env_file = tinfo.local_template_path() / "config" / filenames::template_info_env;
+            std::string target_template_info_env_file = localfile::template_info_env(server_name, service_name);
+            ASSERT(std::filesystem::exists(template_info_env_file), "Template service env file not found: " + template_info_env_file);
+            std::filesystem::remove(target_template_info_env_file);
+            std::filesystem::copy(template_info_env_file, target_template_info_env_file);
+
+            #pragma message("TODO: merge the template info env file")
+
+            // update hash in template info env file
+            // append TEMPLATE_HASH to the .template_info.env file
+            ASSERT(std::filesystem::exists(target_template_info_env_file), "Template info env file not found: " + target_template_info_env_file);
+            std::ofstream template_info_env_file_out(target_template_info_env_file, std::ios::app); // append to the file.
+            template_info_env_file_out << "TEMPLATE_HASH=" << tinfo.hash() << std::endl;
+            template_info_env_file_out.close();
+
+            return true;
         }
 
-        // check template is all good.
-        if (!gTemplateManager().test_template(tinfo.local_template_path()))
-        {
-            error << "Template '" << template_name << "' is not valid" << std::endl;
-            return false;
-        }
-
-        // create the service directory
-        std::filesystem::create_directory(service_dir);
-
-        // copy the template config files to the service directory
-        recursive_copy(tinfo.local_template_path() / "config", service_dir);
-
-        info << "Service " << service_name << " created successfully" << std::endl;
-        info << std::endl;
-        info << "To complete the installation, please:" << std::endl;
-        info << "1. edit the service config file:  dropshell edit " << server_name << " " << service_name << std::endl;
-        info << "2. install the remote service:    dropshell install " << server_name << " " << service_name << std::endl;
-        return true;
-    }
-
     } // namespace shared_commands
 
 } // namespace dropshell

source/src/commands/create-template.cpp

@@ -0,0 +1,63 @@
+#include "command_registry.hpp"
+#include "config.hpp"
+#include "utils/utils.hpp"
+#include "utils/directories.hpp"
+#include "shared_commands.hpp"
+#include "version.hpp"
+#include <libassert/assert.hpp>
+#include "templates.hpp"
+
+#include <unistd.h>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <filesystem>
+
+namespace dropshell {
+
+void create_template_autocomplete(const CommandContext& ctx);
+int create_template_handler(const CommandContext& ctx);
+
+static std::vector<std::string> create_template_name_list={"create-template"};
+
+// Static registration
+struct CreateTemplateCommandRegister {
+    CreateTemplateCommandRegister() {
+        CommandRegistry::instance().register_command({
+            create_template_name_list,
+            create_template_handler,
+            create_template_autocomplete,
+            false, // hidden
+            true, // requires_config
+            true, // requires_install
+            1,     // min_args (after command)
+            1,     // max_args (after command)
+            "create-template TEMPLATE",
+            "Create a new template.",
+            // heredoc
+            R"(
+            Create a new template.
+
+            create-template TEMPLATE
+            )"
+        });
+    }
+} create_template_command_register;
+
+
+void create_template_autocomplete(const CommandContext& ctx) {
+    return; // can't autocomplete as it's a new server!
+}
+
+
+int create_template_handler(const CommandContext& ctx) {
+    // create a new server entry on this host
+    if (ctx.args.size() == 0) {
+        error << "No template name provided" << std::endl;
+        return 1;
+    }
+    bool ok = gTemplateManager().create_template(ctx.args[0]);
+    return ok ? 0 : 1;
+}
+
+} // namespace dropshell

source/src/commands/destroy.cpp

@@ -0,0 +1,180 @@
+#include "command_registry.hpp"
+#include "shared_commands.hpp"
+#include "config.hpp"
+#include "services.hpp"
+#include "servers.hpp"
+#include "utils/directories.hpp"
+#include "servers.hpp"
+#include "templates.hpp"
+#include "utils/utils.hpp"
+
+#include <libassert/assert.hpp>
+
+namespace dropshell
+{
+
+    int destroy_handler(const CommandContext &ctx);
+    static std::vector<std::string> destroy_name_list = {"destroy", "nuke", "nuke-service","erase","destroy-service"};
+
+    // Static registration
+    struct DestroyCommandRegister
+    {
+        DestroyCommandRegister()
+        {
+            CommandRegistry::instance().register_command({destroy_name_list,
+                                                          destroy_handler,
+                                                          shared_commands::std_autocomplete,
+                                                          false, // hidden
+                                                          true,  // requires_config
+                                                          true,  // requires_install
+                                                          2,     // min_args (after command)
+                                                          2,     // max_args (after command)
+                                                          "destroy SERVER SERVICE|all",
+                                                          "Destroy a service on a server. Erases everything, both local and remote!",
+                                                          // heredoc
+                                                          R"(
+            Destroy a service.
+
+            Examples:
+            destroy SERVER SERVICE   destroy the given service on the given server.
+            destroy SERVER all       destroy all services on the given server.
+
+            Note: This command is destructive and will destroy all data and all configuration,
+            both on the dropshell host and on the remote server.
+
+            Use with caution!
+            )"});
+        }
+    } destroy_command_register;
+
+    namespace shared_commands
+    {
+
+        bool destroy_service(const std::string &server, const std::string &service)
+        {
+            ServerConfig server_env(server);
+
+            // step 1 - destroy on remote server.
+            if (server_env.is_valid())
+            {
+                std::string user = server_env.get_user_for_service(service); // returns empty string if no user found.
+                if (user.empty())
+                {
+                    warning << "No user found for service " << service << " on " << server << std::endl;
+                    for (auto sshuser : server_env.get_users())
+                    {
+                        if (server_env.check_remote_dir_exists(remotepath(server, sshuser.user).service(service), sshuser.user))
+                        {
+                            info << "Found a remote service directory here: " << remotepath(server, sshuser.user).service(service) << std::endl;
+                            info << "Deleting it as user " << sshuser.user << std::endl;
+                            user = sshuser.user;
+                            break;
+                        }
+                    }
+                }
+
+                if (user.empty())
+                    warning << "No remote service directory found for " << service << " on " << server << std::endl;
+                else
+                { // user is not empty.
+                    LocalServiceInfo service_info;
+                    service_info = get_service_info(server, service);
+                    bool service_valid = SIvalid(service_info);
+                    if (!service_valid)
+                        warning << "No valid service definition found for " << service << std::endl;
+
+                    if (server_env.check_remote_dir_exists(remotepath(server, user).service(service), user))
+                    {
+                        // run the destroy script on the remote server if it exists.
+                        // otherwise just uninstall.
+                        if (service_valid)
+                        {
+                            if (gTemplateManager().template_command_exists(service_info.template_name, "destroy"))
+                            {
+                                info << "Running destroy script for " << service << " on " << server << std::endl;
+                                if (!server_env.run_remote_template_command(service, "destroy", {}, false, {}))
+                                    warning << "Failed to run destroy script: " << service << std::endl;
+                            }
+                            else
+                            {
+                                info << "No destroy script found for " << service << " on " << server << std::endl;
+                                info << "Running uninstall script instead and will clean directories." << std::endl;
+                                if (!server_env.run_remote_template_command(service, "uninstall", {}, false, {}))
+                                    warning << "Failed to uninstall service: " << service << std::endl;
+                            }
+                        }
+
+                        // Remove the service directory from the server, running in a docker container as root.
+                        if (server_env.remove_remote_dir(remotepath(server, user).service(service), true, user))
+                        {
+                            ASSERT(!server_env.check_remote_dir_exists(remotepath(server, user).service(service), user), "Service directory still found on server after uninstall");
+                            info << "Remote service directory removed: " << remotepath(server, user).service(service) << std::endl;
+                        }
+                        else
+                            warning << "Failed to remove remote service directory" << std::endl;
+                    }
+                    else
+                        warning << "No remote service directory found for " << service << " on "<< server << std::endl;
+                } // user is not empty.
+            } // server_env is valid.
+            else
+                error << "No valid local server information for server " << server << std::endl;
+
+            // step 2 - destroy the local service directory, if it exists.
+            std::string local_service_path = localpath::service(server, service);
+            if (local_service_path.empty() || !std::filesystem::exists(local_service_path))
+            {
+                warning << "No local service directory found for " << service << " on " << server << std::endl;
+            }
+            else
+            {
+                auto itemsdeleted = std::filesystem::remove_all(local_service_path);
+                if (itemsdeleted == 0)
+                    error << "Failed to remove local service directory" << std::endl;
+                else
+                    info << "Local service directory removed: " << local_service_path << std::endl;
+            }
+
+            info << "Finished destroying service " << service << " on server " << server << std::endl;
+
+            return true;
+        }
+    } // namespace shared_commands
+
+    int destroy_handler(const CommandContext &ctx)
+    {
+        ASSERT(ctx.args.size() == 2, "Usage: destroy SERVER SERVICE|all (requires 2 args - you supplied " + std::to_string(ctx.args.size()) + ")");
+        ASSERT(gConfig().is_config_set(), "No configuration found. Please run 'dropshell config' to set up your configuration.");
+
+        std::string server = safearg(ctx.args, 0);
+        std::string service = safearg(ctx.args, 1);
+
+        if (service == "all")
+        {
+            int rval = 0;
+
+            // iterate through all service folders in the server directory.
+            std::string server_path = localpath::server(server);
+            if (server_path.empty())
+            {
+                error << "Server not found: " << server << std::endl;
+                return 1;
+            }
+
+            for (const auto &entry : std::filesystem::directory_iterator(server_path))
+            {
+                if (entry.is_directory() && entry.path().filename().string().find(".") != 0)
+                {
+                    std::string service_name = entry.path().filename().string();
+                    rval |= (shared_commands::destroy_service(server, service_name) ? 0 : 1);
+                }
+            }
+            return rval;
+        }
+        else
+        {
+            return (shared_commands::destroy_service(server, service) ? 0 : 1);
+        }
+    }
+
+} // namespace dropshell

source/src/commands/edit.cpp

@@ -9,7 +9,7 @@
 #include <iostream>
 #include <sstream>
 #include <filesystem>
-#include "utils/assert.hpp"
+#include <libassert/assert.hpp>
 
 namespace dropshell {
 
@@ -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("Error: Failed to edit config file.");
+        return return_die("Failed to edit config file.");
 
     gConfig().load_config();
     if (!gConfig().is_config_set())
-        return die("Error: Failed to load and parse edited config file!");
+        return return_die("Failed to load and parse edited config file!");
 
     gConfig().save_config(true);
 
@@ -112,7 +112,7 @@ int edit_config()
 int edit_server(const std::string &server_name)
 {
     if (localpath::server(server_name).empty()) {
-        std::cerr << "Error: Server not found: " << server_name << std::endl;
+        error << "Server not found: " << server_name << std::endl;
         return -1;
     }
 
@@ -130,6 +130,28 @@ int edit_server(const std::string &server_name)
     return 0;
 }
 
+void list_directory(std::string dir, std::string msg)
+{
+    bool first=true;
+    std::vector<std::string> directories;
+    for (const auto &file : std::filesystem::directory_iterator(dir))
+    {
+        if (first)
+        {
+            if (!msg.empty())
+                info << msg << std::endl;
+            first=false;
+        }
+        if (std::filesystem::is_directory(file.path()))
+            directories.push_back(file.path());
+        else
+            info << "  " << file.path() << std::endl;
+    }
+
+    for (const auto &dir : directories)
+        list_directory(dir, "");
+}
+
 // ------------------------------------------------------------------------------------------------
 // edit service config
 // ------------------------------------------------------------------------------------------------
@@ -143,7 +165,14 @@ int edit_service_config(const std::string &server, const std::string &service)
     }
 
     if (edit_file(config_file, true) && std::filesystem::exists(config_file))
-        info << "To apply your changes, run:\n   dropshell install " + server + " " + service << std::endl;
+        info << "Successfully edited service config file at " << config_file << std::endl;
+
+        std::string service_dir = localpath::service(server, service);
+        list_directory(service_dir, "You may wish to edit the other files in " + service_dir);
+
+        info << "Then to apply your changes, run:" << std::endl;
+        info << "   dropshell uninstall " + server + " " + service << std::endl;
+        info << "   dropshell install " + server + " " + service << std::endl;
     return 0;
 }
 

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/health.cpp

@@ -3,7 +3,7 @@
 #include "utils/utils.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "services.hpp"
 #include "servers.hpp"
 #include "transwarp.hpp"

source/src/commands/help.cpp

@@ -10,7 +10,7 @@
 #include <iostream>
 #include <sstream>
 #include <filesystem>
-#include "utils/assert.hpp"
+#include <libassert/assert.hpp>
 
 namespace dropshell {
 
@@ -45,7 +45,7 @@ struct HelpCommandRegister {
 
 
 void help_autocomplete(const CommandContext& ctx) {
-    if (ctx.args.size() == 1) {
+    if (ctx.args.size() == 0) {
         // list all commands
         for (const auto& cmd : CommandRegistry::instance().list_primary_commands(false)) {
             rawout << cmd << std::endl;
@@ -55,6 +55,11 @@ void help_autocomplete(const CommandContext& ctx) {
 }
 
 void show_command(const std::string& cmd) { 
+    // get console width
+    int width = get_console_width() - 6; // 5 for [INF] + 1 for space
+    int firstcol = 34;
+    int secondcol = width - firstcol - 3;
+
     const auto& cmd_info = CommandRegistry::instance().find_command(cmd); 
     if (!cmd_info) 
     {
@@ -62,9 +67,22 @@ void show_command(const std::string& cmd) {
         return;
     }
 
-    info << "  ";
+    if (cmd_info->help_usage.length() < width-secondcol)
-    info << left_align(cmd_info->help_usage, 32);
+    {
-    info << cmd_info->help_description << std::endl;
+        std::string remaining_description = cmd_info->help_description;
+
+        info << "  " << left_align(cmd_info->help_usage, firstcol) << get_line_wrap(remaining_description, secondcol);
+        while (!remaining_description.empty())
+            info << "   " << left_align(" ",firstcol) << get_line_wrap(remaining_description, secondcol-1);
+    }
+    else
+    {
+        info << "  " << cmd_info->help_usage << std::endl;
+        std::string remaining_description = cmd_info->help_description;
+        info << "  " << left_align(" ",firstcol) << get_line_wrap(remaining_description, secondcol);
+        while (!remaining_description.empty())
+            info << "   " << left_align(" ",firstcol) << get_line_wrap(remaining_description, secondcol-1);
+    }
 }
 
 extern const std::string VERSION;
@@ -106,7 +124,7 @@ int help_handler(const CommandContext& ctx) {
     if (ctx.args.size() > 0)
         return show_command_help(ctx.args[0]);
 
-    info << std::endl;
+    std::cout << std::endl;
     maketitle("DropShell version " + VERSION);
     info << std::endl;
     info << "A tool for managing remote servers, by " << AUTHOR << std::endl;
@@ -120,16 +138,18 @@ int help_handler(const CommandContext& ctx) {
     {
         // show more!
         show_command("list");
-        std::cout << std::endl;
+        info << std::endl;
         show_command("install");
         show_command("uninstall");
-        show_command("nuke");
+        show_command("destroy");
-        std::cout << std::endl;
+        info << std::endl;
         show_command("start");
         show_command("stop");
-        std::cout << std::endl;
+        info << std::endl;
         show_command("ssh");
-        std::cout << std::endl;
+        info << std::endl;
+        show_command("create-server");
+        show_command("create-service");
     }
     return 0;
 }

source/src/commands/install.cpp

@@ -10,13 +10,15 @@
 #include "services.hpp"
 #include "utils/output.hpp"
 
+#include <fstream>
 #include <unistd.h>
 #include <cstring>
 #include <iostream>
 #include <sstream>
 #include <filesystem>
-#include "utils/assert.hpp"
+#include <libassert/assert.hpp>
 #include "servers.hpp"
+#include <sys/stat.h>
 
 namespace dropshell
 {
@@ -39,7 +41,7 @@ namespace dropshell
                                                           0,     // min_args (after command)
                                                           2,     // max_args (after command)
                                                           "install [SERVER] [SERVICE|all]",
-                                                          "Install/reinstall host, remote servers, or service(s). Safe/non-destructive way to update.",
+                                                          "Install/reinstall host and remote servers, or service(s). Safe way to update.",
                                                           // heredoc
                                                           R"(
             Install components on a server. This is safe to re-run (non-destructive) and used to update
@@ -55,27 +57,59 @@ namespace dropshell
         }
     } install_command_register;
 
+
     namespace shared_commands
     {
 
         // ------------------------------------------------------------------------------------------------
         // install service over ssh : SHARED COMMAND
         // ------------------------------------------------------------------------------------------------
-        bool install_service(const std::string &server, const std::string &service)
+        bool install_service(const ServerConfig &server_env, const std::string &service)
         {
-            LocalServiceInfo service_info = get_service_info(server, service);
+            std::string server = server_env.get_server_name();
+            LocalServiceInfo service_info = get_service_info(server_env.get_server_name(), service);
+
             if (!SIvalid(service_info))
-                return false;
+                {
-
+                    error << "Failed to install - service information not valid." << std::endl;
-            server_env_manager server_env(server);
+                    return false;
-            if (!server_env.is_valid())
+                }
-                return false;
-
-            maketitle("Installing " + service + " (" + service_info.template_name + ") on " + server);
             
             if (!server_env.is_valid())
                 return false; // should never hit this.
 
+            
+            std::string user = service_info.user;
+            std::string remote_service_path = remotepath(server,user).service(service);
+
+            ASSERT(!remote_service_path.empty(), "Install_Service: Remote service path is empty for " + service + " on " + server);
+            ASSERT(!user.empty(), "Install_Service: User is empty for " + service + " on " + server);
+
+            if (server_env.check_remote_dir_exists(remote_service_path, user))
+            { // uninstall the old service before we update the config or template!
+                info << "Service " << service << " is already installed on " << server << std::endl;
+                shared_commands::uninstall_service(server_env, service);
+            }
+
+            if (!service_info.service_template_hash_match)
+            {
+                warning << "Service " << service << " is using an old template. Updating. " << std::endl;
+                if (!merge_updated_service_template(server_env.get_server_name(), service))
+                {
+                    error << "Failed to merge updated service template. " << std::endl;
+                    return false;
+                }
+
+                service_info = get_service_info(server_env.get_server_name(), service);
+                if (!SIvalid(service_info) || !service_info.service_template_hash_match)
+                {
+                    error << "Merged updated service template, but it is still not valid. " << std::endl;
+                    return false;
+                }
+            }
+
+            maketitle("Installing " + service + " (" + service_info.template_name + ") on " + server);
+
             // Check if template exists
             template_info tinfo = gTemplateManager().get_template_info(service_info.template_name);
             if (!tinfo.is_set())
@@ -88,27 +122,18 @@ namespace dropshell
             }
 
             // Create service directory
-            std::string remote_service_path = remotepath::service(server, service);
             std::string mkdir_cmd = "mkdir -p " + quote(remote_service_path);
-            if (!execute_ssh_command(server_env.get_SSH_INFO(), sCommand("", mkdir_cmd, {}), cMode::Silent))
+            if (!execute_ssh_command(server_env.get_SSH_INFO(user), sCommand("", mkdir_cmd, {}), cMode::Silent))
             {
                 std::cerr << "Failed to create service directory " << remote_service_path << std::endl;
                 return false;
             }
 
-            // Check if rsync is installed on remote host
-            std::string check_rsync_cmd = "which rsync";
-            if (!execute_ssh_command(server_env.get_SSH_INFO(), sCommand("", check_rsync_cmd, {}), cMode::Silent))
-            {
-                std::cerr << "rsync is not installed on the remote host" << std::endl;
-                return false;
-            }
-
             // Copy template files
             debug << "Copying: [LOCAL] " << tinfo.local_template_path() << std::endl
-                  << std::string(8, ' ') << "[REMOTE] " << remotepath::service_template(server, service) << "/" << std::endl;
+                  << std::string(8, ' ') << "[REMOTE] " << remotepath(server,user).service_template(service) << "/" << std::endl;
-            if (!shared_commands::rsync_tree_to_remote(tinfo.local_template_path().string(), remotepath::service_template(server, service),
+            if (!shared_commands::rsync_tree_to_remote(tinfo.local_template_path().string(), remotepath(server,user).service_template(service),
-                                                       server_env, false))
+                                                       server_env, false, service_info.user))
             {
                 std::cerr << "Failed to copy template files using rsync" << std::endl;
                 return false;
@@ -116,9 +141,9 @@ namespace dropshell
 
             // Copy service files
             debug << "Copying: [LOCAL] " << localpath::service(server, service) << std::endl
-                  << std::string(8, ' ') << "[REMOTE] " << remotepath::service_config(server, service) << std::endl;
+                  << std::string(8, ' ') << "[REMOTE] " << remotepath(server,user).service_config(service) << std::endl;
-            if (!shared_commands::rsync_tree_to_remote(localpath::service(server, service), remotepath::service_config(server, service),
+            if (!shared_commands::rsync_tree_to_remote(localpath::service(server, service), remotepath(server,user).service_config(service),
-                                                       server_env, false))
+                                                       server_env, false, service_info.user))
             {
                 std::cerr << "Failed to copy service files using rsync" << std::endl;
                 return false;
@@ -127,11 +152,19 @@ namespace dropshell
             // Run install script
             {
                 info << "Running " << service_info.template_name << " install script on " << server << "..." << std::endl;
-                server_env.run_remote_template_command(service, "install", {}, false, {});
+
+                shared_commands::cRemoteTempFolder remote_temp_folder(server_env, user);
+                if (!server_env.run_remote_template_command(service, "install", {}, false, {{"TEMP_DIR", remote_temp_folder.path()}}))
+                {
+                    error << "Failed to run install script on " << server << std::endl;
+                    return false;
+                }
             }
 
             // print health tick
             info << "Health: " << shared_commands::healthtick(server, service) << std::endl;
+
+           
             return true;
         }
 
@@ -159,49 +192,107 @@ namespace dropshell
         return trim(result);
     }
 
+    int configure_autocomplete()
+    {
+        debug << "Ensuring dropshell autocomplete is registered in ~/.bashrc..." << std::endl;
+
+        std::filesystem::path bashrc = localpath::current_user_home() +"/.bashrc";
+
+        std::string autocomplete_script = R"(
+#---DROPSHELL AUTOCOMPLETE START---
+_dropshell_completions() {
+    local cur
+    COMPREPLY=()
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    
+    # call dropshell to get the list of possiblities for the current argument. Supply all previous arguments.
+    local completions=($(dropshell autocomplete "${COMP_WORDS[@]:1:${COMP_CWORD}-1}"))
+    COMPREPLY=( $(compgen -W "${completions[*]}" -- ${cur}) )
+    return 0
+}
+
+# Register the completion function
+complete -F _dropshell_completions dropshell 
+complete -F _dropshell_completions ds 
+#---DROPSHELL AUTOCOMPLETE END---
+)";
+
+        file_replace_or_add_segment(bashrc.string(), autocomplete_script);
+        return 0;
+    }
+
+    int configure_localbin()
+    {
+        debug << "Ensuring ~/.local/bin is in the ~/.bashrc path..." << std::endl;
+
+        std::filesystem::path bashrc = localpath::current_user_home() +"/.bashrc";
+        std::filesystem::path localbin = localpath::current_user_home() + "/.local/bin";
+        std::filesystem::create_directories(localbin);
+        // check if already in path
+        const char* env_p = std::getenv("PATH");
+        if (env_p) {
+            std::string path_str = env_p;
+            if (path_str.find(localbin.string()) == std::string::npos) {
+                std::string pathstr="#---DROPSHELL PATH START---\nexport PATH=\""+localbin.string()+":$PATH\"\n#---DROPSHELL PATH END---\n";
+                file_replace_or_add_segment(bashrc.string(), pathstr);
+            }
+        }
+        return 0;
+    }
+
     int update_dropshell()
     {
         maketitle("Updating dropshell on this computer...");
 
+        configure_localbin();
+        configure_autocomplete();
+
         // determine path to this executable
-        std::filesystem::path dropshell_path = std::filesystem::canonical("/proc/self/exe");
+        std::filesystem::path exe_path = std::filesystem::canonical("/proc/self/exe");
-        std::filesystem::path parent_path = dropshell_path.parent_path();
+        std::filesystem::path parent_path = exe_path.parent_path();
 
         // determine the architecture of the system
         std::string arch = shared_commands::get_arch();
 
         std::string url = "https://gitea.jde.nz/public/dropshell/releases/download/latest/dropshell." + arch;
 
-        // download new version, preserve permissions and ownership
+        // check that the user that owns the exe is the current user this process is running as.
-        std::string bash_script;
+        struct stat st;
-        bash_script += "docker run --rm -v " + parent_path.string() + ":/target";
+        if (stat(exe_path.c_str(), &st) != 0) {
-        bash_script += " gitea.jde.nz/public/debian-curl:latest";
+            error << "Failed to stat dropshell executable: " << strerror(errno) << std::endl;
-        bash_script += " sh -c \"";
-        bash_script += " curl -fsSL " + url + " -o /target/dropshell_temp &&";
-        bash_script += " chmod --reference=/target/dropshell /target/dropshell_temp &&";
-        bash_script += " chown --reference=/target/dropshell /target/dropshell_temp";
-        bash_script += "\"";
-
-        std::string cmd = "bash -c '" + bash_script + "'";
-        int rval = system(cmd.c_str());
-        if (rval != 0)
-        {
-            std::cerr << "Failed to download new version of dropshell." << std::endl;
             return -1;
         }
 
+        uid_t current_uid = getuid();
+        if (st.st_uid != current_uid) {
+            warning << "Current user does not own the dropshell executable. Please run as the owner to update." << std::endl;
+            return -1;
+        }
+
+        shared_commands::cLocalTempFolder local_temp_folder;
+        std::filesystem::path temp_file = local_temp_folder.path() / "dropshell";
+        bool download_okay = download_file(url, temp_file);
+        if (!download_okay)
+        {
+            error << "Failed to download new version of dropshell." << std::endl;
+            return -1;
+        }
+
+        // make executable
+        chmod(temp_file.c_str(), 0755);
+
         // check if the new version is the same as the old version
-        uint64_t new_hash = hash_file(parent_path / "dropshell_temp");
+        uint64_t new_hash = hash_file(temp_file);
-        uint64_t old_hash = hash_file(parent_path / "dropshell");
+        uint64_t old_hash = hash_file(exe_path);
         if (new_hash == old_hash)
         {
-            std::cout << "Confirmed dropshell is the latest version." << std::endl;
+            info << "Confirmed dropshell is the latest version." << std::endl;
             return 0;
         }
 
-        std::string runvercmd = (parent_path / "dropshell").string() + " version";
+        std::string runvercmd = exe_path.string() + " version";
         std::string currentver = _exec(runvercmd.c_str());
-        runvercmd = (parent_path / "dropshell_temp").string() + " version";
+        runvercmd = temp_file.string() + " version";
         std::string newver = _exec(runvercmd.c_str());
 
         if (currentver >= newver)
@@ -211,21 +302,15 @@ namespace dropshell
             return 0;
         }
 
-        return 0;
+        // move the new version to the old version.
+        std::filesystem::rename(exe_path, exe_path.parent_path() / "dropshell.old");
+        std::filesystem::rename(temp_file, exe_path);
 
-        std::string bash_script_2 = "docker run --rm -v " + parent_path.string() + ":/target gitea.jde.nz/public/debian-curl:latest " +
+        // remove the old version.
-                                    "sh -c \"mv /target/dropshell_temp /target/dropshell\"";
+        std::filesystem::remove(exe_path.parent_path() / "dropshell.old");
-        rval = system(bash_script_2.c_str());
-        if (rval != 0)
-        {
-            error << "Failed to install new version of dropshell." << std::endl;
-            return -1;
-        }
-
-        info << "Successfully updated " << dropshell_path << " to the latest " << arch << " version." << std::endl;
 
         // 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;
     }
@@ -234,69 +319,56 @@ namespace dropshell
     {
         maketitle("Installing dropshell agent on this computer...");
 
-        std::vector<std::filesystem::path> paths = {
+        // clear out old cruft.
-            gConfig().get_local_template_cache_path(),
+        std::filesystem::remove_all(localpath::agent_local());
-            gConfig().get_local_backup_path(),
+        std::filesystem::remove_all(localpath::agent_remote());
-            gConfig().get_local_tempfiles_path(),
-            localpath::agent()};
-        for (auto &p : gConfig().get_local_server_definition_paths())
-            paths.push_back(p);
 
-        for (auto &p : paths)
+        // recreate the directories.
-            if (!std::filesystem::exists(p))
+        localpath::create_directories();
-            {
-                info << "Creating directory: " << p << std::endl;
-                std::filesystem::create_directories(p);
-            }
 
-        // create the agent-local directory.
+        // populate the agent-local directory.
-        recreate_agent_local::recreate_tree(localpath::agent());
+        recreate_agent_local::recreate_tree(localpath::agent_local());
 
         // run the local agent installer.
-            execute_local_command(localpath::agent(), "agent-install.sh",{}, nullptr, cMode::Defaults | cMode::NoBB64);
+        execute_local_command(localpath::agent_local(), "agent-install.sh",{}, nullptr, cMode::Defaults | cMode::NoBB64);
 
-        // create the agent-remote directory.
+        // populate the agent-remote directory.
         info << "Creating local files to copy to remote agents..." << std::endl;
-        recreate_agent_remote::recreate_tree(localpath::files_for_remote_agent());
+        recreate_agent_remote::recreate_tree(localpath::agent_remote());
 
         return 0;
     }
 
-    int install_server(const std::string &server)
+    int install_server(const ServerConfig &server)
     {
         // install the dropshell agent on the given server.
-        maketitle("Installing dropshell agent on " + server, sColour::INFO);
+        maketitle("Installing dropshell agent on " + server.get_server_name(), sColour::INFO);
 
-        std::string agent_path = remotepath::agent(server);
+        for (const auto &user : server.get_users())
-        if (agent_path.empty())
         {
-            error << "Failed to get agent path for " << server << std::endl;
+            info << "Installing agent for user " << user.user << " on " << server.get_server_name() << std::endl;
-            return 1;
+
+            std::string agent_path = remotepath(server.get_server_name(),user.user).agent();
+            ASSERT(agent_path == user.dir+"/agent", "Remote agent path does not match user directory for "+user.user+"@" + server.get_server_name() + " : " + agent_path + " != " + user.dir);
+            ASSERT(!agent_path.empty(), "Agent path is empty for " + user.user + "@" + server.get_server_name());
+
+            // now create the agent.
+            // copy across from the local agent files.
+            info << "Copying local agent files to remote server... " << std::flush;
+            shared_commands::rsync_tree_to_remote(localpath::agent_remote(), agent_path, server, false, user.user);
+            info << "done." << std::endl;
+
+            // run the agent installer. Can't use BB64 yet, as we're installing it on the remote server.
+            
+            bool okay = execute_ssh_command(server.get_SSH_INFO(user.user), sCommand(agent_path, "agent-install.sh",{}), cMode::Defaults | cMode::NoBB64, nullptr);
+            if (!okay)
+            {
+                error << "Failed to install remote agent on " << server.get_server_name() << std::endl;
+                return 1;
+            }
+
+            info << "Installation on " << server.get_server_name() << " complete." << std::endl;
         }
-
-        server_env_manager server_env(server);
-        if (!server_env.is_valid())
-        {
-            error << "Invalid server environment for " << server << std::endl;
-            return 1;
-        }
-
-        // now create the agent.
-        // copy across from the local agent files.
-        info << "Copying local agent files to remote server... " << std::flush;
-        shared_commands::rsync_tree_to_remote(localpath::files_for_remote_agent(), agent_path, server_env, false);
-        info << "done." << std::endl;
-
-        // run the agent installer. Can't use BB64 yet, as we're installing it on the remote server.
-        
-        bool okay = execute_ssh_command(server_env.get_SSH_INFO(), sCommand(agent_path, "agent-install.sh",{}), cMode::Defaults | cMode::NoBB64, nullptr);
-        if (!okay)
-        {
-            error << "ERROR: Failed to install remote agent on " << server << std::endl;
-            return 1;
-        }
-
-        info << "Installation on " << server << " complete." << std::endl;
         return 0;
     }
 
@@ -317,10 +389,10 @@ namespace dropshell
             return rval;
 
         // install the dropshell agent on all servers.
-        std::vector<ServerInfo> servers = get_configured_servers();
+        std::vector<ServerConfig> servers = get_configured_servers();
         for (const auto &server : servers)
         {
-            rval = install_server(server.name);
+            rval = install_server(server);
             if (rval != 0)
                 return rval;
         }
@@ -353,15 +425,24 @@ namespace dropshell
         }
 
         // install service(s)
+        if (!server_exists(server))
+        {
+            error << "Server " << server << " does not exist." << std::endl;
+            info << "Create it with: dropshell create-server " << server << std::endl;
+            return 1;
+        }
+
+        ServerConfig server_env(server);
+        ASSERT(server_env.is_valid(), "Invalid server environment for " + server);
         if (safearg(ctx.args, 1) == "all")
         {
             // install all services on the server
             maketitle("Installing all services on " + server);
             bool okay = true;
             std::vector<LocalServiceInfo> services = get_server_services_info(server);
-            for (const auto &service : services)
+            for (const auto &lsi : services)
             {
-                if (!shared_commands::install_service(server, service.service_name))
+                if (!shared_commands::install_service(server_env, lsi.service_name))
                     okay = false;
             }
             return okay ? 0 : 1;
@@ -369,7 +450,7 @@ namespace dropshell
         else
         { // install the specific service.
             std::string service = safearg(ctx.args, 1);
-            return shared_commands::install_service(server, service) ? 0 : 1;
+            return shared_commands::install_service(server_env, service) ? 0 : 1;
         }
     }
 

source/src/commands/list.cpp

@@ -6,7 +6,7 @@
 #include "servers.hpp"
 #include "tableprint.hpp"
 #include "transwarp.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "services.hpp"
 
 #include <unistd.h>
@@ -14,7 +14,7 @@
 #include <iostream>
 #include <sstream>
 #include <filesystem>
-#include "utils/assert.hpp"
+#include <libassert/assert.hpp>
 
 namespace dropshell {
 
@@ -81,32 +81,63 @@ void list_servers() {
     }
 
     tableprint tp("All DropShell Servers");
-    tp.add_row({"Name", "User", "Address", "Health", "Ports"});
+    tp.add_row({"Name", "Address", "User", "Health", "Ports"});
 
-    info << "Checking "<<servers.size() << " servers: " << std::flush;
+
+    typedef std::map<std::string, shared_commands::ServiceStatus> tServiceStatusMap;
+    std::vector<tServiceStatusMap> service_status_maps;
+
+    typedef struct {dropshell::ServerConfig server; dropshell::UserConfig user;} server_user_pair;
+    std::vector<server_user_pair> server_user_pairs;
+    for (const auto& server : servers) 
+        for (const auto& user : server.get_users()) 
+            server_user_pairs.push_back({server, user});
+
+    // mutex for the tableprint
+    std::mutex tp_mutex;
+
+    info << "Checking "<<server_user_pairs.size() << " agents: " << std::flush;
     int checked = 0;
 
-    transwarp::parallel exec{servers.size()};
-    auto task = transwarp::for_each(exec, servers.begin(), servers.end(), [&](const ServerInfo& server) {
-        std::map<std::string, shared_commands::ServiceStatus> status = shared_commands::get_all_services_status(server.name); 
 
-        std::set<int> ports_used;
+    transwarp::parallel exec{server_user_pairs.size()};
+    auto task = transwarp::for_each(exec, server_user_pairs.begin(), server_user_pairs.end(), [&](const server_user_pair& sup) {
+
+        ServerConfig server_env(sup.server.get_server_name());
+        if (!server_env.is_valid())
+        {
+            error << "Invalid server environment for " << sup.server.get_server_name() << std::endl;
+            return;
+        }
+
         std::string serviceticks = "";
+        std::string ports_used_str = "";
+        std::set<int> ports_used;
+
+        std::map<std::string, shared_commands::ServiceStatus> status = shared_commands::get_all_services_status(sup.server.get_server_name(),sup.user.user); 
+
         for (const auto& [service_name, service_status] : status) {
             ports_used.insert(service_status.ports.begin(), service_status.ports.end());
             serviceticks += shared_commands::HealthStatus2String(service_status.health) + " ";
         }
-        std::string ports_used_str = "";
+
         for (const auto& port : ports_used) 
             ports_used_str += std::to_string(port) + " ";
+        // critical section
+        {
+            std::lock_guard<std::mutex> lock(tp_mutex);
+            tp.add_row({sup.server.get_server_name(), sup.server.get_SSH_HOST(), sup.user.user, serviceticks, ports_used_str});
 
-        tp.add_row({server.name, server.ssh_user, server.ssh_host, serviceticks, ports_used_str});
+            ++checked;
-        ++checked;
+            // print out a tick character for each server checked.
-        // print out a tick character for each server checked.
+            info << checked << " ✓  " << std::flush;
-        info << checked << " ✓  " << std::flush;
+        }
     });
     task->wait();
     info << std::endl << std::endl;
+
+    tp.sort({0,2});
+
     tp.print();
 }
 
@@ -114,36 +145,28 @@ void list_servers() {
 
 
 void show_server_details(const std::string& server_name) {
-    server_env_manager env(server_name);
+    ServerConfig env(server_name);
     if (!env.is_valid()) {
-        error << "Error: Invalid server environment file: " << server_name << std::endl;
+        error << "Invalid server environment file: " << server_name << std::endl;
         return;
     }
 
     //---------------------
     // Check if server is reachable via SSH
-    std::string ssh_address = env.get_SSH_HOST();
+    ASSERT(env.get_users().size() > 0, "No users found for server " + server_name);
-    std::string ssh_user = env.get_SSH_USER();
+    sSSHInfo sshinfo = env.get_SSH_INFO(env.get_users()[0].user);
-    std::string ssh_port = env.get_SSH_PORT();
+    ASSERT(sshinfo.valid(), "Invalid SSH info for server " + server_name);
-    if (!ssh_address.empty()) {
-        info << std::endl << "Server Status:" << std::endl;
-        info << std::string(40, '-') << std::endl;
 
-        // Try to connect to the server
+    info << std::endl << "Server Status:" << std::endl;
-        std::string cmd = "ssh -o ConnectTimeout=5 " + ssh_user + "@" + ssh_address + " -p " + ssh_port + " 'true' 2>/dev/null";
+    info << std::string(40, '-') << std::endl;
-        int result = system(cmd.c_str());
-        if (result == 0) {
-            info << "Status: Online" << std::endl;
     
-            // // Get uptime if possible
+    // Try to connect to the server
-            // cmd = "ssh " + ssh_address + " 'uptime' 2>/dev/null";
+    std::string cmd = "ssh -o ConnectTimeout=5 " + sshinfo.get_user() + "@" + sshinfo.get_host() + " -p " + sshinfo.get_port() + " 'true' 2>/dev/null";
-            // int rval = system(cmd.c_str());
+    int result = system(cmd.c_str());
-            // if (rval != 0) {
+    if (result == 0) {
-            //     std::cout << "Error: Failed to get uptime" << std::endl;
+        info << "Status: Online" << std::endl;
-            // } 
+    } else {
-        } else {
+        warning << "Status: Offline" << std::endl;
-            warning << "Status: Offline" << std::endl;
-        }
     }
     info << std::endl;
 
@@ -151,9 +174,21 @@ void show_server_details(const std::string& server_name) {
     {
         std::cout << std::endl;
         tableprint tp("Server Configuration: " + server_name, true);
+
         tp.add_row({"Key", "Value"});
         for (const auto& [key, value] : env.get_variables()) {
-            tp.add_row({key, value});
+            if (key == "SSH_USERS")
+            {
+                int i=1;
+                for (const auto& user : env.get_users())
+                {
+                    tp.add_row({"USERS -> USER[" + std::to_string(i) + "]", user.user});
+                    tp.add_row({"USERS -> DIR[" + std::to_string(i) + "]", user.dir});
+                    i++;
+                }
+            }
+            else
+                tp.add_row({key, value});
         }
         tp.print();
     }
@@ -164,7 +199,6 @@ void show_server_details(const std::string& server_name) {
         tableprint tp("Services: " + server_name, false);
         tp.add_row({"Status", "Service", "Template","Ports"});
 
-
         std::map<std::string, shared_commands::ServiceStatus> status = shared_commands::get_all_services_status(server_name); 
 
         std::set<int> ports_used;
@@ -176,7 +210,11 @@ void show_server_details(const std::string& server_name) {
             for (const auto& port : service_status.ports) 
                 ports_str += std::to_string(port) + " ";
 
-            tp.add_row({healthy, service_name, get_service_info(server_name,service_name).template_name, ports_str});
+            std::string template_name = get_service_info(server_name,service_name).template_name;
+            if (template_name.empty())
+                template_name = "Unknown";
+        
+            tp.add_row({healthy, service_name, template_name, ports_str});
         } // end of for (const auto& service : services)
         tp.print();
     } // end of list services

source/src/commands/nuke.cpp

@@ -1,154 +0,0 @@
-#include "command_registry.hpp"
-#include "shared_commands.hpp"
-#include "config.hpp"
-#include "services.hpp"
-#include "server_env_manager.hpp"
-#include "utils/directories.hpp"
-#include "servers.hpp"
-#include "templates.hpp"
-#include "utils/utils.hpp"
-
-#include "utils/assert.hpp"
-
-namespace dropshell
-{
-
-    int nuke_handler(const CommandContext &ctx);
-    static std::vector<std::string> nuke_name_list = {"nuke"};
-
-    // Static registration
-    struct NukeCommandRegister
-    {
-        NukeCommandRegister()
-        {
-            CommandRegistry::instance().register_command({nuke_name_list,
-                                                          nuke_handler,
-                                                          shared_commands::std_autocomplete,
-                                                          false, // hidden
-                                                          true,  // requires_config
-                                                          true,  // requires_install
-                                                          2,     // min_args (after command)
-                                                          2,     // max_args (after command)
-                                                          "nuke SERVER SERVICE|all",
-                                                          "Nuke a service on a server. Destroys everything, both local and remote!",
-                                                          // heredoc
-                                                          R"(
-            Nuke a service.
-
-            Examples:
-            nuke SERVER SERVICE   nuke the given service on the given server.
-            nuke SERVER all       nuke all services on the given server.
-
-            Note: This command is destructive and will destroy all data and all configuration,
-            both on the dropshell host and on the remote server.
-
-            Use with caution!
-            )"});
-        }
-    } nuke_command_register;
-
-    namespace shared_commands
-    {
-
-        bool nuke_service(const std::string &server, const std::string &service)
-        {
-            server_env_manager server_env(server);
-
-            // step 1 - nuke on remote server.
-            if (server_env.is_valid())
-            {
-                LocalServiceInfo service_info;
-
-                service_info = get_service_info(server, service);
-                if (!SIvalid(service_info))
-                    error << "Invalid service: " << service << std::endl;
-
-                if (server_env.check_remote_dir_exists(remotepath::service(server, service)))
-                {
-                    // run the nuke script on the remote server if it exists.
-                    // otherwise just uninstall.
-                    if (gTemplateManager().template_command_exists(service_info.template_name, "nuke"))
-                    {
-                        info << "Running nuke script for " << service << " on " << server << std::endl;
-                        if (!server_env.run_remote_template_command(service, "nuke", {}, false, {}))
-                            warning << "Failed to run nuke script: " << service << std::endl;
-                    }
-                    else
-                    {
-                        info << "No nuke script found for " << service << " on " << server << std::endl;
-                        info << "Running uninstall script instead and will clean directories." << std::endl;
-                        if (!server_env.run_remote_template_command(service, "uninstall", {}, false, {}))
-                            warning << "Failed to uninstall service: " << service << std::endl;
-                    }
-
-                    // Remove the service directory from the server, running in a docker container as root.
-                    if (server_env.remove_remote_dir(remotepath::service(server, service), true))
-                    {
-                        ASSERT(!server_env.check_remote_dir_exists(remotepath::service(server, service)), "Service directory still found on server after uninstall");
-                        info << "Remote service directory removed: " << remotepath::service(server, service) << std::endl;
-                    }
-                    else
-                        warning << "Failed to remove remote service directory" << std::endl;
-                }
-                else
-                    warning << "Service not found on remote server: " << remotepath::service(server, service) << std::endl;
-            }
-            else
-                warning << "Can't nuke the remote service as the server is invalid: " << server << std::endl;
-
-            // step 2 - nuke the local service directory.
-            std::string local_service_path = localpath::service(server, service);
-            if (local_service_path.empty() || !std::filesystem::exists(local_service_path))
-            {
-                warning << "Local service directory not found: " << local_service_path << std::endl;
-            }
-            else
-            {
-                auto itemsdeleted = std::filesystem::remove_all(local_service_path);
-                if (itemsdeleted == 0)
-                    error << "Failed to remove local service directory" << std::endl;
-            }
-
-            info << "Nuked service " << service << " on server " << server << std::endl;
-
-            return true;
-        }
-    } // namespace shared_commands
-
-    int nuke_handler(const CommandContext &ctx)
-    {
-        ASSERT(ctx.args.size() == 2, "Usage: nuke SERVER SERVICE|all (requires 2 args - you supplied " + std::to_string(ctx.args.size()) + ")");
-        ASSERT(gConfig().is_config_set(), "No configuration found. Please run 'dropshell config' to set up your configuration.");
-
-        std::string server = safearg(ctx.args, 0);
-        std::string service = safearg(ctx.args, 1);
-
-        if (service == "all")
-        {
-            int rval = 0;
-
-            // iterate through all service folders in the server directory.
-            std::string server_path = localpath::server(server);
-            if (server_path.empty())
-            {
-                error << "Server not found: " << server << std::endl;
-                return 1;
-            }
-
-            for (const auto &entry : std::filesystem::directory_iterator(server_path))
-            {
-                if (entry.is_directory() && entry.path().filename().string().find(".") != 0)
-                {
-                    std::string service_name = entry.path().filename().string();
-                    rval |= (shared_commands::nuke_service(server, service_name) ? 0 : 1);
-                }
-            }
-            return rval;
-        }
-        else
-        {
-            return (shared_commands::nuke_service(server, service) ? 0 : 1);
-        }
-    }
-
-} // namespace dropshell

source/src/commands/restoredata.cpp

@@ -5,13 +5,13 @@
 #include <filesystem>
 
 #include "utils/output.hpp"
-#include "utils/assert.hpp"
+#include <libassert/assert.hpp>
 #include "utils/utils.hpp"
 #include "command_registry.hpp"
 #include "config.hpp"
 #include "services.hpp"
 #include "servers.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "templates.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
@@ -57,10 +57,10 @@ namespace dropshell
 
     std::vector<shared_commands::cBackupFileName> get_backup_files(const std::string &server, const std::string &match_service = "", const std::string &match_template_name = "")
     {
-        std::string local_backups_dir = gConfig().get_local_backup_path();
+        std::string local_backups_dir = localpath::backups();
         if (local_backups_dir.empty() || !std::filesystem::exists(local_backups_dir))
         {
-            error << "Error: Local backups directory not found: " << local_backups_dir << std::endl;
+            error << "Local backups directory not found: " << local_backups_dir << std::endl;
             return {};
         }
 
@@ -92,7 +92,7 @@ namespace dropshell
         std::string service = ctx.args[1];
         std::string backup_arg = ctx.args[2];
 
-        server_env_manager server_env(server);
+        ServerConfig server_env(server);
         if (!server_env.is_valid())
         {
             error << "Server " << server << " is not valid" << std::endl;
@@ -105,6 +105,16 @@ namespace dropshell
             return 1;
         }
 
+
+        if (!gTemplateManager().template_command_exists(service_info.template_name, "backup") || 
+            !gTemplateManager().template_command_exists(service_info.template_name, "restore"))
+            {
+                info << service << " has no data to restore" << std::endl;
+                debug << "(no backup or restore script for " << service_info.template_name << ")" << std::endl;
+                return 0; // nothing to back up.
+            }
+
+
         std::optional<shared_commands::cBackupFileName> backup_details;
         if (backup_arg == "latest")
         { // special case.
@@ -137,22 +147,22 @@ namespace dropshell
         debug << "   Server:                      " << server << std::endl;
         debug << "   Service:                     " << service << std::endl;
 
-        std::string local_backups_dir = gConfig().get_local_backup_path();
+        std::string local_backups_dir = localpath::backups();
         if (local_backups_dir.empty() || !std::filesystem::exists(local_backups_dir))
         {
-            error << "Error: Local backups directory not found: " << local_backups_dir << std::endl;
+            error << "Local backups directory not found: " << local_backups_dir << std::endl;
             return 1;
         }
         std::string local_backup_file_path = (std::filesystem::path(local_backups_dir) / backup_details->get_filename()).string();
         if (!std::filesystem::exists(local_backup_file_path))
         {
-            error << "Error: Backup file not found at " << local_backup_file_path << std::endl;
+            error << "Backup file not found at " << local_backup_file_path << std::endl;
             return 1;
         }
 
         if (backup_details->get_template_name() != service_info.template_name)
         {
-            error << "Error: Backup template does not match service template. Can't restore." << std::endl;
+            error << "Backup template does not match service template. Can't restore." << std::endl;
             info << "Backup template:  " << backup_details->get_template_name() << std::endl;
             info << "Service template: " << service_info.template_name << std::endl;
             return 1;
@@ -175,39 +185,41 @@ namespace dropshell
             info << "Backup complete." << std::endl;
         }
 
-        { // nuke the old service
+        { // Destroy the old service
-            info << "2) Nuking old service..." << std::endl;
+            info << "2) Destroying old service..." << std::endl;
-            if (!shared_commands::nuke_service(server, service))
+            if (!shared_commands::destroy_service(server, service))
                 return 1;
         }
 
         { // create the new service
             info << "3) Creating new service..." << std::endl;
-            if (!shared_commands::create_service(server, service_info.template_name, service))
+            if (!shared_commands::create_service(server, service_info.template_name, service, service_info.user))
                 return 1;
         }
 
         { // installing fresh service
             info << "4) Install of fresh service..." << std::endl;
-            if (!shared_commands::install_service(server, service))
+            ServerConfig server_env(server);   
+            if (!shared_commands::install_service(server_env, service))
                 return 1;
         }
 
         { // restore service from backup
             info << "5) Restoring service data from backup..." << std::endl;
-            std::string remote_backups_dir = remotepath::backups(server);
+            std::string user = server_env.get_user_for_service(service);
+            std::string remote_backups_dir = remotepath(server, user).backups();
             std::string remote_backup_file_path = remote_backups_dir + "/" + backup_details->get_filename();
 
             debug << "Copying backup file from local to server: " << local_backup_file_path << " -> " << remote_backup_file_path << std::endl;
 
             // Copy backup file from local to server
-            if (!shared_commands::scp_file_to_remote(server_env, local_backup_file_path, remote_backup_file_path, false))
+            if (!shared_commands::scp_file_to_remote(server_env, local_backup_file_path, remote_backup_file_path, false, service_info.user))
             {
                 error << "Failed to copy backup file from local to server" << std::endl;
                 return 1;
             }
 
-            shared_commands::cRemoteTempFolder remote_temp_folder(server_env);
+            shared_commands::cRemoteTempFolder remote_temp_folder(server_env,user);
 
             debug << "Running restore script on server: " << server << std::endl;
             debug << "  BACKUP_FILE: " << remote_backup_file_path << std::endl;

source/src/commands/shared_commands.cpp

@@ -1,7 +1,7 @@
 #include "shared_commands.hpp"
-#include "utils/assert.hpp"
+#include <libassert/assert.hpp>
 #include "utils/utils.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "directories.hpp"
 #include "services.hpp"
 #include "servers.hpp"
@@ -21,10 +21,10 @@ namespace dropshell
             if (ctx.args.size() == 0)
             { // just the command, no args yet.
                 // list servers
-                std::vector<ServerInfo> servers = get_configured_servers();
+                std::vector<ServerConfig> servers = get_configured_servers();
                 for (const auto &server : servers)
                 {
-                    rawout << server.name << std::endl;
+                    rawout << server.get_server_name() << std::endl;
                 }
             }
             else if (ctx.args.size() == 1)
@@ -54,14 +54,15 @@ namespace dropshell
         bool rsync_tree_to_remote(
             const std::string &local_path,
             const std::string &remote_path,
-            server_env_manager &server_env,
+            const ServerConfig &server_env,
-            bool silent)
+            bool silent,
+            std::string user)
         {
             ASSERT(!local_path.empty() && !remote_path.empty(), "Local or remote path not specified. Can't rsync.");
 
             std::string rsync_cmd = "rsync --delete --mkpath -zrpc -e 'ssh -p " + server_env.get_SSH_PORT() + "' " +
                                     quote(local_path + "/") + " " +
-                                    quote(server_env.get_SSH_USER() + "@" + server_env.get_SSH_HOST() + ":" +
+                                    quote(user + "@" + server_env.get_SSH_HOST() + ":" +
                                           remote_path + "/");
             return execute_local_command("", rsync_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
         }
@@ -74,9 +75,9 @@ namespace dropshell
             // determine the architecture of the system
             std::string arch;
 #ifdef __aarch64__
-            arch = "arm64";
+            arch = "aarch64";
 #elif __x86_64__
-            arch = "amd64";
+            arch = "x86_64";
 #endif
             return arch;
         }
@@ -84,11 +85,12 @@ namespace dropshell
         // ------------------------------------------------------------------------------------------------
         // cRemoteTempFolder : SHARED CLASS
         // ------------------------------------------------------------------------------------------------
-        cRemoteTempFolder::cRemoteTempFolder(const server_env_manager &server_env) : mServerEnv(server_env)
+        cRemoteTempFolder::cRemoteTempFolder(const ServerConfig &server_env, std::string user) : 
+        mServerEnv(server_env), mUser(user)
         {
-            std::string p = remotepath::temp_files(server_env.get_server_name()) + "/" + random_alphanumeric_string(10);
+            std::string p = remotepath(server_env.get_server_name(),user).temp_files() + "/" + random_alphanumeric_string(10);
             std::string mkdir_cmd = "mkdir -p " + quote(p);
-            if (!execute_ssh_command(server_env.get_SSH_INFO(), sCommand("", mkdir_cmd, {}), cMode::Silent))
+            if (!execute_ssh_command(server_env.get_SSH_INFO(user), sCommand("", mkdir_cmd, {}), cMode::Silent))
                 error << "Failed to create temp directory on server" << std::endl;
             else
                 mPath = p;
@@ -97,7 +99,7 @@ namespace dropshell
         cRemoteTempFolder::~cRemoteTempFolder()
         {
             std::string rm_cmd = "rm -rf " + quote(mPath);
-            execute_ssh_command(mServerEnv.get_SSH_INFO(), sCommand("", rm_cmd, {}), cMode::Silent);
+            execute_ssh_command(mServerEnv.get_SSH_INFO(mUser), sCommand("", rm_cmd, {}), cMode::Silent);
         }
 
         std::string cRemoteTempFolder::path() const
@@ -105,24 +107,45 @@ namespace dropshell
             return mPath;
         }
 
+
+
+        cLocalTempFolder::cLocalTempFolder()
+        {
+            mPath = std::filesystem::temp_directory_path() / random_alphanumeric_string(10);
+            std::filesystem::create_directories(mPath);
+        }
+        cLocalTempFolder::~cLocalTempFolder()
+        {
+            std::filesystem::remove_all(mPath);
+        }
+        std::filesystem::path cLocalTempFolder::path() const
+        {
+            return mPath;
+        }
+
         // ------------------------------------------------------------------------------------------------
         // get_all_services_status : SHARED COMMAND
         // ------------------------------------------------------------------------------------------------
-        std::map<std::string, ServiceStatus> get_all_services_status(std::string server_name)
+        std::map<std::string, ServiceStatus> get_all_services_status(const ServerConfig & server_env)
         {
             std::map<std::string, ServiceStatus> status;
-
+            for (const auto& user : server_env.get_users()) {
-            server_env_manager env(server_name);
+                status.merge(get_all_services_status(server_env, user.user));
-            if (!env.is_valid())
-            {
-                error << "Invalid server environment" << std::endl;
-                return status;
             }
+            return status;
+        }
+
+        std::map<std::string, ServiceStatus> get_all_services_status(const ServerConfig & server_env, std::string user)
+        {
+            std::map<std::string, ServiceStatus> status;
+            std::string server_name = server_env.get_server_name();
 
             std::string output;
-            if (!execute_ssh_command(env.get_SSH_INFO(), sCommand(remotepath::agent(server_name), "./_allservicesstatus.sh", {{"HOST_NAME", server_name}, {"SERVER", server_name}, {"AGENT_PATH", remotepath::agent(server_name)}}),
+            std::string agentpath = remotepath(server_name,user).agent();
-                                     cMode::Silent,
+            if (!execute_ssh_command(server_env.get_SSH_INFO(user), 
-                                     &output))
+                sCommand(agentpath, "./_allservicesstatus.sh", {{"HOST_NAME", server_name}, {"SERVER", server_name}, {"AGENT_PATH", agentpath}}),
+                cMode::Silent,
+                &output))
                 return status;
 
             std::stringstream ss(output);
@@ -162,6 +185,7 @@ namespace dropshell
                     }
                 }
             }
+
             return status;
         }
 
@@ -208,20 +232,22 @@ namespace dropshell
         // ------------------------------------------------------------------------------------------------
         HealthStatus is_healthy(const std::string &server, const std::string &service)
         {
-            server_env_manager env(server);
+            ServerConfig env(server);
             if (!env.is_valid())
             {
                 error << "Server service not initialized" << std::endl;
                 return HealthStatus::ERROR;
             }
 
-            if (!env.check_remote_dir_exists(remotepath::service(server, service)))
+            std::string user = env.get_user_for_service(service);
+
+            if (!env.check_remote_dir_exists(remotepath(server,user).service(service), user))
             {
                 return HealthStatus::NOTINSTALLED;
             }
 
-            std::string script_path = remotepath::service_template(server, service) + "/status.sh";
+            std::string script_path = remotepath(server,user).service_template(service) + "/status.sh";
-            if (!env.check_remote_file_exists(script_path))
+            if (!env.check_remote_file_exists(script_path, user))
             {
                 return HealthStatus::UNKNOWN;
             }
@@ -299,7 +325,7 @@ namespace dropshell
         // ------------------------------------------------------------------------------------------------
         // scp_file_to_remote : SHARED COMMAND
         // ------------------------------------------------------------------------------------------------
-        bool scp_file_to_remote(const server_env_manager &server_env, const std::string &local_path, const std::string &remote_path, bool silent)
+        bool scp_file_to_remote(const ServerConfig &server_env, const std::string &local_path, const std::string &remote_path, bool silent, std::string user)
         {
             if (!server_env.is_valid())
             {
@@ -307,14 +333,14 @@ namespace dropshell
                 return false;
             }
             ASSERT(!remote_path.empty() && !local_path.empty(), "Remote or local path not specified. Can't scp.");
-            std::string scp_cmd = "scp -P " + server_env.get_SSH_PORT() + " " + quote(local_path) + " " + server_env.get_SSH_USER() + "@" + server_env.get_SSH_HOST() + ":" + quote(remote_path) + (silent ? " > /dev/null 2>&1" : "");
+            std::string scp_cmd = "scp -P " + server_env.get_SSH_PORT() + " " + quote(local_path) + " " + user + "@" + server_env.get_SSH_HOST() + ":" + quote(remote_path) + (silent ? " > /dev/null 2>&1" : "");
             return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
         }
 
         // ------------------------------------------------------------------------------------------------
         // scp_file_from_remote : SHARED COMMAND
         // ------------------------------------------------------------------------------------------------
-        bool scp_file_from_remote(const server_env_manager &server_env, const std::string &remote_path, const std::string &local_path, bool silent)
+        bool scp_file_from_remote(const ServerConfig &server_env, const std::string &remote_path, const std::string &local_path, bool silent, std::string user)
         {
             if (!server_env.is_valid())
             {
@@ -322,7 +348,7 @@ namespace dropshell
                 return false;
             }
             ASSERT(!remote_path.empty() && !local_path.empty(), "Remote or local path not specified. Can't scp.");
-            std::string scp_cmd = "scp -P " + server_env.get_SSH_PORT() + " " + server_env.get_SSH_USER() + "@" + server_env.get_SSH_HOST() + ":" + quote(remote_path) + " " + quote(local_path) + (silent ? " > /dev/null 2>&1" : "");
+            std::string scp_cmd = "scp -P " + server_env.get_SSH_PORT() + " " + user + "@" + server_env.get_SSH_HOST() + ":" + quote(remote_path) + " " + quote(local_path) + (silent ? " > /dev/null 2>&1" : "");
             return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
         }
 

source/src/commands/shared_commands.hpp

@@ -1,9 +1,11 @@
 #ifndef SHARED_COMMANDS_HPP
 #define SHARED_COMMANDS_HPP
 
+#include <filesystem>
+
 #include "servers.hpp"
 #include "command_registry.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 
 namespace dropshell
 {
@@ -31,23 +33,36 @@ namespace dropshell
     class cRemoteTempFolder
     {
     public:
-        cRemoteTempFolder(const server_env_manager &server_env); // create a temp folder on the remote server
+        cRemoteTempFolder(const ServerConfig &server_env, std::string user); // create a temp folder on the remote server
         ~cRemoteTempFolder();                                    // delete the temp folder on the remote server
         std::string path() const;                                // get the path to the temp folder on the remote server
     private:
         std::string mPath;
-        const server_env_manager &mServerEnv;
+        const ServerConfig &mServerEnv;
+        std::string mUser;
+    };
+
+    class cLocalTempFolder
+    {
+    public:
+        cLocalTempFolder(); // create a temp folder on the local machine
+        ~cLocalTempFolder();                                    // delete the temp folder on the local machine
+        std::filesystem::path path() const;                                // get the path to the temp folder on the local machine
+    private:
+        std::filesystem::path mPath;
     };
 
     bool rsync_tree_to_remote(
         const std::string &local_path,
         const std::string &remote_path,
-        server_env_manager &server_env,
+        const ServerConfig &server_env,
-        bool silent);
+        bool silent,
+        std::string user);
 
     std::string get_arch();
 
-    std::map<std::string, ServiceStatus> get_all_services_status(std::string server_name);
+    std::map<std::string, ServiceStatus> get_all_services_status(const ServerConfig & server_env);
+    std::map<std::string, ServiceStatus> get_all_services_status(const ServerConfig & server_env, std::string user);
 
     std::string healthtick(const std::string &server, const std::string &service);
     std::string HealthStatus2String(HealthStatus status);
@@ -78,23 +93,24 @@ namespace dropshell
         std::string mDatetime;
     };
 
-    bool scp_file_to_remote(const server_env_manager &server_env, const std::string &local_path, const std::string &remote_path, bool silent);
+    bool scp_file_to_remote(const ServerConfig &server_env, const std::string &local_path, const std::string &remote_path, bool silent, std::string user);
-    bool scp_file_from_remote(const server_env_manager &server_env, const std::string &remote_path, const std::string &local_path, bool silent);
+    bool scp_file_from_remote(const ServerConfig &server_env, const std::string &remote_path, const std::string &local_path, bool silent, std::string user);
 
     // defined in backupdata.cpp, used by restoredata.cpp.
-    bool backupdata_service(const std::string& server, const std::string& service);
+    bool backupdata_service(const ServerConfig &server_env, const std::string& service);
 
     // defined in uninstall.cpp
-    bool uninstall_service(const std::string &server, const std::string &service);
+    bool uninstall_service(const ServerConfig &server_env, const std::string &service);
 
-    // defined in nuke.cpp
+    // defined in destroy.cpp
-    bool nuke_service(const std::string &server, const std::string &service);
+    bool destroy_service(const std::string &server, const std::string &service);
 
     // defined in install.cpp
-    bool install_service(const std::string &server, const std::string &service);
+    bool install_service(const ServerConfig &server_env, const std::string &service);
 
     // defined in create-service.cpp
-    bool create_service(const std::string &server_name, const std::string &template_name, const std::string &service_name);
+    bool create_service(const std::string &server_name, const std::string &template_name, const std::string &service_name, std::string user_override="");
+    bool merge_updated_service_template(const std::string &server_name, const std::string &service_name);
 
     } // namespace shared_commands
 } // namespace dropshell

source/src/commands/ssh.cpp

@@ -3,10 +3,11 @@
 #include "utils/utils.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "services.hpp"
 #include "servers.hpp"
 #include "templates.hpp"
+#include <libassert/assert.hpp>
 
 namespace dropshell
 {
@@ -24,8 +25,8 @@ namespace dropshell
                                                           ssh_handler,
                                                           shared_commands::std_autocomplete,
                                                           false, // hidden
-                                                          true, // requires_config
+                                                          true,  // requires_config
-                                                          true, // requires_install
+                                                          true,  // requires_install
                                                           1,     // min_args (after command)
                                                           2,     // max_args (after command)
                                                           "ssh SERVER",
@@ -34,33 +35,38 @@ namespace dropshell
                 
                 ssh SERVER SERVICE     SSH into a docker container for a service.
                 ssh SERVER             SSH into a server.
+                ssh USER@SERVER        SSH into a server as a specific user.
                 )"});
         }
     } ssh_command_register;
 
-
+    bool ssh_into_server(const std::string &server, std::string user)
-
-    bool ssh_into_server(const std::string &server)
     {
-        server_env_manager server_env(server);
+        ServerConfig server_env(server);
         if (!server_env.is_valid())
         {
             error << "Server " << server << " is not valid" << std::endl;
             return false;
         }
-        execute_ssh_command(server_env.get_SSH_INFO(), sCommand(remotepath::DROPSHELL_DIR(server), "ls --color && bash", {}), cMode::Interactive);
+        execute_ssh_command(server_env.get_SSH_INFO(user), sCommand(remotepath(server, user).DROPSHELL_DIR(), "ls --color && bash", {}), cMode::Interactive);
         return true;
     }
 
     bool ssh_into_service(const std::string &server, const std::string &service)
     {
-        server_env_manager server_env(server);
+        ServerConfig server_env(server);
         if (!server_env.is_valid())
         {
             error << "Server " << server << " is not valid" << std::endl;
             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))
         {
@@ -80,7 +86,7 @@ namespace dropshell
             return false;
         }
 
-        server_env.run_remote_template_command(service,"ssh",{},false,{}); // explicitly supports interactive ssh!
+        server_env.run_remote_template_command(service, "ssh", {}, false, {}); // explicitly supports interactive ssh!
         return true;
     }
 
@@ -92,18 +98,41 @@ namespace dropshell
             return 1;
         }
 
-        std::string server = safearg(ctx.args, 0);
+        // ssh into the server
-
         if (ctx.args.size() < 2)
         {
-            // ssh into the server
+            std::string arg1 = safearg(ctx.args, 0);
-            return ssh_into_server(server) ? 0 : 1;
+            std::string server, user;
+
+            // parse either user@server or server
+            if (arg1.find("@") != std::string::npos)
+            {
+                user = arg1.substr(0, arg1.find("@"));
+                server = arg1.substr(arg1.find("@") + 1);
+            }
+            else
+            {
+                server = arg1;
+
+                // get the first user from the server.env file, and ssh in as that user.
+                ServerConfig server_env(server);
+                if (!server_env.is_valid())
+                {
+                    error << "Server " << server << " is not valid" << std::endl;
+                    return 1;
+                }
+                ASSERT(server_env.get_users().size() > 0, "Server " + server + " has no users");
+                user = server_env.get_users()[0].user;
+            }
+
+            return ssh_into_server(server, user) ? 0 : 1;
+        }
+        else
+        { // ssh into a service on the server.
+            std::string server = safearg(ctx.args, 0);
+            std::string service = safearg(ctx.args, 1);
+            return ssh_into_service(server, service) ? 0 : 1;
         }
-
-        std::string service = safearg(ctx.args, 1);
-
-        // ssh into the specific service.
-        return ssh_into_service(server, service) ? 0 : 1;
     }
 
 } // namespace dropshell

source/src/commands/start.cpp

@@ -3,7 +3,7 @@
 #include "utils/utils.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "services.hpp"
 #include "servers.hpp"
 #include "utils/output.hpp"
@@ -44,13 +44,19 @@ namespace dropshell
 
     bool start_service(const std::string &server, const std::string &service)
     {
-        server_env_manager server_env(server);
+        ServerConfig server_env(server);
         if (!server_env.is_valid())
         {
             error << "Server " << server << " is not valid" << std::endl;
             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, {});
 
@@ -67,7 +73,7 @@ namespace dropshell
     {
         if (ctx.args.size() < 2)
         {
-            std::cerr << "Error: Server name and service name are both required" << std::endl;
+            error << "Server name and service name are both required" << std::endl;
             return 1;
         }
 

source/src/commands/stop.cpp

@@ -3,7 +3,7 @@
 #include "utils/utils.hpp"
 #include "utils/directories.hpp"
 #include "shared_commands.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "services.hpp"
 #include "servers.hpp"
 #include "utils/output.hpp"
@@ -44,13 +44,19 @@ namespace dropshell
 
     bool stop_service(const std::string &server, const std::string &service)
     {
-        server_env_manager server_env(server);
+        ServerConfig server_env(server);
         if (!server_env.is_valid())
         {
             error << "Server " << server << " is not valid" << std::endl;
             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/commands/uninstall.cpp

@@ -3,7 +3,7 @@
 #include "shared_commands.hpp"
 #include "templates.hpp"
 
-#include "utils/assert.hpp"
+#include <libassert/assert.hpp>
 #include "utils/utils.hpp"
 #include "services.hpp"
 
@@ -36,40 +36,37 @@ namespace dropshell
             uninstall SERVER SERVICE   Uninstall the given service on the given server.
             uninstall SERVER all       Uninstall all services on the given server.
 
-            Update and reinstall the service with install, or delete all configuration and data with nuke.
+            Update and reinstall the service with install, or delete all configuration and data with destroy.
                 )"});
         }
     } uninstall_command_register;
 
     namespace shared_commands {
-        bool uninstall_service(const std::string &server, const std::string &service)
+        bool uninstall_service(const ServerConfig & server_env, const std::string &service)
         {
+            ASSERT(server_env.is_valid(), "Invalid server environment for " + server_env.get_server_name());
+            std::string server = server_env.get_server_name();
             maketitle("Uninstalling " + service + " on " + server);
 
-            server_env_manager server_env(server);
+            std::string user = server_env.get_user_for_service(service);
-            if (!server_env.is_valid())
-            {
-                error << "Invalid server: " << server << std::endl;
-                return false; // should never hit this.
-            }
 
             // 2. Check if service directory exists on server
-            if (!server_env.check_remote_dir_exists(remotepath::service(server, service)))
+            if (!server_env.check_remote_dir_exists(remotepath(server, user).service(service), user))
             {
                 error << "Service is not installed: " << service << std::endl;
                 return true; // Nothing to uninstall
             }
 
             // 3. Run uninstall script if it exists
-            std::string uninstall_script = remotepath::service_template(server, service) + "/uninstall.sh";
+            std::string uninstall_script = remotepath(server, user).service_template(service) + "/uninstall.sh";
             if (!server_env.run_remote_template_command(service, "uninstall", {}, false, {}))
                 warning << "Uninstall script failed, but continuing with directory removal" << std::endl;
 
             // 4. Remove the service directory from the server, running in a docker container as root.
-            if (server_env.remove_remote_dir(remotepath::service(server, service), false))
+            if (server_env.remove_remote_dir(remotepath(server, user).service(service), false, user))
             {
-                ASSERT(!server_env.check_remote_dir_exists(remotepath::service(server, service)), "Service directory still found on server after uninstall");
+                ASSERT(!server_env.check_remote_dir_exists(remotepath(server, user).service(service), user), "Service directory still found on server after uninstall");
-                info << "Removed remote service directory " << remotepath::service(server, service) << std::endl;
+                info << "Removed remote service directory " << remotepath(server, user).service(service) << std::endl;
             }
             else
                 warning << "Failed to remove remote service directory" << std::endl;

source/src/config.cpp

@@ -3,7 +3,6 @@
 #include <fstream>
 #include "config.hpp"
 #include "utils/utils.hpp"
-#include "utils/json.hpp"
 #include <filesystem>
 #include "utils/execute.hpp"
 #include "output.hpp"
@@ -38,7 +37,7 @@ bool config::load_config() { // load json config file.
     }
     catch (nlohmann::json::parse_error& ex)
     {
-        std::cerr << "Error: Failed to parse config file: " << ex.what() << std::endl;
+        error << "Failed to parse config file: " << ex.what() << std::endl;
         return false;
     }
 
@@ -46,6 +45,15 @@ bool config::load_config() { // load json config file.
     return true;
 }
 
+void _append(std::vector<std::string> & a, const std::vector<std::string> & b) {
+    if (b.empty())
+        return;
+    if (a.empty())
+        a = b;
+    else
+        a.insert(std::end(a), std::begin(b), std::end(b));
+}
+
 bool config::save_config(bool create_aux_directories)
 {
     std::string config_path = localfile::dropshell_json();
@@ -62,36 +70,30 @@ bool config::save_config(bool create_aux_directories)
     {
         std::string homedir = localpath::current_user_home();
         std::string dropshell_base = homedir + "/.dropshell";
-        mConfig["tempfiles"] = dropshell_base + "/tmp";
-        mConfig["backups"] = dropshell_base + "/backups";
-
-        mConfig["template_cache"] = dropshell_base + "/template_cache";
-        mConfig["template_registry_URLs"] = {
-            "https://templates.dropshell.app"
-        };
-        mConfig["template_local_paths"] = {
-            dropshell_base + "/local_templates"
-        };
 
         mConfig["server_definition_paths"] = {
             dropshell_base + "/servers"
         };
-        mConfig["template_upload_registry_url"] = "https://templates.dropshell.app"; 
+        mConfig["template_local_paths"] = {
-        mConfig["template_upload_registry_token"] = "SECRETTOKEN";
+            dropshell_base + "/local_templates"
+        };
+        mConfig["template_registry_URLs"] = {
+            "https://templates.dropshell.app"
+        };        
+        mConfig["template_upload_token"] = "SECRETTOKEN";
+
+        mConfig["backups_path"] = {
+            dropshell_base + "/backups"
+        };
     }   
 
     config_file << mConfig.dump(4);
     config_file.close();
 
     if (create_aux_directories) {
-        std::vector<std::filesystem::path> paths = {
+        std::vector<std::string> paths;
-            get_local_template_cache_path(),
+        _append(paths, get_local_template_paths());
-            get_local_backup_path(),
+        _append(paths, get_local_server_definition_paths());
-            get_local_tempfiles_path()
-        };
-        for (auto & p : get_local_server_definition_paths()) 
-            paths.push_back(p);
-
         for (auto & p : paths)
             if (!std::filesystem::exists(p))
             {
@@ -100,6 +102,11 @@ bool config::save_config(bool create_aux_directories)
             }
     }
 
+    debug << "Config paths: " << std::endl;
+    for (auto [key,value] : mConfig.items()) {
+        debug << "  " << key << ": " << value << std::endl;
+    }
+    
     return true;
 }
 
@@ -110,31 +117,20 @@ bool config::is_config_set() const
 
 bool config::is_agent_installed()
 {
-    return std::filesystem::exists(localpath::agent() + "/bb64");
+    return std::filesystem::exists(localfile::bb64());
 }
 
-std::string config::get_local_tempfiles_path() {
+std::vector<tRegistryEntry> config::get_template_registry_urls() {
-    return mConfig["tempfiles"];
+    nlohmann::json template_registries = mConfig["template_registries"];
-}
+    std::vector<tRegistryEntry> registries;
-
+    for (auto &registry : template_registries) {
-std::string config::get_local_backup_path() {
+        if (registry.is_object() && !registry.empty())
-    return mConfig["backups"];
+            registries.push_back(tRegistryEntry(registry));
-}
-
-std::string config::get_local_template_cache_path() {
-    return mConfig["template_cache"];
-}
-
-std::vector<std::string> config::get_template_registry_urls() {
-    nlohmann::json template_registry_urls = mConfig["template_registry_URLs"];
-    std::vector<std::string> urls;
-    for (auto &url : template_registry_urls) {
-        urls.push_back(url);
     }
-    return urls;
+    return registries;
 }
 
-std::vector<std::string> config::get_template_local_paths()
+std::vector<std::string> config::get_local_template_paths()
 {
     nlohmann::json template_local_paths = mConfig["template_local_paths"];
     std::vector<std::string> paths;
@@ -147,23 +143,67 @@ std::vector<std::string> config::get_template_local_paths()
 
 std::vector<std::string> config::get_local_server_definition_paths() {
     nlohmann::json server_definition_paths = mConfig["server_definition_paths"];
-
     std::vector<std::string> paths;
     for (auto &path : server_definition_paths) {
         if (path.is_string() && !path.empty())
             paths.push_back(path);
-        else
-            warning << "Invalid server definition path: " << path << std::endl;
     }
     return paths;
 }
 
-std::string config::get_template_upload_registry_url() {
+std::string config::get_server_create_path()
-    return mConfig["template_upload_registry_url"];
+{
+    std::vector<std::string> paths = get_local_server_definition_paths();
+    if (paths.empty())
+        return "";
+    return paths[0];
 }
 
-std::string config::get_template_upload_registry_token() {
+std::string config::get_template_create_path()
-    return mConfig["template_upload_registry_token"];
+{
+    std::vector<std::string> paths = get_local_template_paths();
+    if (paths.empty())
+        return "";
+    return paths[0];
+}
+
+std::string config::get_backups_path()
+{
+    nlohmann::json backups_path = mConfig["backups_path"];
+    if (backups_path.empty())
+        return "";
+    if (backups_path.is_string())
+        return backups_path;
+    warning << "backups_path is not a string: " << backups_path << std::endl;
+    return "";
+}
+
+dropshell::tRegistryEntry::tRegistryEntry(nlohmann::json json)
+{
+    valid = false;
+    if (json.is_object() && !json.empty()) {
+        for (auto &[key, value] : json.items()) {
+            if (value.is_string() && !value.empty())
+                switch (switchhash(key.c_str())) {
+                    case switchhash("name"):
+                        name = value;
+                        break;
+                    case switchhash("url"):
+                        url = value;
+                        break;
+                    case switchhash("token"):
+                        token = value;
+                        break;
+                    default:
+                        break;
+                }
+            }
+        valid = (!url.empty()&&!name.empty()); // token can be empty.
+    }
+}
+
+tRegistryEntry::~tRegistryEntry()
+{
 }
 
 } // namespace dropshell 

source/src/config.hpp

@@ -2,10 +2,25 @@
 
 #include <string>
 #include <vector>
-#include "utils/json.hpp"
+
+#define JSON_INLINE_ALL
+#include <nlohmann/json.hpp>
 
 namespace dropshell {
 
+class tRegistryEntry {
+
+    public:
+        tRegistryEntry(nlohmann::json json);
+        ~tRegistryEntry();
+
+    public:
+        std::string name;
+        std::string url;
+        std::string token;
+        bool valid;
+};
+
 class config {
     public:
         config();
@@ -17,15 +32,13 @@ class config {
         bool is_config_set() const;
         static bool is_agent_installed();
 
-        std::string get_local_tempfiles_path();
+        std::vector<tRegistryEntry> get_template_registry_urls();
-        std::string get_local_backup_path();
+        std::vector<std::string> get_local_template_paths();
-        std::string get_local_template_cache_path();
-        std::vector<std::string> get_template_registry_urls();
-        std::vector<std::string> get_template_local_paths();
         std::vector<std::string> get_local_server_definition_paths();
 
-        std::string get_template_upload_registry_url();
+        std::string get_server_create_path();
-        std::string get_template_upload_registry_token();
+        std::string get_template_create_path(); 
+        std::string get_backups_path();
 
     private:
         nlohmann::json mConfig;

source/src/dropshell-completion.bash

@@ -6,8 +6,8 @@ _dropshell_completions() {
     cur="${COMP_WORDS[COMP_CWORD]}"
     
     # call dropshell to get the list of possiblities for the current argument. Supply all previous arguments.
-    local completions=($(dropshell autocomplete "${COMP_WORDS[@]:1:${COMP_CWORD}-1}"))
+    mapfile -t completions < <(dropshell autocomplete "${COMP_WORDS[@]:1:${COMP_CWORD}-1}")
-    COMPREPLY=( $(compgen -W "${completions[*]}" -- ${cur}) )
+    mapfile -t COMPREPLY < <(compgen -W "${completions[*]}" -- "$cur")
     return 0
 }
 

source/src/main.cpp

@@ -16,7 +16,7 @@
 #include <vector>
 #include <iomanip>
 #include <chrono>
-#include <assert.hpp>
+#include <libassert/assert.hpp>
 #include <sstream>
 #include <algorithm>
 namespace dropshell {
@@ -80,7 +80,7 @@ int main(int argc, char* argv[]) {
 
     }
     catch (const std::exception& e) {
-        std::cerr << "Error: " << e.what() << std::endl;
+        error << "Uncaught Exception: " << e.what() << std::endl;
         return 1;
     }
 }
@@ -140,115 +140,6 @@ auto command_match = [](const std::string& cmd_list, int argc, char* argv[]) ->
     } \
 }
 
-
-// int old_main(int argc, char* argv[]) {
-//     HAPPYEXIT("hash", hash_demo_raw(safearg(argc,argv,2)))
-//     HAPPYEXIT("version", printversion())
-//     BOOLEXIT("test-template", gTemplateManager().test_template(safearg(argc,argv,2)))
-//     ASSERT(safearg(argc,argv,1) != "assert", "Hello! Here is an assert.");
-
-//     try {
-//         // silently attempt to load the config file and templates.
-//         gConfig().load_config();
-//         if (gConfig().is_config_set())
-//             gTemplateManager().load_sources();
-
-//         std::string cmd = argv[1];
-
-
-//         // ------------------------------------------------------------
-//         // from here we require the config file to be loaded.
-//         if (!gConfig().is_config_set()) 
-//             return die("Please run 'dropshell edit' to set up the dropshell configuration.");
-
-
-//         const std::vector<std::string> & server_definition_paths = gConfig().get_local_server_definition_paths();
-//         if (server_definition_paths.size()>1) { // only show if there are multiple.
-//             std::cout << "Server definition paths: ";
-//             for (auto & dir : server_definition_paths) 
-//                 std::cout << "["<< dir << "] ";
-//             std::cout << std::endl;
-//         }
-//         if (gTemplateManager().is_loaded() && gTemplateManager().get_source_count() > 0)
-//             gTemplateManager().print_sources();
-
-//         HAPPYEXIT("templates", gTemplateManager().list_templates());
-
-//         if (cmd == "create-template") {
-//             if (argc < 3) return die("Error: create-template requires a template name");
-//             return (gTemplateManager().create_template(argv[2])) ? 0 : 1;
-//         }
-
-//         if (cmd == "create-server") {
-//             if (argc < 3) return die("Error: create-server requires a server name");
-//             return (create_server(argv[2])) ? 0 : 1;
-//         }
-
-//         if (cmd == "create-service") {
-//             if (argc < 5) return die("Error: not enough arguments.\ndropshell create-service server template service");
-//             return (create_service(argv[2], argv[3], argv[4])) ? 0 : 1;
-//         }
-
-//          if (cmd == "ssh" && argc < 4) {
-//             if (argc < 3) return die("Error: ssh requires a server name and optionally service name");
-//             service_runner::interactive_ssh(argv[2], "bash");
-//             return 0;
-//         }
-
-
-//         // handle running a command. 
-//         std::set<std::string> commands;
-//         get_all_used_commands(commands);
-
-//         autocomplete::merge_commands(commands, autocomplete::service_commands_require_config); // handled by service_runner, but not in template_shell_commands.
-
-//         if (commands.count(cmd)) {
-//             std::set<std::string> safe_commands = {"nuke", "fullnuke"};
-//             if (safe_commands.count(cmd) && argc < 4) 
-//                 return die("Error: "+cmd+" requires a server name and service name. For safety, can't run on all services.");
-
-//             // get all the services to run the command on.
-//             ServerAndServices server_and_services;
-//             if (!getCLIServices(safearg(argc, argv, 2), safearg(argc, argv, 3), server_and_services)) 
-//                 return die("Error: "+cmd+" command requires server name and optionally service name");
-
-//             // run the command on each service.
-//             for (const auto& service_info : server_and_services.servicelist) {
-//                 if (!SIvalid(service_info))
-//                     std::cerr<<"Error: Unable to get service information."<<std::endl;
-//                 else {
-//                     service_runner runner(server_and_services.server_name, service_info.service_name);
-//                     if (!runner.isValid()) 
-//                         return die("Error: Failed to initialize service");
-                    
-//                     std::vector<std::string> additional_args;
-//                     for (int i=4; i<argc; i++)
-//                         additional_args.push_back(argv[i]);
-//                     if (!runner.run_command(cmd, additional_args)) 
-//                         return die(cmd+" failed on service "+service_info.service_name);
-//                 }
-//             }
-
-//             // success!
-//             return 0;
-//         }
-
-//         // Unknown command
-//         std::cerr << "Error: Unknown command '" << cmd << "'" << std::endl;
-//         std::cerr << "Valid commands: ";
-//         for (const auto& command : commands) {
-//             if (!command.empty() && command[0]!='_')
-//                 std::cerr << command << " ";
-//         }
-//         std::cerr << std::endl;
-//         return 1;
-
-//     } catch (const std::exception& e) {
-//         std::cerr << "Error: " << e.what() << std::endl;
-//         return 1;
-//     }
-// } 
-
 } // namespace dropshell
 
 int main(int argc, char* argv[]) {

source/src/server_env_manager.cpp

@@ -1,230 +0,0 @@
-#include "server_env_manager.hpp"
-#include "utils/directories.hpp"
-#include "utils/utils.hpp"
-#include "services.hpp"
-#include "templates.hpp"
-#include "utils/utils.hpp"
-#include "utils/json.hpp"
-#include "utils/execute.hpp"
-
-#include <iostream>
-#include <memory>
-#include <filesystem>
-#include <fstream>
-#include <sys/wait.h>
-#include <unistd.h>
-#include <vector>
-#include <string>
-#include <iostream>
-#include <wordexp.h> // For potential shell-like expansion if needed
-
-
-namespace dropshell {
-
-server_env_manager::server_env_manager(const std::string& server_name) : mValid(false), mServerName(server_name) {
-    if (server_name.empty())
-        return;
-        
-    // Construct the full path to server.env
-    std::string server_env_path = localfile::server_json(server_name);
-    
-    // Check if file exists
-    if (!std::filesystem::exists(server_env_path)) {
-        std::cerr << "Server environment file not found: " + server_env_path << " for server " << server_name << std::endl;
-        return;
-    }
-
-    try {
-        // Use envmanager to handle the environment file
-        nlohmann::json server_env_json = nlohmann::json::parse(std::ifstream(server_env_path));
-        if (server_env_json.empty()) {
-            std::cerr << "Error: Failed to parse server environment file: " + server_env_path << std::endl;
-            return;
-        }
-
-       // get the variables from the json
-       for (const auto& var : server_env_json.items()) {
-            std::string value;
-            if (var.value().is_string())
-                value = var.value();
-            else if (var.value().is_number_integer())
-                value = std::to_string(var.value().get<int>());
-            else if (var.value().is_boolean())
-                value = var.value() ? "true" : "false";
-            else
-                value = var.value().dump();
-
-            mVariables[var.key()] = replace_with_environment_variables_like_bash(value);
-       }
-
-        // Verify required variables exist
-        for (const auto& var : {"SSH_HOST", "SSH_USER", "SSH_PORT", "DROPSHELL_DIR"}) {
-            if (mVariables.find(var) == mVariables.end()) {
-                // Print the variables identified in the file
-                std::cout << "Variables identified in the file:" << std::endl;
-                for (const auto& v : mVariables) {
-                    std::cout << "    " << v.first << std::endl;
-                }
-                throw std::runtime_error("Missing required variable: " + std::string(var));
-            }
-        }
-        mValid = true;
-
-    } catch (const std::exception& e) {
-        std::cerr << "Failed to parse server environment file: " + std::string(e.what()) << std::endl;
-    }    
-}
-
-bool server_env_manager::create_server_env(const std::string &server_env_path, const std::string &SSH_HOST, const std::string &SSH_USER, const std::string &SSH_PORT, const std::string &DROPSHELL_DIR)
-{
-    nlohmann::json server_env_json;
-    server_env_json["SSH_HOST"] = SSH_HOST;
-    server_env_json["SSH_USER"] = SSH_USER;
-    server_env_json["SSH_PORT"] = SSH_PORT;
-    server_env_json["DROPSHELL_DIR"] = DROPSHELL_DIR;
-
-    try {
-        std::ofstream server_env_file(server_env_path);
-        server_env_file << server_env_json.dump(4);
-        server_env_file.close();
-        return true;
-    } catch (const std::exception& e) {
-        std::cerr << "Failed to create server environment file: " + std::string(e.what()) << std::endl;
-        return false;
-    }
-}
-
-std::string server_env_manager::get_variable(const std::string& name) const {
-    auto it = mVariables.find(name);
-    if (it == mVariables.end()) {
-        return "";
-    }
-    return it->second;
-}
-std::optional<sCommand> server_env_manager::construct_standard_template_run_cmd(const std::string &service_name, const std::string &command, const std::vector<std::string> args, const bool silent) const
-{
-    if (command.empty())
-        return std::nullopt;
-
-    std::string remote_service_template_path = remotepath::service_template(mServerName,service_name);
-    std::string script_path = remote_service_template_path + "/" + command + ".sh";
-
-    std::map<std::string, std::string> env_vars;
-    if (!get_all_service_env_vars(mServerName, service_name, env_vars)) {
-        std::cerr << "Error: Failed to get all service env vars for " << service_name << std::endl;
-        return std::nullopt;
-    }
-
-    std::string argstr = "";
-    for (const auto& arg : args) {
-        argstr += " " + quote(dequote(trim(arg)));
-    }
-
-    sCommand sc(
-        remote_service_template_path, 
-        quote(script_path) + argstr + (silent ? " > /dev/null 2>&1" : ""), 
-        env_vars
-    );
-
-    if (sc.empty()) {
-        std::cerr << "Error: Failed to construct command for " << service_name << " " << command << std::endl;
-        return std::nullopt;
-    }
-    return sc;
-}
-
-
-bool server_env_manager::check_remote_dir_exists(const std::string &dir_path) const
-{
-    sCommand scommand("", "test -d " + quote(dir_path),{});
-    return execute_ssh_command(get_SSH_INFO(), scommand, cMode::Silent);
-}
-
-bool server_env_manager::check_remote_file_exists(const std::string& file_path) const {
-    sCommand scommand("", "test -f " + quote(file_path),{});
-    return execute_ssh_command(get_SSH_INFO(), scommand, cMode::Silent);
-}
-
-bool server_env_manager::check_remote_items_exist(const std::vector<std::string> &file_paths) const
-{
-    // convert file_paths to a single string, separated by spaces
-    std::string file_paths_str;
-    std::string file_names_str;
-    for (const auto& file_path : file_paths) {
-        file_paths_str += quote(file_path) + " ";
-        file_names_str += std::filesystem::path(file_path).filename().string() + " ";
-    }
-    // check if all items in the vector exist on the remote server, in a single command.
-    sCommand scommand("", "for item in " + file_paths_str + "; do test -f $item; done",{});
-
-    bool okay = execute_ssh_command(get_SSH_INFO(), scommand, cMode::Silent);
-    if (!okay) {
-        std::cerr << "Error: Required items not found on remote server: " << file_names_str << std::endl;
-        return false;
-    }
-    return true;
-}
-
-bool server_env_manager::remove_remote_dir(const std::string &dir_path, bool silent) const
-{
-    std::filesystem::path path(dir_path);
-    std::filesystem::path parent_path = path.parent_path();
-    std::string target_dir = path.filename().string();
-
-    if (parent_path.empty()) 
-        parent_path="/";
-    
-    if (target_dir.empty())
-        return false;
-
-    if (!silent)
-        std::cout << "Removing remote directory " << target_dir << " in " << parent_path << " on " << mServerName << std::endl;
-    std::string remote_cmd =
-    "docker run --rm -v " + quote(parent_path.string()) + ":/parent " +
-        " alpine rm -rf \"/parent/" + target_dir + "\"";
-
-    // if (!silent)
-    //     std::cout << "Running command: " << remote_cmd << std::endl;
-
-    sCommand scommand("", remote_cmd,{});
-    cMode mode = (silent ? cMode::Silent : cMode::Defaults);
-
-    return execute_ssh_command(get_SSH_INFO(), scommand, mode);
-}
-
-bool server_env_manager::run_remote_template_command(const std::string &service_name, const std::string &command, std::vector<std::string> args, bool silent, std::map<std::string, std::string> extra_env_vars) const
-{
-    auto scommand = construct_standard_template_run_cmd(service_name, command, args, silent);
-    if (!scommand.has_value())
-        return false;
-
-    // add the extra env vars to the command
-    for (const auto& [key, value] : extra_env_vars) 
-        scommand->add_env_var(key, value);
-
-    if (scommand->get_command_to_run().empty())
-        return false;
-    cMode mode = (command=="ssh") ? (cMode::Interactive) : (silent ? cMode::Silent : cMode::Defaults);
-    return execute_ssh_command(get_SSH_INFO(), scommand.value(), mode);
-}
-
-bool server_env_manager::run_remote_template_command_and_capture_output(const std::string &service_name, const std::string &command, std::vector<std::string> args, std::string &output, bool silent, std::map<std::string, std::string> extra_env_vars) const
-{
-    auto scommand = construct_standard_template_run_cmd(service_name, command, args, false);
-    if (!scommand.has_value())
-        return false;
-
-    // add the extra env vars to the command
-    for (const auto& [key, value] : extra_env_vars) 
-        scommand->add_env_var(key, value);
-
-    return execute_ssh_command(get_SSH_INFO(), scommand.value(), cMode::Defaults, &output);
-}
-
-
-
-// base64 <<< "FOO=BAR WHEE=YAY bash ./test.sh"
-// echo YmFzaCAtYyAnRk9PPUJBUiBXSEVFPVlBWSBiYXNoIC4vdGVzdC5zaCcK | base64 -d | bash
-
-
-} // namespace dropshell

source/src/server_env_manager.hpp

@@ -1,77 +0,0 @@
-// server_env.hpp
-//
-// read the server.env file and provide a class to access the variables
-
-#ifndef __SERVER_ENV_HPP
-#define __SERVER_ENV_HPP
-
-#include <string>
-#include <map>
-#include <memory>
-#include <vector>
-#include "utils/execute.hpp"
-#include <optional>
-namespace dropshell {
-
-class server_env_manager;
-
-// ------------------------------------------------------------------------------------------------
-
-// reads path / server.env and provides a class to access the variables.
-// each env file is required to have the following variables:
-// SSH_HOST
-// SSH_USER
-// SSH_PORT
-// the following replacements are made in the values:
-// ${USER} -> the username of the user running dropshell
-class server_env_manager {
-    public:
-        server_env_manager(const std::string& server_name);
-        
-        static bool create_server_env(
-                 const std::string& server_env_path,
-                 const std::string& SSH_HOST,
-                 const std::string& SSH_USER,
-                 const std::string& SSH_PORT,
-                 const std::string& DROPSHELL_DIR);
-
-        std::string get_variable(const std::string& name) const;
-
-        // trivial getters.
-        const std::map<std::string, std::string>& get_variables() const { return mVariables; }
-        std::string get_SSH_HOST() const { return get_variable("SSH_HOST"); }
-        std::string get_SSH_USER() const { return get_variable("SSH_USER"); }
-        std::string get_SSH_PORT() const { return get_variable("SSH_PORT"); }
-        std::string get_DROPSHELL_DIR() const { return get_variable("DROPSHELL_DIR"); }
-        sSSHInfo get_SSH_INFO() const { return sSSHInfo{get_SSH_HOST(), get_SSH_USER(), get_SSH_PORT(), get_server_name()}; }
-        bool is_valid() const { return mValid; }
-        std::string get_server_name() const { return mServerName; }
-
-// helper functions
-    public:
-        bool check_remote_dir_exists(const std::string &dir_path) const;
-        bool check_remote_file_exists(const std::string& file_path) const;
-        bool check_remote_items_exist(const std::vector<std::string>& file_paths) const;
-
-        bool remove_remote_dir(const std::string &dir_path, bool silent) const;
-
-        bool run_remote_template_command(const std::string& service_name, const std::string& command, 
-            std::vector<std::string> args, bool silent, std::map<std::string, std::string> extra_env_vars) const;
-        bool run_remote_template_command_and_capture_output(const std::string& service_name, const std::string& command, 
-            std::vector<std::string> args, std::string & output, bool silent, std::map<std::string, std::string> extra_env_vars) const;
-
-    private:
-        std::optional<sCommand> construct_standard_template_run_cmd(const std::string& service_name, const std::string& command, const std::vector<std::string> args, const bool silent) const;
-
-    private:
-        std::string mServerName;
-        std::map<std::string, std::string> mVariables;
-        bool mValid;
-};
-
-
-
-} // namespace dropshell
-
-
-#endif // __SERVER_ENV_HPP  

source/src/servers.cpp

@@ -1,125 +1,483 @@
-#include "servers.hpp"
-#include "server_env_manager.hpp"
-#include "utils/tableprint.hpp"
-#include "utils/envmanager.hpp"
 #include "utils/directories.hpp"
+#include "utils/utils.hpp"
+#include "servers.hpp"
 #include "services.hpp"
-#include "config.hpp"
 #include "templates.hpp"
-#include "contrib/transwarp.hpp"
+#include "utils/utils.hpp"
+#include "utils/execute.hpp"
+#include "output.hpp"
+#include <libassert/assert.hpp>
+#include "config.hpp"
 
 #include <iostream>
-#include <fstream>
+#include <memory>
-#include <iomanip>
 #include <filesystem>
+#include <fstream>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <vector>
+#include <string>
+#include <iostream>
+#include <wordexp.h> // For potential shell-like expansion if needed
 
-namespace dropshell {
+namespace dropshell
+{
 
-std::vector<ServerInfo> get_configured_servers() {
+    ServerConfig::ServerConfig(const std::string &server_name) : mValid(false), mServerName(server_name)
-    std::vector<ServerInfo> servers;
+    {
+        if (server_name.empty())
+            return;
 
-    std::vector<std::string> lsdp = gConfig().get_local_server_definition_paths();
+        std::string server_json_path = localfile::server_json(server_name);
-    if (lsdp.empty())
-        return servers;
 
-    for (auto servers_dir : lsdp) {
+        // Check if file exists
-        if (!servers_dir.empty() && std::filesystem::exists(servers_dir)) {
+        if (!std::filesystem::exists(server_json_path))
-            for (const auto& entry : std::filesystem::directory_iterator(servers_dir)) {
+        {
-                if (std::filesystem::is_directory(entry)) {
+            std::cerr << "Server environment file not found: " + server_json_path << " for server " << server_name << std::endl;
-                    std::string server_name = entry.path().filename().string();
+            return;
+        }
 
-                    if (server_name.empty() || server_name[0]=='.' || server_name[0]=='_')
+        try
-                        continue;
+        {
+            // Use envmanager to handle the environment file
+            nlohmann::json server_env_json = nlohmann::json::parse(std::ifstream(server_json_path));
+            if (server_env_json.empty())
+            {
+                error << "Failed to parse server environment file at "<< server_json_path << std::endl;
+                info << "The returned json was empty." << std::endl;
+                return;
+            }
 
-                    server_env_manager env(server_name);
+            // get the variables from the json, converting everything to strings.
-                    if (!env.is_valid()) {
+            for (const auto &var : server_env_json.items())
-                        std::cerr << "Error: Invalid server environment file: " << entry.path().string() << std::endl;
+            {
-                        continue;
+                std::string value;
+                if (var.value().is_string())
+                    value = var.value();
+                else if (var.value().is_number_integer())
+                    value = std::to_string(var.value().get<int>());
+                else if (var.value().is_boolean())
+                    value = var.value() ? "true" : "false";
+                else
+                    value = var.value().dump();
+                mVariables[var.key()] = replace_with_environment_variables_like_bash(value);
+            }
+
+            // Verify required variables exist
+            for (const auto &var : {"SSH_HOST", "SSH_PORT", "SSH_USERS"})
+            {
+                if (mVariables.find(var) == mVariables.end())
+                {
+                    // Print the variables identified in the file
+                    info << "Variables identified in the file:" << std::endl;
+                    for (const auto &v : mVariables)
+                    {
+                        info << "    " << v.first << std::endl;
+                    }
+                    throw std::runtime_error("Missing required variable: " + std::string(var));
+                }
+            }
+
+            // Parse users array
+            if (!server_env_json.contains("SSH_USERS") || !server_env_json["SSH_USERS"].is_array())
+            {
+                error << "SSH_USERS array not found or invalid in server configuration" << std::endl;
+                return;
+            }
+
+            for (const auto &user_json : server_env_json["SSH_USERS"])
+            {
+                UserConfig user;
+                user.user = user_json["USER"].get<std::string>();
+                user.dir = user_json["DIR"].get<std::string>();
+                mUsers.push_back(user);
+            }
+
+            if (mUsers.empty())
+            {
+                error << "No users defined in server configuration " << server_json_path << std::endl;
+                return;
+            }
+
+            mValid = true;
+        }
+        catch (const std::exception &e)
+        {
+            error << "Failed to parse " << server_json_path << std::endl;
+            error << "Exception: " << e.what() << std::endl;
+
+            mValid = false;
+        }
+    }
+
+    std::string ServerConfig::get_SSH_HOST() const
+    {
+        return get_variable("SSH_HOST");
+    }
+
+    std::string ServerConfig::get_SSH_PORT() const
+    {
+        return get_variable("SSH_PORT");
+    }
+
+    std::vector<UserConfig> ServerConfig::get_users() const
+    {
+        return mUsers;
+    }
+
+    std::string ServerConfig::get_user_dir(const std::string &user) const
+    {
+        for (const auto &u : mUsers)
+        {
+            if (u.user == user)
+            {
+                return u.dir;
+            }
+        }
+        return "";
+    }
+
+    std::string ServerConfig::get_server_name() const
+    {
+        return mServerName;
+    }
+
+    std::string ServerConfig::get_user_for_service(const std::string &service) const
+    {
+        return dropshell::get_user_for_service(mServerName, service);
+    }
+
+    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 "";
+    }
+
+    sSSHInfo ServerConfig::get_SSH_INFO(std::string user) const
+    {
+        ASSERT(!user.empty(), "User is empty, cannot get SSH info.");
+        // Find user in mUsers vector
+        auto it = std::find_if(mUsers.begin(), mUsers.end(),
+                               [&user](const UserConfig &u)
+                               { return u.user == user; });
+        ASSERT(it != mUsers.end(), ("User " + user + " not found in server environment."));
+        return sSSHInfo(get_SSH_HOST(), it->user, get_SSH_PORT(), get_server_name(), it->dir);
+    }
+
+    bool ServerConfig::hasRootUser() const
+    {
+        auto it = std::find_if(mUsers.begin(), mUsers.end(),[](const UserConfig &u)
+                               { return u.user == "root"; });
+        return it != mUsers.end();
+    }
+
+    bool ServerConfig::hasDocker() const
+    {
+        return get_variable("HAS_DOCKER") == "true";
+    }
+
+    bool ServerConfig::hasRootDocker() const
+    {
+        return get_variable("DOCKER_ROOTLESS") == "false";
+    }
+
+    bool ServerConfig::hasUser(const std::string &user) const
+    {
+        auto it = std::find_if(mUsers.begin(), mUsers.end(),
+                               [&user](const UserConfig &u)
+                               { return u.user == user; });
+        return it != mUsers.end();
+    }
+
+    bool ServerConfig::check_remote_dir_exists(const std::string &dir_path, std::string user) const
+    {
+        if (user.empty())
+        {
+            debug << "Can't check remote directory exists for " << dir_path << " as user is empty" << std::endl;
+            return false;
+        }
+
+        sCommand scommand("", "test -d " + quote(dir_path), {});
+        return execute_ssh_command(get_SSH_INFO(user), scommand, cMode::Silent);
+    }
+
+    bool ServerConfig::check_remote_file_exists(const std::string &file_path, std::string user) const
+    {
+        if (user.empty())
+        {
+            debug << "Can't check remote file exists for " << file_path << " as user is empty" << std::endl;
+            return false;
+        }
+
+        sCommand scommand("", "test -f " + quote(file_path), {});
+        return execute_ssh_command(get_SSH_INFO(user), scommand, cMode::Silent);
+    }
+
+    bool ServerConfig::check_remote_items_exist(const std::vector<std::string> &file_paths, std::string user) const
+    {
+        if (user.empty())
+        {
+            debug << "Can't check remote items exist as user is empty" << std::endl;
+            return false;
+        }
+
+        // convert file_paths to a single string, separated by spaces
+        std::string file_paths_str;
+        std::string file_names_str;
+        for (const auto &file_path : file_paths)
+        {
+            file_paths_str += quote(file_path) + " ";
+            file_names_str += std::filesystem::path(file_path).filename().string() + " ";
+        }
+        // check if all items in the vector exist on the remote server, in a single command.
+        sCommand scommand("", "for item in " + file_paths_str + "; do test -f $item; done", {});
+
+        sSSHInfo sshinfo = get_SSH_INFO(user);
+        bool okay = execute_ssh_command(sshinfo, scommand, cMode::Silent);
+        if (!okay)
+        {
+            error << "Required items not found on remote server: " << file_names_str << std::endl;
+            return false;
+        }
+        return true;
+    }
+
+    bool ServerConfig::remove_remote_dir(
+        const std::string &dir_path, bool silent, std::string user) const
+    {
+        std::filesystem::path path(dir_path);
+        std::filesystem::path parent_path = path.parent_path();
+        std::string target_dir = path.filename().string();
+
+        if (parent_path.empty())
+            parent_path = "/";
+
+        if (target_dir.empty())
+            return false;
+
+        if (!silent)
+            std::cout << "Removing remote directory " << target_dir << " in " << parent_path << " on " << mServerName << std::endl;
+        std::string remote_cmd =
+            "docker run --rm -v " + quote(parent_path.string()) + ":/parent " +
+            " alpine rm -rf \"/parent/" + target_dir + "\"";
+
+        // if (!silent)
+        //     std::cout << "Running command: " << remote_cmd << std::endl;
+
+        sCommand scommand("", remote_cmd, {});
+        cMode mode = (silent ? cMode::Silent : cMode::Defaults);
+
+        sSSHInfo sshinfo = get_SSH_INFO(user);
+        return execute_ssh_command(sshinfo, scommand, mode);
+    }
+
+    bool ServerConfig::run_remote_template_command(
+        const std::string &service_name,
+        const std::string &command,
+        std::vector<std::string> args,
+        bool silent,
+        std::map<std::string, std::string> extra_env_vars) const
+    {
+        std::string user = get_user_for_service(service_name);
+        auto scommand = construct_standard_template_run_cmd(service_name, command, args, silent);
+        if (!scommand.has_value())
+            return false;
+
+        // add the extra env vars to the command
+        for (const auto &[key, value] : extra_env_vars)
+            scommand->add_env_var(key, value);
+
+        if (scommand->get_command_to_run().empty())
+            return false;
+        cMode mode = (command == "ssh") ? (cMode::Interactive) : (silent ? cMode::Silent : cMode::Defaults);
+        return execute_ssh_command(get_SSH_INFO(user), scommand.value(), mode);
+    }
+
+    bool ServerConfig::run_remote_template_command_and_capture_output(
+        const std::string &service_name,
+        const std::string &command,
+        std::vector<std::string> args,
+        std::string &output,
+        bool silent,
+        std::map<std::string, std::string> extra_env_vars) const
+    {
+        std::string user = get_user_for_service(service_name);
+        auto scommand = construct_standard_template_run_cmd(service_name, command, args, false);
+        if (!scommand.has_value())
+            return false;
+
+        // add the extra env vars to the command
+        for (const auto &[key, value] : extra_env_vars)
+            scommand->add_env_var(key, value);
+
+        return execute_ssh_command(get_SSH_INFO(user), scommand.value(), cMode::Defaults, &output);
+    }
+
+    std::string ServerConfig::get_variable(const std::string &name) const
+    {
+        auto it = mVariables.find(name);
+        if (it == mVariables.end())
+        {
+            return "";
+        }
+        return it->second;
+    }
+
+    std::optional<sCommand> ServerConfig::construct_standard_template_run_cmd(const std::string &service_name, const std::string &command, const std::vector<std::string> args, const bool silent) const
+    {
+        if (command.empty())
+            return std::nullopt;
+
+        std::string user = get_user_for_service(service_name);
+
+        std::string remote_service_template_path = remotepath(mServerName, user).service_template(service_name);
+        std::string script_path = remote_service_template_path + "/" + command + ".sh";
+
+        std::map<std::string, std::string> env_vars;
+        if (!get_all_service_env_vars(mServerName, service_name, env_vars))
+        {
+            error << "Failed to get all service env vars for " << service_name << std::endl;
+            return std::nullopt;
+        }
+
+        env_vars["HOST_NAME"] = get_SSH_HOST();
+
+        std::string argstr = "";
+        for (const auto &arg : args)
+        {
+            argstr += " " + quote(dequote(trim(arg)));
+        }
+
+        sCommand sc(
+            remote_service_template_path,
+            quote(script_path) + argstr + (silent ? " > /dev/null 2>&1" : ""),
+            env_vars);
+
+        if (sc.empty())
+        {
+            error << "Failed to construct command for " << service_name << " " << command << std::endl;
+            return std::nullopt;
+        }
+        return sc;
+    }
+
+    std::vector<ServerConfig> get_configured_servers()
+    {
+        std::vector<ServerConfig> servers;
+
+        std::vector<std::string> lsdp = gConfig().get_local_server_definition_paths();
+        if (lsdp.empty())
+            return servers;
+
+        for (auto servers_dir : lsdp)
+        {
+            if (!servers_dir.empty() && std::filesystem::exists(servers_dir))
+            {
+                for (const auto &entry : std::filesystem::directory_iterator(servers_dir))
+                {
+                    if (std::filesystem::is_directory(entry))
+                    {
+                        std::string server_name = entry.path().filename().string();
+
+                        if (server_name.empty() || server_name[0] == '.' || server_name[0] == '_')
+                            continue;
+
+                        ServerConfig env(server_name);
+                        if (!env.is_valid())
+                        {
+                            error << "Invalid server environment file: " << entry.path().string() << std::endl;
+                            continue;
+                        }
+                        servers.push_back(env);
                     }
-                    servers.push_back({
-                        server_name,
-                        env.get_SSH_HOST(),
-                        env.get_SSH_USER(),
-                        env.get_SSH_PORT()
-                    });
                 }
             }
         }
+
+        return servers;
     }
 
-    return servers;
+    bool create_server(const std::string &server_name)
-}
+    {
+        // 1. check if server name already exists
+        std::string server_existing_dir = localpath::server(server_name);
+        if (!server_existing_dir.empty())
+        {
+            error << "Server name already exists: " << server_name << std::endl;
+            info << "Current server path: " << server_existing_dir << std::endl;
+            return false;
+        }
 
-ServerInfo get_server_info(const std::string &server_name)
+        // 2. create a new directory in the user config directory
-{
+        auto lsdp = gConfig().get_local_server_definition_paths();
-    std::vector<std::string> lsdp = gConfig().get_local_server_definition_paths();
+        if (lsdp.empty() || lsdp[0].empty())
-    if (lsdp.empty())
+        {
-        return ServerInfo();
+            error << "Local server definition path not found" << std::endl;
+            info << "Run 'dropshell edit' to configure DropShell" << std::endl;
+            return false;
+        }
+        std::string server_dir = lsdp[0] + "/" + server_name;
+        std::filesystem::create_directory(server_dir);
 
-    for (auto &config_dir : lsdp) {
+        // 3. create a template server.env file in the server directory
-        std::string server_dir = config_dir + "/" + server_name;
+        std::string user = getenv("USER");
-        if (std::filesystem::exists(server_dir)) {
+        std::string server_env_path = server_dir + "/" + filenames::server_json;
-            server_env_manager env(server_name);
+        std::ofstream server_env_file(server_env_path);
-            if (!env.is_valid()) {
+        server_env_file << "{" << std::endl;
-                std::cerr << "Error: Invalid server environment file: " << server_dir << std::endl;
+        server_env_file << "    \"SSH_HOST\": \"" << server_name << "\"," << std::endl;
-                continue;
+        server_env_file << "    \"SSH_PORT\": " << 22 << "," << std::endl;
-            }
+        server_env_file << "    \"SSH_USERS\": [" << std::endl;
-            return ServerInfo({server_name, env.get_SSH_HOST(), env.get_SSH_USER(), env.get_SSH_PORT()});
+        server_env_file << "        {" << std::endl;
+        server_env_file << "            \"USER\": \"" << user << "\"," << std::endl;
+        server_env_file << "            \"DIR\": \"" << "/home/" + user << "/.dropshell\"" << std::endl;
+        server_env_file << "        }" << std::endl;
+        server_env_file << "    ]," << std::endl;
+        server_env_file << "    \"HAS_DOCKER\": \"true\"," << std::endl;
+        server_env_file << "    \"DOCKER_ROOTLESS\": \"false\"" << std::endl;
+        server_env_file << "}" << std::endl;
+        server_env_file.close();
+
+        std::cout << "Server created successfully: " << server_name << std::endl;
+        std::cout << "Please complete the installation:" << std::endl;
+        std::cout << "1) edit the server configuration: dropshell edit " << server_name << std::endl;
+        std::cout << "2) install the server:            dropshell install " << server_name << std::endl;
+        std::cout << std::endl;
+        return true;
+    }
+
+    void get_all_used_commands(std::set<std::string> &commands)
+    {
+        std::vector<ServerConfig> servers = get_configured_servers();
+        for (const auto &server : servers)
+        {
+            auto services = get_server_services_info(server.get_server_name());
+            for (const auto &service : services)
+                commands.merge(get_used_commands(server.get_server_name(), service.service_name));
         }
     }
-    return ServerInfo();
-}
 
-
+    bool server_exists(const std::string &server_name)
-bool create_server(const std::string &server_name)
-{
-    // 1. check if server name already exists
-    std::string server_existing_dir = localpath::server(server_name);
-    if (!server_existing_dir.empty()) {
-        std::cerr << "Error: Server name already exists: " << server_name << std::endl;
-        std::cerr << "Current server path: " << server_existing_dir << std::endl;
-        return false;
-    }
-
-    // 2. create a new directory in the user config directory
-    auto lsdp = gConfig().get_local_server_definition_paths();
-    if (lsdp.empty() || lsdp[0].empty()) {
-        std::cerr << "Error: Local server definition path not found" << std::endl;
-        std::cerr << "Run 'dropshell edit' to configure DropShell" << std::endl;
-        return false;
-    }
-    std::string server_dir = lsdp[0] + "/" + server_name;
-    std::filesystem::create_directory(server_dir);
-
-    // 3. create a template server.env file in the server directory
-    std::string user = getenv("USER");
-    std::string server_env_path = server_dir + "/server.env";
-    std::ofstream server_env_file(server_env_path);
-    server_env_file << "SSH_HOST=" << server_name << std::endl;
-    server_env_file << "SSH_USER=" << user << std::endl;
-    server_env_file << "SSH_PORT=" << 22 << std::endl;
-    server_env_file << std::endl;
-    server_env_file << "DROPSHELL_DIR=/home/"+user+"/.dropshell" << std::endl;
-    server_env_file.close();
-
-    std::cout << "Server created successfully: " << server_name << std::endl;
-    std::cout << "Please complete the installation:" <<std::endl;
-    std::cout << "1) edit the server configuration: dropshell edit " << server_name << std::endl;
-    std::cout << "2) test ssh is working:           dropshell ssh " << server_name << std::endl;
-    std::cout << "3) install the server:            dropshell install " << server_name << std::endl;
-    std::cout << std::endl;
-    return true;
-}
-
-void get_all_used_commands(std::set<std::string> &commands)
-{
-    std::vector<ServerInfo> servers = get_configured_servers();
-    for (const auto& server : servers) 
     {
-        auto services = dropshell::get_server_services_info(server.name);
+        std::string server_existing_dir = localpath::server(server_name);
-        for (const auto& service : services) 
+        if (server_existing_dir.empty())
-            commands.merge(dropshell::get_used_commands(server.name, service.service_name));
+            return false;
+
+        if (std::filesystem::exists(server_existing_dir));
+            return true;
+        return false;
     }
-}
 
 } // namespace dropshell

source/src/servers.hpp

@@ -1,28 +1,104 @@
-#ifndef SERVERS_HPP
+// server_env.hpp
-#define SERVERS_HPP
+//
+// read the server.env file and provide a class to access the variables
+
+#ifndef __SERVER_ENV_HPP
+#define __SERVER_ENV_HPP
 
 #include <string>
-#include <set>
+#include <map>
+#include <memory>
 #include <vector>
+#include <set>
+#include <optional>
 
-namespace dropshell {
+#include "utils/execute.hpp"
 
-    // Server information structure
+namespace dropshell
-    struct ServerInfo {
+{
-        std::string name;
+
-        std::string ssh_host;
+    struct UserConfig
-        std::string ssh_user;
+    {
-        std::string ssh_port;
+        std::string user;
+        std::string dir;
     };
 
-    std::vector<ServerInfo> get_configured_servers();
+    // ------------------------------------------------------------------------------------------------
 
-    ServerInfo get_server_info(const std::string& server_name);
+    // reads path / server.env and provides a class to access the variables.
+    // each env file is required to have the following variables:
+    // SSH_HOST
+    // SSH_UNPRIVILEGED_USER
+    // SSH_PORT
+    // the following replacements are made in the values:
+    // ${USER} -> the username of the user running dropshell
+    class ServerConfig
+    {
+    public:
+        ServerConfig(const std::string &server_name);
 
-    bool create_server(const std::string& server_name);
+        bool is_valid() const { return mValid; }
+
+
+        // trivial getters.
+        const std::map<std::string, std::string> &get_variables() const { return mVariables; }
+        std::string get_variable(const std::string &name) const;
+
+        // ------------------------------------------------------------------------------------------------
+        // getters
+        // ------------------------------------------------------------------------------------------------
+        std::string get_SSH_HOST() const;
+        std::string get_SSH_PORT() const;
+        std::vector<UserConfig> get_users() const;
+        std::string get_user_dir(const std::string &user) const;
+        std::string get_server_name() const;
+        std::string get_user_for_service(const std::string &service) const;
+
+        sSSHInfo get_SSH_INFO(std::string user) const;
+
+        // server capabilities
+        bool hasRootUser() const;
+        bool hasDocker() const;
+        bool hasRootDocker() const;
+
+        // helper functions
+        bool hasUser(const std::string &user) const;
+
+    public:
+        bool check_remote_dir_exists(const std::string &dir_path, std::string user) const;
+        bool check_remote_file_exists(const std::string &file_path, std::string user) const;
+        bool check_remote_items_exist(const std::vector<std::string> &file_paths, std::string user) const;
+
+        bool remove_remote_dir(const std::string &dir_path, bool silent, std::string user) const;
+
+        bool run_remote_template_command(const std::string &service_name, const std::string &command,
+                                         std::vector<std::string> args, bool silent, std::map<std::string, std::string> extra_env_vars) const;
+
+        bool run_remote_template_command_and_capture_output(const std::string &service_name, const std::string &command,
+                                                            std::vector<std::string> args, std::string &output, bool silent, std::map<std::string, std::string> extra_env_vars) const;
+
+    private:
+        std::optional<sCommand> construct_standard_template_run_cmd(const std::string &service_name, const std::string &command, const std::vector<std::string> args, const bool silent) const;
+
+    private:
+        std::string mServerName;
+        std::map<std::string, std::string> mVariables;
+        std::vector<UserConfig> mUsers;
+        bool mValid;
+    }; // class ServerConfig
+
+
+
+    std::vector<ServerConfig> get_configured_servers();
+
+    std::string get_user_for_service(const std::string &server, const std::string &service);
+
+    bool create_server(const std::string &server_name);
 
     void get_all_used_commands(std::set<std::string> &commands);
 
+    bool server_exists(const std::string &server_name);
+
 } // namespace dropshell
 
-#endif // SERVERS_HPP
+#endif // __SERVER_ENV_HPP

source/src/service_runner.cpp

@@ -1,529 +1,117 @@
 
-#include <iostream>
+// #include <iostream>
-#include <fstream>
+// #include <fstream>
-#include <sstream>
+// #include <sstream>
-#include <cstdlib>
+// #include <cstdlib>
-#include <chrono>
+// #include <chrono>
-#include <iomanip>
+// #include <iomanip>
-#include <filesystem>
+// #include <filesystem>
-#include <unistd.h>
+// #include <unistd.h>
-#include "utils/assert.hpp"
+// #include <libassert/assert.hpp>
-
+
-#include "config.hpp"
+// #include "config.hpp"
-#include "server_env_manager.hpp"
+// #include "servers.hpp"
-#include "templates.hpp"
+// #include "templates.hpp"
-#include "services.hpp"
+// #include "services.hpp"
-#include "utils/directories.hpp"
+// #include "utils/directories.hpp"
-#include "utils/utils.hpp"
+// #include "utils/utils.hpp"
-#include "command_registry.hpp"
+// #include "command_registry.hpp"
-#include "shared_commands.hpp"
+// #include "shared_commands.hpp"
-
+
-
+
-
+// namespace fs = std::filesystem;
-
+
-namespace dropshell {
+// namespace dropshell {
-
+
-
+
-
+// service_runner::service_runner(const std::string& server_name, const std::string& service_name) : 
-class service_runner {
+//     mServerEnv(server_name), mServer(server_name), mService(service_name), mValid(false)
-    public:
+// {
-        service_runner(const std::string& server_name, const std::string& service_name);
+//     if (server_name.empty() || service_name.empty())
-        bool isValid() const { return mValid; }
+//         return; 
-
+
-        // run a command over ssh, using the credentials from server.env (via server_env.hpp)
+//     // Initialize server environment
-        // first check that the command corresponds to a valid .sh file in the service directory
+//     if (!mServerEnv.is_valid()) 
-        // then run the command, passing the {service_name}.env file as an argument
+//         return;
-        // do a lot of checks, such as:
+
-        // checking that we can ssh to the server.
+//     mServiceInfo = get_service_info(server_name, service_name);
-        // checking whether the service directory exists on the server.
+//     if (mServiceInfo.service_name.empty())
-        // checking that the command exists in the service directory.
+//         return;
-        // checking that the command is a valid .sh file.
+
-        // checking that the {service_name}.env file exists in the service directory.
+//     mService = mServiceInfo.service_name;
-        bool run_command(const std::string& command, std::vector<std::string> additional_args={}, std::map<std::string, std::string> env_vars={});
+    
-
+//     mValid = !mServiceInfo.local_template_path.empty();
-        // check health of service. Silent.
+// }
-        // 1. run status.sh on the server
+
-        // 2. return the output of the status.sh script
+
-
+
-        //HealthStatus is_healthy();
+
-
+// // ------------------------------------------------------------------------------------------------
-        // std::string healthtick();
+// // Run a command on the service.
-        // std::string healthmark();
+// // ------------------------------------------------------------------------------------------------
-
+// bool service_runner::run_command(const std::string& command, std::vector<std::string> additional_args, std::map<std::string, std::string> env_vars) {
-    public:            
+//     if (!mServerEnv.is_valid()) {
-        // backup and restore
+//         std::cerr << "Error: Server service not initialized" << std::endl;
-        bool backup(bool silent=false);
+//         return false;
-        bool restore(std::string backup_file, bool silent=false);
+//     }
-
+//     template_info tinfo = gTemplateManager().get_template_info(mServiceInfo.template_name);
-        // nuke the service
+//     if (!tinfo.is_set()) {
-        bool nuke(bool silent=false); // nukes all data for this service on the remote server
+//         std::cerr << "Error: Template '" << mServiceInfo.template_name << "' not found" << std::endl;
-        bool fullnuke(); // nuke all data for this service on the remote server, and then nukes all the local service definitionfiles
+//         return false;
-
+//     }
-        // launch an interactive ssh session on a server or service
+
-        // replaces the current dropshell process with the ssh process
+//     if (!gTemplateManager().template_command_exists(mServiceInfo.template_name, command)) {
-        bool interactive_ssh_service();
+//         std::cout << "No command script for " << mServiceInfo.template_name << " : " << command << std::endl;
-
+//         return true; // nothing to run.
-        bool scp_file_to_remote(const std::string& local_path, const std::string& remote_path, bool silent=false);
+//     }
-        bool scp_file_from_remote(const std::string& remote_path, const std::string& local_path, bool silent=false);
+
-    public:
+//     // install doesn't require anything on the server yet.
-        // utility functions
+//     // if (command == "install") 
-        static std::string get_latest_backup_file(const std::string& server, const std::string& service);
+//     //     return install_service(mServer, mService, false);
-        static bool interactive_ssh(const std::string & server_name, const std::string & command);
+
-        // static std::map<std::string, ServiceStatus> get_all_services_status(std::string server_name);
+//     std::string script_path = remotepath::service_template(mServer, mService) + "/" + command + ".sh";
-
+    
-    private:
+//     // Check if service directory exists
-        std::string mServer;
+//     if (!mServerEnv.check_remote_dir_exists(remotepath::service(mServer, mService))) {
-        server_env_manager mServerEnv;
+//         std::cerr << "Error: Service is not installed: " << mService << std::endl;
-        LocalServiceInfo mServiceInfo;
+//         return false;
-        std::string mService;
+//     }
-        bool mValid;
+    
-
+//     // Check if command script exists
-        // Helper methods
+//     if (!mServerEnv.check_remote_file_exists(script_path)) {
-    public:
+//         std::cerr << "Error: Remote command script not found: " << script_path << std::endl;
-};
+//         return false;
-
+//     }
-
+
-} // namespace dropshell
+//     // Check if env file exists
-
+//     if (!mServerEnv.check_remote_file_exists(remotefile::service_env(mServer, mService))) {
-
+//         std::cerr << "Error: Service config file not found: " << remotefile::service_env(mServer, mService) << std::endl;
-
+//         return false;
-namespace fs = std::filesystem;
+//     }
-
+
-namespace dropshell {
+//     // if (command == "uninstall") 
-
+//     //     return uninstall();
-
+
-service_runner::service_runner(const std::string& server_name, const std::string& service_name) : 
+//     if (command == "ssh") {
-    mServerEnv(server_name), mServer(server_name), mService(service_name), mValid(false)
+//         interactive_ssh_service();
-{
+//         return true;
-    if (server_name.empty() || service_name.empty())
+//     }
-        return; 
+//     if (command == "restore") {
-
+//         if (additional_args.size() < 1) {
-    // Initialize server environment
+//             std::cerr << "Error: restore requires a backup file:" << std::endl;
-    if (!mServerEnv.is_valid()) 
+//             std::cerr << "dropshell restore <server> <service> <backup-file>" << std::endl;
-        return;
+//             return false;
-
+//         }
-    mServiceInfo = get_service_info(server_name, service_name);
+//         return restore(additional_args[0], false);
-    if (mServiceInfo.service_name.empty())
+//     }
-        return;
+//     if (command == "backup") {
-
+//         return backup(false);
-    mService = mServiceInfo.service_name;
+//     }
-    
+
-    mValid = !mServiceInfo.local_template_path.empty();
+//     // Run the generic command
-}
+//     std::vector<std::string> args; // not passed through yet.
-
+//     return mServerEnv.run_remote_template_command(mService, command, args, false, env_vars);
-
+// }
-
+
-bool service_runner::nuke(bool silent)
+
-{
+// } // namespace dropshell
-    maketitle("Nuking " + mService + " (" + mServiceInfo.template_name + ") on " + mServer);
-
-    if (!mServerEnv.is_valid()) return false; // should never hit this.
-
-    std::string remote_service_path = remotepath::service(mServer, mService);
-
-    info << "Service " << mService << " successfully nuked from " << mServer << std::endl;
-
-    if (!silent) {
-        info << "There's nothing left on the remote server." << std::endl;
-        info << "You can remove the local files with:" << std::endl;
-        info << "   rm -rf " << localpath::service(mServer,mService) << std::endl;
-    }
-    return true;
-}
-
-bool service_runner::fullnuke()
-{
-    if (!nuke(true))
-    {
-        warning << "Nuke script failed, aborting." << std::endl;
-        return false;
-    }
-
-    std::string local_service_path = mServiceInfo.local_service_path;
-    if (local_service_path.empty() || !fs::exists(local_service_path)) {
-        error << "Service directory not found: " << local_service_path << std::endl;
-        return false;
-    }  
-    
-    std::string rm_cmd = "rm -rf " + quote(local_service_path);
-    if (!execute_local_command("", rm_cmd, {}, nullptr, cMode::Silent)) {
-        error << "Failed to remove service directory" << std::endl;
-        return false;
-    }
-    
-    return true;
-}
-
-
-// ------------------------------------------------------------------------------------------------
-// Run a command on the service.
-// ------------------------------------------------------------------------------------------------
-bool service_runner::run_command(const std::string& command, std::vector<std::string> additional_args, std::map<std::string, std::string> env_vars) {
-    if (!mServerEnv.is_valid()) {
-        std::cerr << "Error: Server service not initialized" << std::endl;
-        return false;
-    }
-    template_info tinfo = gTemplateManager().get_template_info(mServiceInfo.template_name);
-    if (!tinfo.is_set()) {
-        std::cerr << "Error: Template '" << mServiceInfo.template_name << "' not found" << std::endl;
-        return false;
-    }
-
-    if (command == "fullnuke") 
-        return fullnuke();
-
-    if (command == "nuke") 
-    {
-        std::cout << "Nuking " << mService << " (" << mServiceInfo.template_name << ") on " << mServer << std::endl;
-        return nuke();
-    }
-
-    if (!gTemplateManager().template_command_exists(mServiceInfo.template_name, command)) {
-        std::cout << "No command script for " << mServiceInfo.template_name << " : " << command << std::endl;
-        return true; // nothing to run.
-    }
-
-    // install doesn't require anything on the server yet.
-    // if (command == "install") 
-    //     return install_service(mServer, mService, false);
-
-    std::string script_path = remotepath::service_template(mServer, mService) + "/" + command + ".sh";
-    
-    // Check if service directory exists
-    if (!mServerEnv.check_remote_dir_exists(remotepath::service(mServer, mService))) {
-        std::cerr << "Error: Service is not installed: " << mService << std::endl;
-        return false;
-    }
-    
-    // Check if command script exists
-    if (!mServerEnv.check_remote_file_exists(script_path)) {
-        std::cerr << "Error: Remote command script not found: " << script_path << std::endl;
-        return false;
-    }
-
-    // Check if env file exists
-    if (!mServerEnv.check_remote_file_exists(remotefile::service_env(mServer, mService))) {
-        std::cerr << "Error: Service config file not found: " << remotefile::service_env(mServer, mService) << std::endl;
-        return false;
-    }
-
-    // if (command == "uninstall") 
-    //     return uninstall();
-
-    if (command == "ssh") {
-        interactive_ssh_service();
-        return true;
-    }
-    if (command == "restore") {
-        if (additional_args.size() < 1) {
-            std::cerr << "Error: restore requires a backup file:" << std::endl;
-            std::cerr << "dropshell restore <server> <service> <backup-file>" << std::endl;
-            return false;
-        }
-        return restore(additional_args[0], false);
-    }
-    if (command == "backup") {
-        return backup(false);
-    }
-
-    // Run the generic command
-    std::vector<std::string> args; // not passed through yet.
-    return mServerEnv.run_remote_template_command(mService, command, args, false, env_vars);
-}
-
-
-
-bool service_runner::interactive_ssh(const std::string & server_name, const std::string & command) {
-    std::string serverpath = localpath::server(server_name);
-    if (serverpath.empty()) {
-        std::cerr << "Error: Server not found: " << server_name << std::endl;
-        return false;
-    }
-    
-    server_env_manager env(server_name);
-    if (!env.is_valid()) {
-        std::cerr << "Error: Invalid server environment file: " << server_name << std::endl;
-        return false;
-    }
-    sCommand scommand("", "bash",{});
-    return execute_ssh_command(env.get_SSH_INFO(), scommand, cMode::Interactive);
-}
-
-
-
-bool service_runner::interactive_ssh_service()
-{
-    std::set<std::string> used_commands = get_used_commands(mServer, mService);
-    if (used_commands.find("ssh") == used_commands.end()) {
-        std::cerr << "Error: "<< mService <<" does not support ssh" << std::endl;
-        return false;
-    }
-
-    std::vector<std::string> args; // not passed through yet.
-    return mServerEnv.run_remote_template_command(mService, "ssh", args, false, {});
-}
-
-bool service_runner::scp_file_to_remote(const std::string &local_path, const std::string &remote_path, bool silent)
-{
-    std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " + quote(local_path) + " " + mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + quote(remote_path) + (silent ? " > /dev/null 2>&1" : "");
-    return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
-}
-
-bool service_runner::scp_file_from_remote(const std::string &remote_path, const std::string &local_path, bool silent)
-{
-    std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " + mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + quote(remote_path) + " " + quote(local_path) + (silent ? " > /dev/null 2>&1" : "");
-    return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
-}
-
-bool service_runner::restore(std::string backup_file, bool silent)
-{
-    if (backup_file.empty()) {
-        std::cerr << "Error: not enough arguments.  dropshell restore <server> <service> <backup-file>" << std::endl;
-        return false;
-    }
-
-    std::string local_backups_dir = gConfig().get_local_backup_path();
-
-    if (backup_file == "latest") {
-        // get the latest backup file from the server
-        backup_file = get_latest_backup_file(mServer, mService);
-    }
-
-    std::string local_backup_file_path = (std::filesystem::path(local_backups_dir) / backup_file).string();
-
-    if (! std::filesystem::exists(local_backup_file_path)) {
-        std::cerr << "Error: Backup file not found at " << local_backup_file_path << std::endl;
-        return false;
-    }
-
-    // split the backup filename into parts based on the magic string
-    std::vector<std::string> parts = dropshell::split(backup_file, "-_-");
-    if (parts.size() != 4) {
-        std::cerr << "Error: Backup file format is incompatible, - in one of the names?" << std::endl;
-        return false;
-    }
-
-    std::string backup_server_name = parts[0];
-    std::string backup_template_name = parts[1];
-    std::string backup_service_name = parts[2];
-    std::string backup_datetime = parts[3];
-
-    if (backup_template_name != mServiceInfo.template_name) {
-        std::cerr << "Error: Backup template does not match service template. Can't restore." << std::endl;
-        return false;
-    }
-
-    std::string nicedate = std::string(backup_datetime).substr(0, 10);
-
-    std::cout << "Restoring " << nicedate << " backup of " << backup_template_name << " taken from "<<backup_server_name<<", onto "<<mServer<<"/"<<mService<<std::endl;
-    std::cout << std::endl;
-    std::cout << "*** ALL DATA FOR "<<mServer<<"/"<<mService<<" WILL BE OVERWRITTEN! ***"<<std::endl;
-
-    // run the restore script
-    std::cout << "OK, here goes..." << std::endl;
-
-    { // backup existing service
-        maketitle("1) Backing up old service... ");
-        if (!backup(true)) // silent=true
-        {
-            std::cerr << std::endl;
-            std::cerr << "Error: Backup failed, restore aborted." << std::endl;
-            std::cerr << "You can try using   dropshell install "<<mServer<<" "<<mService<<"   to install the service afresh." << std::endl;
-            std::cerr << "Otherwise, stop the service, create and initialise a new one, then restore to that." << std::endl;
-            return false;
-        }
-        std::cout << "Backup complete." << std::endl;
-    }
-
-    { // uninstall service, then nuke it.
-        maketitle("2) Uninstalling old service...");
-        // if (!uninstall(true))
-        //     return false;
-
-        maketitle("3) Nuking old service...");
-        // if (!nuke(true))
-        //     return false;
-    }
-
-
-    { // restore service from backup
-        maketitle("4) Restoring service data from backup...");
-        std::string remote_backups_dir = remotepath::backups(mServer);
-        std::string remote_backup_file_path = remote_backups_dir + "/" + backup_file;
-
-        // Copy backup file from local to server
-        if (!scp_file_to_remote(local_backup_file_path, remote_backup_file_path, silent)) {
-            std::cerr << "Failed to copy backup file from local to server" << std::endl;
-            return false;
-        }
-
-        shared_commands::cRemoteTempFolder remote_temp_folder(mServerEnv);
-        mServerEnv.run_remote_template_command(mService, "restore", {}, silent, {{"BACKUP_FILE", remote_backup_file_path}, {"TEMP_DIR", remote_temp_folder.path()}});
-    } // dtor of remote_temp_folder will clean up the temp folder on the server
-
-
-    // { // installing fresh service
-    //     maketitle("5) Non-destructive install of fresh service...");
-    //     if (!install_service(mServer, mService, true))
-    //         return false;
-    // }
-
-    bool healthy = false;
-    {// healthcheck the service
-        maketitle("6) Healthchecking service...");
-        std::string green_tick = "\033[32m✓\033[0m";
-        std::string red_cross = "\033[31m✗\033[0m";    
-        healthy= (mServerEnv.run_remote_template_command(mService, "status", {}, silent, {}));
-        if (!silent)
-            std::cout << (healthy ? green_tick : red_cross) << " Service is " << (healthy ? "healthy" : "NOT healthy") << std::endl;
-    }
-
-    return healthy;
-}
-
-
-// backup the service over ssh, using the credentials from server.env (via server_env.hpp)
-// 1. run backup.sh on the server
-// 2. create a backup file with format server-service-datetime.tgz
-// 3. store it in the server's DROPSHELL_DIR/backups folder
-// 4. copy it to the local user_dir/backups folder
-
-// ------------------------------------------------------------------------------------------------
-// Backup the service.
-// ------------------------------------------------------------------------------------------------
-bool service_runner::backup(bool silent) {
-    auto service_info = get_service_info(mServer, mService);
-    if (service_info.local_service_path.empty()) {
-        std::cerr << "Error: Service not found" << std::endl;
-        return 1;
-    }
-
-    const std::string command = "backup";
-
-    if (!gTemplateManager().template_command_exists(service_info.template_name, command)) {
-        std::cout << "No backup script for " << service_info.template_name << std::endl;
-        return true; // nothing to back up.
-    }
-    
-    // Check if basic installed stuff is in place.
-    std::string remote_service_template_path = remotepath::service_template(mServer, mService);
-    std::string remote_command_script_file = remote_service_template_path + "/" + command + ".sh";
-    std::string remote_service_config_path = remotepath::service_config(mServer, mService);
-    if (!mServerEnv.check_remote_items_exist({
-        remotepath::service(mServer, mService),
-        remote_command_script_file,
-        remotefile::service_env(mServer, mService)})
-    )
-    {
-        std::cerr << "Error: Required service directories not found on remote server" << std::endl;
-        std::cerr << "Is the service installed?" << std::endl;
-        return false;
-    }
-
-    // Create backups directory on server if it doesn't exist
-    std::string remote_backups_dir = remotepath::backups(mServer);
-    if (!silent) std::cout << "Remote backups directory on "<< mServer <<": " << remote_backups_dir << std::endl;
-    std::string mkdir_cmd = "mkdir -p " + quote(remote_backups_dir);
-    if (!execute_ssh_command(mServerEnv.get_SSH_INFO(), sCommand("",mkdir_cmd, {}), cMode::Silent)) {
-        std::cerr << "Failed to create backups directory on server" << std::endl;
-        return false;
-    }
-
-    // Create backups directory locally if it doesn't exist
-    std::string local_backups_dir = gConfig().get_local_backup_path();
-    if (local_backups_dir.empty()) {
-        std::cerr << "Error: Local backups directory not found" << std::endl;
-        std::cerr << "Run 'dropshell edit' to configure DropShell" << std::endl;
-        return false;
-    }
-    if (!std::filesystem::exists(local_backups_dir)) 
-        std::filesystem::create_directories(local_backups_dir);
-
-    // Get current datetime for backup filename
-    auto now = std::chrono::system_clock::now();
-    auto time = std::chrono::system_clock::to_time_t(now);
-    std::stringstream datetime;
-    datetime << std::put_time(std::localtime(&time), "%Y-%m-%d_%H-%M-%S");
-    
-    // Construct backup filename
-    shared_commands::cBackupFileName backup_filename_construction(mServer, mService, service_info.template_name);
-    if (!backup_filename_construction.is_valid()) {
-        std::cerr << "Invalid backup filename" << std::endl;
-        return false;
-    }
-    std::string backup_filename = backup_filename_construction.get_filename();
-    std::string remote_backup_file_path = remote_backups_dir + "/" + backup_filename;
-    std::string local_backup_file_path = (std::filesystem::path(local_backups_dir) / backup_filename).string();
-
-    // assert that the backup filename is valid - -_- appears exactly 3 times in local_backup_file_path.
-    ASSERT(3 == count_substring("-_-", local_backup_file_path), "Invalid backup filename");
-
-    {   // Run backup script
-        shared_commands::cRemoteTempFolder remote_temp_folder(mServerEnv);
-        if (!mServerEnv.run_remote_template_command(mService, command, {}, silent, {{"BACKUP_FILE", remote_backup_file_path}, {"TEMP_DIR", remote_temp_folder.path()}})) {
-            std::cerr << "Backup script failed on remote server: " << remote_backup_file_path << std::endl;
-            return false;
-        }
-
-        // Copy backup file from server to local
-        if (!scp_file_from_remote(remote_backup_file_path, local_backup_file_path, silent)) {
-            std::cerr << "Failed to copy backup file from server" << std::endl;
-            return false;
-        }
-    } // dtor of remote_temp_folder will clean up the temp folder on the server
-
-    if (!silent) {
-        std::cout << "Backup created successfully. Restore with:"<<std::endl;
-        std::cout << "   dropshell restore " << mServer << " " << mService << " " << backup_filename << std::endl;
-    }
-    return true;
-}
-
-// Helper function to get the latest backup file for a given server and service
-std::string service_runner::get_latest_backup_file(const std::string& server, const std::string& service) {
-    std::string local_backups_dir = gConfig().get_local_backup_path();
-    if (local_backups_dir.empty() || !std::filesystem::exists(local_backups_dir)) {
-        std::cerr << "Error: Local backups directory not found: " << local_backups_dir << std::endl;
-        return "";
-    }
-
-    // Get the template name for this service
-    LocalServiceInfo info = get_service_info(server, service);
-    if (info.template_name.empty()) {
-        std::cerr << "Error: Could not determine template name for service: " << service << std::endl;
-        return "";
-    }
-
-    // Build the expected prefix for backup files
-    std::string prefix = server + "-_-" + info.template_name + "-_-" + service + "-_-";
-    std::string latest_file;
-    std::string latest_datetime;
-
-    std::cout << "Looking for backup files in " << local_backups_dir << std::endl;
-
-    for (const auto& entry : std::filesystem::directory_iterator(local_backups_dir)) {
-        if (!entry.is_regular_file()) continue;
-        std::string filename = entry.path().filename().string();
-        if (filename.rfind(prefix, 0) == 0) { // starts with prefix
-            // Extract the datetime part
-            size_t dt_start = prefix.size();
-            size_t dt_end = filename.find(".tgz", dt_start);
-            if (dt_end == std::string::npos) continue;
-            std::string datetime = filename.substr(dt_start, dt_end - dt_start);
-            std::cout << "Found backup file: " << filename << " with datetime: " << datetime << std::endl;
-            if (datetime > latest_datetime) {
-                latest_datetime = datetime;
-                latest_file = filename;
-            }
-        }
-    }
-
-    if (latest_file.empty()) {
-        std::cerr << "Error: No backup files found for " << server << ", " << service << std::endl;
-    }
-
-    std::cout << "Latest backup file: " << latest_file << std::endl;
-    return latest_file;
-}
-
-} // namespace dropshell

source/src/services.cpp

@@ -4,220 +4,279 @@
 #include "templates.hpp"
 #include "config.hpp"
 #include "utils/utils.hpp"
-#include "server_env_manager.hpp"
+#include <libassert/assert.hpp>
-#include "servers.hpp"
-#include "assert.hpp"
 
 #include <iostream>
 #include <filesystem>
 
 namespace fs = std::filesystem;
 
-namespace dropshell {   
+namespace dropshell
+{
 
-    bool SIvalid(const LocalServiceInfo& service_info) {
+#pragma message("TODO : Smart test that the service is fully valid.")
+    bool SIvalid(const LocalServiceInfo &service_info)
+    {
         return !service_info.service_name.empty() &&
                !service_info.template_name.empty() &&
                !service_info.local_service_path.empty() &&
-               !service_info.local_template_path.empty();
+               !service_info.local_template_path.empty() &&
+               !service_info.user.empty();
     }
 
-std::vector<LocalServiceInfo> get_server_services_info(const std::string& server_name) {
+    std::vector<LocalServiceInfo> get_server_services_info(const std::string &server_name)
-    std::vector<LocalServiceInfo> services;
-
-    if (server_name.empty())
-        return services;
-
-    std::vector<std::string> local_server_definition_paths = gConfig().get_local_server_definition_paths();
-    if (local_server_definition_paths.empty()) {
-        std::cerr << "Error: No local server definition paths found" << std::endl;
-        std::cerr << "Run 'dropshell edit' to configure DropShell" << std::endl;
-        return services;
-    }
-
-    for (const auto& server_definition_path : local_server_definition_paths) {
-        fs::path serverpath = server_definition_path + "/" + server_name;
-        if (fs::exists(serverpath)) // service is on that server...
-            for (const auto& entry : fs::directory_iterator(serverpath)) {
-                if (fs::is_directory(entry)) {
-                    std::string dirname = entry.path().filename().string();
-                    if (dirname.empty() || dirname[0] == '.' || dirname[0] == '_')
-                        continue;
-                    auto service = get_service_info(server_name, dirname);
-                    if (!service.local_service_path.empty()) 
-                        services.push_back(service);
-                    else 
-                        warning << "Failed to get service info for " << dirname << " on server " << server_name << std::endl;
-                }
-            } // end of for 
-    }
-   
-    return services;
-}
-
-
-LocalServiceInfo get_service_info(const std::string &server_name, const std::string &service_name)
-{
-    LocalServiceInfo service;
-
-    if (server_name.empty() || service_name.empty())
-        return LocalServiceInfo();
-
-    service.service_name = service_name;
-
-    service.local_service_path = localpath::service(server_name, service_name);
-    if (service.local_service_path.empty()) 
-        return LocalServiceInfo();
-
-    // check the service directory exists.
-    if (!fs::exists(service.local_service_path))
     {
-        std::cerr << "Error: Service directory not found: " << service.local_service_path << std::endl;
+        std::vector<LocalServiceInfo> services;
-        return LocalServiceInfo();
-    }
 
-    // now set the template name and path.
+        if (server_name.empty())
-    std::map<std::string, std::string> variables;
+            return services;
-    if (!get_all_service_env_vars(server_name, service_name, variables))
-        return LocalServiceInfo();
 
-    // confirm TEMPLATE is defined.
+        std::vector<std::string> local_server_definition_paths = gConfig().get_local_server_definition_paths();
-    auto it = variables.find("TEMPLATE");
+        if (local_server_definition_paths.empty())
-    if (it == variables.end()) {
+        {
-        std::cerr << "Error: TEMPLATE variable not defined in service " << service_name << " on server " << server_name << std::endl;
+            error << "No local server definition paths found" << std::endl;
-        return LocalServiceInfo();
+            info << "Run 'dropshell edit' to configure DropShell" << std::endl;
-    }
+            return services;
-    service.template_name = it->second;
+        }
 
-    template_info tinfo = gTemplateManager().get_template_info(service.template_name);
+        for (const auto &server_definition_path : local_server_definition_paths)
-    if (!tinfo.is_set()) {
+        {
-        std::cerr << "Error: Template '" << service.template_name << "' not found" << std::endl;
+            fs::path serverpath = server_definition_path + "/" + server_name;
-        return LocalServiceInfo();
+            if (fs::exists(serverpath)) // service is on that server...
-    }
+                for (const auto &entry : fs::directory_iterator(serverpath))
-
-    // find the template path   
-    service.local_template_path = tinfo.local_template_path();
-
-    return service;
-}
-
-std::set<std::string> get_used_commands(const std::string &server_name, const std::string &service_name)
-{
-    std::set<std::string> commands;
-
-    if (server_name.empty() || service_name.empty())
-        return commands;
-
-    auto service_info = get_service_info(server_name, service_name);
-    if (service_info.local_template_path.empty()) {
-        std::cerr << "Error: Service not found: " << service_name << std::endl;
-        return commands;
-    }
-
-    // iterate over all files in the template path, and add the command name to the set.
-    // commands are .sh files that don't begin with _
-    for (const auto& entry : fs::directory_iterator(service_info.local_template_path)) {
-        if (fs::is_regular_file(entry) && entry.path().extension() == ".sh" && (entry.path().filename().string().rfind("_", 0) != 0)) 
-            commands.insert(entry.path().stem().string());
-    }
-    return commands;
-}
-
-std::set<std::string> list_backups(const std::string &server_name, const std::string &service_name)
-{
-    std::set<std::string> backups;
-
-    if (server_name.empty() || service_name.empty())
-        return backups;
-
-    // need to find the template for the service.
-    auto service_info = get_service_info(server_name, service_name);
-    if (service_info.local_template_path.empty()) {
-        std::cerr << "Error: Service not found: " << service_name << std::endl;
-        return backups;
-    }
-
-    std::string backups_dir = gConfig().get_local_backup_path();
-    if (backups_dir.empty())
-        return backups;
-
-    if (fs::exists(backups_dir)) {
-        for (const auto& entry : fs::directory_iterator(backups_dir)) {
-            if (fs::is_regular_file(entry) && entry.path().extension() == ".tgz")
-                if (entry.path().filename().string().find(service_info.template_name) != std::string::npos)
                 {
-                    backups.insert(entry.path().filename().string());
+                    if (fs::is_directory(entry))
-                }
+                    {
+                        std::string dirname = entry.path().filename().string();
+                        if (dirname.empty() || dirname[0] == '.' || dirname[0] == '_')
+                            continue;
+                        auto service = get_service_info(server_name, dirname);
+                        if (!service.local_service_path.empty())
+                            services.push_back(service);
+                        else
+                            warning << "Failed to get service info for " << dirname << " on server " << server_name << std::endl;
+                    }
+                } // end of for
         }
+
+        return services;
     }
-    return backups;
-}
 
-
+    bool get_bool_variable(const std::map<std::string, std::string> &variables, const std::string &variable_name)
-
-bool get_all_service_env_vars(const std::string &server_name, const std::string &service_name, std::map<std::string, std::string> & all_env_vars)
-{
-    all_env_vars.clear();
-
-    if (localpath::service(server_name, service_name).empty() || !fs::exists(localpath::service(server_name, service_name)))
     {
-        std::cerr << "Error: Service not found: " << service_name << " on server " << server_name << std::endl;
+        auto it = variables.find(variable_name);
-        return false;
+        if (it == variables.end())
-    }
+        {
-
+            error << "Variable " << variable_name << " not found in the service " << filenames::template_info_env << std::endl;
-    ServerInfo server_info = get_server_info(server_name);
+            return false;
-    if (server_info.ssh_host.empty()) 
-        std::cerr << "Error: Server " << server_name << " not found - ssh_host empty, so HOST_NAME not set" << std::endl;
-
-    // add in some handy variables.
-    // if we change these, we also need to update agent/_allservicesstatus.sh
-    all_env_vars["CONFIG_PATH"] = remotepath::service_config(server_name,service_name);
-    all_env_vars["SERVER"] = server_name;
-    all_env_vars["SERVICE"] = service_name;
-    all_env_vars["AGENT_PATH"] = remotepath::agent(server_name);
-    all_env_vars["HOST_NAME"] = server_info.ssh_host;
-    all_env_vars["DOCKER_CLI_HINTS"] = "false"; // turn off docker junk.
-
-    // Lambda function to load environment variables from a file
-    auto load_env_file = [&all_env_vars](const std::string& file) {
-        if (!file.empty() && std::filesystem::exists(file)) {
-            std::map<std::string, std::string> env_vars;
-            envmanager env_manager(file);
-            env_manager.load();
-            env_manager.get_all_variables(env_vars);
-            all_env_vars.merge(env_vars);
         }
-        else
+        return it->second == "true";
-            warning << "Expected environment file not found: " << file << std::endl;
-    };
-
-    // Load environment files
-    load_env_file(localfile::service_env(server_name, service_name));
-    load_env_file(localfile::template_info_env(server_name, service_name));
-
-    // determine template name.
-    auto it = all_env_vars.find("TEMPLATE");
-    if (it == all_env_vars.end()) {
-        error << "TEMPLATE variable not defined in service " << service_name << " on server " << server_name << std::endl;
-        info << "The TEMPLATE variable is required to determine the template name." << std::endl;
-        info << "Please check the service.env file and the .template_info.env file in:" << std::endl;
-        info << "    " << localpath::service(server_name, service_name) << std::endl << std::endl;
-        return false;
-    }
-    template_info tinfo = gTemplateManager().get_template_info(it->second);
-    if (!tinfo.is_set()) {
-        std::cerr << "Error: Template '" << it->second << "' not found" << std::endl;
-        return false;
     }
 
-    std::string default_env_file = tinfo.local_template_path()/"_default.env";
+    LocalServiceInfo get_service_info(const std::string &server_name, const std::string &service_name)
-    if (!fs::exists(default_env_file)) {
+    {
-        std::cerr << "Error: Template default env file '" << default_env_file << "' not found" << std::endl;
+        LocalServiceInfo service;
-        return false;
+
+        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);
+        if (service.local_service_path.empty())
+            return LocalServiceInfo();
+
+        // check the service directory exists.
+        if (!fs::exists(service.local_service_path))
+        {
+            warning << "Service directory not found: " << service.local_service_path << std::endl;
+            return LocalServiceInfo();
+        }
+
+        // now set the template name and path.
+        std::map<std::string, std::string> variables;
+        if (!get_all_service_env_vars(server_name, service_name, variables))
+            return LocalServiceInfo();
+
+        { // confirm TEMPLATE is defined.
+            auto it = variables.find("TEMPLATE");
+            if (it == variables.end())
+            {
+                error << "TEMPLATE variable not defined in service " << service_name << " on server " << server_name << std::endl;
+                return LocalServiceInfo();
+            }
+            service.template_name = it->second;
+        }
+
+        template_info tinfo = gTemplateManager().get_template_info(service.template_name);
+        if (!tinfo.is_set())
+        {
+            error << "Template specified '" << service.template_name << "' could not be found" << std::endl;
+            return LocalServiceInfo();
+        }
+
+        // find the template path
+        service.local_template_path = tinfo.local_template_path();
+
+        { // set the user.
+            auto it = variables.find("SSH_USER");
+            if (it == variables.end())
+            {
+                error << "SSH_USER variable not defined in service " << service_name << " on server " << server_name << std::endl;
+                return LocalServiceInfo();
+            }
+            service.user = it->second;
+        }
+
+        // set the host root and docker requirements.
+        service.requires_host_root = get_bool_variable(variables, "REQUIRES_HOST_ROOT");
+        service.requires_docker = get_bool_variable(variables, "REQUIRES_DOCKER");
+        service.requires_docker_root = get_bool_variable(variables, "REQUIRES_DOCKER_ROOT");
+
+        { // determine if the service template hash matches the template hash.
+            auto it = variables.find("TEMPLATE_HASH");
+            if (it == variables.end())
+                error << "Variable TEMPLATE_HASH not found in the service " << filenames::template_info_env << std::endl;
+            else
+            {
+                uint64_t service_template_hash = std::stoull(it->second);
+                service.service_template_hash_match = (service_template_hash == tinfo.hash());
+                //debug << "Service template hash: " << service_template_hash << " == " << tinfo.hash() << std::endl;
+            }
+        }
+
+        return service;
     }
 
-    load_env_file(default_env_file);
+    std::set<std::string> get_used_commands(const std::string &server_name, const std::string &service_name)
-    return true;
+    {
-}
+        std::set<std::string> commands;
+
+        if (server_name.empty() || service_name.empty())
+            return commands;
+
+        auto service_info = get_service_info(server_name, service_name);
+        if (service_info.local_template_path.empty())
+        {
+            error << "Service not found: " << service_name << std::endl;
+            return commands;
+        }
+
+        // iterate over all files in the template path, and add the command name to the set.
+        // commands are .sh files that don't begin with _
+        for (const auto &entry : fs::directory_iterator(service_info.local_template_path))
+        {
+            if (fs::is_regular_file(entry) && entry.path().extension() == ".sh" && (entry.path().filename().string().rfind("_", 0) != 0))
+                commands.insert(entry.path().stem().string());
+        }
+        return commands;
+    }
+
+    std::set<std::string> list_backups(const std::string &server_name, const std::string &service_name)
+    {
+        std::set<std::string> backups;
+
+        if (server_name.empty() || service_name.empty())
+            return backups;
+
+        // need to find the template for the service.
+        auto service_info = get_service_info(server_name, service_name);
+        if (service_info.local_template_path.empty())
+        {
+            error << "Service not found: " << service_name << std::endl;
+            return backups;
+        }
+
+        std::string backups_dir = localpath::backups();
+        if (backups_dir.empty())
+            return backups;
+
+        if (fs::exists(backups_dir))
+        {
+            for (const auto &entry : fs::directory_iterator(backups_dir))
+            {
+                if (fs::is_regular_file(entry) && entry.path().extension() == ".tgz")
+                    if (entry.path().filename().string().find(service_info.template_name) != std::string::npos)
+                    {
+                        backups.insert(entry.path().filename().string());
+                    }
+            }
+        }
+        return backups;
+    }
+
+    bool get_all_service_env_vars(const std::string &server_name, const std::string &service_name, std::map<std::string, std::string> &all_env_vars)
+    {
+        all_env_vars.clear();
+
+        if (localpath::service(server_name, service_name).empty() || !fs::exists(localpath::service(server_name, service_name)))
+        {
+            error << "Service not found: " << service_name << " on server " << server_name << std::endl;
+            return false;
+        }
+
+        // Lambda function to load environment variables from a file
+        auto load_env_file = [&all_env_vars](const std::string &file)
+        {
+            if (!file.empty() && std::filesystem::exists(file))
+            {
+                std::map<std::string, std::string> env_vars;
+                envmanager env_manager(file);
+                env_manager.load();
+                env_manager.get_all_variables(env_vars);
+                all_env_vars.merge(env_vars);
+            }
+            else
+                warning << "Expected environment file not found: " << file << std::endl;
+        };
+
+
+        // add in some simple variables first, as others below may depend on/use these in bash.
+        // if we change these, we also need to update agent/_allservicesstatus.sh
+        all_env_vars["SERVER"] = server_name;
+        all_env_vars["SERVICE"] = service_name;
+        all_env_vars["DOCKER_CLI_HINTS"] = "false"; // turn off docker junk.
+
+        // Load environment files
+        load_env_file(localfile::service_env(server_name, service_name));
+        load_env_file(localfile::template_info_env(server_name, service_name));
+
+        std::string user = all_env_vars["SSH_USER"];
+        if (user.empty())
+        {
+            error << "SSH_USER variable not defined in service " << service_name << " on server " << server_name << std::endl;
+            info << "This variable definition is always required, and usually set in the "<<filenames::service_env << " file." << std::endl;
+            info << "Please check " << localfile::service_env(server_name, service_name) << std::endl;
+            return false;
+        }
+
+        // more additional, these depend on others above.
+        all_env_vars["CONFIG_PATH"] = remotepath(server_name, user).service_config(service_name);
+        all_env_vars["AGENT_PATH"] = remotepath(server_name, user).agent();
+
+
+        // determine template name.
+        auto it = all_env_vars.find("TEMPLATE");
+        if (it == all_env_vars.end())
+        {
+            error << "TEMPLATE variable not defined in service " << service_name << " on server " << server_name << std::endl;
+            info << "The TEMPLATE variable is required to determine the template name." << std::endl;
+            info << "Please check the " << filenames::service_env << " file and the "<< filenames::template_info_env << " file in:" << std::endl;
+            info << "    " << localpath::service(server_name, service_name) << std::endl
+                 << std::endl;
+            return false;
+        }
+        template_info tinfo = gTemplateManager().get_template_info(it->second);
+        if (!tinfo.is_set())
+        {
+            error << "Template '" << it->second << "' not found" << std::endl;
+            return false;
+        }
+
+        return true;
+    }
 
 } // namespace dropshell

source/src/services.hpp

@@ -13,6 +13,11 @@ namespace dropshell {
         std::string template_name;
         std::string local_service_path;
         std::string local_template_path;
+        std::string user;
+        bool requires_host_root;
+        bool requires_docker;
+        bool requires_docker_root;
+        bool service_template_hash_match;
     };
     
     bool SIvalid(const LocalServiceInfo& service_info);
@@ -27,6 +32,7 @@ namespace dropshell {
 
     // list all backups for a given service (across all servers)
     std::set<std::string> list_backups(const std::string& server_name, const std::string& service_name);
+
 } // namespace dropshell
 
 #endif

source/src/templates.cpp

@@ -6,13 +6,14 @@
     #include <algorithm>
     #include <iomanip>
     #include <map>
-    #include "utils/assert.hpp"
+    #include <libassert/assert.hpp>
 
     #include "utils/envmanager.hpp"
     #include "utils/directories.hpp"
     #include "utils/utils.hpp"
     #include "templates.hpp"
     #include "config.hpp"   
+    #include "utils/hash.hpp"
 
     namespace dropshell {
 
@@ -162,7 +163,7 @@
         ASSERT(mLoaded && mSources.size() > 0, "Template manager not loaded, or no template sources found.");
         template_source_interface* source = get_source(template_name);
         if (!source) {
-            std::cerr << "Error: Template '" << template_name << "' not found" << std::endl;
+            error << "Template '" << template_name << "' not found" << std::endl;
             return false;
         }
         return source->template_command_exists(template_name, command);
@@ -170,25 +171,30 @@
 
     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();
         
         if (local_server_definition_paths.empty()) {
-            std::cerr << "Error: No local server definition paths found" << std::endl;
+            error << "No local server definition paths found" << std::endl;
-            std::cerr << "Run 'dropshell edit' to configure DropShell" << std::endl;
+            info << "Run 'dropshell edit' to configure DropShell" << std::endl;
             return false;
         }
 
-        auto info = get_template_info(template_name);
+        auto tinfo = get_template_info(template_name);
-        if (info.is_set()) {
+        if (tinfo.is_set()) {
-            std::cerr << "Error: Template '" << template_name << "' already exists at " << info.locationID() << std::endl;
+            error << "Template '" << template_name << "' already exists at " << tinfo.locationID() << std::endl;
             return false;
         }
 
-        auto local_template_paths = gConfig().get_template_local_paths();
+        auto local_template_paths = gConfig().get_local_template_paths();
         if (local_template_paths.empty()) {
-            std::cerr << "Error: No local template paths found" << std::endl;
+            error << "No local template paths found" << std::endl;
-            std::cerr << "Run 'dropshell edit' to add one to the DropShell config" << std::endl;
+            info << "Run 'dropshell edit' to add one to the DropShell config" << std::endl;
             return false;
         }
         std::string new_template_path = local_template_paths[0] + "/" + template_name;
@@ -199,7 +205,7 @@
         // 2. Copy the example template from the system templates directory
         auto example_info = gTemplateManager().get_template_info("example-nginx");
         if (!example_info.is_set()) {
-            std::cerr << "Error: Example template not found" << std::endl;
+            error << "Example template not found" << std::endl;
             return false;
         }
         std::string example_template_path = example_info.local_template_path();
@@ -219,9 +225,9 @@
         // modify the TEMPLATE=example line in the .template_info.env file to TEMPLATE=<template_name>
         std::string search_string = "TEMPLATE=";
         std::string replacement_line = "TEMPLATE=" + template_name;
-        std::string service_env_path = new_template_path + "/config/.template_info.env";
+        std::string service_env_path = new_template_path + "/config/" + filenames::template_info_env;
         if (!replace_line_in_file(service_env_path, search_string, replacement_line)) {
-            std::cerr << "Error: Failed to replace TEMPLATE= line in the .template_info.env file" << std::endl;
+            error << "Failed to replace TEMPLATE= line in the " << filenames::template_info_env <<" file" << std::endl;
             return false;
         }
 
@@ -252,7 +258,7 @@
         ASSERT(mSources.empty(), "Template manager already loaded (sources are not empty).");
         ASSERT(gConfig().is_config_set(), "Config not set.");
         ASSERT(!mLoaded, "Template manager already loaded.");
-        auto local_template_paths = gConfig().get_template_local_paths();
+        auto local_template_paths = gConfig().get_local_template_paths();
         if (local_template_paths.empty())
             return;
         for (const auto& path : local_template_paths) 
@@ -277,7 +283,7 @@
     bool template_manager::required_file(std::string path, std::string template_name)
     {
         if (!std::filesystem::exists(path)) {
-            std::cerr << "Error: " << path << " file not found in template - REQUIRED." << template_name << std::endl;
+            error << path << " file not found in template - REQUIRED." << template_name << std::endl;
             return false;
         }
         return true;
@@ -305,9 +311,8 @@
         std::string template_name = std::filesystem::path(template_path).filename().string();
 
         std::vector<std::string> required_files = {
-            "config/service.env",
+            "config/" + filenames::service_env,
-            "config/.template_info.env",
+            "config/" + filenames::template_info_env,
-            "_default.env",
             "install.sh",
             "uninstall.sh"
         };
@@ -323,7 +328,7 @@
                 std::filesystem::path path = template_path + "/" + file;
                 auto perms = std::filesystem::status(path).permissions();
                 if ((perms & std::filesystem::perms::owner_exec) == std::filesystem::perms::none)
-                    std::cerr << "Error: " << file << " is not executable" << std::endl;
+                    error << file << " is not executable" << std::endl;
             }
         }        
 
@@ -331,8 +336,8 @@
         // check TEMPLATE= line.
         std::map<std::string, std::string> all_env_vars;
         std::vector<std::string> env_files = {
-            "config/service.env",
+            "config/" + filenames::service_env,
-            "config/.template_info.env"
+            "config/" + filenames::template_info_env
         };
         for (const auto& file : env_files) {
             { // load service.env from the service on this machine.
@@ -347,18 +352,18 @@
         // determine template name.
         auto it = all_env_vars.find("TEMPLATE");
         if (it == all_env_vars.end()) {
-            std::cerr << "Error: TEMPLATE variable not found in " << template_path << std::endl;
+            error << "TEMPLATE variable not found in " << template_path << std::endl;
             return false;
         }
 
         std::string env_template_name = it->second;
         if (env_template_name.empty()) {
-            std::cerr << "Error: TEMPLATE variable is empty in " << template_path << std::endl;
+            error << "TEMPLATE variable is empty in " << template_path << std::endl;
             return false;
         }
 
         if (env_template_name != template_name) {
-            std::cerr << "Error: TEMPLATE variable is wrong in " << template_path << std::endl;
+            error << "TEMPLATE variable is wrong in " << template_path << std::endl;
             return false;
         }
 
@@ -376,8 +381,16 @@
         mLocationID(location_id),
         mTemplateLocalPath(local_template_path),
         mTemplateValid(template_manager::test_template(local_template_path.string())),
-        mIsSet(!template_name.empty() && !location_id.empty() && !local_template_path.empty())
+        mIsSet(!template_name.empty() && !location_id.empty() && !local_template_path.empty()),\
+        mHash(0)
     {
+        if (!std::filesystem::exists(local_template_path))
+        {
+            error << "Template path does not exist: " << local_template_path << std::endl;
+            return;
+        }
+    
+        mHash = hash_directory_recursive(local_template_path);
     }
 
     } // namespace dropshell

source/src/templates.hpp

@@ -4,7 +4,10 @@
 #include <memory>
 #include <set>
 
-#include "utils/json.hpp"
+#include "config.hpp"
+#define JSON_INLINE_ALL
+#include <nlohmann/json.hpp>
+
 
 namespace dropshell {
 
@@ -19,17 +22,20 @@ class template_info {
         template_info() : mIsSet(false) {}
         template_info(const std::string& template_name, const std::string& location_id, const std::filesystem::path& local_template_path);
         virtual ~template_info() {}
-        bool is_set() { return mIsSet; }
+        bool is_set() const { return mIsSet; }
-        std::string name() { return mTemplateName; }
+        std::string name() const { return mTemplateName; }
-        std::string locationID() { return mLocationID; }
+        std::string locationID() const { return mLocationID; }
-        std::filesystem::path local_template_path() { return mTemplateLocalPath; }
+        std::filesystem::path local_template_path() const { return mTemplateLocalPath; }
-        bool template_valid() { return mTemplateValid; }
+        bool template_valid() const { return mTemplateValid; }
+        uint64_t hash() const { return mHash; }
+
     private:
         std::string mTemplateName;
         std::string mLocationID;
         std::filesystem::path mTemplateLocalPath; // source or cache.
         bool mTemplateValid;
         bool mIsSet;
+        uint64_t mHash;
 };
 
 class template_source_interface {
@@ -45,7 +51,7 @@ class template_source_interface {
 
 class template_source_registry : public template_source_interface {
     public:
-        template_source_registry(std::string URL) : mURL(URL) {}
+        template_source_registry(tRegistryEntry registry) : mRegistry(registry) {}
 
         ~template_source_registry() {}
 
@@ -54,11 +60,11 @@ class template_source_registry : public template_source_interface {
         template_info get_template_info(const std::string& template_name);
         bool template_command_exists(const std::string& template_name,const std::string& command);
 
-        std::string get_description() { return "Registry: " + mURL; }
+        std::string get_description() { return "Registry: " + mRegistry.name + " (" + mRegistry.url + ")"; }
     private:
         std::filesystem::path get_cache_dir();
     private:
-        std::string mURL;
+        tRegistryEntry mRegistry;
         std::vector<nlohmann::json> mTemplates; // cached list.
 };
 

source/src/utils/assert.hpp

@@ -1,12 +0,0 @@
-#ifndef ASSERT_HPP
-#define ASSERT_HPP
-
-#include "output.hpp"
-
-#define ASSERT(condition, message) \
-    if (!(condition)) { \
-        dropshell::error << "Assertion failed: " << message << std::endl; \
-        std::exit(1); \
-    }
-
-#endif // ASSERT_HPP

source/src/utils/directories.cpp

@@ -1,53 +1,67 @@
 #include "directories.hpp"
 #include "config.hpp"
-#include "server_env_manager.hpp"
+#include "servers.hpp"
 #include "output.hpp"
 
 #include <iostream>
 #include <string>
 #include <filesystem>
 
-
 namespace fs = std::filesystem;
 
-namespace dropshell {
+namespace dropshell
+{
 
-
+    namespace localfile
-namespace localfile {
-
-    std::string dropshell_json() {
-        // Try ~/.config/dropshell/dropshell.json
-        std::string homedir = localpath::current_user_home();
-        if (!homedir.empty()) {
-            fs::path user_path = fs::path(homedir) / ".config" / "dropshell" /  "dropshell.json";
-            return user_path.string();
-        }
-        return std::string();
-    }
-
-    std::string server_json(const std::string &server_name) {
-        std::string serverpath = localpath::server(server_name);
-        return (serverpath.empty() ? "" : (fs::path(serverpath) / "server.json").string());
-    }
-
-    std::string service_env(const std::string &server_name, const std::string &service_name) {
-        std::string servicepath = localpath::service(server_name, service_name);
-        return (servicepath.empty() ? "" : (fs::path(servicepath) / "service.env").string());
-    }
-
-    std::string template_info_env(const std::string &server_name, const std::string &service_name)
     {
-        std::string servicepath = localpath::service(server_name, service_name);
-        return (servicepath.empty() ? "" : (fs::path(servicepath) / ".template_info.env").string());
-    }
 
-} // namespace localfile
+        std::string dropshell_json()
+        {
+            return localpath::dropshell_dir() + "/" + filenames::dropshell_json;
+        }
 
+        std::string server_json(const std::string &server_name)
+        {
+            std::string serverpath = localpath::server(server_name);
+            return (serverpath.empty() ? "" : (fs::path(serverpath) / filenames::server_json).string());
+        }
 
-// ------------------------------------------------------------------------------------------
+        std::string service_env(const std::string &server_name, const std::string &service_name)
+        {
+            std::string servicepath = localpath::service(server_name, service_name);
+            return (servicepath.empty() ? "" : (fs::path(servicepath) / filenames::service_env).string());
+        }
 
-namespace localpath {
+        std::string template_info_env(const std::string &server_name, const std::string &service_name)
-        std::string server(const std::string &server_name) {
+        {
+            std::string servicepath = localpath::service(server_name, service_name);
+            return (servicepath.empty() ? "" : (fs::path(servicepath) / filenames::template_info_env).string());
+        }
+
+        std::string template_example()
+        {
+            return localpath::agent_local() + "/template_example";
+        }
+
+        std::string bb64()
+        {
+            return localpath::agent_local() + "/bb64";
+        }
+
+    } // namespace localfile
+
+    // ------------------------------------------------------------------------------------------
+
+    namespace localpath
+    {
+
+        std::string dropshell_dir()
+        {
+            return current_user_home() + "/.dropshell";
+        }
+
+        std::string server(const std::string &server_name)
+        {
             for (std::filesystem::path dir : gConfig().get_local_server_definition_paths())
                 if (fs::exists(dir / server_name))
                     return dir / server_name;
@@ -55,27 +69,23 @@ namespace localpath {
             return "";
         }
 
-        std::string service(const std::string &server_name, const std::string &service_name) {
+        std::string service(const std::string &server_name, const std::string &service_name)
+        {
             std::string serverpath = localpath::server(server_name);
-            return ((serverpath.empty() || service_name.empty()) ? "" : (serverpath+"/"+service_name));
+            return ((serverpath.empty() || service_name.empty()) ? "" : (serverpath + "/" + service_name));
         }
 
-        std::string remote_versions(const std::string &server_name, const std::string &service_name)
+        std::string agent_local()
         {
-            std::string template_cache_path = gConfig().get_local_template_cache_path();
+            return dropshell_dir() + "/agent-local";
-            return ((template_cache_path.empty() || service_name.empty()) ? "" : 
-               (template_cache_path+"/remote_versions/"+service_name+".json"));
         }
-        std::string agent(){
+        std::string agent_remote()
-            return current_user_home() + "/.local/dropshell_agent";
-        }
-        std::string files_for_remote_agent()
         {
-            return agent() + "/files_for_remote_agent";
+            return dropshell_dir() + "/agent-remote";
         }
         std::string current_user_home()
         {
-            char * homedir = std::getenv("HOME");
+            char *homedir = std::getenv("HOME");
             if (homedir)
             {
                 std::filesystem::path homedir_path(homedir);
@@ -84,7 +94,46 @@ namespace localpath {
             warning << "Couldn't determine user directory" << std::endl;
             return std::string();
         }
-} // namespace localpath
+
+        std::string backups()
+        {
+            if (!gConfig().is_config_set())
+                return "";
+            return gConfig().get_backups_path();
+        }
+
+        std::string temp_files()
+        {
+            return dropshell_dir() + "/temp_files";
+        }
+
+        std::string template_cache()
+        {
+            return dropshell_dir() + "/template_cache";
+        }
+
+        bool create_directories()
+        {
+            std::vector<std::filesystem::path> paths = {
+                dropshell_dir(),
+                agent_local(),
+                agent_remote(),
+                template_cache(),
+                backups(),
+                temp_files()};
+            for (auto &p : gConfig().get_local_server_definition_paths())
+                paths.push_back(p);
+
+            for (auto &p : paths)
+                if (!p.empty() && !std::filesystem::exists(p))
+                {
+                    info << "Creating directory: " << p << std::endl;
+                    std::filesystem::create_directories(p);
+                }
+            return false;
+        }
+
+    } // namespace localpath
 
     //------------------------------------------------------------------------------------------------
     // remote paths
@@ -99,94 +148,90 @@ namespace localpath {
     //           |-- config
     //               |-- service.env (actual service config)
     //           |-- template
-    //               |-- _default.env
     //               |-- (script files)
     //               |-- config
     //                   |-- service.env (default service config)
     //                   |-- (other config files for specific server&service)
 
+    remotefile::remotefile(const std::string &server_name, const std::string &user) : mServer_name(server_name), mUser(user) {}
 
-
+    std::string remotefile::service_env(const std::string &service_name) const
-namespace remotefile {
-
-    std::string service_env(const std::string &server_name, const std::string &service_name)
     {
-        return remotepath::service_config(server_name, service_name) + "/service.env";
+        return remotepath(mServer_name, mUser).service_config(service_name) + "/" + filenames::service_env;
     }
 
-}
+    remotepath::remotepath(const std::string &server_name, const std::string &user) : mServer_name(server_name), mUser(user) {}
 
-namespace remotepath {
+    std::string remotepath::DROPSHELL_DIR() const
-    std::string DROPSHELL_DIR(const std::string &server_name)
     {
-        return server_env_manager(server_name).get_DROPSHELL_DIR();
+        try 
+        {
+            return ServerConfig(mServer_name).get_user_dir(mUser);
+        } catch (const std::exception &e)
+        {
+            error << "Failed to get remote dropshell directory for " << mServer_name << "@" << mUser << std::endl;
+            error << "Exception: " << e.what() << std::endl;
+            return "";
+        }
     }
 
-    std::string services(const std::string &server_name)
+    std::string remotepath::services() const
     {
-        std::string dsp = DROPSHELL_DIR(server_name);
+        std::string dsp = DROPSHELL_DIR();
         return (dsp.empty() ? "" : (dsp + "/services"));
     }
 
-    std::string service(const std::string &server_name, const std::string &service_name)
+    std::string remotepath::service(const std::string &service_name) const
     {
-        std::string services_path = services(server_name);
+        std::string services_path = services();
         return (services_path.empty() ? "" : (services_path + "/" + service_name));
     }
 
-    std::string service_config(const std::string &server_name, const std::string &service_name) 
+    std::string remotepath::service_config(const std::string &service_name) const
     {
-        std::string service_path = service(server_name, service_name);
+        std::string service_path = service(service_name);
         return (service_path.empty() ? "" : (service_path + "/config"));
     }
 
-    std::string service_template(const std::string &server_name, const std::string &service_name) 
+    std::string remotepath::service_template(const std::string &service_name) const
     {
-        std::string service_path = service(server_name, service_name);
+        std::string service_path = service(service_name);
         return (service_path.empty() ? "" : (service_path + "/template"));
     }
 
-    std::string backups(const std::string &server_name) 
+    std::string remotepath::backups() const
     {
-        std::string dsp = DROPSHELL_DIR(server_name);
+        std::string dsp = DROPSHELL_DIR();
         return (dsp.empty() ? "" : (dsp + "/backups"));
     }
 
-    std::string temp_files(const std::string &server_name)
+    std::string remotepath::temp_files() const
     {
-        std::string dsp = DROPSHELL_DIR(server_name);
+        std::string dsp = DROPSHELL_DIR();
         return (dsp.empty() ? "" : (dsp + "/temp_files"));
     }
 
-    std::string agent(const std::string &server_name)
+    std::string remotepath::agent() const
     {
-        std::string dsp = DROPSHELL_DIR(server_name);
+        std::string dsp = DROPSHELL_DIR();
         return (dsp.empty() ? "" : (dsp + "/agent"));
     }
 
-    std::string service_env(const std::string &server_name, const std::string &service_name) 
+    // ------------------------------------------------------------------------------------------
+    // Utility functions
+
+    std::string get_parent(const std::filesystem::path path)
     {
-        std::string service_path = service_config(server_name, service_name);
+        if (path.empty())
-        return (service_path.empty() ? "" : (service_path + "/service.env"));
+            return std::string();
+        return path.parent_path().string();
     }
-} // namespace remotepath
 
-
+    std::string get_child(const std::filesystem::path path)
-// ------------------------------------------------------------------------------------------
+    {
-// Utility functions
+        if (path.empty())
-
+            return std::string();
-std::string get_parent(const std::filesystem::path path)
+        return path.filename().string();
-{
+    }
-    if (path.empty())
-        return std::string();
-    return path.parent_path().string();
-}
-
-std::string get_child(const std::filesystem::path path)
-{
-    if (path.empty())
-        return std::string();
-    return path.filename().string();
-}
 
 } // namespace dropshell

source/src/utils/directories.hpp

@@ -11,12 +11,28 @@ namespace dropshell {
     //------------------------------------------------------------------------------------------------
     // local user config directories
         
-    // ~/.config/dropshell/dropshell.json
+    // ~/.dropshell
+    //    |-- dropshell.json
+    //    |-- agent-local
+    //        |-- agent-install.sh
+    //        |-- bb64  (only used locally, as it's for the local machine's architecture!)
+    //        |-- template_example
+    //    |-- agent-remote
+    //        |-- (remote agent files, including _allservicesstatus.sh)
+    //    |-- temp_files
+    //    |-- template_cache
+    //        |-- templates
+    //        |   |-- <template_name>.json
+    //        |   |-- <template_name>
+    //        |       |-- (...script files...)
+    //        |       |-- config
+    //        |           |-- service.env
+    //        |           |-- .template_info.env
+    //        |           |-- (...other service config files...)
+
+    // backups_path
+    //    |-- katie-_-squashkiwi-_-squashkiwi-test-_-2025-04-28_21-23-59.tgz
 
-    // ~/.local/dropshell_agent
-    //    |-- bb64  (only used locally, as it's for the local machine's architecture!)
-    //    |-- files_for_remote_agent
-    //        |-- (other agent files, including _allservicesstatus.sh)
 
     // server_definition_path
     //    |-- <server_name>
@@ -27,41 +43,38 @@ namespace dropshell {
     //                |-- .template_info.env
     //                |-- (...other config files for specific server&service...)
     
-    // backup path
+    namespace filenames {
-    //    |-- katie-_-squashkiwi-_-squashkiwi-test-_-2025-04-28_21-23-59.tgz
+        static const std::string template_info_env = ".template_info.env";
- 
+        static const std::string service_env = "service.env";
-    // temp files path
+        static const std::string readme = "README.txt";
-
+        static const std::string server_json = "server.json";
-    // template cache path
+        static const std::string dropshell_json = "dropshell.json";
-    //    |-- templates
+    } // namespace filenames.
-    //    |   |-- <template_name>.json
-    //    |   |-- <template_name>
-    //    |       |-- (...script files...)
-    //    |       |-- _default.env
-    //    |       |-- config
-    //    |           |-- service.env
-    //    |           |-- .template_info.env
-    //    |           |-- (...other service config files...)
-    //    |-- remote_versions
-    //    |   |-- server_name-service_name.json
 
     namespace localfile {
-        // ~/.config/dropshell/dropshell.json
         std::string dropshell_json();
         std::string server_json(const std::string &server_name);
         std::string service_env(const std::string &server_name, const std::string &service_name);
         std::string template_info_env(const std::string &server_name, const std::string &service_name);
+        std::string template_example();
+        std::string bb64();
     } // namespace localfile
 
     namespace localpath {
+        std::string dropshell_dir();
+
         std::string server(const std::string &server_name);
         std::string service(const std::string &server_name, const std::string &service_name);
 
-        std::string remote_versions(const std::string &server_name, const std::string &service_name);
+        std::string agent_local();
-
+        std::string agent_remote();
-        std::string agent();
-        std::string files_for_remote_agent();
         std::string current_user_home();
+
+        std::string backups();
+        std::string temp_files();
+        std::string template_cache();
+
+        bool create_directories();
     } // namespace local
 
 
@@ -79,27 +92,36 @@ namespace dropshell {
     //               |-- service.env (actual service config)
     //               |-- .template_info.env
     //           |-- template
-    //               |-- _default.env
     //               |-- (script files)
     //               |-- config
     //                   |-- service.env (default service config)
     //                   |-- .template_info.env
     //                   |-- (other config files for specific server&service)
 
-    namespace remotefile {
+    class remotefile {
-        std::string service_env(const std::string &server_name, const std::string &service_name);
+        public:
-    } // namespace remotefile
+            remotefile(const std::string &server_name, const std::string &user);
+            std::string service_env(const std::string &service_name) const;
+        private:
+            std::string mServer_name;
+            std::string mUser;
+    };
 
-    namespace remotepath {
+    class remotepath {
-        std::string DROPSHELL_DIR(const std::string &server_name);
+        public: 
-        std::string services(const std::string &server_name);
+            remotepath(const std::string &server_name, const std::string &user);
-        std::string service(const std::string &server_name, const std::string &service_name);
+            std::string DROPSHELL_DIR() const;
-        std::string service_config(const std::string &server_name, const std::string &service_name);
+            std::string services() const;
-        std::string service_template(const std::string &server_name, const std::string &service_name);
+            std::string service(const std::string &service_name) const;
-        std::string backups(const std::string &server_name);
+            std::string service_config(const std::string &service_name) const;
-        std::string temp_files(const std::string &server_name);
+            std::string service_template(const std::string &service_name) const;
-        std::string agent(const std::string &server_name);
+            std::string backups() const;
-    } // namespace remotepath
+            std::string temp_files() const;
+            std::string agent() const;
+        private:
+            std::string mServer_name;
+            std::string mUser;
+    };
 
     //------------------------------------------------------------------------------------------------
     // utility functions

source/src/utils/execute.cpp

@@ -6,7 +6,7 @@
 #include <string>
 #include <cstdlib>
 #include <sstream>
-#include "utils/assert.hpp"
+#include <libassert/assert.hpp>
 
 #include "execute.hpp"
 #include "utils/utils.hpp"
@@ -29,7 +29,7 @@ namespace dropshell
     {
         if (command.get_command_to_run().empty())
             return false;
-        std::string full_command = command.construct_cmd(localpath::agent()+"/bb64"); // Get the command string
+        std::string full_command = command.construct_cmd(localfile::bb64()); // Get the command string
 
         pid_t pid = fork();
 
@@ -130,7 +130,7 @@ namespace dropshell
 
         std::string full_cmd;
         if (!hasFlag(mode, cMode::NoBB64))
-            full_cmd = command.construct_cmd(localpath::agent()+"/bb64");
+            full_cmd = command.construct_cmd(localfile::bb64());
         else
             full_cmd = command.construct_cmd("");
 
@@ -165,13 +165,13 @@ namespace dropshell
             return false;
 
         std::stringstream ssh_cmd;
-        ssh_cmd << "ssh -p " << ssh_info.port << " " << (hasFlag(mode, cMode::Interactive) ? "-tt " : "")
+        ssh_cmd << "ssh -p " << ssh_info.get_port() << " " << (hasFlag(mode, cMode::Interactive) ? "-tt " : "")
-                << ssh_info.user << "@" << ssh_info.host;
+                << ssh_info.get_user() << "@" << ssh_info.get_host();
 
         std::string remote_bb64_path;
 
         if (!hasFlag(mode, cMode::NoBB64))
-            remote_bb64_path = remotepath::agent(ssh_info.server_ID) + "/bb64";
+            remote_bb64_path = remotepath(ssh_info.get_server_ID(), ssh_info.get_user()).agent() + "/bb64";
 
         bool rval = execute_local_command(
             "",                                                                    // local directory to run in
@@ -183,7 +183,7 @@ namespace dropshell
 
         if (!rval && !hasFlag(mode, cMode::Silent))
         {
-            error << "Error: Failed to execute ssh command:" << std::endl;
+            error << "Failed to execute ssh command:" << std::endl;
             debug << ssh_cmd.str() + " " + remote_command.construct_cmd(remote_bb64_path) << std::endl;
         }
         return rval;
@@ -237,4 +237,15 @@ namespace dropshell
         return cmdstr;
     }
 
+    bool sSSHInfo::valid() const
+    {
+    if (host.empty() || user.empty() || port.empty() || server_ID.empty() || user_dir.empty())
+        return false;
+
+    if (atoi(port.c_str()) == 0)
+        return false;
+
+    return true;
+    }
+
 } // namespace dropshell

source/src/utils/execute.hpp

@@ -24,12 +24,25 @@ inline cMode operator|=(cMode & lhs, cMode rhs) {return lhs = lhs | rhs;}
 inline bool hasFlag(cMode mode, cMode flag) {return (mode & flag) == flag;}
 
 
-typedef struct sSSHInfo {
+class sSSHInfo {
-    std::string host;
+    public:
-    std::string user;
+        sSSHInfo(std::string host, std::string user, std::string port, std::string server_ID, std::string user_dir) : 
-    std::string port;
+            host(host), user(user), port(port), server_ID(server_ID), user_dir(user_dir) {}
-    std::string server_ID; // dropshell name for server.
+
-} sSSHInfo;
+        std::string get_host() const { return host; }
+        std::string get_user() const { return user; }
+        std::string get_port() const { return port; }
+        std::string get_server_ID() const { return server_ID; }
+        std::string get_user_dir() const { return user_dir; }
+
+        bool valid() const;
+    private:
+        std::string host;
+        std::string user;
+        std::string port;
+        std::string server_ID; // dropshell name for server.
+        std::string user_dir; // dropshell directory for the user.
+};
 
 bool execute_local_command(std::string directory_to_run_in, std::string command_to_run, const std::map<std::string, std::string> & env_vars, std::string * output = nullptr, cMode mode = cMode::Defaults);
 bool execute_ssh_command(const sSSHInfo & ssh_info, const sCommand & remote_command, cMode mode = cMode::Defaults, std::string * output = nullptr);

source/src/utils/hash.cpp

@@ -3,6 +3,8 @@
 #define XXH_INLINE_ALL
 #include "contrib/xxhash.hpp"
 
+#include "output.hpp"
+
 #include <fstream>
 #include <filesystem>
 #include <iostream>
@@ -13,7 +15,7 @@ uint64_t hash_file(const std::string &path) {
     // Create hash state
     XXH64_state_t* const state = XXH64_createState();
     if (state == nullptr) {
-        std::cerr << "Failed to create hash state" << std::endl;
+        error << "Failed to create hash state" << std::endl;
         return 0;
     }
 
@@ -24,7 +26,7 @@ uint64_t hash_file(const std::string &path) {
     // Open file
     std::ifstream file(path, std::ios::binary);
     if (!file.is_open()) {
-        std::cerr << "Failed to open file: " << path << std::endl;
+        error << "Failed to open file: " << path << std::endl;
         XXH64_freeState(state);
         return 0;
     }
@@ -34,7 +36,7 @@ uint64_t hash_file(const std::string &path) {
     char buffer[buffer_size];
     while (file.read(buffer, buffer_size)) {
         if (XXH64_update(state, buffer, file.gcount()) == XXH_ERROR) {
-            std::cerr << "Failed to update hash" << std::endl;
+            error << "Failed to update hash" << std::endl;
             XXH64_freeState(state);
             return 0;
         }
@@ -43,7 +45,7 @@ uint64_t hash_file(const std::string &path) {
     // Handle any remaining bytes
     if (file.gcount() > 0) {
         if (XXH64_update(state, buffer, file.gcount()) == XXH_ERROR) {
-            std::cerr << "Failed to update hash" << std::endl;
+            error << "Failed to update hash" << std::endl;
             XXH64_freeState(state);
             return 0;
         }
@@ -59,14 +61,14 @@ uint64_t hash_directory_recursive(const std::string &path) {
     // Create hash state
     XXH64_state_t* const state = XXH64_createState();
     if (state == nullptr) {
-        std::cerr << "Failed to create hash state" << std::endl;
+        error << "Failed to create hash state" << std::endl;
         return 0;
     }
 
     // Initialize state with seed 0
     XXH64_hash_t const seed = 0;   /* or any other value */
     if (XXH64_reset(state, seed) == XXH_ERROR) {
-        std::cerr << "Failed to reset hash state" << std::endl;
+        error << "Failed to reset hash state" << std::endl;
         XXH64_freeState(state);
         return 0;
     }
@@ -81,7 +83,7 @@ uint64_t hash_directory_recursive(const std::string &path) {
             }
         }
     } catch (const std::filesystem::filesystem_error& e) {
-        std::cerr << "Filesystem error: " << e.what() << std::endl;
+        error << "Filesystem error: " << e.what() << std::endl;
         XXH64_freeState(state);
         return 0;
     }
@@ -94,7 +96,7 @@ uint64_t hash_directory_recursive(const std::string &path) {
 
 uint64_t hash_path(const std::string &path) {
     if (!std::filesystem::exists(path)) {
-        std::cerr << "Path does not exist: " << path << std::endl;
+        error << "Path does not exist: " << path << std::endl;
         return 0;
     }
 
@@ -103,28 +105,28 @@ uint64_t hash_path(const std::string &path) {
     } else if (std::filesystem::is_regular_file(path)) {
         return hash_file(path);
     } else {
-        std::cerr << "Path is neither a file nor a directory: " << path << std::endl;
+        error << "Path is neither a file nor a directory: " << path << std::endl;
         return 0;
     }
 }
 
 void hash_demo(const std::string & path)
 {
-    std::cout << "Hashing path: " << path << std::endl;
+    info << "Hashing path: " << path << std::endl;
     auto start = std::chrono::high_resolution_clock::now();
     XXH64_hash_t hash = hash_path(path);
     auto end = std::chrono::high_resolution_clock::now();
     auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
-    std::cout << "Hash: " << hash << " (took " << duration.count() << "ms)" << std::endl;
+    info << "Hash: " << hash << " (took " << duration.count() << "ms)" << std::endl;
 }
 
 int hash_demo_raw(const std::string & path)
 {
     if (!std::filesystem::exists(path)) {
-        std::cout << 0 <<std::endl; return 1;
+        info << 0 <<std::endl; return 1;
     }
     XXH64_hash_t hash = hash_path(path);
-    std::cout << hash << std::endl;
+    info << hash << std::endl;
     return 0;
 }
 

source/src/utils/json_fwd.hpp

@@ -1,187 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
-#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
-
-#include <cstdint> // int64_t, uint64_t
-#include <map> // map
-#include <memory> // allocator
-#include <string> // string
-#include <vector> // vector
-
-// #include <nlohmann/detail/abi_macros.hpp>
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013 - 2025 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-
-
-// This file contains all macro definitions affecting or depending on the ABI
-
-#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK
-    #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)
-        #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 12 || NLOHMANN_JSON_VERSION_PATCH != 0
-            #warning "Already included a different version of the library!"
-        #endif
-    #endif
-#endif
-
-#define NLOHMANN_JSON_VERSION_MAJOR 3   // NOLINT(modernize-macro-to-enum)
-#define NLOHMANN_JSON_VERSION_MINOR 12  // NOLINT(modernize-macro-to-enum)
-#define NLOHMANN_JSON_VERSION_PATCH 0   // NOLINT(modernize-macro-to-enum)
-
-#ifndef JSON_DIAGNOSTICS
-    #define JSON_DIAGNOSTICS 0
-#endif
-
-#ifndef JSON_DIAGNOSTIC_POSITIONS
-    #define JSON_DIAGNOSTIC_POSITIONS 0
-#endif
-
-#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
-    #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
-#endif
-
-#if JSON_DIAGNOSTICS
-    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
-#else
-    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS
-#endif
-
-#if JSON_DIAGNOSTIC_POSITIONS
-    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS _dp
-#else
-    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS
-#endif
-
-#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
-    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp
-#else
-    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
-#endif
-
-#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
-    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
-#endif
-
-// Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) json_abi ## a ## b ## c
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c)
-
-#define NLOHMANN_JSON_ABI_TAGS                                       \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
-            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
-            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \
-            NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS)
-
-// Construct the namespace version component
-#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
-    _v ## major ## _ ## minor ## _ ## patch
-#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \
-    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)
-
-#if NLOHMANN_JSON_NAMESPACE_NO_VERSION
-#define NLOHMANN_JSON_NAMESPACE_VERSION
-#else
-#define NLOHMANN_JSON_NAMESPACE_VERSION                                 \
-    NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \
-                                           NLOHMANN_JSON_VERSION_MINOR, \
-                                           NLOHMANN_JSON_VERSION_PATCH)
-#endif
-
-// Combine namespace components
-#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b
-#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \
-    NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)
-
-#ifndef NLOHMANN_JSON_NAMESPACE
-#define NLOHMANN_JSON_NAMESPACE               \
-    nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \
-            NLOHMANN_JSON_ABI_TAGS,           \
-            NLOHMANN_JSON_NAMESPACE_VERSION)
-#endif
-
-#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN
-#define NLOHMANN_JSON_NAMESPACE_BEGIN                \
-    namespace nlohmann                               \
-    {                                                \
-    inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \
-                NLOHMANN_JSON_ABI_TAGS,              \
-                NLOHMANN_JSON_NAMESPACE_VERSION)     \
-    {
-#endif
-
-#ifndef NLOHMANN_JSON_NAMESPACE_END
-#define NLOHMANN_JSON_NAMESPACE_END                                     \
-    }  /* namespace (inline namespace) NOLINT(readability/namespace) */ \
-    }  // namespace nlohmann
-#endif
-
-
-/*!
-@brief namespace for Niels Lohmann
-@see https://github.com/nlohmann
-@since version 1.0.0
-*/
-NLOHMANN_JSON_NAMESPACE_BEGIN
-
-/*!
-@brief default JSONSerializer template argument
-
-This serializer ignores the template arguments and uses ADL
-([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
-for serialization.
-*/
-template<typename T = void, typename SFINAE = void>
-struct adl_serializer;
-
-/// a class to store JSON values
-/// @sa https://json.nlohmann.me/api/basic_json/
-template<template<typename U, typename V, typename... Args> class ObjectType =
-         std::map,
-         template<typename U, typename... Args> class ArrayType = std::vector,
-         class StringType = std::string, class BooleanType = bool,
-         class NumberIntegerType = std::int64_t,
-         class NumberUnsignedType = std::uint64_t,
-         class NumberFloatType = double,
-         template<typename U> class AllocatorType = std::allocator,
-         template<typename T, typename SFINAE = void> class JSONSerializer =
-         adl_serializer,
-         class BinaryType = std::vector<std::uint8_t>, // cppcheck-suppress syntaxError
-         class CustomBaseClass = void>
-class basic_json;
-
-/// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document
-/// @sa https://json.nlohmann.me/api/json_pointer/
-template<typename RefStringType>
-class json_pointer;
-
-/*!
-@brief default specialization
-@sa https://json.nlohmann.me/api/json/
-*/
-using json = basic_json<>;
-
-/// @brief a minimal map-like container that preserves insertion order
-/// @sa https://json.nlohmann.me/api/ordered_map/
-template<class Key, class T, class IgnoredLess, class Allocator>
-struct ordered_map;
-
-/// @brief specialization that maintains the insertion order of object keys
-/// @sa https://json.nlohmann.me/api/ordered_json/
-using ordered_json = basic_json<nlohmann::ordered_map>;
-
-NLOHMANN_JSON_NAMESPACE_END
-
-#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_

source/src/utils/output.cpp

@@ -42,7 +42,7 @@ namespace dropshell
             std::lock_guard<std::mutex> lock(output_mutex);
             if (c == EOF)
                 return !EOF;
-            if (at_line_start_ && c != '\n')
+            if (at_line_start_) // && c != '\n')
             {
                 dest_ << GREY << tag_ << RESET << ' ' << colour_;
                 at_line_start_ = false;

source/src/utils/tableprint.cpp

@@ -147,6 +147,27 @@ void tableprint::set_title(const std::string title) {
     this->title = title;
 }
 
+// gives the columns to sort by, starting at 0.
+void tableprint::sort(std::vector<int> sort_columns)
+{
+    // Skip header row and sort remaining rows
+    if (rows.size() <= 1) return;  // Only header or empty table
+
+    // Create a custom comparator that compares rows based on the specified columns
+    auto comparator = [this, &sort_columns](const std::vector<std::string>& a, const std::vector<std::string>& b) {
+        for (int col : sort_columns) {
+            if (col >= 0 && col < a.size() && col < b.size()) {
+                int cmp = a[col].compare(b[col]);
+                if (cmp != 0) return cmp < 0;
+            }
+        }
+        return false;  // Equal rows maintain original order
+    };
+
+    // Sort rows starting from index 1 (after header)
+    std::sort(rows.begin() + 1, rows.end(), comparator);
+}
+
 void tableprint::add_row(const std::vector<std::string>& row) {
     std::vector<std::string> trimmed_row;
     for (const auto& cell : row) {

source/src/utils/tableprint.hpp

@@ -16,6 +16,7 @@ class tableprint {
         void add_row(const std::vector<std::string>& row);
         void print();
         void set_title(const std::string title);
+        void sort(std::vector<int> sort_columns);
     private:
         std::vector<std::vector<std::string>> rows;
         std::string title;

source/src/utils/utils.cpp

@@ -1,4 +1,8 @@
 #include "utils.hpp"
+#include "httplib.hpp"
+#include <nlohmann/json.hpp>
+
+
 #include <iostream>
 #include <string>
 #include <fstream>
@@ -7,6 +11,10 @@
 #include <filesystem>
 #include <regex>
 #include <random>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <cctype>
+#include <sstream>
 
 namespace dropshell {
 
@@ -32,7 +40,7 @@ bool replace_line_in_file(const std::string& file_path, const std::string& searc
     std::string line;
 
     if (!input_file.is_open()) {
-        std::cerr << "Error: Unable to open file: " << file_path << std::endl;
+        error << "Unable to open file: " << file_path << std::endl;
         return false;
     }
 
@@ -47,7 +55,7 @@ bool replace_line_in_file(const std::string& file_path, const std::string& searc
     std::ofstream output_file(file_path);
     if (!output_file.is_open())
     {
-        std::cerr << "Error: Unable to open file: " << file_path << std::endl;
+        error << "Unable to open file: " << file_path << std::endl;
         return false;
     }
     for (const auto& modified_line : file_lines)
@@ -148,7 +156,7 @@ int str2int(const std::string &str)
     try {
         return std::stoi(str);
     } catch (const std::exception& e) {
-        std::cerr << "Error: Invalid integer string: [" << str << "]" << std::endl;
+        error << "Invalid integer string: [" << str << "]" << std::endl;
         return 0;
     }
 }
@@ -286,29 +294,6 @@ std::vector<std::string> split(const std::string& str, const std::string& delimi
     return tokens;
 }
 
-
-std::string replace_with_environment_variables_like_bash(std::string str) {
-    // Combined regex pattern for both ${var} and $var formats
-    std::regex var_pattern("\\$(?:\\{([^}]+)\\}|([a-zA-Z0-9_]+))");
-    std::string result = str;
-    std::smatch match;
-    
-    while (std::regex_search(result, match, var_pattern)) {
-        // match[1] will contain capture from ${var} format
-        // match[2] will contain capture from $var format
-        std::string var_name = match[1].matched ? match[1].str() : match[2].str();
-        
-        // Get value from system environment variables
-        const char* env_value = std::getenv(var_name.c_str());
-        std::string value = env_value ? env_value : "";
-        
-        result = result.replace(match.position(), match.length(), value);
-    }
-
-    // dequote the result
-    return result;
-}
-
 std::string random_alphanumeric_string(int length)
 {
     static std::mt19937 generator(std::random_device{}());
@@ -327,8 +312,9 @@ std::string requote(std::string str) {
 }
 
 
-int die(const std::string & msg) {
+int return_die(const std::string & msg) {
-    std::cerr << msg << std::endl;
+    error << "Fatal error:" << std::endl;
+    error << msg << std::endl;
     return 1;
 }
 
@@ -366,5 +352,322 @@ std::string center_align(const std::string & str, int width) {
 }
 
 
+std::string replace_with_environment_variables_like_bash(std::string str) {
+    // Combined regex pattern for both ${var} and $var formats
+    std::regex var_pattern("\\$(?:\\{([^}]+)\\}|([a-zA-Z0-9_]+))");
+    std::string result = str;
+    std::smatch match;
+    
+    while (std::regex_search(result, match, var_pattern)) {
+        // match[1] will contain capture from ${var} format
+        // match[2] will contain capture from $var format
+        std::string var_name = match[1].matched ? match[1].str() : match[2].str();
+        
+        // Get value from system environment variables
+        const char* env_value = std::getenv(var_name.c_str());
+        std::string value = env_value ? env_value : "";
+        
+        result = result.replace(match.position(), match.length(), value);
+    }
+
+    // dequote the result
+    return result;
+}
+
+
+std::string substitute_provided_key_value_pairs(std::string str, const std::map<std::string, std::string> &env_vars)
+{
+    // Combined regex pattern for both ${var} and $var formats
+    std::regex var_pattern("\\$(?:\\{([^}]+)\\}|([a-zA-Z0-9_]+))");
+    std::string result = str;
+    std::smatch match;
+    
+    while (std::regex_search(result, match, var_pattern)) {
+        // match[1] will contain capture from ${var} format
+        // match[2] will contain capture from $var format
+        std::string var_name = match[1].matched ? match[1].str() : match[2].str();
+        
+        // Get value from environment variables map
+        auto it = env_vars.find(var_name);
+        std::string value = (it != env_vars.end()) ? it->second : "";
+        
+        result = result.replace(match.position(), match.length(), value);
+    }
+    
+    return result;
+}
+
+int get_console_width()
+{
+    struct winsize w;
+    if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &w) == 0) {
+        return w.ws_col;
+    }
+    // Fallback to a reasonable default if we can't get the width
+    return 80;
+}
+
+std::string remove_return(std::string str)
+{
+    str.erase(std::remove(str.begin(), str.end(), '\n'), str.end());
+    return str;
+}
+
+std::string get_line_wrap(std::string &src, int maxchars)
+{
+    if (src.empty())
+        return "";
+
+    if (src.length() <= maxchars)
+    {
+        std::string out = src;
+        src.erase();
+        return remove_return(out) + '\n';
+    }
+
+    // find last whitespace up to but not more than maxchars
+    size_t grab_to=maxchars;
+    size_t lastreturn = src.rfind('\n', maxchars);
+    size_t lastspace = src.rfind(' ', maxchars);
+    if (lastreturn != std::string::npos)
+        grab_to = lastreturn;
+    else if (lastspace != std::string::npos)
+        grab_to = lastspace;
+
+    std::string out = src.substr(0, grab_to);
+    src = src.substr(grab_to + 1);
+    return remove_return(out) + '\n';
+}
+
+std::string tolower(const std::string& str) {
+    if (str.empty()) return str;
+    
+    std::string result;
+    result.reserve(str.size());  // Pre-allocate space for efficiency
+    
+    for (unsigned char c : str) {
+        result.push_back(std::tolower(c));
+    }
+    return result;
+}
+
+// Common utility function to make HTTP requests
+struct HttpResult {
+    bool success;
+    int status;
+    std::string body;
+    std::string error;
+};
+
+HttpResult make_http_request(const std::string& url) {
+    try {
+        // Parse the URL to get host and path
+        std::string host;
+        std::string path;
+        size_t protocol_end = url.find("://");
+        if (protocol_end != std::string::npos) {
+            size_t host_start = protocol_end + 3;
+            size_t path_start = url.find('/', host_start);
+            if (path_start != std::string::npos) {
+                host = url.substr(host_start, path_start - host_start);
+                path = url.substr(path_start);
+            } else {
+                host = url.substr(host_start);
+                path = "/";
+            }
+        } else {
+            return {false, 0, "", "Invalid URL format"};
+        }
+
+        // Create HTTP client
+        httplib::Client cli(host);
+        cli.set_connection_timeout(10); // 10 second timeout
+
+        // Make GET request
+        auto res = cli.Get(path);
+        if (!res) {
+            return {false, 0, "", "Failed to connect to server"};
+        }
+        if (res->status != 200) {
+            return {false, res->status, "", "HTTP request failed with status " + std::to_string(res->status)};
+        }
+
+        return {true, res->status, res->body, ""};
+    } catch (const std::exception& e) {
+        return {false, 0, "", std::string("Exception: ") + e.what()};
+    }
+}
+
+bool download_file(const std::string &url, const std::string &destination) {
+    auto result = make_http_request(url);
+    if (!result.success) {
+        warning << "Failed to download file from URL: " << url << std::endl;
+        return false;
+    }
+
+    try {
+        std::ofstream out_file(destination, std::ios::binary);
+        if (!out_file) {
+            warning << "Failed to open file for writing: " << destination << std::endl;
+            return false;
+        }
+        out_file.write(result.body.c_str(), result.body.size());
+        out_file.close();
+        return true;
+    } catch (const std::exception& e) {
+        warning << "Failed to download file from URL: " << url << std::endl;
+        warning << "Exception: " << e.what() << std::endl;
+        return false;
+    }
+}
+
+nlohmann::json get_json_from_url(const std::string &url) {
+    auto result = make_http_request(url);
+    if (!result.success) {
+        warning << "Failed to get JSON from URL: " << url << std::endl;
+        return nlohmann::json();
+    }
+
+    try {
+        return nlohmann::json::parse(result.body);
+    } catch (const nlohmann::json::parse_error& e) {
+        warning << "Failed to parse JSON from URL: " << url << std::endl;
+        warning << "JSON: " << result.body << std::endl;
+        return nlohmann::json();
+    }
+}
+
+std::string get_string_from_url(const std::string &url) {
+    auto result = make_http_request(url);
+    if (!result.success) {
+        warning << "Failed to get string from URL: " << url << std::endl;
+        return std::string();
+    }
+    return result.body;
+}
+
+bool match_line(const std::string &line, const std::string &pattern) {
+    return trim(line) == trim(pattern);
+}
+
+// replace or append a block of text to a file, matching first and last lines if replacing.
+// edits file in-place.
+bool file_replace_or_add_segment(std::string filepath, std::string segment)
+{
+    // Create a backup of the original file
+    std::string backup_path = filepath + ".bak";
+    try {
+        std::filesystem::copy_file(filepath, backup_path, std::filesystem::copy_options::overwrite_existing);
+    } catch (const std::exception& e) {
+        std::cerr << "Error creating backup file: " << e.what() << std::endl;
+        return false;
+    }
+
+    // Handle empty segment
+    if (segment.empty()) {
+        error << "Empty segment provided" << std::endl;
+        return false;
+    }
+
+    // split the segment into lines
+    std::vector<std::string> segment_lines = split(segment, "\n");
+    // remove empty lines
+    segment_lines.erase(std::remove_if(segment_lines.begin(), segment_lines.end(), [](const std::string& line) {
+        return trim(line).empty();
+    }), segment_lines.end());
+    // remove any lines that are just whitespace
+    segment_lines.erase(std::remove_if(segment_lines.begin(), segment_lines.end(), [](const std::string& line) { return trim(line).empty(); }), segment_lines.end());
+    
+    // check that the segment has at least two lines
+    if (segment_lines.size() < 2) {
+        error << "Segment must contain at least two non-empty lines" << std::endl;
+        return false;
+    }
+
+    // Read the entire file into memory
+    std::ifstream input_file(filepath);
+    if (!input_file.is_open()) {
+        error << "Unable to open file: " << filepath << std::endl;
+        return false;
+    }
+
+    std::vector<std::string> file_lines;
+    std::string line;
+    while (std::getline(input_file, line)) {
+        file_lines.push_back(line);
+    }
+    input_file.close();
+
+    // Store original file size for verification
+    size_t original_size = file_lines.size();
+    if (original_size == 0) {
+        warning << "File is empty" << std::endl;
+    }
+
+    // Try to find the matching block
+    bool found_match = false;
+    for (size_t i = 0; i < file_lines.size(); i++) {
+        if (match_line(file_lines[i], segment_lines[0])) {
+            // Found potential start, look for end
+            for (size_t j = i + 1; j < file_lines.size(); j++) {
+                if (match_line(file_lines[j], segment_lines[segment_lines.size() - 1])) {
+                    // Found matching block, replace it
+                    file_lines.erase(file_lines.begin() + i, file_lines.begin() + j + 1);
+                    file_lines.insert(file_lines.begin() + i, segment_lines.begin(), segment_lines.end());
+                    
+                    found_match = true;
+                    break;
+                }
+            }
+            if (found_match) break;
+        }
+    }
+
+    // If no match found, append the segment
+    if (!found_match) {
+        file_lines.insert(file_lines.end(), segment_lines.begin(), segment_lines.end());
+    }
+
+    // Write back to file
+    std::ofstream output_file(filepath);
+    if (!output_file.is_open()) {
+        error << "Unable to open file for writing: " << filepath << std::endl;
+        return false;
+    }
+
+    for (const auto& line : file_lines) {
+        output_file << line << "\n";
+    }
+    output_file.close();
+
+    // If everything succeeded, remove the backup
+    try {
+        std::filesystem::remove(backup_path);
+    } catch (const std::exception& e) {
+        warning << "Could not remove backup file: " << e.what() << std::endl;
+    }
+
+    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

@@ -2,8 +2,10 @@
 
 #include <string>
 #include <vector>
+#include <map>
 
 #include "output.hpp"
+#include <nlohmann/json.hpp>
 
 namespace dropshell {
 
@@ -41,11 +43,9 @@ void ensure_directories_exist(std::vector<std::string> directories);
 std::vector<int> search(const std::string &pat, const std::string &txt);
 int count_substring(const std::string &substring, const std::string &text);
 
-std::string replace_with_environment_variables_like_bash(std::string str);
-
 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);
 
@@ -53,4 +53,29 @@ std::string left_align(const std::string & str, int width);
 std::string right_align(const std::string & str, int width);
 std::string center_align(const std::string & str, int width);
 
+std::string replace_with_environment_variables_like_bash(std::string str);
+std::string substitute_provided_key_value_pairs(std::string str, const std::map<std::string, std::string> & env_vars);
+
+int get_console_width();
+
+std::string get_line_wrap(std::string & src, int maxchars);
+
+std::string tolower(const std::string& str);
+
+bool download_file(const std::string& url, const std::string& destination);
+nlohmann::json get_json_from_url(const std::string& url);
+std::string get_string_from_url(const std::string& url);
+
+// replace or append a block of text to a file, matching first and last lines if replacing.
+bool file_replace_or_add_segment(std::string filepath, std::string segment);
+
+
+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
+