lacy 1.8.11 → 1.8.13

package/install.sh

@@ -0,0 +1,1009 @@
+#!/usr/bin/env bash
+
+# Lacy Shell Installation Script
+# https://github.com/lacymorrow/lacy
+#
+# Install methods:
+#   curl -fsSL https://lacy.sh/install | bash
+#   npx lacy
+#   brew install lacymorrow/tap/lacy
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+MAGENTA='\033[0;35m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+DIM='\033[2m'
+NC='\033[0m' # No Color
+
+# Installation directory
+INSTALL_DIR="${HOME}/.lacy"
+REPO_URL="https://github.com/lacymorrow/lacy.git"
+TARBALL_URL="https://github.com/lacymorrow/lacy/archive/refs/heads"
+CONFIG_FILE="${INSTALL_DIR}/config.yaml"
+
+# Release channel (set via --beta, --channel, or LACY_CHANNEL env var)
+LACY_CHANNEL="${LACY_CHANNEL:-latest}"
+
+# Analytics — lightweight, anonymous install tracking via Umami
+# No PII collected. Respects DO_NOT_TRACK. See: https://umami.is
+UMAMI_URL="${LACY_UMAMI_URL:-https://analytics.lacy.sh}"
+UMAMI_WEBSITE_ID="${LACY_UMAMI_WEBSITE_ID:-577521d7-3db7-4a77-a45c-3c97f21b5322}"
+
+track_event() {
+    [[ "${DO_NOT_TRACK:-}" == "1" ]] && return
+    [[ "${LACY_NO_TELEMETRY:-}" == "1" ]] && return
+
+    local event_name="${1:-install}"
+    local method="${2:-curl}"
+    local version
+    version=$(get_installed_version)
+
+    (curl -sf --connect-timeout 3 --max-time 5 -X POST "${UMAMI_URL}/api/send" \
+        -H "Content-Type: application/json" \
+        -H "User-Agent: lacy-install/${version:-unknown}" \
+        -d "{
+            \"type\": \"event\",
+            \"payload\": {
+                \"hostname\": \"lacy.sh\",
+                \"language\": \"\",
+                \"referrer\": \"\",
+                \"screen\": \"\",
+                \"title\": \"Install\",
+                \"url\": \"/install/${method}\",
+                \"website\": \"${UMAMI_WEBSITE_ID}\",
+                \"name\": \"${event_name}\",
+                \"data\": {
+                    \"method\": \"${method}\",
+                    \"os\": \"$(uname -s 2>/dev/null || echo unknown)\",
+                    \"arch\": \"$(uname -m 2>/dev/null || echo unknown)\",
+                    \"shell\": \"${DETECTED_SHELL:-unknown}\",
+                    \"version\": \"${version:-unknown}\",
+                    \"channel\": \"${LACY_CHANNEL}\"
+                }
+            }
+        }" >/dev/null 2>&1 &)
+}
+
+# Validate channel — alphanumeric, hyphens, dots only
+if [[ ! "$LACY_CHANNEL" =~ ^[a-zA-Z0-9._-]+$ ]]; then
+    printf "${RED}Invalid channel: %s${NC}\n" "$LACY_CHANNEL" >&2
+    exit 1
+fi
+
+# Version — read from installed or repo package.json
+get_installed_version() {
+    local pkg_file="${INSTALL_DIR}/package.json"
+    if [[ -f "$pkg_file" ]]; then
+        grep '"version"' "$pkg_file" 2>/dev/null | head -1 | sed 's/.*"version"[[:space:]]*:[[:space:]]*"//' | sed 's/".*//'
+    fi
+}
+
+# Selected tool (set during installation)
+SELECTED_TOOL=""
+CUSTOM_COMMAND=""
+
+# Detected shell (set during installation)
+DETECTED_SHELL=""
+
+# Detect user's login shell
+detect_user_shell() {
+    if [[ -n "$LACY_FORCE_SHELL" ]]; then
+        DETECTED_SHELL="$LACY_FORCE_SHELL"
+        return
+    fi
+
+    local login_shell
+    login_shell=$(basename "${SHELL:-}")
+
+    case "$login_shell" in
+        zsh)  DETECTED_SHELL="zsh" ;;
+        bash) DETECTED_SHELL="bash" ;;
+        fish) DETECTED_SHELL="fish" ;;
+        *)
+            # Detect from running process or what's available
+            if [[ -n "${BASH_VERSION:-}" ]]; then
+                DETECTED_SHELL="bash"
+            elif [[ -n "${ZSH_VERSION:-}" ]]; then
+                DETECTED_SHELL="zsh"
+            elif command -v zsh >/dev/null 2>&1; then
+                DETECTED_SHELL="zsh"
+            elif command -v bash >/dev/null 2>&1; then
+                DETECTED_SHELL="bash"
+            else
+                DETECTED_SHELL="bash"
+            fi
+            ;;
+    esac
+}
+
+# Get the RC file for the detected shell
+get_rc_file() {
+    case "$DETECTED_SHELL" in
+        bash)
+            # macOS uses .bash_profile for login shells
+            if [[ "$OSTYPE" == "darwin"* ]]; then
+                echo "${HOME}/.bash_profile"
+            else
+                echo "${HOME}/.bashrc"
+            fi
+            ;;
+        fish) echo "${HOME}/.config/fish/conf.d/lacy.fish" ;;
+        *)    echo "${HOME}/.zshrc" ;;
+    esac
+}
+
+# Get the plugin file for the detected shell
+get_plugin_file() {
+    case "$DETECTED_SHELL" in
+        bash) echo "lacy.plugin.bash" ;;
+        fish) echo "lacy.plugin.fish" ;;
+        *)    echo "lacy.plugin.zsh" ;;
+    esac
+}
+
+# Get the shell restart command
+get_shell_restart_cmd() {
+    case "$DETECTED_SHELL" in
+        bash) echo "bash -l" ;;
+        fish) echo "fish" ;;
+        *)    echo "zsh -l" ;;
+    esac
+}
+
+# Get the source command for the RC file
+get_source_hint() {
+    local rc_file
+    rc_file=$(get_rc_file)
+    echo "source $rc_file"
+}
+
+# Check if we should use Node installer
+use_node_installer() {
+    # Skip Node installer if --bash flag is passed
+    [[ "$LACY_FORCE_BASH" == "1" ]] && return 1
+
+    # Check if npx is available and we have an interactive terminal
+    # Note: when piped (curl | bash), -t 0 is false but /dev/tty is still available
+    if command -v npx >/dev/null 2>&1 && { [[ -t 0 ]] || [[ -c /dev/tty ]]; }; then
+        return 0
+    fi
+    return 1
+}
+
+# Run Node installer via npx
+run_node_installer() {
+    local pkg="lacy@${LACY_CHANNEL}"
+
+    # Quietly check if package exists first
+    if ! npm view "$pkg" version >/dev/null 2>&1; then
+        return 1
+    fi
+
+    if [[ "$LACY_CHANNEL" != "latest" ]]; then
+        printf "${MAGENTA}Channel: ${LACY_CHANNEL}${NC}\n"
+    fi
+    printf "${BLUE}Using interactive installer...${NC}\n"
+    printf "\n"
+    # Redirect stdin from /dev/tty so the Node process gets an interactive TTY
+    # even when this script is piped (curl | bash)
+    if npx --yes "$pkg" < /dev/tty; then
+        # Restore terminal state — the Node process uses @clack/prompts which
+        # toggles raw mode on the tty. If Node exits without restoring it
+        # (crash, SIGINT, etc.), the parent shell's tty is left corrupted.
+        stty sane 2>/dev/null
+        exit 0
+    fi
+
+    # npx failed for some reason, fall back
+    # Restore terminal state in case Node corrupted it before failing
+    stty sane 2>/dev/null
+    printf "\n"
+    printf "${YELLOW}Falling back to standard installer...${NC}\n"
+    printf "\n"
+    return 1
+}
+
+print_banner() {
+    printf "\n"
+    printf "${MAGENTA}${BOLD}"
+    printf "  _                      \n"
+    printf " | |    __ _  ___ _   _  \n"
+    printf " | |   / _\` |/ __| | | | \n"
+    printf " | |__| (_| | (__| |_| | \n"
+    printf " |_____\__,_|\___|\__, | \n"
+    printf "                  |___/  \n"
+    printf "${NC}"
+    printf "${CYAN}Talk directly to your shell${NC}\n"
+    local version
+    version=$(get_installed_version)
+    if [[ -n "$version" ]]; then
+        printf "${DIM}  v${version}${NC}\n"
+    fi
+    if [[ "$LACY_CHANNEL" != "latest" ]]; then
+        printf "${MAGENTA}${BOLD}  [${LACY_CHANNEL}]${NC}\n"
+    fi
+    printf "\n"
+}
+
+# Check prerequisites
+check_prerequisites() {
+    printf "${BLUE}Checking prerequisites...${NC}\n"
+    local missing=0
+
+    # Check for the target shell
+    case "$DETECTED_SHELL" in
+        zsh)
+            if command -v zsh >/dev/null 2>&1; then
+                printf "  ${GREEN}✓${NC} zsh\n"
+            else
+                printf "  ${RED}✗${NC} zsh (required)\n"
+                missing=1
+            fi
+            ;;
+        bash)
+            if command -v bash >/dev/null 2>&1; then
+                local bash_version user_bash
+                # Use the user's $SHELL if it's bash — on macOS, plain `bash` resolves
+                # to /bin/bash (3.2) even when the user has a newer bash as their shell
+                case "${SHELL:-}" in
+                    */bash) user_bash="$SHELL" ;;
+                    *)      user_bash="bash" ;;
+                esac
+                bash_version=$("$user_bash" -c 'echo ${BASH_VERSINFO[0]}' 2>/dev/null || bash -c 'echo ${BASH_VERSINFO[0]}' 2>/dev/null || echo "0")
+                if [[ "$bash_version" -ge 4 ]]; then
+                    printf "  ${GREEN}✓${NC} bash ${bash_version}+\n"
+                else
+                    printf "  ${RED}✗${NC} bash 4+ required (found bash ${bash_version})\n"
+                    printf "    ${DIM}Install with: brew install bash${NC}\n"
+                    missing=1
+                fi
+            else
+                printf "  ${RED}✗${NC} bash (required)\n"
+                missing=1
+            fi
+            ;;
+    esac
+
+    # Check for curl
+    if command -v curl >/dev/null 2>&1; then
+        printf "  ${GREEN}✓${NC} curl\n"
+    else
+        printf "  ${RED}✗${NC} curl (required)\n"
+        missing=1
+    fi
+
+    # Check for git (optional — curl fallback available)
+    if command -v git >/dev/null 2>&1; then
+        printf "  ${GREEN}✓${NC} git\n"
+    else
+        printf "  ${YELLOW}○${NC} git (not found, will use curl fallback)\n"
+    fi
+
+    printf "\n"
+
+    if [[ $missing -eq 1 ]]; then
+        printf "${RED}Please install missing prerequisites and try again.${NC}\n"
+        exit 1
+    fi
+}
+
+# Detect installed AI CLI tools
+detect_tools() {
+    printf "${BLUE}Detecting AI CLI tools...${NC}\n"
+    local found=0
+
+    for tool in lash claude opencode gemini codex hermes copilot amp; do
+        if command -v "$tool" >/dev/null 2>&1; then
+            printf "  ${GREEN}✓${NC} $tool\n"
+            found=1
+        fi
+    done
+
+    if [[ $found -eq 0 ]]; then
+        printf "  ${YELLOW}○${NC} No AI CLI tools found\n"
+        printf "\n"
+        printf "${YELLOW}Lacy Shell requires an AI CLI tool to work.${NC}\n"
+        printf "Would you like to install ${GREEN}lash${NC}? (AI coding agent — lash.lacy.sh)\n"
+        printf "\n"
+        read -p "Install lash now? [Y/n]: " install_now < /dev/tty 2>/dev/null || install_now="n"
+        if [[ ! "$install_now" =~ ^[Nn]$ ]]; then
+            install_lash
+            printf "\n"
+            # Re-check if lash was installed successfully
+            if command -v lash >/dev/null 2>&1; then
+                printf "  ${GREEN}✓${NC} lash\n"
+            fi
+        fi
+    fi
+
+    printf "\n"
+}
+
+# Interactive tool selection (bash fallback)
+select_tool() {
+    printf "${BOLD}Which AI CLI tool do you want to use?${NC}\n"
+    printf "\n"
+    printf "  1) lash       ${DIM}- AI coding agent (recommended) — lash.lacy.sh${NC}\n"
+    printf "  2) claude     ${DIM}- Claude Code CLI${NC}\n"
+    printf "  3) opencode   ${DIM}- OpenCode CLI${NC}\n"
+    printf "  4) gemini     ${DIM}- Google Gemini CLI${NC}\n"
+    printf "  5) codex      ${DIM}- OpenAI Codex CLI${NC}\n"
+    printf "  6) hermes     ${DIM}- Hermes Agent CLI${NC}\n"
+    printf "  7) copilot    ${DIM}- GitHub Copilot CLI${NC}\n"
+    printf "  8) amp        ${DIM}- Sourcegraph Amp CLI${NC}\n"
+    printf "  9) Auto-detect ${DIM}(use first available)${NC}\n"
+    printf " 10) None       ${DIM}- I'll install one later${NC}\n"
+    printf " 11) Custom     ${DIM}- enter your own command${NC}\n"
+    printf "\n"
+
+    local choice
+    read -p "Select [1-11, default=9]: " choice < /dev/tty 2>/dev/null || choice="9"
+
+    case "$choice" in
+        1) SELECTED_TOOL="lash" ;;
+        2) SELECTED_TOOL="claude" ;;
+        3) SELECTED_TOOL="opencode" ;;
+        4) SELECTED_TOOL="gemini" ;;
+        5) SELECTED_TOOL="codex" ;;
+        6) SELECTED_TOOL="hermes" ;;
+        7) SELECTED_TOOL="copilot" ;;
+        8) SELECTED_TOOL="amp" ;;
+        9|"") SELECTED_TOOL="" ;;
+        10) SELECTED_TOOL="none" ;;
+        11)
+            SELECTED_TOOL="custom"
+            printf "\n"
+            read -p "Enter command (e.g. claude --dangerously-skip-permissions -p): " CUSTOM_COMMAND < /dev/tty 2>/dev/null || CUSTOM_COMMAND=""
+            if [[ -z "$CUSTOM_COMMAND" ]]; then
+                printf "${RED}No command entered. Falling back to auto-detect.${NC}\n"
+                SELECTED_TOOL=""
+            fi
+            ;;
+        *) SELECTED_TOOL="" ;;
+    esac
+
+    if [[ -n "$SELECTED_TOOL" && "$SELECTED_TOOL" != "none" && "$SELECTED_TOOL" != "custom" ]]; then
+        printf "\n"
+        printf "Selected: ${GREEN}$SELECTED_TOOL${NC}\n"
+
+        # Check if selected tool is installed
+        if ! command -v "$SELECTED_TOOL" >/dev/null 2>&1; then
+            printf "${YELLOW}Note: $SELECTED_TOOL is not installed.${NC}\n"
+
+            if [[ "$SELECTED_TOOL" == "lash" ]]; then
+                printf "\n"
+                read -p "Would you like to install lash now? [y/N]: " do_install_lash < /dev/tty 2>/dev/null || do_install_lash="n"
+                if [[ "$do_install_lash" =~ ^[Yy]$ ]]; then
+                    install_lash
+                fi
+            else
+                printf "You can install it later with:\n"
+                case "$SELECTED_TOOL" in
+                    claude) printf "  brew install claude\n" ;;
+                    opencode) printf "  brew install opencode\n" ;;
+                    gemini) printf "  brew install gemini\n" ;;
+                    codex) printf "  npm install -g @openai/codex\n" ;;
+                    hermes) printf "  curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash\n" ;;
+                    copilot) printf "  gh extension install github/gh-copilot\n" ;;
+                    amp) printf "  npm install -g @sourcegraph/amp\n" ;;
+                esac
+            fi
+        fi
+    elif [[ "$SELECTED_TOOL" == "custom" ]]; then
+        printf "\n"
+        printf "Selected: ${GREEN}custom${NC} (${CUSTOM_COMMAND})\n"
+    elif [[ "$SELECTED_TOOL" == "none" ]]; then
+        printf "\n"
+        printf "No tool selected. Lacy will prompt you to install one when needed.\n"
+    else
+        # Auto-detect: check if any tool is available
+        printf "\n"
+        local first_tool_found=""
+        for t in lash claude opencode gemini codex hermes copilot amp; do
+            if command -v "$t" >/dev/null 2>&1; then
+                first_tool_found="$t"
+                break
+            fi
+        done
+
+        if [[ -z "$first_tool_found" ]]; then
+            printf "${YELLOW}No AI CLI tools are installed.${NC}\n"
+            printf "Would you like to install ${GREEN}lash${NC}? (AI coding agent — lash.lacy.sh)\n"
+            printf "\n"
+            local do_install=""
+            read -p "Install lash now? [Y/n]: " do_install < /dev/tty 2>/dev/null || do_install="n"
+            if [[ ! "$do_install" =~ ^[Nn]$ ]]; then
+                install_lash
+            else
+                printf "\n"
+                printf "Using: ${GREEN}auto-detect${NC} (first available tool)\n"
+                printf "${YELLOW}Note: You'll need to install a tool before using Lacy.${NC}\n"
+            fi
+        else
+            printf "Using: ${GREEN}auto-detect${NC} (currently: ${GREEN}${first_tool_found}${NC})\n"
+        fi
+    fi
+
+    printf "\n"
+}
+
+# Install lash CLI
+install_lash() {
+    printf "${BLUE}Installing lash...${NC}\n"
+
+    if command -v npm >/dev/null 2>&1; then
+        npm install -g lashcode
+        printf "${GREEN}✓ lash installed${NC}\n"
+    elif command -v brew >/dev/null 2>&1; then
+        brew tap lacymorrow/tap
+        brew install lash
+        printf "${GREEN}✓ lash installed${NC}\n"
+    else
+        printf "${RED}Could not install lash. Please install npm or homebrew first.${NC}\n"
+    fi
+}
+
+# Download and extract tarball (curl fallback when git is not available)
+install_via_tarball() {
+    local branch="$1"
+    local tarball_file
+    tarball_file=$(mktemp "${TMPDIR:-/tmp}/lacy-XXXXXX.tar.gz")
+
+    curl -fsSL "${TARBALL_URL}/${branch}.tar.gz" -o "$tarball_file" 2>/dev/null || {
+        rm -f "$tarball_file"
+        return 1
+    }
+
+    mkdir -p "$INSTALL_DIR"
+    tar xzf "$tarball_file" --strip-components=1 -C "$INSTALL_DIR" 2>/dev/null || {
+        rm -f "$tarball_file"
+        return 1
+    }
+
+    rm -f "$tarball_file"
+    return 0
+}
+
+# Clone or update repository
+install_plugin() {
+    printf "${BLUE}Installing Lacy...${NC}\n"
+
+    # Determine git branch: beta channel clones beta branch, otherwise main
+    local branch="main"
+    if [[ "$LACY_CHANNEL" != "latest" ]]; then
+        branch="$LACY_CHANNEL"
+    fi
+
+    local has_git=0
+    command -v git >/dev/null 2>&1 && has_git=1
+
+    if [[ -d "$INSTALL_DIR" ]]; then
+        printf "${YELLOW}Existing installation found. Updating...${NC}\n"
+        if [[ $has_git -eq 1 && -d "$INSTALL_DIR/.git" ]]; then
+            cd "$INSTALL_DIR" || exit 1
+            git pull origin "$branch" 2>/dev/null || git pull origin main 2>/dev/null || git pull 2>/dev/null || {
+                printf "${YELLOW}Could not update, using existing installation${NC}\n"
+            }
+        else
+            install_via_tarball "$branch" || install_via_tarball "main" || {
+                printf "${YELLOW}Could not update, using existing installation${NC}\n"
+            }
+        fi
+    else
+        if [[ $has_git -eq 1 ]]; then
+            git clone --depth 1 -b "$branch" "$REPO_URL" "$INSTALL_DIR" 2>/dev/null || \
+            git clone --depth 1 "$REPO_URL" "$INSTALL_DIR" 2>/dev/null || {
+                # Git failed, try curl fallback
+                install_via_tarball "$branch" || install_via_tarball "main" || {
+                    printf "${RED}Failed to install repository${NC}\n"
+                    exit 1
+                }
+            }
+        else
+            install_via_tarball "$branch" || install_via_tarball "main" || {
+                printf "${RED}Failed to download repository${NC}\n"
+                exit 1
+            }
+        fi
+    fi
+
+    local version
+    version=$(get_installed_version)
+    printf "${GREEN}✓ Lacy installed to $INSTALL_DIR${NC}"
+    [[ -n "$version" ]] && printf " ${DIM}(v${version})${NC}"
+    printf "\n\n"
+
+    track_event "install" "curl"
+}
+
+# Configure shell integration (multi-shell aware)
+configure_shell() {
+    printf "${BLUE}Configuring ${DETECTED_SHELL} shell...${NC}\n"
+
+    local rc_file plugin_file plugin_line rc_name
+
+    rc_file=$(get_rc_file)
+    plugin_file=$(get_plugin_file)
+    rc_name=$(basename "$rc_file")
+
+    plugin_line="source ${INSTALL_DIR}/${plugin_file}"
+
+    # PATH line for the lacy CLI binary
+    local path_line="export PATH=\"${INSTALL_DIR}/bin:\$PATH\""
+
+    # Check if already configured
+    if [[ -f "$rc_file" ]] && grep -q "lacy.plugin" "$rc_file" 2>/dev/null; then
+        printf "${GREEN}✓ Already configured in ${rc_name}${NC}\n"
+
+        # Add PATH if missing (upgrade from older install)
+        if ! grep -q '\.lacy/bin' "$rc_file" 2>/dev/null; then
+            printf "%s\n" "$path_line" >> "$rc_file"
+            printf "${GREEN}✓ Added lacy CLI to PATH in ${rc_name}${NC}\n"
+        fi
+    else
+        # Ensure parent directory exists
+        mkdir -p "$(dirname "$rc_file")"
+
+        # Create RC file if it doesn't exist
+        [[ ! -f "$rc_file" ]] && touch "$rc_file"
+
+        # Add source line + PATH
+        {
+            printf "\n"
+            printf "# Lacy Shell\n"
+            printf "%s\n" "$plugin_line"
+            printf "%s\n" "$path_line"
+        } >> "$rc_file"
+
+        printf "${GREEN}✓ Added to ${rc_name}${NC}\n"
+    fi
+
+    # For Fish: also ensure the conf.d directory exists and use `source` syntax
+    if [[ "$DETECTED_SHELL" == "fish" ]]; then
+        mkdir -p "${HOME}/.config/fish/conf.d"
+        # Fish sources all *.fish files in conf.d automatically — create a loader
+        local fish_conf="${HOME}/.config/fish/conf.d/lacy.fish"
+        if [[ ! -f "$fish_conf" ]]; then
+            printf "source %s/lacy.plugin.fish\n" "${INSTALL_DIR}" > "$fish_conf"
+            printf "${GREEN}✓ Created %s${NC}\n" "$fish_conf"
+        fi
+        return
+    fi
+
+    # For Bash on macOS, also add to .bashrc if it exists (some terminals source it)
+    if [[ "$DETECTED_SHELL" == "bash" && "$OSTYPE" == "darwin"* ]]; then
+        local bashrc="${HOME}/.bashrc"
+        if [[ -f "$bashrc" ]] && ! grep -q "lacy.plugin" "$bashrc" 2>/dev/null; then
+            {
+                printf "\n"
+                printf "# Lacy Shell\n"
+                printf "%s\n" "$plugin_line"
+                printf "%s\n" "$path_line"
+            } >> "$bashrc"
+            printf "${GREEN}✓ Also added to .bashrc${NC}\n"
+        fi
+    fi
+
+    printf "\n"
+}
+
+# Backward compat alias
+configure_zsh() { configure_shell; }
+
+# Parse a simple YAML value (strips inline comments and quotes)
+_yaml_value() {
+    local file="$1" key="$2"
+    grep "^[[:space:]]*${key}:" "$file" 2>/dev/null | head -1 | sed 's/^[^:]*:[[:space:]]*//' | sed 's/[[:space:]]*#.*//' | tr -d '"' | tr -d "'"
+}
+
+# Write a YAML value in-place
+_yaml_write() {
+    local file="$1" key="$2" value="$3"
+    local escaped_value="${value//\\/\\\\}"
+    escaped_value="${escaped_value//|/\\|}"
+    escaped_value="${escaped_value//&/\\&}"
+    if grep -q "^[[:space:]]*${key}:" "$file" 2>/dev/null; then
+        sed -i.bak "s|^\\([[:space:]]*${key}:\\).*|\\1 ${escaped_value}|" "$file"
+        rm -f "${file}.bak"
+    fi
+}
+
+# Create configuration with selected tool (preserves existing config)
+create_config() {
+    mkdir -p "$INSTALL_DIR"
+
+    # Determine active tool value for config
+    local active_tool_value=""
+    if [[ -n "$SELECTED_TOOL" && "$SELECTED_TOOL" != "none" ]]; then
+        active_tool_value="$SELECTED_TOOL"
+    fi
+
+    # If config already exists, update the tool selection only
+    if [[ -f "$CONFIG_FILE" ]]; then
+        printf "${BLUE}Updating configuration...${NC}\n"
+        if [[ -n "$active_tool_value" ]]; then
+            _yaml_write "$CONFIG_FILE" "active" "$active_tool_value"
+            if [[ "$SELECTED_TOOL" == "custom" && -n "$CUSTOM_COMMAND" ]]; then
+                _yaml_write "$CONFIG_FILE" "custom_command" "\"$CUSTOM_COMMAND\""
+            fi
+        fi
+        printf "${GREEN}✓ Configuration preserved at $CONFIG_FILE${NC}\n"
+        printf "\n"
+        return
+    fi
+
+    # Fresh config
+    printf "${BLUE}Creating configuration...${NC}\n"
+
+    # Build custom_command line
+    local custom_command_line="  # custom_command: \"your-command -flags\""
+    if [[ "$SELECTED_TOOL" == "custom" && -n "$CUSTOM_COMMAND" ]]; then
+        custom_command_line="  custom_command: \"$CUSTOM_COMMAND\""
+    fi
+
+    cat > "$CONFIG_FILE" << EOF
+# Lacy Shell Configuration
+# https://github.com/lacymorrow/lacy
+
+# AI CLI tool selection
+# Options: lash, claude, opencode, gemini, codex, custom, or empty for auto-detect
+agent_tools:
+  active: $active_tool_value
+$custom_command_line
+
+# API Keys (optional - only needed if no CLI tool is installed)
+api_keys:
+  # openai: "your-key-here"
+  # anthropic: "your-key-here"
+
+# Operating modes
+modes:
+  default: auto  # Options: shell, agent, auto
+
+# Smart auto-detection settings
+auto_detection:
+  enabled: true
+  confidence_threshold: 0.7
+EOF
+
+    printf "${GREEN}✓ Configuration created at $CONFIG_FILE${NC}\n"
+    printf "\n"
+}
+
+# Show success message
+show_success() {
+    local version
+    version=$(get_installed_version)
+    printf "${GREEN}${BOLD}Installation complete!${NC}"
+    [[ -n "$version" ]] && printf " ${DIM}v${version}${NC}"
+    printf "\n"
+    printf "\n"
+    printf "${BOLD}Try it:${NC}\n"
+    printf "  ${CYAN}what files are here${NC}  ${DIM}→ AI answers${NC}\n"
+    printf "  ${CYAN}ls -la${NC}               ${DIM}→ runs in shell${NC}\n"
+    printf "\n"
+    printf "${BOLD}Commands:${NC}\n"
+    printf "  ${CYAN}mode${NC}          Show/change mode (shell/agent/auto)\n"
+    printf "  ${CYAN}tool${NC}          Show/change AI tool\n"
+    printf "  ${CYAN}ask \"query\"${NC}   Direct query to AI\n"
+    printf "  ${CYAN}Ctrl+Space${NC}    Toggle between modes\n"
+    printf "\n"
+    printf "${BOLD}Visual feedback:${NC}\n"
+    printf "  ${GREEN}▌${NC} Green   = will run in shell\n"
+    printf "  ${MAGENTA}▌${NC} Magenta = will go to AI\n"
+    printf "\n"
+
+    if [[ "$SELECTED_TOOL" == "none" ]] || { [[ -z "$SELECTED_TOOL" ]] && ! command -v lash >/dev/null 2>&1 && ! command -v claude >/dev/null 2>&1; }; then
+        printf "${YELLOW}Remember to install an AI CLI tool:${NC}\n"
+        printf "  npm install -g lashcode     # or\n"
+        printf "  brew install claude\n"
+        printf "\n"
+    fi
+
+    printf "${DIM}Learn more: https://github.com/lacymorrow/lacy${NC}\n"
+    printf "\n"
+}
+
+# Restart shell to apply changes
+restart_shell() {
+    # Only prompt if /dev/tty is actually usable (not just that it exists)
+    local restart=""
+    if [[ -t 0 ]]; then
+        printf "\n"
+        read -p "Restart shell now to apply changes? [Y/n]: " restart
+    elif { true < /dev/tty; } 2>/dev/null; then
+        printf "\n"
+        read -p "Restart shell now to apply changes? [Y/n]: " restart < /dev/tty
+    else
+        printf "\nRestart your terminal to apply changes.\n"
+        return 0
+    fi
+
+    if [[ ! "$restart" =~ ^[Nn]$ ]]; then
+        printf "${BLUE}Restarting shell...${NC}\n"
+        local restart_cmd
+        restart_cmd=$(get_shell_restart_cmd)
+        exec $restart_cmd
+    else
+        printf "\n"
+        printf "Run ${CYAN}$(get_source_hint)${NC} or restart your terminal to apply changes.\n"
+    fi
+}
+
+# Remove lacy lines from an RC file
+_remove_from_rc() {
+    local rc_file="$1"
+    local rc_name
+    rc_name=$(basename "$rc_file")
+    if [[ -f "$rc_file" ]]; then
+        if grep -q "lacy.plugin" "$rc_file" 2>/dev/null; then
+            printf "${BLUE}Removing from ${rc_name}...${NC}\n"
+            local tmp_file
+            tmp_file=$(mktemp)
+            grep -v "lacy.plugin" "$rc_file" | grep -v "# Lacy Shell" | grep -v '\.lacy/bin' > "$tmp_file" || true
+            mv "$tmp_file" "$rc_file"
+            printf "  ${GREEN}✓${NC} Removed from ${rc_name}\n"
+        fi
+    fi
+}
+
+# Uninstall function
+do_uninstall() {
+    printf "${BLUE}Uninstalling Lacy Shell...${NC}\n"
+    printf "\n"
+
+    # Check if installed (directory, symlink, or old install path)
+    if [[ ! -d "$INSTALL_DIR" ]] && [[ ! -L "$INSTALL_DIR" ]] && [[ ! -d "${HOME}/.lacy-shell" ]]; then
+        printf "${YELLOW}Lacy Shell is not installed${NC}\n"
+        exit 0
+    fi
+
+    # Remove from all possible RC files
+    _remove_from_rc "${HOME}/.zshrc"
+    _remove_from_rc "${HOME}/.bashrc"
+    _remove_from_rc "${HOME}/.bash_profile"
+    _remove_from_rc "${HOME}/.config/fish/conf.d/lacy.fish"
+
+    # Detect Homebrew-managed install (symlink to Homebrew prefix)
+    local is_brew=false
+    if [[ -L "$INSTALL_DIR" ]]; then
+        local link_target
+        link_target=$(readlink "$INSTALL_DIR" 2>/dev/null || true)
+        if [[ "$link_target" == *"/Cellar/"* || "$link_target" == *"/homebrew/"* ]]; then
+            is_brew=true
+        fi
+    fi
+
+    # Remove installation directories
+    if [[ -L "$INSTALL_DIR" ]]; then
+        printf "${BLUE}Removing $INSTALL_DIR symlink...${NC}\n"
+        rm -f "$INSTALL_DIR"
+        printf "  ${GREEN}✓${NC} Removed\n"
+    elif [[ -d "$INSTALL_DIR" ]]; then
+        printf "${BLUE}Removing $INSTALL_DIR...${NC}\n"
+        rm -rf "$INSTALL_DIR"
+        printf "  ${GREEN}✓${NC} Removed\n"
+    fi
+    if [[ -d "${HOME}/.lacy-shell" ]]; then
+        printf "${BLUE}Removing ${HOME}/.lacy-shell...${NC}\n"
+        rm -rf "${HOME}/.lacy-shell"
+        printf "  ${GREEN}✓${NC} Removed\n"
+    fi
+
+    # If installed via Homebrew, uninstall the formula too
+    if [[ "$is_brew" == true ]] && command -v brew >/dev/null 2>&1; then
+        printf "${BLUE}Removing Homebrew formula...${NC}\n"
+        brew uninstall lacymorrow/tap/lacy 2>/dev/null && printf "  ${GREEN}✓${NC} Homebrew formula removed\n" || true
+    fi
+
+    printf "\n"
+    printf "${GREEN}Lacy Shell uninstalled${NC}\n"
+
+    track_event "uninstall" "curl"
+
+    # Restart shell (reuse the safe TTY-aware function)
+    detect_user_shell
+    restart_shell
+}
+
+# Check if already installed and show menu
+check_existing_installation() {
+    if [[ -d "$INSTALL_DIR" ]]; then
+        print_banner
+        printf "${YELLOW}Lacy Shell is already installed.${NC}\n"
+        printf "\n"
+        printf "What would you like to do?\n"
+        printf "\n"
+        printf "  1) Update      ${DIM}- pull latest changes${NC}\n"
+        printf "  2) Reinstall   ${DIM}- fresh installation${NC}\n"
+        printf "  3) Uninstall   ${DIM}- remove Lacy Shell${NC}\n"
+        printf "  4) Cancel\n"
+        printf "\n"
+
+        local choice
+        read -p "Select [1-4]: " choice < /dev/tty 2>/dev/null || choice="4"
+
+        case "$choice" in
+            1)
+                printf "\n"
+                printf "${BLUE}Updating Lacy...${NC}\n"
+                cd "$INSTALL_DIR" 2>/dev/null || {
+                    printf "${RED}Could not find installation directory${NC}\n"
+                    exit 1
+                }
+                local update_ok=0
+                if command -v git >/dev/null 2>&1 && [[ -d "$INSTALL_DIR/.git" ]]; then
+                    git pull origin main 2>/dev/null || git pull 2>/dev/null && update_ok=1
+                else
+                    install_via_tarball "main" && update_ok=1
+                fi
+                if [[ $update_ok -eq 1 ]]; then
+                    local updated_version
+                    updated_version=$(get_installed_version)
+                    printf "${GREEN}✓ Lacy updated${NC}"
+                    [[ -n "$updated_version" ]] && printf " ${DIM}(v${updated_version})${NC}"
+                    printf "\n"
+                    track_event "update" "curl"
+                    restart_shell
+                else
+                    printf "${RED}Update failed. Try reinstalling.${NC}\n"
+                fi
+                exit 0
+                ;;
+            2)
+                printf "\n"
+                printf "${BLUE}Removing existing installation...${NC}\n"
+                # Backup user config before removing
+                local config_backup=""
+                if [[ -f "$CONFIG_FILE" ]]; then
+                    config_backup=$(mktemp)
+                    cp "$CONFIG_FILE" "$config_backup"
+                fi
+                rm -rf "$INSTALL_DIR" 2>/dev/null
+                # Restore config so create_config() sees it and preserves it
+                if [[ -n "$config_backup" ]]; then
+                    mkdir -p "$INSTALL_DIR"
+                    cp "$config_backup" "$CONFIG_FILE"
+                    rm -f "$config_backup"
+                fi
+                printf "${GREEN}✓ Removed${NC}\n"
+                printf "\n"
+                # Continue with fresh install
+                return 0
+                ;;
+            3)
+                do_uninstall
+                exit 0
+                ;;
+            4|*)
+                printf "\n"
+                printf "Cancelled.\n"
+                exit 0
+                ;;
+        esac
+    fi
+}
+
+# Main installation flow (bash)
+main_bash() {
+    print_banner
+    detect_user_shell
+    printf "${DIM}Detected shell: ${DETECTED_SHELL}${NC}\n\n"
+    check_prerequisites
+    detect_tools
+    select_tool
+    install_plugin
+    configure_shell
+    create_config
+    show_success
+    restart_shell
+}
+
+# Main entry point
+main() {
+    # Try Node installer first (better UX) — it handles existing installations too
+    if use_node_installer && run_node_installer; then
+        return
+    fi
+
+    # Bash installer (fallback)
+    # Check for existing installation first (interactive menu)
+    if [[ -t 0 ]] || [[ -c /dev/tty ]]; then
+        check_existing_installation
+    fi
+
+    main_bash
+}
+
+# Parse flags that can appear anywhere (--beta, --channel)
+_args=()
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --beta)
+            LACY_CHANNEL="beta"
+            shift
+            ;;
+        --channel)
+            LACY_CHANNEL="${2:?--channel requires a value}"
+            shift 2
+            ;;
+        *)
+            _args+=("$1")
+            shift
+            ;;
+    esac
+done
+set -- "${_args[@]}"
+
+# Handle command line arguments
+case "${1:-}" in
+    "--help"|"-h")
+        printf "Lacy Shell Installation Script\n"
+        printf "\n"
+        printf "Usage: $0 [options]\n"
+        printf "\n"
+        printf "Options:\n"
+        printf "  --help        Show this help message\n"
+        printf "  --uninstall   Uninstall Lacy Shell\n"
+        printf "  --bash        Force bash installer (skip Node)\n"
+        printf "  --shell X     Force shell type (zsh, bash)\n"
+        printf "  --tool X      Pre-select tool (lash, claude, opencode, gemini, codex, custom, auto)\n"
+        printf "  --beta        Use beta release channel\n"
+        printf "  --channel X   Use a named release channel (beta, rc, etc.)\n"
+        printf "\n"
+        printf "Examples:\n"
+        printf "  curl -fsSL https://lacy.sh/install | bash\n"
+        printf "  curl -fsSL https://lacy.sh/install/beta | bash\n"
+        printf "  curl -fsSL https://lacy.sh/install | bash -s -- --beta\n"
+        printf "  curl -fsSL https://lacy.sh/install | bash -s -- --uninstall\n"
+        printf "  curl -fsSL https://lacy.sh/install | bash -s -- --tool claude\n"
+        printf "  curl -fsSL https://lacy.sh/install | bash -s -- --tool custom \"claude -p\"\n"
+        printf "  npx lacy\n"
+        printf "  npx lacy --uninstall\n"
+        exit 0
+        ;;
+    "--uninstall"|"-u")
+        do_uninstall
+        ;;
+    "--bash")
+        LACY_FORCE_BASH=1
+        shift
+        main "$@"
+        ;;
+    "--shell")
+        LACY_FORCE_SHELL="$2"
+        shift 2
+        main "$@"
+        ;;
+    "--tool")
+        SELECTED_TOOL="$2"
+        if [[ "$SELECTED_TOOL" == "custom" ]]; then
+            CUSTOM_COMMAND="$3"
+            if [[ -z "$CUSTOM_COMMAND" ]]; then
+                printf "${RED}Error: --tool custom requires a command string.${NC}\n"
+                printf "Usage: $0 --tool custom \"command -flags\"\n"
+                exit 1
+            fi
+            shift 3
+        else
+            shift 2
+        fi
+        print_banner
+        detect_user_shell
+        check_prerequisites
+        install_plugin
+        configure_shell
+        create_config
+        show_success
+        restart_shell
+        ;;
+    *)
+        main "$@"
+        ;;
+esac