start.sh

#!/bin/bash
# =================================================================
#  Portable AI USB - Start AI (macOS/Linux)
# =================================================================

CYAN='\033[36m'; GREEN='\033[32m'; YELLOW='\033[33m'; RED='\033[31m'
DIM='\033[90m'; BOLD='\033[1m'; RESET='\033[0m'

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
ROOT_DIR="$SCRIPT_DIR"
ENGINE_DIR="$ROOT_DIR/engine"
DATA_DIR="$ROOT_DIR/data"
ENV_FILE="$DATA_DIR/ai_settings.env"
NODE_VERSION="22.14.0"

# Save before any `cd` in this script (npm install / update cds into ENGINE_DIR).
# Otherwise the CLI thinks the project is OpenClaude-Portable. Override: OCP_PROJECT_DIR=/path/to/repo
if [ -n "${OCP_PROJECT_DIR:-}" ] && [ -d "$OCP_PROJECT_DIR" ]; then
    CLI_WORKING_DIR="$(cd "$OCP_PROJECT_DIR" && pwd -P)"
else
    CLI_WORKING_DIR="$(pwd -P)"
fi

OS_NAME=$(uname -s | tr '[:upper:]' '[:lower:]')
ARCH=$(uname -m)

if [ "$OS_NAME" = "darwin" ]; then
    PLATFORM="darwin"
elif [ "$OS_NAME" = "linux" ]; then
    PLATFORM="linux"
else
    echo -e "${RED}[ERROR] Unsupported OS: $OS_NAME${RESET}"
    exit 1
fi

if [ "$ARCH" = "x86_64" ] || [ "$ARCH" = "amd64" ]; then
    NODE_ARCH="x64"
elif [ "$ARCH" = "arm64" ] || [ "$ARCH" = "aarch64" ]; then
    NODE_ARCH="arm64"
else
    echo -e "${RED}[ERROR] Unsupported Architecture: $ARCH${RESET}"
    exit 1
fi

NODE_DIR_NAME="node-$PLATFORM-$NODE_ARCH"
NODE_DIR="$ENGINE_DIR/$NODE_DIR_NAME"
NODE_BIN="$NODE_DIR/bin/node"
NPM_BIN="$NODE_DIR/bin/npm"
NPX_BIN="$NODE_DIR/bin/npx"
OPENCLAUDE_DIR="$ENGINE_DIR/node_modules/@gitlawb/openclaude"
OC_BIN="$OPENCLAUDE_DIR/bin/openclaude"
OC_CLI="$OPENCLAUDE_DIR/dist/cli.mjs"

mkdir -p "$ENGINE_DIR"

engine_ready() {
    [ -f "$OC_BIN" ] && [ -f "$OC_CLI" ]
}

install_engine() {
    local action="$1"
    echo -e "${YELLOW}[~] ${action} OpenClaude Engine...${RESET}"
    echo -e "${DIM}    This can take several minutes on slower USB drives or networks.${RESET}"
    cd "$ENGINE_DIR" || exit 1
    "$NPM_BIN" install @gitlawb/openclaude@latest --no-audit --no-fund --loglevel=warn --no-bin-links &
    local npm_pid=$!
    local elapsed=0
    while kill -0 "$npm_pid" 2>/dev/null; do
        sleep 1
        elapsed=$((elapsed + 1))
        if [ $((elapsed % 15)) -eq 0 ] && kill -0 "$npm_pid" 2>/dev/null; then
            echo -e "${DIM}    Still working... npm install has been running for ${elapsed}s.${RESET}"
        fi
    done
    wait "$npm_pid"
    local npm_status=$?
    if [ $npm_status -ne 0 ]; then
        echo -e "${RED}[ERROR] OpenClaude Engine install failed (npm exit $npm_status).${RESET}"
        exit 1
    fi
    if ! engine_ready; then
        echo -e "${RED}[ERROR] OpenClaude Engine install is incomplete.${RESET}"
        echo -e "${DIM}        Missing expected files under $OPENCLAUDE_DIR${RESET}"
        exit 1
    fi
    echo -e "${GREEN}[OK] Engine installed!${RESET}"
}

if [ ! -f "$NODE_BIN" ]; then
    echo -e "${YELLOW}[~] Node.js not found for $PLATFORM-$NODE_ARCH. Downloading...${RESET}"
    NODE_URL="https://nodejs.org/dist/v${NODE_VERSION}/node-v${NODE_VERSION}-${PLATFORM}-${NODE_ARCH}.tar.gz"
    TEMP_TAR="$ENGINE_DIR/node.tar.gz"
    curl -L "$NODE_URL" -o "$TEMP_TAR"
    if [ $? -ne 0 ]; then
        echo -e "${RED}[ERROR] Failed to download Node.js!${RESET}"
        exit 1
    fi
    echo -e "${YELLOW}[~] Extracting Node.js...${RESET}"
    echo -e "${DIM}    This can be silent for a few minutes on external drives.${RESET}"
    rm -rf "$NODE_DIR"
    mkdir -p "$NODE_DIR"
    tar -xzf "$TEMP_TAR" -C "$NODE_DIR" --strip-components=1
    if [ $? -ne 0 ]; then
        echo -e "${RED}[ERROR] Failed to extract Node.js!${RESET}"
        rm -f "$TEMP_TAR"
        exit 1
    fi
    rm "$TEMP_TAR"
    echo -e "${GREEN}[OK] Node.js installed to $NODE_DIR${RESET}"
fi

export PATH="$NODE_DIR/bin:$PATH"

if ! engine_ready; then
    if [ -d "$ENGINE_DIR/node_modules" ] || [ -d "$OPENCLAUDE_DIR" ]; then
        echo -e "${YELLOW}[~] Incomplete or stale OpenClaude Engine detected. Clearing npm tree...${RESET}"
        rm -rf "$ENGINE_DIR/node_modules" "$ENGINE_DIR/package-lock.json" "$OPENCLAUDE_DIR"
    fi
    install_engine "Installing"
fi

# Portable data
export CLAUDE_CONFIG_DIR="$DATA_DIR/openclaude"
export XDG_CONFIG_HOME="$DATA_DIR/config"
export XDG_DATA_HOME="$DATA_DIR/app_data"
mkdir -p "$CLAUDE_CONFIG_DIR" "$XDG_CONFIG_HOME" "$XDG_DATA_HOME" "$DATA_DIR"

# Banner
echo ""
echo -e "${CYAN}    ____            __        __    __        ___    ____${RESET}"
echo -e "${CYAN}   / __ \\____  ____/ /_____ _/ /_  / /__     /   |  /  _/${RESET}"
echo -e "${CYAN}  / /_/ / __ \\/ __/ __/ __ \`/ __ \\/ / _ \\   / /| |  / /  ${RESET}"
echo -e "${CYAN} / ____/ /_/ / / / /_/ /_/ / /_/ / /  __/  / ___ |_/ /   ${RESET}"
echo -e "${CYAN}/_/    \\____/_/  \\__/\\__,_/_.___/_/\\___/  /_/  |_/___/   ${RESET}"
echo ""
echo -e "${CYAN}=========================================================${RESET}"
echo -e "  ${BOLD}Claude Code - Open Source Multi-Platform${RESET}"
echo -e "${CYAN}=========================================================${RESET}"
echo ""

# ─── Check for flags ────────────────────────────────────────
SKIP_UPDATE=0
QUICK_MODE=0
for arg in "$@"; do
    [ "$arg" = "--offline" ] && SKIP_UPDATE=1
    [ "$arg" = "--quick" ] && QUICK_MODE=1
done

# ─── Check for Engine Updates ────────────────────────────────
if [ $SKIP_UPDATE -eq 1 ]; then
    echo -e "  ${DIM}[~] Offline mode - skipping update check${RESET}"
else
    echo -e "  ${YELLOW}[~] Checking for engine updates...${RESET}"
    cd "$ENGINE_DIR"
    if "$NPM_BIN" outdated @gitlawb/openclaude 2>/dev/null | grep -q openclaude; then
        echo -e "  ${YELLOW}[~] New version detected! Upgrading...${RESET}"
        install_engine "Upgrading"
        echo -e "  ${GREEN}[OK] Engine upgraded to latest version!${RESET}"
    else
        echo -e "  ${GREEN}[OK] Engine is up to date!${RESET}"
    fi
fi
echo ""

# ─── Check for settings ─────────────────────────────────────
goto_loaded=0
if [ -f "$ENV_FILE" ]; then
    # Strip \r to handle env files written on Windows (CRLF -> LF)
    ENV_CONTENT="$(cat "$ENV_FILE" 2>/dev/null | tr -d '\r' || true)"
    if [[ "$ENV_CONTENT" == *"AI_PROVIDER="* ]]; then
        # Load settings
        while IFS='=' read -r key value; do
            [[ "$key" =~ ^#.* ]] && continue
            [ -z "$key" ] && continue
            value="${value%$'\r'}"  # strip trailing \r just in case
            export "$key=$value"
        done <<< "$ENV_CONTENT"
        goto_loaded=1
    fi
fi

# ─── Provider Setup ────────────────────────────────────────
save_env() {
    echo "$1" > "$ENV_FILE"
}

setup_provider() {
    echo -e "${CYAN}=========================================================${RESET}"
    echo -e "  ${BOLD}AI PROVIDER SELECTION${RESET}"
    echo -e "${CYAN}=========================================================${RESET}"
    echo ""
    echo -e "  ${CYAN}1)${RESET} ${BOLD}OpenRouter${RESET}   ${DIM}- 200+ Free and Paid Models${RESET}  ${GREEN}[RECOMMENDED]${RESET}"
    echo -e "  ${CYAN}2)${RESET} ${BOLD}NVIDIA NIM${RESET}   ${DIM}- High-Speed GPU Free Tier${RESET}   ${GREEN}[RECOMMENDED]${RESET}"
    echo -e "  ${CYAN}3)${RESET} ${BOLD}DeepSeek${RESET}     ${DIM}- DeepSeek API (OpenAI-compatible)${RESET}"
    echo -e "  ${CYAN}4)${RESET} ${BOLD}Gemini${RESET}       ${DIM}- Google AI API${RESET}"
    echo -e "  ${CYAN}5)${RESET} ${BOLD}Claude${RESET}       ${DIM}- Anthropic API${RESET}"
    echo -e "  ${CYAN}6)${RESET} ${BOLD}OpenAI${RESET}       ${DIM}- GPT / Codex API${RESET}"
    echo -e "  ${CYAN}7)${RESET} ${BOLD}Ollama${RESET}       ${DIM}- Local Offline AI (No internet)${RESET}"
    echo ""

    while true; do
        read -p "  Select your provider (1-7): " PROVIDER_SEL
        case "$PROVIDER_SEL" in
            1) setup_openrouter; return ;;
            2) setup_nvidia; return ;;
            3) setup_deepseek; return ;;
            4) setup_gemini; return ;;
            5) setup_claude; return ;;
            6) setup_openai; return ;;
            7) setup_ollama; return ;;
            *) echo -e "  ${RED}[ERROR] Invalid selection. Please choose 1-7.${RESET}" ;;
        esac
    done
}

verify_key() {
    local provider="$1" key="$2"
    echo -e "  ${YELLOW}[~] Verifying API Key... Please wait...${RESET}"
    case "$provider" in
        openrouter) curl -sf -H "Authorization: Bearer $key" https://openrouter.ai/api/v1/auth/key > /dev/null 2>&1 ;;
        gemini)     curl -sf "https://generativelanguage.googleapis.com/v1beta/models?key=$key" > /dev/null 2>&1 ;;
        anthropic)  curl -sf -H "x-api-key: $key" -H "anthropic-version: 2023-06-01" https://api.anthropic.com/v1/models > /dev/null 2>&1 ;;
        nvidia)     curl -sf -H "Authorization: Bearer $key" https://integrate.api.nvidia.com/v1/models > /dev/null 2>&1 ;;
        deepseek)   curl -sf -H "Authorization: Bearer $key" https://api.deepseek.com/models > /dev/null 2>&1 ;;
        openai)     curl -sf -H "Authorization: Bearer $key" https://api.openai.com/v1/models > /dev/null 2>&1 ;;
    esac
}

mask_key() {
    local key="$1"
    echo "${key:0:6}****${key: -4}"
}

setup_openrouter() {
    echo ""
    echo -e "  ${CYAN}--- OPENROUTER SETUP ---${RESET}"
    echo ""
    read -p "  Enter your OpenRouter API Key: " USER_API_KEY
    [ -z "$USER_API_KEY" ] && echo -e "  ${RED}[ERROR] Key cannot be empty!${RESET}" && setup_openrouter && return
    echo -e "  ${DIM}Key: $(mask_key "$USER_API_KEY")${RESET}"
    echo ""
    if ! verify_key openrouter "$USER_API_KEY"; then
        echo -e "  ${RED}[ERROR] Invalid or expired OpenRouter API Key!${RESET}"
        setup_openrouter; return
    fi
    echo -e "  ${GREEN}[OK] Key Verified!${RESET}"
    echo ""

    # Model selection
    echo -e "  ${CYAN}1)${RESET} Free Models"
    echo -e "  ${CYAN}2)${RESET} Paid Models"
    read -p "  Select category (1 or 2): " MODEL_TIER
    echo ""

    if [ "$MODEL_TIER" = "1" ]; then
        echo -e "  ${CYAN}--- FREE MODELS ---${RESET} ${DIM}(Fetching...)${RESET}"
        MODELS=$(curl -sf https://openrouter.ai/api/v1/models 2>/dev/null | grep -Eo '"id"[[:space:]]*:[[:space:]]*"[^"]*:free"' | sed -e 's/"id"[[:space:]]*:[[:space:]]*"//g' -e 's/"//g' | head -20)
    else
        echo -e "  ${CYAN}--- PAID MODELS ---${RESET} ${DIM}(Fetching...)${RESET}"
        MODELS=$(curl -sf https://openrouter.ai/api/v1/models 2>/dev/null | grep -Eo '"id"[[:space:]]*:[[:space:]]*"[^"]*"' | sed -e 's/"id"[[:space:]]*:[[:space:]]*"//g' -e 's/"//g' | grep -v ':free$' | head -20)
    fi

    if [ -z "$MODELS" ]; then
        echo -e "  ${YELLOW}[API Error] Could not fetch models. Enter manually.${RESET}"
        read -p "  Enter model string: " USER_MODEL
    else
        idx=1
        while IFS= read -r model; do
            echo -e "  ${CYAN}${idx})${RESET} $model"
            eval "MODEL_${idx}='$model'"
            idx=$((idx+1))
        done <<< "$MODELS"
        echo -e "  ${CYAN}${idx})${RESET} ${DIM}Custom Model...${RESET}"
        echo ""
        read -p "  Choose a model (1-$idx): " MODEL_SEL
        if [ "$MODEL_SEL" = "$idx" ]; then
            read -p "  Enter custom model string: " USER_MODEL
        else
            eval "USER_MODEL=\$MODEL_${MODEL_SEL}"
        fi
    fi

    save_env "# ========================================================
# Portable AI - Master Switchboard
# ========================================================
AI_PROVIDER=openai
CLAUDE_CODE_USE_OPENAI=1
OPENAI_API_KEY=${USER_API_KEY}
OPENAI_BASE_URL=https://openrouter.ai/api/v1
OPENAI_MODEL=${USER_MODEL}
AI_DISPLAY_MODEL=${USER_MODEL}"
}

setup_gemini() {
    echo ""
    echo -e "  ${CYAN}--- GEMINI SETUP ---${RESET}"
    echo ""
    read -p "  Enter your Gemini API Key: " USER_API_KEY
    [ -z "$USER_API_KEY" ] && echo -e "  ${RED}[ERROR] Key cannot be empty!${RESET}" && setup_gemini && return
    echo -e "  ${DIM}Key: $(mask_key "$USER_API_KEY")${RESET}"
    echo ""
    USER_API_KEY=$(echo "$USER_API_KEY" | tr -d ' ' | tr -d '\r')
    if ! verify_key gemini "$USER_API_KEY"; then
        echo -e "  ${RED}[ERROR] Invalid or expired Gemini API Key!${RESET}"
        setup_gemini; return
    fi
    echo -e "  ${GREEN}[OK] Key Verified!${RESET}"
    echo ""
    echo -e "  ${CYAN}--- GEMINI MODELS ---${RESET} ${DIM}(Fetching...)${RESET}"
    MODELS=$(curl -sf "https://generativelanguage.googleapis.com/v1alpha/models?key=$USER_API_KEY" 2>/dev/null | grep -Eo '"name"[[:space:]]*:[[:space:]]*"models/gemini-[^"]*"' | sed -e 's/"name"[[:space:]]*:[[:space:]]*"models\///g' -e 's/"//g' | grep -vE 'vision|embedding|banana|lyria|robot|research|computer' | head -40)

    if [ -z "$MODELS" ]; then
        echo -e "  ${YELLOW}[API Error] Could not fetch models. Enter manually.${RESET}"
        read -p "  Enter model string: " USER_MODEL
    else
        idx=1
        while IFS= read -r model; do
            [ -z "$model" ] && continue
            echo -e "  ${CYAN}${idx})${RESET} $model"
            eval "MODEL_${idx}='$model'"
            idx=$((idx+1))
        done <<< "$MODELS"
        echo -e "  ${CYAN}${idx})${RESET} ${DIM}Custom Model...${RESET}"
        echo ""
        read -p "  Choose a model (1-$idx) [Enter for 1]: " MODEL_SEL
        [ -z "$MODEL_SEL" ] && MODEL_SEL=1
        if [ "$MODEL_SEL" = "$idx" ]; then
            read -p "  Enter custom model string: " USER_MODEL
        else
            eval "USER_MODEL=\$MODEL_${MODEL_SEL}"
        fi
    fi
    save_env "AI_PROVIDER=gemini
CLAUDE_CODE_USE_GEMINI=1
GEMINI_API_KEY=${USER_API_KEY}
GEMINI_MODEL=${USER_MODEL}
AI_DISPLAY_MODEL=${USER_MODEL}"
}

setup_claude() {
    echo ""
    echo -e "  ${CYAN}--- CLAUDE SETUP ---${RESET}"
    echo ""
    read -p "  Enter your Anthropic API Key: " USER_API_KEY
    [ -z "$USER_API_KEY" ] && echo -e "  ${RED}[ERROR] Key cannot be empty!${RESET}" && setup_claude && return
    echo -e "  ${DIM}Key: $(mask_key "$USER_API_KEY")${RESET}"
    echo ""
    if ! verify_key anthropic "$USER_API_KEY"; then
        echo -e "  ${RED}[ERROR] Invalid or expired Anthropic API Key!${RESET}"
        setup_claude; return
    fi
    echo -e "  ${GREEN}[OK] Key Verified!${RESET}"
    echo ""
    read -p "  Enter Model (Enter for claude-3-7-sonnet-20250219): " USER_MODEL
    [ -z "$USER_MODEL" ] && USER_MODEL="claude-3-7-sonnet-20250219"
    save_env "AI_PROVIDER=anthropic
ANTHROPIC_API_KEY=${USER_API_KEY}
AI_DISPLAY_MODEL=${USER_MODEL}"
}

setup_ollama() {
    echo ""
    echo -e "  ${CYAN}--- OLLAMA LOCAL SETUP ---${RESET}"
    echo ""

    # ── 1. Detect Ollama: bundled, system PATH, or prompt for path ──
    OLLAMA_BIN=""
    
    # Check bundled first
    if [ -x "$DATA_DIR/ollama/ollama" ]; then
        OLLAMA_BIN="$DATA_DIR/ollama/ollama"
    elif [ -x "$DATA_DIR/ollama/ollama-$PLATFORM" ]; then
        OLLAMA_BIN="$DATA_DIR/ollama/ollama-$PLATFORM"
    # Check system PATH
    elif command -v ollama &>/dev/null; then
        OLLAMA_BIN="$(command -v ollama)"
        echo -e "  ${DIM}[~] Found Ollama in system PATH: $OLLAMA_BIN${RESET}"
    else
        echo -e "  ${YELLOW}[!] Ollama not found locally or in PATH.${RESET}"
        echo -e "  ${DIM}Options:${RESET}"
        echo -e "    ${CYAN}1)${RESET} Auto-download Ollama (requires internet)"
        echo -e "    ${CYAN}2)${RESET} Specify custom Ollama path"
        echo -e "    ${CYAN}3)${RESET} Cancel and choose another provider"
        echo ""
        read -p "  Select option (1-3) [1]: " OPT
        OPT=${OPT:-1}

        case "$OPT" in
            1)
                echo -e "  ${DIM}[~] Downloading Ollama for $PLATFORM...${RESET}"
                mkdir -p "$DATA_DIR/ollama"
                if [[ "$PLATFORM" == "linux-amd64" ]]; then
                    curl -fsSL https://ollama.com/download/ollama-linux-amd64 -o "$DATA_DIR/ollama/ollama" 2>/dev/null
                elif [[ "$PLATFORM" == "darwin-arm64" ]] || [[ "$PLATFORM" == "darwin-amd64" ]]; then
                    curl -fsSL https://ollama.com/download/ollama-darwin -o "$DATA_DIR/ollama/ollama" 2>/dev/null
                else
                    echo -e "  ${RED}[!] Auto-download not supported for $PLATFORM. Please install Ollama manually: https://ollama.com${RESET}"
                    sleep 3
                    setup_provider; return
                fi
                chmod +x "$DATA_DIR/ollama/ollama"
                OLLAMA_BIN="$DATA_DIR/ollama/ollama"
                ;;
            2)
                read -p "  Enter full path to ollama binary: " CUSTOM_PATH
                if [ -x "$CUSTOM_PATH" ]; then
                    OLLAMA_BIN="$CUSTOM_PATH"
                    echo -e "  ${GREEN}[OK] Using custom path: $OLLAMA_BIN${RESET}"
                else
                    echo -e "  ${RED}[ERROR] Not executable or not found: $CUSTOM_PATH${RESET}"
                    setup_ollama; return
                fi
                ;;
            3|*)
                echo -e "  ${DIM}[~] Returning to provider selection...${RESET}"
                setup_provider; return
                ;;
        esac
    fi

    # ── 2. Start Ollama server temporarily to list models ──
    echo -e "  ${DIM}[~] Scanning local models...${RESET}"
    export OLLAMA_MODELS="${OLLAMA_MODELS:-$DATA_DIR/ollama/data}"
    
    # Start server in background
    "$OLLAMA_BIN" serve >/dev/null 2>&1 &
    TMP_PID=$!
    sleep 3  # Give it time to initialize

    # Fetch models
    MODELS=$("$OLLAMA_BIN" list 2>/dev/null | awk 'NR>1 && NF>=1 {print $1}' | grep -v '^$')

    # Cleanup server
    kill "$TMP_PID" 2>/dev/null
    wait "$TMP_PID" 2>/dev/null || true

    # ── 3. Handle model selection ──
    if [ -z "$MODELS" ]; then
        echo -e "  ${YELLOW}[!] No models found locally.${RESET}"
        echo -e "  ${DIM}Tip: Run '${CYAN}ollama pull llama3.2${DIM}' first, or pull one now:${RESET}"
        read -p "  Pull a model now? (y/N): " PULL_NOW
        if [[ "$PULL_NOW" =~ ^[Yy]$ ]]; then
            read -p "  Model name (e.g., llama3.2, mistral, gemma2): " MODEL_NAME
            MODEL_NAME=${MODEL_NAME:-llama3.2}
            echo -e "  ${DIM}[~] Pulling $MODEL_NAME (this may take a while)...${RESET}"
            "$OLLAMA_BIN" pull "$MODEL_NAME"
        else
            setup_provider; return
        fi
        # Re-scan after pull
        MODELS=$("$OLLAMA_BIN" list 2>/dev/null | awk 'NR>1 && NF>=1 {print $1}' | grep -v '^$')
    fi

    # Display & select
    idx=1
    declare -a SYS_MODELS
    echo -e "\n  ${CYAN}Available Local Models:${RESET}"
    while IFS= read -r m; do
        [ -n "$m" ] && { echo -e "  ${CYAN}${idx})${RESET} $m"; SYS_MODELS[$idx]="$m"; idx=$((idx+1)); }
    done <<< "$MODELS"

    echo ""
    read -p "  Select model (1-$((idx-1))) [Enter for 1]: " SEL
    SEL=${SEL:-1}
    USER_MODEL="${SYS_MODELS[$SEL]}"

    if [ -z "$USER_MODEL" ]; then
        echo -e "  ${RED}[ERROR] Invalid selection.${RESET}"
        setup_ollama; return
    fi

    # ── 4. Save configuration ──
    echo -e "  ${GREEN}[OK] Selected: ${CYAN}$USER_MODEL${RESET}"
    save_env "AI_PROVIDER=ollama
CLAUDE_CODE_USE_OPENAI=1
OPENAI_API_KEY=ollama
OPENAI_BASE_URL=http://localhost:11434/v1
OPENAI_MODEL=${USER_MODEL}
AI_DISPLAY_MODEL=${USER_MODEL}
OLLAMA_BIN_PATH=${OLLAMA_BIN}"

    echo -e "  ${DIM}[~] Config saved. Ollama will run locally on port 11434.${RESET}"
    sleep 1
}

setup_deepseek() {
    echo ""
    echo -e "  ${CYAN}--- DEEPSEEK SETUP ---${RESET}"
    echo ""
    read -p "  Enter your DeepSeek API Key: " USER_API_KEY
    [ -z "$USER_API_KEY" ] && echo -e "  ${RED}[ERROR] Key cannot be empty!${RESET}" && setup_deepseek && return
    USER_API_KEY=$(echo "$USER_API_KEY" | tr -d ' ' | tr -d '\r')
    echo -e "  ${DIM}Key: $(mask_key "$USER_API_KEY")${RESET}"
    echo ""
    if ! verify_key deepseek "$USER_API_KEY"; then
        echo -e "  ${RED}[ERROR] Invalid or expired DeepSeek API Key!${RESET}"
        setup_deepseek; return
    fi
    echo -e "  ${GREEN}[OK] Key Verified!${RESET}"
    echo ""
    echo -e "  ${CYAN}--- DEEPSEEK MODELS ---${RESET} ${DIM}(Live Fetching...)${RESET}"
    MODELS=$(curl -sf -H "Authorization: Bearer $USER_API_KEY" https://api.deepseek.com/models 2>/dev/null | grep -Eo '"id"[[:space:]]*:[[:space:]]*"[^"]*"' | sed -e 's/"id"[[:space:]]*:[[:space:]]*"//g' -e 's/"//g')
    if [ -z "$MODELS" ]; then
        echo -e "  ${YELLOW}[API Error] Could not fetch models, using fallback...${RESET}"
        MODELS="deepseek-v4-flash
deepseek-v4-pro"
    fi

    idx=1
    while IFS= read -r model; do
        [ -z "$model" ] && continue
        echo -e "  ${CYAN}${idx})${RESET} $model"
        eval "MODEL_${idx}='$model'"
        idx=$((idx+1))
    done <<< "$MODELS"
    echo -e "  ${CYAN}${idx})${RESET} ${DIM}Custom DeepSeek Model...${RESET}"
    echo ""
    read -p "  Choose a model (1-$idx) [Enter for 1]: " MODEL_SEL
    [ -z "$MODEL_SEL" ] && MODEL_SEL=1
    if [ "$MODEL_SEL" = "$idx" ]; then
        read -p "  Enter custom model string: " USER_MODEL
    else
        eval "USER_MODEL=\$MODEL_${MODEL_SEL}"
    fi
    [ -z "$USER_MODEL" ] && USER_MODEL="deepseek-v4-flash"

    save_env "AI_PROVIDER=openai
CLAUDE_CODE_USE_OPENAI=1
OPENAI_API_KEY=${USER_API_KEY}
OPENAI_BASE_URL=https://api.deepseek.com
OPENAI_MODEL=${USER_MODEL}
AI_DISPLAY_MODEL=${USER_MODEL}"
}

setup_openai() {
    echo ""
    echo -e "  ${CYAN}--- OPENAI / CODEX SETUP ---${RESET}"
    echo ""
    read -p "  Enter your OpenAI API Key: " USER_API_KEY
    [ -z "$USER_API_KEY" ] && echo -e "  ${RED}[ERROR] Key cannot be empty!${RESET}" && setup_openai && return
    echo -e "  ${DIM}Key: $(mask_key "$USER_API_KEY")${RESET}"
    echo ""
    if ! verify_key openai "$USER_API_KEY"; then
        echo -e "  ${RED}[ERROR] Invalid or expired OpenAI API Key!${RESET}"
        setup_openai; return
    fi
    echo -e "  ${GREEN}[OK] Key Verified!${RESET}"
    echo ""
    read -p "  Enter Model (Enter for gpt-4o): " USER_MODEL
    [ -z "$USER_MODEL" ] && USER_MODEL="gpt-4o"
    save_env "AI_PROVIDER=openai
CLAUDE_CODE_USE_OPENAI=1
OPENAI_API_KEY=${USER_API_KEY}
OPENAI_BASE_URL=https://api.openai.com/v1
OPENAI_MODEL=${USER_MODEL}
AI_DISPLAY_MODEL=${USER_MODEL}"
}

setup_nvidia() {
    echo ""
    echo -e "  ${CYAN}--- NVIDIA NIM SETUP ---${RESET}"
    echo ""
    read -p "  Enter your NVIDIA API Key: " USER_API_KEY
    [ -z "$USER_API_KEY" ] && echo -e "  ${RED}[ERROR] Key cannot be empty!${RESET}" && setup_nvidia && return
    echo -e "  ${DIM}Key: $(mask_key "$USER_API_KEY")${RESET}"
    echo ""
    if ! verify_key nvidia "$USER_API_KEY"; then
        echo -e "  ${RED}[ERROR] Invalid or expired NVIDIA API Key!${RESET}"
        setup_nvidia; return
    fi
    echo -e "  ${GREEN}[OK] Key Verified!${RESET}"
    echo ""

    CURATED="qwen/qwen2.5-coder-32b-instruct qwen/qwen3.5-122b-a10b qwen/qwen3.5-397b-a17b meta/llama-3.3-70b-instruct meta/llama-3.1-405b-instruct deepseek-ai/deepseek-v3.1-terminus"
    echo -e "  ${CYAN}--- NVIDIA MODELS ---${RESET} ${DIM}(Fetching...)${RESET}"
    LIVE=$(curl -sf -H "Authorization: Bearer $USER_API_KEY" https://integrate.api.nvidia.com/v1/models 2>/dev/null | grep -Eo '"id"[[:space:]]*:[[:space:]]*"[^"]*"' | sed -e 's/"id"[[:space:]]*:[[:space:]]*"//g' -e 's/"//g' | head -40)
    MODELS=""
    for m in $CURATED; do MODELS="${MODELS}${m}"$'\n'; done
    MODELS="${MODELS}${LIVE}"

    if [ -z "$MODELS" ]; then
        echo -e "  ${YELLOW}[API Error] Could not fetch models. Entering fallback...${RESET}"
        USER_MODEL="meta/llama-3.3-70b-instruct"
    else
        idx=1
        while IFS= read -r model; do
            [ -z "$model" ] && continue
            echo -e "  ${CYAN}${idx})${RESET} $model"
            eval "MODEL_${idx}='$model'"
            idx=$((idx+1))
        done <<< "$MODELS"
        echo -e "  ${CYAN}${idx})${RESET} ${DIM}Custom Model...${RESET}"
        echo ""
        read -p "  Choose a model (1-$idx) [Enter for 1]: " MODEL_SEL
        [ -z "$MODEL_SEL" ] && MODEL_SEL=1
        if [ "$MODEL_SEL" = "$idx" ]; then
            read -p "  Enter custom model string: " USER_MODEL
        else
            eval "USER_MODEL=\$MODEL_${MODEL_SEL}"
        fi
    fi

    # CLAUDE_CODE_AGENT_LIST_IN_MESSAGES=false: stops system-reminder blocks being
    # injected as content arrays, which strict providers like NVIDIA NIM reject with 400
    save_env "AI_PROVIDER=openai
CLAUDE_CODE_USE_OPENAI=1
OPENAI_API_KEY=${USER_API_KEY}
OPENAI_BASE_URL=https://integrate.api.nvidia.com/v1
OPENAI_MODEL=${USER_MODEL}
AI_DISPLAY_MODEL=${USER_MODEL}
CLAUDE_CODE_AGENT_LIST_IN_MESSAGES=false
CLAUDE_CODE_SIMPLE=1"
}

# ─── Main Flow ──────────────────────────────────────────────
if [ "$goto_loaded" -eq 0 ]; then
    setup_provider
    echo ""
    echo -e "  ${GREEN}[OK] Settings saved!${RESET}"
    echo ""
    # Reload (strip \r for cross-platform safety)
    ENV_CONTENT="$(cat "$ENV_FILE" 2>/dev/null | tr -d '\r' || true)"
    while IFS='=' read -r key value; do
        [[ "$key" =~ ^#.* ]] && continue
        [ -z "$key" ] && continue
        value="${value%$'\r'}"
        export "$key=$value"
    done <<< "$ENV_CONTENT"
fi

# ─── Friendly Provider Name ────────────────────────────────
PROVIDER_NAME="$AI_PROVIDER"
case "$AI_PROVIDER" in
    openai)
        if [[ "$OPENAI_BASE_URL" == *"openrouter"* ]]; then PROVIDER_NAME="OpenRouter"
        elif [[ "$OPENAI_BASE_URL" == *"integrate.api.nvidia.com"* ]]; then PROVIDER_NAME="NVIDIA NIM"
        elif [[ "$OPENAI_BASE_URL" == *"api.deepseek.com"* ]]; then PROVIDER_NAME="DeepSeek"
        elif [[ "$OPENAI_BASE_URL" == *"api.openai.com"* ]]; then PROVIDER_NAME="OpenAI"
        elif [[ "$OPENAI_BASE_URL" == *"localhost:11434"* ]]; then PROVIDER_NAME="Ollama"
        fi ;;
    gemini)     PROVIDER_NAME="Google Gemini" ;;
    anthropic)  PROVIDER_NAME="Anthropic Claude" ;;
    ollama)     PROVIDER_NAME="Ollama (Local)" ;;
esac

echo -e "${CYAN}=========================================================${RESET}"
echo -e "  ${BOLD}Claude Code - Ready (Multi-Platform)${RESET}"
echo -e "${CYAN}=========================================================${RESET}"
echo ""
echo -e "  ${BOLD}Provider${RESET} : ${GREEN}${PROVIDER_NAME}${RESET}"
echo -e "  ${BOLD}Model${RESET}    : ${GREEN}${AI_DISPLAY_MODEL}${RESET}"
echo -e "  ${BOLD}Data${RESET}     : ${DIM}Portable Mode (No PC Leaks)${RESET}"
echo ""
echo -e "${CYAN}=========================================================${RESET}"
echo ""

# ─── Launch Mode ─────────────────────────────────────────────

CMD_ARGS=""
if [ $QUICK_MODE -eq 1 ]; then
    echo -e "  ${RED}${BOLD}QUICK LAUNCH - Limitless Mode${RESET}"
    echo -e "  ${RED}[!] Commands will execute without confirmation!${RESET}"
    CMD_ARGS="--dangerously-skip-permissions"
else
    while true; do
        echo -e "  ${BOLD}Select Action:${RESET}"
        echo -e "  🚀 ${CYAN}1)${RESET} ${GREEN}Launch AI${RESET}       ${DIM}- Normal Mode (Auto-starts in 10s)${RESET}"
        echo -e "  ⚡ ${CYAN}2)${RESET} ${RED}Limitless Mode${RESET}  ${DIM}- Auto-executes everything (Advanced)${RESET}"
        echo -e "  ${DIM}─────────────────────────────────────────────────────────${RESET}"
        echo -e "   ${CYAN}3)${RESET} ${BOLD}Open Dashboard${RESET}  ${DIM}- View your chats visually${RESET}"
        echo -e "   ${CYAN}4)${RESET} ${BOLD}Change Provider${RESET} ${DIM}- Switch your AI provider or API Key${RESET}"
        echo -e "   ${CYAN}5)${RESET} ${BOLD}Setup Offline${RESET}   ${DIM}- Download local AI models (Ollama)${RESET}"
        echo ""

        # Read with a visual 10-second countdown
        LAUNCH_MODE=""
        for i in {10..1}; do
            echo -ne "\r  Select action (1-5) [Auto in $i]: "
            if read -t 1 -n 1 LAUNCH_MODE; then
                break
            fi
        done
        if [ -z "$LAUNCH_MODE" ]; then
            LAUNCH_MODE="1"
            echo -ne "\r  Select action (1-5) [Auto in 0]: "
        fi
        echo ""

        case "$LAUNCH_MODE" in
            1)
                echo ""
                echo -e "  ${GREEN}[OK] Normal mode selected.${RESET}"
                break
                ;;
            2)
                echo ""
                echo -e "  ${RED}${BOLD}[!] LIMITLESS MODE ACTIVATED${RESET}"
                CMD_ARGS="--dangerously-skip-permissions"
                break
                ;;
            3)
                echo ""
                exec bash "$ROOT_DIR/tools/open_dashboard.sh"
                ;;
            4)
                echo ""
                exec bash "$ROOT_DIR/tools/change_provider.sh"
                ;;
            5)
                echo ""
                exec bash "$ROOT_DIR/tools/setup_local_models.sh"
                ;;
            *)
                echo -e "  ${RED}[ERROR] Invalid selection.${RESET}\n"
                ;;
        esac
    done
fi

if [ "$AI_PROVIDER" = "ollama" ]; then
    OLLAMA_BIN="$DATA_DIR/ollama/ollama"
    [ ! -f "$OLLAMA_BIN" ] && OLLAMA_BIN="$DATA_DIR/ollama/ollama-$PLATFORM"
    if [ -x "$OLLAMA_BIN" ]; then
        echo -e "  ${CYAN}[~] Starting Local Ollama Server...${RESET}"
        export OLLAMA_MODELS="$DATA_DIR/ollama/data"
        "$OLLAMA_BIN" serve >/dev/null 2>&1 &
        OLLAMA_PID=$!
        sleep 3
        echo -e "  ${GREEN}[OK] Ollama running!${RESET}"
        echo ""
    fi
fi

echo -e "  ${CYAN}[~] Starting AI Engine...${RESET}"
echo ""

# Map internal provider name to openclaude --provider flag
PROVIDER_ARGS=""
if [ -n "$AI_PROVIDER" ]; then
    OC_PROVIDER="$AI_PROVIDER"
    # NVIDIA NIM uses openai-compat internally but the engine expects --provider nvidia-nim
    if [ "$AI_PROVIDER" = "openai" ] && [[ "$OPENAI_BASE_URL" == *"integrate.api.nvidia.com"* ]]; then
        OC_PROVIDER="nvidia-nim"
    fi
    PROVIDER_ARGS="--provider $OC_PROVIDER"
fi

if [ -d "$CLI_WORKING_DIR" ]; then
    cd "$CLI_WORKING_DIR" || cd "$ROOT_DIR"
else
    echo -e "${YELLOW}[~] Project directory not found: $CLI_WORKING_DIR — using $ROOT_DIR${RESET}"
    cd "$ROOT_DIR"
fi

# Use portable binary directly (not npx)
if [ -f "$OC_BIN" ]; then
    "$NODE_BIN" "$OC_BIN" $PROVIDER_ARGS $CMD_ARGS
else
    echo -e "  ${RED}[ERROR] OpenClaude Engine is missing. Re-run ./start.sh to repair the install.${RESET}"
    exit 1
fi

if [ -n "$OLLAMA_PID" ]; then
    echo ""
    echo -e "  ${CYAN}[~] Stopping Local Ollama Server...${RESET}"
    kill "$OLLAMA_PID" 2>/dev/null
    wait "$OLLAMA_PID" 2>/dev/null
fi