install.sh

#!/usr/bin/env bash
set -euo pipefail

# Show error location on failure
trap 'error "Installation failed at line $LINENO."' ERR

# VibeCoding Installer
# Progressive and agile vibe-coding tool. No need to re-deploy Claw/Hermes;
# everything is packed into a single file.
# 主打渐进式、敏捷开发体验的 VibeCoding 工具，整体打包为单个文件，开箱即用，
# 无需重复搭建部署 Claude Code、codex、Claw、Hermes 环境。
#
# Downloads and installs the latest release from GitHub
#
# Supports non-root installation to ~/.vibecoding/bin
#
# Repository: https://github.com/startvibecoding/vibecoding
# Gitee:      https://gitee.com/startvibecoding/vibecoding
# Author:     zhenruyan
# Blog:       https://pkold.com

REPO="startvibecoding/vibecoding"
BINARY_NAME="vibecoding"

# User-level install directory (no root required)
USER_INSTALL_DIR="${HOME}/.vibecoding/bin"

# Default install directory: auto-detect based on write permission
# Priority: INSTALL_DIR env > writable /usr/local/bin > ~/.vibecoding/bin
if [ -n "${INSTALL_DIR:-}" ]; then
    : # User explicitly set INSTALL_DIR
elif [ -w "/usr/local/bin" ] || [ -w "/usr/local" ]; then
    INSTALL_DIR="/usr/local/bin"
else
    INSTALL_DIR="$USER_INSTALL_DIR"
fi

# Colors
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

info() {
    echo -e "${BLUE}[INFO]${NC} $1"
}

success() {
    echo -e "${GREEN}[SUCCESS]${NC} $1"
}

warn() {
    echo -e "${YELLOW}[WARN]${NC} $1"
}

error() {
    echo -e "${RED}[ERROR]${NC} $1"
    exit 1
}

# Show help
show_help() {
    echo ""
    echo "╔═══════════════════════════════════════════════════════════════╗"
    echo "║                   VibeCoding Installer                        ║"
    echo "║               https://github.com/startvibecoding/vibecoding    ║"
    echo "║                  Author: zhenruyan | pkold.com                ║"
    echo "╚═══════════════════════════════════════════════════════════════╝"
    echo ""
    echo "Usage: install.sh [OPTIONS]"
    echo ""
    echo "Options:"
    echo "  -h, --help        Show this help message"
    echo "  -u, --uninstall   Uninstall VibeCoding"
    echo "  -d, --dir DIR     Install to DIR (default: auto-detect)"
    echo ""
    echo "Environment variables:"
    echo "  INSTALL_DIR       Install directory (same as -d)"
    echo ""
    echo "Examples:"
    echo "  # Install (default)"
    echo "  curl -fsSL https://gitee.com/startvibecoding/vibecoding/raw/main/install.sh | bash"
    echo ""
    echo "  # Install to custom directory"
    echo "  curl -fsSL https://gitee.com/startvibecoding/vibecoding/raw/main/install.sh | bash -s -- -d ~/.local/bin"
    echo ""
    echo "  # Uninstall"
    echo "  curl -fsSL https://gitee.com/startvibecoding/vibecoding/raw/main/install.sh | bash -s -- --uninstall"
    echo ""
    echo "  # Or download and run"
    echo "  ./install.sh --uninstall"
    echo ""
}

# Uninstall VibeCoding
uninstall() {
    echo ""
    echo "╔═══════════════════════════════════════════════════════════════╗"
    echo "║                 VibeCoding Uninstaller                        ║"
    echo "╚═══════════════════════════════════════════════════════════════╝"
    echo ""

    # Find vibecoding binary
    local binary_path=""
    local found_paths=()

    # Check common install locations
    for dir in "/usr/local/bin" "$USER_INSTALL_DIR" "$HOME/.local/bin"; do
        if [ -f "$dir/$BINARY_NAME" ]; then
            found_paths+=("$dir/$BINARY_NAME")
        fi
    done

    # Also check PATH
    if command -v "$BINARY_NAME" &> /dev/null; then
        local which_path
        which_path=$(which "$BINARY_NAME" 2>/dev/null || true)
        if [ -n "$which_path" ] && [[ ! " ${found_paths[*]} " =~ " ${which_path} " ]]; then
            found_paths+=("$which_path")
        fi
    fi

    if [ ${#found_paths[@]} -eq 0 ]; then
        warn "VibeCoding not found in common locations"
        echo ""
        echo "Checked locations:"
        echo "  - /usr/local/bin/$BINARY_NAME"
        echo "  - $USER_INSTALL_DIR/$BINARY_NAME"
        echo "  - $HOME/.local/bin/$BINARY_NAME"
        echo ""
        echo "If installed elsewhere, remove it manually:"
        echo "  rm <path>/$BINARY_NAME"
        echo ""
        return 0
    fi

    # Show found installations
    info "Found VibeCoding installations:"
    echo ""
    for p in "${found_paths[@]}"; do
        echo "  - $p"
    done
    echo ""

    # Ask for confirmation
    local answer
    read -rp "Remove all installations? [y/N] " answer
    answer="${answer:-N}"

    if [[ ! "$answer" =~ ^[Yy]$ ]]; then
        info "Uninstall cancelled"
        return 0
    fi

    # Remove binaries
    echo ""
    for p in "${found_paths[@]}"; do
        if [ -f "$p" ]; then
            if [ -w "$(dirname "$p")" ]; then
                rm -f "$p"
                success "Removed: $p"
            else
                info "Need sudo to remove: $p"
                sudo rm -f "$p" && success "Removed: $p" || warn "Failed to remove: $p"
            fi
        fi
    done

    # Ask about config and sessions
    echo ""
    local config_dir="${HOME}/.vibecoding"
    if [ -d "$config_dir" ]; then
        info "Config directory: $config_dir"
        echo ""
        read -rp "Remove config directory ($config_dir)? [y/N] " answer
        answer="${answer:-N}"

        if [[ "$answer" =~ ^[Yy]$ ]]; then
            rm -rf "$config_dir"
            success "Removed: $config_dir"
        else
            info "Kept: $config_dir"
        fi
    fi

    # Ask about project .vibe directory
    echo ""
    local project_vibe="./.vibe"
    if [ -d "$project_vibe" ]; then
        info "Project config found: $project_vibe"
        read -rp "Remove project config ($project_vibe)? [y/N] " answer
        answer="${answer:-N}"

        if [[ "$answer" =~ ^[Yy]$ ]]; then
            rm -rf "$project_vibe"
            success "Removed: $project_vibe"
        else
            info "Kept: $project_vibe"
        fi
    fi

    # Clean PATH entries
    echo ""
    info "Checking shell config for PATH entries..."
    local config_file
    config_file=$(detect_shell_config)

    if [ -f "$config_file" ] && grep -q "\.vibecoding/bin" "$config_file" 2>/dev/null; then
        info "Found PATH entry in: $config_file"
        read -rp "Remove PATH entry from $config_file? [y/N] " answer
        answer="${answer:-N}"

        if [[ "$answer" =~ ^[Yy]$ ]]; then
            # Remove VibeCoding PATH entry (works for bash/zsh)
            sed -i.bak '/# VibeCoding/,+1d' "$config_file"
            rm -f "${config_file}.bak"
            success "Removed PATH entry from $config_file"
        fi
    fi

    # Uninstall npm package if installed via npm
    echo ""
    if command -v npm &> /dev/null; then
        local npm_global
        npm_global=$(npm root -g 2>/dev/null || true)
        if [ -n "$npm_global" ] && [ -d "$npm_global/vibecoding-installer" ]; then
            info "Found npm global installation"
            read -rp "Uninstall npm package (vibecoding-installer)? [y/N] " answer
            answer="${answer:-N}"

            if [[ "$answer" =~ ^[Yy]$ ]]; then
                npm uninstall -g vibecoding-installer && success "Uninstalled npm package" || warn "Failed to uninstall npm package"
            fi
        fi
    fi

    echo ""
    success "Uninstall complete!"
    echo ""
    echo "  Thank you for using VibeCoding! 🙏"
    echo ""
    echo "  If you have any feedback, please visit:"
    echo "    - GitHub: https://github.com/startvibecoding/vibecoding"
    echo "    - Gitee:  https://gitee.com/startvibecoding/vibecoding"
    echo ""
}

# Detect OS and architecture
detect_platform() {
    local os arch

    case "$(uname -s)" in
        Linux*)     os="linux" ;;
        Darwin*)    os="darwin" ;;
        FreeBSD*)   os="freebsd" ;;
        CYGWIN*|MINGW*|MSYS*) os="windows" ;;
        *)          error "Unsupported OS: $(uname -s)" ;;
    esac

    case "$(uname -m)" in
        x86_64|amd64)   arch="amd64" ;;
        aarch64|arm64)   arch="arm64" ;;
        armv7l|armhf)    arch="arm" ;;
        *)               error "Unsupported architecture: $(uname -m)" ;;
    esac

    echo "${os}/${arch}"
}

# Get latest release version from GitHub
get_latest_version() {
    local version
    version=$(curl -sL "https://api.github.com/repos/${REPO}/releases/latest" | grep '"tag_name"' | sed -E 's/.*"([^"]+)".*/\1/')
    
    if [ -z "$version" ]; then
        error "Failed to fetch latest version from GitHub"
    fi
    
    echo "$version"
}

# Download file
download() {
    local url="$1"
    local dest="$2"
    
    info "Downloading: ${url}"
    
    if command -v curl &> /dev/null; then
        curl -sL -o "$dest" "$url"
    elif command -v wget &> /dev/null; then
        wget -qO "$dest" "$url"
    else
        error "Neither curl nor wget found. Please install one of them."
    fi
}

# Verify checksum
verify_checksum() {
    local file="$1"
    local checksum_file="$2"
    
    if [ ! -f "$checksum_file" ]; then
        warn "Checksum file not found, skipping verification"
        return 0
    fi
    
    local expected
    expected=$(grep "$(basename "$file")" "$checksum_file" | awk '{print $1}' || true)
    
    if [ -z "$expected" ]; then
        warn "Checksum not found for $(basename "$file")"
        return 0
    fi
    
    local actual
    if command -v sha256sum &> /dev/null; then
        actual=$(sha256sum "$file" | awk '{print $1}')
    elif command -v shasum &> /dev/null; then
        actual=$(shasum -a 256 "$file" | awk '{print $1}')
    else
        warn "No sha256sum or shasum found, skipping verification"
        return 0
    fi
    
    if [ "$actual" != "$expected" ]; then
        error "Checksum mismatch: expected ${expected}, got ${actual}"
    fi
    
    success "Checksum verified"
}

# Install binary (no sudo for user-level install)
install_binary() {
    local binary_path="$1"
    
    # Create install directory if it doesn't exist
    if [ ! -d "$INSTALL_DIR" ]; then
        info "Creating install directory: ${INSTALL_DIR}"
        mkdir -p "$INSTALL_DIR" || error "Failed to create ${INSTALL_DIR}. Check permissions."
    fi
    
    # Install binary
    mv "$binary_path" "${INSTALL_DIR}/${BINARY_NAME}"
    chmod +x "${INSTALL_DIR}/${BINARY_NAME}"
    
    success "Installed ${BINARY_NAME} to ${INSTALL_DIR}/${BINARY_NAME}"
}

# Detect user's shell and config file
detect_shell_config() {
    local shell_name
    shell_name="$(basename "${SHELL:-bash}")"
    
    case "$shell_name" in
        zsh)
            # Prefer .zshenv for PATH (loaded by all zsh modes)
            if [ -f "${HOME}/.zshenv" ]; then
                echo "${HOME}/.zshenv"
            elif [ -f "${HOME}/.zshrc" ]; then
                echo "${HOME}/.zshrc"
            else
                echo "${HOME}/.zshenv"
            fi
            ;;
        bash)
            # macOS uses login shells by default, so .bash_profile takes precedence
            if [ "$(uname -s)" = "Darwin" ]; then
                if [ -f "${HOME}/.bash_profile" ]; then
                    echo "${HOME}/.bash_profile"
                elif [ -f "${HOME}/.bashrc" ]; then
                    echo "${HOME}/.bashrc"
                else
                    echo "${HOME}/.bash_profile"
                fi
            else
                if [ -f "${HOME}/.bashrc" ]; then
                    echo "${HOME}/.bashrc"
                elif [ -f "${HOME}/.bash_profile" ]; then
                    echo "${HOME}/.bash_profile"
                else
                    echo "${HOME}/.bashrc"
                fi
            fi
            ;;
        fish)
            echo "${HOME}/.config/fish/config.fish"
            ;;
        *)
            echo "${HOME}/.profile"
            ;;
    esac
}

# Add INSTALL_DIR to PATH in shell config
add_to_path() {
    local config_file="$1"
    local config_dir
    config_dir="$(dirname "$config_file")"
    
    # Create config directory if needed (e.g. ~/.config/fish/)
    if [ ! -d "$config_dir" ]; then
        mkdir -p "$config_dir"
    fi
    
    # Create config file if it doesn't exist
    if [ ! -f "$config_file" ]; then
        touch "$config_file"
    fi
    
    # Check if already in PATH config
    if grep -q "\.vibecoding/bin" "$config_file" 2>/dev/null; then
        info "PATH already configured in ${config_file}"
        return 0
    fi
    
    local shell_name
    shell_name="$(basename "${SHELL:-bash}")"
    
    local path_line
    case "$shell_name" in
        fish)
            # Single-quote $PATH to prevent bash from expanding it
            path_line="set -gx PATH ${INSTALL_DIR} "'$PATH'
            ;;
        *)
            path_line="export PATH=\"${INSTALL_DIR}:\$PATH\""
            ;;
    esac
    
    echo "" >> "$config_file"
    echo "# VibeCoding" >> "$config_file"
    echo "$path_line" >> "$config_file"
    
    success "Added ${INSTALL_DIR} to PATH in ${config_file}"
}

# Check if installed directory is in PATH
check_path() {
    local config_file
    config_file=$(detect_shell_config)

    # First check if already configured in shell config file
    if [ -f "$config_file" ] && grep -q "\.vibecoding/bin" "$config_file" 2>/dev/null; then
        # Already in config, but check if it's in current session too
        if echo "$PATH" | tr ':' '\n' | grep -qx "$INSTALL_DIR"; then
            return 0
        fi
        info "PATH already configured in ${config_file} but not active in current session"
        warn "Run: source ${config_file}"
        return 0
    fi

    # If already in current PATH, nothing to do
    if echo "$PATH" | tr ':' '\n' | grep -qx "$INSTALL_DIR"; then
        return 0
    fi
    
    # For user-level install, auto-add to shell config
    if [ "$INSTALL_DIR" = "$USER_INSTALL_DIR" ]; then
        echo ""
        info "Detected shell: $(basename "${SHELL:-bash}")"
        info "Shell config: ${config_file}"
        echo ""
        
        # Ask user (default yes)
        local answer
        read -rp "Add ${INSTALL_DIR} to PATH automatically? [Y/n] " answer
        answer="${answer:-Y}"
        
        if [[ "$answer" =~ ^[Yy]$ ]]; then
            add_to_path "$config_file"
            echo ""
            warn "Run this to apply immediately:"
            echo ""
            local shell_name
            shell_name="$(basename "${SHELL:-bash}")"
            case "$shell_name" in
                fish)
                    echo -e "  ${CYAN}source ${config_file}${NC}"
                    ;;
                *)
                    echo -e "  ${CYAN}source ${config_file}${NC}"
                    ;;
            esac
            echo ""
        else
            warn "${INSTALL_DIR} is not in your PATH"
            echo ""
            echo "Add it manually to your shell configuration:"
            echo ""
            echo -e "  ${CYAN}# bash/zsh:${NC}"
            echo -e "  ${CYAN}export PATH=\"${INSTALL_DIR}:\$PATH\"${NC}"
            echo ""
            echo -e "  ${CYAN}# fish:${NC}"
            echo -e "  ${CYAN}set -gx PATH ${INSTALL_DIR} \$PATH${NC}"
            echo ""
        fi
    else
        # System install dir not in PATH (unusual)
        warn "${INSTALL_DIR} is not in your PATH"
        echo ""
        echo "Add it to your shell configuration:"
        echo ""
        echo "  For bash/zsh:"
        echo "    export PATH=\"${INSTALL_DIR}:\$PATH\""
        echo ""
        echo "  For fish:"
        echo "    set -gx PATH ${INSTALL_DIR} \$PATH"
        echo ""
    fi
}

# Main installation
main_install() {
    echo ""
    echo "╔═══════════════════════════════════════════════════════════════╗"
    echo "║                   VibeCoding Installer                        ║"
    echo "║               https://github.com/startvibecoding/vibecoding    ║"
    echo "║                  Author: zhenruyan | pkold.com                ║"
    echo "╚═══════════════════════════════════════════════════════════════╝"
    echo ""
    
    # Show install mode
    if [ "$INSTALL_DIR" = "$USER_INSTALL_DIR" ]; then
        info "Install mode: user-level (no root required)"
    else
        info "Install mode: system-level"
    fi
    info "Install directory: ${INSTALL_DIR}"
    echo ""
    
    # Detect platform
    local platform
    platform=$(detect_platform)
    local os="${platform%/*}"
    local arch="${platform#*/}"
    info "Detected platform: ${os}/${arch}"
    
    # Get latest version
    local version
    version=$(get_latest_version)
    info "Latest version: ${version}"
    
    # Construct download URL
    local archive_name
    local version_num="${version#v}"
    if [ "$os" = "windows" ]; then
        archive_name="${BINARY_NAME}-${version_num}-${os}-${arch}.zip"
    else
        archive_name="${BINARY_NAME}-${version_num}-${os}-${arch}.tar.gz"
    fi
    
    local download_url="https://github.com/${REPO}/releases/download/${version}/${archive_name}"
    local checksum_url="https://github.com/${REPO}/releases/download/${version}/checksums.txt"
    
    # Create temp directory
    local tmp_dir
    tmp_dir=$(mktemp -d)
    trap "rm -rf ${tmp_dir}" EXIT
    
    # Download archive
    local archive_path="${tmp_dir}/${archive_name}"
    download "$download_url" "$archive_path"
    
    # Download and verify checksum
    local checksum_path="${tmp_dir}/checksums.txt"
    download "$checksum_url" "$checksum_path" 2>/dev/null || true
    verify_checksum "$archive_path" "$checksum_path"
    
    # Extract archive
    info "Extracting archive..."
    local binary_path="${tmp_dir}/${BINARY_NAME}"
    
    if [ "$os" = "windows" ]; then
        if command -v unzip &> /dev/null; then
            unzip -q "$archive_path" -d "$tmp_dir"
        else
            error "unzip not found. Please install unzip."
        fi
        binary_path="${tmp_dir}/${BINARY_NAME}.exe"
    else
        tar -xzf "$archive_path" -C "$tmp_dir"
    fi
    
    if [ ! -f "$binary_path" ]; then
        error "Binary not found in archive"
    fi
    
    # Install binary (no sudo needed for user-level)
    install_binary "$binary_path"
    
    # Check PATH and offer to configure
    check_path
    
    # Determine config directory based on platform
    local config_dir
    case "$(uname -s)" in
        Darwin*|Linux*)
            config_dir="${HOME}/.vibecoding"
            ;;
        *)
            config_dir="${HOME}/.vibecoding"
            ;;
    esac

    # Verify installation
    echo ""
    success "Installation complete!"
    echo ""
    echo "  Install directory: ${INSTALL_DIR}/${BINARY_NAME}"
    echo "  Config directory : ${config_dir}"
    echo "    - Settings file: ${config_dir}/settings.json"
    echo ""

    if command -v "$BINARY_NAME" &> /dev/null; then
        local installed_version
        installed_version=$("$BINARY_NAME" --version 2>/dev/null || echo "unknown")
        echo "  Version: ${installed_version}"
        echo ""
        echo "  Get started:"
        echo "    ${BINARY_NAME} --help"
        echo ""
    else
        warn "'${BINARY_NAME}' is not found in your current PATH."
        echo ""
        echo "  Add it to your PATH manually:"
        echo ""
        local shell_name
        shell_name="$(basename "${SHELL:-bash}")"
        case "$shell_name" in
            fish)
                echo -e "  ${CYAN}# Fish${NC}"
                echo -e "  ${CYAN}set -gx PATH ${INSTALL_DIR} \$PATH${NC}"
                echo -e "  ${CYAN}# Or add to ~/.config/fish/config.fish:${NC}"
                echo -e "  ${CYAN}set -gx PATH ${INSTALL_DIR} \$PATH${NC}"
                ;;
            zsh)
                echo -e "  ${CYAN}# Zsh${NC}"
                echo -e "  ${CYAN}export PATH=\"${INSTALL_DIR}:\$PATH\"${NC}"
                echo -e "  ${CYAN}# Or add to ~/.zshenv:${NC}"
                echo -e "  ${CYAN}echo 'export PATH=\"${INSTALL_DIR}:\$PATH\"' >> ~/.zshenv${NC}"
                ;;
            bash)
                echo -e "  ${CYAN}# Bash${NC}"
                echo -e "  ${CYAN}export PATH=\"${INSTALL_DIR}:\$PATH\"${NC}"
                if [ "$(uname -s)" = "Darwin" ]; then
                    echo -e "  ${CYAN}# Or add to ~/.bash_profile:${NC}"
                    echo -e "  ${CYAN}echo 'export PATH=\"${INSTALL_DIR}:\$PATH\"' >> ~/.bash_profile${NC}"
                else
                    echo -e "  ${CYAN}# Or add to ~/.bashrc:${NC}"
                    echo -e "  ${CYAN}echo 'export PATH=\"${INSTALL_DIR}:\$PATH\"' >> ~/.bashrc${NC}"
                fi
                ;;
            *)
                echo -e "  ${CYAN}export PATH=\"${INSTALL_DIR}:\$PATH\"${NC}"
                echo -e "  ${CYAN}# Add the above line to your shell config file${NC}"
                ;;
        esac
        echo ""
    fi
}

# Parse arguments
ACTION="install"

while [[ $# -gt 0 ]]; do
    case "$1" in
        -h|--help)
            show_help
            exit 0
            ;;
        -u|--uninstall)
            ACTION="uninstall"
            shift
            ;;
        -d|--dir)
            if [ -z "${2:-}" ]; then
                error "Option $1 requires an argument"
            fi
            INSTALL_DIR="$2"
            shift 2
            ;;
        *)
            error "Unknown option: $1\nUse --help for usage information"
            ;;
    esac
done

# Execute action
case "$ACTION" in
    install)
        main_install
        ;;
    uninstall)
        uninstall
        ;;
esac