Spaces:
Sleeping
Sleeping
Download install.sh from codebydante/BrodyFileStreamBot: direct link, hf CLI and curl.
- Browser
- Download file 24.1 kB
-
https://huggingface.co/spaces/codebydante/BrodyFileStreamBot/resolve/main/install.sh
- Command line
-
hf download hf://spaces/codebydante/BrodyFileStreamBot/install.sh
-
curl -L -o install.sh https://huggingface.co/spaces/codebydante/BrodyFileStreamBot/resolve/main/install.sh
24.1 kB
| set -euo pipefail | |
| # TG-FileStreamBot Installer for macOS and Linux | |
| # Usage: curl -sL https://filestream.bot/install | bash | |
| # --------------- COLORS & STYLING --------------- | |
| BOLD='\033[1m' | |
| FSB_GREEN='\033[38;2;0;255;133m' # #00FF85 | |
| FSB_DIM='\033[38;2;0;204;106m' # #00cc6a | |
| INFO='\033[38;2;136;146;176m' # text-secondary | |
| SUCCESS='\033[38;2;0;229;204m' # cyan-bright | |
| WARN='\033[38;2;255;176;32m' # amber | |
| ERROR='\033[38;2;230;57;70m' # coral-mid | |
| MUTED='\033[38;2;90;100;128m' # text-muted | |
| NC='\033[0m' # No Color | |
| REPO="EverythingSuckz/TG-FileStreamBot" | |
| GUM_VERSION="0.13.0" | |
| TMPFILES=() | |
| HAS_TTY="false" | |
| if [[ -r /dev/tty ]]; then | |
| HAS_TTY="true" | |
| fi | |
| can_use_tui() { | |
| [[ -n "${GUM:-}" && "$HAS_TTY" == "true" ]] | |
| } | |
| prompt_read() { | |
| local __var_name="$1" | |
| local __prompt="$2" | |
| local __default="${3-}" | |
| local __input="" | |
| if [[ "$HAS_TTY" == "true" ]]; then | |
| read -r -p "$__prompt" __input < /dev/tty || __input="" | |
| else | |
| read -r -p "$__prompt" __input || __input="" | |
| fi | |
| if [[ -z "$__input" && -n "$__default" ]]; then | |
| __input="$__default" | |
| fi | |
| printf -v "$__var_name" '%s' "$__input" | |
| } | |
| gum_choose() { | |
| if [[ "$HAS_TTY" == "true" ]]; then | |
| "$GUM" choose "$@" < /dev/tty | |
| else | |
| "$GUM" choose "$@" | |
| fi | |
| } | |
| gum_confirm() { | |
| if [[ "$HAS_TTY" == "true" ]]; then | |
| "$GUM" confirm "$@" < /dev/tty | |
| else | |
| "$GUM" confirm "$@" | |
| fi | |
| } | |
| gum_input() { | |
| if [[ "$HAS_TTY" == "true" ]]; then | |
| "$GUM" input "$@" < /dev/tty | |
| else | |
| "$GUM" input "$@" | |
| fi | |
| } | |
| # --------------- TEMP RUNTIME --------------- | |
| cleanup() { | |
| for f in "${TMPFILES[@]:-}"; do | |
| rm -rf "$f" 2>/dev/null || true | |
| done | |
| } | |
| trap cleanup EXIT | |
| mktempdir() { | |
| local d | |
| d="$(mktemp -d)" | |
| TMPFILES+=("$d") | |
| echo "$d" | |
| } | |
| # --------------- LOGGING UI --------------- | |
| ui_info() { echo -e "${MUTED}·${NC} $*"; } | |
| ui_warn() { echo -e "${WARN}!${NC} $*"; } | |
| ui_success() { echo -e "${SUCCESS}✓${NC} $*"; } | |
| ui_error() { echo -e "${ERROR}✗${NC} $*" >&2; } | |
| # --------------- DEPENDENCIES --------------- | |
| DOWNLOADER="" | |
| detect_downloader() { | |
| if command -v curl &> /dev/null; then | |
| DOWNLOADER="curl" | |
| return 0 | |
| fi | |
| if command -v wget &> /dev/null; then | |
| DOWNLOADER="wget" | |
| return 0 | |
| fi | |
| ui_error "Missing downloader. curl or wget required." | |
| exit 1 | |
| } | |
| download_file() { | |
| local url="$1" output="$2" | |
| if [[ -z "$DOWNLOADER" ]]; then detect_downloader; fi | |
| if [[ "$DOWNLOADER" == "curl" ]]; then | |
| curl -fsSL --retry 3 -o "$output" "$url" | |
| else | |
| wget -q --tries=3 -O "$output" "$url" | |
| fi | |
| } | |
| download_github_api() { | |
| local url="$1" output="$2" | |
| if [[ -z "$DOWNLOADER" ]]; then detect_downloader; fi | |
| if [[ "$DOWNLOADER" == "curl" ]]; then | |
| curl -fsSL -H "Accept: application/vnd.github.v3+json" --retry 3 -o "$output" "$url" | |
| else | |
| wget -q --header="Accept: application/vnd.github.v3+json" --tries=3 -O "$output" "$url" | |
| fi | |
| } | |
| # --------------- GUM TUI BOOTSTRAP --------------- | |
| GUM="" | |
| bootstrap_gum() { | |
| if command -v gum &> /dev/null; then | |
| GUM="gum" | |
| return 0 | |
| fi | |
| local os arch asset base gum_tmpdir | |
| os="$(uname -s | tr '[:upper:]' '[:lower:]')" | |
| case "$(uname -m)" in | |
| x86_64|amd64) arch="x86_64" ;; | |
| arm64|aarch64) arch="arm64" ;; | |
| i386|i686) arch="i386" ;; | |
| *) return 1 ;; | |
| esac | |
| asset="gum_${GUM_VERSION}_${os}_${arch}.tar.gz" | |
| base="https://github.com/charmbracelet/gum/releases/download/v${GUM_VERSION}" | |
| gum_tmpdir="$(mktempdir)" | |
| if download_file "${base}/${asset}" "$gum_tmpdir/$asset"; then | |
| tar -xzf "$gum_tmpdir/$asset" -C "$gum_tmpdir" >/dev/null 2>&1 | |
| local gum_path | |
| gum_path="$(find "$gum_tmpdir" -type f -name gum | head -n1)" | |
| if [[ -n "$gum_path" ]]; then | |
| chmod +x "$gum_path" | |
| GUM="$gum_path" | |
| return 0 | |
| fi | |
| fi | |
| return 1 | |
| } | |
| # --------------- DETECTION --------------- | |
| detect_system() { | |
| OS="unknown" | |
| ARCH="unknown" | |
| case "$(uname -s)" in | |
| Darwin) OS="darwin" ;; | |
| Linux) OS="linux" ;; | |
| MINGW*|MSYS*|CYGWIN*) OS="windows" ;; | |
| esac | |
| case "$(uname -m)" in | |
| x86_64|amd64) ARCH="amd64" ;; | |
| arm64|aarch64) ARCH="arm64" ;; | |
| *) | |
| ui_error "Unsupported architecture: $(uname -m)" | |
| exit 1 | |
| ;; | |
| esac | |
| if [[ "$OS" == "unknown" ]]; then | |
| ui_error "Unsupported operating system." | |
| exit 1 | |
| fi | |
| } | |
| # --------------- API LOGIC --------------- | |
| get_latest_version() { | |
| local include_prerelease="$1" | |
| local api_resp | |
| api_resp="$(mktempdir)/api.json" | |
| ui_info "Fetching latest releases from GitHub..." >&2 | |
| download_github_api "https://api.github.com/repos/${REPO}/releases" "$api_resp" | |
| # We parse manually using robust grep/sed combos since jq might not be installed | |
| local latest_tag="" | |
| if [[ "$include_prerelease" == "yes" ]]; then | |
| latest_tag=$(grep -m 1 '"tag_name":' "$api_resp" | sed -E 's/.*"([^"]+)".*/\1/') | |
| else | |
| # Find first non-prerelease | |
| # This basic parsing finds the first release block where "prerelease": false | |
| # We use awk to grab the tag_name of the first object where prerelease is false | |
| latest_tag=$(awk ' | |
| /"tag_name":/ { tag=$2; gsub(/["|,]/, "", tag) } | |
| /"prerelease": false/ { print tag; exit } | |
| ' "$api_resp") | |
| fi | |
| if [[ -z "$latest_tag" || "$latest_tag" == "null" ]]; then | |
| ui_error "Could not determine latest version from GitHub API." | |
| exit 1 | |
| fi | |
| echo "$latest_tag" | |
| } | |
| # --------------- MAIN INSTALLER --------------- | |
| main() { | |
| echo -e "${FSB_GREEN}${BOLD}" | |
| echo " TG-FileStreamBot Installer" | |
| echo -e "${NC}${INFO} Stream Telegram files with direct HTTP links.${NC}" | |
| echo "" | |
| detect_system | |
| bootstrap_gum || true | |
| # Existing Detection | |
| local EXISTING_FSB="" | |
| if command -v fsb &> /dev/null; then | |
| EXISTING_FSB="$(command -v fsb)" | |
| elif [[ -x "$PWD/fsb" ]]; then | |
| EXISTING_FSB="$PWD/fsb" | |
| elif [[ -x "$PWD/FSB/fsb" ]]; then | |
| EXISTING_FSB="$PWD/FSB/fsb" | |
| fi | |
| local SKIP_DIR_PROMPT="no" | |
| if [[ -n "$EXISTING_FSB" ]]; then | |
| local raw_ver | |
| raw_ver=$("$EXISTING_FSB" -v 2>/dev/null | grep -i 'version' | awk '{print $NF}' || true) | |
| local current_ver="unknown" | |
| if [[ -n "$raw_ver" && "$raw_ver" != "unknown" ]]; then | |
| if [[ "$raw_ver" != v* ]]; then | |
| current_ver="v${raw_ver}" | |
| else | |
| current_ver="$raw_ver" | |
| fi | |
| fi | |
| echo "" | |
| ui_info "Found existing installation at ${BOLD}$EXISTING_FSB${NC} (version: $current_ver)" | |
| local latest_stable | |
| latest_stable=$(get_latest_version "no") | |
| echo "" | |
| local ACTION | |
| if [[ "$current_ver" == "$latest_stable" ]]; then | |
| if can_use_tui; then | |
| ACTION=$(gum_choose "Keep installed version" "Reinstall $latest_stable" "Update to Pre-release" "Uninstall") | |
| else | |
| echo "1) Keep installed version" | |
| echo "2) Reinstall $latest_stable" | |
| echo "3) Update to Pre-release" | |
| echo "4) Uninstall" | |
| prompt_read act "Select action [1]: " "1" | |
| case "${act:-1}" in | |
| 2) ACTION="Reinstall $latest_stable" ;; | |
| 3) ACTION="Update to Pre-release" ;; | |
| 4) ACTION="Uninstall" ;; | |
| *) ACTION="Keep installed version" ;; | |
| esac | |
| fi | |
| else | |
| ui_info "New version available: ${BOLD}$latest_stable${NC}" | |
| if can_use_tui; then | |
| ACTION=$(gum_choose "Update to latest stable ($latest_stable)" "Update to Pre-release" "Uninstall" "Cancel") | |
| else | |
| echo "1) Update to latest stable ($latest_stable)" | |
| echo "2) Update to Pre-release" | |
| echo "3) Uninstall" | |
| echo "4) Cancel" | |
| prompt_read act "Select action [1]: " "1" | |
| case "${act:-1}" in | |
| 2) ACTION="Update to Pre-release" ;; | |
| 3) ACTION="Uninstall" ;; | |
| 4) ACTION="Cancel" ;; | |
| *) ACTION="Update to latest stable ($latest_stable)" ;; | |
| esac | |
| fi | |
| fi | |
| case "$ACTION" in | |
| "Keep installed version"|"Cancel") | |
| ui_info "Exiting." | |
| exit 0 | |
| ;; | |
| "Uninstall") | |
| local target_dir | |
| target_dir=$(dirname "$EXISTING_FSB") | |
| local env_file="$target_dir/fsb.env" | |
| echo "" | |
| if [[ "$(basename "$target_dir")" == "FSB" ]]; then | |
| ui_warn "The following directory and all its contents will be deleted:" | |
| echo -e " ${ERROR}$target_dir${NC}" | |
| else | |
| ui_warn "The following files will be deleted:" | |
| echo -e " ${ERROR}$EXISTING_FSB${NC}" | |
| if [[ -f "$env_file" ]]; then | |
| echo -e " ${ERROR}$env_file${NC}" | |
| fi | |
| fi | |
| echo "" | |
| if can_use_tui; then | |
| if ! gum_confirm "Proceed with uninstallation?" --default=false; then | |
| ui_info "Uninstallation cancelled." | |
| exit 0 | |
| fi | |
| else | |
| prompt_read uninst_resp "Proceed with uninstallation? [y/N] " "N" | |
| case "$uninst_resp" in | |
| [yY][eE][sS]|[yY]) ;; | |
| *) | |
| ui_info "Uninstallation cancelled." | |
| exit 0 | |
| ;; | |
| esac | |
| fi | |
| ui_info "Uninstalling..." | |
| if [[ "$(basename "$target_dir")" == "FSB" ]]; then | |
| rm -rf "$target_dir" 2>/dev/null || sudo rm -rf "$target_dir" | |
| else | |
| rm -f "$EXISTING_FSB" 2>/dev/null || sudo rm -f "$EXISTING_FSB" | |
| if [[ -f "$env_file" ]]; then | |
| rm -f "$env_file" 2>/dev/null || sudo rm -f "$env_file" | |
| fi | |
| fi | |
| ui_success "Uninstalled successfully." | |
| exit 0 | |
| ;; | |
| "Update to Pre-release") | |
| WANT_PRERELEASE="yes" | |
| TARGET_VER=$(get_latest_version "yes") | |
| INSTALL_DIR=$(dirname "$EXISTING_FSB") | |
| SKIP_DIR_PROMPT="yes" | |
| WANT_ENV="no" | |
| ;; | |
| *) | |
| WANT_PRERELEASE="no" | |
| TARGET_VER="$latest_stable" | |
| INSTALL_DIR=$(dirname "$EXISTING_FSB") | |
| SKIP_DIR_PROMPT="yes" | |
| WANT_ENV="no" | |
| ;; | |
| esac | |
| fi | |
| # Defaults | |
| if [[ "$SKIP_DIR_PROMPT" != "yes" ]]; then | |
| WANT_PRERELEASE="No" | |
| INSTALL_DIR="$PWD/FSB" | |
| WANT_ENV="no" | |
| ENV_DIR="" | |
| # Interactive flow if TUI is available | |
| if can_use_tui; then | |
| echo -e "${BOLD}Do you want to install the latest pre-release version?${NC}" | |
| if gum_confirm "Include pre-releases? (Recommended: No)" --default=false; then | |
| WANT_PRERELEASE="yes" | |
| else | |
| WANT_PRERELEASE="no" | |
| fi | |
| echo "" | |
| echo -e "${BOLD}Where should we install the binary?${NC}" | |
| INSTALL_DIR=$(gum_choose \ | |
| "Current Directory/FSB (Recommended)" \ | |
| "Current Directory ($PWD)" \ | |
| "$HOME/.local/bin" \ | |
| "/usr/local/bin (Requires sudo/root)" \ | |
| "Custom Path" | sed 's/ (.*//') | |
| if [[ "$INSTALL_DIR" == "Custom Path" ]]; then | |
| INSTALL_DIR=$(gum_input --placeholder "/path/to/install/dir") | |
| elif [[ "$INSTALL_DIR" == "Current Directory/FSB" ]]; then | |
| INSTALL_DIR="$PWD/FSB" | |
| elif [[ "$INSTALL_DIR" == "Current Directory" ]]; then | |
| INSTALL_DIR="$PWD" | |
| fi | |
| echo "" | |
| echo -e "${BOLD}Do you want to download a sample 'fsb.env' configuration file?${NC}" | |
| if gum_confirm "Download sample env?" --default=true; then | |
| WANT_ENV="yes" | |
| fi | |
| if [[ "$WANT_ENV" == "yes" ]]; then | |
| if [[ "$INSTALL_DIR" == "$PWD/FSB" || "$INSTALL_DIR" == "$PWD" ]]; then | |
| ENV_DIR="$INSTALL_DIR" | |
| else | |
| echo "" | |
| echo -e "${BOLD}Where should we save the 'fsb.env' file?${NC}" | |
| ENV_DIR=$(gum_choose \ | |
| "Current Directory ($PWD) (Recommended)" \ | |
| "Installation Folder ($INSTALL_DIR)" \ | |
| "Custom Path" | sed 's/ (.*//') | |
| if [[ "$ENV_DIR" == "Custom Path" ]]; then | |
| ENV_DIR=$(gum_input --placeholder "/path/to/save/env") | |
| elif [[ "$ENV_DIR" == "Current Directory" ]]; then | |
| ENV_DIR="$PWD" | |
| elif [[ "$ENV_DIR" == "Installation Folder" ]]; then | |
| ENV_DIR="$INSTALL_DIR" | |
| fi | |
| fi | |
| fi | |
| else | |
| # Fallback text mode prompts | |
| prompt_read response "Install pre-release version? [y/N] " "N" | |
| case "$response" in | |
| [yY][eE][sS]|[yY]) WANT_PRERELEASE="yes" ;; | |
| *) WANT_PRERELEASE="no" ;; | |
| esac | |
| echo "" | |
| echo "Select installation directory:" | |
| echo "1) Current Directory/FSB (Recommended)" | |
| echo "2) Current Directory ($PWD)" | |
| echo "3) $HOME/.local/bin" | |
| echo "4) /usr/local/bin (Requires sudo)" | |
| prompt_read dir_resp "Selection [1]: " "1" | |
| case "${dir_resp:-1}" in | |
| 2) INSTALL_DIR="$PWD" ;; | |
| 3) INSTALL_DIR="$HOME/.local/bin" ;; | |
| 4) INSTALL_DIR="/usr/local/bin" ;; | |
| *) INSTALL_DIR="$PWD/FSB" ;; | |
| esac | |
| echo "" | |
| prompt_read env_response "Download sample 'fsb.env' configuration file? [Y/n] " "Y" | |
| case "$env_response" in | |
| [nN][oO]|[nN]) WANT_ENV="no" ;; | |
| *) WANT_ENV="yes" ;; | |
| esac | |
| if [[ "$WANT_ENV" == "yes" ]]; then | |
| if [[ "$INSTALL_DIR" == "$PWD/FSB" || "$INSTALL_DIR" == "$PWD" ]]; then | |
| ENV_DIR="$INSTALL_DIR" | |
| else | |
| echo "" | |
| echo "Select where to save 'fsb.env':" | |
| echo "1) Current Directory ($PWD) (Recommended)" | |
| echo "2) Installation Folder ($INSTALL_DIR)" | |
| prompt_read env_dir_resp "Selection [1]: " "1" | |
| case "${env_dir_resp:-1}" in | |
| 2) ENV_DIR="$INSTALL_DIR" ;; | |
| *) ENV_DIR="$PWD" ;; | |
| esac | |
| fi | |
| fi | |
| fi | |
| # Prep path | |
| case "$INSTALL_DIR" in | |
| ~*) INSTALL_DIR="${INSTALL_DIR/#\~/$HOME}" ;; | |
| esac | |
| if [[ "$WANT_ENV" == "yes" ]]; then | |
| case "$ENV_DIR" in | |
| ~*) ENV_DIR="${ENV_DIR/#\~/$HOME}" ;; | |
| esac | |
| fi | |
| TARGET_VER=$(get_latest_version "$WANT_PRERELEASE") | |
| fi | |
| local file_ext=".tar.gz" | |
| if [[ "$OS" == "windows" ]]; then | |
| file_ext=".zip" | |
| fi | |
| ASSET_NAME="TG-FileStreamBot-${TARGET_VER}-${OS}-${ARCH}${file_ext}" | |
| ASSET_URL="https://github.com/${REPO}/releases/download/${TARGET_VER}/${ASSET_NAME}" | |
| CHECKSUM_URL="https://github.com/${REPO}/releases/download/${TARGET_VER}/TG-FileStreamBot-${TARGET_VER}-checksums.txt" | |
| SIG_URL="${CHECKSUM_URL}.sig" | |
| echo "" | |
| ui_info "Target Version : ${BOLD}${TARGET_VER}${NC}" | |
| ui_info "OS / Arch : ${BOLD}${OS} / ${ARCH}${NC}" | |
| ui_info "Binary Location : ${BOLD}${INSTALL_DIR}${NC}" | |
| if [[ "$WANT_ENV" == "yes" ]]; then | |
| ui_info "Env File Location : ${BOLD}${ENV_DIR}/fsb.env${NC}" | |
| fi | |
| echo "" | |
| # Confirmation | |
| if can_use_tui; then | |
| if ! gum_confirm "Proceed with installation?" --default=true; then | |
| ui_info "Installation cancelled." | |
| exit 0 | |
| fi | |
| else | |
| prompt_read proceed_resp "Proceed with installation? [Y/n] " "Y" | |
| case "$proceed_resp" in | |
| [nN][oO]|[nN]) | |
| ui_info "Installation cancelled." | |
| exit 0 | |
| ;; | |
| esac | |
| fi | |
| if [[ -n "$GUM" ]]; then | |
| "$GUM" spin --spinner dot --title "Downloading components..." -- sleep 0.1 | |
| fi | |
| local dl_dir | |
| dl_dir="$(mktempdir)" | |
| ui_info "Downloading ${ASSET_NAME}..." | |
| if ! download_file "$ASSET_URL" "$dl_dir/$ASSET_NAME"; then | |
| ui_error "Failed to download the binary archive. Is the release available for this architecture?" | |
| exit 1 | |
| fi | |
| ui_info "Downloading checksums..." | |
| download_file "$CHECKSUM_URL" "$dl_dir/checksums.txt" | |
| # Verify checksum if sha256sum or shasum exists | |
| ui_info "Verifying SHA256 checksum..." | |
| pushd "$dl_dir" >/dev/null | |
| local checksum_matched=false | |
| if command -v sha256sum &> /dev/null; then | |
| if grep "$ASSET_NAME" checksums.txt | sha256sum -c - >/dev/null 2>&1; then | |
| checksum_matched=true | |
| fi | |
| elif command -v shasum &> /dev/null; then | |
| if grep "$ASSET_NAME" checksums.txt | shasum -a 256 -c - >/dev/null 2>&1; then | |
| checksum_matched=true | |
| fi | |
| else | |
| ui_warn "No sha256sum or shasum found; skipping checksum verification." | |
| checksum_matched=true | |
| fi | |
| popd >/dev/null | |
| if [[ "$checksum_matched" != "true" ]]; then | |
| ui_error "Checksum verification failed! The file may be corrupted or compromised." | |
| exit 1 | |
| fi | |
| ui_success "Checksum matched." | |
| # Verify Signature if tools exist | |
| ui_info "Downloading signature..." | |
| download_file "$SIG_URL" "$dl_dir/checksums.txt.sig" | |
| ui_info "Verifying signature..." | |
| pushd "$dl_dir" >/dev/null | |
| local sig_verified=false | |
| if command -v gpg &> /dev/null; then | |
| ui_info "gpg detected. Fetching developer's public key..." | |
| download_file "https://github.com/EverythingSuckz.gpg" "dev_key.asc" | |
| # Create a temporary keyring to avoid polluting the user's keychain | |
| local keyring="--no-default-keyring --keyring ./temp_keyring.gpg" | |
| gpg $keyring --import dev_key.asc >/dev/null 2>&1 | |
| if gpg $keyring --verify checksums.txt.sig checksums.txt >/dev/null 2>&1; then | |
| sig_verified=true | |
| ui_success "Signature verified successfully." | |
| else | |
| ui_warn "Signature verification failed. The release might be compromised." | |
| sig_verified=false | |
| fi | |
| else | |
| ui_warn "No gpg executable found; skipping signature validation." | |
| sig_verified=true | |
| fi | |
| popd >/dev/null | |
| if [[ "$sig_verified" != "true" ]]; then | |
| ui_error "Signature verification failed!" | |
| exit 1 | |
| fi | |
| ui_info "Extracting binary..." | |
| if [[ "$ASSET_NAME" == *.zip ]]; then | |
| if ! command -v unzip &> /dev/null; then | |
| ui_error "unzip is required to extract Windows binaries." | |
| exit 1 | |
| fi | |
| unzip -q "$dl_dir/$ASSET_NAME" -d "$dl_dir" | |
| else | |
| tar -xzf "$dl_dir/$ASSET_NAME" -C "$dl_dir" | |
| fi | |
| # The tarball contains the binary, possibly named `fsb` or inside a folder. | |
| # Usually it extracts right out as `fsb`. | |
| local bin_file | |
| bin_file="$(find "$dl_dir" -type f \( -name "fsb" -o -name "TG-FileStreamBot" \) | head -n1)" | |
| if [[ -z "$bin_file" ]]; then | |
| ui_error "Could not find the executable inside the extracted archive." | |
| exit 1 | |
| fi | |
| chmod +x "$bin_file" | |
| if [[ ! -d "$INSTALL_DIR" ]]; then | |
| ui_info "Creating directory $INSTALL_DIR..." | |
| mkdir -p "$INSTALL_DIR" 2>/dev/null || sudo mkdir -p "$INSTALL_DIR" | |
| fi | |
| ui_info "Installing to $INSTALL_DIR..." | |
| if mv "$bin_file" "$INSTALL_DIR/fsb" 2>/dev/null; then | |
| ui_success "Installed successfully!" | |
| else | |
| ui_info "Elevated permissions required to write to $INSTALL_DIR" | |
| # Use sudo on unix, but check if we are on windows first | |
| if command -v sudo &> /dev/null; then | |
| if sudo mv "$bin_file" "$INSTALL_DIR/fsb"; then | |
| ui_success "Installed successfully!" | |
| else | |
| ui_error "Installation failed due to permissions." | |
| exit 1 | |
| fi | |
| else | |
| ui_error "Insufficient permissions and sudo not found. Please run script as Admin/Root." | |
| exit 1 | |
| fi | |
| fi | |
| echo "" | |
| echo -e "${FSB_GREEN}${BOLD}✓ Setup Complete!${NC}" | |
| # Path logic checking | |
| local in_path=false | |
| if builtin type -p fsb &>/dev/null; then | |
| in_path=true | |
| elif [[ ":$PATH:" == *":$INSTALL_DIR:"* ]]; then | |
| in_path=true | |
| fi | |
| local is_portable=false | |
| if [[ "$INSTALL_DIR" != "/usr/local/bin" && "$INSTALL_DIR" != "/usr/bin" && "$INSTALL_DIR" != "$HOME/.local/bin" ]]; then | |
| is_portable=true | |
| fi | |
| echo "" | |
| if [[ "$in_path" == false && "$is_portable" == false ]]; then | |
| ui_warn "The directory $INSTALL_DIR is not in your PATH." | |
| echo -e "You may need to add it to your shell configuration file (e.g. ~/.bashrc or ~/.zshrc):" | |
| echo -e " ${BOLD}export PATH=\"\$PATH:$INSTALL_DIR\"${NC}" | |
| echo "" | |
| fi | |
| local bin_cmd="fsb" | |
| if [[ "$in_path" == false ]]; then | |
| bin_cmd="./fsb" | |
| fi | |
| # Download Env if requested | |
| if [[ "$WANT_ENV" == "yes" ]]; then | |
| ui_info "Downloading sample configuration to $ENV_DIR/fsb.env..." | |
| if [[ ! -d "$ENV_DIR" ]]; then | |
| mkdir -p "$ENV_DIR" 2>/dev/null || sudo mkdir -p "$ENV_DIR" | |
| fi | |
| local env_branch="main" | |
| if [[ "$WANT_PRERELEASE" == "yes" ]]; then | |
| env_branch="dev" | |
| fi | |
| local env_url="https://raw.githubusercontent.com/${REPO}/refs/heads/${env_branch}/fsb.sample.env" | |
| local dl_env | |
| dl_env="$(mktempdir)/fsb.sample.env" | |
| if download_file "$env_url" "$dl_env"; then | |
| if mv "$dl_env" "$ENV_DIR/fsb.env" 2>/dev/null; then | |
| ui_success "Saved fsb.env" | |
| else | |
| sudo mv "$dl_env" "$ENV_DIR/fsb.env" 2>/dev/null || ui_warn "Failed to move fsb.env to $ENV_DIR" | |
| fi | |
| else | |
| ui_warn "Failed to download sample fsb.env configuration." | |
| fi | |
| fi | |
| echo "" | |
| echo -e "${BOLD}Next Steps:${NC}" | |
| if [[ "$INSTALL_DIR" != "$PWD" && "$is_portable" == true ]]; then | |
| # If it's a sub-directory, e.g. PWD/FSB or custom folder | |
| echo -e " cd $INSTALL_DIR" | |
| fi | |
| if [[ "$WANT_ENV" == "yes" ]]; then | |
| echo -e " ${INFO}# Edit fsb.env to configure your bot variables${NC}" | |
| else | |
| echo -e " ${INFO}# Supply your environmental variables (e.g. in fsb.env) before running${NC}" | |
| fi | |
| echo -e " ${bin_cmd} run" | |
| echo "" | |
| } | |
| main "$@" | |