dropshell release 2025.0519.0021

source/agent-local/agent-install.sh

@@ -0,0 +1,83 @@
+#!/bin/bash
+
+SCRIPT_DIR=$(dirname "$0")
+
+echo "Installing dropshell host agent on this computer..."
+
+
+# Prints an error message in red and exits with status code 1.
+_die() {
+    echo -e "Error: $1"
+    exit 1
+}
+
+
+# Checks if listed environment variables are set; calls _die() if any are missing.
+_check_required_env_vars() {
+    local required_vars=("$@")
+    for var in "${required_vars[@]}"; do
+        if [ -z "${!var}" ]; then
+            _die "Required environment variable $var is not set"
+        fi
+    done
+}
+
+# Checks if Docker is installed, running, and user has permission. Returns 1 on failure.
+_check_docker_installed() {
+    if ! command -v docker &> /dev/null; then
+        echo "Docker is not installed"
+        return 1
+    fi
+
+    # check if docker daemon is running
+    if ! docker info &> /dev/null; then
+        echo "Docker daemon is not running"
+        return 1
+    fi
+
+    # check if user has permission to run docker
+    if ! docker run --rm hello-world &> /dev/null; then
+        echo "User does not have permission to run docker"
+        return 1
+    fi
+
+    return 0
+}
+
+function install_bb64() {    
+    # check curl installed
+    if ! command -v curl &> /dev/null; then
+        _die "Curl is not installed. Curl is required for agent installation."
+    fi
+
+    curl -fsSL "https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh" | bash -s -- "$AGENT_PATH" "$(id -u $USER):$(id -g $USER)"
+
+    # test result code from curl
+    if [ $? -ne 0 ]; then
+        _die "Failed to install bb64. Curl returned non-zero exit code."
+    fi
+
+    # test if bb64 is installed
+    "$AGENT_PATH/bb64" -v
+    if [ $? -ne 0 ]; then
+        _die "bb64 did not install correctly."
+    fi
+
+    echo "bb64 installed successfully."
+    return 0;
+}
+
+
+#-------------------------------------------------------------------------
+
+set -a
+AGENT_PATH="$SCRIPT_DIR"
+set +a
+
+_check_required_env_vars "AGENT_PATH"
+echo "Installing host agent into $AGENT_PATH"
+
+_check_docker_installed || _die "Docker is required."
+
+install_bb64
+

source/agent-remote/agent-install.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+
+# This script is used to install the dropshell agent on a remote server.
+
+SCRIPT_DIR=$(dirname "$0")
+
+set -a
+
+AGENT_PATH="$SCRIPT_DIR"
+
+set +a
+
+
+if [ -f "$SCRIPT_DIR/common.sh" ]; then
+    source "$SCRIPT_DIR/common.sh"
+else
+    echo "Error: common.sh not found in $SCRIPT_DIR"
+    exit 1
+fi
+
+_check_required_env_vars "AGENT_PATH"
+
+function install_bb64() {    
+    # check curl installed
+    if ! command -v curl &> /dev/null; then
+        _die "Curl is not installed. Curl is required for agent installation."
+    fi
+
+    curl -fsSL "https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh" | bash -s -- "$AGENT_PATH" "$(id -u $USER):$(id -g $USER)"
+
+    # test result code from curl
+    if [ $? -ne 0 ]; then
+        _die "Failed to install bb64. Curl returned non-zero exit code."
+    fi
+
+    # test if bb64 is installed
+    "$AGENT_PATH/bb64" -v
+    if [ $? -ne 0 ]; then
+        _die "bb64 did not install correctly."
+    fi
+
+    echo "bb64 installed successfully."
+    return 0;
+}
+
+#-------------------------------------------------------------------------
+
+echo "Installing dropshell agent..."
+
+install_bb64
+
+
+
+#-------------------------------------------------------------------------
+
+echo "Running remote agent self-test..."
+
+
+#-------------------------------------------------------------------------
+
+echo "Completed remote agent self-test."
+
+
+#-------------------------------------------------------------------------
+
+echo "Completed dropshell agent installation."
+
+#-------------------------------------------------------------------------
+
+exit 0

source/agent-remote/datacommands.sh

@@ -47,7 +47,7 @@ _autocommandrun_path() {
             local path_parent=$(dirname ${path})
             local path_child=$(basename ${path})
             if [ -d "${path_parent}/${path_child}" ]; then
-                docker run --rm -v ${path_parent}:/volume debian bash -c "rm -rf /volume/${path_child}" || echo "Failed to nuke path ${path}"
+                docker run --rm -v ${path_parent}:/volume debian bash -c "rm -rfv /volume/${path_child}" || echo "Failed to nuke path ${path}"
             else
                 echo "Path ${path} does not exist - nothing to nuke"
             fi
@@ -61,8 +61,14 @@ _autocommandrun_path() {
             fi
             ;;
         restore)
-            echo "Restoring path ${path} from backup file ${backup_folder}/backup.tgz"
+            if [ ! -f "${backup_folder}/backup.tgz" ]; then
-            tar -xzvf ${backup_folder}/backup.tgz -C ${path} --strip-components=1
+                echo "Backup file ${backup_folder}/backup.tgz does not exist - nothing to restore"
+            else
+                echo "Clearing existing data in path ${path}"
+                docker run --rm -v ${path}:/path debian bash -c "rm -rfv /path/{*,.*}"
+                echo "Restoring path ${path} from backup file ${backup_folder}/backup.tgz"
+                tar -xzvf ${backup_folder}/backup.tgz -C ${path} --strip-components=1
+            fi
             ;;
     esac
 }
@@ -91,7 +97,8 @@ _autocommandrun_file() {
         restore)
             echo "Restoring file ${filepath}"
             local file_name=$(basename ${filepath})
-            cp ${backup_folder}/${file_name} ${filepath}
+            rm -f ${filepath} || die "Unable to remove existing file ${filepath}, restore failed."
+            cp ${backup_folder}/${file_name} ${filepath} || die "Unable to copy file ${backup_folder}/${file_name} to ${filepath}, restore failed."
             ;;
     esac
 }

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/make_createagent.sh

@@ -14,6 +14,5 @@ if ! command -v dehydrate &> /dev/null; then
     curl -fsSL https://gitea.jde.nz/public/dehydrate/releases/download/latest/install.sh | bash
 fi
 
-SCRIPT_DIR=$(dirname "$0")
+dehydrate "${SCRIPT_DIR}/agent-remote" "${SCRIPT_DIR}/src/autogen"
-
+dehydrate "${SCRIPT_DIR}/agent-local" "${SCRIPT_DIR}/src/autogen"
-dehydrate "${SCRIPT_DIR}/agent" "${SCRIPT_DIR}/src/autogen"

source/src/autogen/_agent-local.cpp

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

source/src/autogen/_agent-local.hpp

@@ -10,6 +10,6 @@
 
 
 #include <string>
-namespace recreate_agent {
+namespace recreate_agent_local {
     bool recreate_tree(std::string destination_folder);
 }

source/src/autogen/_agent-remote.cpp

@@ -12,8 +12,8 @@
 */
 
 
-#include "_agent.hpp"
+#include "_agent-remote.hpp"
-namespace recreate_agent {
+namespace recreate_agent_remote {
 
 
 // Tiny dependency-free FNV-1a 64-bit hash
@@ -105,22 +105,6 @@ 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";
@@ -152,82 +136,91 @@ bool recreate_tree(std::string destination_folder) {
             "ICAgbG9jYWwgcGF0aF9jaGlsZD0kKGJhc2VuYW1lICR7cGF0aH0pCiAgICAgICAgICAgIGlmIFsg"\
             "LWQgIiR7cGF0aF9wYXJlbnR9LyR7cGF0aF9jaGlsZH0iIF07IHRoZW4KICAgICAgICAgICAgICAg"\
             "IGRvY2tlciBydW4gLS1ybSAtdiAke3BhdGhfcGFyZW50fTovdm9sdW1lIGRlYmlhbiBiYXNoIC1j"\
-            "ICJybSAtcmYgL3ZvbHVtZS8ke3BhdGhfY2hpbGR9IiB8fCBlY2hvICJGYWlsZWQgdG8gbnVrZSBw"\
+            "ICJybSAtcmZ2IC92b2x1bWUvJHtwYXRoX2NoaWxkfSIgfHwgZWNobyAiRmFpbGVkIHRvIG51a2Ug"\
-            "YXRoICR7cGF0aH0iCiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgIGVjaG8gIlBhdGgg"\
+            "cGF0aCAke3BhdGh9IgogICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICBlY2hvICJQYXRo"\
-            "JHtwYXRofSBkb2VzIG5vdCBleGlzdCAtIG5vdGhpbmcgdG8gbnVrZSIKICAgICAgICAgICAgZmkK"\
+            "ICR7cGF0aH0gZG9lcyBub3QgZXhpc3QgLSBub3RoaW5nIHRvIG51a2UiCiAgICAgICAgICAgIGZp"\
-            "ICAgICAgICAgICAgOzsKICAgICAgICBiYWNrdXApCiAgICAgICAgICAgIGVjaG8gIkJhY2tpbmcg"\
+            "CiAgICAgICAgICAgIDs7CiAgICAgICAgYmFja3VwKQogICAgICAgICAgICBlY2hvICJCYWNraW5n"\
-            "dXAgcGF0aCAke3BhdGh9IgogICAgICAgICAgICBpZiBbIC1kICIke3BhdGh9IiBdOyB0aGVuCiAg"\
+            "IHVwIHBhdGggJHtwYXRofSIKICAgICAgICAgICAgaWYgWyAtZCAiJHtwYXRofSIgXTsgdGhlbgog"\
-            "ICAgICAgICAgICAgICBkb2NrZXIgcnVuIC0tcm0gLXYgJHtwYXRofTovcGF0aCAtdiAke2JhY2t1"\
+            "ICAgICAgICAgICAgICAgZG9ja2VyIHJ1biAtLXJtIC12ICR7cGF0aH06L3BhdGggLXYgJHtiYWNr"\
-            "cF9mb2xkZXJ9Oi9iYWNrdXAgZGViaWFuIGJhc2ggLWMgInRhciAtY3p2ZiAvYmFja3VwL2JhY2t1"\
+            "dXBfZm9sZGVyfTovYmFja3VwIGRlYmlhbiBiYXNoIC1jICJ0YXIgLWN6dmYgL2JhY2t1cC9iYWNr"\
-            "cC50Z3ogLUMgL3BhdGggLiAmJiBjaG93biAtUiAkTVlJRDokTVlHUlAgL2JhY2t1cCIKICAgICAg"\
+            "dXAudGd6IC1DIC9wYXRoIC4gJiYgY2hvd24gLVIgJE1ZSUQ6JE1ZR1JQIC9iYWNrdXAiCiAgICAg"\
-            "ICAgICAgZWxzZQogICAgICAgICAgICAgICAgZWNobyAiUGF0aCAke3BhdGh9IGRvZXMgbm90IGV4"\
+            "ICAgICAgIGVsc2UKICAgICAgICAgICAgICAgIGVjaG8gIlBhdGggJHtwYXRofSBkb2VzIG5vdCBl"\
-            "aXN0IC0gbm90aGluZyB0byBiYWNrdXAiCiAgICAgICAgICAgIGZpCiAgICAgICAgICAgIDs7CiAg"\
+            "eGlzdCAtIG5vdGhpbmcgdG8gYmFja3VwIgogICAgICAgICAgICBmaQogICAgICAgICAgICA7Owog"\
-            "ICAgICAgcmVzdG9yZSkKICAgICAgICAgICAgZWNobyAiUmVzdG9yaW5nIHBhdGggJHtwYXRofSBm"\
+            "ICAgICAgIHJlc3RvcmUpCiAgICAgICAgICAgIGlmIFsgISAtZiAiJHtiYWNrdXBfZm9sZGVyfS9i"\
-            "cm9tIGJhY2t1cCBmaWxlICR7YmFja3VwX2ZvbGRlcn0vYmFja3VwLnRneiIKICAgICAgICAgICAg"\
+            "YWNrdXAudGd6IiBdOyB0aGVuCiAgICAgICAgICAgICAgICBlY2hvICJCYWNrdXAgZmlsZSAke2Jh"\
-            "dGFyIC14enZmICR7YmFja3VwX2ZvbGRlcn0vYmFja3VwLnRneiAtQyAke3BhdGh9IC0tc3RyaXAt"\
+            "Y2t1cF9mb2xkZXJ9L2JhY2t1cC50Z3ogZG9lcyBub3QgZXhpc3QgLSBub3RoaW5nIHRvIHJlc3Rv"\
-            "Y29tcG9uZW50cz0xCiAgICAgICAgICAgIDs7CiAgICBlc2FjCn0KCl9hdXRvY29tbWFuZHJ1bl9m"\
+            "cmUiCiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgIGVjaG8gIkNsZWFyaW5nIGV4aXN0"\
-            "aWxlKCkgewogICAgbG9jYWwgY29tbWFuZD0iJDEiCiAgICBsb2NhbCBmaWxlcGF0aD0iJDIiCiAg"\
+            "aW5nIGRhdGEgaW4gcGF0aCAke3BhdGh9IgogICAgICAgICAgICAgICAgZG9ja2VyIHJ1biAtLXJt"\
-            "ICBsb2NhbCBiYWNrdXBfZm9sZGVyPSIkMyIKCiAgICBjYXNlICIkY29tbWFuZCIgaW4KICAgICAg"\
+            "IC12ICR7cGF0aH06L3BhdGggZGViaWFuIGJhc2ggLWMgInJtIC1yZnYgL3BhdGgveyosLip9Igog"\
-            "ICBjcmVhdGUpCiAgICAgICAgICAgIDs7CiAgICAgICAgbnVrZSkKICAgICAgICAgICAgcm0gLWYg"\
+            "ICAgICAgICAgICAgICAgZWNobyAiUmVzdG9yaW5nIHBhdGggJHtwYXRofSBmcm9tIGJhY2t1cCBm"\
-            "JHtmaWxlcGF0aH0KICAgICAgICAgICAgOzsKICAgICAgICBiYWNrdXApCiAgICAgICAgICAgIGVj"\
+            "aWxlICR7YmFja3VwX2ZvbGRlcn0vYmFja3VwLnRneiIKICAgICAgICAgICAgICAgIHRhciAteHp2"\
-            "aG8gIkJhY2tpbmcgdXAgZmlsZSAke2ZpbGVwYXRofSIKICAgICAgICAgICAgbG9jYWwgZmlsZV9w"\
+            "ZiAke2JhY2t1cF9mb2xkZXJ9L2JhY2t1cC50Z3ogLUMgJHtwYXRofSAtLXN0cmlwLWNvbXBvbmVu"\
-            "YXJlbnQ9JChkaXJuYW1lICR7ZmlsZXBhdGh9KQogICAgICAgICAgICBsb2NhbCBmaWxlX25hbWU9"\
+            "dHM9MQogICAgICAgICAgICBmaQogICAgICAgICAgICA7OwogICAgZXNhYwp9CgpfYXV0b2NvbW1h"\
-            "JChiYXNlbmFtZSAke2ZpbGVwYXRofSkKICAgICAgICAgICAgaWYgWyAtZiAiJHtmaWxlX3BhcmVu"\
+            "bmRydW5fZmlsZSgpIHsKICAgIGxvY2FsIGNvbW1hbmQ9IiQxIgogICAgbG9jYWwgZmlsZXBhdGg9"\
-            "dH0vJHtmaWxlX25hbWV9IiBdOyB0aGVuCiAgICAgICAgICAgICAgICBkb2NrZXIgcnVuIC0tcm0g"\
+            "IiQyIgogICAgbG9jYWwgYmFja3VwX2ZvbGRlcj0iJDMiCgogICAgY2FzZSAiJGNvbW1hbmQiIGlu"\
-            "LXYgJHtmaWxlX3BhcmVudH06L3ZvbHVtZSAtdiAke2JhY2t1cF9mb2xkZXJ9Oi9iYWNrdXAgZGVi"\
+            "CiAgICAgICAgY3JlYXRlKQogICAgICAgICAgICA7OwogICAgICAgIG51a2UpCiAgICAgICAgICAg"\
-            "aWFuIGJhc2ggLWMgImNwIC92b2x1bWUvJHtmaWxlX25hbWV9IC9iYWNrdXAvJHtmaWxlX25hbWV9"\
+            "IHJtIC1mICR7ZmlsZXBhdGh9CiAgICAgICAgICAgIDs7CiAgICAgICAgYmFja3VwKQogICAgICAg"\
-            "ICYmIGNob3duIC1SICRNWUlEOiRNWUdSUCAvYmFja3VwIgogICAgICAgICAgICBlbHNlCiAgICAg"\
+            "ICAgICBlY2hvICJCYWNraW5nIHVwIGZpbGUgJHtmaWxlcGF0aH0iCiAgICAgICAgICAgIGxvY2Fs"\
-            "ICAgICAgICAgICBlY2hvICJGaWxlICR7ZmlsZXBhdGh9IGRvZXMgbm90IGV4aXN0IC0gbm90aGlu"\
+            "IGZpbGVfcGFyZW50PSQoZGlybmFtZSAke2ZpbGVwYXRofSkKICAgICAgICAgICAgbG9jYWwgZmls"\
-            "ZyB0byBiYWNrdXAiCiAgICAgICAgICAgIGZpCiAgICAgICAgICAgIDs7CiAgICAgICAgcmVzdG9y"\
+            "ZV9uYW1lPSQoYmFzZW5hbWUgJHtmaWxlcGF0aH0pCiAgICAgICAgICAgIGlmIFsgLWYgIiR7Zmls"\
-            "ZSkKICAgICAgICAgICAgZWNobyAiUmVzdG9yaW5nIGZpbGUgJHtmaWxlcGF0aH0iCiAgICAgICAg"\
+            "ZV9wYXJlbnR9LyR7ZmlsZV9uYW1lfSIgXTsgdGhlbgogICAgICAgICAgICAgICAgZG9ja2VyIHJ1"\
-            "ICAgIGxvY2FsIGZpbGVfbmFtZT0kKGJhc2VuYW1lICR7ZmlsZXBhdGh9KQogICAgICAgICAgICBj"\
+            "biAtLXJtIC12ICR7ZmlsZV9wYXJlbnR9Oi92b2x1bWUgLXYgJHtiYWNrdXBfZm9sZGVyfTovYmFj"\
-            "cCAke2JhY2t1cF9mb2xkZXJ9LyR7ZmlsZV9uYW1lfSAke2ZpbGVwYXRofQogICAgICAgICAgICA7"\
+            "a3VwIGRlYmlhbiBiYXNoIC1jICJjcCAvdm9sdW1lLyR7ZmlsZV9uYW1lfSAvYmFja3VwLyR7Zmls"\
-            "OwogICAgZXNhYwp9CgpfYXV0b2NvbW1hbmRwYXJzZSgpIHsKICAgICMgZmlyc3QgYXJndW1lbnQg"\
+            "ZV9uYW1lfSAmJiBjaG93biAtUiAkTVlJRDokTVlHUlAgL2JhY2t1cCIKICAgICAgICAgICAgZWxz"\
-            "aXMgdGhlIGNvbW1hbmQKICAgICMgaWYgdGhlIGNvbW1hbmQgaXMgYmFja3VwIG9yIHJlc3RvcmUs"\
+            "ZQogICAgICAgICAgICAgICAgZWNobyAiRmlsZSAke2ZpbGVwYXRofSBkb2VzIG5vdCBleGlzdCAt"\
-            "IHRoZW4gdGhlIGxhc3QgdHdvIGFyZ3VtZW50cyBhcmUgdGhlIGJhY2t1cCBmaWxlIGFuZCB0aGUg"\
+            "IG5vdGhpbmcgdG8gYmFja3VwIgogICAgICAgICAgICBmaQogICAgICAgICAgICA7OwogICAgICAg"\
-            "dGVtcG9yYXJ5IHBhdGgKICAgICMgYWxsIG90aGVyIGFyZ3VtZW50cyBhcmUgb2YgZm9ybToKICAg"\
+            "IHJlc3RvcmUpCiAgICAgICAgICAgIGVjaG8gIlJlc3RvcmluZyBmaWxlICR7ZmlsZXBhdGh9Igog"\
-            "ICMga2V5PXZhbHVlCiAgICAjIHdoZXJlIGtleSBjYW4gYmUgb25lIG9mIHZvbHVtZSwgcGF0aCBv"\
+            "ICAgICAgICAgICBsb2NhbCBmaWxlX25hbWU9JChiYXNlbmFtZSAke2ZpbGVwYXRofSkKICAgICAg"\
-            "ciBmaWxlLgogICAgIyB2YWx1ZSBpcyB0aGUgcGF0aCBvciB2b2x1bWUgbmFtZS4KCiAgICAjIHdl"\
+            "ICAgICAgcm0gLWYgJHtmaWxlcGF0aH0gfHwgZGllICJVbmFibGUgdG8gcmVtb3ZlIGV4aXN0aW5n"\
-            "IGl0ZXJhdGUgb3ZlciB0aGUga2V5PXZhbHVlIGFyZ3VtZW50cywgYW5kIGZvciBlYWNoIHdlIGNh"\
+            "IGZpbGUgJHtmaWxlcGF0aH0sIHJlc3RvcmUgZmFpbGVkLiIKICAgICAgICAgICAgY3AgJHtiYWNr"\
-            "bGw6CiAgICAjICAgIGF1dG9ydW4gPGNvbW1hbmQ+IDxiYWNrdXBmaWxlPiA8a2V5PiA8dmFsdWU+"\
+            "dXBfZm9sZGVyfS8ke2ZpbGVfbmFtZX0gJHtmaWxlcGF0aH0gfHwgZGllICJVbmFibGUgdG8gY29w"\
-            "CgogICAgbG9jYWwgY29tbWFuZD0iJDEiCiAgICBzaGlmdAoKICAgIGxvY2FsIGJhY2t1cF90ZW1w"\
+            "eSBmaWxlICR7YmFja3VwX2ZvbGRlcn0vJHtmaWxlX25hbWV9IHRvICR7ZmlsZXBhdGh9LCByZXN0"\
-            "X3BhdGg9IiQxIgogICAgc2hpZnQKCiAgICBlY2hvICJhdXRvY29tbWFuZHBhcnNlOiBjb21tYW5k"\
+            "b3JlIGZhaWxlZC4iCiAgICAgICAgICAgIDs7CiAgICBlc2FjCn0KCl9hdXRvY29tbWFuZHBhcnNl"\
-            "PSRjb21tYW5kIGJhY2t1cF90ZW1wX3BhdGg9JGJhY2t1cF90ZW1wX3BhdGgiCgogICAgIyBFeHRy"\
+            "KCkgewogICAgIyBmaXJzdCBhcmd1bWVudCBpcyB0aGUgY29tbWFuZAogICAgIyBpZiB0aGUgY29t"\
-            "YWN0IHRoZSBiYWNrdXAgZmlsZSBhbmQgdGVtcCBwYXRoIChsYXN0IHR3byBhcmd1bWVudHMpCiAg"\
+            "bWFuZCBpcyBiYWNrdXAgb3IgcmVzdG9yZSwgdGhlbiB0aGUgbGFzdCB0d28gYXJndW1lbnRzIGFy"\
-            "ICBsb2NhbCBhcmdzPSgiJEAiKQogICAgbG9jYWwgYXJnX2NvdW50PSR7I2FyZ3NbQF19CiAgICAK"\
+            "ZSB0aGUgYmFja3VwIGZpbGUgYW5kIHRoZSB0ZW1wb3JhcnkgcGF0aAogICAgIyBhbGwgb3RoZXIg"\
-            "ICAgICMgUHJvY2VzcyBhbGwga2V5PXZhbHVlIHBhaXJzCiAgICBmb3IgKChpPTA7IGk8JGFyZ19j"\
+            "YXJndW1lbnRzIGFyZSBvZiBmb3JtOgogICAgIyBrZXk9dmFsdWUKICAgICMgd2hlcmUga2V5IGNh"\
-            "b3VudDsgaSsrKSk7IGRvCiAgICAgICAgbG9jYWwgcGFpcj0iJHthcmdzWyRpXX0iCiAgICAgICAg"\
+            "biBiZSBvbmUgb2Ygdm9sdW1lLCBwYXRoIG9yIGZpbGUuCiAgICAjIHZhbHVlIGlzIHRoZSBwYXRo"\
-            "CiAgICAgICAgIyBTa2lwIGlmIG5vdCBpbiBrZXk9dmFsdWUgZm9ybWF0CiAgICAgICAgaWYgW1sg"\
+            "IG9yIHZvbHVtZSBuYW1lLgoKICAgICMgd2UgaXRlcmF0ZSBvdmVyIHRoZSBrZXk9dmFsdWUgYXJn"\
-            "IiRwYWlyIiAhPSAqIj0iKiBdXTsgdGhlbgogICAgICAgICAgICBjb250aW51ZQogICAgICAgIGZp"\
+            "dW1lbnRzLCBhbmQgZm9yIGVhY2ggd2UgY2FsbDoKICAgICMgICAgYXV0b3J1biA8Y29tbWFuZD4g"\
-            "CiAgICAgICAgCiAgICAgICAgbG9jYWwga2V5PSIke3BhaXIlJT0qfSIKICAgICAgICBsb2NhbCB2"\
+            "PGJhY2t1cGZpbGU+IDxrZXk+IDx2YWx1ZT4KCiAgICBsb2NhbCBjb21tYW5kPSIkMSIKICAgIHNo"\
-            "YWx1ZT0iJHtwYWlyIyo9fSIKCiAgICAgICAgIyBjcmVhdGUgYmFja3VwIGZvbGRlciB1bmlxdWUg"\
+            "aWZ0CgogICAgbG9jYWwgYmFja3VwX3RlbXBfcGF0aD0iJDEiCiAgICBzaGlmdAoKICAgIGVjaG8g"\
-            "dG8ga2V5L3ZhbHVlLgogICAgICAgIGxvY2FsIGJmb2xkZXI9JChlY2hvICIke2tleX1fJHt2YWx1"\
+            "ImF1dG9jb21tYW5kcGFyc2U6IGNvbW1hbmQ9JGNvbW1hbmQgYmFja3VwX3RlbXBfcGF0aD0kYmFj"\
-            "ZX0iIHwgdHIgLWNkICdbOmFsbnVtOl1fLScpCiAgICAgICAgbG9jYWwgdGFyZ2V0cGF0aD0iJHti"\
+            "a3VwX3RlbXBfcGF0aCIKCiAgICAjIEV4dHJhY3QgdGhlIGJhY2t1cCBmaWxlIGFuZCB0ZW1wIHBh"\
-            "YWNrdXBfdGVtcF9wYXRofS8ke2Jmb2xkZXJ9IgogICAgICAgIG1rZGlyIC1wICR7dGFyZ2V0cGF0"\
+            "dGggKGxhc3QgdHdvIGFyZ3VtZW50cykKICAgIGxvY2FsIGFyZ3M9KCIkQCIpCiAgICBsb2NhbCBh"\
-            "aH0KCiAgICAgICAgIyBLZXkgbXVzdCBiZSBvbmUgb2Ygdm9sdW1lLCBwYXRoIG9yIGZpbGUKICAg"\
+            "cmdfY291bnQ9JHsjYXJnc1tAXX0KICAgIAogICAgIyBQcm9jZXNzIGFsbCBrZXk9dmFsdWUgcGFp"\
-            "ICAgICBjYXNlICIka2V5IiBpbgogICAgICAgICAgICB2b2x1bWUpCiAgICAgICAgICAgICAgICBf"\
+            "cnMKICAgIGZvciAoKGk9MDsgaTwkYXJnX2NvdW50OyBpKyspKTsgZG8KICAgICAgICBsb2NhbCBw"\
-            "YXV0b2NvbW1hbmRydW5fdm9sdW1lICIkY29tbWFuZCIgIiR2YWx1ZSIgIiR0YXJnZXRwYXRoIgog"\
+            "YWlyPSIke2FyZ3NbJGldfSIKICAgICAgICAKICAgICAgICAjIFNraXAgaWYgbm90IGluIGtleT12"\
-            "ICAgICAgICAgICAgICAgOzsKICAgICAgICAgICAgcGF0aCkKICAgICAgICAgICAgICAgIF9hdXRv"\
+            "YWx1ZSBmb3JtYXQKICAgICAgICBpZiBbWyAiJHBhaXIiICE9ICoiPSIqIF1dOyB0aGVuCiAgICAg"\
-            "Y29tbWFuZHJ1bl9wYXRoICIkY29tbWFuZCIgIiR2YWx1ZSIgIiR0YXJnZXRwYXRoIgogICAgICAg"\
+            "ICAgICAgIGNvbnRpbnVlCiAgICAgICAgZmkKICAgICAgICAKICAgICAgICBsb2NhbCBrZXk9IiR7"\
-            "ICAgICAgICAgOzsKICAgICAgICAgICAgZmlsZSkKICAgICAgICAgICAgICAgIF9hdXRvY29tbWFu"\
+            "cGFpciUlPSp9IgogICAgICAgIGxvY2FsIHZhbHVlPSIke3BhaXIjKj19IgoKICAgICAgICAjIGNy"\
-            "ZHJ1bl9maWxlICIkY29tbWFuZCIgIiR2YWx1ZSIgIiR0YXJnZXRwYXRoIgogICAgICAgICAgICAg"\
+            "ZWF0ZSBiYWNrdXAgZm9sZGVyIHVuaXF1ZSB0byBrZXkvdmFsdWUuCiAgICAgICAgbG9jYWwgYmZv"\
-            "ICAgOzsKICAgICAgICAgICAgKikKICAgICAgICAgICAgICAgIF9kaWUgIlVua25vd24ga2V5ICRr"\
+            "bGRlcj0kKGVjaG8gIiR7a2V5fV8ke3ZhbHVlfSIgfCB0ciAtY2QgJ1s6YWxudW06XV8tJykKICAg"\
-            "ZXkgcGFzc2VkIHRvIGF1dG8ke2NvbW1hbmR9LiBXZSBvbmx5IHN1cHBvcnQgdm9sdW1lLCBwYXRo"\
+            "ICAgICBsb2NhbCB0YXJnZXRwYXRoPSIke2JhY2t1cF90ZW1wX3BhdGh9LyR7YmZvbGRlcn0iCiAg"\
-            "IGFuZCBmaWxlLiIKICAgICAgICAgICAgICAgIDs7CiAgICAgICAgZXNhYwogICAgZG9uZQp9CgoK"\
+            "ICAgICAgbWtkaXIgLXAgJHt0YXJnZXRwYXRofQoKICAgICAgICAjIEtleSBtdXN0IGJlIG9uZSBv"\
-            "ZGF0YWNyZWF0ZSgpIHsKICAgIF9hdXRvY29tbWFuZHBhcnNlIGNyZWF0ZSBub25lICIkQCIKfQoK"\
+            "ZiB2b2x1bWUsIHBhdGggb3IgZmlsZQogICAgICAgIGNhc2UgIiRrZXkiIGluCiAgICAgICAgICAg"\
-            "CmRhdGFudWtlKCkgewogICAgX2F1dG9jb21tYW5kcGFyc2UgbnVrZSBub25lICIkQCIKfQoKZGF0"\
+            "IHZvbHVtZSkKICAgICAgICAgICAgICAgIF9hdXRvY29tbWFuZHJ1bl92b2x1bWUgIiRjb21tYW5k"\
-            "YWJhY2t1cCgpIHsKICAgIF9jaGVja19yZXF1aXJlZF9lbnZfdmFycyAiQkFDS1VQX0ZJTEUiICJU"\
+            "IiAiJHZhbHVlIiAiJHRhcmdldHBhdGgiCiAgICAgICAgICAgICAgICA7OwogICAgICAgICAgICBw"\
-            "RU1QX0RJUiIKICAgIEJBQ0tVUF9URU1QX1BBVEg9IiRURU1QX0RJUi9iYWNrdXAiCgoKICAgIG1r"\
+            "YXRoKQogICAgICAgICAgICAgICAgX2F1dG9jb21tYW5kcnVuX3BhdGggIiRjb21tYW5kIiAiJHZh"\
-            "ZGlyIC1wICIkQkFDS1VQX1RFTVBfUEFUSCIKICAgIGVjaG8gIl9hdXRvY29tbWFuZHBhcnNlIFti"\
+            "bHVlIiAiJHRhcmdldHBhdGgiCiAgICAgICAgICAgICAgICA7OwogICAgICAgICAgICBmaWxlKQog"\
-            "YWNrdXBdIFskQkFDS1VQX1RFTVBfUEFUSF0gWyRAXSIKICAgIF9hdXRvY29tbWFuZHBhcnNlIGJh"\
+            "ICAgICAgICAgICAgICAgX2F1dG9jb21tYW5kcnVuX2ZpbGUgIiRjb21tYW5kIiAiJHZhbHVlIiAi"\
-            "Y2t1cCAiJEJBQ0tVUF9URU1QX1BBVEgiICIkQCIKCiAgICB0YXIgemN2ZiAiJEJBQ0tVUF9GSUxF"\
+            "JHRhcmdldHBhdGgiCiAgICAgICAgICAgICAgICA7OwogICAgICAgICAgICAqKQogICAgICAgICAg"\
-            "IiAtQyAiJEJBQ0tVUF9URU1QX1BBVEgiIC4KfQoKZGF0YXJlc3RvcmUoKSB7CiAgICBfY2hlY2tf"\
+            "ICAgICAgX2RpZSAiVW5rbm93biBrZXkgJGtleSBwYXNzZWQgdG8gYXV0byR7Y29tbWFuZH0uIFdl"\
-            "cmVxdWlyZWRfZW52X3ZhcnMgIkJBQ0tVUF9GSUxFIiAiVEVNUF9ESVIiCiAgICBCQUNLVVBfVEVN"\
+            "IG9ubHkgc3VwcG9ydCB2b2x1bWUsIHBhdGggYW5kIGZpbGUuIgogICAgICAgICAgICAgICAgOzsK"\
-            "UF9QQVRIPSIkVEVNUF9ESVIvcmVzdG9yZSIKCiAgICBlY2hvICJfYXV0b2NvbW1hbmRwYXJzZSBb"\
+            "ICAgICAgICBlc2FjCiAgICBkb25lCn0KCgpkYXRhY3JlYXRlKCkgewogICAgX2F1dG9jb21tYW5k"\
-            "cmVzdG9yZV0gWyRCQUNLVVBfVEVNUF9QQVRIXSBbJEBdIgoKICAgIG1rZGlyIC1wICIkQkFDS1VQ"\
+            "cGFyc2UgY3JlYXRlIG5vbmUgIiRAIgp9CgoKZGF0YW51a2UoKSB7CiAgICBfYXV0b2NvbW1hbmRw"\
-            "X1RFTVBfUEFUSCIKICAgIHRhciB6eHZmICIkQkFDS1VQX0ZJTEUiIC1DICIkQkFDS1VQX1RFTVBf"\
+            "YXJzZSBudWtlIG5vbmUgIiRAIgp9CgpkYXRhYmFja3VwKCkgewogICAgX2NoZWNrX3JlcXVpcmVk"\
-            "UEFUSCIgLS1zdHJpcC1jb21wb25lbnRzPTEKCiAgICBfYXV0b2NvbW1hbmRwYXJzZSByZXN0b3Jl"\
+            "X2Vudl92YXJzICJCQUNLVVBfRklMRSIgIlRFTVBfRElSIgogICAgQkFDS1VQX1RFTVBfUEFUSD0i"\
-            "ICIkQkFDS1VQX1RFTVBfUEFUSCIgIiRAIgp9Cg==";
+            "JFRFTVBfRElSL2JhY2t1cCIKCgogICAgbWtkaXIgLXAgIiRCQUNLVVBfVEVNUF9QQVRIIgogICAg"\
+            "ZWNobyAiX2F1dG9jb21tYW5kcGFyc2UgW2JhY2t1cF0gWyRCQUNLVVBfVEVNUF9QQVRIXSBbJEBd"\
+            "IgogICAgX2F1dG9jb21tYW5kcGFyc2UgYmFja3VwICIkQkFDS1VQX1RFTVBfUEFUSCIgIiRAIgoK"\
+            "ICAgIHRhciB6Y3ZmICIkQkFDS1VQX0ZJTEUiIC1DICIkQkFDS1VQX1RFTVBfUEFUSCIgLgp9Cgpk"\
+            "YXRhcmVzdG9yZSgpIHsKICAgIF9jaGVja19yZXF1aXJlZF9lbnZfdmFycyAiQkFDS1VQX0ZJTEUi"\
+            "ICJURU1QX0RJUiIKICAgIEJBQ0tVUF9URU1QX1BBVEg9IiRURU1QX0RJUi9yZXN0b3JlIgoKICAg"\
+            "IGVjaG8gIl9hdXRvY29tbWFuZHBhcnNlIFtyZXN0b3JlXSBbJEJBQ0tVUF9URU1QX1BBVEhdIFsk"\
+            "QF0iCgogICAgbWtkaXIgLXAgIiRCQUNLVVBfVEVNUF9QQVRIIgogICAgdGFyIHp4dmYgIiRCQUNL"\
+            "VVBfRklMRSIgLUMgIiRCQUNLVVBfVEVNUF9QQVRIIiAtLXN0cmlwLWNvbXBvbmVudHM9MQoKICAg"\
+            "IF9hdXRvY29tbWFuZHBhcnNlIHJlc3RvcmUgIiRCQUNLVVBfVEVNUF9QQVRIIiAiJEAiCn0K";
 
         // Decode Base64 data
         size_t decoded_size = (strlen(filedata_base64) * 3) / 4;
@@ -235,7 +228,49 @@ 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, 10759194710819511084ULL, std::filesystem::perms(493), decoded_data, actual_size);
+        bool file_written = _recreate_file_(outpath, 12213965674971673660ULL, std::filesystem::perms(493), decoded_data, actual_size);
+        delete[] decoded_data;
+        any_written = any_written || file_written;
+    }
+    {
+        // File: agent-install.sh
+        fs::path outpath = fs::path(destination_folder) / "agent-install.sh";
+        static const char filedata_base64[] = "IyEvYmluL2Jhc2gKCiMgVGhpcyBzY3JpcHQgaXMgdXNlZCB0byBpbnN0YWxsIHRoZSBkcm9wc2hl"\
+            "bGwgYWdlbnQgb24gYSByZW1vdGUgc2VydmVyLgoKU0NSSVBUX0RJUj0kKGRpcm5hbWUgIiQwIikK"\
+            "CnNldCAtYQoKQUdFTlRfUEFUSD0iJFNDUklQVF9ESVIiCgpzZXQgK2EKCgppZiBbIC1mICIkU0NS"\
+            "SVBUX0RJUi9jb21tb24uc2giIF07IHRoZW4KICAgIHNvdXJjZSAiJFNDUklQVF9ESVIvY29tbW9u"\
+            "LnNoIgplbHNlCiAgICBlY2hvICJFcnJvcjogY29tbW9uLnNoIG5vdCBmb3VuZCBpbiAkU0NSSVBU"\
+            "X0RJUiIKICAgIGV4aXQgMQpmaQoKX2NoZWNrX3JlcXVpcmVkX2Vudl92YXJzICJBR0VOVF9QQVRI"\
+            "IgoKZnVuY3Rpb24gaW5zdGFsbF9iYjY0KCkgeyAgICAKICAgICMgY2hlY2sgY3VybCBpbnN0YWxs"\
+            "ZWQKICAgIGlmICEgY29tbWFuZCAtdiBjdXJsICY+IC9kZXYvbnVsbDsgdGhlbgogICAgICAgIF9k"\
+            "aWUgIkN1cmwgaXMgbm90IGluc3RhbGxlZC4gQ3VybCBpcyByZXF1aXJlZCBmb3IgYWdlbnQgaW5z"\
+            "dGFsbGF0aW9uLiIKICAgIGZpCgogICAgY3VybCAtZnNTTCAiaHR0cHM6Ly9naXRlYS5qZGUubnov"\
+            "cHVibGljL2JiNjQvcmVsZWFzZXMvZG93bmxvYWQvbGF0ZXN0L2luc3RhbGwuc2giIHwgYmFzaCAt"\
+            "cyAtLSAiJEFHRU5UX1BBVEgiICIkKGlkIC11ICRVU0VSKTokKGlkIC1nICRVU0VSKSIKCiAgICAj"\
+            "IHRlc3QgcmVzdWx0IGNvZGUgZnJvbSBjdXJsCiAgICBpZiBbICQ/IC1uZSAwIF07IHRoZW4KICAg"\
+            "ICAgICBfZGllICJGYWlsZWQgdG8gaW5zdGFsbCBiYjY0LiBDdXJsIHJldHVybmVkIG5vbi16ZXJv"\
+            "IGV4aXQgY29kZS4iCiAgICBmaQoKICAgICMgdGVzdCBpZiBiYjY0IGlzIGluc3RhbGxlZAogICAg"\
+            "IiRBR0VOVF9QQVRIL2JiNjQiIC12CiAgICBpZiBbICQ/IC1uZSAwIF07IHRoZW4KICAgICAgICBf"\
+            "ZGllICJiYjY0IGRpZCBub3QgaW5zdGFsbCBjb3JyZWN0bHkuIgogICAgZmkKCiAgICBlY2hvICJi"\
+            "YjY0IGluc3RhbGxlZCBzdWNjZXNzZnVsbHkuIgogICAgcmV0dXJuIDA7Cn0KCiMtLS0tLS0tLS0t"\
+            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t"\
+            "LS0tLS0tCgplY2hvICJJbnN0YWxsaW5nIGRyb3BzaGVsbCBhZ2VudC4uLiIKCmluc3RhbGxfYmI2"\
+            "NAoKCgojLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t"\
+            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoKZWNobyAiUnVubmluZyByZW1vdGUgYWdlbnQgc2VsZi10"\
+            "ZXN0Li4uIgoKCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t"\
+            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgplY2hvICJDb21wbGV0ZWQgcmVtb3RlIGFnZW50"\
+            "IHNlbGYtdGVzdC4iCgoKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t"\
+            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KCmVjaG8gIkNvbXBsZXRlZCBkcm9wc2hl"\
+            "bGwgYWdlbnQgaW5zdGFsbGF0aW9uLiIKCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t"\
+            "LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgpleGl0IDAK";
+
+        // Decode Base64 data
+        size_t decoded_size = (strlen(filedata_base64) * 3) / 4;
+        unsigned char* decoded_data = new unsigned char[decoded_size];
+        size_t actual_size;
+        base64_decode(filedata_base64, strlen(filedata_base64), decoded_data, &actual_size);
+
+        bool file_written = _recreate_file_(outpath, 8417440848759774142ULL, std::filesystem::perms(493), decoded_data, actual_size);
         delete[] decoded_data;
         any_written = any_written || file_written;
     }

source/src/autogen/_agent-remote.hpp

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

source/src/commands/install.cpp

@@ -5,7 +5,8 @@
 #include "templates.hpp"
 #include "shared_commands.hpp"
 #include "utils/hash.hpp"
-#include "autogen/_agent.hpp"
+#include "autogen/_agent-local.hpp"
+#include "autogen/_agent-remote.hpp"
 #include "services.hpp"
 #include "utils/output.hpp"
 
@@ -15,6 +16,7 @@
 #include <sstream>
 #include <filesystem>
 #include "utils/assert.hpp"
+#include "servers.hpp"
 
 namespace dropshell
 {
@@ -43,8 +45,8 @@ namespace dropshell
             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                      (re)install dropshell components on this computer, and on all servers.
-            install SERVER               (re)install dropshell agent on the given server.
+            install SERVER               (re)install dropshell agent on the particular 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:
@@ -159,6 +161,8 @@ namespace dropshell
 
     int update_dropshell()
     {
+        maketitle("Updating dropshell on this computer...");
+
         // 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();
@@ -202,8 +206,8 @@ namespace dropshell
 
         if (currentver >= newver)
         {
-            std::cout << "Current dropshell version: " << currentver << ", published version: " << newver << std::endl;
+            info << "Current dropshell version: " << currentver << ", published version: " << newver << std::endl;
-            std::cout << "No update needed." << std::endl;
+            info << "Release version is not newer, no update needed." << std::endl;
             return 0;
         }
 
@@ -214,20 +218,22 @@ namespace dropshell
         rval = system(bash_script_2.c_str());
         if (rval != 0)
         {
-            std::cerr << "Failed to install new version of dropshell." << std::endl;
+            error << "Failed to install new version of dropshell." << std::endl;
             return -1;
         }
 
-        std::cout << "Successfully updated " << dropshell_path << " to the latest " << arch << " version." << std::endl;
+        info << "Successfully updated " << dropshell_path << " to the latest " << arch << " version." << std::endl;
 
         // execute the new version
         execlp("bash", "bash", "-c", (parent_path / "dropshell").c_str(), "install", (char *)nullptr);
-        std::cerr << "Failed to execute new version of dropshell." << std::endl;
+        error << "Failed to execute new version of dropshell." << std::endl;
         return -1;
     }
 
     int install_local_agent()
     {
+        maketitle("Installing dropshell agent on this computer...");
+
         std::vector<std::filesystem::path> paths = {
             gConfig().get_local_template_cache_path(),
             gConfig().get_local_backup_path(),
@@ -239,46 +245,20 @@ namespace dropshell
         for (auto &p : paths)
             if (!std::filesystem::exists(p))
             {
-                std::cout << "Creating directory: " << p << std::endl;
+                info << "Creating directory: " << p << std::endl;
                 std::filesystem::create_directories(p);
             }
 
-        // download bb64 for the host architecture.
+        // create the agent-local directory.
-        if (!std::filesystem::exists(localpath::agent() + "bb64"))
+        recreate_agent_local::recreate_tree(localpath::agent());
-        {
-            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;
+        // run the local agent installer.
-        recreate_agent::recreate_tree(localpath::files_for_remote_agent());
+            execute_local_command(localpath::agent(), "agent-install.sh",{}, nullptr, cMode::Defaults | cMode::NoBB64);
 
-        return 0;
+        // create the agent-remote directory.
-    }
+        info << "Creating local files to copy to remote agents..." << std::endl;
+        recreate_agent_remote::recreate_tree(localpath::files_for_remote_agent());
 
-    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;
     }
 
@@ -307,23 +287,9 @@ namespace dropshell
         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!
+        // run the agent installer. Can't use BB64 yet, as we're installing it on the remote server.
-        info << "Installing bb64 on " << server << "..." << std::endl
+        
-             << std::flush;
+        bool okay = execute_ssh_command(server_env.get_SSH_INFO(), sCommand(agent_path, "agent-install.sh",{}), cMode::Defaults | cMode::NoBB64, nullptr);
-
-        std::string remote_cmd =
-            "ssh -p " + server_env.get_SSH_INFO().port + " " + server_env.get_SSH_INFO().user + "@" + server_env.get_SSH_INFO().host +
-            " 'mkdir -p " + quote(agent_path) + " && curl -fsSL \"https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh\" | bash -s -- " +
-            quote(agent_path) + " " + quote("$(id -u " + server_env.get_SSH_USER() + "):$(id -g " + server_env.get_SSH_USER() + ")") + "'";
-
-        // std::cout << "Executing: " << remote_cmd << std::endl;
-        if (!execute_local_command("", remote_cmd, {}, nullptr, cMode::Silent))
-            error << "Failed to download bb64 to " << agent_path << " on remote server." << std::endl;
-        else
-            debug << "Downloaded bb64 to " << agent_path << " on remote server." << std::endl;
-
-        // run the self-test.
-        bool okay = execute_ssh_command(server_env.get_SSH_INFO(), sCommand(agent_path, "./selftest.sh", {}), cMode::Defaults, nullptr);
         if (!okay)
         {
             error << "ERROR: Failed to install remote agent on " << server << std::endl;
@@ -334,6 +300,35 @@ namespace dropshell
         return 0;
     }
 
+    // ------------------------------------------------------------------------------------------------
+    // install_host
+    // ------------------------------------------------------------------------------------------------
+    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;
+
+        // install the dropshell agent on all servers.
+        std::vector<ServerInfo> servers = get_configured_servers();
+        for (const auto &server : servers)
+        {
+            rval = install_server(server.name);
+            if (rval != 0)
+                return rval;
+        }
+
+        std::cout << "Installation complete." << std::endl;
+        return 0;
+    }
+
     // ------------------------------------------------------------------------------------------------
     // install command implementation
     // ------------------------------------------------------------------------------------------------

source/src/commands/restoredata.cpp

@@ -127,6 +127,16 @@ namespace dropshell
 
         ASSERT(backup_details.has_value() && backup_details->is_valid(), "Invalid backup file.");
 
+        debug << "Backup details: " << std::endl;
+        debug << "   Backup filename:             " << backup_details->get_filename() << std::endl;
+        debug << "   Backup template:             " << backup_details->get_template_name() << std::endl;
+        debug << "   Backup taken from server:    " << backup_details->get_server() << std::endl;
+        debug << "   Backup taken from service:   " << backup_details->get_service() << std::endl;
+        debug << " " << std::endl;
+        debug << "Restoring to:" << std::endl;
+        debug << "   Server:                      " << server << std::endl;
+        debug << "   Service:                     " << service << std::endl;
+
         std::string local_backups_dir = gConfig().get_local_backup_path();
         if (local_backups_dir.empty() || !std::filesystem::exists(local_backups_dir))
         {
@@ -143,14 +153,11 @@ namespace dropshell
         if (backup_details->get_template_name() != service_info.template_name)
         {
             error << "Error: Backup template does not match service template. Can't restore." << std::endl;
-            debug << "Backup template:  " << backup_details->get_template_name() << std::endl;
+            info << "Backup template:  " << backup_details->get_template_name() << std::endl;
-            debug << "Service template: " << service_info.template_name << std::endl;
+            info << "Service template: " << service_info.template_name << std::endl;
-            debug << "Backup file:      " << local_backup_file_path << std::endl;
             return 1;
         }
 
-        info << "Restoring " << backup_details->get_datetime() << " backup of " << backup_details->get_service() << " taken from " << backup_details->get_server() << ", onto " << server << "/" << service << std::endl;
-        info << std::endl;
         warning << "*** ALL DATA FOR " << server << "/" << service << " WILL BE OVERWRITTEN! ***" << std::endl;
 
         // run the restore script
@@ -160,9 +167,9 @@ namespace dropshell
             info << "1) Backing up old service... " << std::endl;
             if (!shared_commands::backupdata_service(server, service))
             {
-                error << "Error: Backup failed, restore aborted." << std::endl;
+                error << "Backup failed, restore aborted." << std::endl;
-                error << "You can try using   dropshell install " << server << " " << service << "   to install the service afresh." << std::endl;
+                info << "You can try using   dropshell install " << server << " " << service << "   to install the service afresh." << std::endl;
-                error << "Otherwise, stop the service, create and initialise a new one, then restore to that." << std::endl;
+                info << "Otherwise, stop the service, create and initialise a new one, then restore to that." << std::endl;
                 return 1;
             }
             info << "Backup complete." << std::endl;
@@ -191,6 +198,8 @@ namespace dropshell
             std::string remote_backups_dir = remotepath::backups(server);
             std::string remote_backup_file_path = remote_backups_dir + "/" + backup_details->get_filename();
 
+            debug << "Copying backup file from local to server: " << local_backup_file_path << " -> " << remote_backup_file_path << std::endl;
+
             // Copy backup file from local to server
             if (!shared_commands::scp_file_to_remote(server_env, local_backup_file_path, remote_backup_file_path, false))
             {
@@ -199,6 +208,11 @@ namespace dropshell
             }
 
             shared_commands::cRemoteTempFolder remote_temp_folder(server_env);
+
+            debug << "Running restore script on server: " << server << std::endl;
+            debug << "  BACKUP_FILE: " << remote_backup_file_path << std::endl;
+            debug << "  TEMP_DIR:    " << remote_temp_folder.path() << std::endl;
+
             server_env.run_remote_template_command(service, "restore", {}, false, {{"BACKUP_FILE", remote_backup_file_path}, {"TEMP_DIR", remote_temp_folder.path()}});
         } // dtor of remote_temp_folder will clean up the temp folder on the server
 

source/src/commands/shared_commands.cpp

@@ -121,7 +121,7 @@ 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 | cMode::Silent,
+                                     cMode::Silent,
                                      &output))
                 return status;
 

source/src/server_env_manager.cpp

@@ -218,8 +218,7 @@ bool server_env_manager::run_remote_template_command_and_capture_output(const st
     for (const auto& [key, value] : extra_env_vars) 
         scommand->add_env_var(key, value);
 
-    cMode mode = cMode::CaptureOutput;
+    return execute_ssh_command(get_SSH_INFO(), scommand.value(), cMode::Defaults, &output);
-    return execute_ssh_command(get_SSH_INFO(), scommand.value(), mode, &output);
 }
 
 

source/src/utils/execute.cpp

@@ -22,7 +22,6 @@ namespace dropshell
         return (ret != -1 && WIFEXITED(ret) && (WEXITSTATUS(ret) == 0)); // ret is -1 if the command failed to execute.
     }
 
-
     // ----------------------------------------------------------------------------------------------------------
     // execute_local_command_interactive
     // ----------------------------------------------------------------------------------------------------------
@@ -30,7 +29,7 @@ namespace dropshell
     {
         if (command.get_command_to_run().empty())
             return false;
-        std::string full_command = command.construct_cmd(localpath::agent()); // Get the command string
+        std::string full_command = command.construct_cmd(localpath::agent()+"/bb64"); // Get the command string
 
         pid_t pid = fork();
 
@@ -62,7 +61,7 @@ namespace dropshell
 
     class fancypinter
     {
-        public:
+    public:
         fancypinter(sColour startColour) : startColour_(startColour), currentColour_(startColour) {}
 
         void print_chunk(std::string chunk)
@@ -82,18 +81,22 @@ namespace dropshell
                 else if (chunk.find("info") == 0)
                     currentColour_ = sColour::INFO;
                 else
-                    currentColour_ = startColour_;    
+                    currentColour_ = startColour_;
             }
             colourstream(currentColour_) << chunk;
-            newline_ = (chunk[chunk.size()-1] == '\n');
+            newline_ = (chunk[chunk.size() - 1] == '\n');
         }
 
-        void print(const std::string& buffer) {
+        void print(const std::string &buffer)
+        {
             size_t start = 0;
-            while (start < buffer.size()) {
+            while (start < buffer.size())
+            {
                 size_t newline_pos = buffer.find('\n', start);
-                if (newline_pos == std::string::npos) {
+                if (newline_pos == std::string::npos)
-                    if (start < buffer.size()) {
+                {
+                    if (start < buffer.size())
+                    {
                         print_chunk(buffer.substr(start));
                     }
                     break;
@@ -103,32 +106,36 @@ namespace dropshell
             }
         }
 
-        private:
+    private:
         bool newline_ = true;
         sColour startColour_;
         sColour currentColour_;
     };
 
-
     bool execute_local_command(std::string directory_to_run_in, std::string command_to_run, const std::map<std::string, std::string> &env_vars, std::string *output, cMode mode)
     {
         sCommand command(directory_to_run_in, command_to_run, env_vars);
 
         if (hasFlag(mode, cMode::Interactive))
         {
-            ASSERT(!hasFlag(mode, cMode::CaptureOutput), "Interactive mode and capture output mode cannot be used together");
             ASSERT(output == nullptr, "Interactive mode and an output string cannot be used together");
 
             return execute_local_command_interactive(command);
         }
 
-
         if (command.get_command_to_run().empty())
             return false;
 
         bool silent = hasFlag(mode, cMode::Silent);
 
-        std::string full_cmd = command.construct_cmd(localpath::agent()) + (hasFlag(mode, cMode::CaptureOutput) ? " 2>&1" : ""); // capture both stdout and stderr
+        std::string full_cmd;
+        if (!hasFlag(mode, cMode::NoBB64))
+            full_cmd = command.construct_cmd(localpath::agent()+"/bb64");
+        else
+            full_cmd = command.construct_cmd("");
+
+        if (output != nullptr)
+            full_cmd += " 2>&1"; // capture both stdout and stderr
 
         FILE *pipe = popen(full_cmd.c_str(), "r");
         if (!pipe)
@@ -140,7 +147,7 @@ namespace dropshell
         while (fgets(buffer, sizeof(buffer), pipe) != nullptr)
         {
             if (output != nullptr)
-               (*output) += buffer;
+                (*output) += buffer;
 
             if (!silent)
                 fancyprint.print(buffer);
@@ -157,30 +164,27 @@ namespace dropshell
         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);
+        std::string remote_bb64_path;
+
+        if (!hasFlag(mode, cMode::NoBB64))
+            remote_bb64_path = remotepath::agent(ssh_info.server_ID) + "/bb64";
 
         bool rval = execute_local_command(
-            "",                                                                          // directory to run in
+            "",                                                                    // local directory to run in
-            ssh_cmd.str() + " " + remote_command.construct_cmd(remote_agent_path),       // local command to run
+            ssh_cmd.str() + " " + remote_command.construct_cmd(remote_bb64_path),  // local command to run
-            {},                                                                          // environment variables
+            {},                                                                    // environment variables
-            output,                                                                      // output string
+            output,                                                                // output string
-            mode                                                                         // mode
+            mode                                                                   // mode
         );
 
         if (!rval && !hasFlag(mode, cMode::Silent))
         {
-            std::cerr << std::endl
+            error << "Error: Failed to execute ssh command:" << std::endl;
-                      << std::endl;
+            debug << ssh_cmd.str() + " " + remote_command.construct_cmd(remote_bb64_path) << 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;
     }
@@ -188,19 +192,19 @@ namespace dropshell
     // ----------------------------------------------------------------------------------------------------------
     // makesafecmd
     // ----------------------------------------------------------------------------------------------------------
-    std::string sCommand::makesafecmd(std::string agent_path, const std::string &command) const
+    std::string sCommand::makesafecmd(std::string bb64path, const std::string &command) const
     {
         if (command.empty())
             return "";
         std::string encoded = base64_encode(dequote(trim(command)));
-        std::string commandstr = agent_path + "/bb64 " + encoded;
+        std::string commandstr = bb64path + " " + encoded;
         return commandstr;
     }
 
     // ----------------------------------------------------------------------------------------------------------
     // construct_cmd
     // ----------------------------------------------------------------------------------------------------------
-    std::string sCommand::construct_cmd(std::string agent_path) const
+    std::string sCommand::construct_cmd(std::string bb64path) const
     {
         if (mCmd.empty())
             return "";
@@ -208,17 +212,27 @@ namespace dropshell
         // need to construct to change directory and set environment variables
         std::string cmdstr;
 
-        if (!mDir.empty())
+        if (!bb64path.empty())
-            cmdstr += "cd " + quote(mDir) + " && ";
+        {
+            if (!mDir.empty())
+                cmdstr += "cd " + quote(mDir) + " && ";
 
-        if (!mVars.empty())
+            if (!mVars.empty())
-            for (const auto &env_var : mVars)
+                for (const auto &env_var : mVars)
-                cmdstr += env_var.first + "=" + quote(dequote(trim(env_var.second))) + " ";
+                    cmdstr += env_var.first + "=" + quote(dequote(trim(env_var.second))) + " ";
 
-        cmdstr += mCmd;
+            cmdstr += mCmd;
 
-        if (!agent_path.empty())
+            cmdstr = makesafecmd(bb64path, cmdstr);
-        cmdstr = makesafecmd(agent_path, cmdstr);
+        }
+        else 
+        { // raw! bootstrapping only.
+            ASSERT(mVars.empty(), "Bootstrapping command must not have environment variables");
+            if (!mDir.empty())
+                cmdstr += mDir + "/" + mCmd;
+            else
+                cmdstr += mCmd;
+        }
 
         return cmdstr;
     }

source/src/utils/execute.hpp

@@ -13,7 +13,7 @@ enum class cMode {
     Defaults = 0,
     Interactive = 1,
     Silent = 2,
-    CaptureOutput = 4
+    NoBB64 = 4
 };
 
 inline cMode operator&(cMode lhs, cMode rhs) {return static_cast<cMode>(static_cast<int>(lhs) & static_cast<int>(rhs));}
@@ -52,10 +52,10 @@ class sCommand {
         
         bool empty() const { return mCmd.empty(); }
     
-        std::string construct_cmd(std::string agent_path) const;
+        std::string construct_cmd(std::string bb64path) const;
 
     private:
-        std::string makesafecmd(std::string agent_path, const std::string& command) const;
+        std::string makesafecmd(std::string bb64path, const std::string& command) const;
 
     private:
         std::string mDir;