bb64 release v39

.vscode/settings.json

@@ -63,6 +63,7 @@
         "typeinfo": "cpp",
         "variant": "cpp",
         "format": "cpp",
-        "__nullptr": "cpp"
+        "__nullptr": "cpp",
+        "codecvt": "cpp"
     }
 }

README.md

@@ -2,10 +2,18 @@
 
 # Installation
 
+Automated system-wide installation:
 ```
-curl -fsSL -o bb64_install.sh https://gitea.jde.nz/j/bb64/raw/branch/main/install.sh && sudo bash ./bb64_install.sh && rm bb64_install.sh
+curl -fsSL https://gitea.jde.nz/public/bb64/releases/download/latest/install.sh | bash
 ```
 
+## To download just the bb64 executable:
+
+```
+curl -fsSL -o bb64 https://gitea.jde.nz/public/bb64/releases/download/latest/bb64.amd64 && chmod a+x bb64
+```
+
+
 # Use
 
 Bash Base64, written in C++.
@@ -13,12 +21,11 @@ Bash Base64, written in C++.
 Uses a custom Base64 character set for bash compatibility, not compatible with other utilities.
 
 ```
-Useage:
+Usage:
-    bb64 BASE64COMMAND      Decodes the base64 encoded command, and runs it
+    bb64 BASE64COMMAND          Decodes and runs the command
-    bb64 -i BASE64COMMAND   Decodes the base64 encoded command, and prints to the screen
+    bb64 -[i|d] BASE64COMMAND   Displays the decoded command
-                            If it contains a bb64 command within the decoded command, it 
+    bb64 -e COMMAND             Encodes the command and prints the result
-                            also decodes that and prints it to the screen.
+    bb64 -u                     Updates bb64 to the latest version (uses docker)
-    bb64 -e COMMAND(S)      encodes the commands in base64.
 ```
 
 # Implementation Notes
@@ -27,11 +34,9 @@ bb64 runs the command by replacing the current process, so it ensures that tty,
 variables etc are all identical for the run command. It works with interactive commands, like
 nano or ssh.
 
-The command is run as:
+bb64 supports bash scripts, as the command is run as:
-    `bash -c COMMAND`
+    `bash -c 'COMMAND'`
 Where COMMAND is passed to bash as a single argument.
 
 If the command is run, the return value is the return value of the command.
 If it isn't run, bb64 returns -1.
-
-`./build.sh` will build bb64 for x86_64 (amd64) and arm64 architectures.

bb64.cpp

@@ -4,14 +4,16 @@
 #include <unistd.h>
 #include <cstring>
 #include <sstream>
-
+#include <filesystem>
 #include "version.h"
 #include "b64ed.hpp"
 
 // Recursively decode and print if nested bb64 command is found
 void recursive_print(const std::string &decoded)
 {
+    std::cout << std::string(80, '-') << std::endl;
     std::cout << decoded << std::endl;
+    std::cout << std::string(80, '-') << std::endl;
 
     size_t pos = decoded.find("bb64 ");
     if (pos != std::string::npos)
@@ -34,6 +36,102 @@ constexpr unsigned int hash(const char *s, int off = 0)
     return !s[off] ? 5381 : (hash(s, off + 1) * 33) ^ s[off];
 }
 
+std::string tidy(const std::string &str)
+{
+    std::string result;
+    bool in_whitespace = false;
+    for (char c : str)
+    {
+        // Remove non-printable characters except for whitespace (space, tab, newline, carriage return)
+        if ((static_cast<unsigned char>(c) < 32 && c != ' ' && c != '\t' && c != '\n' && c != '\r') || static_cast<unsigned char>(c) == 127)
+        {
+            continue;
+        }
+        if (c == ' ' || c == '\t' || c == '\n' || c == '\r')
+        {
+            if (!in_whitespace)
+            {
+                result += ' ';
+                in_whitespace = true;
+            }
+        }
+        else
+        {
+            result += c;
+            in_whitespace = false;
+        }
+    }
+    // Remove leading whitespace
+    size_t start = result.find_first_not_of(' ');
+    if (start == std::string::npos)
+        return "";
+    // Remove trailing whitespace
+    size_t end = result.find_last_not_of(' ');
+    return result.substr(start, end - start + 1);
+}
+    
+
+std::string get_arch()
+{
+    // determine the architecture of the system
+    std::string arch;
+#ifdef __aarch64__
+    arch = "arm64";
+#elif __x86_64__
+    arch = "amd64";
+#endif
+    return arch;
+}
+
+int update_bb64()
+{
+    // determine path to this executable
+    std::filesystem::path bb64_path = std::filesystem::canonical("/proc/self/exe");
+    std::filesystem::path parent_path = bb64_path.parent_path();
+
+    // determine the architecture of the system
+    std::string arch = get_arch();
+
+    std::string url = "https://gitea.jde.nz/public/bb64/releases/download/latest/bb64." + arch;
+
+    // download new version, preserve permissions and ownership
+    std::string bash_script;
+    bash_script += "docker run --rm -v "+parent_path.string()+":/target";
+    bash_script += " gitea.jde.nz/public/debian-curl:latest";
+    bash_script += " sh -c \"";
+    bash_script += " curl -fsSL " + url + " -o /target/bb64_temp &&";
+    bash_script += " chmod --reference=/target/bb64 /target/bb64_temp &&";
+    bash_script += " chown --reference=/target/bb64 /target/bb64_temp &&";
+    bash_script += " mv /target/bb64_temp /target/bb64";
+    bash_script += "\"";
+
+    std::cout << "Updating " << bb64_path << " to the latest " << arch << " version." << std::endl;
+
+    // std::cout << "bash_script: " << std::endl
+    //           << bash_script << std::endl;
+
+    // run the bash script
+    execlp("bash", "bash", "-c", bash_script.c_str(), (char *)nullptr);
+    std::cerr << "Failed to execute command." << std::endl;
+    return -1;
+}
+
+int decode_and_run(const std::string &encoded)
+{
+    // Default: decode and run
+    std::string decoded = base64_decode(encoded);
+    if (decoded.empty())
+    {
+        std::cerr << "Failed to decode base64 command." << std::endl;
+        return -1;
+    }
+    // Replace current process with bash -c "decoded"
+    execlp("bash", "bash", "-c", decoded.c_str(), (char *)nullptr);
+    // If execlp returns, there was an error
+    std::cerr << "Failed to execute command." << std::endl;
+    return -1;
+}
+
 int main(int argc, char *argv[])
 {
     if (argc < 2)
@@ -45,41 +143,62 @@ int main(int argc, char *argv[])
 Usage:
     bb64 BASE64COMMAND          Decodes and runs the command
     bb64 -[i|d] BASE64COMMAND   Displays the decoded command
-    bb64 -e COMMAND             Encodes the command and prints the result
+    
+    bb64 -e COMMAND             Encodes the command and prints the base64 encoded result
+    bb64 -e                     Encodes the command provided on stdin and prints the result
+
+    bb64 -u                     Updates bb64 to the latest version (uses docker)
+
+    bb64 -v                     Prints the version number
 
 )" << std::endl;
         return -1;
     }
 
+    std::string mode = argv[1];
+
     if (argc == 2)
     {
-        // Default: decode and run
+        if (mode == "-u")
-        std::string decoded = base64_decode(argv[1]);
+            return update_bb64();
-        if (decoded.empty())
+        else if (mode == "-v")
         {
-            std::cerr << "Failed to decode base64 command." << std::endl;
+            std::cout << VERSION << std::endl;
-            return -1;
+            return 0;
         }
-        // Replace current process with bash -c "decoded"
+        else if (mode == "-e")
-        execlp("bash", "bash", "-c", decoded.c_str(), (char *)nullptr);
+        {
-        // If execlp returns, there was an error
+            std::ostringstream oss;
-        std::cerr << "Failed to execute command." << std::endl;
+            while (std::cin)
-        return -1;
+            {
+                std::string line;
+                std::getline(std::cin, line);
+                oss << line << std::endl;
+            }
+            std::string tidier = tidy(oss.str());
+            std::cout << base64_encode(tidier) << std::endl;
+            return 0;
+        }
+        else
+            return decode_and_run(mode);
     }
 
-    std::string mode = argv[1];
     std::ostringstream oss;
+    std::string tidier;
 
     switch (hash(mode.c_str()))
     {
     case hash("-i"):
     case hash("-d"):
+        std::cout << "Decoding command..." << std::endl
+                  << std::endl;
         recursive_print(base64_decode(argv[2]));
         break;
     case hash("-e"):
         for (int i = 2; i < argc; ++i)
             oss << (i > 2 ? " " : "") << argv[i];
-        std::cout << base64_encode(oss.str()) << std::endl;
+        tidier = tidy(oss.str());
+        std::cout << base64_encode(tidier) << std::endl;
         break;
     default:
         std::cerr << "Invalid mode: " << mode << std::endl;

build.sh

@@ -8,12 +8,7 @@ mkdir -p "$OUTPUT_DIR"
 # Build for x86_64 with musl static linking
 if [[ $(uname -m) == "x86_64" ]]; then
     echo "Building for x86_64 (musl static)..."
-    if command -v x86_64-linux-musl-g++ &>/dev/null; then
+    x86_64-linux-musl-g++ -O2 -static -o "$OUTPUT_DIR/bb64.amd64" bb64.cpp b64ed.cpp
-        x86_64-linux-musl-g++ -O2 -static -o "$OUTPUT_DIR/bb64.amd64" bb64.cpp b64ed.cpp
-    else
-        g++ -O2 -static -o "$OUTPUT_DIR/bb64.amd64" bb64.cpp b64ed.cpp -static-libgcc -static-libstdc++
-        echo "Warning: musl-g++ not found, built with g++ static flags."
-    fi
     echo "Built bb64.amd64 (x86_64, static)"
 fi
 

install.sh

@@ -1,19 +1,31 @@
 #!/bin/bash
 set -e
 
-# Require root
-if [[ $EUID -ne 0 ]]; then
-    echo "This script must be run as root." >&2
-    exit 1
-fi
-
 # Installs bb64 on the local machine.
 # 1. determines the architecture of the local machine
-# 2. downloads the appropriate bb64 binary from the latest public release on Gitea (https://gitea.jde.nz/j/bb64/releases)
+# 2. downloads the appropriate bb64 binary from the latest public release on Gitea (https://gitea.jde.nz/public/bb64/releases)
 # 3. makes the bb64 binary executable
 # 4. moves the bb64 binary to /usr/local/bin
 # 5. prints a message to the user
 
+# 0. see if we were passed a folder to install to
+# -----------------------------------------------------------------------------
+INSTALL_DIR="$1"
+if [[ -z "$INSTALL_DIR" ]]; then
+    INSTALL_DIR="/usr/local/bin"
+else
+    echo "Installing bb64 to $INSTALL_DIR"
+    if [[ ! -d "$INSTALL_DIR" ]]; then
+        mkdir -p "$INSTALL_DIR"
+    fi
+fi
+
+# 0. see if we were passed a user to chown to
+# -----------------------------------------------------------------------------
+CHOWN_USER="$2"
+if [[ -z "$CHOWN_USER" ]]; then
+    CHOWN_USER=$(id -u)
+fi
 
 # 1. Determine architecture
 # ----------------------------------------------------------------------------- 
@@ -28,26 +40,11 @@ else
     exit 1
 fi
 
-# 2. Get latest release tag from Gitea API
-# -----------------------------------------------------------------------------
-REPO_API="https://gitea.jde.nz/api/v1/repos/j/bb64/releases"
-if command -v jq >/dev/null 2>&1; then
-    TAG=$(curl -s "$REPO_API" | jq -r '.[0].tag_name')
-else
-    TAG=$(curl -s "$REPO_API" | grep -m1 '"tag_name"' | sed 's/.*"tag_name"[ ]*:[ ]*"\([^"]*\)".*/\1/')
-fi
-if [ -z "$TAG" ] || [ "$TAG" = "null" ]; then
-    echo "Could not determine latest release tag from $REPO_API" >&2
-    exit 1
-fi
-
-echo "Latest version of bb64 is: $TAG"
-
 # 3. Download the appropriate binary to a temp directory
 # -----------------------------------------------------------------------------
 TMPDIR=$(mktemp -d)
 trap 'rm -rf "$TMPDIR"' EXIT
-URL="https://gitea.jde.nz/j/bb64/releases/download/$TAG/$BIN"
+URL="https://gitea.jde.nz/public/bb64/releases/download/latest/$BIN"
 echo "Downloading $BIN from $URL..."
 
 curl -fsSL -o "$TMPDIR/bb64" "$URL"
@@ -58,11 +55,15 @@ chmod +x "$TMPDIR/bb64"
 
 # 5. Move to /usr/local/bin
 # -----------------------------------------------------------------------------
-mv "$TMPDIR/bb64" /usr/local/bin/bb64
+docker run --rm -v "$TMPDIR:/tmp" -v "$INSTALL_DIR:/target" alpine sh -c "cp /tmp/bb64 /target/bb64; chown $CHOWN_USER /target/bb64"
+rm "$TMPDIR/bb64"
 
 # 6. Print success message
 # -----------------------------------------------------------------------------
-echo "bb64 installed successfully to /usr/local/bin/bb64 (version $TAG, arch $ARCH)"
+echo "bb64 installed successfully to $INSTALL_DIR/bb64 (arch $ARCH)"
-echo " "
+# echo " "
-echo "try it out with:"
+# echo "Update bb64 with:"
-echo "    bb64 ZWNobyAiSGVsbG8td29ybGQhIGJiNjQgaXMgd29ya2luZy4i"
+# echo "    bb64 -u"
+# echo " "
+# echo "try it out with:"
+# echo "    bb64 ZWNobyAiSGVsbG8td29ybGQhIGJiNjQgaXMgd29ya2luZy4i"

install_prerequisites.sh

@@ -39,15 +39,15 @@ if [ ! -d "$INSTALL_DIR/aarch64-linux-musl-cross" ]; then
 fi
 
 # Print instructions for adding to PATH
-cat <<EOF
+# cat <<EOF
 
-To use the musl cross compilers, add the following to your shell:
+# To use the musl cross compilers, add the following to your shell:
-export PATH="$INSTALL_DIR/x86_64-linux-musl-cross/bin:$INSTALL_DIR/aarch64-linux-musl-cross/bin:$PATH"
+# export PATH="$INSTALL_DIR/x86_64-linux-musl-cross/bin:$INSTALL_DIR/aarch64-linux-musl-cross/bin:$PATH"
 
-Or run:
+# Or run:
-    export PATH="$INSTALL_DIR/x86_64-linux-musl-cross/bin:$INSTALL_DIR/aarch64-linux-musl-cross/bin:\$PATH"
+#     export PATH="$INSTALL_DIR/x86_64-linux-musl-cross/bin:$INSTALL_DIR/aarch64-linux-musl-cross/bin:\$PATH"
 
-EOF
+# EOF
 
 # Clean up
 rm -rf "$TMPDIR"

publish.sh

@@ -17,8 +17,9 @@ if [ ! -f version.h ]; then
     exit 1
 else
     v=$(cat version.h | grep -o 'static const char \*VERSION = "[0-9.]*";' | cut -d'"' -f2)
-    v=$((v+1))
+    oldv=$v
-    echo "Incrementing version from $v to $v" >&2
+    v=$((v+1))  
+    echo "Incrementing version from $oldv to $v" >&2
     echo "static const char *VERSION = \"$v\";" > version.h
 fi
 TAG="v$v"
@@ -26,6 +27,10 @@ TAG="v$v"
 # Build binaries
 ./build.sh
 
+# make sure we've commited.
+git add . && git commit -m "bb64 release $TAG" && git push
+
+
 # Find repo info from .git/config
 REPO_URL=$(git config --get remote.origin.url)
 if [[ ! $REPO_URL =~ gitea ]]; then
@@ -72,15 +77,24 @@ if [ -z "$RELEASE_ID" ]; then
     exit 1
 fi
 
-# Upload binaries
+# Upload binaries and install.sh
-for BIN in bb64.amd64 bb64.arm64; do
+for FILE in bb64.amd64 bb64.arm64 install.sh; do
-    if [ -f "output/$BIN" ]; then
+    if [ -f "output/$FILE" ]; then
-        curl -s -X POST "$API_URL/releases/$RELEASE_ID/assets?name=$BIN" \
+        filetoupload="output/$FILE"
-            -H "Content-Type: application/octet-stream" \
+    elif [ -f "$FILE" ]; then
-            -H "Authorization: token $TOKEN" \
+        filetoupload="$FILE"
-            --data-binary @"output/$BIN"
+    else
-        echo "Uploaded $BIN to release $TAG."
+        continue
     fi
+
+    # Auto-detect content type
+    ctype=$(file --mime-type -b "$filetoupload")
+
+    curl -s -X POST "$API_URL/releases/$RELEASE_ID/assets?name=$FILE" \
+        -H "Content-Type: $ctype" \
+        -H "Authorization: token $TOKEN" \
+        --data-binary @"$filetoupload"
+    echo "Uploaded $FILE to release $TAG as $ctype."
 done
 
 echo "Published bb64 version $v to $REPO_URL (tag $TAG) with binaries."

version.h

@@ -1 +1 @@
-static const char *VERSION = "8";
+static const char *VERSION = "39";