.

.gitignore

@@ -1,7 +1,5 @@
 # Build directories
 build/
-build_amd64/
-build_arm64/
 cmake-build-*/
 out/
 bin/

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.10)
 project(dropshell VERSION 1.0.0 LANGUAGES CXX)
 
-set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 # Set default build type to Release if not specified
@@ -25,7 +25,7 @@ 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/autogen/version.hpp"
+    "${CMAKE_CURRENT_BINARY_DIR}/src/version.hpp"
     @ONLY
 )
 
@@ -36,33 +36,32 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 file(GLOB_RECURSE SOURCES "src/*.cpp")
 file(GLOB_RECURSE HEADERS "src/*.hpp")
 
-# Add custom target to run make_createagent.sh at the start of the build process
-add_custom_target(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 
-    $<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
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/src>
 )
 
+include(FetchContent)
+FetchContent_Declare(
+  libassert
+  GIT_REPOSITORY https://github.com/jeremy-rifkin/libassert.git
+  GIT_TAG        v2.1.5 # <HASH or TAG>
+)
+FetchContent_MakeAvailable(libassert)
+target_link_libraries(dropshell libassert::assert)
+
+# On windows copy libassert.dll to the same directory as the executable for your_target
 if(WIN32)
   add_custom_command(
     TARGET dropshell POST_BUILD
     COMMAND ${CMAKE_COMMAND} -E copy_if_different
+    $<TARGET_FILE:libassert::assert>
     $<TARGET_FILE_DIR:dropshell>
   )
 endif()

README.md

@@ -1,32 +1,3 @@
 # 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`

build.sh

@@ -9,11 +9,15 @@ GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 NC='\033[0m' # No Color
 
-JOBS=4
-# Determine number of CPU cores for parallel build
-if command -v nproc >/dev/null 2>&1; then
-    JOBS=$(nproc)
-fi
+# Parse command line arguments
+AUTO_INSTALL=false
+for arg in "$@"; do
+    case $arg in
+        --auto-install)
+            AUTO_INSTALL=true
+            ;;
+    esac
+done
 
 
 # Function to print status messages
@@ -29,9 +33,6 @@ 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..."
@@ -78,7 +79,7 @@ cmake .. -DCMAKE_BUILD_TYPE=Debug
 
 # Build the project
 print_status "Building project..."
-make -j"$JOBS"
+make -j$(nproc)
 
 # Check if build was successful
 if [ $? -eq 0 ]; then
@@ -89,16 +90,31 @@ else
     exit 1
 fi
 
-print_status "Auto-installing dropshell..."
-sudo make install
-if [ $? -eq 0 ]; then
+# Check if user wants to install
+if [ $AUTO_INSTALL = true ]; then
+    print_status "Auto-installing dropshell..."
+    sudo make install
+    if [ $? -eq 0 ]; then
         print_status "Installation successful!"
-else
+    else
         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 ..
 

docker/Dockerfile.build

@@ -0,0 +1,24 @@
+FROM debian:bullseye AS builder
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    cmake \
+    pkg-config \
+    bash \
+    gcc-aarch64-linux-gnu \
+    g++-aarch64-linux-gnu \
+    binutils-aarch64-linux-gnu \
+    qemu-user-static
+
+WORKDIR /app
+
+COPY . .
+
+COPY --chmod=755 docker/_create_dropshell.sh /scripts/
+
+RUN rm -rf build
+
+ENV CXXFLAGS="-static-libstdc++ -static-libgcc"
+ENV LDFLAGS="-static -pthread -Wl,--whole-archive -lpthread -Wl,--no-whole-archive"
+
+CMD ["/bin/bash","/scripts/_create_dropshell.sh"]

docker/_create_dropshell.sh

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

docker/build_builder.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+
+ROOT_DIR=$(dirname $SCRIPT_DIR)
+
+docker build -t gitea.jde.nz/j/dropshell_builder:latest $ROOT_DIR -f $SCRIPT_DIR/Dockerfile.build
+

docker/compile.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+
+ROOT_DIR=$(dirname $SCRIPT_DIR)
+
+echo "Building dropshell from $ROOT_DIR"
+
+# Build the builder image
+#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)
+
+# Build for x86_64
+echo "Building for x86_64..."
+docker run --rm -tt --env CHOWN_USER=$MYUID --env CHOWN_GROUP=$MYGID \
+    -v $SCRIPT_DIR/output:/output \
+    -e TARGET_ARCH=x86_64 \
+    -e CC=gcc \
+    -e CXX=g++ \
+    gitea.jde.nz/j/dropshell_builder:latest
+
+mv $SCRIPT_DIR/output/dropshell $SCRIPT_DIR/output/dropshell_x86_64
+
+$SCRIPT_DIR/output/dropshell_x86_64 version
+
+echo "dropshell built in $SCRIPT_DIR/output/dropshell_x86_64"
+
+
+# Build for arm64
+echo "Building for arm64..."
+docker run --rm -tt --env CHOWN_USER=$MYUID --env CHOWN_GROUP=$MYGID \
+    -v $SCRIPT_DIR/output:/output \
+    -e TARGET_ARCH=aarch64 \
+    -e CC=aarch64-linux-gnu-gcc \
+    -e CXX=aarch64-linux-gnu-g++ \
+    gitea.jde.nz/j/dropshell_builder:latest
+
+mv $SCRIPT_DIR/output/dropshell $SCRIPT_DIR/output/dropshell_aarch64
+
+
+echo "dropshell built in $SCRIPT_DIR/output/dropshell_aarch64"
+

docker/publish_builder.sh

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

docker/publish_dropshell.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+

install.sh

@@ -1,50 +0,0 @@
-#!/bin/bash
-set -e
-
-# download and install dropshell
-
-# Check if running as root
-if [ "$EUID" -ne 0 ]; then
-    echo "Please run this script as root (use sudo)"
-    exit 1
-fi
-
-# 1. Determine architecture
-# ----------------------------------------------------------------------------- 
-
-ARCH=$(uname -m)
-if [[ "$ARCH" == "x86_64" ]]; then
-    BIN=dropshell.amd64
-elif [[ "$ARCH" == "aarch64" || "$ARCH" == "arm64" ]]; then
-    BIN=dropshell.arm64
-else
-    echo "Unsupported architecture: $ARCH" >&2
-    exit 1
-fi
-
-
-# 2. Download the appropriate binary to a temp directory
-# -----------------------------------------------------------------------------
-TMPDIR=$(mktemp -d)
-trap 'rm -rf "$TMPDIR"' EXIT
-URL="https://gitea.jde.nz/public/dropshell/releases/download/latest/$BIN"
-echo "Downloading $BIN from $URL..."
-
-curl -fsSL -o "$TMPDIR/dropshell" "$URL"
-
-if [ ! -f "$TMPDIR/dropshell" ]; then
-    echo "Failed to download dropshell" >&2
-    exit 1
-fi
-
-chmod +x "$TMPDIR/dropshell"
-
-cp "$TMPDIR/dropshell" /usr/local/bin/dropshell
-if [ -f /usr/local/bin/ds ]; then
-    rm -f /usr/local/bin/ds
-fi
-ln -s /usr/local/bin/dropshell /usr/local/bin/ds
-rm -rf "$TMPDIR"
-
-echo "dropshell installed successfully to /usr/local/bin/dropshell"
-

install_build_prerequisites.sh

@@ -0,0 +1,86 @@
+#!/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
+
+print_status "All dependencies installed successfully!"
+print_status "You can now run ./build.sh to build the project" 

remote_host_autosetup/host_autosetup.sh

@@ -90,6 +90,17 @@ chsh -s /bin/bash dropshell
 
 #--------------------------------
 
+# download dropshell
+
+# determine if x86_64 or arm64
+ARCH=$(uname -m)
+
+# check is aarch64 or x86_64 and error if neither
+if [ "$ARCH" != "aarch64" ] && [ "$ARCH" != "x86_64" ]; then
+    echo "Unsupported architecture: $ARCH"
+    exit 1
+fi
+
 echo "Installation complete."
 
 #--------------------------------

source/agent/selftest.sh

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

source/install_build_prerequisites.sh

@@ -1,150 +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"
-        ;;
-    *)
-        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

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

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

source/publish.sh

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

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

@@ -1,443 +0,0 @@
-#include <fstream>
-#include <filesystem>
-#include <string>
-#include <iostream>
-#include <cstring>
-
-/*
-
-   THIS FILE IS AUTO-GENERATED BY DEHYDRATE.
-   DO NOT EDIT THIS FILE.
-
-*/
-
-
-#include "_agent.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"\
-            "ICAgICAgcmVzdG9yZSkKICAgICAgICAgICAgZWNobyAiUmVzdG9yaW5nIHBhdGggJHtwYXRofSIK"\
-            "ICAgICAgICAgICAgdGFyIC14enZmICR7YmFja3VwX2ZvbGRlcn0vYmFja3VwLnRneiAtQyAke3Bh"\
-            "dGh9IC0tc3RyaXAtY29tcG9uZW50cz0xCiAgICAgICAgICAgIDs7CiAgICBlc2FjCn0KCl9hdXRv"\
-            "Y29tbWFuZHJ1bl9maWxlKCkgewogICAgbG9jYWwgY29tbWFuZD0iJDEiCiAgICBsb2NhbCBmaWxl"\
-            "cGF0aD0iJDIiCiAgICBsb2NhbCBiYWNrdXBfZm9sZGVyPSIkMyIKCiAgICBjYXNlICIkY29tbWFu"\
-            "ZCIgaW4KICAgICAgICBjcmVhdGUpCiAgICAgICAgICAgIDs7CiAgICAgICAgbnVrZSkKICAgICAg"\
-            "ICAgICAgcm0gLWYgJHtmaWxlcGF0aH0KICAgICAgICAgICAgOzsKICAgICAgICBiYWNrdXApCiAg"\
-            "ICAgICAgICAgIGVjaG8gIkJhY2tpbmcgdXAgZmlsZSAke2ZpbGVwYXRofSIKICAgICAgICAgICAg"\
-            "bG9jYWwgZmlsZV9wYXJlbnQ9JChkaXJuYW1lICR7ZmlsZXBhdGh9KQogICAgICAgICAgICBsb2Nh"\
-            "bCBmaWxlX25hbWU9JChiYXNlbmFtZSAke2ZpbGVwYXRofSkKICAgICAgICAgICAgaWYgWyAtZiAi"\
-            "JHtmaWxlX3BhcmVudH0vJHtmaWxlX25hbWV9IiBdOyB0aGVuCiAgICAgICAgICAgICAgICBkb2Nr"\
-            "ZXIgcnVuIC0tcm0gLXYgJHtmaWxlX3BhcmVudH06L3ZvbHVtZSAtdiAke2JhY2t1cF9mb2xkZXJ9"\
-            "Oi9iYWNrdXAgZGViaWFuIGJhc2ggLWMgImNwIC92b2x1bWUvJHtmaWxlX25hbWV9IC9iYWNrdXAv"\
-            "JHtmaWxlX25hbWV9ICYmIGNob3duIC1SICRNWUlEOiRNWUdSUCAvYmFja3VwIgogICAgICAgICAg"\
-            "ICBlbHNlCiAgICAgICAgICAgICAgICBlY2hvICJGaWxlICR7ZmlsZXBhdGh9IGRvZXMgbm90IGV4"\
-            "aXN0IC0gbm90aGluZyB0byBiYWNrdXAiCiAgICAgICAgICAgIGZpCiAgICAgICAgICAgIDs7CiAg"\
-            "ICAgICAgcmVzdG9yZSkKICAgICAgICAgICAgZWNobyAiUmVzdG9yaW5nIGZpbGUgJHtmaWxlcGF0"\
-            "aH0iCiAgICAgICAgICAgIGxvY2FsIGZpbGVfbmFtZT0kKGJhc2VuYW1lICR7ZmlsZXBhdGh9KQog"\
-            "ICAgICAgICAgICBjcCAke2JhY2t1cF9mb2xkZXJ9LyR7ZmlsZV9uYW1lfSAke2ZpbGVwYXRofQog"\
-            "ICAgICAgICAgICA7OwogICAgZXNhYwp9CgpfYXV0b2NvbW1hbmRwYXJzZSgpIHsKICAgICMgZmly"\
-            "c3QgYXJndW1lbnQgaXMgdGhlIGNvbW1hbmQKICAgICMgaWYgdGhlIGNvbW1hbmQgaXMgYmFja3Vw"\
-            "IG9yIHJlc3RvcmUsIHRoZW4gdGhlIGxhc3QgdHdvIGFyZ3VtZW50cyBhcmUgdGhlIGJhY2t1cCBm"\
-            "aWxlIGFuZCB0aGUgdGVtcG9yYXJ5IHBhdGgKICAgICMgYWxsIG90aGVyIGFyZ3VtZW50cyBhcmUg"\
-            "b2YgZm9ybToKICAgICMga2V5PXZhbHVlCiAgICAjIHdoZXJlIGtleSBjYW4gYmUgb25lIG9mIHZv"\
-            "bHVtZSwgcGF0aCBvciBmaWxlLgogICAgIyB2YWx1ZSBpcyB0aGUgcGF0aCBvciB2b2x1bWUgbmFt"\
-            "ZS4KCiAgICAjIHdlIGl0ZXJhdGUgb3ZlciB0aGUga2V5PXZhbHVlIGFyZ3VtZW50cywgYW5kIGZv"\
-            "ciBlYWNoIHdlIGNhbGw6CiAgICAjICAgIGF1dG9ydW4gPGNvbW1hbmQ+IDxiYWNrdXBmaWxlPiA8"\
-            "a2V5PiA8dmFsdWU+CgogICAgbG9jYWwgY29tbWFuZD0iJDEiCiAgICBzaGlmdAoKICAgIGxvY2Fs"\
-            "IGJhY2t1cF90ZW1wX3BhdGg9IiQxIgogICAgc2hpZnQKCiAgICBlY2hvICJhdXRvY29tbWFuZHBh"\
-            "cnNlOiBjb21tYW5kPSRjb21tYW5kIGJhY2t1cF90ZW1wX3BhdGg9JGJhY2t1cF90ZW1wX3BhdGgi"\
-            "CgogICAgIyBFeHRyYWN0IHRoZSBiYWNrdXAgZmlsZSBhbmQgdGVtcCBwYXRoIChsYXN0IHR3byBh"\
-            "cmd1bWVudHMpCiAgICBsb2NhbCBhcmdzPSgiJEAiKQogICAgbG9jYWwgYXJnX2NvdW50PSR7I2Fy"\
-            "Z3NbQF19CiAgICAKICAgICMgUHJvY2VzcyBhbGwga2V5PXZhbHVlIHBhaXJzCiAgICBmb3IgKChp"\
-            "PTA7IGk8JGFyZ19jb3VudDsgaSsrKSk7IGRvCiAgICAgICAgbG9jYWwgcGFpcj0iJHthcmdzWyRp"\
-            "XX0iCiAgICAgICAgCiAgICAgICAgIyBTa2lwIGlmIG5vdCBpbiBrZXk9dmFsdWUgZm9ybWF0CiAg"\
-            "ICAgICAgaWYgW1sgIiRwYWlyIiAhPSAqIj0iKiBdXTsgdGhlbgogICAgICAgICAgICBjb250aW51"\
-            "ZQogICAgICAgIGZpCiAgICAgICAgCiAgICAgICAgbG9jYWwga2V5PSIke3BhaXIlJT0qfSIKICAg"\
-            "ICAgICBsb2NhbCB2YWx1ZT0iJHtwYWlyIyo9fSIKCiAgICAgICAgIyBjcmVhdGUgYmFja3VwIGZv"\
-            "bGRlciB1bmlxdWUgdG8ga2V5L3ZhbHVlLgogICAgICAgIGxvY2FsIGJmb2xkZXI9JChlY2hvICIk"\
-            "e2tleX1fJHt2YWx1ZX0iIHwgdHIgLWNkICdbOmFsbnVtOl1fLScpCiAgICAgICAgbG9jYWwgdGFy"\
-            "Z2V0cGF0aD0iJHtiYWNrdXBfdGVtcF9wYXRofS8ke2Jmb2xkZXJ9IgogICAgICAgIG1rZGlyIC1w"\
-            "ICR7dGFyZ2V0cGF0aH0KCiAgICAgICAgIyBLZXkgbXVzdCBiZSBvbmUgb2Ygdm9sdW1lLCBwYXRo"\
-            "IG9yIGZpbGUKICAgICAgICBjYXNlICIka2V5IiBpbgogICAgICAgICAgICB2b2x1bWUpCiAgICAg"\
-            "ICAgICAgICAgICBfYXV0b2NvbW1hbmRydW5fdm9sdW1lICIkY29tbWFuZCIgIiR2YWx1ZSIgIiR0"\
-            "YXJnZXRwYXRoIgogICAgICAgICAgICAgICAgOzsKICAgICAgICAgICAgcGF0aCkKICAgICAgICAg"\
-            "ICAgICAgIF9hdXRvY29tbWFuZHJ1bl9wYXRoICIkY29tbWFuZCIgIiR2YWx1ZSIgIiR0YXJnZXRw"\
-            "YXRoIgogICAgICAgICAgICAgICAgOzsKICAgICAgICAgICAgZmlsZSkKICAgICAgICAgICAgICAg"\
-            "IF9hdXRvY29tbWFuZHJ1bl9maWxlICIkY29tbWFuZCIgIiR2YWx1ZSIgIiR0YXJnZXRwYXRoIgog"\
-            "ICAgICAgICAgICAgICAgOzsKICAgICAgICAgICAgKikKICAgICAgICAgICAgICAgIF9kaWUgIlVu"\
-            "a25vd24ga2V5ICRrZXkgcGFzc2VkIHRvIGF1dG8ke2NvbW1hbmR9LiBXZSBvbmx5IHN1cHBvcnQg"\
-            "dm9sdW1lLCBwYXRoIGFuZCBmaWxlLiIKICAgICAgICAgICAgICAgIDs7CiAgICAgICAgZXNhYwog"\
-            "ICAgZG9uZQp9CgoKZGF0YWNyZWF0ZSgpIHsKICAgIF9hdXRvY29tbWFuZHBhcnNlIGNyZWF0ZSBu"\
-            "b25lICIkQCIKfQoKCmRhdGFudWtlKCkgewogICAgX2F1dG9jb21tYW5kcGFyc2UgbnVrZSBub25l"\
-            "ICIkQCIKfQoKZGF0YWJhY2t1cCgpIHsKICAgIF9jaGVja19yZXF1aXJlZF9lbnZfdmFycyAiQkFD"\
-            "S1VQX0ZJTEUiICJURU1QX0RJUiIKICAgIEJBQ0tVUF9URU1QX1BBVEg9IiRURU1QX0RJUi9iYWNr"\
-            "dXAiCgoKICAgIG1rZGlyIC1wICIkQkFDS1VQX1RFTVBfUEFUSCIKICAgIGVjaG8gIl9hdXRvY29t"\
-            "bWFuZHBhcnNlIFtiYWNrdXBdIFskQkFDS1VQX1RFTVBfUEFUSF0gWyRAXSIKICAgIF9hdXRvY29t"\
-            "bWFuZHBhcnNlIGJhY2t1cCAiJEJBQ0tVUF9URU1QX1BBVEgiICIkQCIKCiAgICB0YXIgemN2ZiAi"\
-            "JEJBQ0tVUF9GSUxFIiAtQyAiJEJBQ0tVUF9URU1QX1BBVEgiIC4KfQoKZGF0YXJlc3RvcmUoKSB7"\
-            "CiAgICBfY2hlY2tfcmVxdWlyZWRfZW52X3ZhcnMgIkJBQ0tVUF9GSUxFIiAiVEVNUF9ESVIiCiAg"\
-            "ICBCQUNLVVBfVEVNUF9QQVRIPSIkVEVNUF9ESVIvcmVzdG9yZSIKCiAgICBlY2hvICJfYXV0b2Nv"\
-            "bW1hbmRwYXJzZSBbcmVzdG9yZV0gWyRCQUNLVVBfVEVNUF9QQVRIXSBbJEBdIgoKICAgIG1rZGly"\
-            "IC1wICIkQkFDS1VQX1RFTVBfUEFUSCIKICAgIHRhciB6eHZmICIkQkFDS1VQX0ZJTEUiIC1DICIk"\
-            "QkFDS1VQX1RFTVBfUEFUSCIgLS1zdHJpcC1jb21wb25lbnRzPTEKCiAgICBfYXV0b2NvbW1hbmRw"\
-            "YXJzZSByZXN0b3JlICIkQkFDS1VQX1RFTVBfUEFUSCIgIiRAIgp9Cg==";
-
-        // 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, 6443138635497166205ULL, 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"\
-            "CiAgICAgICAgU0VSVklDRT0iJHtTRVJWSUNFX05BTUV9IgoKICAgICAgICBzZXQgK2EKCiAgICAg"\
-            "ICAgX2NoZWNrX3JlcXVpcmVkX2Vudl92YXJzX2FsbHNlcnZpY2Vzc3RhdHVzICJDT05GSUdfUEFU"\
-            "SCIgIlNFUlZFUiIgIlNFUlZJQ0UiICJBR0VOVF9QQVRIIiAiSE9TVF9OQU1FIiAiVEVNUExBVEUi"\
-            "CgogICAgICAgIGlmIFsgIiRjYXB0dXJlX291dHB1dCIgPSAidHJ1ZSIgXTsgdGhlbgogICAgICAg"\
-            "ICAgICAjIENhcHR1cmUgYW5kIHJldHVybiBvdXRwdXQKICAgICAgICAgICAgYmFzaCAiJHtzZXJ2"\
-            "aWNlX3BhdGh9L3RlbXBsYXRlLyR7Y29tbWFuZH0uc2giIDI+JjEKICAgICAgICBlbHNlCiAgICAg"\
-            "ICAgICAgICMgUnVuIHNpbGVudGx5IGFuZCByZXR1cm4gZXhpdCBjb2RlCiAgICAgICAgICAgIGJh"\
-            "c2ggIiR7c2VydmljZV9wYXRofS90ZW1wbGF0ZS8ke2NvbW1hbmR9LnNoIiA+IC9kZXYvbnVsbCAy"\
-            "PiYxCiAgICAgICAgZmkKICAgICkKICAgIENVUlJFTlRfRVhJVF9DT0RFPSQ/Cn0KCmZ1bmN0aW9u"\
-            "IGNvbW1hbmRfZXhpc3RzKCkgewogICAgbG9jYWwgc2VydmljZV9wYXRoPSQxCiAgICBsb2NhbCBj"\
-            "b21tYW5kPSQyCiAgICBpZiBbICEgLWYgIiR7c2VydmljZV9wYXRofS90ZW1wbGF0ZS8ke2NvbW1h"\
-            "bmR9LnNoIiBdOyB0aGVuCiAgICAgICAgcmV0dXJuIDEKICAgIGZpCiAgICByZXR1cm4gMAp9CgoK"\
-            "CiMgR2V0IGFsbCBzZXJ2aWNlIG5hbWVzClNFUlZJQ0VfTkFNRVM9JChscyAiJHtTRVJWSUNFU19Q"\
-            "QVRIfSIpCgojIEl0ZXJhdGUgb3ZlciBhbGwgc2VydmljZSBuYW1lcwpmb3IgU0VSVklDRV9OQU1F"\
-            "IGluICR7U0VSVklDRV9OQU1FU307IGRvCgogICAgU0VSVklDRV9QQVRIPSQocmVhbHBhdGggIiR7"\
-            "U0VSVklDRVNfUEFUSH0vJHtTRVJWSUNFX05BTUV9IikKCiAgICAjLS0tLS0tLS0tLS0tLS0tLS0t"\
-            "LS0tLS0tLS0tLS0tLS0KICAgICMgR2V0IHRoZSBzZXJ2aWNlIGhlYWx0aAogICAgaWYgISBjb21t"\
-            "YW5kX2V4aXN0cyAiJHtTRVJWSUNFX1BBVEh9IiAic3RhdHVzIjsgdGhlbgogICAgICAgIFNFUlZJ"\
-            "Q0VfSEVBTFRIPSJ1bmtub3duIgogICAgZWxzZQogICAgICAgIHJ1bl9jb21tYW5kICIke1NFUlZJ"\
-            "Q0VfUEFUSH0iICJzdGF0dXMiICJmYWxzZSIKICAgICAgICBpZiBbICIke0NVUlJFTlRfRVhJVF9D"\
-            "T0RFfSIgLWVxIDAgXTsgdGhlbgogICAgICAgICAgICBTRVJWSUNFX0hFQUxUSD0iaGVhbHRoeSIK"\
-            "ICAgICAgICBlbHNlCiAgICAgICAgICAgIFNFUlZJQ0VfSEVBTFRIPSJ1bmhlYWx0aHkiCiAgICAg"\
-            "ICAgZmkKICAgIGZpCgogICAgIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgICAj"\
-            "IEdldCB0aGUgc2VydmljZSBwb3J0cwogICAgaWYgISBjb21tYW5kX2V4aXN0cyAiJHtTRVJWSUNF"\
-            "X1BBVEh9IiAicG9ydHMiOyB0aGVuCiAgICAgICAgU0VSVklDRV9QT1JUUz0iIgogICAgZWxzZQog"\
-            "ICAgICAgIHJ1bl9jb21tYW5kICIke1NFUlZJQ0VfUEFUSH0iICJwb3J0cyIgInRydWUiCiAgICAg"\
-            "ICAgU0VSVklDRV9QT1JUUz0iJHtDVVJSRU5UX09VVFBVVH0iCiAgICBmaQoKICAgICMtLS0tLS0t"\
-            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogICAgIyByZXR1cm4gdGhlIGhlYWx0aCBhbmQgcG9y"\
-            "dHMKICAgIGVjaG8gIiR7U0VSVklDRV9OQU1FfV9IRUFMVEg9JHtTRVJWSUNFX0hFQUxUSH0iCiAg"\
-            "ICBlY2hvICIke1NFUlZJQ0VfTkFNRX1fUE9SVFM9JHtTRVJWSUNFX1BPUlRTfSIKZG9uZQo=";
-
-        // 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, 4383289270743338040ULL, 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"\
-            "KCkgewogICAgZWNobyAtZSAiXDAzM1s5MW1FcnJvcjogJDFcMDMzWzBtIgogICAgZXhpdCAxCn0K"\
-            "CiMgU3dpdGNoZXMgdGVybWluYWwgb3V0cHV0IGNvbG9yIHRvIGdyZXkuCl9ncmV5X3N0YXJ0KCkg"\
-            "ewogICAgZWNobyAtZSAtbiAiXDAzM1s5MG0iCn0KCiMgUmVzZXRzIHRlcm1pbmFsIG91dHB1dCBj"\
-            "b2xvciBmcm9tIGdyZXkuCl9ncmV5X2VuZCgpIHsKICAgIGVjaG8gLWUgLW4gIlwwMzNbMG0iCn0K"\
-            "CiMgQ3JlYXRlcy9zdGFydHMgYSBjb250YWluZXIsIHZlcmlmeWluZyBpdCBydW5zLgpfY3JlYXRl"\
-            "X2FuZF9zdGFydF9jb250YWluZXIoKSB7CiAgICBpZiBbIC16ICIkMSIgXSB8fCBbIC16ICIkMiIg"\
-            "XTsgdGhlbgogICAgICAgIF9kaWUgIlRlbXBsYXRlIGVycm9yOiBjcmVhdGVfYW5kX3N0YXJ0X2Nv"\
-            "bnRhaW5lciA8cnVuX2NtZD4gPGNvbnRhaW5lcl9uYW1lPiIKICAgIGZpCgogICAgbG9jYWwgcnVu"\
-            "X2NtZD0iJDEiCiAgICBsb2NhbCBjb250YWluZXJfbmFtZT0iJDIiCgogICAgaWYgX2lzX2NvbnRh"\
-            "aW5lcl9leGlzdHMgJGNvbnRhaW5lcl9uYW1lOyB0aGVuCiAgICAgICAgX2lzX2NvbnRhaW5lcl9y"\
-            "dW5uaW5nICRjb250YWluZXJfbmFtZSAmJiByZXR1cm4gMAogICAgICAgIF9zdGFydF9jb250YWlu"\
-            "ZXIgJGNvbnRhaW5lcl9uYW1lCiAgICBlbHNlCiAgICAgICAgX2dyZXlfc3RhcnQKICAgICAgICAk"\
-            "cnVuX2NtZAogICAgICAgIF9ncmV5X2VuZAogICAgZmkKCiAgICBpZiAhIF9pc19jb250YWluZXJf"\
-            "cnVubmluZyAkY29udGFpbmVyX25hbWU7IHRoZW4KICAgICAgICBfZGllICJDb250YWluZXIgJHtj"\
-            "b250YWluZXJfbmFtZX0gZmFpbGVkIHRvIHN0YXJ0IgogICAgZmkKCiAgICBJRD0kKF9nZXRfY29u"\
-            "dGFpbmVyX2lkICRjb250YWluZXJfbmFtZSkKICAgIGVjaG8gIkNvbnRhaW5lciAke2NvbnRhaW5l"\
-            "cl9uYW1lfSBpcyBydW5uaW5nIHdpdGggSUQgJHtJRH0iCn0KCiMgQ3JlYXRlcyBhIGRpcmVjdG9y"\
-            "eSBpZiBpdCBkb2Vzbid0IGV4aXN0IChjaG1vZCA3NzcpLgpfY3JlYXRlX2ZvbGRlcigpIHsKICAg"\
-            "IGxvY2FsIGZvbGRlcj0iJDEiCiAgICBpZiBbIC1kICIkZm9sZGVyIiBdOyB0aGVuCiAgICAgICAg"\
-            "cmV0dXJuIDAKICAgIGZpCiAgICBpZiAhIG1rZGlyIC1wICIkZm9sZGVyIjsgdGhlbgogICAgICAg"\
-            "IF9kaWUgIkZhaWxlZCB0byBjcmVhdGUgZm9sZGVyOiAkZm9sZGVyIgogICAgZmkKICAgIGNobW9k"\
-            "IDc3NyAiJGZvbGRlciIKICAgIGVjaG8gIkZvbGRlciBjcmVhdGVkOiAkZm9sZGVyIgp9CgojIENo"\
-            "ZWNrcyBpZiBEb2NrZXIgaXMgaW5zdGFsbGVkLCBydW5uaW5nLCBhbmQgdXNlciBoYXMgcGVybWlz"\
-            "c2lvbi4gUmV0dXJucyAxIG9uIGZhaWx1cmUuCl9jaGVja19kb2NrZXJfaW5zdGFsbGVkKCkgewog"\
-            "ICAgaWYgISBjb21tYW5kIC12IGRvY2tlciAmPiAvZGV2L251bGw7IHRoZW4KICAgICAgICBlY2hv"\
-            "ICJEb2NrZXIgaXMgbm90IGluc3RhbGxlZCIKICAgICAgICByZXR1cm4gMQogICAgZmkKCiAgICAj"\
-            "IGNoZWNrIGlmIGRvY2tlciBkYWVtb24gaXMgcnVubmluZwogICAgaWYgISBkb2NrZXIgaW5mbyAm"\
-            "PiAvZGV2L251bGw7IHRoZW4KICAgICAgICBlY2hvICJEb2NrZXIgZGFlbW9uIGlzIG5vdCBydW5u"\
-            "aW5nIgogICAgICAgIHJldHVybiAxCiAgICBmaQoKICAgICMgY2hlY2sgaWYgdXNlciBoYXMgcGVy"\
-            "bWlzc2lvbiB0byBydW4gZG9ja2VyCiAgICBpZiAhIGRvY2tlciBydW4gLS1ybSBoZWxsby13b3Js"\
-            "ZCAmPiAvZGV2L251bGw7IHRoZW4KICAgICAgICBlY2hvICJVc2VyIGRvZXMgbm90IGhhdmUgcGVy"\
-            "bWlzc2lvbiB0byBydW4gZG9ja2VyIgogICAgICAgIHJldHVybiAxCiAgICBmaQoKICAgIHJldHVy"\
-            "biAwCn0KCiMgQ2hlY2tzIGlmIGEgY29udGFpbmVyIChhbnkgc3RhdGUpIGV4aXN0cy4gUmV0dXJu"\
-            "cyAxIGlmIG5vdCBmb3VuZC4KX2lzX2NvbnRhaW5lcl9leGlzdHMoKSB7CiAgICBpZiAhIGRvY2tl"\
-            "ciBwcyAtYSAtLWZvcm1hdCAie3suTmFtZXN9fSIgfCBncmVwIC1xICJeJDEkIjsgdGhlbgogICAg"\
-            "ICAgIHJldHVybiAxCiAgICBmaQogICAgcmV0dXJuIDAKfQoKIyBDaGVja3MgaWYgYSBjb250YWlu"\
-            "ZXIgaXMgY3VycmVudGx5IHJ1bm5pbmcuIFJldHVybnMgMSBpZiBub3QgcnVubmluZy4KX2lzX2Nv"\
-            "bnRhaW5lcl9ydW5uaW5nKCkgewogICAgaWYgISBkb2NrZXIgcHMgLS1mb3JtYXQgInt7Lk5hbWVz"\
-            "fX0iIHwgZ3JlcCAtcSAiXiQxJCI7IHRoZW4KICAgICAgICByZXR1cm4gMQogICAgZmkKICAgIHJl"\
-            "dHVybiAwCn0KCiMgUHJpbnRzIHRoZSBJRCBvZiB0aGUgbmFtZWQgY29udGFpbmVyLgpfZ2V0X2Nv"\
-            "bnRhaW5lcl9pZCgpIHsKICAgIGRvY2tlciBwcyAtLWZvcm1hdCAie3suSUR9fSIgLS1maWx0ZXIg"\
-            "Im5hbWU9JDEiCn0KCiMgUHJpbnRzIHRoZSBzdGF0dXMgc3RyaW5nIG9mIHRoZSBuYW1lZCBjb250"\
-            "YWluZXIuCl9nZXRfY29udGFpbmVyX3N0YXR1cygpIHsKICAgIGRvY2tlciBwcyAtLWZvcm1hdCAi"\
-            "e3suU3RhdHVzfX0iIC0tZmlsdGVyICJuYW1lPSQxIgp9CgojIFN0YXJ0cyBhbiBleGlzdGluZywg"\
-            "c3RvcHBlZCBjb250YWluZXIuCl9zdGFydF9jb250YWluZXIoKSB7CiAgICBfaXNfY29udGFpbmVy"\
-            "X2V4aXN0cyAkMSB8fCByZXR1cm4gMQogICAgX2lzX2NvbnRhaW5lcl9ydW5uaW5nICQxICYmIHJl"\
-            "dHVybiAwCiAgICBkb2NrZXIgc3RhcnQgJDEKfQoKIyBTdG9wcyBhIHJ1bm5pbmcgY29udGFpbmVy"\
-            "Lgpfc3RvcF9jb250YWluZXIoKSB7CiAgICBfaXNfY29udGFpbmVyX3J1bm5pbmcgJDEgfHwgcmV0"\
-            "dXJuIDA7CiAgICBkb2NrZXIgc3RvcCAkMQp9ICAgCgojIFN0b3BzIChpZiBuZWVkZWQpIGFuZCBy"\
-            "ZW1vdmVzIGEgY29udGFpbmVyLgpfcmVtb3ZlX2NvbnRhaW5lcigpIHsKICAgIF9zdG9wX2NvbnRh"\
-            "aW5lciAkMQogICAgX2lzX2NvbnRhaW5lcl9leGlzdHMgJDEgfHwgcmV0dXJuIDA7CiAgICBkb2Nr"\
-            "ZXIgcm0gJDEKfQoKIyBQcmludHMgdGhlIGxvZ3MgZm9yIGEgY29udGFpbmVyLgpfZ2V0X2NvbnRh"\
-            "aW5lcl9sb2dzKCkgewogICAgaWYgISBfaXNfY29udGFpbmVyX2V4aXN0cyAkMTsgdGhlbgogICAg"\
-            "ICAgIGVjaG8gIkNvbnRhaW5lciAkMSBkb2VzIG5vdCBleGlzdCIKICAgICAgICByZXR1cm4gMQog"\
-            "ICAgZmkKCiAgICBkb2NrZXIgbG9ncyAkMQp9CgojIENoZWNrcyBpZiBsaXN0ZWQgZW52aXJvbm1l"\
-            "bnQgdmFyaWFibGVzIGFyZSBzZXQ7IGNhbGxzIF9kaWUoKSBpZiBhbnkgYXJlIG1pc3NpbmcuCl9j"\
-            "aGVja19yZXF1aXJlZF9lbnZfdmFycygpIHsKICAgIGxvY2FsIHJlcXVpcmVkX3ZhcnM9KCIkQCIp"\
-            "CiAgICBmb3IgdmFyIGluICIke3JlcXVpcmVkX3ZhcnNbQF19IjsgZG8KICAgICAgICBpZiBbIC16"\
-            "ICIkeyF2YXJ9IiBdOyB0aGVuCiAgICAgICAgICAgIF9kaWUgIlJlcXVpcmVkIGVudmlyb25tZW50"\
-            "IHZhcmlhYmxlICR2YXIgaXMgbm90IHNldCIKICAgICAgICBmaQogICAgZG9uZQp9CgojIFJlbW92"\
-            "ZXMgYSBwYXRoIHVzaW5nIGEgcm9vdCBEb2NrZXIgY29udGFpbmVyIChmb3IgcGVybWlzc2lvbnMp"\
-            "Lgpfcm9vdF9yZW1vdmVfdHJlZSgpIHsKICAgIGxvY2FsIHRvX3JlbW92ZT0iJDEiCiAgICBwYXJl"\
-            "bnQ9JChkaXJuYW1lICIkdG9fcmVtb3ZlIikKICAgIGFic19wYXJlbnQ9JChyZWFscGF0aCAiJHBh"\
-            "cmVudCIpCiAgICBjaGlsZD0kKGJhc2VuYW1lICIkdG9fcmVtb3ZlIikKICAgIGRvY2tlciBydW4g"\
-            "LS1ybSAtdiAiJGFic19wYXJlbnQiOi9kYXRhIGFscGluZSBybSAtcmYgIi9kYXRhLyRjaGlsZCIK"\
-            "fQoKCiMgTG9hZCBhdXRvY29tbWFuZHMKc291cmNlICIke0FHRU5UX1BBVEh9L2RhdGFjb21tYW5k"\
-            "cy5zaCI=";
-
-        // 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, 15958097326741776083ULL, 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

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

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

source/src/commands/command_registry.cpp

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

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

@@ -1,133 +0,0 @@
-#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);
-    bool create_service(const std::string &server_name, const std::string &template_name, const std::string &service_name, bool silent);
-    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 create_service(server, template_name, service, false) ? 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)
-                    std::cout << template_name << std::endl;
-            }
-        }
-    }
-
-    bool create_service(const std::string &server_name, const std::string &template_name, const std::string &service_name, bool silent)
-    {
-        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())
-        {
-            if (!silent)
-            {
-                std::cerr << "Error: Couldn't locate server " << server_name << " in any config directory" << std::endl;
-                std::cerr << "Please check the server name is correct and try again" << std::endl;
-                std::cerr << "You can list all servers with 'dropshell servers'" << std::endl;
-                std::cerr << "You can create a new server with 'dropshell create-server " << server_name << "'" << std::endl;
-            }
-            return false;
-        }
-
-        if (std::filesystem::exists(service_dir))
-        {
-            if (!silent)
-            {
-                std::cerr << "Error: Service already exists: " << service_name << std::endl;
-                std::cerr << "Current service path: " << service_dir << std::endl;
-            }
-            return false;
-        }
-
-        template_info tinfo = gTemplateManager().get_template_info(template_name);
-        if (!tinfo.is_set())
-        {
-            if (!silent)
-            {
-                std::cerr << "Error: Template '" << template_name << "' not found" << std::endl;
-                std::cerr << "Please check the template name is correct and try again" << std::endl;
-                std::cerr << "You can list all templates with 'dropshell templates'" << std::endl;
-                std::cerr << "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()))
-        {
-            if (!silent)
-                std::cerr << "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);
-
-        if (!silent)
-        {
-            std::cout << "Service " << service_name << " created successfully" << std::endl;
-            std::cout << std::endl;
-            std::cout << "To complete the installation, please:" << std::endl;
-            std::cout << "1. edit the service config file:  dropshell edit " << server_name << " " << service_name << std::endl;
-            std::cout << "2. install the remote service:    dropshell install " << server_name << " " << service_name << std::endl;
-        }
-        return true;
-    }
-
-} // namespace dropshell

source/src/commands/edit.cpp

@@ -1,177 +0,0 @@
-#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 {
-        std::cerr << "Error: Standard input is not a terminal and EDITOR environment variable is not set." << std::endl;
-        std::cerr << "Try setting the EDITOR environment variable (e.g., export EDITOR=nano) or run in an interactive terminal." << std::endl;
-        std::cerr << "You can manually edit the file at: " << file_path << std::endl;
-        return false;
-    }
-
-    std::cout << "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)) {
-        std::cerr << "Error: Failed to edit server config" << std::endl;
-        std::cerr << "You can manually edit this file at: " << config_file << std::endl;
-        return 1;
-    }
-
-    std::cout << "If you have changed DROPSHELL_DIR, you should manually move the files to the new location NOW." << std::endl
-              << "You can ssh in to the remote server with:  dropshell ssh "<<server_name<< std::endl
-              << "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))
-    {
-        std::cerr << "Error: Service config file not found: " << config_file << std::endl;
-        return 1;
-    }
-
-    if (edit_file(config_file, true) && std::filesystem::exists(config_file))
-        std::cout << "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;
-    }
-
-    std::cout << "Edit handler called with " << ctx.args.size() << " args\n";
-    return -1;
-}
-
-
-
-
-} // namespace dropshell

source/src/commands/health.cpp

@@ -1,73 +0,0 @@
-#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)
-        {
-            std::cerr << "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

@@ -1,188 +0,0 @@
-#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)) {
-            std::cout << cmd << std::endl;
-        }
-    }
-    return;
-}
-
-void show_command(const std::string& cmd) { 
-    const auto& cmd_info = CommandRegistry::instance().find_command(cmd); 
-    if (!cmd_info) 
-    {
-        std::cout << "Unknown command: " << cmd << std::endl;
-        return;
-    }
-
-    std::cout << "  ";
-    print_left_aligned(cmd_info->help_usage, 30);
-    std::cout << 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) 
-    {
-        std::cout << "Unknown command: " << cmd << std::endl;
-        return 1;
-    }
-
-    std::cout << std::endl;
-    std::cout << "Usage: " << std::endl;
-    std::cout << "  ";
-    print_left_aligned(cmd_info->help_usage, 30);
-    std::cout << cmd_info->help_description << std::endl;
-
-    std::cout << std::endl;
-
-    std::cout << "  Equivalent names: ";
-    bool first = true;
-    for (const auto& name : cmd_info->names) {
-        if (!first) std::cout << ", ";
-        std::cout << name;
-        first = false;
-    }
-    std::cout << std::endl << std::endl;
-    
-    std::cout << 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]);
-
-    std::cout << std::endl;
-    maketitle("DropShell version " + VERSION);
-    std::cout << std::endl;
-    std::cout << "A tool for managing remote servers, by " << AUTHOR << std::endl;
-    std::cout << std::endl;
-    std::cout << "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");
-    }
-    return 0;
-}
-
-// void show_command(const std::string& cmd) { 
-//     const auto& cmd_info = CommandRegistry::instance().find_command(cmd); 
-//     if (cmd_info) { 
-//         std::cout << "  " << cmd_info->help_usage 
-//         << std::string(' ', std::min(1,(int)(30-cmd_info->help_usage.length())))
-//         << cmd_info->help_description << std::endl; 
-//     } 
-// }
-
-// bool 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;
-//     show_command("help");
-//     show_command("edit");
-
-//     if (gConfig().is_config_set()) {
-//     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 << "  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 << std::endl;
-//     std::cout << "  install SERVER [SERVICE]     Install/reinstall/update service(s). Safe/non-destructive." << std::endl;
-//     std::cout << "  uninstall SERVER [SERVICE]   Uninstalls the service on the remote server. Leaves data intact." << std::endl;
-//     std::cout << "  nuke SERVER SERVICE          Nuke the service, deleting ALL local and remote data." << std::endl;
-//     std::cout << std::endl;
-//     std::cout << "  COMMAND SERVER [SERVICE]     Run a command on service(s), e.g." << std::endl;
-//     std::cout << "                                  backup, restore, start, stop, logs" << 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 {
-//         show_command("help");
-//         show_command("edit");
-//         std::cout << std::endl;
-//         std::cout << "Other commands available once initialised." << std::endl;
-//     }
-//     return true;
-// }
-
-
-
-} // namespace dropshell

source/src/commands/install.cpp

@@ -1,380 +0,0 @@
-#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 <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 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;
-
-
-    // ------------------------------------------------------------------------------------------------
-    // install service over ssh : SHARED COMMAND
-    // ------------------------------------------------------------------------------------------------
-    bool install_service(const std::string &server, const std::string &service, bool silent)
-    {
-        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
-        std::cout << "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, silent))
-        {
-            std::cerr << "Failed to copy template files using rsync" << std::endl;
-            return false;
-        }
-
-        // Copy service files
-        std::cout << "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, silent))
-        {
-            std::cerr << "Failed to copy service files using rsync" << std::endl;
-            return false;
-        }
-
-        // Run install script
-        {
-            std::cout << "Running " << service_info.template_name << " install script on " << server << "..." << std::endl;
-            server_env.run_remote_template_command(service, "install", {}, silent, {});
-        }
-
-        // print health tick
-        std::cout << "Health: " << shared_commands::healthtick(server, service) << std::endl;
-        return true;
-    }
-
-
-    // ------------------------------------------------------------------------------------------------
-    // 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.
-        std::cout << "Installing dropshell agent on " << server << std::endl;
-
-        std::string agent_path = remotepath::agent(server);
-        if (agent_path.empty())
-        {
-            std::cerr << "Failed to get agent path for " << server << std::endl;
-            return 1;
-        }
-
-        server_env_manager server_env(server);
-        if (!server_env.is_valid())
-        {
-            std::cerr << "Invalid server environment for " << server << std::endl;
-            return 1;
-        }
-
-        // now create the agent.
-        // copy across from the local agent files.
-        std::cout << "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);
-        std::cout << "done." << std::endl;
-
-        // add in bb64. We can't use execute_remote_command() here, as that relies on bb64 which we're installing!
-        std::cout << "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))
-            std::cerr << "Failed to download bb64 to " << agent_path << " on remote server." << std::endl;
-        else
-            std::cout << "Downloaded bb64 to " << agent_path << " on remote server." << std::endl;
-
-        // just test all is ok
-
-        // run the self-test.
-        std::string output;
-        bool okay = execute_ssh_command(server_env.get_SSH_INFO(), sCommand(agent_path, "./selftest.sh", {}), cMode::Defaults, &output);
-        if (!okay)
-        {
-            std::cerr << "ERROR: Failed to install remote agent on " << server << std::endl;
-            std::cerr << "ERROR: Output: " << output << std::endl;
-            return 1;
-        }
-
-        std::cout << output << 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())
-        {
-            std::cerr << "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 (!install_service(server, service.service_name, false))
-                    okay = false;
-            }
-            return okay ? 0 : 1;
-        }
-        else
-        { // install the specific service.
-            std::string service = safearg(ctx.args, 1);
-            return install_service(server, service, false) ? 0 : 1;
-        }
-    }
-
-} // namespace dropshell

source/src/commands/list.cpp

@@ -1,185 +0,0 @@
-#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 <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;
-    }
-
-    std::cout << "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()) {
-        std::cout << "No servers found" << std::endl;
-        std::cout << "Please run 'dropshell edit' to set up dropshell." << std::endl;
-        std::cout << "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"});
-
-    std::cout << "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.
-        std::cout << checked << " ✓  " << std::flush;
-    });
-    task->wait();
-    std::cout << 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()) {
-        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, 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, 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

@@ -1,148 +0,0 @@
-#include "command_registry.hpp"
-#include "shared_commands.hpp"
-#include "config.hpp"
-#include "services.hpp"
-#include "server_env_manager.hpp"
-#include "utils/directories.hpp"
-#include "servers.hpp"
-#include "templates.hpp"
-#include "utils/utils.hpp"
-
-#include "utils/assert.hpp"
-
-#pragma message ("TODO: Fix issues with Nuke below.")
-
-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;
-
-int nuke_one(std::string server, 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))
-            std::cerr << "Warning: 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"))
-            {
-                if (!server_env.run_remote_template_command(service, "nuke", {}, false, {}))
-                    std::cerr << "Warning: Failed to run nuke script: " << service << std::endl;
-            }
-            else
-            {
-                if (!server_env.run_remote_template_command(service, "uninstall", {}, false, {}))
-                    std::cerr << "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");
-                std::cout << "Remote service directory removed: " << remotepath::service(server, service) << std::endl;
-            }
-            else 
-                std::cerr << "Warning: Failed to remove remote service directory" << std::endl;
-        }
-        else
-            std::cerr << "Warning: Service not found on remote server: " << remotepath::service(server, service) << std::endl;
-    }
-    else
-        std::cerr << "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))
-    {
-        std::cerr << "Warning: Local service directory not found: " << local_service_path << std::endl;
-    }
-    else
-    {
-        auto itemsdeleted = std::filesystem::remove_all(local_service_path);
-        if (itemsdeleted == 0)
-            std::cerr << "Error: Failed to remove local service directory" << std::endl;
-    }
-
-    std::cout << "Nuked service " << service << " on server " << server << std::endl;
-
-    return 0;
-}
-
-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())
-        {
-            std::cerr << "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 |= nuke_one(server, service_name);
-            }
-        }
-        return rval;
-    }
-    else
-    {
-        return nuke_one(server, service);
-    }
-}
-
-} // namespace dropshell

source/src/commands/shared_commands.cpp

@@ -1,247 +0,0 @@
-#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"
-
-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)
-            {
-                std::cout << 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)
-            {
-                std::cout << 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)
-            std::cout << "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))
-            std::cerr << "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())
-        {
-            std::cerr << "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, &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())
-        {
-            std::cerr << "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);
-    }
-
-    } // namespace shared_commands
-
-} // namespace dropshell

source/src/commands/shared_commands.hpp

@@ -1,63 +0,0 @@
-#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);
-
-
-    } // namespace shared_commands
-} // namespace dropshell
-#endif

source/src/commands/start.cpp

@@ -1,91 +0,0 @@
-#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"
-
-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())
-        {
-            std::cerr << "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)
-        {
-            std::cout << "Service " << service << " on server " << server << " started." << std::endl;
-            return true;
-        }
-        std::cerr << "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

@@ -1,91 +0,0 @@
-#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"
-
-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())
-        {
-            std::cerr << "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)
-        {
-            std::cout << "Service " << service << " on server " << server << " stopped." << std::endl;
-            return true;
-        }
-        std::cerr << "Error: Failed to stop service " << service << " on server " << server << std::endl;
-        return false;
-    }
-
-    int stop_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 &= 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

@@ -1,111 +0,0 @@
-#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;
-
-    bool uninstall_service(const std::string &server, const std::string &service, bool silent = false)
-    {
-        if (!silent)
-            maketitle("Uninstalling " + service + " on " + server);
-
-        server_env_manager server_env(server);
-        if (!server_env.is_valid())
-        {
-            std::cerr << "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)))
-        {
-            std::cerr << "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", {}, silent, {}))
-            if (!silent)
-                std::cerr << "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), silent))
-        {
-            ASSERT(!server_env.check_remote_dir_exists(remotepath::service(server, service)), "Service directory still found on server after uninstall");
-            if (!silent)
-                std::cout << "Removed remote service directory " << remotepath::service(server, service) << std::endl;
-        }
-        else if (!silent)
-            std::cerr << "Warning: Failed to remove remote service directory" << std::endl;
-
-        if (!silent)
-            std::cout << "Completed service " << service << " uninstall on " << server << std::endl;
-        return true;
-    }
-
-    int uninstall_handler(const CommandContext &ctx)
-    {
-        if (ctx.args.size() < 1)
-        {
-            std::cerr << "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 (!uninstall_service(server, service.service_name))
-                    okay = false;
-            }
-            return okay ? 0 : 1;
-        }
-
-        std::string service = safearg(ctx.args, 1);
-        return uninstall_service(server, service) ? 0 : 1;
-    }
-
-} // namespace dropshell

source/src/commands/version.cpp

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

@@ -1,262 +0,0 @@
-#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 <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* info = CommandRegistry::instance().find_command(ctx.command);
-        if (!info) {
-            std::cerr << "Unknown command: " << ctx.command << std::endl;
-            return 1;
-        }
-        if (info->requires_config && !gConfig().is_config_set()) {
-            std::cerr << "Valid dropshell configuration required for command: " << ctx.command << std::endl;
-            std::cerr << "Please run 'dropshell edit' to set up the dropshell configuration." << std::endl;
-            return 1;
-        }
-        if (info->requires_install && !gConfig().is_agent_installed()) {
-            std::cerr << "Dropshell agent not installed for command: " << ctx.command << std::endl;
-            std::cerr << "Please run 'dropshell install' to install the local dropshell agent." << std::endl;
-            return 1;
-        }
-
-        int arg_count = ctx.args.size();
-        if (arg_count < info->min_args || (info->max_args != -1 && arg_count > info->max_args)) {
-            std::cerr << "Invalid number of arguments for command: " << ctx.command << std::endl;
-            std::cerr << "(" << ctx.args.size() << " args provided, " << ctx.command << " requires " << (info->min_args) << " to " << (info->max_args) << " args)" << std::endl;
-            std::cerr << "Usage: " << std::endl;
-            std::cerr << "  ";
-            print_left_aligned(info->help_usage,30);
-            std::cout << info->help_description << std::endl;
-            return 1;
-        }
-        return info->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;
-}
-
-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;
-}
-
-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/utils/assert.hpp

@@ -1,11 +0,0 @@
-#ifndef ASSERT_HPP
-#define ASSERT_HPP
-
-
-#define ASSERT(condition, message) \
-    if (!(condition)) { \
-        std::cerr << "Assertion failed: " << message << std::endl; \
-        std::exit(1); \
-    }
-
-#endif // ASSERT_HPP

source/src/utils/b64ed.cpp

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

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

@@ -1,179 +0,0 @@
-#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"
-
-namespace dropshell
-{
-    bool EXITSTATUSCHECK(int ret)
-    {
-        return (ret != -1 && WIFEXITED(ret) && (WEXITSTATUS(ret) == 0)); // ret is -1 if the command failed to execute.
-    }
-
-    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);
-        }
-    }
-
-    bool execute_local_command_and_capture_output(const sCommand &command, std::string *output)
-    {
-        ASSERT(output != nullptr, "Output string must be provided");
-        if (command.get_command_to_run().empty())
-            return false;
-        std::string full_cmd = command.construct_cmd(localpath::agent()) + " 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 ret = pclose(pipe);
-        return EXITSTATUSCHECK(ret);
-    }
-
-    bool execute_local_command(std::string command, std::string *output, cMode mode)
-    {
-        return execute_local_command("", command, {}, output, mode);
-    }
-
-    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 (hasFlag(mode, cMode::CaptureOutput))
-        {
-            ASSERT(output != nullptr, "Capture output mode requires an output string to be provided");
-            ASSERT(!hasFlag(mode, cMode::Silent), "Silent mode is not allowed with capture output mode");
-
-            return execute_local_command_and_capture_output(command, output);
-        }
-
-        if (command.get_command_to_run().empty())
-            return false;
-        bool silent = hasFlag(mode, cMode::Silent);
-        std::string full_cmd = command.construct_cmd(localpath::agent()) + " 2>&1" + (silent ? " > /dev/null" : "");
-        int ret = system(full_cmd.c_str());
-
-        bool ok = EXITSTATUSCHECK(ret);
-        if (!ok && !silent)
-        {
-            std::cerr << "Error: Failed to execute command: " << std::endl;
-            std::cerr << full_cmd << std::endl;
-        }
-        return ok;
-    }
-
-    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;
-    }
-
-    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;
-    }
-
-    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

src/autocomplete.cpp

@@ -5,30 +5,11 @@
 #include "services.hpp"
 #include "servers.hpp"
 
-#include <assert.hpp>
+#include <libassert/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)
+bool dropshell::autocomplete(const std::vector<std::string> &args)
 {
     if (args.size() < 3) // dropshell autocomplete ???
     {
@@ -36,7 +17,7 @@ bool autocomplete(const std::vector<std::string> &args)
         return true;
     }
 
-    ASSERT(args.size() >= 3, "Invalid number of arguments");
+    ASSERT(args.size() >= 3);
     std::string cmd = args[2];
 
     // std::cout<<" cmd = ["<<cmd<<"]"<<std::endl;
@@ -49,8 +30,10 @@ bool autocomplete(const std::vector<std::string> &args)
         return true;
     }
 
-    if (autocomplete::is_no_arg_cmd(cmd))
-        return true; // no arguments needed.
+
+    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 true;
 
     if (!dropshell::gConfig().is_config_set())
         return false; // can't help without working config.
@@ -100,21 +83,23 @@ bool autocomplete(const std::vector<std::string> &args)
     return false; // catch-all.
 }
 
-bool autocomplete_list_commands()
+bool dropshell::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);
-
+    commands.merge(std::set<std::string>{ 
+        "help","edit" // these are always available.
+    });
     if (dropshell::gConfig().is_config_set()) 
-        autocomplete::merge_commands(commands, autocomplete::system_commands_require_config);
-
+        commands.merge(std::set<std::string>{
+            "server","templates","create-service","create-template","create-server","ssh",
+            "list" // only if we have a config.
+        });
     for (const auto& command : commands) {
         std::cout << command << std::endl;
     }
     return true;
 }
 
-} // namespace autocomplete

src/autocomplete.hpp

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

src/config.cpp

@@ -5,7 +5,7 @@
 #include "utils/utils.hpp"
 #include "utils/json.hpp"
 #include <filesystem>
-#include "utils/execute.hpp"
+
 namespace dropshell {
 
 
@@ -61,7 +61,6 @@ bool config::save_config(bool create_aux_directories)
         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"
@@ -69,7 +68,6 @@ bool config::save_config(bool create_aux_directories)
         mConfig["template_local_paths"] = {
             dropshell_base + "/local_templates"
         };
-        
         mConfig["server_definition_paths"] = {
             dropshell_base + "/servers"
         };
@@ -100,16 +98,12 @@ bool config::save_config(bool create_aux_directories)
     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"];
 }

src/config.hpp

@@ -15,11 +15,12 @@ class 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();

src/contrib/base64.cpp

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

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

@@ -0,0 +1,272 @@
+#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 "autocomplete.hpp"
+#include "utils/hash.hpp"
+
+#include <filesystem>
+#include <iostream>
+#include <string>
+#include <vector>
+#include <iomanip>
+#include <chrono>
+#include <libassert/assert.hpp>
+
+namespace dropshell {
+
+extern const std::string VERSION;
+extern const std::string RELEASE_DATE;
+extern const std::string AUTHOR;
+extern const std::string LICENSE;
+
+bool 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 << "  edit           Edit the configuration of dropshell" << 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 << "  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 << std::endl;
+    std::cout << "  install SERVER [SERVICE]     Install/reinstall/update service(s). Safe/non-destructive." << std::endl;
+    std::cout << "  uninstall SERVER [SERVICE]   Uninstalls the service on the remote server. Leaves data intact." << std::endl;
+    std::cout << "  nuke SERVER SERVICE          Nuke the service on the remote server, deleting all remote data." << std::endl;
+    std::cout << std::endl;
+    std::cout << "  COMMAND SERVER [SERVICE]     Run a command on service(s), e.g." << std::endl;
+    std::cout << "                                  backup, restore, start, stop, logs" << 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;
+    }
+    return true;
+}
+
+
+int die(const std::string & msg) {
+    std::cerr << msg << 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;
+}
+
+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;}}
+#define BOOLEXIT(CMD, RUNCMD) {if (safearg(argc,argv,1) == CMD) {return (RUNCMD) ? 0 : 1;}}
+
+int 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();
+
+        if (argc < 2) 
+            return print_help() ? 0 : 1;
+
+        std::string cmd = argv[1];
+
+        if (cmd == "autocomplete") {
+            std::vector<std::string> argvec;
+            for (int i=0; i<argc; i++) 
+                argvec.push_back(argv[i]);
+            return autocomplete(argvec) ? 0 : 1;
+        }
+
+        if (cmd == "help" || cmd == "-h" || cmd == "--help" || cmd== "h" || cmd=="halp") 
+            return print_help() ? 0 : 1;
+
+        if (cmd == "edit" && argc < 3) {
+            if (!gConfig().is_config_set())
+               gConfig().save_config(false);
+
+            std::string config_file = localfile::dropshell_json();
+            if (!service_runner::edit_file(config_file) || !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;
+        }
+
+        // ------------------------------------------------------------
+        // 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();
+
+        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") {
+            gTemplateManager().list_templates();
+            return 0;
+        }
+
+        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;
+        }
+
+        if (cmd == "edit" && argc < 4) {
+            ASSERT(argc>=3, "Error: logic error!");
+            service_runner::edit_server(safearg(argc,argv,2));
+            return 0;
+        }
+
+        // handle running a command. 
+        std::set<std::string> commands;
+        get_all_used_commands(commands);
+        commands.merge(std::set<std::string>{"ssh","edit","_allservicesstatus","fullnuke"}); // 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);
+}

src/server_env_manager.cpp

@@ -101,10 +101,11 @@ std::string server_env_manager::get_variable(const std::string& name) const {
     }
     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
+
+sCommand server_env_manager::construct_standard_template_run_cmd(const std::string &service_name, const std::string &command, std::vector<std::string> args, bool silent) const
 {
     if (command.empty())
-        return std::nullopt;
+        return sCommand();
 
     std::string remote_service_template_path = remotepath::service_template(mServerName,service_name);
     std::string script_path = remote_service_template_path + "/" + command + ".sh";
@@ -112,7 +113,7 @@ std::optional<sCommand> server_env_manager::construct_standard_template_run_cmd(
     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;
+        return sCommand();
     }
 
     std::string argstr = "";
@@ -120,29 +121,28 @@ std::optional<sCommand> server_env_manager::construct_standard_template_run_cmd(
         argstr += " " + quote(dequote(trim(arg)));
     }
 
-    sCommand sc(
-        remote_service_template_path, 
-        quote(script_path) + argstr + (silent ? " > /dev/null 2>&1" : ""), 
-        env_vars
-    );
+    std::vector<std::string> cmd = {script_path};
+    cmd.insert(cmd.end(), args.begin(), args.end());
+    sCommand scommand(remote_service_template_path, cmd, env_vars);
 
-    if (sc.empty()) {
+    if (scommand.empty())
         std::cerr << "Error: Failed to construct command for " << service_name << " " << command << std::endl;
-        return std::nullopt;
-    }
-    return sc;
+
+    return scommand;
 }
 
 
 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);
+    std::vector<std::string> cmd = {"test", "-d", dir_path};
+    sCommand scommand(cmd);
+    return execute_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);
+    std::vector<std::string> cmd = {"test", "-f", file_path};
+    sCommand scommand(cmd);
+    return execute_command(get_SSH_INFO(), scommand, cMode::Silent);
 }
 
 bool server_env_manager::check_remote_items_exist(const std::vector<std::string> &file_paths) const
@@ -155,9 +155,11 @@ bool server_env_manager::check_remote_items_exist(const std::vector<std::string>
         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",{});
+    sCommand scommand({
+       "bash", "-c", "for item in " + file_paths_str + "; do test -f $item; done"
+    });
 
-    bool okay = execute_ssh_command(get_SSH_INFO(), scommand, cMode::Silent);
+    bool okay = execute_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;
@@ -165,65 +167,35 @@ bool server_env_manager::check_remote_items_exist(const std::vector<std::string>
     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;
+    sCommand scommand = construct_standard_template_run_cmd(service_name, command, args, silent);
 
     // add the extra env vars to the command
     for (const auto& [key, value] : extra_env_vars) 
-        scommand->add_env_var(key, value);
+            scommand.add_env_var(key, value);
 
-    if (scommand->get_command_to_run().empty())
+    if (scommand.get_command_to_run().empty())
         return false;
-    cMode mode = (command=="ssh") ? (cMode::Interactive) : cMode::Silent;
-    return execute_ssh_command(get_SSH_INFO(), scommand.value(), mode);
+    cMode mode = (command=="ssh" ? cMode::Defaults : cMode::Silent);
+    return execute_command(get_SSH_INFO(), scommand, 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())
+    sCommand scommand = construct_standard_template_run_cmd(service_name, command, args, false);
+    if (scommand.get_command_to_run().empty())
         return false;
 
     // add the extra env vars to the command
     for (const auto& [key, value] : extra_env_vars) 
-        scommand->add_env_var(key, value);
+        scommand.add_env_var(key, value);
 
     cMode mode = cMode::CaptureOutput;
-    return execute_ssh_command(get_SSH_INFO(), scommand.value(), mode, &output);
+    return execute_command(get_SSH_INFO(), scommand, mode, output);
 }
 
 
-
 // base64 <<< "FOO=BAR WHEE=YAY bash ./test.sh"
 // echo YmFzaCAtYyAnRk9PPUJBUiBXSEVFPVlBWSBiYXNoIC4vdGVzdC5zaCcK | base64 -d | bash
 

src/server_env_manager.hpp

@@ -10,7 +10,7 @@
 #include <memory>
 #include <vector>
 #include "utils/execute.hpp"
-#include <optional>
+
 namespace dropshell {
 
 class server_env_manager;
@@ -43,7 +43,7 @@ class server_env_manager {
         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()}; }
+        sSSHInfo get_SSH_INFO() const { return sSSHInfo{get_SSH_HOST(), get_SSH_USER(), get_SSH_PORT()}; }
         bool is_valid() const { return mValid; }
         std::string get_server_name() const { return mServerName; }
 
@@ -53,15 +53,13 @@ class server_env_manager {
         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;
+        sCommand construct_standard_template_run_cmd(const std::string& service_name, const std::string& command, std::vector<std::string> args, bool silent) const;
 
     private:
         std::string mServerName;

src/servers.cpp

@@ -1,5 +1,6 @@
 #include "servers.hpp"
 #include "server_env_manager.hpp"
+#include "service_runner.hpp"
 #include "utils/tableprint.hpp"
 #include "utils/envmanager.hpp"
 #include "utils/directories.hpp"
@@ -70,6 +71,108 @@ ServerInfo get_server_info(const std::string &server_name)
     return ServerInfo();
 }
 
+// https://github.com/bloomen/transwarp?tab=readme-ov-file#range-functions
+void list_servers() {
+    auto servers = get_configured_servers();
+
+    tableprint tp("All DropShell Servers");
+    tp.add_row({"Name", "User", "Address", "Health", "Ports"});
+
+    std::cout << "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, 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_user, server.ssh_host, serviceticks, ports_used_str});
+        ++checked;
+        // print out a tick character for each server checked.
+        std::cout << checked << " ✓  " << std::flush;
+    });
+    task->wait();
+    std::cout << 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()) {
+        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
 
 bool create_server(const std::string &server_name)
 {
@@ -102,11 +205,14 @@ bool create_server(const std::string &server_name)
     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::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 << "3) install dropshell-agent:       dropshell install " << server_name << " dropshell-agent" << std::endl;
     std::cout << std::endl;
     return true;
 }

src/servers.hpp

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

src/service_runner.cpp

@@ -1,4 +1,3 @@
-
 #include <iostream>
 #include <fstream>
 #include <sstream>
@@ -7,84 +6,15 @@
 #include <iomanip>
 #include <filesystem>
 #include <unistd.h>
-#include "utils/assert.hpp"
+#include <libassert/assert.hpp>
 
 #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 "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;
@@ -112,7 +42,109 @@ service_runner::service_runner(const std::string& server_name, const std::string
     mValid = !mServiceInfo.local_template_path.empty();
 }
 
+bool service_runner::install(bool silent) {
+    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 = gTemplateManager().get_template_info(mServiceInfo.template_name);
+    if (!tinfo.is_set())
+        return false;
+        
+    // Create service directory
+    std::string remote_service_path = remotepath::service(mServer, mService);
+    if (!execute_command(mServerEnv.get_SSH_INFO(), sCommand({"mkdir", "-p", quote(remote_service_path)}), cMode::Silent))
+    {
+        std::cerr << "Failed to create service directory " << remote_service_path << std::endl;
+        return false;
+    }
+    
+    // Check if rsync is installed on remote host
+    if (!execute_command(mServerEnv.get_SSH_INFO(), sCommand({"which", "rsync", ">", "/dev/null", "2>&1"}), cMode::Silent))
+    {
+        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::vector<std::string> rsync_cmd = {"rsync", "--delete", "-zrpc", "-e", quote("ssh -p " + mServerEnv.get_SSH_PORT()), 
+                            quote(tinfo.local_template_path().string()+"/"), 
+                            mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + quote(remotepath::service_template(mServer, mService)+"/")
+                            };
+        if (!execute_command(rsync_cmd, silent ? cMode::Silent : cMode::Defaults))
+        {
+            std::cerr << "Failed to copy template files using rsync" << std::endl;
+            return false;
+        }
+    }
+    
+    // Copy service files
+    {
+        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::vector<std::string> rsync_cmd = {"rsync", "--delete", "-zrpc", "-e", quote("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 (!execute_command(rsync_cmd, silent ? cMode::Silent : cMode::Defaults))
+        {
+            std::cerr << "Failed to copy service files using rsync" << std::endl;
+            return false;
+        }
+    }
+
+    // Run install script
+    {
+        mServerEnv.run_remote_template_command(mService, "install", {}, silent, {});
+    }
+
+    // print health tick
+    std::cout << "Health: " << healthtick() << std::endl;
+    return true;
+}
+
+bool service_runner::uninstall(bool silent) {
+    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", {}, silent, {})) {
+            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::vector<std::string> rm_cmd = {"rm", "-rf", remotepath::service(mServer, mService)};
+    if (!execute_command(mServerEnv.get_SSH_INFO(), sCommand(rm_cmd), cMode::Silent)) {
+        std::cerr << "Failed to remove service directory" << std::endl;
+        return false;
+    }
+    
+    std::cout << "Service " << mService << " successfully uninstalled from " << mServer << std::endl;
+    return true;
+}
 
 bool service_runner::nuke(bool silent)
 {
@@ -121,6 +153,12 @@ bool service_runner::nuke(bool silent)
     if (!mServerEnv.is_valid()) return false; // should never hit this.
 
     std::string remote_service_path = remotepath::service(mServer, mService);
+    bool okay = mServerEnv.run_remote_template_command("dropshell-agent", "_nuke_other", {mService, remote_service_path}, silent, {});
+    if (!okay)
+    {
+        std::cerr << "Warning: Nuke script failed" << std::endl;
+        return false;
+    }
 
     std::cout << "Service " << mService << " successfully nuked from " << mServer << std::endl;
 
@@ -146,8 +184,8 @@ bool service_runner::fullnuke()
         return false;
     }  
     
-    std::string rm_cmd = "rm -rf " + quote(local_service_path);
-    if (!execute_local_command(rm_cmd, nullptr, cMode::Silent)) {
+    std::vector<std::string> rm_cmd = {"rm", "-rf", local_service_path};
+    if (!execute_command(sCommand(rm_cmd), cMode::Silent)) {
         std::cerr << "Failed to remove service directory" << std::endl;
         return false;
     }
@@ -170,6 +208,12 @@ bool service_runner::run_command(const std::string& command, std::vector<std::st
         return false;
     }
 
+    // don't need a script for edit!
+    if (command == "edit") {
+        edit_service_config();
+        return true;
+    }
+
     if (command == "fullnuke") 
         return fullnuke();
 
@@ -185,8 +229,8 @@ bool service_runner::run_command(const std::string& command, std::vector<std::st
     }
 
     // install doesn't require anything on the server yet.
-    // if (command == "install") 
-    //     return install_service(mServer, mService, false);
+    if (command == "install") 
+        return install();
 
     std::string script_path = remotepath::service_template(mServer, mService) + "/" + command + ".sh";
     
@@ -208,8 +252,8 @@ bool service_runner::run_command(const std::string& command, std::vector<std::st
         return false;
     }
 
-    // if (command == "uninstall") 
-    //     return uninstall();
+    if (command == "uninstall") 
+        return uninstall();
 
     if (command == "ssh") {
         interactive_ssh_service();
@@ -233,6 +277,123 @@ bool service_runner::run_command(const std::string& command, std::vector<std::st
 }
 
 
+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 (!gTemplateManager().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, true, {}))
+        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:";
+}
+
+
+std::string service_runner::healthmark()
+{
+    HealthStatus status = is_healthy();
+    return HealthStatus2String(status);
+}
 
 bool service_runner::interactive_ssh(const std::string & server_name, const std::string & command) {
     std::string serverpath = localpath::server(server_name);
@@ -241,16 +402,62 @@ bool service_runner::interactive_ssh(const std::string & server_name, const std:
         return false;
     }
     
+    sCommand scommand({"bash"});
     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);
+    return execute_command(env.get_SSH_INFO(), scommand, cMode::Defaults);
 }
 
+void service_runner::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";
+    if (!edit_file(config_file)) {
+        std::cerr << "Error: Failed to edit server.env" << std::endl;
+        std::cerr << "You can manually edit this file at: " << config_file << std::endl;
+        std::cerr << "After editing, " << aftertext.str() << std::endl;
+    }
+    else
+        std::cout << aftertext.str() << std::endl;
+}
+
+bool service_runner::edit_file(const std::string &file_path)
+{
+    // make sure parent directory exists.
+    std::string parent_dir = get_parent(file_path);
+    std::filesystem::create_directories(parent_dir);
+
+    std::vector<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), file_path};
+    } else if (isatty(STDIN_FILENO)) {
+        // Check if stdin is connected to a terminal if EDITOR is not set
+        editor_cmd = {"nano", "-w", file_path};
+    } else {
+        std::cerr << "Error: Standard input is not a terminal and EDITOR environment variable is not set." << std::endl;
+        std::cerr << "Try setting the EDITOR environment variable (e.g., export EDITOR=nano) or run in an interactive terminal." << std::endl;
+        std::cerr << "You can manually edit the file at: " << file_path << std::endl;
+        return false;
+    }
+
+    std::cout << "Editing file: " << file_path << std::endl;
+    return execute_command(editor_cmd, cMode::Defaults);
+}
 
 bool service_runner::interactive_ssh_service()
 {
@@ -264,17 +471,19 @@ bool service_runner::interactive_ssh_service()
     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)
+void service_runner::edit_service_config()
 {
-    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));
+    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;
+    }
+
+    if (edit_file(config_file) && std::filesystem::exists(config_file))    
+        std::cout << "To apply your changes, run:\n   dropshell install " + mServer + " " + mService << std::endl;
 }
 
-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)
 {
@@ -338,12 +547,12 @@ bool service_runner::restore(std::string backup_file, bool silent)
 
     { // uninstall service, then nuke it.
         maketitle("2) Uninstalling old service...");
-        // if (!uninstall(true))
-        //     return false;
+        if (!uninstall(true))
+            return false;
 
         maketitle("3) Nuking old service...");
-        // if (!nuke(true))
-        //     return false;
+        if (!nuke(true))
+            return false;
     }
 
 
@@ -353,21 +562,22 @@ bool service_runner::restore(std::string backup_file, bool silent)
         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;
+        std::vector<std::string> scp_cmd = {"scp", "-P", mServerEnv.get_SSH_PORT(), quote(local_backup_file_path), mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + quote(remote_backup_file_path) + (silent ? " > /dev/null 2>&1" : "")};
+        if (!execute_command(sCommand(scp_cmd), silent ? cMode::Silent : cMode::Defaults)) {
+            std::cerr << "Failed to copy backup file from server" << std::endl;
             return false;
         }
 
-        shared_commands::cRemoteTempFolder remote_temp_folder(mServerEnv);
+        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;
-    // }
+    { // installing fresh service
+        maketitle("5) Non-destructive install of fresh service...");
+        if (!install(true))
+            return false;
+    }
 
     bool healthy = false;
     {// healthcheck the service
@@ -430,8 +640,7 @@ bool service_runner::backup(bool silent) {
     // 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)) {
+    if (!execute_command(mServerEnv.get_SSH_INFO(), sCommand({"mkdir","-p",remote_backups_dir}), cMode::Silent)) {
         std::cerr << "Failed to create backups directory on server" << std::endl;
         return false;
     }
@@ -462,17 +671,21 @@ bool service_runner::backup(bool silent) {
     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");
+    ASSERT(3 == count_substring(magic_string, local_backup_file_path));
 
     {   // Run backup script
-        shared_commands::cRemoteTempFolder remote_temp_folder(mServerEnv);
+        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::vector<std::string> scp_cmd = {"scp", "-P", mServerEnv.get_SSH_PORT(), 
+                            mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + 
+                            remote_backup_file_path, 
+                            local_backup_file_path};
+        if (!execute_command(sCommand(scp_cmd), silent ? cMode::Silent : cMode::Defaults)) {
             std::cerr << "Failed to copy backup file from server" << std::endl;
             return false;
         }
@@ -485,6 +698,27 @@ bool service_runner::backup(bool silent) {
     return true;
 }
 
+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::vector<std::string> mkdir_cmd = {"mkdir", "-p", p};
+    if (!execute_command(server_env.get_SSH_INFO(), sCommand(mkdir_cmd), cMode::Silent)) 
+        std::cerr << "Failed to create temp directory on server" << std::endl;
+    else 
+        mPath = p;
+}
+
+cRemoteTempFolder::~cRemoteTempFolder()
+{
+    std::vector<std::string> rm_cmd = {"rm", "-rf", mPath};
+    execute_command(mServerEnv.get_SSH_INFO(), sCommand(rm_cmd), cMode::Silent);
+}
+
+std::string cRemoteTempFolder::path() const
+{
+    return mPath;
+}
+
 // 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();

src/service_runner.hpp

@@ -0,0 +1,123 @@
+// 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/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, 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();
+
+    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(bool silent=false); 
+        
+        // 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(bool silent=false);
+
+        // 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();
+
+        // edit the service configuration file
+        void edit_service_config();
+
+
+    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 void edit_server(const std::string & server_name);
+        static bool edit_file(const std::string & file_path);
+        static std::map<std::string, ServiceStatus> get_all_services_status(std::string server_name);
+        static std::string HealthStatus2String(HealthStatus status);
+
+    private:
+        std::string mServer;
+        server_env_manager mServerEnv;
+        LocalServiceInfo mServiceInfo;
+        std::string mService;
+        bool mValid;
+
+        // Helper methods
+    public:
+};
+
+    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;
+    };
+
+} // namespace dropshell
+
+#endif // SERVICE_RUNNER_HPP

src/services.cpp

@@ -6,7 +6,6 @@
 #include "utils/utils.hpp"
 #include "server_env_manager.hpp"
 #include "servers.hpp"
-#include "assert.hpp"
 
 #include <iostream>
 #include <filesystem>
@@ -69,12 +68,6 @@ LocalServiceInfo get_service_info(const std::string &server_name, const std::str
     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;
@@ -153,6 +146,73 @@ std::set<std::string> list_backups(const std::string &server_name, const std::st
     return backups;
 }
 
+bool create_service(const std::string &server_name, const std::string &template_name, const std::string &service_name, bool silent)
+{
+    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())
+    {
+        if (!silent)
+        {
+            std::cerr << "Error: Couldn't locate server " << server_name << " in any config directory" << std::endl;
+            std::cerr << "Please check the server name is correct and try again" << std::endl;
+            std::cerr << "You can list all servers with 'dropshell servers'" << std::endl;
+            std::cerr << "You can create a new server with 'dropshell create-server " << server_name << "'" << std::endl;
+        }
+        return false;
+    }
+
+    if (fs::exists(service_dir)) 
+    {
+        if (!silent)
+        {
+            std::cerr << "Error: Service already exists: " << service_name << std::endl;
+            std::cerr << "Current service path: " << service_dir << std::endl;
+        }
+        return false;
+    }
+
+    template_info tinfo = gTemplateManager().get_template_info(template_name);
+    if (!tinfo.is_set())
+    {
+        if (!silent)
+        {
+            std::cerr << "Error: Template '" << template_name << "' not found" << std::endl;
+            std::cerr << "Please check the template name is correct and try again" << std::endl;
+            std::cerr << "You can list all templates with 'dropshell templates'" << std::endl;
+            std::cerr << "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()))
+    {
+        if (!silent)
+            std::cerr << "Error: Template '" << template_name << "' is not valid" << std::endl;
+        return false;
+    }
+
+    // create the service directory
+    fs::create_directory(service_dir);
+
+    // copy the template config files to the service directory
+    recursive_copy(tinfo.local_template_path()/"config", service_dir);
+
+    if (!silent)
+    {
+        std::cout << "Service " << service_name <<" created successfully"<<std::endl;
+        std::cout << std::endl;
+        std::cout << "To complete the installation, please:" << std::endl;
+        std::cout << "1. edit the service config file:  dropshell edit " << server_name << " " << service_name << std::endl;
+        std::cout << "2. install the remote service:    dropshell install " << server_name << " " << service_name << std::endl;
+    }
+    return true;
+}
+
 
 
 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)
@@ -161,20 +221,19 @@ bool get_all_service_env_vars(const std::string &server_name, const std::string
 
     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;
+        std::cerr << "Error: Service not found: " << service_name << std::endl;
         return false;
     }
 
+    // add in some handy variables.
+    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::service_template(server_name, "dropshell-agent") + "/shared";
+
     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;
 
     // Lambda function to load environment variables from a file

src/services.hpp

@@ -27,6 +27,8 @@ namespace dropshell {
 
     // list all backups for a given service (across all servers)
     std::set<std::string> list_backups(const std::string& server_name, const std::string& service_name);
+
+    bool create_service(const std::string& server_name, const std::string& template_name, const std::string& service_name, bool silent=false);
 } // namespace dropshell
 
 #endif

src/templates.cpp

@@ -6,7 +6,7 @@
     #include <algorithm>
     #include <iomanip>
     #include <map>
-    #include "utils/assert.hpp"
+    #include <libassert/assert.hpp>
 
     #include "utils/envmanager.hpp"
     #include "utils/directories.hpp"
@@ -105,7 +105,7 @@
     // ------------------------------------------------------------------------------------------------
 
     void template_manager::list_templates() const {
-        ASSERT(mLoaded && mSources.size() > 0, "Template manager not loaded, or no template sources found.");
+        ASSERT(mLoaded && mSources.size() > 0);
         auto templates = get_template_list();
         
         if (templates.empty()) {
@@ -128,7 +128,7 @@
 
     std::set<std::string> template_manager::get_template_list() const
     {
-        ASSERT(mLoaded && mSources.size() > 0, "Template manager not loaded, or no template sources found.");
+        ASSERT(mLoaded && mSources.size() > 0);
         std::set<std::string> templates;
         for (const auto& source : mSources) {
             auto source_templates = source->get_template_list();
@@ -139,7 +139,7 @@
 
     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.");
+        ASSERT(mLoaded && mSources.size() > 0);
         template_source_interface* source = get_source(template_name);
         if (!source) 
             return false;
@@ -148,7 +148,7 @@
 
     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.");
+        ASSERT(mLoaded && mSources.size() > 0);
         template_source_interface* source = get_source(template_name);
         if (source)
             return source->get_template_info(template_name);
@@ -159,7 +159,7 @@
 
     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.");
+        ASSERT(mLoaded && mSources.size() > 0);
         template_source_interface* source = get_source(template_name);
         if (!source) {
             std::cerr << "Error: Template '" << template_name << "' not found" << std::endl;
@@ -249,9 +249,9 @@
 
     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.");
+        ASSERT(mSources.empty());
+        ASSERT(gConfig().is_config_set());
+        ASSERT(!mLoaded);
         auto local_template_paths = gConfig().get_template_local_paths();
         if (local_template_paths.empty())
             return;
@@ -285,7 +285,7 @@
 
     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.");
+        ASSERT(mLoaded && mSources.size() > 0);
         for (const auto& source : mSources) {
             if (source->has_template(template_name)) {
                 return source.get();
@@ -296,12 +296,6 @@
 
     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 = {
@@ -309,22 +303,13 @@
             "config/.template_info.env",
             "_default.env",
             "install.sh",
-            "uninstall.sh"
+            "uninstall.sh",
+            "nuke.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;
-            }
         }        
 
         // ------------------------------------------------------------
@@ -371,13 +356,4 @@
         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

src/templates.hpp

@@ -17,18 +17,16 @@ typedef enum 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);
+        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), mIsSet(true) {}
         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;
 };
 

src/utils/directories.cpp

@@ -63,15 +63,10 @@ namespace localpath {
             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 local_bin(){
+            return current_user_home() + "/.local/bin";
         }
-        std::string files_for_remote_agent()
-        {
-            return agent() + "/files_for_remote_agent";
-        }
-        std::string current_user_home()
-        {
+        std::string current_user_home(){
             char * homedir = std::getenv("HOME");
             if (homedir)
             {
@@ -83,25 +78,17 @@ namespace localpath {
         }
 } // 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)
+    //          |-- service.env
+    //          |-- (user config files)
     //      |-- template
-    //               |-- _default.env
     //          |-- (script files)
-    //               |-- config
-    //                   |-- service.env (default service config)
-    //                   |-- (other config files for specific server&service)
-
+    //      |-- backups
 
 
 namespace remotefile {
@@ -155,12 +142,6 @@ namespace remotepath {
         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);

src/utils/directories.hpp

@@ -13,11 +13,6 @@ namespace dropshell {
     
     // ~/.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
@@ -59,8 +54,7 @@ namespace dropshell {
 
         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 local_bin();
         std::string current_user_home();
     } // namespace local
 
@@ -70,20 +64,14 @@ namespace dropshell {
     // 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
+    //               |-- service.env
     //           |-- template
-    //               |-- _default.env
     //               |-- (script files)
     //               |-- config
-    //                   |-- service.env (default service config)
-    //                   |-- .template_info.env
+    //                   |-- service.env
     //                   |-- (other config files for specific server&service)
 
     namespace remotefile {
@@ -98,7 +86,6 @@ namespace dropshell {
         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
 
     //------------------------------------------------------------------------------------------------

src/utils/execute.cpp

@@ -0,0 +1,175 @@
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <vector>
+#include <iostream>
+#include <string>
+#include <cstdlib>
+#include <sstream>
+#include <libassert/assert.hpp>
+#include <algorithm>
+#include "execute.hpp"
+#include "contrib/base64.hpp"
+#include "utils/utils.hpp"
+#include "utils/directories.hpp"
+#include <termios.h>
+
+bool EXITSTATUSCHECK(int ret) {
+    return (ret != -1 && WIFEXITED(ret) && (WEXITSTATUS(ret) == 0)); // ret is -1 if the command failed to execute.
+}
+
+namespace dropshell {
+bool __execute_command(std::vector<std::string> command, std::string * output)
+{
+    // Save TTY state if possible
+    struct termios orig_termios;
+    int tty_fd = isatty(STDIN_FILENO) ? STDIN_FILENO : -1;
+    if (tty_fd != -1) {
+        tcgetattr(tty_fd, &orig_termios);
+    }
+
+    std::cout << "Executing command: ";
+    for (auto & x : command) std::cout << "[" << x << "] ";
+    std::cout << std::endl << std::flush;
+
+    int pipefd[2];
+    bool capture = (output != nullptr);
+    if (capture && pipe(pipefd) == -1) {
+        perror("pipe failed");
+        return false;
+    }
+
+    pid_t pid = fork();
+
+    if (pid == -1) {
+        // Fork failed
+        perror("fork failed");
+        return false;
+    } else if (pid == 0) {
+        // Child process
+        if (capture) {
+            close(pipefd[0]); // Close read end
+            dup2(pipefd[1], STDOUT_FILENO); // Redirect stdout to pipe
+            dup2(pipefd[1], STDERR_FILENO); // Redirect stderr to pipe
+            close(pipefd[1]);
+        }
+
+        std::vector<const char *> commandvec;
+        for (auto & x : command) {
+            commandvec.push_back(x.c_str());
+        }
+        commandvec.push_back(NULL);
+
+        // if (!silent) {
+        //     std::cout << "Executing command: ";
+        //     for (auto & x : commandvec) std::cout << x << " ";
+        //     std::cout << std::endl;
+        // }
+
+        execvp(commandvec[0], const_cast<char* const*>(commandvec.data()));
+        // If execvp returns, it means an error occurred
+        perror("execvp failed");
+        exit(EXIT_FAILURE); // Exit child process on error
+    } else {
+        // Parent process
+        if (capture) {
+            close(pipefd[1]); // Close write end
+            char buffer[256];
+            ssize_t count;
+            while ((count = read(pipefd[0], buffer, sizeof(buffer))) > 0) {
+                output->append(buffer, count);
+            }
+            close(pipefd[0]);
+        }
+        int ret;
+        // Wait for the child process to complete
+        waitpid(pid, &ret, 0);
+
+        // Restore TTY state if possible
+        if (tty_fd != -1) {
+            tcsetattr(tty_fd, TCSANOW, &orig_termios);
+        }
+
+        return EXITSTATUSCHECK(ret);
+    }
+}
+
+bool execute_command(const sSSHInfo * ssh_info, const sCommand command, cMode mode, std::string * output)
+{
+    if (command.get_command_to_run().empty())
+        return false;
+
+    std::vector<std::string> commandvec;
+    
+    // Construct the shell command with proper environment variables and directory
+    std::string shell_command;
+    
+    // Add working directory if provided
+    if (!command.get_directory_to_run_in().empty()) {
+        shell_command += "cd " + quote(command.get_directory_to_run_in()) + " && ";
+    }
+    
+    // Add environment variables if provided
+    for (const auto& env_var : command.get_env_vars()) {
+        shell_command += env_var.first + "=" + quote(env_var.second) + " ";
+    }
+    
+    // Add the command arguments properly joined
+    const auto& args = command.get_command_to_run();
+    std::ostringstream cmd_stream;
+    for (size_t i = 0; i < args.size(); ++i) {
+        if (i > 0) cmd_stream << " ";
+        cmd_stream << args[i];
+    }
+    shell_command += cmd_stream.str();
+    
+    if (ssh_info) {
+        // Use bash -c for SSH to ensure proper command execution
+        commandvec = {
+            "/usr/bin/ssh", 
+            "-p", ssh_info->port, 
+            (hasFlag(mode, cMode::CaptureOutput) ? "" : "-tt"), 
+            ssh_info->user + "@" + ssh_info->host,
+            "bash", "-c", halfquote(shell_command)
+        };
+    } else {
+        // Local execution
+        commandvec = {"bash", "-c", halfquote(shell_command)};
+    }
+    
+    // Remove any empty strings
+    commandvec.erase(
+        std::remove_if(commandvec.begin(), commandvec.end(), 
+                      [](const std::string& s) { return s.empty(); }),
+        commandvec.end());
+    
+    if (hasFlag(mode, cMode::CaptureOutput)) {
+        ASSERT(output, "Capture output mode requires an output string to be provided");
+        return __execute_command(commandvec, output);
+    } else {
+        return __execute_command(commandvec, nullptr);
+    }
+}
+
+bool execute_command(const sSSHInfo ssh_info, const sCommand command, const cMode mode)
+{
+    return execute_command(&ssh_info, command, mode, nullptr);
+}
+
+bool execute_command(const sSSHInfo ssh_info, const sCommand command, const cMode mode, std::string & output)
+{
+    return execute_command(&ssh_info, command, mode, &output);
+}
+
+bool execute_command(const sCommand command, const cMode mode)
+{
+    return execute_command(nullptr, command, mode, nullptr);
+}
+
+bool execute_command(const sCommand command, const cMode mode, std::string & output)
+{
+    return execute_command(nullptr, command, mode, &output);
+}
+
+
+} // namespace dropshell

src/utils/execute.hpp

@@ -3,6 +3,7 @@
 
 #include <string>
 #include <map>
+#include <optional>
 
 namespace dropshell {
 
@@ -11,9 +12,8 @@ class sCommand;
 // mode bitset
 enum class cMode {
     Defaults = 0,
-    Interactive = 1,
-    Silent = 2,
-    CaptureOutput = 4
+    Silent = 1,
+    CaptureOutput = 2
 };
 
 inline cMode operator&(cMode lhs, cMode rhs) {return static_cast<cMode>(static_cast<int>(lhs) & static_cast<int>(rhs));}
@@ -28,44 +28,40 @@ 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 command, std::string * output = nullptr, cMode mode = cMode::Defaults);
-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);
-
+bool execute_command(const sSSHInfo ssh_info, const sCommand command, const cMode mode);
+bool execute_command(const sSSHInfo ssh_info, const sCommand command, const cMode mode, std::string & output);
+bool execute_command(const sCommand command, const cMode mode);
+bool execute_command(const sCommand command, const cMode mode, std::string & output);
 
 // ------------------------------------------------------------------------------------------------
 
 
+
 // 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 directory_to_run_in, const std::vector<std::string> & command_to_run, const std::map<std::string, std::string> & env_vars) : 
+            mDir(directory_to_run_in), mCmdArgs(command_to_run), mEnvVars(env_vars) {}
+        sCommand(const std::vector<std::string> & command_to_run) : 
+            mDir(""), mCmdArgs(command_to_run), mEnvVars({}) {}
+        sCommand() : mDir(""), mCmdArgs({}), mEnvVars({}) {}
 
         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; }
+        const std::vector<std::string>& get_command_to_run() const { return mCmdArgs; }
+        const std::map<std::string, std::string>& get_env_vars() const { return mEnvVars; }
 
-        void add_env_var(const std::string& key, const std::string& value) { mVars[key] = value; }
+        void add_env_var(const std::string& key, const std::string& value) { mEnvVars[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;
+        bool empty() const { return mCmdArgs.empty(); }
 
     private:
         std::string mDir;
-        std::string mCmd;
-        std::map<std::string, std::string> mVars;
+        std::vector<std::string> mCmdArgs;
+        std::map<std::string, std::string> mEnvVars;
 };
 
-bool EXITSTATUSCHECK(int ret);
-
 
 } // namespace dropshell
 

src/utils/utils.cpp

@@ -316,59 +316,4 @@ 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];
-}
-
-
-void print_left_aligned(const std::string & str, int width) {
-    std::cout << left_align(str, width);
-}
-
-void print_centered(const std::string & str, int width) {
-    std::cout << center_align(str, width);
-}
-
-void print_right_aligned(const std::string & str, int width) {
-    std::cout << right_align(str, width);
-}
-
-
-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 

src/utils/utils.hpp

@@ -41,16 +41,4 @@ 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);
-
-void print_left_aligned(const std::string & str, int width);
-void print_centered(const std::string & str, int width);
-void print_right_aligned(const std::string & str, int width);
-
-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 

src/version.hpp.in

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

templates/caddy/README.txt

@@ -0,0 +1,3 @@
+Caddy!
+
+Edit the static site, and the Caddyfile.

templates/caddy/_default.env

@@ -0,0 +1,8 @@
+# Service settings specific to this server 
+
+# Image settings
+IMAGE_REGISTRY="docker.io"
+IMAGE_REPO="caddy"
+
+DATA_VOLUME=caddy_data
+CONFIG_VOLUME=caddy_config

templates/caddy/backup.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+source "${AGENT_PATH}/_common.sh"
+_check_required_env_vars
+
+_stop_container "$CONTAINER_NAME"
+
+autobackup "$1" "$2" "volume=$DATA_VOLUME" "volume=$CONFIG_VOLUME" || _die "Failed to create backup"
+
+_start_container "$CONTAINER_NAME"
+
+echo "Backup created successfully: $BACKUP_FILE"

templates/caddy/config/.template_info.env

@@ -0,0 +1,2 @@
+# Template to use - always required!
+TEMPLATE=caddy

templates/caddy/config/Caddyfile

@@ -0,0 +1,6 @@
+# See https://caddyserver.com/docs/caddyfile
+
+localhost {
+root * /srv
+file_server
+}

templates/caddy/config/service.env

@@ -0,0 +1,10 @@
+# Service settings specific to this server 
+# (can also override anything in the _default.env file in the template to make it specific to this server)
+CONTAINER_NAME=caddy
+IMAGE_TAG="latest"
+
+# Scripts will have these environment variables set, plus those in _default.env, plus:
+# SERVER, SERVICE, CONFIG_PATH
+# CONFIG_PATH points to this directory!
+
+

templates/caddy/config/static/index.html

@@ -0,0 +1,9 @@
+<html>
+    <head>
+        <title>Static Site</title>
+    </head>
+    <body>
+        <h1>Static Site</h1>
+        <p>This is a static site.</p>
+    </body>
+</html>

templates/caddy/install.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+source "${AGENT_PATH}/_common.sh"
+_check_required_env_vars "CONTAINER_NAME" "IMAGE_REGISTRY" "IMAGE_REPO" "IMAGE_TAG" "DATA_VOLUME" "CONFIG_VOLUME" "CONFIG_PATH"
+
+autocreate "volume=$DATA_VOLUME" "volume=$CONFIG_VOLUME" || _die "Failed to autocreate volumes $DATA_VOLUME and $CONFIG_VOLUME"
+
+_check_docker_installed || _die "Docker test failed, aborting installation..."
+
+docker pull "$IMAGE_REGISTRY/$IMAGE_REPO:$IMAGE_TAG" || _die "Failed to pull image $IMAGE_REGISTRY/$IMAGE_REPO:$IMAGE_TAG"
+
+[ -f "${CONFIG_PATH}/Caddyfile" ] || _die "Caddyfile not found in ${CONFIG_PATH}!"
+
+bash ./stop.sh || _die "Failed to stop container ${CONTAINER_NAME}"
+_remove_container $CONTAINER_NAME || _die "Failed to remove container ${CONTAINER_NAME}"
+bash ./start.sh || _die "Failed to start container ${CONTAINER_NAME}"
+
+echo "Installation of ${CONTAINER_NAME} complete"

templates/caddy/logs.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+source "${AGENT_PATH}/_common.sh"
+_check_required_env_vars
+
+# Main script.
+echo "Container ${CONTAINER_NAME} logs:"
+_grey_start
+docker logs "${CONTAINER_NAME}"
+_grey_end

templates/caddy/nuke.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+source "${AGENT_PATH}/_common.sh"
+_check_required_env_vars
+
+# NUKE SCRIPT
+# This is run after the uninstall.sh script to delete all data.
+# dropshell handles the configuration files, so we just need to remove
+# any docker volumes and any custom local data folders.
+
+
+autonuke "volume=$DATA_VOLUME" "volume=$CONFIG_VOLUME" || _die "Failed to nuke"
+
+echo "Nuking of ${CONTAINER_NAME} complete."

templates/caddy/ports.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+source "${AGENT_PATH}/_common.sh"
+
+
+echo 80
+echo 443

templates/caddy/restore.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+source "${AGENT_PATH}/_common.sh"
+_check_required_env_vars
+
+# RESTORE SCRIPT
+
+
+# uninstall container before restore
+bash ./uninstall.sh || _die "Failed to uninstall service before restore"
+
+# restore data from backup file
+autorestore "$1" "$2" "volume=$DATA_VOLUME" "volume=$CONFIG_VOLUME" || _die "Failed to restore data from backup file"
+
+# reinstall service
+bash ./install.sh || _die "Failed to reinstall service after restore"
+
+echo "Restore complete! Service is running again."

templates/caddy/start.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+source "${AGENT_PATH}/_common.sh"
+_check_required_env_vars
+
+# START SCRIPT
+# The start script is required for all templates.
+# It is used to start the service on the server.
+
+
+
+DOCKER_RUN_CMD="docker run -d \
+                --restart unless-stopped \
+                --name ${CONTAINER_NAME} \
+                -p 80:80 \
+                -p 443:443 \
+                -p 443:443/udp \
+                -v ${CONFIG_PATH}/Caddyfile:/etc/caddy/Caddyfile \
+                -v ${DATA_VOLUME}:/data \
+                -v ${CONFIG_VOLUME}:/config \
+                -v ${CONFIG_PATH}/static:/srv \
+                ${IMAGE_REGISTRY}/${IMAGE_REPO}:${IMAGE_TAG}"
+
+
+if ! _create_and_start_container "$DOCKER_RUN_CMD" "$CONTAINER_NAME"; then
+    _die "Failed to start container ${CONTAINER_NAME}"
+fi
+
+# Check if the container is running
+if ! _is_container_running "$CONTAINER_NAME"; then
+    _die "Container ${CONTAINER_NAME} is not running"
+fi
+
+echo "Container ${CONTAINER_NAME} started"

templates/caddy/status.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+source "${AGENT_PATH}/_common.sh"
+_check_required_env_vars
+
+# STATUS SCRIPT
+# The status script is OPTIONAL.
+# It is used to return the status of the service (0 is healthy, 1 is unhealthy).
+
+# This is an example of a status script that checks if the service is running.
+
+# check if the service is running
+_is_container_running $CONTAINER_NAME || _die "Service is not running - did not find container $CONTAINER_NAME."
+
+echo "Service is healthy"
+exit 0

templates/caddy/stop.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+source "${AGENT_PATH}/_common.sh"
+_check_required_env_vars
+
+# STOP SCRIPT
+# The stop script is required for all templates.
+# It is used to stop the service on the server.
+
+
+_stop_container $CONTAINER_NAME || _die "Failed to stop container ${CONTAINER_NAME}"
+
+echo "Container ${CONTAINER_NAME} stopped"

templates/caddy/uninstall.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+source "${AGENT_PATH}/_common.sh"
+_check_required_env_vars
+
+# UNINSTALL SCRIPT
+# The uninstall script is required for all templates.
+# It is used to uninstall the service from the server.
+
+
+_remove_container $CONTAINER_NAME || _die "Failed to remove container ${CONTAINER_NAME}"
+_is_container_running && _die "Couldn't stop existing container"
+_is_container_exists && _die "Couldn't remove existing container"
+
+# remove the image
+docker rmi "$IMAGE_REGISTRY/$IMAGE_REPO:$IMAGE_TAG" || echo "Failed to remove image $IMAGE_REGISTRY/$IMAGE_REPO:$IMAGE_TAG"
+
+echo "Uninstallation of ${CONTAINER_NAME} complete."
+echo "Local data still in place."

templates/dropshell-agent/README.txt

@@ -0,0 +1,3 @@
+DropShell agent.
+
+Required for health checks etc.

templates/dropshell-agent/_allservicesstatus.sh

@@ -9,29 +9,17 @@
 # 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
-    # //               |-- 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)
-
-# Get all services on the server
-SERVICES_PATH=$(realpath "${SCRIPT_DIR}/../services/")
+# // DROPSHELL_DIR
+# //   |-- backups
+# //   |-- services
+# //       |-- service name
+# //           |-- config  <-- this is passed as argument to all scripts
+# //               |-- service.env
+# //           |-- template
+# //               |-- (script files)
+# //               |-- config
+# //                   |-- service.env
+# //                   |-- (other config files for specific server&service)
 
 CURRENT_OUTPUT=""
 CURRENT_EXIT_CODE=0
@@ -43,15 +31,6 @@ 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
@@ -65,18 +44,14 @@ 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"
-        load_dotenv "${service_path}/config/.template_info.env"
-
-        # update the main variables.
-        CONFIG_PATH="${service_path}/config"
-        SERVICE="${SERVICE_NAME}"
-
         set +a
 
-        _check_required_env_vars_allservicesstatus "CONFIG_PATH" "SERVER" "SERVICE" "AGENT_PATH" "HOST_NAME" "TEMPLATE"
+        # update the main variables.
+        export CONFIG_PATH="${service_path}/config"
+        # SERVER is correct
+        export SERVICE="${SERVICE_NAME}"
         
         if [ "$capture_output" = "true" ]; then
             # Capture and return output
@@ -98,7 +73,8 @@ function command_exists() {
     return 0
 }
 
-
+# Get all services on the server
+SERVICES_PATH=$(realpath "${SCRIPT_DIR}/../../")
 
 # Get all service names
 SERVICE_NAMES=$(ls "${SERVICES_PATH}")

templates/dropshell-agent/_default.env

@@ -0,0 +1 @@
+#

templates/dropshell-agent/_nuke_other.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+source "$SCRIPT_DIR/shared/_common.sh"
+
+
+A_SERVICE="$1"
+A_SERVICE_PATH="$2"
+
+
+# 1. Check if service directory exists on server
+[ -d "$A_SERVICE_PATH" ] || _die "Service is not installed: $A_SERVICE"
+
+# uninstall the service
+if [ -f "$A_SERVICE_PATH/uninstall.sh" ]; then
+    $A_SERVICE_PATH/uninstall.sh
+fi
+
+# nuke the service
+if [ -f "$A_SERVICE_PATH/nuke.sh" ]; then
+    $A_SERVICE_PATH/nuke.sh
+fi
+
+# remove the service directory
+rm -rf "$A_SERVICE_PATH"

templates/dropshell-agent/config/.template_info.env

@@ -0,0 +1,4 @@
+# Template to use - always required!
+TEMPLATE=dropshell-agent
+
+

templates/dropshell-agent/install.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+# INSTALL SCRIPT
+# The install script is required for all templates.
+# It is used to install the service on the server.
+# It is called with the path to the server specific env file as an argument.
+
+
+check_prerequisites() {
+    # prerequisites:
+    # - bash
+    # - curl
+    # - wget
+    # - docker
+
+    PREREQUISITES=("bash" "curl" "wget" "jq" "docker")
+
+    # check if all prerequisites are installed
+    for prerequisite in "${PREREQUISITES[@]}"; do
+        if ! command -v "${prerequisite}" &> /dev/null; then
+            echo "Prerequisite: ${prerequisite} is not installed."
+            exit 1
+        fi
+    done
+}
+
+check_prerequisites
+exit 0
+