dropshell release 2025.0518.1356

README.md

@@ -8,6 +8,8 @@ A system management tool for server operations, written in C++.
 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.
@@ -24,3 +26,7 @@ Manual steps:
 1. Test ssh'ing into the server.
 
 
+## Install Services
+
+Set up a server and install a service:
+1. `ds create-server SERVERNAME`

source/CMakeLists.txt

@@ -51,7 +51,7 @@ 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>
+    $<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

source/agent/_allservicesstatus.sh

@@ -73,6 +73,7 @@ function run_command() {
         # update the main variables.
         CONFIG_PATH="${service_path}/config"
         SERVICE="${SERVICE_NAME}"
+        DOCKER_CLI_HINTS=false
 
         set +a
 
@@ -99,6 +100,10 @@ function command_exists() {
 }
 
 
+if [ ! -d "${SERVICES_PATH}" ]; then
+    echo "Services path does not exist: ${SERVICES_PATH}"
+    exit 0
+fi
 
 # Get all service names
 SERVICE_NAMES=$(ls "${SERVICES_PATH}")

source/agent/common.sh

@@ -28,20 +28,10 @@
 
 # Prints an error message in red and exits with status code 1.
 _die() {
-    echo -e "\033[91mError: $1\033[0m"
+    echo -e "Error: $1"
     exit 1
 }
 
-# Switches terminal output color to grey.
-_grey_start() {
-    echo -e -n "\033[90m"
-}
-
-# Resets terminal output color from grey.
-_grey_end() {
-    echo -e -n "\033[0m"
-}
-
 # Creates/starts a container, verifying it runs.
 _create_and_start_container() {
     if [ -z "$1" ] || [ -z "$2" ]; then
@@ -55,9 +45,7 @@ _create_and_start_container() {
         _is_container_running $container_name && return 0
         _start_container $container_name
     else
-        _grey_start
         $run_cmd
-        _grey_end
     fi
 
     if ! _is_container_running $container_name; then

source/agent/selftest.sh

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

source/multibuild.sh

@@ -6,7 +6,9 @@
 
 set -e
 
-rm -f build_amd64/dropshell build_arm64/dropshell build/dropshell.amd64 build/dropshell.arm64
+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
@@ -15,6 +17,9 @@ 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 \
@@ -23,8 +28,8 @@ cmake -B build_amd64 -DCMAKE_BUILD_TYPE=Release \
   -DCMAKE_EXE_LINKER_FLAGS="-static" \
   -DCMAKE_CXX_FLAGS="-march=x86-64" .
 cmake --build build_amd64 --target dropshell --config Release -j"$JOBS"
-mkdir -p build
-cp build_amd64/dropshell build/dropshell.amd64
+mkdir -p output
+cp build_amd64/dropshell output/dropshell.amd64
 
 # Build for arm64 (musl)
 echo "Building for arm64 (musl)..."
@@ -35,18 +40,20 @@ cmake -B build_arm64 -DCMAKE_BUILD_TYPE=Release \
   -DCMAKE_CXX_FLAGS="-march=armv8-a" \
   -DCMAKE_SYSTEM_PROCESSOR=aarch64 .
 cmake --build build_arm64 --target dropshell --config Release -j"$JOBS"
-mkdir -p build
-cp build_arm64/dropshell build/dropshell.arm64
+mkdir -p output
+cp build_arm64/dropshell output/dropshell.arm64
 
-if [ ! -f build/dropshell.amd64 ]; then
-    echo "build/dropshell.amd64 not found!" >&2
+if [ ! -f output/dropshell.amd64 ]; then
+    echo "output/dropshell.amd64 not found!" >&2
     exit 1
 fi
 
-if [ ! -f build/dropshell.arm64 ]; then
-    echo "build/dropshell.arm64 not found!" >&2
+if [ ! -f output/dropshell.arm64 ]; then
+    echo "output/dropshell.arm64 not found!" >&2
     exit 1
 fi
 
 echo "Builds complete:"
-ls -lh build/dropshell.*
+ls -lh output/dropshell.*
+
+cd $PREV_PWD

source/publish.sh

@@ -1,6 +1,10 @@
 #!/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"
@@ -11,27 +15,32 @@ else
     exit 1
 fi
 
+$SCRIPT_DIR/multibuild.sh
+BUILD_DIR=$SCRIPT_DIR/build
 
-./multibuild.sh
+OLD_PWD=$PWD
+cd $SCRIPT_DIR
 
-if [ ! -f "build/dropshell.amd64" ]; then
-    echo "build/dropshell.amd64 not found!" >&2
+
+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 "build/dropshell.arm64" ]; then
-    echo "build/dropshell.arm64 not found!" >&2
+if [ ! -f "output/dropshell.arm64" ]; then
+    echo "output/dropshell.arm64 not found!" >&2
     echo "Please run multibuild.sh first." >&2
     exit 1
 fi
 
-TAG=$(./build/dropshell.amd64 --version)
+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 . && git commit -m "dropshell release $TAG" && git push
+git add "$SCRIPT_DIR/../" && git commit -m "dropshell release $TAG" && git push
 
 
 # Find repo info from .git/config
@@ -73,8 +82,10 @@ fi
 
 # Upload binaries and install.sh
 for FILE in dropshell.amd64 dropshell.arm64 install.sh server_autosetup.sh; do
-    if [ -f "build/$FILE" ]; then
-        filetoupload="build/$FILE"
+    if [ -f "output/$FILE" ]; then
+        filetoupload="output/$FILE"
+    elif [ -f "../$FILE" ]; then
+        filetoupload="../$FILE"
     elif [ -f "$FILE" ]; then
         filetoupload="$FILE"
     else
@@ -93,3 +104,5 @@ for FILE in dropshell.amd64 dropshell.arm64 install.sh server_autosetup.sh; do
 done
 
 echo "Published dropshell version $TAG to $REPO_URL (tag $TAG) with binaries."
+
+cd $OLD_PWD

source/src/autogen/_agent.cpp

@@ -105,6 +105,22 @@ static bool _recreate_file_(const std::filesystem::path& outpath, uint64_t file_
 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";
@@ -265,36 +281,39 @@ bool recreate_tree(std::string destination_folder) {
             "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=";
+            "CiAgICAgICAgU0VSVklDRT0iJHtTRVJWSUNFX05BTUV9IgogICAgICAgIERPQ0tFUl9DTElfSElO"\
+            "VFM9ZmFsc2UKCiAgICAgICAgc2V0ICthCgogICAgICAgIF9jaGVja19yZXF1aXJlZF9lbnZfdmFy"\
+            "c19hbGxzZXJ2aWNlc3N0YXR1cyAiQ09ORklHX1BBVEgiICJTRVJWRVIiICJTRVJWSUNFIiAiQUdF"\
+            "TlRfUEFUSCIgIkhPU1RfTkFNRSIgIlRFTVBMQVRFIgoKICAgICAgICBpZiBbICIkY2FwdHVyZV9v"\
+            "dXRwdXQiID0gInRydWUiIF07IHRoZW4KICAgICAgICAgICAgIyBDYXB0dXJlIGFuZCByZXR1cm4g"\
+            "b3V0cHV0CiAgICAgICAgICAgIGJhc2ggIiR7c2VydmljZV9wYXRofS90ZW1wbGF0ZS8ke2NvbW1h"\
+            "bmR9LnNoIiAyPiYxCiAgICAgICAgZWxzZQogICAgICAgICAgICAjIFJ1biBzaWxlbnRseSBhbmQg"\
+            "cmV0dXJuIGV4aXQgY29kZQogICAgICAgICAgICBiYXNoICIke3NlcnZpY2VfcGF0aH0vdGVtcGxh"\
+            "dGUvJHtjb21tYW5kfS5zaCIgPiAvZGV2L251bGwgMj4mMQogICAgICAgIGZpCiAgICApCiAgICBD"\
+            "VVJSRU5UX0VYSVRfQ09ERT0kPwp9CgpmdW5jdGlvbiBjb21tYW5kX2V4aXN0cygpIHsKICAgIGxv"\
+            "Y2FsIHNlcnZpY2VfcGF0aD0kMQogICAgbG9jYWwgY29tbWFuZD0kMgogICAgaWYgWyAhIC1mICIk"\
+            "e3NlcnZpY2VfcGF0aH0vdGVtcGxhdGUvJHtjb21tYW5kfS5zaCIgXTsgdGhlbgogICAgICAgIHJl"\
+            "dHVybiAxCiAgICBmaQogICAgcmV0dXJuIDAKfQoKCmlmIFsgISAtZCAiJHtTRVJWSUNFU19QQVRI"\
+            "fSIgXTsgdGhlbgogICAgZWNobyAiU2VydmljZXMgcGF0aCBkb2VzIG5vdCBleGlzdDogJHtTRVJW"\
+            "SUNFU19QQVRIfSIKICAgIGV4aXQgMApmaQoKIyBHZXQgYWxsIHNlcnZpY2UgbmFtZXMKU0VSVklD"\
+            "RV9OQU1FUz0kKGxzICIke1NFUlZJQ0VTX1BBVEh9IikKCiMgSXRlcmF0ZSBvdmVyIGFsbCBzZXJ2"\
+            "aWNlIG5hbWVzCmZvciBTRVJWSUNFX05BTUUgaW4gJHtTRVJWSUNFX05BTUVTfTsgZG8KCiAgICBT"\
+            "RVJWSUNFX1BBVEg9JChyZWFscGF0aCAiJHtTRVJWSUNFU19QQVRIfS8ke1NFUlZJQ0VfTkFNRX0i"\
+            "KQoKICAgICMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogICAgIyBHZXQgdGhlIHNl"\
+            "cnZpY2UgaGVhbHRoCiAgICBpZiAhIGNvbW1hbmRfZXhpc3RzICIke1NFUlZJQ0VfUEFUSH0iICJz"\
+            "dGF0dXMiOyB0aGVuCiAgICAgICAgU0VSVklDRV9IRUFMVEg9InVua25vd24iCiAgICBlbHNlCiAg"\
+            "ICAgICAgcnVuX2NvbW1hbmQgIiR7U0VSVklDRV9QQVRIfSIgInN0YXR1cyIgImZhbHNlIgogICAg"\
+            "ICAgIGlmIFsgIiR7Q1VSUkVOVF9FWElUX0NPREV9IiAtZXEgMCBdOyB0aGVuCiAgICAgICAgICAg"\
+            "IFNFUlZJQ0VfSEVBTFRIPSJoZWFsdGh5IgogICAgICAgIGVsc2UKICAgICAgICAgICAgU0VSVklD"\
+            "RV9IRUFMVEg9InVuaGVhbHRoeSIKICAgICAgICBmaQogICAgZmkKCiAgICAjLS0tLS0tLS0tLS0t"\
+            "LS0tLS0tLS0tLS0tLS0tLS0tLS0KICAgICMgR2V0IHRoZSBzZXJ2aWNlIHBvcnRzCiAgICBpZiAh"\
+            "IGNvbW1hbmRfZXhpc3RzICIke1NFUlZJQ0VfUEFUSH0iICJwb3J0cyI7IHRoZW4KICAgICAgICBT"\
+            "RVJWSUNFX1BPUlRTPSIiCiAgICBlbHNlCiAgICAgICAgcnVuX2NvbW1hbmQgIiR7U0VSVklDRV9Q"\
+            "QVRIfSIgInBvcnRzIiAidHJ1ZSIKICAgICAgICBTRVJWSUNFX1BPUlRTPSIke0NVUlJFTlRfT1VU"\
+            "UFVUfSIKICAgIGZpCgogICAgIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgICAj"\
+            "IHJldHVybiB0aGUgaGVhbHRoIGFuZCBwb3J0cwogICAgZWNobyAiJHtTRVJWSUNFX05BTUV9X0hF"\
+            "QUxUSD0ke1NFUlZJQ0VfSEVBTFRIfSIKICAgIGVjaG8gIiR7U0VSVklDRV9OQU1FfV9QT1JUUz0k"\
+            "e1NFUlZJQ0VfUE9SVFN9Igpkb25lCg==";
 
         // Decode Base64 data
         size_t decoded_size = (strlen(filedata_base64) * 3) / 4;
@@ -302,7 +321,7 @@ bool recreate_tree(std::string destination_folder) {
         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);
+        bool file_written = _recreate_file_(outpath, 4669115953916396805ULL, std::filesystem::perms(493), decoded_data, actual_size);
         delete[] decoded_data;
         any_written = any_written || file_written;
     }
@@ -344,73 +363,69 @@ bool recreate_tree(std::string destination_folder) {
             "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=";
+            "KCkgewogICAgZWNobyAtZSAiRXJyb3I6ICQxIgogICAgZXhpdCAxCn0KCiMgQ3JlYXRlcy9zdGFy"\
+            "dHMgYSBjb250YWluZXIsIHZlcmlmeWluZyBpdCBydW5zLgpfY3JlYXRlX2FuZF9zdGFydF9jb250"\
+            "YWluZXIoKSB7CiAgICBpZiBbIC16ICIkMSIgXSB8fCBbIC16ICIkMiIgXTsgdGhlbgogICAgICAg"\
+            "IF9kaWUgIlRlbXBsYXRlIGVycm9yOiBjcmVhdGVfYW5kX3N0YXJ0X2NvbnRhaW5lciA8cnVuX2Nt"\
+            "ZD4gPGNvbnRhaW5lcl9uYW1lPiIKICAgIGZpCgogICAgbG9jYWwgcnVuX2NtZD0iJDEiCiAgICBs"\
+            "b2NhbCBjb250YWluZXJfbmFtZT0iJDIiCgogICAgaWYgX2lzX2NvbnRhaW5lcl9leGlzdHMgJGNv"\
+            "bnRhaW5lcl9uYW1lOyB0aGVuCiAgICAgICAgX2lzX2NvbnRhaW5lcl9ydW5uaW5nICRjb250YWlu"\
+            "ZXJfbmFtZSAmJiByZXR1cm4gMAogICAgICAgIF9zdGFydF9jb250YWluZXIgJGNvbnRhaW5lcl9u"\
+            "YW1lCiAgICBlbHNlCiAgICAgICAgJHJ1bl9jbWQKICAgIGZpCgogICAgaWYgISBfaXNfY29udGFp"\
+            "bmVyX3J1bm5pbmcgJGNvbnRhaW5lcl9uYW1lOyB0aGVuCiAgICAgICAgX2RpZSAiQ29udGFpbmVy"\
+            "ICR7Y29udGFpbmVyX25hbWV9IGZhaWxlZCB0byBzdGFydCIKICAgIGZpCgogICAgSUQ9JChfZ2V0"\
+            "X2NvbnRhaW5lcl9pZCAkY29udGFpbmVyX25hbWUpCiAgICBlY2hvICJDb250YWluZXIgJHtjb250"\
+            "YWluZXJfbmFtZX0gaXMgcnVubmluZyB3aXRoIElEICR7SUR9Igp9CgojIENyZWF0ZXMgYSBkaXJl"\
+            "Y3RvcnkgaWYgaXQgZG9lc24ndCBleGlzdCAoY2htb2QgNzc3KS4KX2NyZWF0ZV9mb2xkZXIoKSB7"\
+            "CiAgICBsb2NhbCBmb2xkZXI9IiQxIgogICAgaWYgWyAtZCAiJGZvbGRlciIgXTsgdGhlbgogICAg"\
+            "ICAgIHJldHVybiAwCiAgICBmaQogICAgaWYgISBta2RpciAtcCAiJGZvbGRlciI7IHRoZW4KICAg"\
+            "ICAgICBfZGllICJGYWlsZWQgdG8gY3JlYXRlIGZvbGRlcjogJGZvbGRlciIKICAgIGZpCiAgICBj"\
+            "aG1vZCA3NzcgIiRmb2xkZXIiCiAgICBlY2hvICJGb2xkZXIgY3JlYXRlZDogJGZvbGRlciIKfQoK"\
+            "IyBDaGVja3MgaWYgRG9ja2VyIGlzIGluc3RhbGxlZCwgcnVubmluZywgYW5kIHVzZXIgaGFzIHBl"\
+            "cm1pc3Npb24uIFJldHVybnMgMSBvbiBmYWlsdXJlLgpfY2hlY2tfZG9ja2VyX2luc3RhbGxlZCgp"\
+            "IHsKICAgIGlmICEgY29tbWFuZCAtdiBkb2NrZXIgJj4gL2Rldi9udWxsOyB0aGVuCiAgICAgICAg"\
+            "ZWNobyAiRG9ja2VyIGlzIG5vdCBpbnN0YWxsZWQiCiAgICAgICAgcmV0dXJuIDEKICAgIGZpCgog"\
+            "ICAgIyBjaGVjayBpZiBkb2NrZXIgZGFlbW9uIGlzIHJ1bm5pbmcKICAgIGlmICEgZG9ja2VyIGlu"\
+            "Zm8gJj4gL2Rldi9udWxsOyB0aGVuCiAgICAgICAgZWNobyAiRG9ja2VyIGRhZW1vbiBpcyBub3Qg"\
+            "cnVubmluZyIKICAgICAgICByZXR1cm4gMQogICAgZmkKCiAgICAjIGNoZWNrIGlmIHVzZXIgaGFz"\
+            "IHBlcm1pc3Npb24gdG8gcnVuIGRvY2tlcgogICAgaWYgISBkb2NrZXIgcnVuIC0tcm0gaGVsbG8t"\
+            "d29ybGQgJj4gL2Rldi9udWxsOyB0aGVuCiAgICAgICAgZWNobyAiVXNlciBkb2VzIG5vdCBoYXZl"\
+            "IHBlcm1pc3Npb24gdG8gcnVuIGRvY2tlciIKICAgICAgICByZXR1cm4gMQogICAgZmkKCiAgICBy"\
+            "ZXR1cm4gMAp9CgojIENoZWNrcyBpZiBhIGNvbnRhaW5lciAoYW55IHN0YXRlKSBleGlzdHMuIFJl"\
+            "dHVybnMgMSBpZiBub3QgZm91bmQuCl9pc19jb250YWluZXJfZXhpc3RzKCkgewogICAgaWYgISBk"\
+            "b2NrZXIgcHMgLWEgLS1mb3JtYXQgInt7Lk5hbWVzfX0iIHwgZ3JlcCAtcSAiXiQxJCI7IHRoZW4K"\
+            "ICAgICAgICByZXR1cm4gMQogICAgZmkKICAgIHJldHVybiAwCn0KCiMgQ2hlY2tzIGlmIGEgY29u"\
+            "dGFpbmVyIGlzIGN1cnJlbnRseSBydW5uaW5nLiBSZXR1cm5zIDEgaWYgbm90IHJ1bm5pbmcuCl9p"\
+            "c19jb250YWluZXJfcnVubmluZygpIHsKICAgIGlmICEgZG9ja2VyIHBzIC0tZm9ybWF0ICJ7ey5O"\
+            "YW1lc319IiB8IGdyZXAgLXEgIl4kMSQiOyB0aGVuCiAgICAgICAgcmV0dXJuIDEKICAgIGZpCiAg"\
+            "ICByZXR1cm4gMAp9CgojIFByaW50cyB0aGUgSUQgb2YgdGhlIG5hbWVkIGNvbnRhaW5lci4KX2dl"\
+            "dF9jb250YWluZXJfaWQoKSB7CiAgICBkb2NrZXIgcHMgLS1mb3JtYXQgInt7LklEfX0iIC0tZmls"\
+            "dGVyICJuYW1lPSQxIgp9CgojIFByaW50cyB0aGUgc3RhdHVzIHN0cmluZyBvZiB0aGUgbmFtZWQg"\
+            "Y29udGFpbmVyLgpfZ2V0X2NvbnRhaW5lcl9zdGF0dXMoKSB7CiAgICBkb2NrZXIgcHMgLS1mb3Jt"\
+            "YXQgInt7LlN0YXR1c319IiAtLWZpbHRlciAibmFtZT0kMSIKfQoKIyBTdGFydHMgYW4gZXhpc3Rp"\
+            "bmcsIHN0b3BwZWQgY29udGFpbmVyLgpfc3RhcnRfY29udGFpbmVyKCkgewogICAgX2lzX2NvbnRh"\
+            "aW5lcl9leGlzdHMgJDEgfHwgcmV0dXJuIDEKICAgIF9pc19jb250YWluZXJfcnVubmluZyAkMSAm"\
+            "JiByZXR1cm4gMAogICAgZG9ja2VyIHN0YXJ0ICQxCn0KCiMgU3RvcHMgYSBydW5uaW5nIGNvbnRh"\
+            "aW5lci4KX3N0b3BfY29udGFpbmVyKCkgewogICAgX2lzX2NvbnRhaW5lcl9ydW5uaW5nICQxIHx8"\
+            "IHJldHVybiAwOwogICAgZG9ja2VyIHN0b3AgJDEKfSAgIAoKIyBTdG9wcyAoaWYgbmVlZGVkKSBh"\
+            "bmQgcmVtb3ZlcyBhIGNvbnRhaW5lci4KX3JlbW92ZV9jb250YWluZXIoKSB7CiAgICBfc3RvcF9j"\
+            "b250YWluZXIgJDEKICAgIF9pc19jb250YWluZXJfZXhpc3RzICQxIHx8IHJldHVybiAwOwogICAg"\
+            "ZG9ja2VyIHJtICQxCn0KCiMgUHJpbnRzIHRoZSBsb2dzIGZvciBhIGNvbnRhaW5lci4KX2dldF9j"\
+            "b250YWluZXJfbG9ncygpIHsKICAgIGlmICEgX2lzX2NvbnRhaW5lcl9leGlzdHMgJDE7IHRoZW4K"\
+            "ICAgICAgICBlY2hvICJDb250YWluZXIgJDEgZG9lcyBub3QgZXhpc3QiCiAgICAgICAgcmV0dXJu"\
+            "IDEKICAgIGZpCgogICAgZG9ja2VyIGxvZ3MgJDEKfQoKIyBDaGVja3MgaWYgbGlzdGVkIGVudmly"\
+            "b25tZW50IHZhcmlhYmxlcyBhcmUgc2V0OyBjYWxscyBfZGllKCkgaWYgYW55IGFyZSBtaXNzaW5n"\
+            "LgpfY2hlY2tfcmVxdWlyZWRfZW52X3ZhcnMoKSB7CiAgICBsb2NhbCByZXF1aXJlZF92YXJzPSgi"\
+            "JEAiKQogICAgZm9yIHZhciBpbiAiJHtyZXF1aXJlZF92YXJzW0BdfSI7IGRvCiAgICAgICAgaWYg"\
+            "WyAteiAiJHshdmFyfSIgXTsgdGhlbgogICAgICAgICAgICBfZGllICJSZXF1aXJlZCBlbnZpcm9u"\
+            "bWVudCB2YXJpYWJsZSAkdmFyIGlzIG5vdCBzZXQiCiAgICAgICAgZmkKICAgIGRvbmUKfQoKIyBS"\
+            "ZW1vdmVzIGEgcGF0aCB1c2luZyBhIHJvb3QgRG9ja2VyIGNvbnRhaW5lciAoZm9yIHBlcm1pc3Np"\
+            "b25zKS4KX3Jvb3RfcmVtb3ZlX3RyZWUoKSB7CiAgICBsb2NhbCB0b19yZW1vdmU9IiQxIgogICAg"\
+            "cGFyZW50PSQoZGlybmFtZSAiJHRvX3JlbW92ZSIpCiAgICBhYnNfcGFyZW50PSQocmVhbHBhdGgg"\
+            "IiRwYXJlbnQiKQogICAgY2hpbGQ9JChiYXNlbmFtZSAiJHRvX3JlbW92ZSIpCiAgICBkb2NrZXIg"\
+            "cnVuIC0tcm0gLXYgIiRhYnNfcGFyZW50IjovZGF0YSBhbHBpbmUgcm0gLXJmICIvZGF0YS8kY2hp"\
+            "bGQiCn0KCgojIExvYWQgYXV0b2NvbW1hbmRzCnNvdXJjZSAiJHtBR0VOVF9QQVRIfS9kYXRhY29t"\
+            "bWFuZHMuc2gi";
 
         // Decode Base64 data
         size_t decoded_size = (strlen(filedata_base64) * 3) / 4;
@@ -418,7 +433,7 @@ bool recreate_tree(std::string destination_folder) {
         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);
+        bool file_written = _recreate_file_(outpath, 6967493376886731479ULL, std::filesystem::perms(493), decoded_data, actual_size);
         delete[] decoded_data;
         any_written = any_written || file_written;
     }

source/src/autogen/version.hpp

@@ -1,15 +1,11 @@
+// version.hpp (dummy for linter/IntelliSense)
 #pragma once
 
-// DUMMY VERSION - replaced by build process.
-
 #include <string>
 
 namespace dropshell {
-
-// Version information
-const std::string VERSION = "DEV";
-const std::string RELEASE_DATE = "NEVER";
-const std::string AUTHOR = "j842";
-const std::string LICENSE = "MIT";
-
-} // 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/create-service.cpp

@@ -17,9 +17,9 @@ namespace dropshell
     static std::vector<std::string> create_service_name_list = {"create-service"};
 
     // Static registration
-    struct UninstallCommandRegister
+    struct CreateServiceCommandRegister
     {
-        UninstallCommandRegister()
+        CreateServiceCommandRegister()
         {
             CommandRegistry::instance().register_command({create_service_name_list,
                                                           create_service_handler,

source/src/commands/edit.cpp

@@ -75,7 +75,7 @@ bool edit_file(const std::string &file_path, bool has_bb64)
     std::cout << "Editing file: " << file_path << std::endl;
 
     if (has_bb64) {
-        return execute_local_command(editor_cmd, nullptr, cMode::Interactive);
+        return execute_local_command("", editor_cmd, {}, nullptr, cMode::Interactive);
     }
     else {
         // might not have bb64 at this early stage. Direct edit.

source/src/commands/help.cpp

@@ -57,10 +57,13 @@ void help_autocomplete(const CommandContext& ctx) {
 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);
+    print_left_aligned(cmd_info->help_usage, 32);
     std::cout << cmd_info->help_description << std::endl;
 }
 
@@ -119,6 +122,16 @@ int help_handler(const CommandContext& ctx) {
     {
         // show more!
         show_command("list");
+        std::cout << std::endl;
+        show_command("install");
+        show_command("uninstall");
+        show_command("nuke");
+        std::cout << std::endl;
+        show_command("start");
+        show_command("stop");
+        std::cout << std::endl;
+        show_command("ssh");
+        std::cout << std::endl;
     }
     return 0;
 }

source/src/commands/install.cpp

@@ -7,6 +7,7 @@
 #include "utils/hash.hpp"
 #include "autogen/_agent.hpp"
 #include "services.hpp"
+#include "utils/output.hpp"
 
 #include <unistd.h>
 #include <cstring>
@@ -35,8 +36,8 @@ namespace dropshell
                                                           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.",
+                                                          "install [SERVER] [SERVICE|all]",
+                                                          "Install/reinstall host, remote servers, or service(s). Safe/non-destructive way to update.",
                                                           // heredoc
                                                           R"(
             Install components on a server. This is safe to re-run (non-destructive) and used to update
@@ -100,7 +101,7 @@ namespace dropshell
         }
 
         // Copy template files
-        std::cout << "Copying: [LOCAL] " << tinfo.local_template_path() << std::endl
+        debug << "Copying: [LOCAL] " << tinfo.local_template_path() << std::endl
                   << std::string(8, ' ') << "[REMOTE] " << remotepath::service_template(server, service) << "/" << std::endl;
         if (!shared_commands::rsync_tree_to_remote(tinfo.local_template_path().string(), remotepath::service_template(server, service),
                                   server_env, silent))
@@ -110,7 +111,7 @@ namespace dropshell
         }
 
         // Copy service files
-        std::cout << "Copying: [LOCAL] " << localpath::service(server, service) << std::endl
+        debug << "Copying: [LOCAL] " << localpath::service(server, service) << std::endl
                   << std::string(8, ' ') << "[REMOTE] " << remotepath::service_config(server, service) << std::endl;
         if (!shared_commands::rsync_tree_to_remote(localpath::service(server, service), remotepath::service_config(server, service),
                                   server_env, silent))
@@ -121,11 +122,12 @@ namespace dropshell
 
         // Run install script
         {
+            info << "Running " << service_info.template_name << " install script on " << server << "..." << std::endl;
             server_env.run_remote_template_command(service, "install", {}, silent, {});
         }
 
         // print health tick
-        std::cout << "Health: " << shared_commands::healthtick(server, service) << std::endl;
+        info << "Health: " << shared_commands::healthtick(server, service) << std::endl;
         return true;
     }
 
@@ -280,28 +282,30 @@ namespace dropshell
     int install_server(const std::string &server)
     {
         // install the dropshell agent on the given server.
-        std::cout << "Installing dropshell agent on " << server << std::endl;
+        maketitle("Installing dropshell agent on " + server, sColour::INFO);
 
         std::string agent_path = remotepath::agent(server);
         if (agent_path.empty())
         {
-            std::cerr << "Failed to get agent path for " << server << std::endl;
+            error << "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;
+            error << "Invalid server environment for " << server << std::endl;
             return 1;
         }
 
         // now create the agent.
         // copy across from the local agent files.
+        info << "Copying local agent files to remote server... " << std::flush;
         shared_commands::rsync_tree_to_remote(localpath::files_for_remote_agent(), agent_path, server_env, false);
+        info << "done." << std::endl;
 
         // add in bb64. We can't use execute_remote_command() here, as that relies on bb64 which we're installing!
-        std::cout << "Installing bb64 on " << server << std::endl << std::flush;
+        info << "Installing bb64 on " << server << "..." << std::endl << std::flush;
 
         std::string remote_cmd =
             "ssh -p " + server_env.get_SSH_INFO().port + " " + server_env.get_SSH_INFO().user + "@" + server_env.get_SSH_INFO().host +
@@ -309,21 +313,20 @@ namespace dropshell
             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;
+        if (!execute_local_command("", remote_cmd, {}, nullptr, cMode::Silent))
+            error << "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;
+            debug << "Downloaded bb64 to " << agent_path << " on remote server." << std::endl;
 
-        // just test all is ok
-        std::string output;
-        bool okay = execute_ssh_command(server_env.get_SSH_INFO(), sCommand(agent_path, "./bb64 -i VGhlIGRyb3BzaGVsbCByZW1vdGUgYWdlbnQgaXMgY29ycmVjdGx5IGluc3RhbGxlZC4=", {}), cMode::CaptureOutput, &output);
+        // run the self-test.
+        bool okay = execute_ssh_command(server_env.get_SSH_INFO(), sCommand(agent_path, "./selftest.sh", {}), cMode::Defaults, nullptr);
         if (!okay)
         {
-            std::cerr << "Failed to install bb64 on " << server << std::endl;
+            error << "ERROR: Failed to install remote agent on " << server << std::endl;
             return 1;
         }
 
-        std::cout << output << std::endl;
+        info << "Installation on " << server << " complete." << std::endl;
         return 0; 
     }
 
@@ -339,7 +342,7 @@ namespace dropshell
 
         if (!gConfig().is_config_set())
         {
-            std::cerr << "Error: Dropshell is not configured. Please run 'dropshell edit' to configure it." << std::endl;
+            error << "Dropshell is not configured. Please run 'dropshell edit' to configure it." << std::endl;
             return 1;
         }
 

source/src/commands/list.cpp

@@ -7,6 +7,7 @@
 #include "tableprint.hpp"
 #include "transwarp.hpp"
 #include "server_env_manager.hpp"
+#include "services.hpp"
 
 #include <unistd.h>
 #include <cstring>
@@ -62,7 +63,7 @@ int list_handler(const CommandContext& ctx) {
         return 0;
     }
 
-    std::cout << "List handler called with " << ctx.args.size() << " args\n";
+    debug << "List handler called with " << ctx.args.size() << " args\n";
     return 0;
 }
 
@@ -73,16 +74,16 @@ 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;
+        error << "No servers found" << std::endl;
+        info << "Please run 'dropshell edit' to set up dropshell." << std::endl;
+        info << "Then run 'dropshell create-server' to create a server." << std::endl;
         return;
     }
 
     tableprint tp("All DropShell Servers");
     tp.add_row({"Name", "User", "Address", "Health", "Ports"});
 
-    std::cout << "Checking "<<servers.size() << " servers: " << std::flush;
+    info << "Checking "<<servers.size() << " servers: " << std::flush;
     int checked = 0;
 
     transwarp::parallel exec{servers.size()};
@@ -102,10 +103,10 @@ void list_servers() {
         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;
+        info << checked << " ✓  " << std::flush;
     });
     task->wait();
-    std::cout << std::endl << std::endl;
+    info << std::endl << std::endl;
     tp.print();
 }
 
@@ -115,7 +116,7 @@ void list_servers() {
 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;
+        error << "Error: Invalid server environment file: " << server_name << std::endl;
         return;
     }
 
@@ -125,14 +126,14 @@ void show_server_details(const std::string& server_name) {
     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;
+        info << std::endl << "Server Status:" << std::endl;
+        info << std::string(40, '-') << std::endl;
         
         // Try to connect to the server
-        std::string cmd = "ssh -o ConnectTimeout=5 " + ssh_user + "@" + ssh_address + " -p " + ssh_port + " 'echo connected' 2>/dev/null";
+        std::string cmd = "ssh -o ConnectTimeout=5 " + ssh_user + "@" + ssh_address + " -p " + ssh_port + " 'true' 2>/dev/null";
         int result = system(cmd.c_str());
         if (result == 0) {
-            std::cout << "Status: Online" << std::endl;
+            info << "Status: Online" << std::endl;
             
             // // Get uptime if possible
             // cmd = "ssh " + ssh_address + " 'uptime' 2>/dev/null";
@@ -141,10 +142,10 @@ void show_server_details(const std::string& server_name) {
             //     std::cout << "Error: Failed to get uptime" << std::endl;
             // } 
         } else {
-            std::cout << "Status: Offline" << std::endl;
+            warning << "Status: Offline" << std::endl;
         }
     }
-    std::cout << std::endl;
+    info << std::endl;
 
     //---------------------
     {
@@ -161,7 +162,7 @@ void show_server_details(const std::string& server_name) {
     // list services, and run healthcheck on each
     {
         tableprint tp("Services: " + server_name, false);
-        tp.add_row({"Status", "Service", "Ports"});
+        tp.add_row({"Status", "Service", "Template","Ports"});
         
 
         std::map<std::string, shared_commands::ServiceStatus> status = shared_commands::get_all_services_status(server_name); 
@@ -175,7 +176,7 @@ void show_server_details(const std::string& server_name) {
             for (const auto& port : service_status.ports) 
                 ports_str += std::to_string(port) + " ";
         
-            tp.add_row({healthy, service_name, ports_str});
+            tp.add_row({healthy, service_name, get_service_info(server_name,service_name).template_name, ports_str});
         } // end of for (const auto& service : services)
         tp.print();
     } // end of list services

source/src/commands/nuke.cpp

@@ -10,8 +10,6 @@
 
 #include "utils/assert.hpp"
 
-#pragma message ("TODO: Fix issues with Nuke below.")
-
 namespace dropshell {
 
 int nuke_handler(const CommandContext& ctx);
@@ -33,9 +31,16 @@ struct NukeCommandRegister {
             "Nuke a service on a server. Destroys everything, both local and remote!",
             // heredoc
             R"(
-            Nuke a service on a server. Destroys everything, both local and remote!
+            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!
             )"
         });
     }
@@ -60,11 +65,14 @@ int nuke_one(std::string server, std::string service)
             // otherwise just uninstall.
             if (gTemplateManager().template_command_exists(service_info.template_name, "nuke"))
             {
+                std::cout << "Running nuke script for " << service << " on " << server << std::endl;
                 if (!server_env.run_remote_template_command(service, "nuke", {}, false, {}))
                     std::cerr << "Warning: Failed to run nuke script: " << service << std::endl;
             }
             else
             {
+                std::cout << "No nuke script found for " << service << " on " << server << std::endl;
+                std::cout << "Running uninstall script instead and will clean directories." << std::endl;
                 if (!server_env.run_remote_template_command(service, "uninstall", {}, false, {}))
                     std::cerr << "Warning: Failed to uninstall service: " << service << std::endl;
             }

source/src/commands/shared_commands.cpp

@@ -62,7 +62,7 @@ namespace dropshell
                                 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));
+        return execute_local_command("", rsync_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
     }
 
     // ------------------------------------------------------------------------------------------------
@@ -119,7 +119,11 @@ namespace dropshell
         }
 
         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))
+        if (!execute_ssh_command(env.get_SSH_INFO(), sCommand(remotepath::agent(server_name), 
+            "./_allservicesstatus.sh", 
+            {{"HOST_NAME", server_name}, {"SERVER", server_name}, {"AGENT_PATH", remotepath::agent(server_name)}}), 
+            cMode::CaptureOutput | cMode::Silent, 
+            &output))
             return status;
 
         std::stringstream ss(output);

source/src/commands/ssh.cpp

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

source/src/commands/start.cpp

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

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

@@ -31,16 +31,16 @@ namespace dropshell
                                                           "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 all       uninstall all services on the given server.
+            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)
@@ -81,7 +81,6 @@ namespace dropshell
         return true;
     }
 
-
     int uninstall_handler(const CommandContext &ctx)
     {
         if (ctx.args.size() < 1)
@@ -109,5 +108,4 @@ namespace dropshell
         return uninstall_service(server, service) ? 0 : 1;
     }
 
-
 } // namespace dropshell

source/src/main.cpp

@@ -8,6 +8,7 @@
 #include "autocomplete.hpp"
 #include "utils/hash.hpp"
 #include "command_registry.hpp"
+#include "output.hpp"
 
 #include <filesystem>
 #include <iostream>

source/src/server_env_manager.cpp

@@ -204,7 +204,7 @@ bool server_env_manager::run_remote_template_command(const std::string &service_
 
     if (scommand->get_command_to_run().empty())
         return false;
-    cMode mode = (command=="ssh") ? (cMode::Interactive) : cMode::Silent;
+    cMode mode = (command=="ssh") ? (cMode::Interactive) : (silent ? cMode::Silent : cMode::Defaults);
     return execute_ssh_command(get_SSH_INFO(), scommand.value(), mode);
 }
 

source/src/service_runner.cpp

@@ -147,7 +147,7 @@ bool service_runner::fullnuke()
     }  
     
     std::string rm_cmd = "rm -rf " + quote(local_service_path);
-    if (!execute_local_command(rm_cmd, nullptr, cMode::Silent)) {
+    if (!execute_local_command("", rm_cmd, {}, nullptr, cMode::Silent)) {
         std::cerr << "Failed to remove service directory" << std::endl;
         return false;
     }
@@ -267,13 +267,13 @@ bool service_runner::interactive_ssh_service()
 bool service_runner::scp_file_to_remote(const std::string &local_path, const std::string &remote_path, bool silent)
 {
     std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " + quote(local_path) + " " + mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + quote(remote_path) + (silent ? " > /dev/null 2>&1" : "");
-    return execute_local_command(scp_cmd, nullptr, (silent ? cMode::Silent : cMode::Defaults));
+    return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
 }
 
 bool service_runner::scp_file_from_remote(const std::string &remote_path, const std::string &local_path, bool silent)
 {
     std::string scp_cmd = "scp -P " + mServerEnv.get_SSH_PORT() + " " + mServerEnv.get_SSH_USER() + "@" + mServerEnv.get_SSH_HOST() + ":" + quote(remote_path) + " " + quote(local_path) + (silent ? " > /dev/null 2>&1" : "");
-    return execute_local_command(scp_cmd, nullptr, (silent ? cMode::Silent : cMode::Defaults));
+    return execute_local_command("", scp_cmd, {}, nullptr, (silent ? cMode::Silent : cMode::Defaults));
 }
 
 bool service_runner::restore(std::string backup_file, bool silent)

source/src/services.cpp

@@ -176,6 +176,7 @@ bool get_all_service_env_vars(const std::string &server_name, const std::string
     all_env_vars["SERVICE"] = service_name;
     all_env_vars["AGENT_PATH"] = remotepath::agent(server_name);
     all_env_vars["HOST_NAME"] = server_info.ssh_host;
+    all_env_vars["DOCKER_CLI_HINTS"] = "false"; // turn off docker junk.
 
     // Lambda function to load environment variables from a file
     auto load_env_file = [&all_env_vars](const std::string& file) {

source/src/utils/assert.hpp

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

source/src/utils/execute.cpp

@@ -13,6 +13,7 @@
 #include "utils/b64ed.hpp"
 #include "config.hpp"
 #include "utils/directories.hpp"
+#include "utils/output.hpp"
 
 namespace dropshell
 {
@@ -21,6 +22,10 @@ namespace dropshell
         return (ret != -1 && WIFEXITED(ret) && (WEXITSTATUS(ret) == 0)); // ret is -1 if the command failed to execute.
     }
 
+
+    // ----------------------------------------------------------------------------------------------------------
+    // execute_local_command_interactive
+    // ----------------------------------------------------------------------------------------------------------
     bool execute_local_command_interactive(const sCommand &command)
     {
         if (command.get_command_to_run().empty())
@@ -51,30 +56,59 @@ namespace dropshell
         }
     }
 
-    bool execute_local_command_and_capture_output(const sCommand &command, std::string *output)
+    // ----------------------------------------------------------------------------------------------------------
+    // execute_local_command
+    // ----------------------------------------------------------------------------------------------------------
+
+    class fancypinter
     {
-        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)
+        public:
+        fancypinter(sColour startColour) : startColour_(startColour), currentColour_(startColour) {}
+
+        void print_chunk(std::string chunk)
         {
-            return false;
+            if (chunk.empty())
+                return;
+
+            if (newline_)
+            {
+                // sniff the mode... if the string starts with warning or warning: then set mode to WARNING. etc.
+                if (chunk.find("warning") == 0)
+                    currentColour_ = sColour::WARNING;
+                else if (chunk.find("error") == 0)
+                    currentColour_ = sColour::ERROR;
+                else if (chunk.find("debug") == 0)
+                    currentColour_ = sColour::DEBUG;
+                else if (chunk.find("info") == 0)
+                    currentColour_ = sColour::INFO;
+                else
+                    currentColour_ = startColour_;    
             }
-        char buffer[128];
-        while (fgets(buffer, sizeof(buffer), pipe) != nullptr)
-        {
-            (*output) += buffer;
-        }
-        int ret = pclose(pipe);
-        return EXITSTATUSCHECK(ret);
+            colourstream(currentColour_) << chunk;
+            newline_ = (chunk[chunk.size()-1] == '\n');
         }
 
-    bool execute_local_command(std::string command, std::string *output, cMode mode)
-    {
-        return execute_local_command("", command, {}, output, mode);
+        void print(const std::string& buffer) {
+            size_t start = 0;
+            while (start < buffer.size()) {
+                size_t newline_pos = buffer.find('\n', start);
+                if (newline_pos == std::string::npos) {
+                    if (start < buffer.size()) {
+                        print_chunk(buffer.substr(start));
                     }
+                    break;
+                }
+                print_chunk(buffer.substr(start, newline_pos - start + 1)); // include the newline
+                start = newline_pos + 1;
+            }
+        }
+
+        private:
+        bool newline_ = true;
+        sColour startColour_;
+        sColour currentColour_;
+    };
+
 
     bool execute_local_command(std::string directory_to_run_in, std::string command_to_run, const std::map<std::string, std::string> &env_vars, std::string *output, cMode mode)
     {
@@ -88,29 +122,36 @@ namespace dropshell
             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::string full_cmd = command.construct_cmd(localpath::agent()) + (hasFlag(mode, cMode::CaptureOutput) ? " 2>&1" : ""); // capture both stdout and stderr
+
+        FILE *pipe = popen(full_cmd.c_str(), "r");
+        if (!pipe)
         {
-            std::cerr << "Error: Failed to execute command: " << std::endl;
-            std::cerr << full_cmd << std::endl;
+            return false;
         }
-        return ok;
+        char buffer[128];
+        fancypinter fancyprint(sColour::DEBUG);
+        while (fgets(buffer, sizeof(buffer), pipe) != nullptr)
+        {
+            if (output != nullptr)
+               (*output) += buffer;
+
+            if (!silent)
+                fancyprint.print(buffer);
+        }
+        int ret = pclose(pipe);
+        return EXITSTATUSCHECK(ret);
     }
 
+    // ----------------------------------------------------------------------------------------------------------
+    // execute_ssh_command
+    // ----------------------------------------------------------------------------------------------------------
     bool execute_ssh_command(const sSSHInfo &ssh_info, const sCommand &remote_command, cMode mode, std::string *output)
     {
         if (remote_command.get_command_to_run().empty())
@@ -144,6 +185,9 @@ namespace dropshell
         return rval;
     }
 
+    // ----------------------------------------------------------------------------------------------------------
+    // makesafecmd
+    // ----------------------------------------------------------------------------------------------------------
     std::string sCommand::makesafecmd(std::string agent_path, const std::string &command) const
     {
         if (command.empty())
@@ -153,6 +197,9 @@ namespace dropshell
         return commandstr;
     }
 
+    // ----------------------------------------------------------------------------------------------------------
+    // construct_cmd
+    // ----------------------------------------------------------------------------------------------------------
     std::string sCommand::construct_cmd(std::string agent_path) const
     {
         if (mCmd.empty())

source/src/utils/execute.hpp

@@ -31,7 +31,6 @@ typedef struct sSSHInfo {
     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);
 

source/src/utils/output.cpp

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

source/src/utils/output.hpp

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

source/src/utils/utils.cpp

@@ -10,10 +10,10 @@
 
 namespace dropshell {
 
-void maketitle(const std::string& title) {
-    std::cout << std::string(title.length() + 4, '-') << std::endl;
-    std::cout << "| " << title << " |" << std::endl;
-    std::cout << std::string(title.length() + 4, '-') << std::endl;
+void maketitle(const std::string& title, sColour colour) {
+    colourstream(colour) << std::string(title.length() + 4, '-') << std::endl;
+    colourstream(colour) << "| " << title << " |" << std::endl;
+    colourstream(colour) << std::string(title.length() + 4, '-') << std::endl;
 }
 
 bool replace_line_in_file(const std::string& file_path, const std::string& search_string, const std::string& replacement_line) {

source/src/utils/utils.hpp

@@ -3,6 +3,8 @@
 #include <string>
 #include <vector>
 
+#include "output.hpp"
+
 namespace dropshell {
 
 /**
@@ -10,7 +12,7 @@ namespace dropshell {
  * 
  * @param title The title string to display
  */
-void maketitle(const std::string& title);
+void maketitle(const std::string& title, sColour colour=sColour::INFO);
 
 bool replace_line_in_file(const std::string& file_path, const std::string& search_string, const std::string& replacement_line);