dropshell release 2025.0518.2245

.

.gitea/workflows/test.yaml

@@ -0,0 +1,23 @@
+name: Dropshell Test
+run-name: Test dropshell
+on: [push]
+
+jobs:
+  Build_and_Test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y openssh-server
+      - name: Check out repository code
+        uses: actions/checkout@v4
+      - name: Build
+        run: |
+          cd ${{ gitea.workspace }}/docker
+          ./compile.sh
+      - name: Test
+        run: |
+          cd ${{ gitea.workspace }}/docker/output
+          ./dropshell_x86_64 list
+          ./dropshell_x86_64 help

.gitignore

@@ -1,9 +1,12 @@
 # Build directories
 build/
+build_amd64/
+build_arm64/
 cmake-build-*/
 out/
 bin/
 lib/
+output/
 
 # Compiled Object files
 *.o

README.md

@@ -1,3 +1,32 @@
 # Dropshell
 
 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
+```
+
+This installs as dropshell, with a symlink ds if the ds command does not already exist.
+
+## Installation of Agent
+
+Install the Agent on each server you wish to manage. Supports amd64 (x86_64) and arm64 (aarch64) architectures.
+
+```
+curl -fsSL https://gitea.jde.nz/public/dropshell/releases/download/latest/server_autosetup.sh | sudo bash
+```
+
+Manual steps:
+1. `apt install curl wget jq`
+1. `curl -fsSL https://get.docker.com -o get-docker.sh && sh get-docker.sh && rm get-docker.sh`
+1. `useradd -m dropshell && usermod -aG docker dropshell && chsh -s /bin/bash dropshell`
+1. Put appropriate ssh keys in `/home/dropshell/.ssh/authorized_keys`
+1. Test ssh'ing into the server.
+
+
+## Install Services
+
+Set up a server and install a service:
+1. `ds create-server SERVERNAME`

cmake/FindxxHash.cmake

@@ -1,38 +0,0 @@
-# Find xxHash library
-#
-# This sets the following variables:
-#   xxHash_FOUND - True if xxHash was found
-#   xxHash_INCLUDE_DIRS - xxHash include directories
-#   xxHash_LIBRARIES - xxHash libraries
-
-find_path(xxHash_INCLUDE_DIR
-    NAMES xxhash.h
-    PATHS
-        /usr/include
-        /usr/local/include
-        /opt/local/include
-        ${CMAKE_INSTALL_PREFIX}/include
-    PATH_SUFFIXES xxhash
-)
-
-find_library(xxHash_LIBRARY
-    NAMES xxhash libxxhash
-    PATHS
-        /usr/lib
-        /usr/local/lib
-        /opt/local/lib
-        ${CMAKE_INSTALL_PREFIX}/lib
-)
-
-include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(xxHash
-    FOUND_VAR xxHash_FOUND
-    REQUIRED_VARS xxHash_LIBRARY xxHash_INCLUDE_DIR
-)
-
-if(xxHash_FOUND)
-    set(xxHash_LIBRARIES ${xxHash_LIBRARY})
-    set(xxHash_INCLUDE_DIRS ${xxHash_INCLUDE_DIR})
-endif()
-
-mark_as_advanced(xxHash_INCLUDE_DIR xxHash_LIBRARY) 

debian/changelog

@@ -1,8 +0,0 @@
-dropshell (1.0.0-1) unstable; urgency=medium
-
-  * Initial release.
-  * Converted from bash script to C++ implementation
-  * Added proper system status monitoring
-  * Improved server management functionality
-
- -- j842 Sun, 21 Apr 2025 12:00:00 +0000 

debian/control

@@ -1,15 +0,0 @@
-Source: dropshell
-Section: utils
-Priority: optional
-Maintainer: j842
-Build-Depends: debhelper (>= 10), cmake, libboost-all-dev
-Standards-Version: 4.5.0
-Homepage: https://github.com/j842/dropshell
-
-Package: dropshell
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}, libboost-program-options1.74.0, libboost-filesystem1.74.0, libboost-system1.74.0
-Description: A system management tool for server operations
- dropshell is a command-line tool for managing and monitoring servers.
- It provides functionality for checking system status, managing server
- configurations, and performing common administrative tasks. 

debian/copyright

@@ -1,26 +0,0 @@
-Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-Upstream-Name: dropshell
-Source: https://github.com/j842/dropshell
-
-Files: *
-Copyright: 2025 j842 
-License: MIT
-
-License: MIT
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
- .
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
- .
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE. 

debian/rules

@@ -1,14 +0,0 @@
-#!/usr/bin/make -f
-
-%:
-	dh $@
-
-override_dh_auto_configure:
-	dh_auto_configure -- -DCMAKE_BUILD_TYPE=Release
-
-override_dh_auto_install:
-	dh_auto_install
-	# Install bash completion
-	install -D -m 644 src/dropshell-completion.bash debian/dropshell/etc/bash_completion.d/dropshell
-	# Install configuration
-	install -D -m 644 src/dropshell.conf debian/dropshell/etc/dropshell.conf 

docker/dropshell_alpine/Dockerfile.build

@@ -1,21 +0,0 @@
-FROM alpine:latest
-
-RUN apk add --no-cache \
-    build-base \
-    cmake \
-    git \
-    ncurses-dev \
-    pkgconfig \
-    libtbb-dev \
-    xxhash-dev \
-    bash
-
-WORKDIR /app
-
-COPY . .
-
-COPY --chmod=755 docker/dropshell_alpine/_create_dropshell.sh /scripts/
-
-RUN rm -rf build
-
-CMD ["/bin/bash","/scripts/_create_dropshell.sh"]

docker/dropshell_alpine/Dockerfile.run

@@ -1,19 +0,0 @@
-FROM alpine:latest
-
-RUN apk add --no-cache \
-    libtbb \
-    xxhash-dev \
-    bash \
-    nano
-
-WORKDIR /app
-
-COPY docker/dropshell_alpine/output/dropshell /app/dropshell
-RUN /bin/bash -c "mkdir -p /opt/dropshell/templates && mkdir -p /config"
-COPY templates /opt/dropshell/templates
-COPY src/dropshell-completion.bash /etc/bash_completion.d/
-
-RUN /app/dropshell init /config
-RUN /app/dropshell version
-
-ENTRYPOINT ["/app/dropshell"]

docker/dropshell_alpine/_create_dropshell.sh

@@ -1,12 +0,0 @@
-#!/bin/bash
-set -x
-
-mkdir -p /app/build
-cd /app/build
-cmake .. -DCMAKE_BUILD_TYPE=Release
-make -j4
-cp /app/build/dropshell /output/
-
-chown $CHOWN_USER:$CHOWN_GROUP /output/dropshell
-
-/app/build/dropshell version

docker/dropshell_alpine/build.sh

@@ -1,23 +0,0 @@
-#!/bin/bash
-
-SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-
-ROOT_DIR=$(dirname $(dirname $SCRIPT_DIR))
-
-echo "Building dropshell from $ROOT_DIR"
-
-docker build -t dropshell_alpine_builder $ROOT_DIR -f $SCRIPT_DIR/Dockerfile.build
-
-rm -rf $SCRIPT_DIR/output
-mkdir -p $SCRIPT_DIR/output
-
-MYUID=$(id -u)  
-MYGID=$(id -g)
-
-docker run -it --env CHOWN_USER=$MYUID --env CHOWN_GROUP=$MYGID -v $SCRIPT_DIR/output:/output dropshell_alpine_builder 
-
-echo "dropshell built in $SCRIPT_DIR/output/dropshell"
-
-docker build -t gitea.jde.nz/j/dropshell_alpine:latest -t dropshell_alpine $ROOT_DIR -f $SCRIPT_DIR/Dockerfile.run
-
-docker run -it dropshell_alpine version

docker/dropshell_alpine/example.sh

@@ -1,13 +0,0 @@
-#!/bin/bash
-
-if [ $# -lt 1 ]; then
-	echo "	Use: example <dir>"
-	exit 0	
-fi
-
-
-(
-cd "$1"
-echo ZG9ja2VyIHJ1biAtdHQgLS1ybSAtdi46L3ggZ2l0ZWEuamRlLm56L2ovZHJvcHNoZWxsX2FscGluZSBoYXNoIC94 | base64 -d | bash
-)
-

docker/dropshell_alpine/publish.sh

@@ -1,3 +0,0 @@
-#!/bin/bash
-
-docker push gitea.jde.nz/j/dropshell_alpine:latest

install.sh

@@ -0,0 +1,50 @@
+#!/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"
+

install_prerequisites.sh

@@ -1,98 +0,0 @@
-#!/bin/bash
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# 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}"
-}
-
-# Check if running as root
-if [ "$EUID" -ne 0 ]; then
-    print_error "Please run this script as root (use sudo)"
-    exit 1
-fi
-
-# Detect distribution
-if [ -f /etc/os-release ]; then
-    . /etc/os-release
-    OS=$NAME
-    VER=$VERSION_ID
-else
-    print_error "Could not detect distribution"
-    exit 1
-fi
-
-print_status "Detected OS: $OS $VER"
-
-# 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 libtbb-dev libxxhash-dev"
-        ;;
-    *)
-        print_error "Unsupported distribution: $OS"
-        exit 1
-        ;;
-esac
-
-# Function to check if a package is installed
-is_package_installed() {
-    dpkg -l "$1" 2>/dev/null | grep -q "^ii"
-}
-
-# Install missing packages
-print_status "Checking and installing required packages..."
-for pkg in $PACKAGES; do
-    if ! is_package_installed "$pkg"; then
-        print_status "Installing $pkg..."
-        apt-get install -y "$pkg"
-        if [ $? -ne 0 ]; then
-            print_error "Failed to install $pkg"
-            exit 1
-        fi
-    else
-        print_status "$pkg is already installed"
-    fi
-done
-
-# Update package lists
-print_status "Updating package lists..."
-apt-get update
-
-# Verify all required tools are installed
-print_status "Verifying installation..."
-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
-
-# Check TBB installation
-if [ ! -d "/usr/include/tbb" ]; then
-    print_error "TBB headers not found"
-    exit 1
-fi
-
-# # Check Boost installation
-# if [ ! -d "/usr/include/boost" ]; then
-#     print_error "Boost headers not found"
-#     exit 1
-# fi
-
-print_status "All dependencies installed successfully!"
-print_status "You can now run ./build.sh to build the project" 

server_autosetup.sh

@@ -0,0 +1,96 @@
+# can you make this script run in bash, but fall back to sh if bash is not installed?
+
+# check if we are running as root
+if [ "$(id -u)" -ne 0 ]; then
+    echo "Please run the script with sudo privileges or as root."
+    exit 1
+fi
+
+# install bash if not already installed.
+if ! command -v bash > /dev/null 2>&1; then
+    echo "bash is not installed"
+    apt update
+    apt install -y bash
+fi
+
+# re-exec this script in bash if not already running in bash
+if [ -z "$BASH_VERSION" ]; then
+    echo "Re-executing script in Bash..."
+    exec /bin/bash "$0" "$@"
+fi
+
+if [ -n "$BASH_VERSION" ]; then
+    echo "Running in Bash $BASH_VERSION"
+else
+    echo "Not running in Bash"
+    exit 1
+fi
+
+# check if curl, wget, bash installed, and install if not
+PREREQUISITES=("curl" "wget" "jq")
+
+# check if all prerequisites are installed
+ALLINSTALLED=true
+for prerequisite in "${PREREQUISITES[@]}"; do
+    if ! command -v "${prerequisite}" &> /dev/null; then
+        echo "Prerequisite: ${prerequisite} is not installed."
+        ALLINSTALLED=false
+    fi
+done
+
+if [ "$ALLINSTALLED" = false ]; then
+    echo "Installing prerequisites..."
+    apt update
+    apt install -y "${PREREQUISITES[@]}"
+fi
+
+#--------------------------------
+
+# check docker installation
+if ! command -v docker &> /dev/null; then
+    echo "Docker is not installed."
+    echo "Installing docker..."
+    curl -fsSL https://get.docker.com -o get-docker.sh
+    sh get-docker.sh
+    rm get-docker.sh
+fi
+
+# check dropshell user exists
+if ! id "dropshell" &> /dev/null; then
+    echo "Dropshell user does not exist."
+    echo "Creating dropshell user..."
+    useradd -m dropshell
+fi
+
+# add dropshell user to docker group
+# check if already in docker group
+if ! id "dropshell" | grep -q "docker" &> /dev/null; then
+    echo "Adding dropshell user to docker group..."
+    usermod -aG docker dropshell
+fi
+
+# check .ssh/authorized_keys file exists
+if [ ! -f "/home/dropshell/.ssh/authorized_keys" ]; then
+    echo "Creating .ssh/authorized_keys file..."
+    mkdir -p /home/dropshell/.ssh
+    cp /root/.ssh/authorized_keys /home/dropshell/.ssh/authorized_keys
+    chown -R dropshell:dropshell /home/dropshell/.ssh
+    chmod 600 /home/dropshell/.ssh/authorized_keys
+fi
+
+# also check known_hosts file exists
+if [ ! -f "/home/dropshell/.ssh/known_hosts" ]; then
+    echo "Creating .ssh/known_hosts file..."
+    mkdir -p /home/dropshell/.ssh
+    touch /home/dropshell/.ssh/known_hosts
+fi
+
+# ensure default shell for dropshell user is bash
+chsh -s /bin/bash dropshell
+
+#--------------------------------
+
+echo "Installation complete."
+
+#--------------------------------
+

source/CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.10)
 project(dropshell VERSION 1.0.0 LANGUAGES CXX)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # Set default build type to Release if not specified
@@ -17,41 +17,58 @@ set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -DNDEBUG")
 string(TIMESTAMP CURRENT_YEAR "%Y")
 string(TIMESTAMP CURRENT_MONTH "%m")
 string(TIMESTAMP CURRENT_DAY "%d")
-set(PROJECT_VERSION "${CURRENT_YEAR}.${CURRENT_MONTH}.${CURRENT_DAY}")
+string(TIMESTAMP CURRENT_HOUR "%H")
+string(TIMESTAMP CURRENT_MINUTE "%M")
+set(PROJECT_VERSION "${CURRENT_YEAR}.${CURRENT_MONTH}${CURRENT_DAY}.${CURRENT_HOUR}${CURRENT_MINUTE}")
 string(TIMESTAMP RELEASE_DATE "%Y-%m-%d")
 
 # Configure version.hpp file
 configure_file(
     "${CMAKE_CURRENT_SOURCE_DIR}/src/version.hpp.in"
-    "${CMAKE_CURRENT_BINARY_DIR}/src/version.hpp"
+    "${CMAKE_CURRENT_BINARY_DIR}/src/autogen/version.hpp"
     @ONLY
 )
 
 # Set CMAKE_MODULE_PATH to include our custom find modules
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 
-# Find required packages
-find_package(TBB REQUIRED)
-find_package(xxHash REQUIRED)
-
 # Auto-detect source files
 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(run_createagent ALL
+    COMMAND ${CMAKE_COMMAND} -E echo "Running make_createagent.sh..."
+    COMMAND ${CMAKE_COMMAND} -E env bash ${CMAKE_CURRENT_SOURCE_DIR}/make_createagent.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)
 
 # Set include directories
+# build dir goes first so that we can use the generated version.hpp
 target_include_directories(dropshell PRIVATE 
-    src
-    ${CMAKE_CURRENT_BINARY_DIR}/src
-    ${xxHash_INCLUDE_DIRS}
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/src/autogen>
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/utils
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/contrib
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/commands
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/autogen
 )
 
+if(WIN32)
+  add_custom_command(
+    TARGET dropshell POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different
+    $<TARGET_FILE_DIR:dropshell>
+  )
+endif()
+
 # Link libraries
 target_link_libraries(dropshell PRIVATE
-    TBB::tbb
-    ${xxHash_LIBRARIES}
 )
 
 # Install targets
@@ -126,14 +143,3 @@ install(CODE "
         message(STATUS \"Command 'ds' not found. Skipping completion symlink.\")
     endif()
 ")
-
-# Create pre-install script to clean old templates
-install(CODE "
-    message(STATUS \"Removing old template files...\")
-    execute_process(COMMAND rm -rf /opt/dropshell/templates)
-")
-
-# Install templates with pre-install script
-install(DIRECTORY templates/
-    DESTINATION /opt/dropshell/templates
-)

source/agent/_allservicesstatus.sh

@@ -9,18 +9,30 @@
 # Get all services on the server
 SCRIPT_DIR="$(dirname "$0")"
 
+    # //------------------------------------------------------------------------------------------------
+    # // remote paths
     # // DROPSHELL_DIR
     # //   |-- backups
+    # //   |-- temp_files
+    # //   |-- agent
+    # //   |   |-- bb64
+    # //   |   |-- (other agent files, including _allservicesstatus.sh)
     # //   |-- services
     # //       |-- service name
-# //           |-- config  <-- this is passed as argument to all scripts
-# //               |-- service.env
+    # //           |-- config
+    # //               |-- service.env (actual service config)
+    # //               |-- .template_info.env
     # //           |-- template
+    # //               |-- _default.env
     # //               |-- (script files)
-# //               |-- example
-# //                   |-- service.env
+    # //               |-- config
+    # //                   |-- service.env (default service config)
+    # //                   |-- .template_info.env
     # //                   |-- (other config files for specific server&service)
 
+# Get all services on the server
+SERVICES_PATH=$(realpath "${SCRIPT_DIR}/../services/")
+
 CURRENT_OUTPUT=""
 CURRENT_EXIT_CODE=0
 
@@ -31,6 +43,15 @@ load_dotenv(){
     fi
 }
 
+_check_required_env_vars_allservicesstatus() {
+    local required_vars=("$@")
+    for var in "${required_vars[@]}"; do
+        if [ -z "${!var}" ]; then
+            _die "Required environment variable $var is not set"
+        fi
+    done
+}
+
 function run_command() {
     local service_path=$1
     local command=$2
@@ -44,14 +65,19 @@ function run_command() {
     # run the command in a subshell to prevent environment changes
     CURRENT_OUTPUT=$(
         set -a
+
         load_dotenv "${service_path}/template/_default.env"
         load_dotenv "${service_path}/config/service.env"
-        set +a
+        load_dotenv "${service_path}/config/.template_info.env"
 
         # update the main variables.
-        export CONFIG_PATH="${service_path}/config"
-        # SERVER is correct
-        export SERVICE="${SERVICE_NAME}"
+        CONFIG_PATH="${service_path}/config"
+        SERVICE="${SERVICE_NAME}"
+        DOCKER_CLI_HINTS=false
+
+        set +a
+
+        _check_required_env_vars_allservicesstatus "CONFIG_PATH" "SERVER" "SERVICE" "AGENT_PATH" "HOST_NAME" "TEMPLATE"
 
         if [ "$capture_output" = "true" ]; then
             # Capture and return output
@@ -73,8 +99,11 @@ function command_exists() {
     return 0
 }
 
-# Get all services on the server
-SERVICES_PATH=$(realpath "${SCRIPT_DIR}/../../")
+
+if [ ! -d "${SERVICES_PATH}" ]; then
+    echo "Services path does not exist: ${SERVICES_PATH}"
+    exit 0
+fi
 
 # Get all service names
 SERVICE_NAMES=$(ls "${SERVICES_PATH}")

source/agent/common.sh

@@ -0,0 +1,171 @@
+# COMMON FUNCTIONS
+# JDE
+# 2025-05-03
+
+# This file is available TO ***ALL*** templates, as ${AGENT_PATH}/_common.sh
+
+# ----------------------------------------------------------------------------------------------------------
+
+# summary of functions:
+#   _die "message"                         : Prints an error message in red and exits with status code 1.
+#   _grey_start                            : Switches terminal output color to grey.
+#   _grey_end                              : Resets terminal output color from grey.
+#   _create_and_start_container "<run_cmd>" <container_name> : Creates/starts a container, verifying it runs.
+#   _create_folder <folder_path>           : Creates a directory if it doesn't exist (chmod 777).
+#   _check_docker_installed               : Checks if Docker is installed, running, and user has permission. Returns 1 on failure.
+#   _is_container_exists <container_name> : Checks if a container (any state) exists. Returns 1 if not found.
+#   _is_container_running <container_name>: Checks if a container is currently running. Returns 1 if not running.
+#   _get_container_id <container_name>    : Prints the ID of the named container.
+#   _get_container_status <container_name>: Prints the status string of the named container.
+#   _start_container <container_name>     : Starts an existing, stopped container.
+#   _stop_container <container_name>      : Stops a running container.
+#   _remove_container <container_name>    : Stops (if needed) and removes a container.
+#   _get_container_logs <container_name>  : Prints the logs for a container.
+#   _check_required_env_vars "VAR1" ...    : Checks if listed environment variables are set; calls _die() if any are missing.
+#   _root_remove_tree <path>              : Removes a path using a root Docker container (for permissions).
+
+# ----------------------------------------------------------------------------------------------------------
+
+# Prints an error message in red and exits with status code 1.
+_die() {
+    echo -e "Error: $1"
+    exit 1
+}
+
+# Creates/starts a container, verifying it runs.
+_create_and_start_container() {
+    if [ -z "$1" ] || [ -z "$2" ]; then
+        _die "Template error: create_and_start_container <run_cmd> <container_name>"
+    fi
+
+    local run_cmd="$1"
+    local container_name="$2"
+
+    if _is_container_exists $container_name; then
+        _is_container_running $container_name && return 0
+        _start_container $container_name
+    else
+        $run_cmd
+    fi
+
+    if ! _is_container_running $container_name; then
+        _die "Container ${container_name} failed to start"
+    fi
+
+    ID=$(_get_container_id $container_name)
+    echo "Container ${container_name} is running with ID ${ID}"
+}
+
+# Creates a directory if it doesn't exist (chmod 777).
+_create_folder() {
+    local folder="$1"
+    if [ -d "$folder" ]; then
+        return 0
+    fi
+    if ! mkdir -p "$folder"; then
+        _die "Failed to create folder: $folder"
+    fi
+    chmod 777 "$folder"
+    echo "Folder created: $folder"
+}
+
+# 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
+}
+
+# Checks if a container (any state) exists. Returns 1 if not found.
+_is_container_exists() {
+    if ! docker ps -a --format "{{.Names}}" | grep -q "^$1$"; then
+        return 1
+    fi
+    return 0
+}
+
+# Checks if a container is currently running. Returns 1 if not running.
+_is_container_running() {
+    if ! docker ps --format "{{.Names}}" | grep -q "^$1$"; then
+        return 1
+    fi
+    return 0
+}
+
+# Prints the ID of the named container.
+_get_container_id() {
+    docker ps --format "{{.ID}}" --filter "name=$1"
+}
+
+# Prints the status string of the named container.
+_get_container_status() {
+    docker ps --format "{{.Status}}" --filter "name=$1"
+}
+
+# Starts an existing, stopped container.
+_start_container() {
+    _is_container_exists $1 || return 1
+    _is_container_running $1 && return 0
+    docker start $1
+}
+
+# Stops a running container.
+_stop_container() {
+    _is_container_running $1 || return 0;
+    docker stop $1
+}   
+
+# Stops (if needed) and removes a container.
+_remove_container() {
+    _stop_container $1
+    _is_container_exists $1 || return 0;
+    docker rm $1
+}
+
+# Prints the logs for a container.
+_get_container_logs() {
+    if ! _is_container_exists $1; then
+        echo "Container $1 does not exist"
+        return 1
+    fi
+
+    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
+            _die "Required environment variable $var is not set"
+        fi
+    done
+}
+
+# Removes a path using a root Docker container (for permissions).
+_root_remove_tree() {
+    local to_remove="$1"
+    parent=$(dirname "$to_remove")
+    abs_parent=$(realpath "$parent")
+    child=$(basename "$to_remove")
+    docker run --rm -v "$abs_parent":/data alpine rm -rf "/data/$child"
+}
+
+
+# Load autocommands
+source "${AGENT_PATH}/datacommands.sh"

source/agent/datacommands.sh

@@ -0,0 +1,189 @@
+#!/bin/bash
+
+# This script contains the common code for the autocommands.
+
+MYID=$(id -u)
+MYGRP=$(id -g)
+
+_autocommandrun_volume() {
+    local command="$1"
+    local volume_name="$2"
+    local backup_folder="$3"
+
+    case "$command" in
+        create)
+            echo "Creating volume ${volume_name}"
+            docker volume create ${volume_name}
+            ;;
+        nuke)
+            echo "Nuking volume ${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"
+            ;;
+        restore)
+            echo "Restoring volume ${volume_name}"
+            docker volume rm ${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"
+            ;;
+    esac
+}   
+
+_autocommandrun_path() {
+    local command="$1"
+    local path="$2"
+    local backup_folder="$3"
+
+    case "$command" in
+        create)
+            echo "Creating path ${path}"
+            mkdir -p ${path}
+            ;;
+        nuke)
+            echo "Nuking path ${path}"
+            local path_parent=$(dirname ${path})
+            local path_child=$(basename ${path})
+            if [ -d "${path_parent}/${path_child}" ]; then
+                docker run --rm -v ${path_parent}:/volume debian bash -c "rm -rf /volume/${path_child}" || echo "Failed to nuke path ${path}"
+            else
+                echo "Path ${path} does not exist - nothing to nuke"
+            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"
+            else
+                echo "Path ${path} does not exist - nothing to backup"
+            fi
+            ;;
+        restore)
+            echo "Restoring path ${path} from backup file ${backup_folder}/backup.tgz"
+            tar -xzvf ${backup_folder}/backup.tgz -C ${path} --strip-components=1
+            ;;
+    esac
+}
+
+_autocommandrun_file() {
+    local command="$1"
+    local filepath="$2"
+    local backup_folder="$3"
+
+    case "$command" in
+        create)
+            ;;
+        nuke)
+            rm -f ${filepath}
+            ;;
+        backup)
+            echo "Backing up file ${filepath}"
+            local file_parent=$(dirname ${filepath})
+            local 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"
+            else
+                echo "File ${filepath} does not exist - nothing to backup"
+            fi
+            ;;
+        restore)
+            echo "Restoring file ${filepath}"
+            local file_name=$(basename ${filepath})
+            cp ${backup_folder}/${file_name} ${filepath}
+            ;;
+    esac
+}
+
+_autocommandparse() {
+    # first argument is the command
+    # if the command is backup or restore, then the last two arguments are the backup file and the temporary path
+    # all other arguments are of form:
+    # key=value
+    # where key can be one of volume, path or file.
+    # value is the path or volume name.
+
+    # we iterate over the key=value arguments, and for each we call:
+    #    autorun <command> <backupfile> <key> <value>
+
+    local command="$1"
+    shift
+
+    local backup_temp_path="$1"
+    shift
+
+    echo "autocommandparse: command=$command backup_temp_path=$backup_temp_path"
+
+    # Extract the backup file and temp path (last two arguments)
+    local args=("$@")
+    local arg_count=${#args[@]}
+    
+    # Process all key=value pairs
+    for ((i=0; i<$arg_count; i++)); do
+        local pair="${args[$i]}"
+        
+        # Skip if not in key=value format
+        if [[ "$pair" != *"="* ]]; then
+            continue
+        fi
+        
+        local key="${pair%%=*}"
+        local value="${pair#*=}"
+
+        # create backup folder unique to key/value.
+        local bfolder=$(echo "${key}_${value}" | tr -cd '[:alnum:]_-')
+        local targetpath="${backup_temp_path}/${bfolder}"
+        mkdir -p ${targetpath}
+
+        # Key must be one of volume, path or file
+        case "$key" in
+            volume)
+                _autocommandrun_volume "$command" "$value" "$targetpath"
+                ;;
+            path)
+                _autocommandrun_path "$command" "$value" "$targetpath"
+                ;;
+            file)
+                _autocommandrun_file "$command" "$value" "$targetpath"
+                ;;
+            *)
+                _die "Unknown key $key passed to auto${command}. We only support volume, path and file."
+                ;;
+        esac
+    done
+}
+
+
+datacreate() {
+    _autocommandparse create none "$@"
+}
+
+
+datanuke() {
+    _autocommandparse nuke none "$@"
+}
+
+databackup() {
+    _check_required_env_vars "BACKUP_FILE" "TEMP_DIR"
+    BACKUP_TEMP_PATH="$TEMP_DIR/backup"
+
+
+    mkdir -p "$BACKUP_TEMP_PATH"
+    echo "_autocommandparse [backup] [$BACKUP_TEMP_PATH] [$@]"
+    _autocommandparse backup "$BACKUP_TEMP_PATH" "$@"
+
+    tar zcvf "$BACKUP_FILE" -C "$BACKUP_TEMP_PATH" .
+}
+
+datarestore() {
+    _check_required_env_vars "BACKUP_FILE" "TEMP_DIR"
+    BACKUP_TEMP_PATH="$TEMP_DIR/restore"
+
+    echo "_autocommandparse [restore] [$BACKUP_TEMP_PATH] [$@]"
+
+    mkdir -p "$BACKUP_TEMP_PATH"
+    tar zxvf "$BACKUP_FILE" -C "$BACKUP_TEMP_PATH" --strip-components=1
+
+    _autocommandparse restore "$BACKUP_TEMP_PATH" "$@"
+}

source/agent/selftest.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+echo "Running remote agent self-test..."
+
+echo "Completed remote agent self-test."
+
+exit 0

source/build.sh

@@ -9,15 +9,11 @@ GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 NC='\033[0m' # No Color
 
-# Parse command line arguments
-AUTO_INSTALL=false
-for arg in "$@"; do
-    case $arg in
-        --auto-install)
-            AUTO_INSTALL=true
-            ;;
-    esac
-done
+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
@@ -33,6 +29,9 @@ 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..."
@@ -74,12 +73,12 @@ fi
 
 # Configure with CMake
 print_status "Configuring with CMake..."
-#cmake .. -DCMAKE_BUILD_TYPE=Debug
-cmake .. -DCMAKE_BUILD_TYPE=Release
+cmake .. -DCMAKE_BUILD_TYPE=Debug
+#cmake .. -DCMAKE_BUILD_TYPE=Release
 
 # Build the project
 print_status "Building project..."
-make -j$(nproc)
+make -j"$JOBS"
 
 # Check if build was successful
 if [ $? -eq 0 ]; then
@@ -90,8 +89,6 @@ else
     exit 1
 fi
 
-# Check if user wants to install
-if [ $AUTO_INSTALL = true ]; then
 print_status "Auto-installing dropshell..."
 sudo make install
 if [ $? -eq 0 ]; then
@@ -100,20 +97,7 @@ if [ $AUTO_INSTALL = true ]; then
     print_error "Installation failed!"
     exit 1
 fi
-else
-    read -p "Do you want to install the program? (y/n) " -n 1 -r
-    echo
-    if [[ $REPLY =~ ^[Yy]$ ]]; then
-        print_status "Installing dropshell..."
-        sudo make install
-        if [ $? -eq 0 ]; then
-            print_status "Installation successful!"
-        else
-            print_error "Installation failed!"
-            exit 1
-        fi
-    fi
-fi
+
 
 # Return to original directory
 cd ..

source/install_build_prerequisites.sh

@@ -0,0 +1,150 @@
+#!/bin/bash
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# 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}"
+}
+
+# Check if running as root
+if [ "$EUID" -ne 0 ]; then
+    print_error "Please run this script as root (use sudo)"
+    exit 1
+fi
+
+# Detect distribution
+if [ -f /etc/os-release ]; then
+    . /etc/os-release
+    OS=$NAME
+    VER=$VERSION_ID
+else
+    print_error "Could not detect distribution"
+    exit 1
+fi
+
+print_status "Detected OS: $OS $VER"
+
+# 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"
+        ;;
+    *)
+        print_error "Unsupported distribution: $OS"
+        exit 1
+        ;;
+esac
+
+# Function to check if a package is installed
+is_package_installed() {
+    dpkg -l "$1" 2>/dev/null | grep -q "^ii"
+}
+
+# Update package lists
+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
+        print_status "Installing $pkg..."
+        apt-get install -y "$pkg"
+        if [ $? -ne 0 ]; then
+            print_error "Failed to install $pkg"
+            exit 1
+        fi
+    else
+        print_status "$pkg is already installed"
+    fi
+done
+
+# Verify all required tools are installed
+print_status "Verifying installation..."
+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)
+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
+if [ ! -d "$INSTALL_DIR/x86_64-linux-musl-cross" ]; then
+    echo "Downloading x86_64 musl cross toolchain..."
+    wget -nc -O "$TMPDIR/x86_64-linux-musl-cross.tgz" $MUSL_CC_URL/x86_64-linux-musl-cross.tgz
+    tar -C "$INSTALL_DIR" -xvf "$TMPDIR/x86_64-linux-musl-cross.tgz"
+fi
+
+# aarch64
+if [ ! -d "$INSTALL_DIR/aarch64-linux-musl-cross" ]; then
+    echo "Downloading aarch64 musl cross toolchain..."
+    wget -nc -O "$TMPDIR/aarch64-linux-musl-cross.tgz" $MUSL_CC_URL/aarch64-linux-musl-cross.tgz
+    tar -C "$INSTALL_DIR" -xvf "$TMPDIR/aarch64-linux-musl-cross.tgz"
+fi
+
+# Print instructions for adding to PATH
+# cat <<EOF
+
+# To use the musl cross compilers, add the following to your shell:
+# export PATH="$INSTALL_DIR/x86_64-linux-musl-cross/bin:$INSTALL_DIR/aarch64-linux-musl-cross/bin:$PATH"
+
+# Or run:
+#     export PATH="$INSTALL_DIR/x86_64-linux-musl-cross/bin:$INSTALL_DIR/aarch64-linux-musl-cross/bin:\$PATH"
+
+# EOF
+
+# Clean up
+rm -rf "$TMPDIR"
+
+# If run with sudo, add to invoking user's ~/.bashrc
+if [ -n "$SUDO_USER" ] && [ "$SUDO_USER" != "root" ]; then
+    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/make_createagent.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+set -e
+
+# This script creates two files:
+# src/utils/createagent.hpp
+# src/utils/createagent.cpp
+#
+
+SCRIPT_DIR=$(dirname "$0")
+
+# 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
+fi
+
+SCRIPT_DIR=$(dirname "$0")
+
+dehydrate "${SCRIPT_DIR}/agent" "${SCRIPT_DIR}/src/autogen"

source/multibuild.sh

@@ -0,0 +1,59 @@
+#!/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

@@ -0,0 +1,108 @@
+#!/bin/bash
+set -e
+
+# directory of this script
+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"
+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
+BUILD_DIR=$SCRIPT_DIR/build
+
+OLD_PWD=$PWD
+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
+
+echo "Publishing dropshell version $TAG"
+
+# make sure we've commited.
+git add "$SCRIPT_DIR/../" && git commit -m "dropshell release $TAG" && git push
+
+
+# Find repo info from .git/config
+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" \
+    -H "Content-Type: application/json" \
+    -H "Authorization: token $TOKEN" \
+    -d "$RELEASE_DATA" | grep -o '"id":[0-9]*' | head -1 | cut -d: -f2)
+
+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
+    if [ -f "output/$FILE" ]; then
+        filetoupload="output/$FILE"
+    elif [ -f "../$FILE" ]; then
+        filetoupload="../$FILE"
+    elif [ -f "$FILE" ]; then
+        filetoupload="$FILE"
+    else
+        echo "File $FILE not found!" >&2
+        continue
+    fi
+
+    # Auto-detect content type
+    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."
+
+cd $OLD_PWD

source/src/autocomplete.cpp

@@ -0,0 +1,120 @@
+#include "autocomplete.hpp"
+#include "servers.hpp"
+#include "config.hpp"
+#include "templates.hpp"
+#include "services.hpp"
+#include "servers.hpp"
+
+#include <assert.hpp>
+#include <algorithm>
+#include <iostream>
+
+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> service_commands_require_config = {"ssh","edit","nuke","_allservicesstatus"};
+
+    void merge_commands(std::set<std::string> &commands, const std::set<std::string> &new_commands)
+    {
+        commands.insert(new_commands.begin(), new_commands.end());
+    }
+
+    bool is_no_arg_cmd(std::string cmd)
+    {
+        return system_commands_noargs.find(cmd) != system_commands_noargs.end();
+    }
+
+bool autocomplete(const std::vector<std::string> &args)
+{
+    if (args.size() < 3) // dropshell autocomplete ???
+    {
+        autocomplete_list_commands();
+        return true;
+    }
+
+    ASSERT(args.size() >= 3, "Invalid number of arguments");
+    std::string cmd = args[2];
+
+    // std::cout<<" cmd = ["<<cmd<<"]"<<std::endl;
+
+    if (cmd=="hash")
+    {   // output files and folders in the current directory, one per line.
+        std::filesystem::directory_iterator dir_iter(std::filesystem::current_path());
+        for (const auto& entry : dir_iter) 
+            std::cout << entry.path().filename().string() << std::endl;        
+        return true;
+    }
+
+    if (autocomplete::is_no_arg_cmd(cmd))
+        return true; // no arguments needed.
+
+    if (!dropshell::gConfig().is_config_set())
+        return false; // can't help without working config.
+
+    if (args.size()==3) // we have the command but nothing else.  dropshell autocomplete command <server>
+    {
+        auto servers = dropshell::get_configured_servers();
+        for (const auto& server : servers) 
+            std::cout << server.name << std::endl;
+        return true;
+    }
+
+    if (args.size()==4) // we have the command and the server.  dropshell autocomplete command server <service>
+    {
+        std::string server = args[3];
+
+        if (cmd=="create-service")
+        { // create-service <server> <template> <service>
+            auto templates = dropshell::gTemplateManager().get_template_list();
+            for (const auto& t : templates)
+                std::cout << t << std::endl;
+            return true;
+        }
+
+        auto services = dropshell::get_server_services_info(server);
+        for (const auto& service : services) 
+            std::cout << service.service_name << std::endl;
+        return true;
+    }
+
+    if (args.size()==5) // we have the command and the server and the service.  dropshell autocomplete command server service_name <command?>
+    { 
+        std::string server_name = args[3];
+        std::string service_name = args[4];
+        if (cmd=="restore")
+        {
+            std::set<std::string> backups = dropshell::list_backups(server_name, service_name);
+            for (auto backup : backups) 
+                std::cout << backup << std::endl;
+            return true;
+        }
+
+        return false; // no more autocompletion possible - don't know what the argument is for.
+    }
+
+    // args>5 - no more autocompletion possible - don't know what the argument is for.
+    return false; // catch-all.
+}
+
+bool autocomplete_list_commands()
+{
+    std::set<std::string> commands;
+    dropshell::get_all_used_commands(commands);
+
+// add in commmands hard-coded and handled in main
+    autocomplete::merge_commands(commands, autocomplete::system_commands_always_available);
+
+    if (dropshell::gConfig().is_config_set()) 
+        autocomplete::merge_commands(commands, autocomplete::system_commands_require_config);
+
+    for (const auto& command : commands) {
+        std::cout << command << std::endl;
+    }
+    return true;
+}
+
+} // namespace autocomplete

source/src/autocomplete.hpp

@@ -0,0 +1,28 @@
+#ifndef AUTOCOMPLETE_HPP
+#define AUTOCOMPLETE_HPP
+
+#include <string>
+#include <vector>
+#include <set>
+
+namespace autocomplete {
+
+    extern const std::set<std::string> system_commands_noargs;
+    extern const std::set<std::string> system_commands_always_available;
+    extern const std::set<std::string> system_commands_require_config;
+    extern const std::set<std::string> system_commands_hidden;
+
+    extern const std::set<std::string> service_commands_require_config;
+
+    void merge_commands(std::set<std::string> &commands, const std::set<std::string> &new_commands);
+
+    bool is_no_arg_cmd(std::string cmd);
+
+    bool autocomplete(const std::vector<std::string> &args);
+
+    bool autocomplete_list_commands();
+
+}
+
+
+#endif

source/src/autogen/_agent.cpp

@@ -0,0 +1,443 @@
+#include <fstream>
+#include <filesystem>
+#include <string>
+#include <iostream>
+#include <cstring>
+
+/*
+
+   THIS FILE IS AUTO-GENERATED BY DEHYDRATE.
+   DO NOT EDIT THIS FILE.
+
+*/
+
+
+#include "_agent.hpp"
+namespace recreate_agent {
+
+
+// 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: selftest.sh
+        fs::path outpath = fs::path(destination_folder) / "selftest.sh";
+        static const char filedata_base64[] = "IyEvYmluL2Jhc2gKCmVjaG8gIlJ1bm5pbmcgcmVtb3RlIGFnZW50IHNlbGYtdGVzdC4uLiIKCmVj"\
+            "aG8gIkNvbXBsZXRlZCByZW1vdGUgYWdlbnQgc2VsZi10ZXN0LiIKCmV4aXQgMAo=";
+
+        // 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, 11594895391899191874ULL, std::filesystem::perms(493), decoded_data, actual_size);
+        delete[] decoded_data;
+        any_written = any_written || file_written;
+    }
+    {
+        // 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"\
+            "ICJybSAtcmYgL3ZvbHVtZS8ke3BhdGhfY2hpbGR9IiB8fCBlY2hvICJGYWlsZWQgdG8gbnVrZSBw"\
+            "YXRoICR7cGF0aH0iCiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgIGVjaG8gIlBhdGgg"\
+            "JHtwYXRofSBkb2VzIG5vdCBleGlzdCAtIG5vdGhpbmcgdG8gbnVrZSIKICAgICAgICAgICAgZmkK"\
+            "ICAgICAgICAgICAgOzsKICAgICAgICBiYWNrdXApCiAgICAgICAgICAgIGVjaG8gIkJhY2tpbmcg"\
+            "dXAgcGF0aCAke3BhdGh9IgogICAgICAgICAgICBpZiBbIC1kICIke3BhdGh9IiBdOyB0aGVuCiAg"\
+            "ICAgICAgICAgICAgICBkb2NrZXIgcnVuIC0tcm0gLXYgJHtwYXRofTovcGF0aCAtdiAke2JhY2t1"\
+            "cF9mb2xkZXJ9Oi9iYWNrdXAgZGViaWFuIGJhc2ggLWMgInRhciAtY3p2ZiAvYmFja3VwL2JhY2t1"\
+            "cC50Z3ogLUMgL3BhdGggLiAmJiBjaG93biAtUiAkTVlJRDokTVlHUlAgL2JhY2t1cCIKICAgICAg"\
+            "ICAgICAgZWxzZQogICAgICAgICAgICAgICAgZWNobyAiUGF0aCAke3BhdGh9IGRvZXMgbm90IGV4"\
+            "aXN0IC0gbm90aGluZyB0byBiYWNrdXAiCiAgICAgICAgICAgIGZpCiAgICAgICAgICAgIDs7CiAg"\
+            "ICAgICAgcmVzdG9yZSkKICAgICAgICAgICAgZWNobyAiUmVzdG9yaW5nIHBhdGggJHtwYXRofSBm"\
+            "cm9tIGJhY2t1cCBmaWxlICR7YmFja3VwX2ZvbGRlcn0vYmFja3VwLnRneiIKICAgICAgICAgICAg"\
+            "dGFyIC14enZmICR7YmFja3VwX2ZvbGRlcn0vYmFja3VwLnRneiAtQyAke3BhdGh9IC0tc3RyaXAt"\
+            "Y29tcG9uZW50cz0xCiAgICAgICAgICAgIDs7CiAgICBlc2FjCn0KCl9hdXRvY29tbWFuZHJ1bl9m"\
+            "aWxlKCkgewogICAgbG9jYWwgY29tbWFuZD0iJDEiCiAgICBsb2NhbCBmaWxlcGF0aD0iJDIiCiAg"\
+            "ICBsb2NhbCBiYWNrdXBfZm9sZGVyPSIkMyIKCiAgICBjYXNlICIkY29tbWFuZCIgaW4KICAgICAg"\
+            "ICBjcmVhdGUpCiAgICAgICAgICAgIDs7CiAgICAgICAgbnVrZSkKICAgICAgICAgICAgcm0gLWYg"\
+            "JHtmaWxlcGF0aH0KICAgICAgICAgICAgOzsKICAgICAgICBiYWNrdXApCiAgICAgICAgICAgIGVj"\
+            "aG8gIkJhY2tpbmcgdXAgZmlsZSAke2ZpbGVwYXRofSIKICAgICAgICAgICAgbG9jYWwgZmlsZV9w"\
+            "YXJlbnQ9JChkaXJuYW1lICR7ZmlsZXBhdGh9KQogICAgICAgICAgICBsb2NhbCBmaWxlX25hbWU9"\
+            "JChiYXNlbmFtZSAke2ZpbGVwYXRofSkKICAgICAgICAgICAgaWYgWyAtZiAiJHtmaWxlX3BhcmVu"\
+            "dH0vJHtmaWxlX25hbWV9IiBdOyB0aGVuCiAgICAgICAgICAgICAgICBkb2NrZXIgcnVuIC0tcm0g"\
+            "LXYgJHtmaWxlX3BhcmVudH06L3ZvbHVtZSAtdiAke2JhY2t1cF9mb2xkZXJ9Oi9iYWNrdXAgZGVi"\
+            "aWFuIGJhc2ggLWMgImNwIC92b2x1bWUvJHtmaWxlX25hbWV9IC9iYWNrdXAvJHtmaWxlX25hbWV9"\
+            "ICYmIGNob3duIC1SICRNWUlEOiRNWUdSUCAvYmFja3VwIgogICAgICAgICAgICBlbHNlCiAgICAg"\
+            "ICAgICAgICAgICBlY2hvICJGaWxlICR7ZmlsZXBhdGh9IGRvZXMgbm90IGV4aXN0IC0gbm90aGlu"\
+            "ZyB0byBiYWNrdXAiCiAgICAgICAgICAgIGZpCiAgICAgICAgICAgIDs7CiAgICAgICAgcmVzdG9y"\
+            "ZSkKICAgICAgICAgICAgZWNobyAiUmVzdG9yaW5nIGZpbGUgJHtmaWxlcGF0aH0iCiAgICAgICAg"\
+            "ICAgIGxvY2FsIGZpbGVfbmFtZT0kKGJhc2VuYW1lICR7ZmlsZXBhdGh9KQogICAgICAgICAgICBj"\
+            "cCAke2JhY2t1cF9mb2xkZXJ9LyR7ZmlsZV9uYW1lfSAke2ZpbGVwYXRofQogICAgICAgICAgICA7"\
+            "OwogICAgZXNhYwp9CgpfYXV0b2NvbW1hbmRwYXJzZSgpIHsKICAgICMgZmlyc3QgYXJndW1lbnQg"\
+            "aXMgdGhlIGNvbW1hbmQKICAgICMgaWYgdGhlIGNvbW1hbmQgaXMgYmFja3VwIG9yIHJlc3RvcmUs"\
+            "IHRoZW4gdGhlIGxhc3QgdHdvIGFyZ3VtZW50cyBhcmUgdGhlIGJhY2t1cCBmaWxlIGFuZCB0aGUg"\
+            "dGVtcG9yYXJ5IHBhdGgKICAgICMgYWxsIG90aGVyIGFyZ3VtZW50cyBhcmUgb2YgZm9ybToKICAg"\
+            "ICMga2V5PXZhbHVlCiAgICAjIHdoZXJlIGtleSBjYW4gYmUgb25lIG9mIHZvbHVtZSwgcGF0aCBv"\
+            "ciBmaWxlLgogICAgIyB2YWx1ZSBpcyB0aGUgcGF0aCBvciB2b2x1bWUgbmFtZS4KCiAgICAjIHdl"\
+            "IGl0ZXJhdGUgb3ZlciB0aGUga2V5PXZhbHVlIGFyZ3VtZW50cywgYW5kIGZvciBlYWNoIHdlIGNh"\
+            "bGw6CiAgICAjICAgIGF1dG9ydW4gPGNvbW1hbmQ+IDxiYWNrdXBmaWxlPiA8a2V5PiA8dmFsdWU+"\
+            "CgogICAgbG9jYWwgY29tbWFuZD0iJDEiCiAgICBzaGlmdAoKICAgIGxvY2FsIGJhY2t1cF90ZW1w"\
+            "X3BhdGg9IiQxIgogICAgc2hpZnQKCiAgICBlY2hvICJhdXRvY29tbWFuZHBhcnNlOiBjb21tYW5k"\
+            "PSRjb21tYW5kIGJhY2t1cF90ZW1wX3BhdGg9JGJhY2t1cF90ZW1wX3BhdGgiCgogICAgIyBFeHRy"\
+            "YWN0IHRoZSBiYWNrdXAgZmlsZSBhbmQgdGVtcCBwYXRoIChsYXN0IHR3byBhcmd1bWVudHMpCiAg"\
+            "ICBsb2NhbCBhcmdzPSgiJEAiKQogICAgbG9jYWwgYXJnX2NvdW50PSR7I2FyZ3NbQF19CiAgICAK"\
+            "ICAgICMgUHJvY2VzcyBhbGwga2V5PXZhbHVlIHBhaXJzCiAgICBmb3IgKChpPTA7IGk8JGFyZ19j"\
+            "b3VudDsgaSsrKSk7IGRvCiAgICAgICAgbG9jYWwgcGFpcj0iJHthcmdzWyRpXX0iCiAgICAgICAg"\
+            "CiAgICAgICAgIyBTa2lwIGlmIG5vdCBpbiBrZXk9dmFsdWUgZm9ybWF0CiAgICAgICAgaWYgW1sg"\
+            "IiRwYWlyIiAhPSAqIj0iKiBdXTsgdGhlbgogICAgICAgICAgICBjb250aW51ZQogICAgICAgIGZp"\
+            "CiAgICAgICAgCiAgICAgICAgbG9jYWwga2V5PSIke3BhaXIlJT0qfSIKICAgICAgICBsb2NhbCB2"\
+            "YWx1ZT0iJHtwYWlyIyo9fSIKCiAgICAgICAgIyBjcmVhdGUgYmFja3VwIGZvbGRlciB1bmlxdWUg"\
+            "dG8ga2V5L3ZhbHVlLgogICAgICAgIGxvY2FsIGJmb2xkZXI9JChlY2hvICIke2tleX1fJHt2YWx1"\
+            "ZX0iIHwgdHIgLWNkICdbOmFsbnVtOl1fLScpCiAgICAgICAgbG9jYWwgdGFyZ2V0cGF0aD0iJHti"\
+            "YWNrdXBfdGVtcF9wYXRofS8ke2Jmb2xkZXJ9IgogICAgICAgIG1rZGlyIC1wICR7dGFyZ2V0cGF0"\
+            "aH0KCiAgICAgICAgIyBLZXkgbXVzdCBiZSBvbmUgb2Ygdm9sdW1lLCBwYXRoIG9yIGZpbGUKICAg"\
+            "ICAgICBjYXNlICIka2V5IiBpbgogICAgICAgICAgICB2b2x1bWUpCiAgICAgICAgICAgICAgICBf"\
+            "YXV0b2NvbW1hbmRydW5fdm9sdW1lICIkY29tbWFuZCIgIiR2YWx1ZSIgIiR0YXJnZXRwYXRoIgog"\
+            "ICAgICAgICAgICAgICAgOzsKICAgICAgICAgICAgcGF0aCkKICAgICAgICAgICAgICAgIF9hdXRv"\
+            "Y29tbWFuZHJ1bl9wYXRoICIkY29tbWFuZCIgIiR2YWx1ZSIgIiR0YXJnZXRwYXRoIgogICAgICAg"\
+            "ICAgICAgICAgOzsKICAgICAgICAgICAgZmlsZSkKICAgICAgICAgICAgICAgIF9hdXRvY29tbWFu"\
+            "ZHJ1bl9maWxlICIkY29tbWFuZCIgIiR2YWx1ZSIgIiR0YXJnZXRwYXRoIgogICAgICAgICAgICAg"\
+            "ICAgOzsKICAgICAgICAgICAgKikKICAgICAgICAgICAgICAgIF9kaWUgIlVua25vd24ga2V5ICRr"\
+            "ZXkgcGFzc2VkIHRvIGF1dG8ke2NvbW1hbmR9LiBXZSBvbmx5IHN1cHBvcnQgdm9sdW1lLCBwYXRo"\
+            "IGFuZCBmaWxlLiIKICAgICAgICAgICAgICAgIDs7CiAgICAgICAgZXNhYwogICAgZG9uZQp9CgoK"\
+            "ZGF0YWNyZWF0ZSgpIHsKICAgIF9hdXRvY29tbWFuZHBhcnNlIGNyZWF0ZSBub25lICIkQCIKfQoK"\
+            "CmRhdGFudWtlKCkgewogICAgX2F1dG9jb21tYW5kcGFyc2UgbnVrZSBub25lICIkQCIKfQoKZGF0"\
+            "YWJhY2t1cCgpIHsKICAgIF9jaGVja19yZXF1aXJlZF9lbnZfdmFycyAiQkFDS1VQX0ZJTEUiICJU"\
+            "RU1QX0RJUiIKICAgIEJBQ0tVUF9URU1QX1BBVEg9IiRURU1QX0RJUi9iYWNrdXAiCgoKICAgIG1r"\
+            "ZGlyIC1wICIkQkFDS1VQX1RFTVBfUEFUSCIKICAgIGVjaG8gIl9hdXRvY29tbWFuZHBhcnNlIFti"\
+            "YWNrdXBdIFskQkFDS1VQX1RFTVBfUEFUSF0gWyRAXSIKICAgIF9hdXRvY29tbWFuZHBhcnNlIGJh"\
+            "Y2t1cCAiJEJBQ0tVUF9URU1QX1BBVEgiICIkQCIKCiAgICB0YXIgemN2ZiAiJEJBQ0tVUF9GSUxF"\
+            "IiAtQyAiJEJBQ0tVUF9URU1QX1BBVEgiIC4KfQoKZGF0YXJlc3RvcmUoKSB7CiAgICBfY2hlY2tf"\
+            "cmVxdWlyZWRfZW52X3ZhcnMgIkJBQ0tVUF9GSUxFIiAiVEVNUF9ESVIiCiAgICBCQUNLVVBfVEVN"\
+            "UF9QQVRIPSIkVEVNUF9ESVIvcmVzdG9yZSIKCiAgICBlY2hvICJfYXV0b2NvbW1hbmRwYXJzZSBb"\
+            "cmVzdG9yZV0gWyRCQUNLVVBfVEVNUF9QQVRIXSBbJEBdIgoKICAgIG1rZGlyIC1wICIkQkFDS1VQ"\
+            "X1RFTVBfUEFUSCIKICAgIHRhciB6eHZmICIkQkFDS1VQX0ZJTEUiIC1DICIkQkFDS1VQX1RFTVBf"\
+            "UEFUSCIgLS1zdHJpcC1jb21wb25lbnRzPTEKCiAgICBfYXV0b2NvbW1hbmRwYXJzZSByZXN0b3Jl"\
+            "ICIkQkFDS1VQX1RFTVBfUEFUSCIgIiRAIgp9Cg==";
+
+        // 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, 10759194710819511084ULL, 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.hpp

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

source/src/autogen/version.hpp

@@ -0,0 +1,11 @@
+// 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

@@ -0,0 +1,174 @@
+#include <unistd.h>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <filesystem>
+
+#include "utils/output.hpp"
+#include "utils/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 "templates.hpp"
+#include "utils/directories.hpp"
+#include "shared_commands.hpp"
+
+namespace dropshell
+{
+
+    int backupdata_handler(const CommandContext &ctx);
+
+    static std::vector<std::string> backupdata_name_list = {"backupdata", "bd", "backup", "bup"};
+
+    // Static registration
+    struct BackupDataCommandRegister
+    {
+        BackupDataCommandRegister()
+        {
+            CommandRegistry::instance().register_command({backupdata_name_list,
+                                                          backupdata_handler,
+                                                          shared_commands::std_autocomplete_allowall,
+                                                          false, // hidden
+                                                          true,  // requires_config
+                                                          true,  // requires_install
+                                                          2,     // min_args (after command)
+                                                          2,     // max_args (after command)
+                                                          "backupdata SERVER SERVICE",
+                                                          "Backup data for a service on a server.",
+                                                          // heredoc
+                                                          R"(
+                backupdata SERVER SERVICE     Backup data for a service on a server.
+                backupdata SERVER all         Backup data for all services on a server.
+
+                Note: This command will not create any data or configuration.
+                It will simply backup the data on the remote server, saving it to a local file.
+                Restore the data with restore.
+            )"});
+        }
+    } backupdata_command_register;
+
+    namespace shared_commands
+    {
+
+        bool backupdata_service(const std::string &server, const std::string &service)
+        {
+            server_env_manager server_env(server);
+            if (!server_env.is_valid())
+            {
+                error << "Server " << server << " is not valid" << std::endl;
+                return false;
+            }
+
+            LocalServiceInfo sinfo = get_service_info(server, service);
+            if (!SIvalid(sinfo))
+            {
+                error << "Service " << service << " is not valid" << std::endl;
+                return false;
+            }
+
+            const std::string command = "backup";
+
+            if (!gTemplateManager().template_command_exists(sinfo.template_name, command))
+            {
+                info << service << " has no data to backup" << std::endl;
+                debug << "(no backup script for " << sinfo.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(server, service);
+            std::string remote_command_script_file = remote_service_template_path + "/" + command + ".sh";
+            std::string remote_service_config_path = remotepath::service_config(server, service);
+            if (!server_env.check_remote_items_exist({remotepath::service(server, service),
+                                                      remote_command_script_file,
+                                                      remotefile::service_env(server, service)}))
+            {
+                error << "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);
+            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))
+            {
+                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();
+            if (local_backups_dir.empty())
+            {
+                error << "Error: Local backups directory not found" << std::endl;
+                info << "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
+            shared_commands::cBackupFileName backup_filename_construction(server, service, sinfo.template_name);
+            if (!backup_filename_construction.is_valid())
+            {
+                error << "Invalid backup filename" << std::endl;
+                return false;
+            }
+
+            // Construct backup filename
+            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(magic_string(), local_backup_file_path), "Invalid backup filename");
+
+            { // Run backup script
+                shared_commands::cRemoteTempFolder remote_temp_folder(server_env);
+                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;
+                    return false;
+                }
+
+                // 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))
+                {
+                    error << "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
+
+            info << "Backup created successfully. Restore with:" << std::endl;
+            info << "   dropshell restore " << server << " " << service << " " << backup_filename << std::endl;
+            return true;
+        }
+    } // namespace shared_commands
+
+    int backupdata_handler(const CommandContext &ctx)
+    {
+        ASSERT(ctx.args.size() == 2, "Invalid number of arguments");
+
+        std::string server = safearg(ctx.args, 0);
+        std::string service = safearg(ctx.args, 1);
+
+        if (service == "all")
+        {
+            // backup all services on the server
+            maketitle("Backing up data for all services on " + server);
+            bool okay = true;
+            std::vector<LocalServiceInfo> services = get_server_services_info(server);
+            for (const LocalServiceInfo &si : services)
+                okay &= shared_commands::backupdata_service(server, si.service_name);
+            return okay ? 0 : 1;
+        }
+
+        return shared_commands::backupdata_service(server, service) ? 0 : 1;
+    }
+
+} // namespace dropshell

source/src/commands/colours.cpp

@@ -0,0 +1,44 @@
+#include "command_registry.hpp"
+#include "config.hpp"
+#include "utils/output.hpp"
+#include "utils/assert.hpp"
+
+namespace dropshell {
+
+void colours_autocomplete(const CommandContext& ctx) {}
+int colours_handler(const CommandContext& ctx)
+{
+    info << "Colours:" << std::endl;
+    debug <<   "Debug Example:   The quick brown fox jumps over the lazy dog." << std::endl;
+    info <<    "Info Example:    The quick brown fox jumps over the lazy dog." << std::endl;
+    warning << "Warning Example: The quick brown fox jumps over the lazy dog." << std::endl;
+    error <<   "Error Example:   The quick brown fox jumps over the lazy dog." << std::endl;
+    return 0;
+}
+
+static std::vector<std::string> colours_name_list={"colours","c","--colours","-c"};
+
+// Static registration
+struct ColoursCommandRegister {
+    ColoursCommandRegister() {
+        CommandRegistry::instance().register_command({
+            colours_name_list,
+            colours_handler,
+            colours_autocomplete,
+            true, // hidden
+            false, // requires_config
+            false, // requires_install
+            0,     // min_args (after command)
+            0,     // max_args (after command)
+            "colours",
+            "Show the colours used by dropshell.",
+            // heredoc
+            R"(
+            Show the colours used by dropshell.
+            )"
+        });
+    }
+} colours_command_register;
+
+
+} // namespace dropshell

source/src/commands/command_registry.cpp

@@ -0,0 +1,75 @@
+#include "command_registry.hpp"
+#include "utils/utils.hpp"
+#include "config.hpp"
+
+namespace dropshell {
+
+CommandRegistry& CommandRegistry::instance() {
+    static CommandRegistry reg;
+    return reg;
+}
+
+void CommandRegistry::register_command(const CommandInfo& info) {
+    auto ptr = std::make_shared<CommandInfo>(info);
+    for (const auto& name : info.names) {
+        command_map_[name] = ptr;
+    }
+    all_commands_.push_back(ptr);
+}
+
+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();
+    return nullptr;
+}
+
+std::vector<std::string> CommandRegistry::list_commands(bool include_hidden) const {
+    std::set<std::string> out;
+    for (const auto& cmd : all_commands_) {
+        if (!cmd->hidden || include_hidden) {
+            for (const auto& name : cmd->names) out.insert(name);
+        }
+    }
+    return std::vector<std::string>(out.begin(), out.end());
+}
+
+std::vector<std::string> CommandRegistry::list_primary_commands(bool include_hidden) const {
+    std::set<std::string> out;
+    for (const auto& cmd : all_commands_) {
+        if (!cmd->hidden || include_hidden) {
+            if (cmd->names.size() > 0)
+            {
+                if (cmd->requires_config && !gConfig().is_config_set())
+                    continue;
+                if (cmd->requires_install && !gConfig().is_agent_installed())
+                    continue;
+                out.insert(cmd->names[0]);
+            }
+        }
+    }
+    return std::vector<std::string>(out.begin(), out.end());
+}
+
+
+void CommandRegistry::autocomplete(const CommandContext& ctx) const {
+    // dropshell autocomplete <command> <arg> <arg> ...
+    if (ctx.args.size() < 1) {
+        for (const auto& name : list_primary_commands(false)) {
+            std::cout << name << std::endl;
+        }
+        return;
+    }
+
+    // ctx command is autocomplete, so recreate ctx with the first arg removed
+    CommandContext childcontext = {
+        ctx.exename,
+        ctx.args[0],
+        std::vector<std::string>(ctx.args.begin() + 1, ctx.args.end())
+    };
+    auto* info = find_command(childcontext.command);
+    if (info && info->autocomplete) {
+        info->autocomplete(childcontext);
+    }
+}
+
+} // namespace dropshell

source/src/commands/command_registry.hpp

@@ -0,0 +1,60 @@
+#ifndef COMMAND_REGISTRY_HPP
+#define COMMAND_REGISTRY_HPP
+
+#include <string>
+#include <vector>
+#include <functional>
+#include <map>
+#include <set>
+#include <memory>
+#include <iostream>
+
+namespace dropshell {
+
+struct CommandContext {
+    std::string exename;
+    std::string command;
+    std::vector<std::string> args;
+
+    // Add more fields as needed (e.g., config pointer, output stream, etc.)
+};
+
+struct CommandInfo {
+    std::vector<std::string> names;
+    std::function<int(const CommandContext&)> handler;
+    std::function<void(const CommandContext&)> autocomplete; // optional
+    bool hidden = false;
+    bool requires_config = true;
+    bool requires_install = true;
+    int min_args = 0;
+    int max_args = -1; // -1 = unlimited
+    std::string help_usage;       // install SERVER [SERVICE]
+    std::string help_description; // Install/reinstall/update service(s). Safe/non-destructive.
+    std::string full_help;        // detailed help for the command
+};
+
+class CommandRegistry {
+public:
+    static CommandRegistry& instance();
+
+    void register_command(const CommandInfo& info);
+
+    // Returns nullptr if not found
+    const CommandInfo* find_command(const std::string& name) const;
+
+    // List all commands (optionally including hidden)
+    std::vector<std::string> list_commands(bool include_hidden = false) const;
+    std::vector<std::string> list_primary_commands(bool include_hidden = false) const;
+
+    // For autocomplete
+    void autocomplete(const CommandContext& ctx) const;
+
+private:
+    CommandRegistry() = default;
+    std::map<std::string, std::shared_ptr<CommandInfo>> command_map_;
+    std::vector<std::shared_ptr<CommandInfo>> all_commands_;
+};
+
+} // namespace dropshell
+
+#endif // COMMAND_REGISTRY_HPP

source/src/commands/create-service.cpp

@@ -0,0 +1,124 @@
+#include "command_registry.hpp"
+#include "directories.hpp"
+#include "shared_commands.hpp"
+#include "templates.hpp"
+
+#include "utils/assert.hpp"
+#include "utils/utils.hpp"
+#include "services.hpp"
+
+namespace dropshell
+{
+
+    int create_service_handler(const CommandContext &ctx);
+    void create_service_autocomplete(const CommandContext &ctx);
+
+    static std::vector<std::string> create_service_name_list = {"create-service"};
+
+    // Static registration
+    struct CreateServiceCommandRegister
+    {
+        CreateServiceCommandRegister()
+        {
+            CommandRegistry::instance().register_command({create_service_name_list,
+                                                          create_service_handler,
+                                                          create_service_autocomplete,
+                                                          false, // hidden
+                                                          true,  // requires_config
+                                                          true,  // requires_install
+                                                          3,     // min_args (after command)
+                                                          3,     // max_args (after command)
+                                                          "create-service SERVER SERVICE TEMPLATE",
+                                                          "Create a service on a server.",
+                                                          // heredoc
+                                                          R"(
+            Create a service on a server.
+            create-service SERVER SERVICE TEMPLATE    create the given service on the given server.
+                )"});
+        }
+    } create_service_command_register;
+
+    int create_service_handler(const CommandContext &ctx)
+    {
+        std::string server = safearg(ctx.args, 0);
+        std::string service = safearg(ctx.args, 1);
+        std::string template_name = safearg(ctx.args, 2);
+
+        return shared_commands::create_service(server, template_name, service) ? 0 : 1;
+    }
+
+    void create_service_autocomplete(const CommandContext &ctx)
+    {
+        if (ctx.args.size() < 2)
+            shared_commands::std_autocomplete(ctx);
+        else
+        {
+            if (ctx.args.size() == 2)
+            {
+                std::set<std::string> templates = gTemplateManager().get_template_list();
+                for (const auto &template_name : templates)
+                    rawout << template_name << std::endl;
+            }
+        }
+    }
+
+    namespace shared_commands
+    {
+
+    bool create_service(const std::string &server_name, const std::string &template_name, const std::string &service_name)
+    {
+        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;
+            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);
+
+        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/edit.cpp

@@ -0,0 +1,177 @@
+#include "command_registry.hpp"
+#include "config.hpp"
+#include "utils/utils.hpp"
+#include "utils/directories.hpp"
+#include "shared_commands.hpp"
+
+#include <unistd.h>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <filesystem>
+#include "utils/assert.hpp"
+
+namespace dropshell {
+
+int edit_handler(const CommandContext& ctx);
+
+static std::vector<std::string> edit_name_list={"edit"};
+
+// Static registration
+struct EditCommandRegister {
+    EditCommandRegister() {
+        CommandRegistry::instance().register_command({
+            edit_name_list,
+            edit_handler,
+            shared_commands::std_autocomplete,
+            false, // hidden
+            false, // requires_config
+            false, // requires_install
+            0,     // min_args (after command)
+            2,     // max_args (after command)
+            "edit [SERVER] [SERVICE]",
+            "Edit dropshell, server or service configuration",
+            // heredoc
+            R"(
+            Edit dropshell, server or service configuration.
+            edit                      edit the dropshell config.
+            edit <server>             edit the server config.
+            edit <server> <service>   edit the service config.
+            )"
+        });
+    }
+} edit_command_register;
+ 
+// ------------------------------------------------------------------------------------------------
+// edit command implementation
+// ------------------------------------------------------------------------------------------------
+
+
+
+// ------------------------------------------------------------------------------------------------
+// utility function to edit a file
+// ------------------------------------------------------------------------------------------------
+bool edit_file(const std::string &file_path, bool has_bb64)
+{
+    // make sure parent directory exists.
+    std::string parent_dir = get_parent(file_path);
+    std::filesystem::create_directories(parent_dir);
+
+    std::string editor_cmd;
+    const char* editor_env = std::getenv("EDITOR");
+
+    if (editor_env && std::strlen(editor_env) > 0) {
+        editor_cmd = std::string(editor_env) + " " + quote(file_path);
+    } else if (isatty(STDIN_FILENO)) {
+        // Check if stdin is connected to a terminal if EDITOR is not set
+        editor_cmd = "nano -w " + quote(file_path);
+    } else {
+        error << "Standard input is not a terminal and EDITOR environment variable is not set." << std::endl;
+        info << "Try setting the EDITOR environment variable (e.g., export EDITOR=nano) or run in an interactive terminal." << std::endl;
+        info << "You can manually edit the file at: " << file_path << std::endl;
+        return false;
+    }
+
+    info << "Editing file: " << file_path << std::endl;
+
+    if (has_bb64) {
+        return execute_local_command("", editor_cmd, {}, nullptr, cMode::Interactive);
+    }
+    else {
+        // might not have bb64 at this early stage. Direct edit.
+        int ret = system(editor_cmd.c_str());
+        return EXITSTATUSCHECK(ret);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// edit config
+// ------------------------------------------------------------------------------------------------
+int edit_config()
+{
+    if (!gConfig().is_config_set())
+        gConfig().save_config(false); // save defaults.
+
+    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.");
+
+    gConfig().load_config();
+    if (!gConfig().is_config_set())
+        return die("Error: Failed to load and parse edited config file!");
+
+    gConfig().save_config(true);
+
+    std::cout << "Successfully edited config file at " << config_file << std::endl;
+    return 0;
+}
+
+// ------------------------------------------------------------------------------------------------
+// edit server
+// ------------------------------------------------------------------------------------------------
+int edit_server(const std::string &server_name)
+{
+    if (localpath::server(server_name).empty()) {
+        std::cerr << "Error: Server not found: " << server_name << std::endl;
+        return -1;
+    }
+
+    std::string config_file = localfile::server_json(server_name);
+
+    if (!edit_file(config_file, true)) {
+        error << "Failed to edit server config" << std::endl;
+        info << "You can manually edit this file at: " << config_file << std::endl;
+        return 1;
+    }
+
+    info << "If you have changed DROPSHELL_DIR, you should manually move the files to the new location NOW." << std::endl;
+    info << "You can ssh in to the remote server with:  dropshell ssh "<<server_name<< std::endl;
+    info << "Once moved, reinstall all services with:   dropshell install " << server_name << std::endl;
+    return 0;
+}
+
+// ------------------------------------------------------------------------------------------------
+// edit service config
+// ------------------------------------------------------------------------------------------------
+int edit_service_config(const std::string &server, const std::string &service)
+{
+    std::string config_file = localfile::service_env(server, service);
+    if (!std::filesystem::exists(config_file))
+    {
+        error << "Service config file not found: " << config_file << std::endl;
+        return 1;
+    }
+
+    if (edit_file(config_file, true) && std::filesystem::exists(config_file))
+        info << "To apply your changes, run:\n   dropshell install " + server + " " + service << std::endl;
+    return 0;
+}
+
+// ------------------------------------------------------------------------------------------------
+// edit command handler
+// ------------------------------------------------------------------------------------------------
+int edit_handler(const CommandContext& ctx) {
+    // edit dropshell config
+    if (ctx.args.size() < 1) 
+        return edit_config();
+
+    // edit server config
+    if (ctx.args.size() < 2) {
+        edit_server(safearg(ctx.args,0));
+        return 0;
+    }
+
+    // edit service config
+    if (ctx.args.size() < 3) {
+        edit_service_config(safearg(ctx.args,0), safearg(ctx.args,1));
+        return 0;
+    }
+
+    info << "Edit handler called with " << ctx.args.size() << " args\n";
+    return -1;
+}
+
+
+
+
+} // namespace dropshell

source/src/commands/health.cpp

@@ -0,0 +1,73 @@
+#include "command_registry.hpp"
+#include "config.hpp"
+#include "utils/utils.hpp"
+#include "utils/directories.hpp"
+#include "shared_commands.hpp"
+#include "server_env_manager.hpp"
+#include "services.hpp"
+#include "servers.hpp"
+#include "transwarp.hpp"
+
+namespace dropshell
+{
+
+    int health_handler(const CommandContext &ctx);
+
+    static std::vector<std::string> health_name_list = {"health", "check", "healthcheck", "status"};
+
+    // Static registration
+    struct HealthCommandRegister
+    {
+        HealthCommandRegister()
+        {
+            CommandRegistry::instance().register_command({health_name_list,
+                                                          health_handler,
+                                                          shared_commands::std_autocomplete_allowall,
+                                                          false, // hidden
+                                                          true, // requires_config
+                                                          true, // requires_install
+                                                          1,     // min_args (after command)
+                                                          2,     // max_args (after command)
+                                                          "health SERVER",
+                                                          "Check the health of a server.",
+                                                          R"(
+                health <server>
+                )"});
+        }
+    } health_command_register;
+
+
+
+    // ------------------------------------------------------------------------------------------------
+    // health command implementation
+    // ------------------------------------------------------------------------------------------------
+    int health_handler(const CommandContext &ctx)
+    {
+        if (ctx.args.size() < 1)
+        {
+            error << "Server name is required" << std::endl;
+            return 1;
+        }
+
+        std::string server = safearg(ctx.args, 0);
+
+        if (ctx.args.size() == 1) {
+            // get all services on server
+            std::vector<LocalServiceInfo> services = get_server_services_info(server);
+            transwarp::parallel exec{services.size()};
+            auto task = transwarp::for_each(exec, services.begin(), services.end(), [&](const LocalServiceInfo& service) {
+                std::string status = shared_commands::healthtick(server, service.service_name);
+                std::cout << status << " " << service.service_name << " (" << service.template_name << ")" << std::endl << std::flush;
+            });
+            task->wait();
+            return 0;
+        } else {
+            // get service status
+            std::string service = safearg(ctx.args, 1);
+            LocalServiceInfo service_info = get_service_info(server, service);
+            std::cout << shared_commands::healthtick(server, service) << " " << service << " (" << service_info.template_name << ")" << std::endl << std::flush;
+        }
+        return 0;
+    }
+
+} // namespace dropshell

source/src/commands/help.cpp

@@ -0,0 +1,139 @@
+#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 "utils/assert.hpp"
+
+namespace dropshell {
+
+void help_autocomplete(const CommandContext& ctx);
+int help_handler(const CommandContext& ctx);
+
+static std::vector<std::string> help_name_list={"help","h","--help","-h"};
+
+// Static registration
+struct HelpCommandRegister {
+    HelpCommandRegister() {
+        CommandRegistry::instance().register_command({
+            help_name_list,
+            help_handler,
+            help_autocomplete,
+            false, // hidden
+            false, // requires_config
+            false, // requires_install
+            0,     // min_args (after command)
+            1,     // max_args (after command)
+            "help [COMMAND]",
+            "Show help for dropshell, or detailed help for a specific command.",
+            // heredoc
+            R"(
+            Show help for dropshell, or detailed help for a specific command.
+            If you want to see documentation, please visit the DropShell website:
+                https://dropshell.app
+            )"
+        });
+    }
+} help_command_register;
+
+
+void help_autocomplete(const CommandContext& ctx) {
+    if (ctx.args.size() == 1) {
+        // list all commands
+        for (const auto& cmd : CommandRegistry::instance().list_primary_commands(false)) {
+            rawout << cmd << std::endl;
+        }
+    }
+    return;
+}
+
+void show_command(const std::string& cmd) { 
+    const auto& cmd_info = CommandRegistry::instance().find_command(cmd); 
+    if (!cmd_info) 
+    {
+        error << "Unknown command: " << cmd << std::endl;
+        return;
+    }
+
+    info << "  ";
+    info << left_align(cmd_info->help_usage, 32);
+    info << cmd_info->help_description << std::endl;
+}
+
+extern const std::string VERSION;
+extern const std::string RELEASE_DATE;
+extern const std::string AUTHOR;
+extern const std::string LICENSE;
+
+
+int show_command_help(const std::string& cmd) {
+    const auto& cmd_info = CommandRegistry::instance().find_command(cmd); 
+    if (!cmd_info) 
+    {
+        error << "Unknown command: " << cmd << std::endl;
+        return 1;
+    }
+    info << "Command " << cmd << " usage:" << std::endl;
+    info << "  ";
+    info << left_align(cmd_info->help_usage, 32);
+    info << cmd_info->help_description << std::endl;
+
+    info << std::endl;
+
+    info << "  Equivalent names: ";
+    bool first = true;
+    for (const auto& name : cmd_info->names) {
+        if (!first) info << ", ";
+        info << name;
+        first = false;
+    }
+    info << std::endl;
+    
+    info << cmd_info->full_help << std::endl << std::endl;
+
+    return 0;
+}
+
+int help_handler(const CommandContext& ctx) {
+
+    if (ctx.args.size() > 0)
+        return show_command_help(ctx.args[0]);
+
+    info << std::endl;
+    maketitle("DropShell version " + VERSION);
+    info << std::endl;
+    info << "A tool for managing remote servers, by " << AUTHOR << std::endl;
+    info << std::endl;
+    info << "dropshell ..." << std::endl;
+
+    show_command("help");
+    show_command("edit");
+
+    if (gConfig().is_config_set())
+    {
+        // show more!
+        show_command("list");
+        std::cout << std::endl;
+        show_command("install");
+        show_command("uninstall");
+        show_command("nuke");
+        std::cout << std::endl;
+        show_command("start");
+        show_command("stop");
+        std::cout << std::endl;
+        show_command("ssh");
+        std::cout << std::endl;
+    }
+    return 0;
+}
+
+
+
+} // namespace dropshell

source/src/commands/install.cpp

@@ -0,0 +1,381 @@
+#include "command_registry.hpp"
+#include "config.hpp"
+#include "utils/utils.hpp"
+#include "utils/directories.hpp"
+#include "templates.hpp"
+#include "shared_commands.hpp"
+#include "utils/hash.hpp"
+#include "autogen/_agent.hpp"
+#include "services.hpp"
+#include "utils/output.hpp"
+
+#include <unistd.h>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <filesystem>
+#include "utils/assert.hpp"
+
+namespace dropshell
+{
+
+    int install_handler(const CommandContext &ctx);
+
+    static std::vector<std::string> install_name_list = {"install", "reinstall", "update"};
+
+    // Static registration
+    struct InstallCommandRegister
+    {
+        InstallCommandRegister()
+        {
+            CommandRegistry::instance().register_command({install_name_list,
+                                                          install_handler,
+                                                          shared_commands::std_autocomplete_allowall,
+                                                          false, // hidden
+                                                          false, // requires_config
+                                                          false, // requires_install
+                                                          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.",
+                                                          // heredoc
+                                                          R"(
+            Install components on a server. This is safe to re-run (non-destructive) and used to update
+            servers and their services.
+
+            install                      (re)install dropshell components on this computer.
+            install SERVER               (re)install dropshell agent on the given server.
+            install SERVER [SERVICE|all] (re)install the given service (or all services) on the given server.
+
+            Note you need to create the service first with:
+                dropshell create-service <server> <template> <service>
+            )"});
+        }
+    } install_command_register;
+
+    namespace shared_commands
+    {
+
+        // ------------------------------------------------------------------------------------------------
+        // install service over ssh : SHARED COMMAND
+        // ------------------------------------------------------------------------------------------------
+        bool install_service(const std::string &server, const std::string &service)
+        {
+            LocalServiceInfo service_info = get_service_info(server, service);
+            if (!SIvalid(service_info))
+                return false;
+
+            server_env_manager server_env(server);
+            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.
+
+            // Check if template exists
+            template_info tinfo = gTemplateManager().get_template_info(service_info.template_name);
+            if (!tinfo.is_set())
+                return false;
+
+            if (!tinfo.template_valid())
+            {
+                std::cerr << "Template is not valid: " << service_info.template_name << std::endl;
+                return false;
+            }
+
+            // 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))
+            {
+                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;
+            if (!shared_commands::rsync_tree_to_remote(tinfo.local_template_path().string(), remotepath::service_template(server, service),
+                                                       server_env, false))
+            {
+                std::cerr << "Failed to copy template files using rsync" << std::endl;
+                return false;
+            }
+
+            // Copy service files
+            debug << "Copying: [LOCAL] " << localpath::service(server, service) << std::endl
+                  << std::string(8, ' ') << "[REMOTE] " << remotepath::service_config(server, service) << std::endl;
+            if (!shared_commands::rsync_tree_to_remote(localpath::service(server, service), remotepath::service_config(server, service),
+                                                       server_env, false))
+            {
+                std::cerr << "Failed to copy service files using rsync" << std::endl;
+                return false;
+            }
+
+            // Run install script
+            {
+                info << "Running " << service_info.template_name << " install script on " << server << "..." << std::endl;
+                server_env.run_remote_template_command(service, "install", {}, false, {});
+            }
+
+            // print health tick
+            info << "Health: " << shared_commands::healthtick(server, service) << std::endl;
+            return true;
+        }
+
+    } // namespace shared_commands
+
+    // ------------------------------------------------------------------------------------------------
+    // update_dropshell
+    // ------------------------------------------------------------------------------------------------
+
+    std::string _exec(const char *cmd)
+    {
+        char buffer[128];
+        std::string result = "";
+        FILE *pipe = popen(cmd, "r");
+        if (!pipe)
+        {
+            throw std::runtime_error("popen() failed!");
+        }
+        while (!feof(pipe))
+        {
+            if (fgets(buffer, 128, pipe) != nullptr)
+                result += buffer;
+        }
+        pclose(pipe);
+        return trim(result);
+    }
+
+    int update_dropshell()
+    {
+        // determine path to this executable
+        std::filesystem::path dropshell_path = std::filesystem::canonical("/proc/self/exe");
+        std::filesystem::path parent_path = dropshell_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
+        std::string bash_script;
+        bash_script += "docker run --rm -v " + parent_path.string() + ":/target";
+        bash_script += " gitea.jde.nz/public/debian-curl:latest";
+        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;
+        }
+
+        // check if the new version is the same as the old version
+        uint64_t new_hash = hash_file(parent_path / "dropshell_temp");
+        uint64_t old_hash = hash_file(parent_path / "dropshell");
+        if (new_hash == old_hash)
+        {
+            std::cout << "Confirmed dropshell is the latest version." << std::endl;
+            return 0;
+        }
+
+        std::string runvercmd = (parent_path / "dropshell").string() + " version";
+        std::string currentver = _exec(runvercmd.c_str());
+        runvercmd = (parent_path / "dropshell_temp").string() + " version";
+        std::string newver = _exec(runvercmd.c_str());
+
+        if (currentver >= newver)
+        {
+            std::cout << "Current dropshell version: " << currentver << ", published version: " << newver << std::endl;
+            std::cout << "No update needed." << std::endl;
+            return 0;
+        }
+
+        return 0;
+
+        std::string bash_script_2 = "docker run --rm -v " + parent_path.string() + ":/target gitea.jde.nz/public/debian-curl:latest " +
+                                    "sh -c \"mv /target/dropshell_temp /target/dropshell\"";
+        rval = system(bash_script_2.c_str());
+        if (rval != 0)
+        {
+            std::cerr << "Failed to install new version of dropshell." << std::endl;
+            return -1;
+        }
+
+        std::cout << "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);
+        std::cerr << "Failed to execute new version of dropshell." << std::endl;
+        return -1;
+    }
+
+    int install_local_agent()
+    {
+        std::vector<std::filesystem::path> paths = {
+            gConfig().get_local_template_cache_path(),
+            gConfig().get_local_backup_path(),
+            gConfig().get_local_tempfiles_path(),
+            localpath::agent()};
+        for (auto &p : gConfig().get_local_server_definition_paths())
+            paths.push_back(p);
+
+        for (auto &p : paths)
+            if (!std::filesystem::exists(p))
+            {
+                std::cout << "Creating directory: " << p << std::endl;
+                std::filesystem::create_directories(p);
+            }
+
+        // download bb64 for the host architecture.
+        if (!std::filesystem::exists(localpath::agent() + "bb64"))
+        {
+            std::string cmd = "cd " + localpath::agent() + " && curl -fsSL -o bb64 https://gitea.jde.nz/public/bb64/releases/download/latest/bb64.amd64 && chmod a+x bb64";
+            int ret = system(cmd.c_str());
+            if (EXITSTATUSCHECK(ret))
+                std::cout << "Downloaded local bb64 to " << localpath::agent() << std::endl;
+            else
+                std::cerr << "Failed to download local bb64 to " << localpath::agent() << std::endl;
+        }
+        else
+        {
+            std::cout << "Updating local bb64..." << std::endl;
+            system((localpath::agent() + "bb64 -u").c_str()); // update.
+        }
+
+        std::cout << "Creating local files to copy to remote agents..." << std::endl;
+        recreate_agent::recreate_tree(localpath::files_for_remote_agent());
+
+        return 0;
+    }
+
+    int install_host()
+    {
+        // update dropshell.
+        // install the local dropshell agent.
+
+        int rval = update_dropshell();
+        if (rval != 0)
+            return rval;
+
+        rval = install_local_agent();
+        if (rval != 0)
+            return rval;
+
+        std::cout << "Installation complete." << std::endl;
+        return 0;
+    }
+
+    int install_server(const std::string &server)
+    {
+        // install the dropshell agent on the given server.
+        maketitle("Installing dropshell agent on " + server, sColour::INFO);
+
+        std::string agent_path = remotepath::agent(server);
+        if (agent_path.empty())
+        {
+            error << "Failed to get agent path for " << server << std::endl;
+            return 1;
+        }
+
+        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;
+
+        // add in bb64. We can't use execute_remote_command() here, as that relies on bb64 which we're installing!
+        info << "Installing bb64 on " << server << "..." << std::endl
+             << std::flush;
+
+        std::string remote_cmd =
+            "ssh -p " + server_env.get_SSH_INFO().port + " " + server_env.get_SSH_INFO().user + "@" + server_env.get_SSH_INFO().host +
+            " 'mkdir -p " + quote(agent_path) + " && curl -fsSL \"https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh\" | bash -s -- " +
+            quote(agent_path) + " " + quote("$(id -u " + server_env.get_SSH_USER() + "):$(id -g " + server_env.get_SSH_USER() + ")") + "'";
+
+        // std::cout << "Executing: " << remote_cmd << std::endl;
+        if (!execute_local_command("", remote_cmd, {}, nullptr, cMode::Silent))
+            error << "Failed to download bb64 to " << agent_path << " on remote server." << std::endl;
+        else
+            debug << "Downloaded bb64 to " << agent_path << " on remote server." << std::endl;
+
+        // run the self-test.
+        bool okay = execute_ssh_command(server_env.get_SSH_INFO(), sCommand(agent_path, "./selftest.sh", {}), cMode::Defaults, 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;
+    }
+
+    // ------------------------------------------------------------------------------------------------
+    // install command implementation
+    // ------------------------------------------------------------------------------------------------
+    int install_handler(const CommandContext &ctx)
+    {
+        if (ctx.args.size() < 1)
+        { // install host
+            return install_host();
+        }
+
+        if (!gConfig().is_config_set())
+        {
+            error << "Dropshell is not configured. Please run 'dropshell edit' to configure it." << std::endl;
+            return 1;
+        }
+
+        std::string server = safearg(ctx.args, 0);
+
+        if (ctx.args.size() == 1)
+        { // install server
+            return install_server(server);
+        }
+
+        // install service(s)
+        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)
+            {
+                if (!shared_commands::install_service(server, service.service_name))
+                    okay = false;
+            }
+            return okay ? 0 : 1;
+        }
+        else
+        { // install the specific service.
+            std::string service = safearg(ctx.args, 1);
+            return shared_commands::install_service(server, service) ? 0 : 1;
+        }
+    }
+
+} // namespace dropshell

source/src/commands/list.cpp

@@ -0,0 +1,186 @@
+#include "command_registry.hpp"
+#include "config.hpp"
+#include "utils/utils.hpp"
+#include "utils/directories.hpp"
+#include "shared_commands.hpp"
+#include "servers.hpp"
+#include "tableprint.hpp"
+#include "transwarp.hpp"
+#include "server_env_manager.hpp"
+#include "services.hpp"
+
+#include <unistd.h>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <filesystem>
+#include "utils/assert.hpp"
+
+namespace dropshell {
+
+int list_handler(const CommandContext& ctx);
+void show_server_details(const std::string& server_name);
+void list_servers();
+
+static std::vector<std::string> list_name_list={"list","ls","info","-l"};
+
+// Static registration
+struct ListCommandRegister {
+    ListCommandRegister() {
+        CommandRegistry::instance().register_command({
+            list_name_list,
+            list_handler,
+            shared_commands::std_autocomplete,
+            false, // hidden
+            true, // requires_config
+            true, // requires_install
+            0,     // min_args (after command)
+            2,     // max_args (after command)
+            "list [SERVER] [SERVICE]",
+            "List server or service information and status",
+            // heredoc
+            R"(
+List details for servers and services controller by dropshell.
+  list                          list all servers.
+  list server                   list all services for the given server.
+  list server service           list the given service details on the given server.
+            )"
+        });
+    }
+} list_command_register;
+
+// ------------------------------------------------------------------------------------------------
+// list command handler
+// ------------------------------------------------------------------------------------------------
+int list_handler(const CommandContext& ctx) {
+    if (ctx.args.size() == 0) {
+        list_servers();
+        return 0;
+    }
+
+    if (ctx.args.size() == 1) {
+        show_server_details(ctx.args[0]);
+        return 0;
+    }
+
+    debug << "List handler called with " << ctx.args.size() << " args\n";
+    return 0;
+}
+
+
+
+// https://github.com/bloomen/transwarp?tab=readme-ov-file#range-functions
+void list_servers() {
+    auto servers = get_configured_servers();
+
+    if (servers.empty()) {
+        error << "No servers found" << std::endl;
+        info << "Please run 'dropshell edit' to set up dropshell." << std::endl;
+        info << "Then run 'dropshell create-server' to create a server." << std::endl;
+        return;
+    }
+
+    tableprint tp("All DropShell Servers");
+    tp.add_row({"Name", "User", "Address", "Health", "Ports"});
+
+    info << "Checking "<<servers.size() << " servers: " << 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;
+        std::string serviceticks = "";
+        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) + " ";
+        
+        tp.add_row({server.name, server.ssh_user, server.ssh_host, serviceticks, ports_used_str});
+        ++checked;
+        // print out a tick character for each server checked.
+        info << checked << " ✓  " << std::flush;
+    });
+    task->wait();
+    info << std::endl << std::endl;
+    tp.print();
+}
+
+
+
+
+void show_server_details(const std::string& server_name) {
+    server_env_manager env(server_name);
+    if (!env.is_valid()) {
+        error << "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();
+    std::string ssh_user = env.get_SSH_USER();
+    std::string ssh_port = env.get_SSH_PORT();
+    if (!ssh_address.empty()) {
+        info << std::endl << "Server Status:" << std::endl;
+        info << std::string(40, '-') << std::endl;
+        
+        // Try to connect to the server
+        std::string cmd = "ssh -o ConnectTimeout=5 " + ssh_user + "@" + ssh_address + " -p " + ssh_port + " 'true' 2>/dev/null";
+        int result = system(cmd.c_str());
+        if (result == 0) {
+            info << "Status: Online" << std::endl;
+            
+            // // Get uptime if possible
+            // cmd = "ssh " + ssh_address + " 'uptime' 2>/dev/null";
+            // int rval = system(cmd.c_str());
+            // if (rval != 0) {
+            //     std::cout << "Error: Failed to get uptime" << std::endl;
+            // } 
+        } else {
+            warning << "Status: Offline" << std::endl;
+        }
+    }
+    info << std::endl;
+
+    //---------------------
+    {
+        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});
+        }
+        tp.print();
+    }
+
+    //---------------------
+    // list services, and run healthcheck on each
+    {
+        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;
+        std::string serviceticks = "";
+        for (const auto& [service_name, service_status] : status) {
+            std::string healthy = shared_commands::HealthStatus2String(service_status.health);
+            
+            std::string ports_str = "";
+            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});
+        } // end of for (const auto& service : services)
+        tp.print();
+    } // end of list services
+} // end of show_server_details
+
+
+} // namespace dropshell

source/src/commands/nuke.cpp

@@ -0,0 +1,154 @@
+#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

@@ -0,0 +1,251 @@
+#include <unistd.h>
+#include <cstring>
+#include <iostream>
+#include <sstream>
+#include <filesystem>
+
+#include "utils/output.hpp"
+#include "utils/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 "templates.hpp"
+#include "utils/directories.hpp"
+#include "shared_commands.hpp"
+
+namespace dropshell
+{
+
+    int restoredata_handler(const CommandContext &ctx);
+
+    void restoredata_autocomplete(const CommandContext &ctx);
+
+    static std::vector<std::string> restoredata_name_list = {"restoredata", "rd", "restore", "rest"};
+
+    // Static registration
+    struct RestoreDataCommandRegister
+    {
+        RestoreDataCommandRegister()
+        {
+            CommandRegistry::instance().register_command({restoredata_name_list,
+                                                          restoredata_handler,
+                                                          restoredata_autocomplete,
+                                                          false, // hidden
+                                                          true,  // requires_config
+                                                          true,  // requires_install
+                                                          3,     // min_args (after command)
+                                                          3,     // max_args (after command)
+                                                          "restoredata SERVER SERVICE BACKUP_FILE|latest",
+                                                          "Restore data for a service on a server, overwriting the existing data.",
+                                                          // heredoc
+                                                          R"(
+                restoredata SERVER SERVICE BACKUP_FILE     Restore data to a service on a server. Destructive.
+                restoredata SERVER SERVICE latest          Restore the latest backup for the given service.
+
+                Note: This command will not create any service configuration, you need
+                      to have a valid service installed first.
+                      The backup file must be in the local backups directory.
+
+                WARNING: This will permanently overwrite the service's data on the remote server!
+            )"});
+        }
+    } restoredata_command_register;
+
+
+    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();
+        if (local_backups_dir.empty() || !std::filesystem::exists(local_backups_dir))
+        {
+            error << "Error: Local backups directory not found: " << local_backups_dir << std::endl;
+            return {};
+        }
+
+        std::vector<shared_commands::cBackupFileName> backups;
+        for (const auto &entry : std::filesystem::directory_iterator(local_backups_dir))
+        {
+            if (!entry.is_regular_file())
+                continue;
+            std::string filename = entry.path().filename().string();
+            shared_commands::cBackupFileName backup_details(filename);
+            if (backup_details.is_valid())
+                if (match_service.empty() || backup_details.get_service() == match_service)
+                    if (match_template_name.empty() || backup_details.get_template_name() == match_template_name)
+                        backups.push_back(backup_details);
+        }
+
+        // sort backups by datetime
+        std::sort(backups.begin(), backups.end(), [](const shared_commands::cBackupFileName &a, const shared_commands::cBackupFileName &b)
+                  { return a.get_datetime() > b.get_datetime(); });
+
+        return backups;
+    }
+
+
+    int restoredata_handler(const CommandContext &ctx)
+    {
+        ASSERT(ctx.args.size() == 3, "Invalid number of arguments");
+        std::string server = ctx.args[0];
+        std::string service = ctx.args[1];
+        std::string backup_arg = ctx.args[2];
+
+        server_env_manager server_env(server);
+        if (!server_env.is_valid())
+        {
+            error << "Server " << server << " is not valid" << std::endl;
+            return 1;
+        }
+        LocalServiceInfo service_info = get_service_info(server, service);
+        if (!SIvalid(service_info))
+        {
+            error << "Service " << service << " is not valid" << std::endl;
+            return 1;
+        }
+
+        std::optional<shared_commands::cBackupFileName> backup_details;
+        if (backup_arg == "latest")
+        { // special case.
+            std::vector<shared_commands::cBackupFileName> backups = get_backup_files(server, service, service_info.template_name); // this service only (and also match template in case something changed there!).
+            if (backups.empty())
+            {
+                error << "No backups found for " << server << "/" << service << std::endl;
+                debug << "Template also has to match with the service template: " << service_info.template_name << std::endl;
+                return 1;
+            }
+            backup_details = backups[0];
+        } else {
+            backup_details = shared_commands::cBackupFileName(backup_arg);
+            if (!backup_details->is_valid())
+            {
+                error << "Invalid backup file: " << backup_arg << std::endl;
+                return 1;
+            }
+        }
+
+        ASSERT(backup_details.has_value() && backup_details->is_valid(), "Invalid backup file.");
+
+        std::string local_backups_dir = gConfig().get_local_backup_path();
+        if (local_backups_dir.empty() || !std::filesystem::exists(local_backups_dir))
+        {
+            error << "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;
+            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;
+            debug << "Backup template:  " << backup_details->get_template_name() << std::endl;
+            debug << "Service template: " << service_info.template_name << std::endl;
+            debug << "Backup file:      " << local_backup_file_path << std::endl;
+            return 1;
+        }
+
+        info << "Restoring " << backup_details->get_datetime() << " backup of " << backup_details->get_service() << " taken from " << backup_details->get_server() << ", onto " << server << "/" << service << std::endl;
+        info << std::endl;
+        warning << "*** ALL DATA FOR " << server << "/" << service << " WILL BE OVERWRITTEN! ***" << std::endl;
+
+        // run the restore script
+        info << "OK, here goes..." << std::endl;
+
+        { // backup existing service
+            info << "1) Backing up old service... " << std::endl;
+            if (!shared_commands::backupdata_service(server, service))
+            {
+                error << "Error: Backup failed, restore aborted." << std::endl;
+                error << "You can try using   dropshell install " << server << " " << service << "   to install the service afresh." << std::endl;
+                error << "Otherwise, stop the service, create and initialise a new one, then restore to that." << std::endl;
+                return 1;
+            }
+            info << "Backup complete." << std::endl;
+        }
+
+        { // nuke the old service
+            info << "2) Nuking old service..." << std::endl;
+            if (!shared_commands::nuke_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))
+                return 1;
+        }
+
+        { // installing fresh service
+            info << "4) Install of fresh service..." << std::endl;
+            if (!shared_commands::install_service(server, 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 remote_backup_file_path = remote_backups_dir + "/" + backup_details->get_filename();
+
+            // 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))
+            {
+                error << "Failed to copy backup file from local to server" << std::endl;
+                return 1;
+            }
+
+            shared_commands::cRemoteTempFolder remote_temp_folder(server_env);
+            server_env.run_remote_template_command(service, "restore", {}, false, {{"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
+
+
+
+        { // healthcheck the service
+            info << "5) Healthchecking service..." << std::endl;
+            std::string green_tick = "\033[32m✓\033[0m";
+            std::string red_cross = "\033[31m✗\033[0m";
+            bool healthy = (server_env.run_remote_template_command(service, "status", {}, false, {}));
+            info << (healthy ? green_tick : red_cross) << " Service is " << (healthy ? "healthy" : "NOT healthy") << std::endl;
+        }
+
+        return 0;
+    }
+
+
+
+    void restoredata_autocomplete(const CommandContext &ctx)
+    {
+        shared_commands::std_autocomplete(ctx);
+        if (ctx.args.size() == 2) // next arg is the backup file
+        {
+            std::string server = ctx.args[0];
+            std::string service = ctx.args[1];
+
+            LocalServiceInfo service_info = get_service_info(server, service);
+            if (!SIvalid(service_info))
+            {
+                error << "Service " << service << " is not valid" << std::endl;
+                return;
+            }
+            std::string template_name = service_info.template_name;
+
+            std::vector<shared_commands::cBackupFileName> backups = get_backup_files(server, "", template_name); // any service, but must match template.
+
+            // print most recent backup for each {host,service} pair
+            std::map<std::string, std::string> unique_backups;
+            for (const auto &backup : backups)
+            {
+                std::string key = backup.get_server() + "-" + backup.get_service();
+                if (unique_backups.find(key) == unique_backups.end())
+                    unique_backups[key] = backup.get_filename();                
+            }
+            for (const auto &[key, value] : unique_backups)
+                rawout << value << std::endl;
+        }
+    }
+
+} // namespace dropshell

source/src/commands/shared_commands.cpp

@@ -0,0 +1,331 @@
+#include "shared_commands.hpp"
+#include "utils/assert.hpp"
+#include "utils/utils.hpp"
+#include "server_env_manager.hpp"
+#include "directories.hpp"
+#include "services.hpp"
+#include "servers.hpp"
+#include "utils/output.hpp"
+
+namespace dropshell
+{
+
+    namespace shared_commands
+    {
+
+        // ------------------------------------------------------------------------------------------------
+        // std_autocomplete : SHARED COMMAND
+        // ------------------------------------------------------------------------------------------------
+        void std_autocomplete(const CommandContext &ctx)
+        {
+            if (ctx.args.size() == 0)
+            { // just the command, no args yet.
+                // list servers
+                std::vector<ServerInfo> servers = get_configured_servers();
+                for (const auto &server : servers)
+                {
+                    rawout << server.name << std::endl;
+                }
+            }
+            else if (ctx.args.size() == 1)
+            {
+                // list services
+                std::vector<LocalServiceInfo> services = get_server_services_info(ctx.args[0]);
+                for (const auto &service : services)
+                {
+                    rawout << service.service_name << std::endl;
+                }
+            }
+        }
+
+        // ------------------------------------------------------------------------------------------------
+        // std_autocomplete_allowall : SHARED COMMAND
+        // ------------------------------------------------------------------------------------------------
+        void std_autocomplete_allowall(const CommandContext &ctx)
+        {
+            std_autocomplete(ctx);
+            if (ctx.args.size() == 1)
+                rawout << "all" << std::endl;
+        }
+
+        // ------------------------------------------------------------------------------------------------
+        // rsync_tree_to_remote : SHARED COMMAND
+        // ------------------------------------------------------------------------------------------------
+        bool rsync_tree_to_remote(
+            const std::string &local_path,
+            const std::string &remote_path,
+            server_env_manager &server_env,
+            bool silent)
+        {
+            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() + ":" +
+                                          remote_path + "/");
+            return execute_local_command("", rsync_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
+        }
+
+        // ------------------------------------------------------------------------------------------------
+        // get_arch : SHARED COMMAND
+        // ------------------------------------------------------------------------------------------------
+        std::string get_arch()
+        {
+            // determine the architecture of the system
+            std::string arch;
+#ifdef __aarch64__
+            arch = "arm64";
+#elif __x86_64__
+            arch = "amd64";
+#endif
+            return arch;
+        }
+
+        // ------------------------------------------------------------------------------------------------
+        // cRemoteTempFolder : SHARED CLASS
+        // ------------------------------------------------------------------------------------------------
+        cRemoteTempFolder::cRemoteTempFolder(const server_env_manager &server_env) : mServerEnv(server_env)
+        {
+            std::string p = remotepath::temp_files(server_env.get_server_name()) + "/" + 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))
+                error << "Failed to create temp directory on server" << std::endl;
+            else
+                mPath = p;
+        }
+
+        cRemoteTempFolder::~cRemoteTempFolder()
+        {
+            std::string rm_cmd = "rm -rf " + quote(mPath);
+            execute_ssh_command(mServerEnv.get_SSH_INFO(), sCommand("", rm_cmd, {}), cMode::Silent);
+        }
+
+        std::string cRemoteTempFolder::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> status;
+
+            server_env_manager env(server_name);
+            if (!env.is_valid())
+            {
+                error << "Invalid server environment" << std::endl;
+                return status;
+            }
+
+            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)}}),
+                                     cMode::CaptureOutput | cMode::Silent,
+                                     &output))
+                return status;
+
+            std::stringstream ss(output);
+            std::string line;
+            while (std::getline(ss, line))
+            {
+                std::string key, value;
+                std::size_t pos = line.find("=");
+                if (pos != std::string::npos)
+                {
+                    key = dequote(trim(line.substr(0, pos)));
+                    value = dequote(trim(line.substr(pos + 1)));
+
+                    // decode key, it's of format SERVICENAME_[HEALTH|PORTS]
+                    std::string service_name = key.substr(0, key.find_last_of("_"));
+                    std::string status_type = key.substr(key.find_last_of("_") + 1);
+
+                    if (status_type == "HEALTH")
+                    { // healthy|unhealthy|unknown
+                        if (value == "healthy")
+                            status[service_name].health = HealthStatus::HEALTHY;
+                        else if (value == "unhealthy")
+                            status[service_name].health = HealthStatus::UNHEALTHY;
+                        else if (value == "unknown")
+                            status[service_name].health = HealthStatus::UNKNOWN;
+                        else
+                            status[service_name].health = HealthStatus::ERROR;
+                    }
+                    else if (status_type == "PORTS")
+                    { // port1,port2,port3
+                        std::vector<std::string> ports = string2multi(value);
+                        for (const auto &port : ports)
+                        {
+                            if (port != "unknown")
+                                status[service_name].ports.push_back(str2int(port));
+                        }
+                    }
+                }
+            }
+            return status;
+        }
+
+        // ------------------------------------------------------------------------------------------------
+        // healthtick : SHARED COMMAND
+        // ------------------------------------------------------------------------------------------------
+        std::string healthtick(const std::string &server, const std::string &service)
+        {
+            std::string green_tick = "\033[32m✓\033[0m";
+            std::string red_cross = "\033[31m✗\033[0m";
+            std::string yellow_exclamation = "\033[33m!\033[0m";
+            std::string unknown = "\033[37m✓\033[0m";
+
+            HealthStatus status = is_healthy(server, service);
+            if (status == HealthStatus::HEALTHY)
+                return green_tick;
+            else if (status == HealthStatus::UNHEALTHY)
+                return red_cross;
+            else if (status == HealthStatus::UNKNOWN)
+                return unknown;
+            else
+                return yellow_exclamation;
+        }
+
+        // ------------------------------------------------------------------------------------------------
+        // HealthStatus2String : SHARED COMMAND
+        // ------------------------------------------------------------------------------------------------
+        std::string HealthStatus2String(HealthStatus status)
+        {
+            if (status == HealthStatus::HEALTHY)
+                return ":tick:";
+            else if (status == HealthStatus::UNHEALTHY)
+                return ":cross:";
+            else if (status == HealthStatus::UNKNOWN)
+                return ":greytick:";
+            else if (status == HealthStatus::NOTINSTALLED)
+                return ":warning:";
+            else
+                return ":error:";
+        }
+
+        // ------------------------------------------------------------------------------------------------
+        // is_healthy : SHARED COMMAND
+        // ------------------------------------------------------------------------------------------------
+        HealthStatus is_healthy(const std::string &server, const std::string &service)
+        {
+            server_env_manager 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)))
+            {
+                return HealthStatus::NOTINSTALLED;
+            }
+
+            std::string script_path = remotepath::service_template(server, service) + "/status.sh";
+            if (!env.check_remote_file_exists(script_path))
+            {
+                return HealthStatus::UNKNOWN;
+            }
+
+            // Run status script, does not display output.
+            if (!env.run_remote_template_command(service, "status", {}, true, {}))
+                return HealthStatus::UNHEALTHY;
+            return HealthStatus::HEALTHY;
+        }
+
+        // ------------------------------------------------------------------------------------------------
+        // healthmark : SHARED COMMAND
+        // ------------------------------------------------------------------------------------------------
+        std::string healthmark(const std::string &server, const std::string &service)
+        {
+            HealthStatus status = is_healthy(server, service);
+            return HealthStatus2String(status);
+        }
+
+        // ------------------------------------------------------------------------------------------------
+        // cBackupFileName : SHARED CLASS
+        // ------------------------------------------------------------------------------------------------
+        cBackupFileName::cBackupFileName(const std::string &server, const std::string &service, const std::string &template_name)
+        {
+            mServer = server;
+            mService = service;
+            mTemplateName = template_name;
+            // 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");
+            mDatetime = datetime.str();
+        }
+
+        cBackupFileName::cBackupFileName(const std::string &filename)
+        {
+            // Parse the filename according to the format:
+            // server + magic_string() + template_name + magic_string() + service + magic_string() + datetime + ".tgz"
+            std::string name = filename;
+            if (name.size() > 4 && name.substr(name.size() - 4) == ".tgz")
+                name = name.substr(0, name.size() - 4);
+            std::string sep = magic_string();
+            size_t first = name.find(sep);
+            size_t second = name.find(sep, first + sep.size());
+            size_t third = name.find(sep, second + sep.size());
+            if (first == std::string::npos || second == std::string::npos || third == std::string::npos)
+            {
+                mServer = mService = mTemplateName = mDatetime = "";
+                return;
+            }
+            mServer = name.substr(0, first);
+            mTemplateName = name.substr(first + sep.size(), second - (first + sep.size()));
+            mService = name.substr(second + sep.size(), third - (second + sep.size()));
+            mDatetime = name.substr(third + sep.size());
+        }
+
+        std::string cBackupFileName::get_filename() const
+        {
+            return mServer + magic_string() + mTemplateName + magic_string() + mService + magic_string() + mDatetime + ".tgz";
+        }
+
+        std::string cBackupFileName::get_server() const { return mServer; }
+        std::string cBackupFileName::get_service() const { return mService; }
+        std::string cBackupFileName::get_template_name() const { return mTemplateName; }
+        std::string cBackupFileName::get_datetime() const { return mDatetime; }
+
+        bool cBackupFileName::is_valid() const
+        {
+            // All fields must be non-empty, and none may contain the magic string
+            return !mServer.empty() && !mService.empty() && !mTemplateName.empty() && !mDatetime.empty() &&
+                   !has_magic_string(mServer) && !has_magic_string(mService) && !has_magic_string(mTemplateName);
+        }
+
+        // ------------------------------------------------------------------------------------------------
+        // 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)
+        {
+            if (!server_env.is_valid())
+            {
+                error << "Invalid server environment" << std::endl;
+                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" : "");
+            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)
+        {
+            if (!server_env.is_valid())
+            {
+                error << "Invalid server environment" << std::endl;
+                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" : "");
+            return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
+        }
+
+    } // namespace shared_commands
+
+} // namespace dropshell

source/src/commands/shared_commands.hpp

@@ -0,0 +1,101 @@
+#ifndef SHARED_COMMANDS_HPP
+#define SHARED_COMMANDS_HPP
+
+#include "servers.hpp"
+#include "command_registry.hpp"
+#include "server_env_manager.hpp"
+
+namespace dropshell
+{
+
+    namespace shared_commands
+    {
+
+    typedef enum HealthStatus
+    {
+        HEALTHY,
+        UNHEALTHY,
+        NOTINSTALLED,
+        ERROR,
+        UNKNOWN
+    } HealthStatus;
+
+    typedef struct ServiceStatus
+    {
+        HealthStatus health;
+        std::vector<int> ports;
+    } ServiceStatus;
+
+    // expose routines used by multiple commands.
+
+    class cRemoteTempFolder
+    {
+    public:
+        cRemoteTempFolder(const server_env_manager &server_env); // 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;
+    };
+
+    bool rsync_tree_to_remote(
+        const std::string &local_path,
+        const std::string &remote_path,
+        server_env_manager &server_env,
+        bool silent);
+
+    std::string get_arch();
+
+    std::map<std::string, ServiceStatus> get_all_services_status(std::string server_name);
+
+    std::string healthtick(const std::string &server, const std::string &service);
+    std::string HealthStatus2String(HealthStatus status);
+    HealthStatus is_healthy(const std::string &server, const std::string &service);
+    std::string healthmark(const std::string &server, const std::string &service);
+
+    void std_autocomplete(const CommandContext &ctx);
+    void std_autocomplete_allowall(const CommandContext &ctx);
+
+    class cBackupFileName
+    {
+    public:
+        cBackupFileName(const std::string &server, const std::string &service, const std::string &template_name);
+        cBackupFileName(const std::string &filename);
+
+        std::string get_filename() const;
+        std::string get_server() const;
+        std::string get_service() const;
+        std::string get_template_name() const;
+        std::string get_datetime() const;
+
+        bool is_valid() const;
+
+    private:
+        std::string mServer;
+        std::string mService;
+        std::string mTemplateName;
+        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_from_remote(const server_env_manager &server_env, const std::string &remote_path, const std::string &local_path, bool silent);
+
+    // defined in backupdata.cpp, used by restoredata.cpp.
+    bool backupdata_service(const std::string& server, const std::string& service);
+
+    // defined in uninstall.cpp
+    bool uninstall_service(const std::string &server, const std::string &service);
+
+    // defined in nuke.cpp
+    bool nuke_service(const std::string &server, const std::string &service);
+
+    // defined in install.cpp
+    bool install_service(const std::string &server, 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);
+
+    } // namespace shared_commands
+} // namespace dropshell
+#endif

source/src/commands/ssh.cpp

@@ -0,0 +1,109 @@
+#include "command_registry.hpp"
+#include "config.hpp"
+#include "utils/utils.hpp"
+#include "utils/directories.hpp"
+#include "shared_commands.hpp"
+#include "server_env_manager.hpp"
+#include "services.hpp"
+#include "servers.hpp"
+#include "templates.hpp"
+
+namespace dropshell
+{
+
+    int ssh_handler(const CommandContext &ctx);
+
+    static std::vector<std::string> ssh_name_list = {"ssh"};
+
+    // Static registration
+    struct SSHCommandRegister
+    {
+        SSHCommandRegister()
+        {
+            CommandRegistry::instance().register_command({ssh_name_list,
+                                                          ssh_handler,
+                                                          shared_commands::std_autocomplete,
+                                                          false, // hidden
+                                                          true, // requires_config
+                                                          true, // requires_install
+                                                          1,     // min_args (after command)
+                                                          2,     // max_args (after command)
+                                                          "ssh SERVER",
+                                                          "SSH into a server, or into a docker container for a service.",
+                                                          R"(
+                
+                ssh SERVER SERVICE     SSH into a docker container for a service.
+                ssh SERVER             SSH into a server.
+                )"});
+        }
+    } ssh_command_register;
+
+
+
+    bool ssh_into_server(const std::string &server)
+    {
+        server_env_manager 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);
+        return true;
+    }
+
+    bool ssh_into_service(const std::string &server, const std::string &service)
+    {
+        server_env_manager server_env(server);
+        if (!server_env.is_valid())
+        {
+            error << "Server " << server << " is not valid" << std::endl;
+            return false;
+        }
+
+        LocalServiceInfo sinfo = get_service_info(server, service);
+        if (!SIvalid(sinfo))
+        {
+            error << "Service " << service << " is not valid" << std::endl;
+            return false;
+        }
+
+        if (!gTemplateManager().has_template(sinfo.template_name))
+        {
+            error << "Template " << sinfo.template_name << " is not valid" << std::endl;
+            return false;
+        }
+
+        if (!gTemplateManager().template_command_exists(sinfo.template_name, "ssh"))
+        {
+            error << "Template " << sinfo.template_name << " does not have an ssh command" << std::endl;
+            return false;
+        }
+
+        server_env.run_remote_template_command(service,"ssh",{},false,{}); // explicitly supports interactive ssh!
+        return true;
+    }
+
+    int ssh_handler(const CommandContext &ctx)
+    {
+        if (ctx.args.size() < 1)
+        {
+            error << "Server name is required" << std::endl;
+            return 1;
+        }
+
+        std::string server = safearg(ctx.args, 0);
+
+        if (ctx.args.size() < 2)
+        {
+            // ssh into the server
+            return ssh_into_server(server) ? 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

@@ -0,0 +1,92 @@
+#include "command_registry.hpp"
+#include "config.hpp"
+#include "utils/utils.hpp"
+#include "utils/directories.hpp"
+#include "shared_commands.hpp"
+#include "server_env_manager.hpp"
+#include "services.hpp"
+#include "servers.hpp"
+#include "utils/output.hpp"
+
+namespace dropshell
+{
+
+    int start_handler(const CommandContext &ctx);
+
+    static std::vector<std::string> start_name_list = {"start", "start-service"};
+
+    // Static registration
+    struct StartCommandRegister
+    {
+        StartCommandRegister()
+        {
+            CommandRegistry::instance().register_command({start_name_list,
+                                                          start_handler,
+                                                          shared_commands::std_autocomplete_allowall,
+                                                          false, // hidden
+                                                          true, // requires_config
+                                                          true, // requires_install
+                                                          1,     // min_args (after command)
+                                                          2,     // max_args (after command)
+                                                          "start SERVER SERVICE|all",
+                                                          "Start a service or all services on a server.",
+                                                          R"(
+                
+                start SERVER SERVICE     Starts the given service on the given server.
+                start SERVER all         Starts all services on the given server.
+
+                Note: This command will not create any data or configuration.
+                It will simply start the service on the remote server.
+                Stop the service with stop, or uninstall with uninstall.
+                )"});
+        }
+    } start_command_register;
+
+    bool start_service(const std::string &server, const std::string &service)
+    {
+        server_env_manager server_env(server);
+        if (!server_env.is_valid())
+        {
+            error << "Server " << server << " is not valid" << std::endl;
+            return false;
+        }
+
+        // run the start script.
+        bool started = server_env.run_remote_template_command(service, "start", {}, false, {});
+
+        if (started)
+        {
+            info << "Service " << service << " on server " << server << " started." << std::endl;
+            return true;
+        }
+        error << "Failed to start service " << service << " on server " << server << std::endl;
+        return false;
+    }
+
+    int start_handler(const CommandContext &ctx)
+    {
+        if (ctx.args.size() < 2)
+        {
+            std::cerr << "Error: Server name and service name are both required" << std::endl;
+            return 1;
+        }
+
+        std::string server = safearg(ctx.args, 0);
+        std::string service = safearg(ctx.args, 1);
+
+        if (service == "all")
+        {
+            // install all services on the server
+            maketitle("Stopping all services on " + server);
+            bool okay = true;
+            std::vector<LocalServiceInfo> services = get_server_services_info(server);
+            for (const auto &service : services)
+                okay &= start_service(server, service.service_name);
+            return okay ? 0 : 1;
+        }
+
+        // start the specific service.
+        return start_service(server, service) ? 0 : 1;
+    }
+
+} // namespace dropshell

source/src/commands/stop.cpp

@@ -0,0 +1,92 @@
+#include "command_registry.hpp"
+#include "config.hpp"
+#include "utils/utils.hpp"
+#include "utils/directories.hpp"
+#include "shared_commands.hpp"
+#include "server_env_manager.hpp"
+#include "services.hpp"
+#include "servers.hpp"
+#include "utils/output.hpp"
+
+namespace dropshell
+{
+
+    int stop_handler(const CommandContext &ctx);
+
+    static std::vector<std::string> stop_name_list = {"stop", "stop-service"};
+
+    // Static registration
+    struct StopCommandRegister
+    {
+        StopCommandRegister()
+        {
+            CommandRegistry::instance().register_command({stop_name_list,
+                                                          stop_handler,
+                                                          shared_commands::std_autocomplete_allowall,
+                                                          false, // hidden
+                                                          true, // requires_config
+                                                          true, // requires_install
+                                                          1,     // min_args (after command)
+                                                          2,     // max_args (after command)
+                                                          "stop SERVER SERVICE|all",
+                                                          "Stop a service or all services on a server.",
+                                                          R"(
+                
+                stop SERVER SERVICE     Stops the given service on the given server.
+                stop SERVER all         Stops all services on the given server.
+
+                Note: This command will not destroy any data or configuration.
+                It will simply stop the service on the remote server.
+                Restart the service with start, or update and start it with install.
+                )"});
+        }
+    } stop_command_register;
+
+    bool stop_service(const std::string &server, const std::string &service)
+    {
+        server_env_manager server_env(server);
+        if (!server_env.is_valid())
+        {
+            error << "Server " << server << " is not valid" << std::endl;
+            return false;
+        }
+
+        // run the stop script.
+        bool stopped = server_env.run_remote_template_command(service, "stop", {}, false, {});
+
+        if (stopped)
+        {
+            info << "Service " << service << " on server " << server << " stopped." << std::endl;
+            return true;
+        }
+        error << "Failed to stop service " << service << " on server " << server << std::endl;
+        return false;
+    }
+
+    int stop_handler(const CommandContext &ctx)
+    {
+        if (ctx.args.size() < 2)
+        {
+            error << "Server name and service name are both required" << std::endl;
+            return 1;
+        }
+
+        std::string server = safearg(ctx.args, 0);
+        std::string service = safearg(ctx.args, 1);
+
+        if (service == "all")
+        {
+            // install all services on the server
+            maketitle("Stopping all services on " + server);
+            bool okay = true;
+            std::vector<LocalServiceInfo> services = get_server_services_info(server);
+            for (const auto &service : services)
+                okay &= stop_service(server, service.service_name);
+            return okay ? 0 : 1;
+        }
+
+        // stop the specific service.
+        return stop_service(server, service) ? 0 : 1;
+    }
+
+} // namespace dropshell

source/src/commands/uninstall.cpp

@@ -0,0 +1,109 @@
+#include "command_registry.hpp"
+#include "directories.hpp"
+#include "shared_commands.hpp"
+#include "templates.hpp"
+
+#include "utils/assert.hpp"
+#include "utils/utils.hpp"
+#include "services.hpp"
+
+namespace dropshell
+{
+
+    int uninstall_handler(const CommandContext &ctx);
+
+    static std::vector<std::string> uninstall_name_list = {"uninstall", "remove"};
+
+    // Static registration
+    struct UninstallCommandRegister
+    {
+        UninstallCommandRegister()
+        {
+            CommandRegistry::instance().register_command({uninstall_name_list,
+                                                          uninstall_handler,
+                                                          shared_commands::std_autocomplete_allowall,
+                                                          false, // hidden
+                                                          true,  // requires_config
+                                                          true,  // requires_install
+                                                          2,     // min_args (after command)
+                                                          2,     // max_args (after command)
+                                                          "uninstall SERVER SERVICE|all",
+                                                          "Uninstall a service on a server. Does not remove configuration or user data.",
+                                                          // heredoc
+                                                          R"(
+            Uninstall a service, leaving all configuration and data intact.
+
+            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.
+                )"});
+        }
+    } uninstall_command_register;
+
+    namespace shared_commands {
+        bool uninstall_service(const std::string &server, const std::string &service)
+        {
+            maketitle("Uninstalling " + service + " on " + server);
+
+            server_env_manager server_env(server);
+            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)))
+            {
+                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";
+            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))
+            {
+                ASSERT(!server_env.check_remote_dir_exists(remotepath::service(server, service)), "Service directory still found on server after uninstall");
+                info << "Removed remote service directory " << remotepath::service(server, service) << std::endl;
+            }
+            else
+                warning << "Failed to remove remote service directory" << std::endl;
+
+            info << "Completed service " << service << " uninstall on " << server << std::endl;
+            return true;
+        }
+    } // namespace shared_commands
+
+    int uninstall_handler(const CommandContext &ctx)
+    {
+        if (ctx.args.size() < 1)
+        {
+            error << "uninstall requires a server and a service (or all)" << std::endl;
+            return 1;
+        }
+
+        std::string server = safearg(ctx.args, 0);
+
+        if (safearg(ctx.args, 1) == "all")
+        {
+            // uninstall all services on the server
+            bool okay = true;
+            std::vector<LocalServiceInfo> services = get_server_services_info(server);
+            for (const auto &service : services)
+            {
+                if (!shared_commands::uninstall_service(server, service.service_name))
+                    okay = false;
+            }
+            return okay ? 0 : 1;
+        }
+
+        std::string service = safearg(ctx.args, 1);
+        return shared_commands::uninstall_service(server, service) ? 0 : 1;
+    }
+
+} // namespace dropshell

source/src/commands/version.cpp

@@ -0,0 +1,45 @@
+#include "command_registry.hpp"
+#include "version.hpp"
+namespace dropshell {
+
+    int version_handler(const CommandContext &ctx);
+
+    static std::vector<std::string> version_name_list = {"version","v","ver","-v","-ver","--version"};
+
+    void version_autocomplete(const CommandContext &ctx)
+    {
+    }
+
+    // Static registration
+    struct VersionCommandRegister
+    {
+        VersionCommandRegister()
+        {
+            CommandRegistry::instance().register_command({version_name_list,
+                                                          version_handler,
+                                                          version_autocomplete,
+                                                          false, // hidden
+                                                          false, // requires_config
+                                                          false, // requires_install
+                                                          0,     // min_args (after command)
+                                                          0,     // max_args (after command)
+                                                          "version",
+                                                          "Uninstall a service on a server. Does not remove configuration or user data.",
+                                                          // heredoc
+                                                          R"(
+                Uninstall a service on a server. Does not remove configuration or user data.
+                uninstall <server> <service>    uninstall the given service on the given server.
+                uninstall <server>              uninstall all services on the given server.
+                )"});
+        }
+    } version_command_register;
+
+
+    int version_handler(const CommandContext &ctx)
+    {
+        std::cout << VERSION << std::endl;
+        return 0;
+    }
+
+
+} // namespace dropshell

source/src/config.cpp

@@ -0,0 +1,169 @@
+#include "utils/directories.hpp"
+#include <iostream>
+#include <fstream>
+#include "config.hpp"
+#include "utils/utils.hpp"
+#include "utils/json.hpp"
+#include <filesystem>
+#include "utils/execute.hpp"
+#include "output.hpp"
+
+
+namespace dropshell {
+
+
+config & gConfig() {
+    static config *globalConfig = new config();
+    return *globalConfig;
+}
+
+
+config::config() : mIsConfigSet(false) {
+}
+
+config::~config() {
+}
+
+bool config::load_config() { // load json config file.
+    std::string config_path = localfile::dropshell_json();
+    if (config_path.empty() || !std::filesystem::exists(config_path))
+        return false;
+
+    std::ifstream config_file(config_path);
+    if (!config_file.is_open())
+        return false;
+
+    try {
+        mConfig = nlohmann::json::parse(config_file);
+    }
+    catch (nlohmann::json::parse_error& ex)
+    {
+        std::cerr << "Error: Failed to parse config file: " << ex.what() << std::endl;
+        return false;
+    }
+
+    mIsConfigSet = true;
+    return true;
+}
+
+bool config::save_config(bool create_aux_directories)
+{
+    std::string config_path = localfile::dropshell_json();
+    if (config_path.empty())
+        return false;
+
+    std::filesystem::create_directories(get_parent(config_path));
+
+    std::ofstream config_file(config_path);
+    if (!config_file.is_open())
+        return false;
+
+    if (!mIsConfigSet)
+    {
+        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_upload_registry_token"] = "SECRETTOKEN";
+    }   
+
+    config_file << mConfig.dump(4);
+    config_file.close();
+
+    if (create_aux_directories) {
+        std::vector<std::filesystem::path> paths = {
+            get_local_template_cache_path(),
+            get_local_backup_path(),
+            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))
+            {
+                std::cout << "Creating directory: " << p << std::endl;
+                std::filesystem::create_directories(p);
+            }
+    }
+    
+    return true;
+}
+
+bool config::is_config_set() const
+{   
+    return mIsConfigSet;
+}
+
+bool config::is_agent_installed()
+{
+    return std::filesystem::exists(localpath::agent() + "/bb64");
+}
+
+std::string config::get_local_tempfiles_path() {
+    return mConfig["tempfiles"];
+}
+
+std::string config::get_local_backup_path() {
+    return mConfig["backups"];
+}
+
+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;
+}
+
+std::vector<std::string> config::get_template_local_paths()
+{
+    nlohmann::json template_local_paths = mConfig["template_local_paths"];
+    std::vector<std::string> paths;
+    for (auto &path : template_local_paths) {
+        if (path.is_string() && !path.empty())
+            paths.push_back(path);
+    }
+    return 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() {
+    return mConfig["template_upload_registry_url"];
+}
+
+std::string config::get_template_upload_registry_token() {
+    return mConfig["template_upload_registry_token"];
+}
+
+} // namespace dropshell 

source/src/config.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include "utils/json.hpp"
+
+namespace dropshell {
+
+class config {
+    public:
+        config();
+        ~config();
+
+        bool load_config();
+        bool save_config(bool create_aux_directories);
+
+        bool is_config_set() const;
+        static bool is_agent_installed();
+
+        std::string get_local_tempfiles_path();
+        std::string get_local_backup_path();
+        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_template_upload_registry_token();
+
+    private:
+        nlohmann::json mConfig;
+        bool mIsConfigSet;
+};
+
+
+config & gConfig();
+
+} // namespace dropshell 

source/src/main.cpp

@@ -0,0 +1,256 @@
+#include "version.hpp"
+#include "config.hpp"
+#include "services.hpp"
+#include "servers.hpp"
+#include "utils/directories.hpp"
+#include "templates.hpp"
+#include "utils/utils.hpp"
+#include "autocomplete.hpp"
+#include "utils/hash.hpp"
+#include "command_registry.hpp"
+#include "output.hpp"
+
+#include <filesystem>
+#include <iostream>
+#include <string>
+#include <vector>
+#include <iomanip>
+#include <chrono>
+#include <assert.hpp>
+#include <sstream>
+#include <algorithm>
+namespace dropshell {
+
+extern const std::string VERSION;
+extern const std::string RELEASE_DATE;
+extern const std::string AUTHOR;
+extern const std::string LICENSE;
+
+
+int main(int argc, char* argv[]) {
+
+    try {
+        // silently attempt to load the config file and templates.
+        gConfig().load_config();
+        if (gConfig().is_config_set())
+            gTemplateManager().load_sources();
+
+
+        // process the command line arguments.
+        std::vector<std::string> args(argv, argv + argc);
+
+        if (args.size() < 2) 
+            args.push_back("help");
+        ASSERT(args.size() > 1, "No command provided, logic error.");
+
+        CommandContext ctx{args[0], args[1], std::vector<std::string>(args.begin() + 2, args.end())};
+
+        if (ctx.command == "autocomplete") {
+            CommandRegistry::instance().autocomplete(ctx);
+            return 0;
+        }
+
+        const CommandInfo* cmdinfo = CommandRegistry::instance().find_command(ctx.command);
+        if (!cmdinfo) {
+            error << "Unknown command: " << ctx.command << std::endl;
+            return 1;
+        }
+        if (cmdinfo->requires_config && !gConfig().is_config_set()) {
+            error << "Valid dropshell configuration required for command: " << ctx.command << std::endl;
+            info << "Please run 'dropshell edit' to set up the dropshell configuration." << std::endl;
+            return 1;
+        }
+        if (cmdinfo->requires_install && !gConfig().is_agent_installed()) {
+            error << "Dropshell agent not installed for command: " << ctx.command << std::endl;
+            info << "Please run 'dropshell install' to install the local dropshell agent." << std::endl;
+            return 1;
+        }
+
+        int arg_count = ctx.args.size();
+        if (arg_count < cmdinfo->min_args || (cmdinfo->max_args != -1 && arg_count > cmdinfo->max_args)) {
+            error << "Invalid number of arguments for command: " << ctx.command << std::endl;
+            debug << "(" << ctx.args.size() << " args provided, " << ctx.command << " requires " << (cmdinfo->min_args) << " to " << (cmdinfo->max_args) << " args)" << std::endl;
+            info << "Usage: " << std::endl;
+            info << "  ";
+            info << left_align(cmdinfo->help_usage,30);
+            info << cmdinfo->help_description << std::endl;
+            return 1;
+        }
+        return cmdinfo->handler(ctx);
+
+    }
+    catch (const std::exception& e) {
+        std::cerr << "Error: " << e.what() << std::endl;
+        return 1;
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+// ------------------------------------------------------------------------------------------------
+
+struct ServerAndServices {
+    std::string server_name;
+    std::vector<LocalServiceInfo> servicelist;
+};
+
+bool getCLIServices(const std::string & arg2, const std::string & arg3, 
+    ServerAndServices & server_and_services)
+{
+    if (arg2.empty()) return false;
+    server_and_services.server_name = arg2;
+
+    if (arg3.empty()) {
+        server_and_services.servicelist = get_server_services_info(arg2);
+    } else {
+        server_and_services.servicelist.push_back(get_service_info(arg2, arg3));
+    }
+    return true;
+}
+
+auto command_match = [](const std::string& cmd_list, int argc, char* argv[]) -> bool {
+    std::istringstream iss(cmd_list);
+    std::string cmd_item;
+    while (iss >> cmd_item) {
+        if (cmd_item == safearg(argc, argv, 1)) {
+            return true;
+        }
+    }
+    return false;
+};
+
+#define BOOLEXIT(CMD_LIST, RUNCMD) { \
+    if (command_match(CMD_LIST, argc, argv)) { \
+        return (RUNCMD) ? 0 : 1; \
+    } \
+}
+
+#define HAPPYEXIT(CMD_LIST, RUNCMD) { \
+    if (command_match(CMD_LIST, argc, argv)) { \
+        RUNCMD; \
+        return 0; \
+    } \
+}
+
+
+// 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[]) {
+    return dropshell::main(argc, argv);
+}

source/src/server_env_manager.cpp

@@ -0,0 +1,231 @@
+#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);
+
+    cMode mode = cMode::CaptureOutput;
+    return execute_ssh_command(get_SSH_INFO(), scommand.value(), mode, &output);
+}
+
+
+
+// base64 <<< "FOO=BAR WHEE=YAY bash ./test.sh"
+// echo YmFzaCAtYyAnRk9PPUJBUiBXSEVFPVlBWSBiYXNoIC4vdGVzdC5zaCcK | base64 -d | bash
+
+
+} // namespace dropshell

source/src/server_env_manager.hpp

@@ -0,0 +1,77 @@
+// 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

@@ -0,0 +1,125 @@
+#include "servers.hpp"
+#include "server_env_manager.hpp"
+#include "utils/tableprint.hpp"
+#include "utils/envmanager.hpp"
+#include "utils/directories.hpp"
+#include "services.hpp"
+#include "config.hpp"
+#include "templates.hpp"
+#include "contrib/transwarp.hpp"
+
+#include <iostream>
+#include <fstream>
+#include <iomanip>
+#include <filesystem>
+
+namespace dropshell {
+
+std::vector<ServerInfo> get_configured_servers() {
+    std::vector<ServerInfo> 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;
+
+                    server_env_manager env(server_name);
+                    if (!env.is_valid()) {
+                        std::cerr << "Error: Invalid server environment file: " << entry.path().string() << std::endl;
+                        continue;
+                    }
+                    servers.push_back({
+                        server_name,
+                        env.get_SSH_HOST(),
+                        env.get_SSH_USER(),
+                        env.get_SSH_PORT()
+                    });
+                }
+            }
+        }
+    }
+
+    return servers;
+}
+
+ServerInfo get_server_info(const std::string &server_name)
+{
+    std::vector<std::string> lsdp = gConfig().get_local_server_definition_paths();
+    if (lsdp.empty())
+        return ServerInfo();
+
+    for (auto &config_dir : lsdp) {
+        std::string server_dir = config_dir + "/" + server_name;
+        if (std::filesystem::exists(server_dir)) {
+            server_env_manager env(server_name);
+            if (!env.is_valid()) {
+                std::cerr << "Error: Invalid server environment file: " << server_dir << std::endl;
+                continue;
+            }
+            return ServerInfo({server_name, env.get_SSH_HOST(), env.get_SSH_USER(), env.get_SSH_PORT()});
+        }
+    }
+    return ServerInfo();
+}
+
+
+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);
+        for (const auto& service : services) 
+            commands.merge(dropshell::get_used_commands(server.name, service.service_name));
+    }
+}
+
+} // namespace dropshell

source/src/servers.hpp

@@ -2,10 +2,9 @@
 #define SERVERS_HPP
 
 #include <string>
+#include <set>
 #include <vector>
 
-#include "service_runner.hpp" // for ServiceStatus
-
 namespace dropshell {
 
     // Server information structure
@@ -17,10 +16,10 @@ namespace dropshell {
     };
 
     std::vector<ServerInfo> get_configured_servers();
-    void list_servers();
-    void show_server_details(const std::string& server_name);
 
-    void create_server(const std::string& server_name);
+    ServerInfo get_server_info(const std::string& server_name);
+
+    bool create_server(const std::string& server_name);
    
     void get_all_used_commands(std::set<std::string> &commands);
 

source/src/service_runner.cpp

@@ -0,0 +1,529 @@
+
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <cstdlib>
+#include <chrono>
+#include <iomanip>
+#include <filesystem>
+#include <unistd.h>
+#include "utils/assert.hpp"
+
+#include "config.hpp"
+#include "server_env_manager.hpp"
+#include "templates.hpp"
+#include "services.hpp"
+#include "utils/directories.hpp"
+#include "utils/utils.hpp"
+#include "command_registry.hpp"
+#include "shared_commands.hpp"
+
+
+
+
+namespace dropshell {
+
+
+
+class service_runner {
+    public:
+        service_runner(const std::string& server_name, const std::string& service_name);
+        bool isValid() const { return mValid; }
+
+        // run a command over ssh, using the credentials from server.env (via server_env.hpp)
+        // first check that the command corresponds to a valid .sh file in the service directory
+        // then run the command, passing the {service_name}.env file as an argument
+        // do a lot of checks, such as:
+        // checking that we can ssh to the server.
+        // checking whether the service directory exists on the server.
+        // checking that the command exists in the service directory.
+        // checking that the command is a valid .sh file.
+        // checking that the {service_name}.env file exists in the service directory.
+        bool run_command(const std::string& command, std::vector<std::string> additional_args={}, std::map<std::string, std::string> env_vars={});
+
+        // 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();
+        // std::string healthmark();
+
+    public:            
+        // backup and restore
+        bool backup(bool silent=false);
+        bool restore(std::string backup_file, bool silent=false);
+
+        // nuke the service
+        bool nuke(bool silent=false); // nukes all data for this service on the remote server
+        bool fullnuke(); // nuke all data for this service on the remote server, and then nukes all the local service definitionfiles
+
+        // launch an interactive ssh session on a server or service
+        // replaces the current dropshell process with the ssh process
+        bool interactive_ssh_service();
+
+        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:
+        // utility functions
+        static std::string get_latest_backup_file(const std::string& server, const std::string& service);
+        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);
+
+    private:
+        std::string mServer;
+        server_env_manager mServerEnv;
+        LocalServiceInfo mServiceInfo;
+        std::string mService;
+        bool mValid;
+
+        // Helper methods
+    public:
+};
+
+
+} // namespace dropshell
+
+
+
+namespace fs = std::filesystem;
+
+namespace dropshell {
+
+
+service_runner::service_runner(const std::string& server_name, const std::string& service_name) : 
+    mServerEnv(server_name), mServer(server_name), mService(service_name), mValid(false)
+{
+    if (server_name.empty() || service_name.empty())
+        return; 
+
+    // Initialize server environment
+    if (!mServerEnv.is_valid()) 
+        return;
+
+    mServiceInfo = get_service_info(server_name, service_name);
+    if (mServiceInfo.service_name.empty())
+        return;
+
+    mService = mServiceInfo.service_name;
+    
+    mValid = !mServiceInfo.local_template_path.empty();
+}
+
+
+
+bool service_runner::nuke(bool silent)
+{
+    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

@@ -0,0 +1,223 @@
+#include "services.hpp"
+#include "utils/envmanager.hpp"
+#include "utils/directories.hpp"
+#include "templates.hpp"
+#include "config.hpp"
+#include "utils/utils.hpp"
+#include "server_env_manager.hpp"
+#include "servers.hpp"
+#include "assert.hpp"
+
+#include <iostream>
+#include <filesystem>
+
+namespace fs = std::filesystem;
+
+namespace dropshell {   
+
+    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();
+    }
+
+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;
+        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()) {
+        std::cerr << "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()) {
+        std::cerr << "Error: Template '" << service.template_name << "' not found" << std::endl;
+        return LocalServiceInfo();
+    }
+
+    // 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());
+                }
+        }
+    }
+    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)))
+    {
+        std::cerr << "Error: Service not found: " << service_name << " on server " << server_name << std::endl;
+        return false;
+    }
+
+    ServerInfo server_info = get_server_info(server_name);
+    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
+            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";
+    if (!fs::exists(default_env_file)) {
+        std::cerr << "Error: Template default env file '" << default_env_file << "' not found" << std::endl;
+        return false;
+    }
+
+    load_env_file(default_env_file);
+    return true;
+}
+
+} // namespace dropshell

source/src/services.hpp

@@ -4,25 +4,29 @@
 #include <string>
 #include <vector>
 #include <set>
+#include <map>
 
 namespace dropshell {
 
-    struct ServiceInfo {
+    struct LocalServiceInfo {
         std::string service_name;
         std::string template_name;
         std::string local_service_path;
         std::string local_template_path;
-        std::string local_template_default_env_path;
     };
     
-    std::vector<ServiceInfo> get_server_services_info(const std::string& server_name);
-    ServiceInfo get_service_info(const std::string& server_name, const std::string& service_name);
+    bool SIvalid(const LocalServiceInfo& service_info);
+    
+    std::vector<LocalServiceInfo> get_server_services_info(const std::string& server_name);
+
+    LocalServiceInfo get_service_info(const std::string& server_name, const std::string& service_name);
     std::set<std::string> get_used_commands(const std::string& server_name, const std::string& service_name);
 
+    // get all env vars for a given service
+    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);
+
     // 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);
-
-    bool create_service(const std::string& server_name, const std::string& template_name, const std::string& service_name, bool silent=false);
 } // namespace dropshell
 
 #endif

source/src/templates.cpp

@@ -0,0 +1,383 @@
+    #include <filesystem>
+    #include <iostream>
+    #include <fstream>
+    #include <vector>
+    #include <string>
+    #include <algorithm>
+    #include <iomanip>
+    #include <map>
+    #include "utils/assert.hpp"
+
+    #include "utils/envmanager.hpp"
+    #include "utils/directories.hpp"
+    #include "utils/utils.hpp"
+    #include "templates.hpp"
+    #include "config.hpp"   
+
+    namespace dropshell {
+
+    // ------------------------------------------------------------------------------------------------
+    // template_source_local
+    // ------------------------------------------------------------------------------------------------
+
+    std::set<std::string> template_source_local::get_template_list() {
+        std::set<std::string> templates;
+            
+        // Helper function to add templates from a directory
+        auto add_templates_from_dir = [&templates](const std::string& dir_path) {
+            if (!std::filesystem::exists(dir_path)) 
+                return;
+            
+            for (const auto& entry : std::filesystem::directory_iterator(dir_path)) 
+                if (entry.is_directory()) 
+                    templates.insert(entry.path().filename().string());
+        };
+
+        add_templates_from_dir(mLocalPath);
+        return templates;
+    }
+
+    bool template_source_local::has_template(const std::string& template_name) {
+        std::filesystem::path path = mLocalPath / template_name;
+        return (std::filesystem::exists(path));
+    }
+
+    bool template_source_local::template_command_exists(const std::string& template_name, const std::string& command) {
+        std::filesystem::path path = mLocalPath / template_name / (command+".sh");
+        return std::filesystem::exists(path);
+    }    
+
+    template_info template_source_local::get_template_info(const std::string& template_name) {
+        std::filesystem::path path = mLocalPath / template_name;
+
+        if (!std::filesystem::exists(path)) 
+            return template_info();
+
+        return template_info(
+            template_name,
+            mLocalPath.string(),
+            path
+        );
+    }
+
+
+    
+    // ------------------------------------------------------------------------------------------------
+    // template_source_registry
+    // ------------------------------------------------------------------------------------------------
+
+    std::set<std::string> template_source_registry::get_template_list()
+    {
+        #pragma message("TODO: Implement template_source_registry::get_template_list")
+        return std::set<std::string>();
+    }
+
+    bool template_source_registry::has_template(const std::string& template_name)
+    {
+        #pragma message("TODO: Implement template_source_registry::has_template")
+        return false;
+    }
+
+    template_info template_source_registry::get_template_info(const std::string& template_name)
+    {
+        #pragma message("TODO: Implement template_source_registry::get_template_info")
+        return template_info();
+    }
+
+    bool template_source_registry::template_command_exists(const std::string& template_name, const std::string& command)
+    {
+        #pragma message("TODO: Implement template_source_registry::template_command_exists")
+        return false;
+    }
+
+    std::filesystem::path template_source_registry::get_cache_dir()
+    {
+        #pragma message("TODO: Implement template_source_registry::get_cache_dir")
+        return std::filesystem::path();
+    }
+
+
+
+
+
+    // ------------------------------------------------------------------------------------------------
+    // template_manager
+    // ------------------------------------------------------------------------------------------------
+
+    void template_manager::list_templates() const {
+        ASSERT(mLoaded && mSources.size() > 0, "Template manager not loaded, or no template sources found.");
+        auto templates = get_template_list();
+        
+        if (templates.empty()) {
+            std::cout << "No templates found." << std::endl;
+            return;
+        }
+        
+        std::cout << "Available templates:" << std::endl;
+
+        // print templates.
+        std::cout << std::string(60, '-') << std::endl;        
+        bool first = true;
+        for (const auto& t : templates) {
+            std::cout << (first ? "" : ", ") << t;
+            first = false;
+        }
+        std::cout << std::endl;
+        std::cout << std::string(60, '-') << std::endl;
+    }
+
+    std::set<std::string> template_manager::get_template_list() const
+    {
+        ASSERT(mLoaded && mSources.size() > 0, "Template manager not loaded, or no template sources found.");
+        std::set<std::string> templates;
+        for (const auto& source : mSources) {
+            auto source_templates = source->get_template_list();
+            templates.insert(source_templates.begin(), source_templates.end());
+        }
+        return templates;
+    }
+
+    bool template_manager::has_template(const std::string &template_name) const
+    {
+        ASSERT(mLoaded && mSources.size() > 0, "Template manager not loaded, or no template sources found.");
+        template_source_interface* source = get_source(template_name);
+        if (!source) 
+            return false;
+        return true;
+    }
+
+    template_info template_manager::get_template_info(const std::string &template_name) const
+    {
+        ASSERT(mLoaded && mSources.size() > 0, "Template manager not loaded, or no template sources found.");
+        template_source_interface* source = get_source(template_name);
+        if (source)
+            return source->get_template_info(template_name);
+
+        // fail
+        return template_info();
+}
+
+    bool template_manager::template_command_exists(const std::string &template_name, const std::string &command) const
+    {
+        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;
+            return false;
+        }
+        return source->template_command_exists(template_name, command);
+    }
+
+    bool template_manager::create_template(const std::string &template_name) const
+    {
+        // 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;
+            std::cerr << "Run 'dropshell edit' to configure DropShell" << std::endl;
+            return false;
+        }
+
+        auto info = get_template_info(template_name);
+        if (info.is_set()) {
+            std::cerr << "Error: Template '" << template_name << "' already exists at " << info.locationID() << std::endl;
+            return false;
+        }
+
+        auto local_template_paths = gConfig().get_template_local_paths();
+        if (local_template_paths.empty()) {
+            std::cerr << "Error: No local template paths found" << std::endl;
+            std::cerr << "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;
+        
+        // Create the new template directory
+        std::filesystem::create_directories(new_template_path);
+        
+        // 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;
+            return false;
+        }
+        std::string example_template_path = example_info.local_template_path();
+                
+        // Copy all files from example template to new template
+        for (const auto& entry : std::filesystem::recursive_directory_iterator(example_template_path)) {
+            std::string relative_path = entry.path().string().substr(example_template_path.length());
+            std::string target_path = new_template_path + relative_path;
+            
+            if (entry.is_directory()) {
+                std::filesystem::create_directory(target_path);
+            } else {
+                std::filesystem::copy_file(entry.path(), target_path);
+            }
+        }
+
+        // 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";
+        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;
+            return false;
+        }
+
+        // 3. Print out the README.txt file and the path
+        std::string readme_path = new_template_path + "/README.txt";
+        if (std::filesystem::exists(readme_path)) {
+            std::cout << "\nREADME contents:" << std::endl;
+            std::cout << std::string(60, '-') << std::endl;
+            
+            std::ifstream readme_file(readme_path);
+            if (readme_file.is_open()) {
+                std::string line;
+                while (std::getline(readme_file, line)) {
+                    std::cout << line << std::endl;
+                }
+                readme_file.close();
+            }
+            std::cout << std::string(60, '-') << std::endl;
+        } 
+
+        std::cout << std::endl;
+        std::cout << "Template '" << template_name << "' created at " << new_template_path << std::endl;
+        return test_template(new_template_path);
+    }
+
+    void template_manager::load_sources()
+    {
+        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();
+        if (local_template_paths.empty())
+            return;
+        for (const auto& path : local_template_paths) 
+            mSources.push_back(std::make_unique<template_source_local>(path));
+
+        auto registry_urls = gConfig().get_template_registry_urls();
+        for (const auto& url : registry_urls) 
+            mSources.push_back(std::make_unique<template_source_registry>(url));
+
+        mLoaded = true;
+    }
+
+    void template_manager::print_sources() const
+    {
+        std::cout << "Template sources: ";
+        for (const auto& source : mSources) {
+            std::cout << "[" << source->get_description() << "] ";
+        }
+        std::cout << std::endl;
+    }
+
+    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;
+            return false;
+        }
+        return true;
+    }
+
+    template_source_interface *template_manager::get_source(const std::string &template_name) const
+    {
+        ASSERT(mLoaded && mSources.size() > 0, "Template manager not loaded, or no template sources found.");
+        for (const auto& source : mSources) {
+            if (source->has_template(template_name)) {
+                return source.get();
+            }
+        }
+        return nullptr;
+    }
+
+    bool template_manager::test_template(const std::string &template_path)
+    {
+        if (template_path.empty())
+            return false;
+
+        if (!std::filesystem::exists(template_path))
+            return false;
+
+        std::string template_name = std::filesystem::path(template_path).filename().string();
+
+        std::vector<std::string> required_files = {
+            "config/service.env",
+            "config/.template_info.env",
+            "_default.env",
+            "install.sh",
+            "uninstall.sh"
+        };
+
+        for (const auto& file : required_files) {
+            if (!required_file(template_path + "/" + file, template_name)) 
+                return false;
+
+            // check if file is executable, if it ends in .sh
+            std::string suffix=".sh";
+            if (file.find(suffix) == file.size() - suffix.size())
+            {
+                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;
+            }
+        }        
+
+        // ------------------------------------------------------------
+        // check TEMPLATE= line.
+        std::map<std::string, std::string> all_env_vars;
+        std::vector<std::string> env_files = {
+            "config/service.env",
+            "config/.template_info.env"
+        };
+        for (const auto& file : env_files) {
+            { // load service.env from the service on this machine.
+            std::map<std::string, std::string> env_vars;
+            envmanager env_manager(template_path + "/" + file);
+            env_manager.load();
+            env_manager.get_all_variables(env_vars);
+            all_env_vars.merge(env_vars);
+            }
+        }
+
+        // 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;
+            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;
+            return false;
+        }
+
+        if (env_template_name != template_name) {
+            std::cerr << "Error: TEMPLATE variable is wrong in " << template_path << std::endl;
+            return false;
+        }
+
+        return true;
+    }
+
+    template_manager & gTemplateManager()
+    {
+        static template_manager instance;
+        return instance;
+    }
+
+    template_info::template_info(const std::string &template_name, const std::string &location_id, const std::filesystem::path &local_template_path) :
+        mTemplateName(template_name),
+        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())
+    {
+    }
+
+    } // namespace dropshell

source/src/templates.hpp

@@ -0,0 +1,112 @@
+#include <string>
+#include <vector>
+#include <filesystem>
+#include <memory>
+#include <set>
+
+#include "utils/json.hpp"
+
+namespace dropshell {
+
+typedef enum template_source_type {
+    TEMPLATE_SOURCE_TYPE_LOCAL,
+    TEMPLATE_SOURCE_TYPE_REGISTRY,
+    TEMPLATE_SOURCE_NOT_SET
+} template_source_type;
+
+class template_info {
+    public:
+        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; }
+        std::string name() { return mTemplateName; }
+        std::string locationID() { return mLocationID; }
+        std::filesystem::path local_template_path() { return mTemplateLocalPath; }
+        bool template_valid() { return mTemplateValid; }
+    private:
+        std::string mTemplateName;
+        std::string mLocationID;
+        std::filesystem::path mTemplateLocalPath; // source or cache.
+        bool mTemplateValid;
+        bool mIsSet;
+};
+
+class template_source_interface {
+    public:
+        virtual ~template_source_interface() {}
+        virtual std::set<std::string> get_template_list() = 0;
+        virtual bool has_template(const std::string& template_name) = 0;
+        virtual template_info get_template_info(const std::string& template_name) = 0;
+        virtual bool template_command_exists(const std::string& template_name,const std::string& command) = 0;
+
+        virtual std::string get_description() = 0;
+};
+
+class template_source_registry : public template_source_interface {
+    public:
+        template_source_registry(std::string URL) : mURL(URL) {}
+
+        ~template_source_registry() {}
+
+        std::set<std::string> get_template_list();
+        bool has_template(const std::string& template_name);
+        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; }
+    private:
+        std::filesystem::path get_cache_dir();
+    private:
+        std::string mURL;
+        std::vector<nlohmann::json> mTemplates; // cached list.
+};
+
+class template_source_local : public template_source_interface {
+    public:
+        template_source_local(std::string local_path) : mLocalPath(local_path) {}
+        ~template_source_local() {}
+        std::set<std::string> get_template_list();
+        bool has_template(const std::string& template_name);
+        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 "Local: " + mLocalPath.string(); }
+    private:
+        std::filesystem::path mLocalPath;
+};
+
+class template_manager {
+    public:
+        template_manager() : mLoaded(false) {}
+        ~template_manager() {}
+
+        std::set<std::string> get_template_list() const;
+        bool has_template(const std::string& template_name) const;
+        template_info get_template_info(const std::string& template_name) const;
+
+        bool template_command_exists(const std::string& template_name,const std::string& command) const;
+        bool create_template(const std::string& template_name) const;
+        static bool test_template(const std::string& template_path);
+
+        void list_templates() const;
+
+        void load_sources();
+        void print_sources() const;
+
+        bool is_loaded() const { return mLoaded; }
+        int get_source_count() const { return mSources.size(); }
+
+    private:
+        static bool required_file(std::string path, std::string template_name);
+        template_source_interface* get_source(const std::string& template_name) const;
+
+    private:
+        bool mLoaded;
+        mutable std::vector<std::unique_ptr<template_source_interface>> mSources;
+};
+
+template_manager & gTemplateManager();
+
+
+} // namespace dropshell

source/src/utils/assert.hpp

@@ -0,0 +1,12 @@
+#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/b64ed.cpp

@@ -0,0 +1,42 @@
+#include "b64ed.hpp"
+
+#include <vector>
+
+// Custom base64 encoding/decoding tables
+static const std::string custom_base64_chars =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    "abcdefghijklmnopqrstuvwxyz"
+    "0123456789+_";
+
+std::string base64_encode(const std::string &in) {
+    std::string out;
+    int val = 0, valb = -6;
+    for (unsigned char c : in) {
+        val = (val << 8) + c;
+        valb += 8;
+        while (valb >= 0) {
+            out.push_back(custom_base64_chars[(val >> valb) & 0x3F]);
+            valb -= 6;
+        }
+    }
+    if (valb > -6) out.push_back(custom_base64_chars[((val << 8) >> (valb + 8)) & 0x3F]);
+    while (out.size() % 4) out.push_back('=');
+    return out;
+}
+
+std::string base64_decode(const std::string &in) {
+    std::vector<int> T(256, -1);
+    for (int i = 0; i < 64; i++) T[custom_base64_chars[i]] = i;
+    std::string out;
+    int val = 0, valb = -8;
+    for (unsigned char c : in) {
+        if (T[c] == -1) break;
+        val = (val << 6) + T[c];
+        valb += 6;
+        if (valb >= 0) {
+            out.push_back(char((val >> valb) & 0xFF));
+            valb -= 8;
+        }
+    }
+    return out;
+}

source/src/utils/b64ed.hpp

@@ -0,0 +1,9 @@
+#ifndef B64ED_HPP   
+#define B64ED_HPP
+
+#include <string>
+
+std::string base64_decode(const std::string &in);
+std::string base64_encode(const std::string &in);
+
+#endif

source/src/utils/directories.cpp

@@ -0,0 +1,192 @@
+#include "directories.hpp"
+#include "config.hpp"
+#include "server_env_manager.hpp"
+#include "output.hpp"
+
+#include <iostream>
+#include <string>
+#include <filesystem>
+
+
+namespace fs = std::filesystem;
+
+namespace dropshell {
+
+
+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
+
+
+// ------------------------------------------------------------------------------------------
+
+namespace localpath {
+        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;
+
+            return "";
+        }
+
+        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));
+        }
+
+        std::string remote_versions(const std::string &server_name, const std::string &service_name)
+        {
+            std::string template_cache_path = gConfig().get_local_template_cache_path();
+            return ((template_cache_path.empty() || service_name.empty()) ? "" : 
+               (template_cache_path+"/remote_versions/"+service_name+".json"));
+        }
+        std::string agent(){
+            return current_user_home() + "/.local/dropshell_agent";
+        }
+        std::string files_for_remote_agent()
+        {
+            return agent() + "/files_for_remote_agent";
+        }
+        std::string current_user_home()
+        {
+            char * homedir = std::getenv("HOME");
+            if (homedir)
+            {
+                std::filesystem::path homedir_path(homedir);
+                return fs::canonical(homedir_path).string();
+            }
+            warning << "Couldn't determine user directory" << std::endl;
+            return std::string();
+        }
+} // namespace localpath
+
+    //------------------------------------------------------------------------------------------------
+    // remote paths
+    // DROPSHELL_DIR
+    //   |-- backups
+    //   |-- temp_files
+    //   |-- agent
+    //   |   |-- bb64
+    //   |   |-- (other agent files, including _allservicesstatus.sh)
+    //   |-- services
+    //       |-- service name
+    //           |-- config
+    //               |-- service.env (actual service config)
+    //           |-- template
+    //               |-- _default.env
+    //               |-- (script files)
+    //               |-- config
+    //                   |-- service.env (default service config)
+    //                   |-- (other config files for specific server&service)
+
+
+
+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";
+    }
+
+}
+
+namespace remotepath {
+    std::string DROPSHELL_DIR(const std::string &server_name)
+    {            
+        return server_env_manager(server_name).get_DROPSHELL_DIR();
+    }
+
+    std::string services(const std::string &server_name)
+    {
+        std::string dsp = DROPSHELL_DIR(server_name);
+        return (dsp.empty() ? "" : (dsp + "/services"));
+    }
+
+    std::string service(const std::string &server_name, const std::string &service_name)
+    {
+        std::string services_path = services(server_name);
+        return (services_path.empty() ? "" : (services_path + "/" + service_name));
+    }
+
+    std::string service_config(const std::string &server_name, const std::string &service_name) 
+    {
+        std::string service_path = service(server_name, 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 service_path = service(server_name, service_name);
+        return (service_path.empty() ? "" : (service_path + "/template"));
+    }
+
+    std::string backups(const std::string &server_name) 
+    {
+        std::string dsp = DROPSHELL_DIR(server_name);
+        return (dsp.empty() ? "" : (dsp + "/backups"));
+    }
+
+    std::string temp_files(const std::string &server_name)
+    {
+        std::string dsp = DROPSHELL_DIR(server_name);
+        return (dsp.empty() ? "" : (dsp + "/temp_files"));
+    }
+
+    std::string agent(const std::string &server_name)
+    {
+        std::string dsp = DROPSHELL_DIR(server_name);
+        return (dsp.empty() ? "" : (dsp + "/agent"));
+    }
+
+    std::string service_env(const std::string &server_name, const std::string &service_name) 
+    {
+        std::string service_path = service_config(server_name, service_name);
+        return (service_path.empty() ? "" : (service_path + "/service.env"));
+    }
+} // namespace remotepath
+
+
+// ------------------------------------------------------------------------------------------
+// Utility functions
+
+std::string get_parent(const std::filesystem::path path)
+{
+    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

@@ -0,0 +1,111 @@
+#ifndef DIRECTORIES_HPP
+#define DIRECTORIES_HPP
+
+#include <string>
+#include <filesystem>
+
+namespace dropshell {
+
+    // all functions return empty string on failure
+
+    //------------------------------------------------------------------------------------------------
+    // local user config directories
+    
+    // ~/.config/dropshell/dropshell.json
+    
+    // ~/.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>
+    //        |-- server.json
+    //        |-- services
+    //            |-- <service_name>
+    //                |-- service.env
+    //                |-- .template_info.env
+    //                |-- (...other config files for specific server&service...)
+    
+    // backup path
+    //    |-- katie-_-squashkiwi-_-squashkiwi-test-_-2025-04-28_21-23-59.tgz
+ 
+    // temp files path
+
+    // template cache path
+    //    |-- templates
+    //    |   |-- <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);
+    } // namespace localfile
+
+    namespace localpath {
+        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();
+        std::string files_for_remote_agent();
+        std::string current_user_home();
+    } // namespace local
+
+
+    //------------------------------------------------------------------------------------------------
+    // remote paths
+    // DROPSHELL_DIR
+    //   |-- backups
+    //   |-- temp_files
+    //   |-- agent
+    //   |   |-- bb64
+    //   |   |-- (other agent files, including _allservicesstatus.sh)
+    //   |-- services
+    //       |-- service name
+    //           |-- config
+    //               |-- 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 {
+        std::string service_env(const std::string &server_name, const std::string &service_name);
+    } // namespace remotefile
+
+    namespace remotepath {
+        std::string DROPSHELL_DIR(const std::string &server_name);
+        std::string services(const std::string &server_name);
+        std::string service(const std::string &server_name, const std::string &service_name);
+        std::string service_config(const std::string &server_name, const std::string &service_name);
+        std::string service_template(const std::string &server_name, const std::string &service_name);
+        std::string backups(const std::string &server_name);
+        std::string temp_files(const std::string &server_name);
+        std::string agent(const std::string &server_name);
+    } // namespace remotepath
+
+    //------------------------------------------------------------------------------------------------
+    // utility functions
+    std::string get_parent(const std::filesystem::path path);
+    std::string get_child(const std::filesystem::path path);
+} // namespace dropshell
+
+
+#endif // DIRECTORIES_HPP

source/src/utils/envmanager.cpp

@@ -72,18 +72,6 @@ void envmanager::get_all_variables(std::map<std::string, std::string>& variables
     variables = m_variables;
 }
 
-std::string envmanager::get_variable_substituted(std::string key) const {
-    std::string value = get_variable(key);
-    return expand_patterns(value);
-}
-
-void envmanager::get_all_variables_substituted(std::map<std::string, std::string>& variables) const {
-    variables.clear();
-    for (const auto& pair : m_variables) {
-        variables[pair.first] = expand_patterns(pair.second);
-    }
-}
-
 void envmanager::add_variables(std::map<std::string, std::string> variables) {
     for (auto& pair : variables) {
         set_variable(pair.first, pair.second);
@@ -98,26 +86,4 @@ void envmanager::clear_variables() {
     m_variables.clear();
 }
 
-std::string envmanager::expand_patterns(std::string str) const {
-    // 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;
-}
-
 } // namespace dropshell

source/src/utils/envmanager.hpp

@@ -25,20 +25,12 @@ class envmanager {
         std::string get_variable(std::string key) const;
         void get_all_variables(std::map<std::string, std::string>& variables) const;
 
-        // get variables, but replace patterns ${var} and $var with the actual environment variable in the returned string.
-        // trim whitespace from the values.
-        std::string get_variable_substituted(std::string key) const;
-        void get_all_variables_substituted(std::map<std::string, std::string>& variables) const;
-
         // add variables to the environment files.
         // trim whitespace from the values.
         void add_variables(std::map<std::string, std::string> variables);
         void set_variable(std::string key, std::string value);
         void clear_variables();
 
-    private:
-        std::string expand_patterns(std::string str) const;
-
     private:
         std::string m_path;
         std::map<std::string, std::string> m_variables;

source/src/utils/execute.cpp

@@ -0,0 +1,226 @@
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <vector>
+#include <iostream>
+#include <string>
+#include <cstdlib>
+#include <sstream>
+#include "utils/assert.hpp"
+
+#include "execute.hpp"
+#include "utils/utils.hpp"
+#include "utils/b64ed.hpp"
+#include "config.hpp"
+#include "utils/directories.hpp"
+#include "utils/output.hpp"
+
+namespace dropshell
+{
+    bool EXITSTATUSCHECK(int ret)
+    {
+        return (ret != -1 && WIFEXITED(ret) && (WEXITSTATUS(ret) == 0)); // ret is -1 if the command failed to execute.
+    }
+
+
+    // ----------------------------------------------------------------------------------------------------------
+    // execute_local_command_interactive
+    // ----------------------------------------------------------------------------------------------------------
+    bool execute_local_command_interactive(const sCommand &command)
+    {
+        if (command.get_command_to_run().empty())
+            return false;
+        std::string full_command = command.construct_cmd(localpath::agent()); // Get the command string
+
+        pid_t pid = fork();
+
+        if (pid == -1)
+        {
+            // Fork failed
+            perror("fork failed");
+            return false;
+        }
+        else if (pid == 0)
+        {
+            int rval = system(full_command.c_str());
+            exit(rval);
+        }
+        else
+        {
+            // Parent process
+            int ret;
+            // Wait for the child process to complete
+            waitpid(pid, &ret, 0);
+
+            return EXITSTATUSCHECK(ret);
+        }
+    }
+
+    // ----------------------------------------------------------------------------------------------------------
+    // execute_local_command
+    // ----------------------------------------------------------------------------------------------------------
+
+    class fancypinter
+    {
+        public:
+        fancypinter(sColour startColour) : startColour_(startColour), currentColour_(startColour) {}
+
+        void print_chunk(std::string chunk)
+        {
+            if (chunk.empty())
+                return;
+
+            if (newline_)
+            {
+                // sniff the mode... if the string starts with warning or warning: then set mode to WARNING. etc.
+                if (chunk.find("warning") == 0)
+                    currentColour_ = sColour::WARNING;
+                else if (chunk.find("error") == 0)
+                    currentColour_ = sColour::ERROR;
+                else if (chunk.find("debug") == 0)
+                    currentColour_ = sColour::DEBUG;
+                else if (chunk.find("info") == 0)
+                    currentColour_ = sColour::INFO;
+                else
+                    currentColour_ = startColour_;    
+            }
+            colourstream(currentColour_) << chunk;
+            newline_ = (chunk[chunk.size()-1] == '\n');
+        }
+
+        void print(const std::string& buffer) {
+            size_t start = 0;
+            while (start < buffer.size()) {
+                size_t newline_pos = buffer.find('\n', start);
+                if (newline_pos == std::string::npos) {
+                    if (start < buffer.size()) {
+                        print_chunk(buffer.substr(start));
+                    }
+                    break;
+                }
+                print_chunk(buffer.substr(start, newline_pos - start + 1)); // include the newline
+                start = newline_pos + 1;
+            }
+        }
+
+        private:
+        bool newline_ = true;
+        sColour startColour_;
+        sColour currentColour_;
+    };
+
+
+    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, cMode mode)
+    {
+        sCommand command(directory_to_run_in, command_to_run, env_vars);
+
+        if (hasFlag(mode, cMode::Interactive))
+        {
+            ASSERT(!hasFlag(mode, cMode::CaptureOutput), "Interactive mode and capture output mode cannot be used together");
+            ASSERT(output == nullptr, "Interactive mode and an output string cannot be used together");
+
+            return execute_local_command_interactive(command);
+        }
+
+
+        if (command.get_command_to_run().empty())
+            return false;
+
+        bool silent = hasFlag(mode, cMode::Silent);
+
+        std::string full_cmd = command.construct_cmd(localpath::agent()) + (hasFlag(mode, cMode::CaptureOutput) ? " 2>&1" : ""); // capture both stdout and stderr
+
+        FILE *pipe = popen(full_cmd.c_str(), "r");
+        if (!pipe)
+        {
+            return false;
+        }
+        char buffer[128];
+        fancypinter fancyprint(sColour::DEBUG);
+        while (fgets(buffer, sizeof(buffer), pipe) != nullptr)
+        {
+            if (output != nullptr)
+               (*output) += buffer;
+
+            if (!silent)
+                fancyprint.print(buffer);
+        }
+        int ret = pclose(pipe);
+        return EXITSTATUSCHECK(ret);
+    }
+
+    // ----------------------------------------------------------------------------------------------------------
+    // execute_ssh_command
+    // ----------------------------------------------------------------------------------------------------------
+    bool execute_ssh_command(const sSSHInfo &ssh_info, const sCommand &remote_command, cMode mode, std::string *output)
+    {
+        if (remote_command.get_command_to_run().empty())
+            return false;
+
+        ASSERT(!(hasFlag(mode, cMode::CaptureOutput) && output == nullptr), "Capture output mode must be used with an output string");
+
+        std::stringstream ssh_cmd;
+        ssh_cmd << "ssh -p " << ssh_info.port << " " << (hasFlag(mode, cMode::Interactive) ? "-tt " : "")
+                << ssh_info.user << "@" << ssh_info.host;
+
+        std::string remote_agent_path = remotepath::agent(ssh_info.server_ID);
+
+        bool rval = execute_local_command(
+            "",                                                                          // directory to run in
+            ssh_cmd.str() + " " + remote_command.construct_cmd(remote_agent_path),       // local command to run
+            {},                                                                          // environment variables
+            output,                                                                      // output string
+            mode                                                                         // mode
+        );
+
+        if (!rval && !hasFlag(mode, cMode::Silent))
+        {
+            std::cerr << std::endl
+                      << std::endl;
+            std::cerr << "Error: Failed to execute ssh command:" << std::endl;
+            std::cerr << "\033[90m" << ssh_cmd.str() + " " + remote_command.construct_cmd(remote_agent_path) << "\033[0m" << std::endl;
+            std::cerr << std::endl
+                      << std::endl;
+        }
+        return rval;
+    }
+
+    // ----------------------------------------------------------------------------------------------------------
+    // makesafecmd
+    // ----------------------------------------------------------------------------------------------------------
+    std::string sCommand::makesafecmd(std::string agent_path, const std::string &command) const
+    {
+        if (command.empty())
+            return "";
+        std::string encoded = base64_encode(dequote(trim(command)));
+        std::string commandstr = agent_path + "/bb64 " + encoded;
+        return commandstr;
+    }
+
+    // ----------------------------------------------------------------------------------------------------------
+    // construct_cmd
+    // ----------------------------------------------------------------------------------------------------------
+    std::string sCommand::construct_cmd(std::string agent_path) const
+    {
+        if (mCmd.empty())
+            return "";
+
+        // need to construct to change directory and set environment variables
+        std::string cmdstr;
+
+        if (!mDir.empty())
+            cmdstr += "cd " + quote(mDir) + " && ";
+
+        if (!mVars.empty())
+            for (const auto &env_var : mVars)
+                cmdstr += env_var.first + "=" + quote(dequote(trim(env_var.second))) + " ";
+
+        cmdstr += mCmd;
+
+        if (!agent_path.empty())
+        cmdstr = makesafecmd(agent_path, cmdstr);
+
+        return cmdstr;
+    }
+
+} // namespace dropshell

source/src/utils/execute.hpp

@@ -0,0 +1,73 @@
+#ifndef EXECUTE_HPP
+#define EXECUTE_HPP
+
+#include <string>
+#include <map>
+
+namespace dropshell {
+
+class sCommand;
+
+// mode bitset
+enum class cMode {
+    Defaults = 0,
+    Interactive = 1,
+    Silent = 2,
+    CaptureOutput = 4
+};
+
+inline cMode operator&(cMode lhs, cMode rhs) {return static_cast<cMode>(static_cast<int>(lhs) & static_cast<int>(rhs));}
+inline cMode operator+(cMode lhs, cMode rhs) {return static_cast<cMode>(static_cast<int>(lhs) | static_cast<int>(rhs));}
+inline cMode operator-(cMode lhs, cMode rhs) {return static_cast<cMode>(static_cast<int>(lhs) & ~static_cast<int>(rhs));}
+inline cMode operator|(cMode lhs, cMode rhs) {return static_cast<cMode>(static_cast<int>(lhs) | static_cast<int>(rhs));}
+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 {
+    std::string host;
+    std::string user;
+    std::string port;
+    std::string server_ID; // dropshell name for server.
+} sSSHInfo;
+
+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);
+
+
+// ------------------------------------------------------------------------------------------------
+
+
+// class to hold a command to run on the remote server.
+class sCommand {
+    public:
+        sCommand(std::string directory_to_run_in, std::string command_to_run, const std::map<std::string, std::string> & env_vars) : 
+            mDir(directory_to_run_in), mCmd(command_to_run), mVars(env_vars) {}
+
+        std::string get_directory_to_run_in() const { return mDir; }
+        std::string get_command_to_run() const { return mCmd; }
+        const std::map<std::string, std::string>& get_env_vars() const { return mVars; }
+
+        void add_env_var(const std::string& key, const std::string& value) { mVars[key] = value; }
+        
+        bool empty() const { return mCmd.empty(); }
+    
+        std::string construct_cmd(std::string agent_path) const;
+
+    private:
+        std::string makesafecmd(std::string agent_path, const std::string& command) const;
+
+    private:
+        std::string mDir;
+        std::string mCmd;
+        std::map<std::string, std::string> mVars;
+};
+
+bool EXITSTATUSCHECK(int ret);
+
+
+} // namespace dropshell
+
+
+
+#endif

source/src/utils/hash.cpp

@@ -1,11 +1,15 @@
-#include "hash.hpp"
+#include "utils/hash.hpp"
+
+#define XXH_INLINE_ALL
+#include "contrib/xxhash.hpp"
+
 #include <fstream>
 #include <filesystem>
 #include <iostream>
 
 namespace dropshell {
 
-XXH64_hash_t hash_file(const std::string &path) {
+uint64_t hash_file(const std::string &path) {
     // Create hash state
     XXH64_state_t* const state = XXH64_createState();
     if (state == nullptr) {
@@ -14,11 +18,8 @@ XXH64_hash_t hash_file(const std::string &path) {
     }
 
     // Initialize state with seed 0
-    if (XXH64_reset(state, 0) == XXH_ERROR) {
-        std::cerr << "Failed to reset hash state" << std::endl;
-        XXH64_freeState(state);
-        return 0;
-    }
+    XXH64_hash_t const seed = 0;   /* or any other value */
+    if (XXH64_reset(state, seed) == XXH_ERROR) return 0;
 
     // Open file
     std::ifstream file(path, std::ios::binary);
@@ -54,7 +55,7 @@ XXH64_hash_t hash_file(const std::string &path) {
     return hash;
 }
 
-XXH64_hash_t hash_directory_recursive(const std::string &path) {
+uint64_t hash_directory_recursive(const std::string &path) {
     // Create hash state
     XXH64_state_t* const state = XXH64_createState();
     if (state == nullptr) {
@@ -63,7 +64,8 @@ XXH64_hash_t hash_directory_recursive(const std::string &path) {
     }
 
     // Initialize state with seed 0
-    if (XXH64_reset(state, 0) == XXH_ERROR) {
+    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;
         XXH64_freeState(state);
         return 0;
@@ -75,13 +77,7 @@ XXH64_hash_t hash_directory_recursive(const std::string &path) {
             if (entry.is_regular_file()) {
                 // Get file hash
                 XXH64_hash_t file_hash = hash_file(entry.path().string());
-                
-                // Update directory hash with file hash
-                if (XXH64_update(state, &file_hash, sizeof(file_hash)) == XXH_ERROR) {
-                    std::cerr << "Failed to update hash" << std::endl;
-                    XXH64_freeState(state);
-                    return 0;
-                }
+                XXH64_update(state, &file_hash, sizeof(file_hash));
             }
         }
     } catch (const std::filesystem::filesystem_error& e) {
@@ -96,11 +92,27 @@ XXH64_hash_t hash_directory_recursive(const std::string &path) {
     return hash;
 }
 
+uint64_t hash_path(const std::string &path) {
+    if (!std::filesystem::exists(path)) {
+        std::cerr << "Path does not exist: " << path << std::endl;
+        return 0;
+    }
+
+    if (std::filesystem::is_directory(path)) {
+        return hash_directory_recursive(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;
+        return 0;
+    }
+}
+
 void hash_demo(const std::string & path)
 {
-    std::cout << "Hashing directory: " << path << std::endl;
+    std::cout << "Hashing path: " << path << std::endl;
     auto start = std::chrono::high_resolution_clock::now();
-    XXH64_hash_t hash = hash_directory_recursive(path);
+    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;
@@ -111,7 +123,7 @@ int hash_demo_raw(const std::string & path)
     if (!std::filesystem::exists(path)) {
         std::cout << 0 <<std::endl; return 1;
     }
-    XXH64_hash_t hash = hash_directory_recursive(path);
+    XXH64_hash_t hash = hash_path(path);
     std::cout << hash << std::endl;
     return 0;
 }

source/src/utils/hash.hpp

@@ -1,14 +1,16 @@
 #ifndef HASH_HPP
 #define HASH_HPP
 
-#include <xxhash.h>
 #include <string>
+#include <cstdint>
 
 namespace dropshell {
 
-    XXH64_hash_t hash_file(const std::string &path);
+    uint64_t hash_file(const std::string &path);
 
-    XXH64_hash_t hash_directory_recursive(const std::string &path);
+    uint64_t hash_directory_recursive(const std::string &path);
+
+    uint64_t hash_path(const std::string &path);
 
     void hash_demo(const std::string & path);
 

source/src/utils/json_fwd.hpp

@@ -0,0 +1,187 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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

@@ -0,0 +1,133 @@
+#include "output.hpp"
+#include <iostream>
+#include <mutex>
+
+namespace dropshell
+{
+    // Mutex to synchronize output
+    std::mutex output_mutex;
+
+    // ANSI colour codes
+    constexpr const char *GREY = "\033[90m";
+    constexpr const char *RESET = "\033[0m";
+    constexpr const char *DEBUG_COLOUR = "\033[36m";   // Cyan
+    // constexpr const char *INFO_COLOUR = "\033[32m";    // Green
+    constexpr const char *INFO_COLOUR = "\033[37m";    // White
+    constexpr const char *WARNING_COLOUR = "\033[33m"; // Yellow
+    constexpr const char *ERROR_COLOUR = "\033[31m";   // Red
+
+    // Tag and colour for each stream
+    struct StreamInfo
+    {
+        const char *tag;
+        const char *colour;
+    };
+
+    const StreamInfo stream_infos[] = {
+        {"[DBG]", DEBUG_COLOUR},
+        {"[INF]", INFO_COLOUR},
+        {"[WRN]", WARNING_COLOUR},
+        {"[ERR]", ERROR_COLOUR}};
+
+    // Custom streambuf to prefix and colour each line
+    class PrefixStreambuf : public std::streambuf
+    {
+    public:
+        PrefixStreambuf(std::ostream &dest, const char *tag, const char *colour)
+            : dest_(dest), tag_(tag), colour_(colour), at_line_start_(true) {}
+
+    protected:
+        int overflow(int c) override
+        {
+            std::lock_guard<std::mutex> lock(output_mutex);
+            if (c == EOF)
+                return !EOF;
+            if (at_line_start_ && c != '\n')
+            {
+                dest_ << GREY << tag_ << RESET << ' ' << colour_;
+                at_line_start_ = false;
+            }
+            dest_.put(static_cast<char>(c));
+            if (c == '\n')
+            {
+                dest_ << RESET;
+                at_line_start_ = true;
+            }
+            return c;
+        }
+
+    private:
+        std::ostream &dest_;
+        const char *tag_;
+        const char *colour_;
+        bool at_line_start_;
+    };
+
+    PrefixStreambuf debug_buf(std::clog, stream_infos[0].tag, stream_infos[0].colour);
+    PrefixStreambuf info_buf(std::clog, stream_infos[1].tag, stream_infos[1].colour);
+    PrefixStreambuf warning_buf(std::clog, stream_infos[2].tag, stream_infos[2].colour);
+    PrefixStreambuf error_buf(std::cerr, stream_infos[3].tag, stream_infos[3].colour);
+
+    std::ostream debug_stream(&debug_buf);
+    std::ostream info_stream(&info_buf);
+    std::ostream warning_stream(&warning_buf);
+    std::ostream error_stream(&error_buf);
+
+    std::ostream &debug = debug_stream;
+    std::ostream &info = info_stream;
+    std::ostream &warning = warning_stream;
+    std::ostream &error = error_stream;
+
+    std::ostream &rawout = std::cout;
+    std::ostream &rawerr = std::cerr;
+
+    std::ostream &colourstream(sColour colour)
+    {
+        switch (colour)
+        {
+        case sColour::DEBUG:
+            return debug_stream;
+        case sColour::INFO:
+            return info_stream;
+        case sColour::WARNING:
+            return warning_stream;
+        case sColour::ERROR:
+            return error_stream;
+        default:
+            return info_stream;
+        }
+    }
+
+    void SetColour(sColour colour, std::ostream &os)
+    {
+        switch (colour)
+        {
+        case sColour::RESET:
+            os << RESET;
+            break;
+        case sColour::DEBUG:
+            os << DEBUG_COLOUR;
+            break;
+        case sColour::INFO:
+            os << INFO_COLOUR;
+            break;
+        case sColour::WARNING:
+            os << WARNING_COLOUR;
+            break;
+        case sColour::ERROR:
+            os << ERROR_COLOUR;
+            break;
+        }
+    }
+
+    SwitchColour::SwitchColour(sColour colour, std::ostream &os) : os_(os), colour_(colour)
+    {
+        SetColour(colour_, os_);
+    }
+
+    SwitchColour::~SwitchColour()
+    {
+        SetColour(sColour::RESET, os_);
+    }
+
+} // namespace dropshell

source/src/utils/output.hpp

@@ -0,0 +1,87 @@
+#ifndef OUTPUT_HPP
+#define OUTPUT_HPP
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <ostream>
+
+namespace dropshell {
+
+/*
+
+output.hpp and output.cpp - simple output helpers.
+
+Defines ostreams:
+
+debug, info, warning, error.
+
+These ostreams can be used with C++23 print and println, e.g.
+std::println(debug, "funny variable: {}={}","my_var",my_var);
+
+Also defines a few helper functions:
+
+PrintDebug(const std::string& msg);     // equivalent to std::println(debug, msg);
+PrintInfo(const std::string& msg);      // equivalent to std::println(info, msg);
+PrintWarning(const std::string& msg);   // equivalent to std::println(warning, msg);
+PrintError(const std::string& msg);     // equivalent to std::println(error, msg);
+
+Output for these streams for each line is formatted as:
+[DBG] <message>
+[INF] <message>
+[WRN] <message>
+[ERR] <message>
+
+The output is coloured, and the tag is printed in grey.
+
+In addition, when not using any of the above, helper routines for coloring the output of cout and cerr are provided.
+
+SetColour(std::ostream& os, sColour colour);
+
+Where sColour is an enum:
+enum class sColour {
+    RESET,
+    DEBUG,
+    INFO,
+    WARNING,
+    ERROR
+};
+
+
+*/
+
+// Output streams for different log levels
+extern std::ostream& debug;
+extern std::ostream& info;
+extern std::ostream& warning;
+extern std::ostream& error;
+
+extern std::ostream& rawout;
+extern std::ostream& rawerr;
+
+// Enum for colours
+enum class sColour {
+    RESET,
+    DEBUG,
+    INFO,
+    WARNING,
+    ERROR
+};
+std::ostream& colourstream(sColour colour);
+
+// Set colour for a stream
+void SetColour(sColour colour, std::ostream& os = std::cerr);
+
+class SwitchColour
+{
+    public:
+    SwitchColour(sColour colour, std::ostream& os = std::cerr);
+    ~SwitchColour();
+    private:
+    std::ostream& os_;
+    sColour colour_;
+};
+
+} // namespace dropshell
+
+#endif // OUTPUT_HPP

source/src/utils/tableprint.cpp

@@ -9,6 +9,8 @@
 #include <iostream>
 #include <map>
 
+#include "output.hpp"
+
 enum kTextColors {
     kTextColor_Default,
     kTextColor_Red,
@@ -32,7 +34,7 @@ const std::map<std::string, coloredText> kReplacements = {
     {":tick:", {"+", kTextColor_Green}},
     {":cross:", {"x", kTextColor_Red}},
     {":warning:", {"!", kTextColor_Yellow}},
-    {":info:", {"i", kTextColor_Blue}},
+    {":dropshell::info:", {"i", kTextColor_Blue}},
     {":check:", {"+", kTextColor_Green}},
     {":x:", {"x", kTextColor_Red}},
     {":error:", {"!", kTextColor_Red}},
@@ -115,12 +117,12 @@ std::string width_print_centered(std::string str,int width, std::string rowcolor
     oss << rowcolor << std::string(lpad, ' ') << process_cell(str, rowcolor) << 
         std::string(rpad, ' ') << "\033[0m";
 
-    // std::cout << "str = "<<str <<std::endl;
-    // std::cout << "width = "<<width <<std::endl;
-    // std::cout << "padding = "<<padding <<std::endl;
-    // std::cout << "get_visible_length(str) = "<<get_visible_length(str) <<std::endl;
-    // std::cout << "get_codepoints(str) = "<<get_codepoints(str) <<std::endl;
-    // std::cout << "oss.str() = ["<<oss.str() <<"]"<<std::endl;
+    // dropshell::info << "str = "<<str <<std::endl;
+    // dropshell::info << "width = "<<width <<std::endl;
+    // dropshell::info << "padding = "<<padding <<std::endl;
+    // dropshell::info << "get_visible_length(str) = "<<get_visible_length(str) <<std::endl;
+    // dropshell::info << "get_codepoints(str) = "<<get_codepoints(str) <<std::endl;
+    // dropshell::info << "oss.str() = ["<<oss.str() <<"]"<<std::endl;
 
     return oss.str();
 }
@@ -195,98 +197,105 @@ void tableprint::print() {
 
     // Print title if it exists
     if (!title.empty()) {
-        std::cout << "\033[90m"; // Dark grey color for borders
-        std::cout << "+";
+        dropshell::info << "\033[90m"; // Dark grey color for borders
+        dropshell::info << "+";
         for (size_t i = 0; i < rows[0].size(); ++i) {
-            std::cout << std::string(col_widths[i] + 2, '-');
-            if (i < rows[0].size() - 1) std::cout << "-";
+            dropshell::info << std::string(col_widths[i] + 2, '-');
+            if (i < rows[0].size() - 1) dropshell::info << "-";
         }
-        std::cout << "+" << std::endl;
+        dropshell::info << "+" << std::endl;
         
-        std::cout << "|"; // White color for title
+        dropshell::info << "\033[90m"; // Dark grey color for borders
+        dropshell::info << "|"; // White color for title
         size_t title_width = 0;
         for (size_t width : col_widths) {
             title_width += width + 2; // +2 for padding
         }
         title_width += col_widths.size() - 1; // Add space for vertical borders
 
-        std::cout << width_print_centered(title,title_width,"\033[1;37m");
-        std::cout << "\033[90m|" << std::endl;
+        dropshell::info << width_print_centered(title,title_width,"\033[1;37m");
+        dropshell::info << "\033[90m|" << std::endl;
         
         // Use └─┴─┘ for bottom of title box to connect with table
-        std::cout << "+";
+        dropshell::info << "\033[90m"; // Dark grey color for borders
+        dropshell::info << "+";
         for (size_t i = 0; i < rows[0].size(); ++i) {
-            std::cout << std::string(col_widths[i] + 2, '-');
-            if (i < rows[0].size() - 1) std::cout << "-";
+            dropshell::info << std::string(col_widths[i] + 2, '-');
+            if (i < rows[0].size() - 1) dropshell::info << "-";
         }
-        std::cout << "+" << std::endl;
+        dropshell::info << "+" << std::endl;
     } else {
         // Print top border if no title
-        std::cout << "\033[90m"; // Dark grey color for borders
-        std::cout << "+";
+        dropshell::info << "\033[90m"; // Dark grey color for borders
+        dropshell::info << "+";
         for (size_t i = 0; i < rows[0].size(); ++i) {
-            std::cout << std::string(col_widths[i] + 2, '-');
-            if (i < rows[0].size() - 1) std::cout << "+";
+            dropshell::info << std::string(col_widths[i] + 2, '-');
+            if (i < rows[0].size() - 1) dropshell::info << "+";
         }
-        std::cout << "+" << std::endl;
+        dropshell::info << "+" << std::endl;
     }
 
     // Print header
-    std::cout << "|";
+    dropshell::info << "\033[90m"; // Dark grey color for borders
+    dropshell::info << "|";
     for (size_t i = 0; i < rows[0].size(); ++i) {
-        std::cout << width_print_centered(rows[0][i],col_widths[i]+2,"\033[1;36m");
+        dropshell::info << width_print_centered(rows[0][i],col_widths[i]+2,"\033[1;36m");
         if (i < rows[0].size() - 1) {
-            std::cout << "\033[90m|\033[1;36m"; // Border color then back to cyan
+            dropshell::info << "\033[90m|\033[1;36m"; // Border color then back to cyan
         } else {
-            std::cout << "\033[90m|"; // Just border color for last column
+            dropshell::info << "\033[90m|"; // Just border color for last column
         }
     }
-    std::cout << std::endl;
+    dropshell::info << std::endl;
 
     // Print header separator
     if (!mCompact) {
-        std::cout << "+";
+        dropshell::info << "\033[90m"; // Dark grey color for borders
+        dropshell::info << "+";
         for (size_t i = 0; i < rows[0].size(); ++i) {
             for (size_t j = 0; j < col_widths[i] + 2; ++j) {
-                std::cout << "-";
+                dropshell::info << "-";
             }
-            if (i < rows[0].size() - 1) std::cout << "+";
+            if (i < rows[0].size() - 1) dropshell::info << "+";
         }
-        std::cout << "+" << std::endl;
+        dropshell::info << "+" << std::endl;
     }
 
     // Print rows
     for (size_t row_idx = 1; row_idx < rows.size(); ++row_idx) {
         const auto& row = rows[row_idx];
-        std::cout << "|";
+        dropshell::info << "\033[90m"; // Dark grey color for borders
+        dropshell::info << "|";
         for (size_t i = 0; i < row.size(); ++i) {
             // Set the appropriate color for the row
             std::string rowcolor = (row_idx % 2 == 1) ? "\033[38;5;142m" : "\033[38;5;250m";
-            std::cout << width_print_left(row[i],col_widths[i]+2,rowcolor);
-            std::cout << "\033[90m" << "|";
+            dropshell::info << width_print_left(row[i],col_widths[i]+2,rowcolor);
+            dropshell::info << "\033[90m" << "|";
         }
-        std::cout << std::endl;
+        dropshell::info << std::endl;
 
         // Print row separator if not the last row
         if (row_idx < rows.size() - 1 && !mCompact) {
-            std::cout << "+";
+            dropshell::info << "\033[90m"; // Dark grey color for borders
+            dropshell::info << "+";
             for (size_t i = 0; i < rows[0].size(); ++i) {
                 for (size_t j = 0; j < col_widths[i] + 2; ++j) {
-                    std::cout << "-";
+                    dropshell::info << "-";
                 }
-                if (i < rows[0].size() - 1) std::cout << "+";
+                if (i < rows[0].size() - 1) dropshell::info << "+";
             }
-            std::cout << "+" << std::endl;
+            dropshell::info << "+" << std::endl;
         }
     }
 
     // Print bottom border
-    std::cout << "+";
+    dropshell::info << "\033[90m"; // Dark grey color for borders
+    dropshell::info << "+";
     for (size_t i = 0; i < rows[0].size(); ++i) {
         for (size_t j = 0; j < col_widths[i] + 2; ++j) {
-            std::cout << "-";
+            dropshell::info << "-";
         }
-        if (i < rows[0].size() - 1) std::cout << "+";
+        if (i < rows[0].size() - 1) dropshell::info << "+";
     }
-    std::cout << "+" << "\033[0m" << std::endl; // Reset color
+    dropshell::info << "+" << "\033[0m" << std::endl; // Reset color
 } 

source/src/utils/utils.cpp

@@ -5,12 +5,25 @@
 #include <vector>
 #include <algorithm>
 #include <filesystem>
+#include <regex>
+#include <random>
+
 namespace dropshell {
 
-void maketitle(const std::string& title) {
-    std::cout << std::string(title.length() + 4, '-') << std::endl;
-    std::cout << "| " << title << " |" << std::endl;
-    std::cout << std::string(title.length() + 4, '-') << std::endl;
+std::string magic_string() {
+    return "-_-";
+}
+
+bool has_magic_string(std::string name)
+{
+    return name.find(magic_string()) != std::string::npos;
+}
+
+
+void maketitle(const std::string& title, sColour colour) {
+    colourstream(colour) << std::string(title.length() + 4, '-') << std::endl;
+    colourstream(colour) << "| " << title << " |" << std::endl;
+    colourstream(colour) << std::string(title.length() + 4, '-') << std::endl;
 }
 
 bool replace_line_in_file(const std::string& file_path, const std::string& search_string, const std::string& replacement_line) {
@@ -72,6 +85,16 @@ std::string quote(std::string str)
     return "\""+str+"\"";
 }
 
+std::string halfquote(std::string str)
+{
+    return "'" + str + "'";
+}
+
+std::string escapequotes(std::string str)
+{
+    return std::regex_replace(str, std::regex("\""), "\\\"");
+}
+
 std::string multi2string(std::vector<std::string> values)
 {
     std::string result;
@@ -263,4 +286,85 @@ 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{}());
+    static const std::string chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    std::uniform_int_distribution<> distribution(0, chars.size() - 1);
+    std::string random_string;
+    for (int i = 0; i < length; ++i) {
+        random_string += chars[distribution(generator)];
+    }
+    
+    return random_string;
+}
+
+std::string requote(std::string str) {
+    return quote(trim(dequote(trim(str))));
+}
+
+
+int die(const std::string & msg) {
+    std::cerr << msg << std::endl;
+    return 1;
+}
+
+std::string safearg(const std::vector<std::string> & args, int index)
+{
+    if (index<0 || index >= args.size()) return "";
+    return args[index];
+}
+
+std::string safearg(int argc, char *argv[], int index)
+{
+    if (index<0 || index >= argc) return "";
+    return argv[index];
+}
+
+std::string left_align(const std::string & str, int width) {
+    if (static_cast<int>(str.size()) >= width)
+        return str;
+    return str + std::string(width - str.size(), ' ');
+}
+
+std::string right_align(const std::string & str, int width) {
+    if (static_cast<int>(str.size()) >= width)
+        return str;
+    return std::string(width - str.size(), ' ') + str;
+}
+
+std::string center_align(const std::string & str, int width) {
+    int pad = width - static_cast<int>(str.size());
+    if (pad <= 0)
+        return str;
+    int pad_left = pad / 2;
+    int pad_right = pad - pad_left;
+    return std::string(pad_left, ' ') + str + std::string(pad_right, ' ');
+}
+
+
+
 } // namespace dropshell 

source/src/utils/utils.hpp

@@ -3,6 +3,8 @@
 #include <string>
 #include <vector>
 
+#include "output.hpp"
+
 namespace dropshell {
 
 /**
@@ -10,15 +12,21 @@ namespace dropshell {
  * 
  * @param title The title string to display
  */
-void maketitle(const std::string& title);
+void maketitle(const std::string& title, sColour colour=sColour::INFO);
 
 bool replace_line_in_file(const std::string& file_path, const std::string& search_string, const std::string& replacement_line);
 
+std::string magic_string();
+bool has_magic_string(std::string name);
 
 // utility functions
 std::string trim(std::string str);
 std::string dequote(std::string str);
 std::string quote(std::string str);
+std::string halfquote(std::string str);
+std::string requote(std::string str);
+std::string escapequotes(std::string str);
+
 std::string multi2string(std::vector<std::string> values);
 std::vector<std::string> string2multi(std::string values);
 std::vector<std::string> split(const std::string& str, const std::string& delimiter);
@@ -33,4 +41,16 @@ 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);
+std::string safearg(int argc, char *argv[], int index);
+std::string safearg(const std::vector<std::string> & args, int index);
+
+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);
+
 } // namespace dropshell 

source/src/version.hpp.in

@@ -1,5 +1,13 @@
 #pragma once
 
+/*
+
+version.hpp is automatically generated by the build system, from version.hpp.in.
+
+DO NOT EDIT VERSION.HPP!
+
+*/
+
 #include <string>
 
 namespace dropshell {

src/autocomplete.cpp

@@ -1,96 +0,0 @@
-#include "autocomplete.hpp"
-#include "servers.hpp"
-#include "config.hpp"
-#include "templates.hpp"
-#include "services.hpp"
-#include "servers.hpp"
-#include "utils/assert.hpp"
-
-#include <algorithm>
-#include <iostream>
-
-void dropshell::autocomplete(const std::vector<std::string> &args)
-{
-    if (args.size() < 3) // dropshell autocomplete ???
-    {
-        autocomplete_list_commands();
-        return;
-    }
-
-    ASSERT(args.size() >= 3);
-    std::string cmd = args[2];
-
-    // std::cout<<" cmd = ["<<cmd<<"]"<<std::endl;
-
-    std::string noargcmds[] = {"templates","autocomplete_list_servers","autocomplete_list_services","autocomplete_list_commands"};
-    if (std::find(std::begin(noargcmds), std::end(noargcmds), cmd) != std::end(noargcmds))
-        return;
-
-    if (!dropshell::gConfig().is_config_set())
-        return; // can't help without working config.
-
-    if (args.size()==3) // we have the command but nothing else.  dropshell autocomplete command <server>
-    {
-        auto servers = dropshell::get_configured_servers();
-        for (const auto& server : servers) 
-        std::cout << server.name << std::endl;
-        return;
-    }
-
-    if (args.size()==4) // we have the command and the server.  dropshell autocomplete command server <service>
-    {
-        std::string server = args[3];
-
-        if (cmd=="create-service")
-        { // create-service <server> <template> <service>
-            std::vector<template_info> templates;
-            get_templates(templates);
-            for (const auto& t : templates)
-                std::cout << t.template_name << std::endl;
-            return;
-        }
-
-        auto services = dropshell::get_server_services_info(server);
-        for (const auto& service : services) 
-            std::cout << service.service_name << std::endl;
-        return;
-    }
-
-    if (args.size()==5) // we have the command and the server and the service.  dropshell autocomplete command server service_name <command?>
-    { 
-        std::string server_name = args[3];
-        std::string service_name = args[4];
-        if (cmd=="restore")
-        {
-            std::set<std::string> backups = dropshell::list_backups(server_name, service_name);
-            for (auto backup : backups) 
-                std::cout << backup << std::endl;
-            return;
-        }
-
-        return; // no more autocompletion possible - don't know what the argument is for.
-    }
-
-    // args>5 - no more autocompletion possible - don't know what the argument is for.
-    return; // catch-all.
-}
-
-void dropshell::autocomplete_list_commands()
-{
-    std::set<std::string> commands;
-    dropshell::get_all_used_commands(commands);
-
-// add in commmands hard-coded and handled in main
-    commands.merge(std::set<std::string>{ 
-        "help","init" // these are always available.
-    });
-    if (dropshell::gConfig().is_config_set()) 
-        commands.merge(std::set<std::string>{
-            "server","templates","create-service","create-template","create-server","edit","ssh",
-            "list" // only if we have a config.
-        });
-    for (const auto& command : commands) {
-        std::cout << command << std::endl;
-    }
-}
-

src/autocomplete.hpp

@@ -1,16 +0,0 @@
-#ifndef AUTOCOMPLETE_HPP
-#define AUTOCOMPLETE_HPP
-
-#include <string>
-#include <vector>
-
-
-namespace dropshell {
-
-    void autocomplete(const std::vector<std::string> &args);
-
-    void autocomplete_list_commands();
-
-} // namespace dropshell
-
-#endif

src/config.cpp

@@ -1,118 +0,0 @@
-#include "utils/directories.hpp"
-#include <iostream>
-#include <fstream>
-#include "config.hpp"
-#include "utils/envmanager.hpp"
-#include "utils/utils.hpp"
-
-#include <filesystem>
-
-namespace dropshell {
-
-
-config & gConfig() {
-    static config *globalConfig = new config();
-    return *globalConfig;
-}
-
-
-config::config() {
-}
-config::~config() {
-}
-
-bool config::load_config() {
-    std::string config_path = localfile::dropshell_env();
-    if (config_path.empty() || !std::filesystem::exists(config_path))
-        return false;
-
-    envmanager config_env(config_path);
-    if (!config_env.load())
-        return false;
-
-    std::string directories = config_env.get_variable_substituted("local.config.directories");
-    if (directories.empty())
-        return false;   
-
-    // Split the directories string into a vector of strings
-    mLocalConfigPaths = string2multi(directories);
-
-    mLocalBackupPath = config_env.get_variable_substituted("local.backup.directory");
-
-    // legacy config file conversion
-    if (mLocalBackupPath.empty() && mLocalConfigPaths.size()>0)
-        mLocalBackupPath = mLocalConfigPaths[0] + "/backups";
-
-    //std::cout << "Local config path: " << mLocalConfigPath << std::endl;
-    return true;
-}
-
-void config::save_config()
-{
-    if (mLocalConfigPaths.empty())
-    {
-        std::cerr << "Warning: Unable to save configuration file, as DropShell has not been initialised."<< std::endl;
-        std::cerr << "Please run 'dropshell init <path>' to initialise DropShell." << std::endl;
-        return;
-    }
-
-    std::string parent_path = dropshell::get_parent(localfile::dropshell_env());
-    std::filesystem::create_directories(parent_path);
-
-    std::string config_path = localfile::dropshell_env();
-    envmanager config_env(config_path);
-
-    config_env.set_variable("local.config.directories", multi2string(mLocalConfigPaths));
-    config_env.set_variable("local.backup.directory", mLocalBackupPath);
-    config_env.save();
-}
-
-bool config::is_config_set() const
-{   
-    return !mLocalConfigPaths.empty() && !mLocalBackupPath.empty();
-}
-
-
-const std::vector<std::string> & config::get_local_config_directories() const
-{
-    return mLocalConfigPaths;
-}
-
-bool config::add_local_config_directory(const std::string &path)
-{
-    if (path.empty())
-        return false;
-
-    // Convert to canonical path, using std::filesystem
-    std::filesystem::path abs_path = std::filesystem::canonical(path);
-    
-    // The directory must exist
-    if (!std::filesystem::exists(abs_path)) {
-        std::cerr << "Error: The local config directory does not exist: " << abs_path.string() << std::endl;
-        return false;
-    }
-
-    // Add to config paths if not already there
-    for (auto &p : mLocalConfigPaths)
-    { // robustly compare the two paths.
-        if (p == abs_path.string())
-        {
-            std::cerr << "Warning: The local config directory is already registered: " << abs_path.string() << std::endl;
-            std::cerr << "No changes made to the DropShell configuration." << std::endl;
-            return false;
-        }
-    }
-    mLocalConfigPaths.push_back(abs_path.string());
-
-    if (mLocalBackupPath.empty())
-            mLocalBackupPath = abs_path.string() + "/backups";
-
-    return true;
-}
-
-const std::string &config::get_local_backup_path() const
-{
-    return mLocalBackupPath;
-}
-
-} // namespace dropshell 

src/config.hpp

@@ -1,30 +0,0 @@
-#pragma once
-
-#include <string>
-#include <vector>
-
-namespace dropshell {
-
-class config {
-    public:
-        config();
-        ~config();
-        bool load_config();
-        void save_config();
-
-        bool is_config_set() const;
-
-        const std::vector<std::string> & get_local_config_directories() const;
-        bool add_local_config_directory(const std::string& path);
-
-        const std::string & get_local_backup_path() const;
-
-    private:
-        std::vector<std::string> mLocalConfigPaths;
-        std::string mLocalBackupPath;
-};
-
-
-config & gConfig();
-
-} // namespace dropshell 

src/contrib/base64.cpp

@@ -1,282 +0,0 @@
-/*
-   base64.cpp and base64.h
-
-   base64 encoding and decoding with C++.
-   More information at
-     https://renenyffenegger.ch/notes/development/Base64/Encoding-and-decoding-base-64-with-cpp
-
-   Version: 2.rc.09 (release candidate)
-
-   Copyright (C) 2004-2017, 2020-2022 René Nyffenegger
-
-   This source code is provided 'as-is', without any express or implied
-   warranty. In no event will the author be held liable for any damages
-   arising from the use of this software.
-
-   Permission is granted to anyone to use this software for any purpose,
-   including commercial applications, and to alter it and redistribute it
-   freely, subject to the following restrictions:
-
-   1. The origin of this source code must not be misrepresented; you must not
-      claim that you wrote the original source code. If you use this source code
-      in a product, an acknowledgment in the product documentation would be
-      appreciated but is not required.
-
-   2. Altered source versions must be plainly marked as such, and must not be
-      misrepresented as being the original source code.
-
-   3. This notice may not be removed or altered from any source distribution.
-
-   René Nyffenegger rene.nyffenegger@adp-gmbh.ch
-
-*/
-
-#include "contrib/base64.hpp"
-
-#include <algorithm>
-#include <stdexcept>
-
- //
- // Depending on the url parameter in base64_chars, one of
- // two sets of base64 characters needs to be chosen.
- // They differ in their last two characters.
- //
-static const char* base64_chars[2] = {
-             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-             "abcdefghijklmnopqrstuvwxyz"
-             "0123456789"
-             "+/",
-
-             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-             "abcdefghijklmnopqrstuvwxyz"
-             "0123456789"
-             "-_"};
-
-static unsigned int pos_of_char(const unsigned char chr) {
- //
- // Return the position of chr within base64_encode()
- //
-
-    if      (chr >= 'A' && chr <= 'Z') return chr - 'A';
-    else if (chr >= 'a' && chr <= 'z') return chr - 'a' + ('Z' - 'A')               + 1;
-    else if (chr >= '0' && chr <= '9') return chr - '0' + ('Z' - 'A') + ('z' - 'a') + 2;
-    else if (chr == '+' || chr == '-') return 62; // Be liberal with input and accept both url ('-') and non-url ('+') base 64 characters (
-    else if (chr == '/' || chr == '_') return 63; // Ditto for '/' and '_'
-    else
- //
- // 2020-10-23: Throw std::exception rather than const char*
- //(Pablo Martin-Gomez, https://github.com/Bouska)
- //
-    throw std::runtime_error("Input is not valid base64-encoded data.");
-}
-
-static std::string insert_linebreaks(std::string str, size_t distance) {
- //
- // Provided by https://github.com/JomaCorpFX, adapted by me.
- //
-    if (!str.length()) {
-        return "";
-    }
-
-    size_t pos = distance;
-
-    while (pos < str.size()) {
-        str.insert(pos, "\n");
-        pos += distance + 1;
-    }
-
-    return str;
-}
-
-template <typename String, unsigned int line_length>
-static std::string encode_with_line_breaks(String s) {
-  return insert_linebreaks(base64_encode(s, false), line_length);
-}
-
-template <typename String>
-static std::string encode_pem(String s) {
-  return encode_with_line_breaks<String, 64>(s);
-}
-
-template <typename String>
-static std::string encode_mime(String s) {
-  return encode_with_line_breaks<String, 76>(s);
-}
-
-template <typename String>
-static std::string encode(String s, bool url) {
-  return base64_encode(reinterpret_cast<const unsigned char*>(s.data()), s.length(), url);
-}
-
-std::string base64_encode(unsigned char const* bytes_to_encode, size_t in_len, bool url) {
-
-    size_t len_encoded = (in_len +2) / 3 * 4;
-
-    unsigned char trailing_char = url ? '.' : '=';
-
- //
- // Choose set of base64 characters. They differ
- // for the last two positions, depending on the url
- // parameter.
- // A bool (as is the parameter url) is guaranteed
- // to evaluate to either 0 or 1 in C++ therefore,
- // the correct character set is chosen by subscripting
- // base64_chars with url.
- //
-    const char* base64_chars_ = base64_chars[url];
-
-    std::string ret;
-    ret.reserve(len_encoded);
-
-    unsigned int pos = 0;
-
-    while (pos < in_len) {
-        ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0xfc) >> 2]);
-
-        if (pos+1 < in_len) {
-           ret.push_back(base64_chars_[((bytes_to_encode[pos + 0] & 0x03) << 4) + ((bytes_to_encode[pos + 1] & 0xf0) >> 4)]);
-
-           if (pos+2 < in_len) {
-              ret.push_back(base64_chars_[((bytes_to_encode[pos + 1] & 0x0f) << 2) + ((bytes_to_encode[pos + 2] & 0xc0) >> 6)]);
-              ret.push_back(base64_chars_[  bytes_to_encode[pos + 2] & 0x3f]);
-           }
-           else {
-              ret.push_back(base64_chars_[(bytes_to_encode[pos + 1] & 0x0f) << 2]);
-              ret.push_back(trailing_char);
-           }
-        }
-        else {
-
-            ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0x03) << 4]);
-            ret.push_back(trailing_char);
-            ret.push_back(trailing_char);
-        }
-
-        pos += 3;
-    }
-
-
-    return ret;
-}
-
-template <typename String>
-static std::string decode(String const& encoded_string, bool remove_linebreaks) {
- //
- // decode(…) is templated so that it can be used with String = const std::string&
- // or std::string_view (requires at least C++17)
- //
-
-    if (encoded_string.empty()) return std::string();
-
-    if (remove_linebreaks) {
-
-       std::string copy(encoded_string);
-
-       copy.erase(std::remove(copy.begin(), copy.end(), '\n'), copy.end());
-
-       return base64_decode(copy, false);
-    }
-
-    size_t length_of_string = encoded_string.length();
-    size_t pos = 0;
-
- //
- // The approximate length (bytes) of the decoded string might be one or
- // two bytes smaller, depending on the amount of trailing equal signs
- // in the encoded string. This approximation is needed to reserve
- // enough space in the string to be returned.
- //
-    size_t approx_length_of_decoded_string = length_of_string / 4 * 3;
-    std::string ret;
-    ret.reserve(approx_length_of_decoded_string);
-
-    while (pos < length_of_string) {
-    //
-    // Iterate over encoded input string in chunks. The size of all
-    // chunks except the last one is 4 bytes.
-    //
-    // The last chunk might be padded with equal signs or dots
-    // in order to make it 4 bytes in size as well, but this
-    // is not required as per RFC 2045.
-    //
-    // All chunks except the last one produce three output bytes.
-    //
-    // The last chunk produces at least one and up to three bytes.
-    //
-
-       size_t pos_of_char_1 = pos_of_char(encoded_string.at(pos+1) );
-
-    //
-    // Emit the first output byte that is produced in each chunk:
-    //
-       ret.push_back(static_cast<std::string::value_type>( ( (pos_of_char(encoded_string.at(pos+0)) ) << 2 ) + ( (pos_of_char_1 & 0x30 ) >> 4)));
-
-       if ( ( pos + 2 < length_of_string  )       &&  // Check for data that is not padded with equal signs (which is allowed by RFC 2045)
-              encoded_string.at(pos+2) != '='     &&
-              encoded_string.at(pos+2) != '.'         // accept URL-safe base 64 strings, too, so check for '.' also.
-          )
-       {
-       //
-       // Emit a chunk's second byte (which might not be produced in the last chunk).
-       //
-          unsigned int pos_of_char_2 = pos_of_char(encoded_string.at(pos+2) );
-          ret.push_back(static_cast<std::string::value_type>( (( pos_of_char_1 & 0x0f) << 4) + (( pos_of_char_2 & 0x3c) >> 2)));
-
-          if ( ( pos + 3 < length_of_string )     &&
-                 encoded_string.at(pos+3) != '='  &&
-                 encoded_string.at(pos+3) != '.'
-             )
-          {
-          //
-          // Emit a chunk's third byte (which might not be produced in the last chunk).
-          //
-             ret.push_back(static_cast<std::string::value_type>( ( (pos_of_char_2 & 0x03 ) << 6 ) + pos_of_char(encoded_string.at(pos+3))   ));
-          }
-       }
-
-       pos += 4;
-    }
-
-    return ret;
-}
-
-std::string base64_decode(std::string const& s, bool remove_linebreaks) {
-   return decode(s, remove_linebreaks);
-}
-
-std::string base64_encode(std::string const& s, bool url) {
-   return encode(s, url);
-}
-
-std::string base64_encode_pem (std::string const& s) {
-   return encode_pem(s);
-}
-
-std::string base64_encode_mime(std::string const& s) {
-   return encode_mime(s);
-}
-
-#if __cplusplus >= 201703L
-//
-// Interface with std::string_view rather than const std::string&
-// Requires C++17
-// Provided by Yannic Bonenberger (https://github.com/Yannic)
-//
-
-std::string base64_encode(std::string_view s, bool url) {
-   return encode(s, url);
-}
-
-std::string base64_encode_pem(std::string_view s) {
-   return encode_pem(s);
-}
-
-std::string base64_encode_mime(std::string_view s) {
-   return encode_mime(s);
-}
-
-std::string base64_decode(std::string_view s, bool remove_linebreaks) {
-   return decode(s, remove_linebreaks);
-}
-
-#endif  // __cplusplus >= 201703L

src/contrib/base64.hpp

@@ -1,35 +0,0 @@
-//
-//  base64 encoding and decoding with C++.
-//  Version: 2.rc.09 (release candidate)
-//
-
-#ifndef BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A
-#define BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A
-
-#include <string>
-
-#if __cplusplus >= 201703L
-#include <string_view>
-#endif  // __cplusplus >= 201703L
-
-std::string base64_encode     (std::string const& s, bool url = false);
-std::string base64_encode_pem (std::string const& s);
-std::string base64_encode_mime(std::string const& s);
-
-std::string base64_decode(std::string const& s, bool remove_linebreaks = false);
-std::string base64_encode(unsigned char const*, size_t len, bool url = false);
-
-#if __cplusplus >= 201703L
-//
-// Interface with std::string_view rather than const std::string&
-// Requires C++17
-// Provided by Yannic Bonenberger (https://github.com/Yannic)
-//
-std::string base64_encode     (std::string_view s, bool url = false);
-std::string base64_encode_pem (std::string_view s);
-std::string base64_encode_mime(std::string_view s);
-
-std::string base64_decode(std::string_view s, bool remove_linebreaks = false);
-#endif  // __cplusplus >= 201703L
-
-#endif /* BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A */

src/main.cpp

@@ -1,262 +0,0 @@
-#include "version.hpp"
-#include "config.hpp"
-#include "service_runner.hpp"
-#include "services.hpp"
-#include "servers.hpp"
-#include "utils/directories.hpp"
-#include "templates.hpp"
-#include "utils/utils.hpp"
-#include "utils/readmes.hpp"
-#include "autocomplete.hpp"
-#include "main_commands.hpp"
-#include "utils/hash.hpp"
-
-#include <filesystem>
-#include <iostream>
-#include <string>
-#include <vector>
-#include <iomanip>
-#include <chrono>
-
-
-namespace dropshell {
-
-extern const std::string VERSION;
-extern const std::string RELEASE_DATE;
-extern const std::string AUTHOR;
-extern const std::string LICENSE;
-
-void print_help() {
-    std::cout << std::endl;
-    maketitle("DropShell version " + VERSION);
-    std::cout << std::endl;
-    std::cout << "A tool for managing server configurations" << std::endl;
-    std::cout << std::endl;
-    std::cout << "dropshell ..." << std::endl;
-    std::cout << "  help           Show this help message" << std::endl;
-    std::cout << "  init DIR       Add DIR as a local server config directory (can add several)" << std::endl;
-
-    if (gConfig().is_config_set()) {
-    std::cout << "  server NAME    Show details for specific server" << std::endl;
-    std::cout << "  templates      List all available templates" << std::endl;
-    std::cout << std::endl;
-    std::cout << std::endl;
-    std::cout << "Service commands: (if no service is specified, all services for the server are affected)" << std::endl;
-    std::cout << "  install SERVER [SERVICE]     Install/reinstall/update service(s). Non-destructive." << std::endl;
-    std::cout << "  list [SERVER] [SERVICE]      List status/details of all servers/server/service." << std::endl;
-    std::cout << "  edit [SERVER] [SERVICE]      Edit the configuration of dropshell/server/service." << std::endl;
-    std::cout << "  COMMAND SERVER [SERVICE]     Run a command on service(s)." << std::endl;
-    std::cout << std::endl;
-    std::cout << "Standard commands: install, uninstall, backup, restore, start, stop" << std::endl;
-    std::cout << std::endl;
-    std::cout << "  ssh     SERVER [SERVICE]     Launch an interactive shell on a server or service" << std::endl;
-    std::cout << std::endl;
-    std::cout << "Creation commands: (apply to the first local config directory)"<<std::endl;
-    std::cout << "  create-template TEMPLATE" << std::endl;
-    std::cout << "  create-server   SERVER" << std::endl;
-    std::cout << "  create-service  SERVER TEMPLATE SERVICE" << std::endl;
-    }
-    else {
-        std::cout << "  edit           Edit the configuration of dropshell" << std::endl;
-        std::cout << std::endl;
-        std::cout << "Other commands available once initialised." << std::endl;
-    }
-}
-
-
-int die(const std::string & msg) {
-    std::cerr << msg << std::endl;
-    return 1;
-}
-
-bool parseargs(std::string arg2, std::string arg3, std::string & server_name, std::vector<ServiceInfo>& servicelist)
-{
-    if (arg2.empty()) return false;
-    server_name = arg2;
-
-    if (arg3.empty()) {
-        servicelist = get_server_services_info(server_name);
-    } else {
-        servicelist.push_back(get_service_info(server_name, arg3));
-    }
-
-    return true;
-}
-
-std::string safearg(int argc, char *argv[], int index)
-{
-    if (index >= argc) return "";
-    return argv[index];
-}
-
-void printversion() {
-    maketitle("DropShell version " + VERSION);
-    std::cout << "Release date: " << RELEASE_DATE << std::endl;
-    std::cout << "Author:       " << AUTHOR << std::endl;
-    std::cout << "License:      " << LICENSE << std::endl;
-}
-
-#define HAPPYEXIT(CMD, RUNCMD) {if (safearg(argc,argv,1) == CMD) {RUNCMD; return 0;}}
-
-int main(int argc, char* argv[]) {
-    HAPPYEXIT("hash", hash_demo_raw(safearg(argc,argv,2)))
-    HAPPYEXIT("makesafecmd", std::cout<<makesafecmd(safearg(argc,argv,2))<<std::endl)
-    HAPPYEXIT("version", printversion())
-    ASSERT_MSG(safearg(argc,argv,1) != "assert", "Hello! Here is an assert.");
-
-    try {
-        // silently attempt to load the config file.
-        gConfig().load_config();
-
-        if (argc < 2) {
-            print_help();
-            return 0;
-        }
-        std::string cmd = argv[1];
-        std::vector<std::string> argvec;
-        for (int i=0; i<argc; i++) 
-            argvec.push_back(argv[i]);
-
-
-        if (cmd == "autocomplete") {
-            autocomplete(argvec);
-            return 0;
-        }
-
-        if (cmd == "init") {
-            return main_commands::init(argvec);
-        }
-
-        if (cmd == "help" || cmd == "-h" || cmd == "--help" || cmd== "h" || cmd=="halp") {
-            print_help();
-            return 0;
-        }
-
-        if (cmd == "edit" && argc < 3) {
-            std::string config_file = localfile::dropshell_env();
-            std::filesystem::create_directories(  get_parent(config_file) );
-            edit_file(config_file, "Please ensure any directories you have introduced in the config file exist.");
-            return 0;
-        }
-
-        // ------------------------------------------------------------
-        // from here we require the config file to be loaded.
-        if (!gConfig().is_config_set()) 
-            return die("Please run 'dropshell init <path>' to initialise the user directory and create a configuration file.");
-
-        const std::vector<std::string> & local_config_directories = gConfig().get_local_config_directories();
-        std::cout << "Config directories: ";
-        for (auto & dir : local_config_directories) 
-            std::cout << "["<< dir << "] ";
-        std::cout << std::endl;
-
-        if (cmd == "server" || cmd == "servers" || cmd == "list" || cmd == "view") 
-            switch (argc)
-            {
-                case 2:
-                    list_servers();
-                    return 0;
-                case 3:
-                    show_server_details(argv[2]);
-                    return 0;
-                case 4:
-                    cmd="logs";
-                    break;
-                default:
-                    return die("dropshell server: too many arguments");
-            }
-
-        if (cmd == "templates") {
-            list_templates();
-            return 0;
-        }
-
-        if (cmd == "create-template") {
-            if (argc < 3) return die("Error: create-template requires a template name");
-            create_template(argv[2]);
-            return 0;
-        }
-
-        if (cmd == "create-server") {
-            if (argc < 3) return die("Error: create-server requires a server name");
-            create_server(argv[2]);
-            return 0;
-        }
-
-        if (cmd == "create-service") {
-            if (argc < 5) return die("Error: not enough arguments.\ndropshell create-service server template service");
-            create_service(argv[2], argv[3], argv[4]);
-            return 0;
-        }
-
-         if (cmd == "ssh" && argc < 4) {
-            if (argc < 3) return die("Error: ssh requires a server name and optionally service name");
-            interactive_ssh(argv[2], "bash");
-            return 0;
-        }
-
-        if (cmd == "edit" && argc < 4) {
-            ASSERT_MSG(argc>=3, "Error: logic error!");
-            edit_server(safearg(argc,argv,2));
-            return 0;
-        }
-
-        if (cmd == "backup" || cmd=="backups") {
-            if (argc < 4) return die("Error: backup requires a target server and target service to back up");
-            return main_commands::backup(argvec);
-        }
-
-        if (cmd == "restore") {
-            if (argc < 4) return die("Error: restore requires a target server, target service the backup file to restore");
-            return main_commands::restore(argvec);
-        }
-
-        // handle running a command. 
-        std::set<std::string> commands;
-        get_all_used_commands(commands);
-        commands.merge(std::set<std::string>{"ssh","edit","_allservicesstatus"}); // handled by service_runner, but not in template_shell_commands.
-        for (const auto& command : commands) {
-            if (cmd == command) {
-                std::string server_name;
-                std::vector<ServiceInfo> servicelist;
-                if (!parseargs(safearg(argc, argv, 2), safearg(argc, argv, 3), server_name, servicelist)) {
-                    std::cerr << "Error: " << command << " command requires server name and optionally service name" << std::endl;
-                    return 1;
-                }
-
-                for (const auto& service_info : servicelist) {
-                    service_runner runner(server_name, service_info.service_name);
-                    if (!runner.isValid()) {
-                        std::cerr << "Error: Failed to initialize service" << std::endl;
-                        return 1;
-                    }
-                    if (!runner.run_command(command)) {
-                        std::cerr << command +" failed." << std::endl;
-                        return 1;
-                    }
-                }
-                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[]) {
-    return dropshell::main(argc, argv);
-}

src/main_commands.cpp

@@ -1,280 +0,0 @@
-#include "main_commands.hpp"
-
-#include "utils/directories.hpp"
-#include "utils/utils.hpp"
-#include "utils/readmes.hpp"
-#include "service_runner.hpp"
-#include "config.hpp"
-#include "templates.hpp"
-#include "server_env_manager.hpp"
-
-#include <iostream>
-#include <filesystem>
-#include <algorithm>
-
-namespace dropshell {
-
-namespace main_commands {
-
-
-static const std::string magic_string = "-_-";
-
-
-int init(const std::vector<std::string> &args)
-{
-    std::string lcd;
-
-    if (args.size() < 3) {
-        std::cerr << "Error: init command requires a directory argument" << std::endl;
-        return 1;
-    }
-    try {
-        if (!gConfig().add_local_config_directory(args[2])) 
-            return 1; // error already reported
-
-        gConfig().save_config();
-        std::cout << "Config directory added: " << gConfig().get_local_config_directories().back() << std::endl;
-        dropshell::create_readme_local_config_dir(gConfig().get_local_config_directories().back());
-        
-        if (gConfig().get_local_config_directories().size() ==1)
-            std::cout << "DropShell is now initialised and you can add a server with 'dropshell create-server <server-name>'" << std::endl;
-        else
-        {
-            std::cout << "DropShell will now use all of the following directories for configuration:" << std::endl;
-            for (const auto& dir : gConfig().get_local_config_directories()) {
-                std::cout << "  " << dir << std::endl;
-            }
-            std::cout << "You can edit the config file manually with:   dropshell edit" << std::endl;
-        }
-    } catch (const std::exception& e) {
-        std::cerr << "Error in init: " << e.what() << std::endl;
-        return 1;
-    }
-    return 0;
-}
-
-int restore(const std::vector<std::string> &args, bool silent)
-{
-    if (args.size() < 4) {
-        std::cerr << "Error: not enough arguments.  dropshell restore <server> <service> <backup-file>" << std::endl;
-        return 1;
-    }
-
-    std::string server_name = args[2];
-    std::string service_name = args[3];
-    std::string backup_file = args[4];
-
-    ServiceInfo service_info = get_service_info(server_name, service_name);
-    if (service_info.local_service_path.empty()) {
-        std::cerr << "Error: Service not found" << std::endl;
-        return 1;
-    }
-
-    server_env_manager env(server_name);
-    if (!env.is_valid()) {
-        std::cerr << "Error: Invalid server environment" << std::endl;
-        return 1;
-    }
-
-    std::string local_backups_dir = localpath::backups_path();
-    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 1;
-    }
-
-    // split the backup filename into parts based on the magic string
-    std::vector<std::string> parts = dropshell::split(backup_file, magic_string);
-    if (parts.size() != 4) {
-        std::cerr << "Error: Backup file format is incompatible, - in one of the names?" << std::endl;
-        return 1;
-    }
-
-    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 != service_info.template_name) {
-        std::cerr << "Error: Backup template does not match service template. Can't restore." << std::endl;
-        return 1;
-    }
-
-    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 "<<server_name<<std::endl;
-    std::cout << std::endl;
-    std::cout << "*** ALL DATA FOR "<<server_name<<"/"<<service_name<<" WILL BE OVERWRITTEN! ***"<<std::endl;
-    std::cout << std::endl;
-    std::cout << "Are you sure you want to continue? (y/n)" << std::endl;
-    char confirm;
-    std::cin >> confirm;
-    if (confirm != 'y') {
-        std::cout << "Restore cancelled." << std::endl;
-        return 1;
-    }
-
-    // run the restore script
-    std::cout << "OK, here goes..." << std::endl;
-
-    { // backup existing service
-        std::cout << "1) Backing up existing service... " << std::flush;
-        std::vector<std::string> backup_args = {"dropshell","backup",server_name, service_name};
-        if (!backup(backup_args,true)) // silent=true
-        {
-            std::cerr << std::endl;
-            std::cerr << "Error: Backup failed, restore aborted." << std::endl;
-            std::cerr << "You can try using   dropshell install "<<server_name<<" "<<service_name<<"   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 1;
-        }
-        std::cout << "Backup complete." << std::endl;
-    }
-
-    { // restore service from backup
-        std::cout << "2) Restoring service from backup..." << std::endl;
-        std::string remote_backups_dir = remotepath::backups(server_name);
-        std::string remote_backup_file_path = remote_backups_dir + "/" + backup_file;
-
-        // Copy backup file from local to server
-        std::string scp_cmd = "scp -P " + env.get_SSH_PORT() + " " + quote(local_backup_file_path) + " " + env.get_SSH_USER() + "@" + env.get_SSH_HOST() + ":" + quote(remote_backup_file_path) + (silent ? " > /dev/null 2>&1" : "");
-        if (!env.execute_local_command(scp_cmd)) {
-            std::cerr << "Failed to copy backup file from server" << std::endl;
-            return false;
-        }
-        env.run_remote_template_command(service_name, "restore", {remote_backup_file_path}, silent);
-    }
-
-    // healthcheck the service
-    std::cout << "3) Healthchecking service..." << std::endl;
-    std::string green_tick = "\033[32m✓\033[0m";
-    std::string red_cross = "\033[31m✗\033[0m";    
-    bool healthy= (env.run_remote_template_command(service_name, "status", {}, silent));
-    if (!silent)
-        std::cout << (healthy ? green_tick : red_cross) << " Service is " << (healthy ? "healthy" : "NOT healthy") << std::endl;
-
-    return 0;
-}
-
-bool name_breaks_backups(std::string name)
-{
-    // if name contains -_-, return true
-    return name.find("-_-") != std::string::npos;
-}
-
-
-        // 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.
-// ------------------------------------------------------------------------------------------------
-int backup(const std::vector<std::string> & args, bool silent) {
-    if (args.size() < 4) {
-        std::cerr << "Error: backup command requires a server name and service name" << std::endl;
-        return 1;
-    }
-
-    std::string server_name = args[2];
-    std::string service_name = args[3];
-
-    ServiceInfo service_info = get_service_info(server_name, service_name);
-    if (service_info.local_service_path.empty()) {
-        std::cerr << "Error: Service not found" << std::endl;
-        return 1;
-    }
-
-    server_env_manager env(server_name);
-    if (!env.is_valid()) {
-        std::cerr << "Error: Invalid server environment" << std::endl;
-        return 1;
-    }
-
-    const std::string command = "backup";
-
-    if (!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(server_name, service_name);
-    std::string remote_command_script_file = remote_service_template_path + "/" + command + ".sh";
-    std::string remote_service_config_path = remotepath::service_config(server_name, service_name);
-    if (!env.check_remote_items_exist({
-        remotepath::service(server_name, service_name),
-        remote_command_script_file,
-        remotefile::service_env(server_name, service_name)})
-    )
-    {
-        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(server_name);
-    if (!silent) std::cout << "Remote backups directory on "<< server_name <<": " << remote_backups_dir << std::endl;
-    std::string mkdir_cmd = "mkdir -p " + quote(remote_backups_dir);
-    if (!env.execute_ssh_command(mkdir_cmd)) {
-        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 = localpath::backups_path();
-    if (local_backups_dir.empty()) {
-        std::cerr << "Error: Local backups directory not found - is DropShell initialised?" << 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");
-    
-    if (name_breaks_backups(server_name)) {std::cerr << "Error: Server name contains invalid character sequence ( -_- ) that would break backup naming scheme" << std::endl; return 1;}
-    if (name_breaks_backups(service_name)) {std::cerr << "Error: Service name contains invalid character sequence ( -_- ) that would break backup naming scheme" << std::endl; return 1;}
-    if (name_breaks_backups(service_info.template_name)) {std::cerr << "Error: Service template name contains invalid character sequence ( -_- ) that would break backup naming scheme" << std::endl; return 1;}
-
-    // Construct backup filename
-    std::string backup_filename = server_name + magic_string + service_info.template_name + magic_string + service_name + magic_string + datetime.str() + ".tgz";
-    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(magic_string, local_backup_file_path));
-
-    // Run backup script
-    if (!env.run_remote_template_command(service_name, command, {remote_backup_file_path}, silent)) {
-        std::cerr << "Backup script failed on remote server: " << remote_backup_file_path << std::endl;
-        return false;
-    }
-
-    // Copy backup file from server to local
-    std::string scp_cmd = "scp -P " + env.get_SSH_PORT() + " " + 
-                         env.get_SSH_USER() + "@" + env.get_SSH_HOST() + ":" + 
-                         quote(remote_backup_file_path) + " " + quote(local_backup_file_path) + (silent ? " > /dev/null 2>&1" : "");
-    if (!env.execute_local_command(scp_cmd)) {
-        std::cerr << "Failed to copy backup file from server" << std::endl;
-        return false;
-    }
-
-    if (!silent) {
-        std::cout << "Backup created successfully. Restore with:"<<std::endl;
-        std::cout << "   dropshell restore " << server_name << " " << service_name << " " << backup_filename << std::endl;
-    }
-    return true;
-}
-
-
-} // namespace main_commands
-
-} // namespace dropshell

src/main_commands.hpp

@@ -1,18 +0,0 @@
-#ifndef MAIN_COMMANDS_HPP
-#define MAIN_COMMANDS_HPP
-
-#include <string>
-#include <vector>
-
-namespace dropshell {
-
-    namespace main_commands {
-
-        int init(const std::vector<std::string> &args);
-        int restore(const std::vector<std::string> &args, bool silent=false);
-        int backup(const std::vector<std::string> &args, bool silent=false);
-        } // namespace main_commands
-
-} // namespace dropshell
-
-#endif

src/server_env_manager.cpp

@@ -1,225 +0,0 @@
-#include "server_env_manager.hpp"
-#include "utils/envmanager.hpp"
-#include "utils/directories.hpp"
-#include "utils/utils.hpp"
-#include "services.hpp"
-#include "contrib/base64.hpp"
-#include "templates.hpp"
-
-#include <iostream>
-#include <memory>
-#include <filesystem>
-
-namespace dropshell {
-
-server_env_manager::server_env_manager(const std::string& server_name) : mValid(false), mServer_name(server_name) {
-    if (server_name.empty())
-        return;
-        
-    // Construct the full path to server.env
-    std::string env_path = localfile::server_env(server_name);
-    
-    // Check if file exists
-    if (!std::filesystem::exists(env_path)) {
-        std::cerr << "Server environment file not found: " + env_path << std::endl;
-        return;
-    }
-
-    try {
-        // Use envmanager to handle the environment file
-        m_env_manager = std::unique_ptr<envmanager>(new envmanager(env_path));
-        m_env_manager->load();
-        
-        // Get all variables
-        m_env_manager->get_all_variables_substituted(variables);
-
-        // Verify required variables exist
-        for (const auto& var : {"SSH_HOST", "SSH_USER", "SSH_PORT", "DROPSHELL_DIR"}) {
-            if (variables.find(var) == variables.end()) {
-                // Print the variables identified in the file
-                std::cout << "Variables identified in the file:" << std::endl;
-                for (const auto& v : variables) {
-                    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;
-    }    
-}
-
-std::string server_env_manager::get_variable(const std::string& name) const {
-    if (!m_env_manager) {
-        return "";
-    }
-    return m_env_manager->get_variable_substituted(name);
-}
-
-// Helper method implementations
-std::string server_env_manager::construct_ssh_cmd() const {
-    std::stringstream ssh_cmd;
-    ssh_cmd << "ssh -p " << get_SSH_PORT() << " "
-            << get_SSH_USER() << "@" << get_SSH_HOST();
-    return ssh_cmd.str();
-}
-
-std::string server_env_manager::construct_standard_command_run_cmd(const std::string &service_name, const std::string &command, std::vector<std::string> args, bool silent) const
-{
-    std::string remote_service_template_path = remotepath::service_template(mServer_name,service_name);
-    std::string remote_service_config_path = remotepath::service_config(mServer_name,service_name);
-
-    std::string script_path = remote_service_template_path + "/" + command + ".sh";
-
-    std::map<std::string, std::string> env_vars;
-    get_all_service_env_vars(service_name, env_vars);
-
-    std::string argstr = "";
-    for (const auto& arg : args) {
-        argstr += " " + quote(dequote(trim(arg)));
-    }
-
-    sCommand scommand(remote_service_template_path, "bash " + quote(script_path) + argstr + (silent ? " > /dev/null 2>&1" : ""), env_vars);
-    std::string run_cmd = scommand.construct_safecmd();
-    return run_cmd;
-}
-
-void server_env_manager::get_all_service_env_vars(const std::string &service_name, std::map<std::string, std::string> & all_env_vars) const
-{
-    all_env_vars.clear();
-
-    // add in some handy variables.
-    all_env_vars["CONFIG_PATH"] = remotepath::service_config(mServer_name,service_name);
-    all_env_vars["SERVER"] = mServer_name;
-    all_env_vars["SERVICE"] = service_name;
-
-
-    { // load service.env from the service on this machine.
-    std::map<std::string, std::string> env_vars;
-    envmanager env_manager(localfile::service_env(mServer_name,service_name));
-    env_manager.load();
-    env_manager.get_all_variables(env_vars);
-    all_env_vars.merge(env_vars);
-    }
-
-    { // load _default.env from the template on this machine.
-    std::map<std::string, std::string> env_vars;
-    ServiceInfo service_info = get_service_info(mServer_name, service_name);
-    std::string defaultenvpath = service_info.local_template_default_env_path;
-    if (std::filesystem::exists(defaultenvpath)) {
-        envmanager env_manager(defaultenvpath);
-        env_manager.load();
-        env_manager.get_all_variables(env_vars);
-        all_env_vars.merge(env_vars);
-        }
-    else 
-        std::cerr << "Warning: _default.env not found in template: " << defaultenvpath << std::endl;
-    }
-}
-
-
-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(scommand);
-}
-
-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(scommand);
-}
-
-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(scommand);
-    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::execute_ssh_command(const sCommand& command) const {
-    std::string full_cmd = construct_ssh_cmd() + " " + quote(command.construct_safecmd());
-    return execute_local_command(full_cmd);
-}
-
-bool server_env_manager::execute_ssh_command_and_capture_output(const sCommand& command, std::string &output) const
-{
-    std::string full_cmd = construct_ssh_cmd() + " " + quote(command.construct_safecmd());
-    return execute_local_command_and_capture_output(full_cmd, output);
-}
-
-bool server_env_manager::run_remote_template_command(const std::string &service_name, const std::string &command, std::vector<std::string> args, bool silent) const
-{
-    std::string full_cmd = construct_standard_command_run_cmd(service_name, command, args, silent);
-    return execute_ssh_command(full_cmd);
-}
-
-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) const
-{
-    std::string full_cmd = construct_standard_command_run_cmd(service_name, command, args, silent);
-    return execute_ssh_command_and_capture_output(full_cmd, output);
-}
-
-bool server_env_manager::execute_local_command(const sCommand& command) {
-    return (system(command.construct_safecmd().c_str()) == 0);
-}
-
-bool server_env_manager::execute_local_command_and_capture_output(const sCommand& command, std::string &output)
-{
-    std::string full_cmd = command.construct_safecmd() + " 2>&1";
-    FILE *pipe = popen(full_cmd.c_str(), "r");
-    if (!pipe) {
-        return false;
-    }
-    char buffer[128];
-    while (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
-        output += buffer;
-    }
-    int status = pclose(pipe);
-    return (status == 0);
-}
-
-
-std::string sCommand::construct_safecmd() const
-{
-    std::string to_encode;
-
-    for (const auto& env_var : mVars) {
-        to_encode += env_var.first + "=" + quote(dequote(trim(env_var.second))) + " ";
-    }
-    to_encode += mCmd;
-
-    std::string encoded = base64_encode(to_encode);
-
-    std::string commandstr = "echo " + encoded + " | base64 -d | bash";
-
-    if (!mDir.empty()) 
-        commandstr = "cd " + quote(mDir) + " && " + commandstr;
-    return commandstr;
-}
-
-// base64 <<< "FOO=BAR WHEE=YAY bash ./test.sh"
-// echo YmFzaCAtYyAnRk9PPUJBUiBXSEVFPVlBWSBiYXNoIC4vdGVzdC5zaCcK | base64 -d | bash
-
-std::string makesafecmd(const std::string &command)
-{
-    std::string encoded = base64_encode(dequote(trim(command)));
-    std::string commandstr = "echo " + encoded + " | base64 -d | bash";
-    return commandstr;
-}
-
-} // namespace dropshell

src/server_env_manager.hpp

@@ -1,92 +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 "utils/envmanager.hpp"
-namespace dropshell {
-
-// class to hold a command to run on the remote server.
-class sCommand {
-    public:
-        sCommand(std::string directory_to_run_in, std::string command_to_run, const std::map<std::string, std::string> & env_vars) : 
-            mDir(directory_to_run_in), mCmd(command_to_run), mVars(env_vars) {}
-        sCommand(std::string command_to_run) : 
-            mDir(""), mCmd(command_to_run), mVars({}) {}
-
-
-        std::string get_directory_to_run_in() const { return mDir; }
-        std::string get_command_to_run() const { return mCmd; }
-        const std::map<std::string, std::string>& get_env_vars() const { return mVars; }
-
-        void add_env_var(const std::string& key, const std::string& value) { mVars[key] = value; }
-
-        std::string construct_safecmd() const;
-
-    private:
-        std::string mDir;
-        std::string mCmd;
-        std::map<std::string, std::string> mVars;
-};
-
-std::string makesafecmd(const std::string& command);
-
-// 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);
-        std::string get_variable(const std::string& name) const;
-
-        // trivial getters.
-        const std::map<std::string, std::string>& get_variables() const { return variables; }
-        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"); }
-        bool is_valid() const { return mValid; }
-
-// 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 run_remote_template_command(const std::string& service_name, const std::string& command, std::vector<std::string> args, bool silent=false) 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=false) const;
-
-    public:
-        bool execute_ssh_command(const sCommand& command) const;
-        bool execute_ssh_command_and_capture_output(const sCommand& command, std::string & output) const;
-
-        static bool execute_local_command(const sCommand& command);
-        static bool execute_local_command_and_capture_output(const sCommand& command, std::string & output);
-
-    private:
-        std::string construct_ssh_cmd() const;
-        std::string construct_standard_command_run_cmd(const std::string& service_name, const std::string& command, std::vector<std::string> args, bool silent) const;
-
-    private:
-        void get_all_service_env_vars(const std::string& service_name, std::map<std::string, std::string> & all_env_vars) const;
-
-    private:
-        std::string mServer_name;
-        std::map<std::string, std::string> variables;
-        bool mValid;
-        std::unique_ptr<envmanager> m_env_manager;
-};
-
-} // namespace dropshell
-
-
-#endif // __SERVER_ENV_HPP  

src/servers.cpp

@@ -1,199 +0,0 @@
-#include "servers.hpp"
-#include "server_env_manager.hpp"
-#include "service_runner.hpp"
-#include "utils/tableprint.hpp"
-#include "utils/envmanager.hpp"
-#include "utils/directories.hpp"
-#include "services.hpp"
-#include "config.hpp"
-#include "templates.hpp"
-#include <iostream>
-#include <fstream>
-#include <iomanip>
-#include <execution>
-#include <filesystem>
-
-namespace dropshell {
-
-std::vector<ServerInfo> get_configured_servers() {
-    std::vector<ServerInfo> servers;
-
-    std::vector<std::string> local_config_directories = gConfig().get_local_config_directories();
-    if (local_config_directories.empty())
-        return servers;
-
-    for (int i = 0; i < local_config_directories.size(); i++) {
-        std::string servers_dir = localpath::config_servers(i);
-        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();
-
-                    server_env_manager env(server_name);
-                    if (!env.is_valid()) {
-                        std::cerr << "Error: Invalid server environment file: " << entry.path().string() << std::endl;
-                        continue;
-                    }
-                    servers.push_back({
-                        server_name,
-                        env.get_SSH_HOST(),
-                        env.get_SSH_USER(),
-                        env.get_SSH_PORT()
-                    });
-                }
-            }
-        }
-    }
-
-    return servers;
-}
-
-void list_servers() {
-    auto servers = get_configured_servers();
-
-    tableprint tp("All DropShell Servers");
-    tp.add_row({"Name", "Address", "Health", "Ports"});
-
-    std::for_each(std::execution::par, servers.begin(), servers.end(), [&](const ServerInfo& server) {
-
-        std::map<std::string, ServiceStatus> status = service_runner::get_all_services_status(server.name); 
-
-        std::set<int> ports_used;
-        std::string serviceticks = "";
-        for (const auto& [service_name, service_status] : status) {
-            ports_used.insert(service_status.ports.begin(), service_status.ports.end());
-            serviceticks += service_runner::HealthStatus2String(service_status.health) + " ";
-        }
-        std::string ports_used_str = "";
-        for (const auto& port : ports_used) 
-            ports_used_str += std::to_string(port) + " ";
-        
-        tp.add_row({server.name, server.ssh_host, serviceticks, ports_used_str});
-    });
-    tp.print();
-}
-
-void show_server_details(const std::string& server_name) {
-    server_env_manager env(server_name);
-    if (!env.is_valid()) {
-        std::cerr << "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();
-    std::string ssh_user = env.get_SSH_USER();
-    std::string ssh_port = env.get_SSH_PORT();
-    if (!ssh_address.empty()) {
-        std::cout << std::endl << "Server Status:" << std::endl;
-        std::cout << std::string(40, '-') << std::endl;
-        
-        // Try to connect to the server
-        std::string cmd = "ssh -o ConnectTimeout=5 " + ssh_user + "@" + ssh_address + " -p " + ssh_port + " 'echo connected' 2>/dev/null";
-        int result = system(cmd.c_str());
-        if (result == 0) {
-            std::cout << "Status: Online" << std::endl;
-            
-            // // Get uptime if possible
-            // cmd = "ssh " + ssh_address + " 'uptime' 2>/dev/null";
-            // int rval = system(cmd.c_str());
-            // if (rval != 0) {
-            //     std::cout << "Error: Failed to get uptime" << std::endl;
-            // } 
-        } else {
-            std::cout << "Status: Offline" << std::endl;
-        }
-    }
-    std::cout << std::endl;
-
-    //---------------------
-    {
-        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});
-        }
-        tp.print();
-    }
-
-    //---------------------
-    // list services, and run healthcheck on each
-    {
-        tableprint tp("Services: " + server_name, false);
-        tp.add_row({"Status", "Service", "Ports"});
-        
-
-        std::map<std::string, ServiceStatus> status = service_runner::get_all_services_status(server_name); 
-
-        std::set<int> ports_used;
-        std::string serviceticks = "";
-        for (const auto& [service_name, service_status] : status) {
-            std::string healthy = service_runner::HealthStatus2String(service_status.health);
-            
-            std::string ports_str = "";
-            for (const auto& port : service_status.ports) 
-                ports_str += std::to_string(port) + " ";
-        
-            tp.add_row({healthy, service_name, ports_str});
-        } // end of for (const auto& service : services)
-        tp.print();
-    } // end of list services
-} // end of show_server_details
-
-void 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;
-    }
-
-    // 2. create a new directory in the user config directory
-    std::string config_servers_dir = localpath::config_servers();
-    std::string server_dir = config_servers_dir + "/" + 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();
-
-    // 4. add dropshell-agent service to server
-    create_service(server_name, "dropshell-agent", "dropshell-agent", true); // silently create service.
-
-    // std::string service_dir = server_dir + "/dropshell-agent";
-    // std::filesystem::create_directory(service_dir);
-    // std::string service_env_path = service_dir + "/service.env";
-    // std::filesystem::copy(get_local_system_templates_path() + "/dropshell-agent/example/service.env", service_env_path);
-
-    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 dropshell-agent:       dropshell install " << server_name << " dropshell-agent" << std::endl;
-    std::cout << std::endl;
-}
-
-void get_all_used_commands(std::set<std::string> &commands)
-{
-    std::vector<ServerInfo> servers = get_configured_servers();
-    for (const auto& server : servers) 
-    {
-        std::vector<dropshell::ServiceInfo> services = dropshell::get_server_services_info(server.name);
-        for (const auto& service : services) 
-            commands.merge(dropshell::get_used_commands(server.name, service.service_name));
-    }
-}
-
-} // namespace dropshell

src/service_runner.cpp

@@ -1,449 +0,0 @@
-#include "config.hpp"
-#include "service_runner.hpp"
-#include "server_env_manager.hpp"
-#include "templates.hpp"
-#include "services.hpp"
-#include "utils/directories.hpp"
-#include "utils/utils.hpp"
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <cstdlib>
-#include <chrono>
-#include <iomanip>
-#include <filesystem>
-#include <unistd.h>
-
-namespace fs = std::filesystem;
-
-namespace dropshell {
-
-service_runner::service_runner(const std::string& server_name, const std::string& service_name) : 
-    mServerEnv(server_name), mServer(server_name), mService(service_name), mValid(false)
-{
-    if (server_name.empty() || service_name.empty())
-        return; 
-
-    // Initialize server environment
-    if (!mServerEnv.is_valid()) 
-        return;
-
-    mServiceInfo = get_service_info(server_name, service_name);
-    mService = mServiceInfo.service_name;
-    
-    mValid = !mServiceInfo.local_template_path.empty();
-}
-
-bool service_runner::install() {
-    maketitle("Installing " + mService + " (" + mServiceInfo.template_name + ") on " + mServer);
-
-    if (!mServerEnv.is_valid()) return false; // should never hit this.
-    
-    // Check if template exists
-    template_info tinfo;
-    if (!get_template_info(mServiceInfo.template_name, tinfo))
-        return false;
-        
-    // Create service directory
-    std::string remote_service_path = remotepath::service(mServer, mService);
-    std::string mkdir_cmd = "mkdir -p " + quote(remote_service_path);
-    if (!mServerEnv.execute_ssh_command(mkdir_cmd))
-    {
-        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 > /dev/null 2>&1";
-    if (!mServerEnv.execute_ssh_command(check_rsync_cmd))
-    {
-        std::cerr << "rsync is not installed on the remote host" << std::endl;
-        return false;
-    }
-
-    // Copy template files
-    {
-        std::cout << "Copying: [LOCAL] " << tinfo.local_template_path << std::endl << std::string(8,' ')<<"[REMOTE] " << remotepath::service_template(mServer, mService) << "/" << std::endl;
-        std::string rsync_cmd = "rsync --delete -zrpc -e 'ssh -p " + mServerEnv.get_SSH_PORT() + "' " + 
-                            quote(tinfo.local_template_path + "/") + " "+ 
-                            mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + 
-                            quote(remotepath::service_template(mServer, mService)+"/");
-        //std::cout << std::endl << rsync_cmd << std::endl << std::endl;
-        if (!mServerEnv.execute_local_command(rsync_cmd))
-        {
-            std::cerr << "Failed to copy template files using rsync" << std::endl;
-            std::cerr << "Is rsync installed on the remote host?" << std::endl;
-            return false;
-        }
-    }
-    
-    // Copy service files (including service.env)
-    {
-        std::string local_service_path = localpath::service(mServer,mService);
-        if (local_service_path.empty() || !fs::exists(local_service_path)) {
-            std::cerr << "Error: Service directory not found: " << local_service_path << std::endl;
-            return false;
-        }
-        std::cout << "Copying: [LOCAL] " << local_service_path << std::endl <<std::string(8,' ')<<"[REMOTE] " << remotepath::service_config(mServer,mService) << std::endl; 
-        std::string rsync_cmd = "rsync --delete -zrpc -e 'ssh -p " + mServerEnv.get_SSH_PORT() + "' " + 
-                            quote(local_service_path + "/") + " "+
-                            mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + 
-                            quote(remotepath::service_config(mServer,mService) + "/");
-        if (!mServerEnv.execute_local_command(rsync_cmd))
-        {
-            std::cerr << "Failed to copy service files using rsync" << std::endl;
-            return false;
-        }
-    }
-
-    // Run install script
-    {
-        mServerEnv.run_remote_template_command(mService, "install", {});
-    }
-
-    // print health tick
-    std::cout << "Health: " << healthtick() << std::endl;
-    return true;
-}
-
-bool service_runner::uninstall() {
-    maketitle("Uninstalling " + mService + " (" + mServiceInfo.template_name + ") on " + mServer);
-    
-    if (!mServerEnv.is_valid()) return false; // should never hit this.
-    
-    // 2. Check if service directory exists on server
-    if (!mServerEnv.check_remote_dir_exists(remotepath::service(mServer, mService))) {
-        std::cerr << "Service is not installed: " << mService << std::endl;
-        return true; // Nothing to uninstall
-    }
-    
-    // 3. Run uninstall script if it exists
-    std::string uninstall_script = remotepath::service_template(mServer, mService) + "/_uninstall.sh";
-    bool script_exists = mServerEnv.check_remote_file_exists(uninstall_script);
-    
-    if (script_exists) {
-        if (!mServerEnv.run_remote_template_command(mService, "uninstall", {})) {
-            std::cerr << "Warning: Uninstall script failed, but continuing with directory removal" << std::endl;
-        }
-
-    } else {
-        std::cerr << "Warning: No uninstall script found. Unable to uninstall service." << std::endl;
-        return false;
-    }
-    
-    // 4. Remove the service directory from the server
-    std::string rm_cmd = "'rm -rf " + quote(remotepath::service(mServer, mService)) + "'";
-    if (!mServerEnv.execute_ssh_command(rm_cmd)) {
-        std::cerr << "Failed to remove service directory" << std::endl;
-        return false;
-    }
-    
-    std::cout << "Service " << mService << " successfully uninstalled from " << mServer << std::endl;
-    return true;
-}
-
-
-// ------------------------------------------------------------------------------------------------
-// Run a command on the service.
-// ------------------------------------------------------------------------------------------------
-bool service_runner::run_command(const std::string& command) {
-    if (!mServerEnv.is_valid()) {
-        std::cerr << "Error: Server service not initialized" << std::endl;
-        return false;
-    }
-    template_info tinfo;
-    if (!get_template_info(mServiceInfo.template_name, tinfo)) {
-        std::cerr << "Error: Template '" << mServiceInfo.template_name << "' not found" << std::endl;
-        return false;
-    }
-
-    // don't need a script for edit!
-    if (command == "edit") {
-        edit_service_config();
-        return true;
-    }
-
-    if (!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();
-
-    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))) {
-        return false;
-    }
-    
-    // Check if command script exists
-    if (!mServerEnv.check_remote_file_exists(script_path)) {
-        return false;
-    }
-
-    // Check if env file exists
-    if (!mServerEnv.check_remote_file_exists(remotefile::service_env(mServer, mService))) {
-        return false;
-    }
-
-    if (command == "uninstall") 
-        return uninstall();
-    if (command == "ssh") {
-        interactive_ssh_service();
-        return true;
-    }
-
-    // Run the generic command
-    std::vector<std::string> args; // not passed through yet.
-    return mServerEnv.run_remote_template_command(mService, command, args);
-}
-
-
-std::map<std::string, ServiceStatus> service_runner::get_all_services_status(std::string server_name)
-{
-    std::map<std::string, ServiceStatus> status;
-
-    std::string command = "_allservicesstatus";
-    std::string service_name = "dropshell-agent";
-
-    if (!template_command_exists(service_name, command))
-        {
-            std::cerr << "Error: " << service_name << " does not contain the " << command << " script" << std::endl;
-            return status;
-        }
-
-    server_env_manager env(server_name);
-    if (!env.is_valid()) {
-        std::cerr << "Error: Invalid server environment" << std::endl;
-        return status;
-    }
-
-    std::string output;
-    if (!env.run_remote_template_command_and_capture_output(service_name, command, {}, output))
-        return status;
-
-    std::stringstream ss(output);
-    std::string line;
-    while (std::getline(ss, line)) {
-        std::string key, value;
-        std::size_t pos = line.find("=");
-        if (pos != std::string::npos) {
-            key = dequote(trim(line.substr(0, pos)));
-            value = dequote(trim(line.substr(pos + 1)));
-
-            // decode key, it's of format SERVICENAME_[HEALTH|PORTS]
-            std::string service_name = key.substr(0, key.find_last_of("_"));
-            std::string status_type = key.substr(key.find_last_of("_") + 1);
-
-            if (status_type == "HEALTH") { // healthy|unhealthy|unknown
-                if (value == "healthy")
-                    status[service_name].health = HealthStatus::HEALTHY;
-                else if (value == "unhealthy")
-                    status[service_name].health = HealthStatus::UNHEALTHY;
-                else if (value == "unknown")
-                    status[service_name].health = HealthStatus::UNKNOWN;
-                else
-                    status[service_name].health = HealthStatus::ERROR;
-            } else if (status_type == "PORTS") { // port1,port2,port3
-                std::vector<std::string> ports = string2multi(value);
-                for (const auto& port : ports) {
-                    if (port!="unknown")
-                        status[service_name].ports.push_back(str2int(port));
-                }
-            }
-        }
-    }
-    return status;
-}
-
-HealthStatus service_runner::is_healthy()
-{
-    if (!mServerEnv.is_valid()) {
-        std::cerr << "Error: Server service not initialized" << std::endl;
-        return HealthStatus::ERROR;
-    }
-
-    if (!mServerEnv.check_remote_dir_exists(remotepath::service(mServer, mService))) {
-        return HealthStatus::NOTINSTALLED;
-    }
-
-    std::string script_path = remotepath::service_template(mServer, mService) + "/status.sh";
-    if (!mServerEnv.check_remote_file_exists(script_path)) {
-        return HealthStatus::UNKNOWN;
-    }
-    
-    // Run status script, does not display output.
-    if (!mServerEnv.run_remote_template_command(mService, "status", {}, true))
-        return HealthStatus::UNHEALTHY;
-    return HealthStatus::HEALTHY;
-}
-
-std::string service_runner::healthtick()
-{
-    std::string green_tick = "\033[32m✓\033[0m";
-    std::string red_cross = "\033[31m✗\033[0m";    
-    std::string yellow_exclamation = "\033[33m!\033[0m";
-    std::string unknown = "\033[37m✓\033[0m";
-
-    HealthStatus status = is_healthy();
-    if (status == HealthStatus::HEALTHY)
-        return green_tick;
-    else if (status == HealthStatus::UNHEALTHY)
-        return red_cross;
-    else if (status == HealthStatus::UNKNOWN)
-        return unknown;
-    else
-        return yellow_exclamation;
-}
-
-std::string service_runner::HealthStatus2String(HealthStatus status)
-{
-    if (status == HealthStatus::HEALTHY)
-        return ":tick:";
-    else if (status == HealthStatus::UNHEALTHY)
-        return ":cross:";
-    else if (status == HealthStatus::UNKNOWN)
-        return ":greytick:";
-    else if (status == HealthStatus::NOTINSTALLED)
-        return ":warning:";
-    else
-        return ":error:";
-}
-
-bool service_runner::ensure_service_dropshell_files_up_to_date()
-{
-    if (!mServerEnv.is_valid()) {
-        std::cerr << "Error: Server service not initialized" << std::endl;
-        return false;
-    }
-    
-    // check if the service template and config are up to date on the remote server.
-    service_versions versions(mServer, mService);
-    if (versions.remote_up_to_date())
-        return true;
-    
-    if (!versions.remote_template_is_up_to_date()) {
-        std::cerr << "Error: Service template is not up to date on the remote server" << std::endl;
-        return false;
-    }
-
-    if (!versions.remote_config_is_up_to_date()) {
-        std::cerr << "Error: Service config is not up to date on the remote server" << std::endl;
-        return false;
-    }
-
-// TODO - actually update things!
-
-    versions.update_stored_remote_versions();
-    return versions.remote_up_to_date();
-}
-
-std::string service_runner::healthmark()
-{
-    HealthStatus status = is_healthy();
-    return HealthStatus2String(status);
-}
-
-void 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;
-    }
-
-    server_env_manager env(server_name);
-    if (!env.is_valid()) {
-        std::cerr << "Error: Invalid server environment file: " << server_name << std::endl;
-        return;
-    }
-
-    std::string ssh_address = env.get_SSH_HOST();
-    std::string ssh_user = env.get_SSH_USER();
-    std::string ssh_port = env.get_SSH_PORT();
-
-    std::string login = ssh_user + "@" + ssh_address;
-
-    // Execute ssh with server_name and command
-    if (command.empty())
-        execlp("ssh", "ssh", "-tt", login.c_str(), "-p", ssh_port.c_str(), nullptr);
-    else
-        execlp("ssh", "ssh", "-tt", login.c_str(), "-p", ssh_port.c_str(), command.c_str(), nullptr);
-    
-    // If exec returns, it means there was an error
-    perror("ssh execution failed");
-    exit(EXIT_FAILURE);
-}
-
-void edit_server(const std::string &server_name)
-{
-    std::string serverpath = localpath::server(server_name);
-    if (serverpath.empty()) {
-        std::cerr << "Error: Server not found: " << server_name << std::endl;
-        return;
-    }
-
-    std::ostringstream aftertext; 
-    aftertext << "If you have changed DROPSHELL_DIR, you should manually move the files to the new location NOW.\n"
-              << "You can ssh in to the remote server with:  dropshell ssh "<<server_name<<"\n" 
-              << "Once moved, reinstall all services with:   dropshell install " << server_name;
-
-    std::string config_file = serverpath + "/server.env";
-    edit_file(config_file, aftertext.str());
-}
-
-void edit_file(const std::string &file_path, const std::string & aftertext)
-{
-    std::string cmd = "nano -w "+file_path+" ; echo \""+aftertext+"\"";
-    execlp("bash","bash","-c",cmd.c_str(), nullptr);
-    
-    // If exec returns, it means there was an error
-    perror("ssh execution failed");
-    exit(EXIT_FAILURE);
-}
-
-bool service_runner::restore(std::string backup_file)
-{
-    std::string command = "restore";
-    std::string script_path = remotepath::service_template(mServer, mService) + "/" + command + ".sh";
-    if (!template_command_exists(mServiceInfo.template_name, command)) {
-        std::cout << "No restore script for " << mServiceInfo.template_name << std::endl;
-        return true; // nothing to restore.
-    }
-
-    /// TOODOOOOOO!!!!!!
-    std::cout << "Restore not implemented yet" << std::endl;
-    return true;
-
-    //    std::string run_cmd = construct_standard_command_run_cmd("restore");
-    //    return execute_ssh_command(run_cmd, "Restore script failed");
-}
-
-void 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;
-    }
-
-    std::vector<std::string> args; // not passed through yet.
-    mServerEnv.run_remote_template_command(mService, "ssh", args);
-}
-
-void service_runner::edit_service_config()
-{
-    std::string config_file = localfile::service_env(mServer,mService);
-    if (!fs::exists(config_file)) {
-        std::cerr << "Error: Service config file not found: " << config_file << std::endl;
-        return;
-    }
-
-    std::string aftertext = "To apply your changes, run:\n   dropshell install " + mServer + " " + mService;
-
-    edit_file(config_file, aftertext);
-}
-
-} // namespace dropshell 

src/service_runner.hpp

@@ -1,140 +0,0 @@
-// server_service.hpp
-//
-// manage a service on a server
-//
-
-#ifndef SERVICE_RUNNER_HPP
-#define SERVICE_RUNNER_HPP  
-
-#include <string>
-#include <vector>
-#include <memory>
-#include "server_env_manager.hpp"
-#include "services.hpp"
-#include "utils/utils.hpp"
-#include "utils/assert.hpp"
-#include "utils/hash.hpp"
-
-namespace dropshell {
-
-typedef enum HealthStatus {
-    HEALTHY,
-    UNHEALTHY,
-    NOTINSTALLED,
-    ERROR,
-    UNKNOWN
-} HealthStatus;
-
-typedef struct ServiceStatus {
-    HealthStatus health;
-    std::vector<int> ports;
-} ServiceStatus;
-
-class service_runner {
-    public:
-        service_runner(const std::string& server_name, const std::string& service_name);
-        bool isValid() const { return mValid; }
-
-        // run a command over ssh, using the credentials from server.env (via server_env.hpp)
-        // first check that the command corresponds to a valid .sh file in the service directory
-        // then run the command, passing the {service_name}.env file as an argument
-        // do a lot of checks, such as:
-        // checking that we can ssh to the server.
-        // checking whether the service directory exists on the server.
-        // checking that the command exists in the service directory.
-        // checking that the command is a valid .sh file.
-        // checking that the {service_name}.env file exists in the service directory.
-        bool run_command(const std::string& command);
-
-        // 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();
-        std::string healthmark();
-
-        // get the status of all services on the server
-        static std::map<std::string, ServiceStatus> get_all_services_status(std::string server_name);
-        static std::string HealthStatus2String(HealthStatus status);
-
-        // ensure the service related dropshell files (template and config) are up to date on the remote server.
-        bool ensure_service_dropshell_files_up_to_date();
-
-    private:    
-        // install the service over ssh, using the credentials from server.env (via server_env.hpp), by:
-        // 1. check if the server_name exists, and the service_name refers to a valid template
-        // 2. check if service_name is valid for the server_name
-        // 3. create the service directory on the server at {DROPSHELL_DIR}/{service_name}
-        // 3. copy the template files into {DROPSHELL_DIR}/{service_name}/template (from the templates directory for the specified server, using templates.hpp to identify the path)
-        // 4. copying the local service directory into {DROPSHELL_DIR}/{service_name}/config (from the server directory for the specified server)
-        // 5. running the install.sh script on the server, passing the {service_name}.env file as an argument
-        bool install(); 
-        
-        // uninstall the service over ssh, using the credentials from server.env (via server_env.hpp)
-        // 1. check if the server_name exists, and the service_name refers to a valid template
-        // 2. check if service_name is valid for the server_name
-        // 3. run the uninstall.sh script on the server, passing the {service_name}.env file as an argument
-        // 4. remove the service directory from the server
-        bool uninstall();
-
-        // restore the service over ssh, using the credentials from server.env (via server_env.hpp)
-        // 1. copy the backup file to the server's DROPSHELL_DIR/backups folder
-        // 2. run the restore.sh script on the server, passing the {service_name}.env file as an argument
-        bool restore(std::string backup_file);
-
-        // launch an interactive ssh session on a server or service
-        // replaces the current dropshell process with the ssh process
-        void interactive_ssh_service();
-
-        // edit the service configuration file
-        void edit_service_config();
-
-    private:
-        std::string mServer;
-        server_env_manager mServerEnv;
-        ServiceInfo mServiceInfo;
-        std::string mService;
-        bool mValid;
-
-        // Helper methods
-    public:
-};
-
-
-// other utility routines (not specific to service_runner)
-void interactive_ssh(const std::string & server_name, const std::string & command);
-void edit_server(const std::string & server_name);
-void edit_file(const std::string & file_path, const std::string & aftertext);
-
-// check if the service template and config are up to date on the remote server.
-class service_versions {
-    public:
-        service_versions(const std::string & server_name, const std::string & service_name);
-
-        bool remote_up_to_date() { return remote_template_is_up_to_date() && remote_config_is_up_to_date(); }
-
-        bool remote_template_is_up_to_date() { return get_version_remote_service_template() == calculate_version_local_service_template(); }
-        bool remote_config_is_up_to_date() { return get_version_remote_config() == calculate_version_local_config(); }    
-
-        XXH64_hash_t calculate_version_local_service_template();
-        XXH64_hash_t calculate_version_local_config();
-
-        void update_stored_remote_versions();
-        XXH64_hash_t get_version_remote_config();
-        XXH64_hash_t get_version_remote_service_template();
-
-    private:
-        XXH64_hash_t calculate_version_remote_service_template();
-        XXH64_hash_t calculate_version_remote_config();
-
-    private:
-        std::string m_server_name;
-        std::string m_service_name;
-};
-
-
-} // namespace dropshell
-
-#endif // SERVICE_RUNNER_HPP