MacOS 开发环境一键安装脚本

#!/usr/bin/env bash
# =============================================================================
# macOS (Apple Silicon) 开发环境一键安装脚本
#
# 可选模块：
#   1. Homebrew（含清华镜像）
#   2. SDKMAN（自动升级 Bash 4+）
#   3. JDK（执行时手动输入主版本，可安装多个版本，如 8 17 21 25）
#   4. Maven
#   5. Node（执行时手动输入主版本，如 22 = 安装 22.x 最新，可多个）
#   6. pnpm（含国内镜像）
#   7. yarn（含国内镜像）
#   8. uv
#   9. React Native（watchman / CocoaPods / Android SDK）
#
# =============================================================================
set -euo pipefail
 
# ----------------------------- 配置区 --------------------------------------
MODULES_ALL=(homebrew sdkman jdk maven node pnpm yarn uv rn)
MODULE_LABELS=(
  "Homebrew（含清华镜像）"
  "SDKMAN（自动升级 Bash4+）"
  "JDK（手动输入版本，可多版本）"
  "Maven"
  "Node（手动输入版本，如 22 = 22.x 最新）"
  "pnpm（含国内镜像）"
  "yarn（含国内镜像）"
  "uv"
  "React Native（watchman/CocoaPods/Android SDK）"
)
JDK_VENDOR="zulu"
ANDROID_SDK_DIR="${ANDROID_SDK_DIR:-$HOME/Library/Android/sdk}"
ANDROID_PLATFORM="android-35"
ANDROID_BUILD_TOOLS="35.0.0"
CMDTOOLS_ZIP_URL="https://dl.google.com/android/repository/commandlinetools-mac-11076708_latest.zip"
NPM_REGISTRY="https://registry.npmmirror.com"
HB="https://mirrors.tuna.tsinghua.edu.cn"
# ---------------------------------------------------------------------------
 
# ----------------------------- 输出工具 --------------------------------------
C_RED=$'\033[31m'; C_GRN=$'\033[32m'; C_YEL=$'\033[33m'; C_CYN=$'\033[36m'; C_OFF=$'\033[0m'
info() { printf "%s[INFO]%s %s\n" "$C_CYN" "$C_OFF" "$*"; }
ok()   { printf "%s[ OK ]%s %s\n" "$C_GRN" "$C_OFF" "$*"; }
warn() { printf "%s[WARN]%s %s\n" "$C_YEL" "$C_OFF" "$*"; }
die()  { printf "%s[FAIL]%s %s\n" "$C_RED" "$C_OFF" "$*" >&2; exit 1; }
 
# ----------------------------- 全局状态 --------------------------------------
SELECTED=()                  # 已选模块名（去重，按原始顺序）
JDK_VERSIONS=()              # 用户指定的 JDK 主版本（如 8 17 25）
NODE_VERSIONS=()             # 用户指定的 Node 主版本（如 22）
VERIFY_ONLY=0
INTERACTIVE=1
 
is_selected() {
  local m
  [[ ${#SELECTED[@]} -eq 0 ]] && return 1
  for m in "${SELECTED[@]}"; do [[ "$m" == "$1" ]] && return 0; done
  return 1
}
 
add_selected() {
  local m
  if [[ ${#SELECTED[@]} -eq 0 ]]; then SELECTED+=("$1"); return; fi
  for m in "${SELECTED[@]}"; do [[ "$m" == "$1" ]] && return; done
  SELECTED+=("$1")
}
 
valid_major() { [[ "$1" =~ ^[0-9]+$ ]] && (( 10#$1 >= 1 && 10#$1 <= 99 )); }
 
# ----------------------------- 参数解析 --------------------------------------
usage() {
  sed -n '2,31p' "$0" | sed 's/^# \{0,1\}//'
}
 
parse_selection() {
  local input="$1" part i m
  input=$(printf '%s' "$input" | tr ',' ' ')
  for part in $input; do
    if [[ "$part" =~ ^([0-9]+)-([0-9]+)$ ]]; then
      for ((i=10#${BASH_REMATCH[1]}; i<=10#${BASH_REMATCH[2]}; i++)); do
        (( i >= 1 && i <= ${#MODULES_ALL[@]} )) && add_selected "${MODULES_ALL[i-1]}"
      done
    elif [[ "$part" =~ ^[0-9]+$ ]]; then
      i=$((10#$part))
      (( i >= 1 && i <= ${#MODULES_ALL[@]} )) && add_selected "${MODULES_ALL[i-1]}"
    else
      for m in "${MODULES_ALL[@]}"; do
        [[ "$part" == "$m" ]] && add_selected "$m"
      done
    fi
  done
  [[ ${#SELECTED[@]} -gt 0 ]] || die "无效选择: $input（示例：1,2,5 或 1-6 或 homebrew,node）"
}
 
parse_versions() {
  # 解析版本字符串写入指定全局数组（$1=数组名，兼容 Bash 3.2）
  local __var="$1" input="$2" part
  local __tmp=()
  input=$(printf '%s' "$input" | tr ',' ' ')
  for part in $input; do
    if valid_major "$part"; then
      __tmp+=("$((10#$part))")
    else
      warn "忽略无效版本: $part"
    fi
  done
  [[ ${#__tmp[@]} -gt 0 ]] || die "未指定有效版本"
  eval "$__var=(\"\${__tmp[@]}\")"
}
 
# 模块依赖自动补全
resolve_dependencies() {
  is_selected jdk    && add_selected sdkman
  is_selected maven  && add_selected sdkman
  is_selected sdkman && add_selected homebrew
  is_selected node   && add_selected homebrew
  is_selected pnpm   && { add_selected node; add_selected homebrew; }
  is_selected yarn   && { add_selected node; add_selected homebrew; }
  is_selected uv     && add_selected homebrew
  is_selected rn     && { add_selected homebrew; add_selected jdk; add_selected node; }
  return 0
}
 
# 默认版本：选中但未指定时
apply_default_versions() {
  if is_selected jdk && [[ ${#JDK_VERSIONS[@]} -eq 0 ]]; then
    JDK_VERSIONS=(8 17 25)
    info "JDK 未指定版本，默认安装: 8 17 25"
  fi
  if is_selected node && [[ ${#NODE_VERSIONS[@]} -eq 0 ]]; then
    NODE_VERSIONS=(22)
    info "Node 未指定版本，默认安装: 22"
  fi
}
 
# ----------------------------- 交互选择 --------------------------------------
# 智能多选菜单：↑/↓ 移动、空格 选中/取消、回车 确认、q 退出
# 选中模块自动勾选其依赖（如选 JDK 自动带上 SDKMAN/Homebrew，标记"依赖"）；
# 取消模块时，若其依赖不再被任何选中模块需要，会自动级联取消（智能联动）。
menu_select() {
  local items=("${MODULES_ALL[@]}") labels=("${MODULE_LABELS[@]}")
  local cur=0 key seq i m
  declare -A CHOSEN=() DEP_AUTO=() DEPS=()
  DEPS[jdk]="sdkman"
  DEPS[maven]="sdkman"
  DEPS[sdkman]="homebrew"
  DEPS[node]="homebrew"
  DEPS[pnpm]="node homebrew"
  DEPS[yarn]="node homebrew"
  DEPS[uv]="homebrew"
  DEPS[rn]="homebrew jdk node"
 
  add_with_deps() {   # 勾选模块并递归勾选依赖（已手动选中的模块不被覆盖为"依赖"）
    local m="$1" d
    CHOSEN[$m]=1
    for d in ${DEPS[$m]:-}; do
      if [[ -z "${CHOSEN[$d]:-}" ]]; then
        DEP_AUTO[$d]=1
      fi
      add_with_deps "$d"
    done
  }
 
  add_manual() {      # 用户手动勾选：解除该模块的"依赖"标记
    local m="$1"
    unset "DEP_AUTO[$m]"
    add_with_deps "$m"
  }
 
  needed_by_others() {  # 依赖 d 是否仍被除 except 外的选中模块需要
    local d="$1" except="$2" x dep
    for x in "${!CHOSEN[@]}"; do
      [[ "$x" == "$except" ]] && continue
      for dep in ${DEPS[$x]:-}; do
        [[ "$dep" == "$d" ]] && return 0
      done
    done
    return 1
  }
 
  remove_with_deps() {  # 取消模块；仅级联取消"自动带上"且不再被需要的依赖
    local m="$1" d
    unset "CHOSEN[$m]" "DEP_AUTO[$m]"
    for d in ${DEPS[$m]:-}; do
      if [[ -n "${DEP_AUTO[$d]:-}" ]] && ! needed_by_others "$d" "$m"; then
        remove_with_deps "$d"
      fi
    done
  }
 
  toggle() {
    local m="${items[$cur]}"
    if [[ -n "${CHOSEN[$m]:-}" ]]; then
      if needed_by_others "$m" ""; then
        return   # 被其它选中模块依赖（或由依赖自动带上），先取消对应模块
      fi
      unset "CHOSEN[$m]"
      remove_with_deps "$m"
    else
      add_manual "$m"
    fi
  }
 
  render() {
    printf '\033[2J\033[H'
    echo "=============================================================="
    echo "  macOS 开发环境一键安装（↑/↓ 移动 ｜ 空格 选中/取消 ｜ 回车 确认 ｜ q 退出）"
    echo "  提示：选中模块自动带上依赖；取消模块时其依赖也会智能释放"
    echo "=============================================================="
    for i in "${!items[@]}"; do
      local m="${items[$i]}" mark="[ ]" tag=""
      [[ -n "${CHOSEN[$m]:-}" ]] && mark="[x]"
      [[ -n "${DEP_AUTO[$m]:-}" ]] && tag=" (依赖)"
      if (( i == cur )); then
        printf '\033[7m  %s %d) %s%s \033[0m\n' "$mark" "$((i+1))" "${labels[$i]}" "$tag"
      else
        printf '  %s %d) %s%s\n' "$mark" "$((i+1))" "${labels[$i]}" "$tag"
      fi
    done
    echo "--------------------------------------------------------------"
    printf '  已选 %d 项（含自动依赖）\n' "${#CHOSEN[@]}"
  }
 
  printf '\033[?25l'            # 隐藏光标
  trap 'printf "\033[?25h"' EXIT
  while :; do
    render
    IFS= read -s -n 1 key || true
    if [[ -z "$key" || "$key" == $'\r' || "$key" == $'\n' ]]; then break; fi
    case "$key" in
      $'\e')                    # 方向键（ESC [ A / B）
        IFS= read -s -n 2 -t 0.05 seq || true
        case "$seq" in
          "[A") (( cur > 0 )) && cur=$((cur-1)) ;;
          "[B") (( cur < ${#items[@]} - 1 )) && cur=$((cur+1)) ;;
        esac
        ;;
      " ") toggle ;;
      q|Q) printf '\033[2J\033[H'; echo "已取消，未安装任何模块。"; exit 0 ;;
    esac
  done
  printf '\033[2J\033[H\033[?25h'
  trap - EXIT
 
  SELECTED=()
  for m in "${items[@]}"; do
    [[ -n "${CHOSEN[$m]:-}" ]] && SELECTED+=("$m")
  done
  [[ ${#SELECTED[@]} -gt 0 ]] || { echo "未选择任何模块，退出。"; exit 0; }
  echo
  info "已选择：${SELECTED[*]}"
}
 
# 数字输入回退模式（非 TTY / 简易终端）
select_modules_interactive() {
  echo
  echo "=============================================="
  echo "  请选择要安装的软件环境（支持多选）"
  echo "=============================================="
  local idx
  for idx in "${!MODULES_ALL[@]}"; do
    printf "  %d) %s\n" "$((idx+1))" "${MODULE_LABELS[idx]}"
  done
  echo "----------------------------------------------"
  echo "  输入示例：1,2,5 或 1-6（范围）或 1 2 3（空格分隔）"
  echo "  直接回车 = 全选；输入 q = 退出"
  echo "=============================================="
  local ans
  read -r -p "> " ans || ans=""
  [[ "$ans" == "q" || "$ans" == "Q" ]] && { echo "已取消，未安装任何模块。"; exit 0; }
  if [[ -z "$ans" ]]; then
    SELECTED=("${MODULES_ALL[@]}")
    info "已选择全部模块"
  else
    parse_selection "$ans"
    local ordered=() m
    for m in "${MODULES_ALL[@]}"; do is_selected "$m" && ordered+=("$m"); done
    SELECTED=("${ordered[@]}")
  fi
}
 
# 询问版本（$1 提示名，$2 默认值，结果写入全局数组）
prompt_versions() {
  local label="$1" default="$2" ans
  read -r -p "> 请输入$label 主版本（多个用空格/逗号分隔；直接回车默认 [$default]；示例：$default）：" ans
  ans="${ans:-$default}"
  parse_versions "$3" "$ans"
}
 
# ----------------------------- 参数处理（顶层）-------------------------------
for arg in "$@"; do
  case "$arg" in
    --verify)              VERIFY_ONLY=1; INTERACTIVE=0 ;;
    --all)                 SELECTED=("${MODULES_ALL[@]}"); INTERACTIVE=0 ;;
    --no-rn)               INTERACTIVE=0; for m in "${MODULES_ALL[@]}"; do [[ "$m" != "rn" ]] && add_selected "$m"; done ;;
    --modules=*)           INTERACTIVE=0; parse_selection "${arg#--modules=}" ;;
    --jdk=*)               parse_versions JDK_VERSIONS "${arg#--jdk=}" ;;
    --node=*)              parse_versions NODE_VERSIONS "${arg#--node=}" ;;
    --help|-h)             usage; exit 0 ;;
    *) die "未知参数: $arg（支持 --all / --modules= / --jdk= / --node= / --no-rn / --verify / --help）" ;;
  esac
done
 
# ----------------------------- SDKMAN 执行封装 --------------------------------
sdk_exec() {
  zsh -c 'source "$HOME/.sdkman/bin/sdkman-init.sh" && "$@"' _ "$@"
}
 
# ----------------------------- Bash 版本检查 ----------------------------------
check_bash() {
  if [[ "${BASH_VERSINFO[0]:-0}" -lt 4 ]]; then
    warn "当前 Bash 版本过旧 ($BASH_VERSION)，SDKMAN 需要 Bash 4+，正在升级..."
    if [[ ! -x /opt/homebrew/bin/brew ]]; then
      add_selected homebrew
      install_homebrew
    fi
    /opt/homebrew/bin/brew install bash >/dev/null 2>&1 || die "新版 bash 安装失败"
    ok "bash 已升级，使用新版重新执行脚本"
    exec /opt/homebrew/bin/bash "$0" "$@"
  fi
}
 
# ----------------------------- Homebrew --------------------------------------
ensure_homebrew_dir() {
  if [[ ! -d /opt/homebrew ]]; then
    info "创建 /opt/homebrew（需要管理员密码，正常输入即可）"
    sudo mkdir -p /opt/homebrew
    sudo chown -R "$(whoami):admin" /opt/homebrew
  fi
}
 
install_homebrew() {
  if command -v brew >/dev/null 2>&1 || [[ -x /opt/homebrew/bin/brew ]]; then
    ok "Homebrew 已存在，跳过: $(brew --version 2>/dev/null | head -1)"
    return
  fi
  info "安装 Homebrew（清华镜像加速）..."
  ensure_homebrew_dir
  export HOMEBREW_BREW_GIT_REMOTE="$HB/git/homebrew/brew.git"
  export HOMEBREW_CORE_GIT_REMOTE="$HB/git/homebrew/homebrew-core.git"
  export HOMEBREW_CASK_GIT_REMOTE="$HB/git/homebrew/homebrew-cask.git"
  export HOMEBREW_API_DOMAIN="$HB/homebrew-bottles/api"
  export HOMEBREW_BOTTLE_DOMAIN="$HB/homebrew-bottles"
  export NONINTERACTIVE=1
  local installer
  installer=$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh) \
    || die "下载 Homebrew 安装脚本失败，请检查网络后重试"
  /bin/bash -c "$installer" || die "Homebrew 安装失败，请检查网络后重试"
  eval "$(/opt/homebrew/bin/brew shellenv)"
  ok "Homebrew 安装完成: $(brew --version | head -1)"
}
 
brew_install_if_missing() {
  local pkg="$1"
  if brew list --formula "$pkg" >/dev/null 2>&1; then
    ok "brew 包已存在: $pkg"
  else
    info "brew 安装: $pkg"
    brew install "$pkg" || die "brew 安装 $pkg 失败"
  fi
}
 
# ----------------------------- SDKMAN ----------------------------------------
install_sdkman() {
  if [[ -d "$HOME/.sdkman" ]]; then
    ok "SDKMAN 已存在，跳过: $(sdk_exec sdk version 2>/dev/null | grep 'core:' | head -1)"
    return
  fi
  info "安装 SDKMAN..."
  curl -s "https://get.sdkman.io" | bash || die "SDKMAN 安装失败"
  ok "SDKMAN 安装完成"
}
 
# ----------------------------- JDK ---------------------------------------------
get_latest_jdk_id() {
  local major="$1" id
  id=$(sdk_exec sdk list java 2>/dev/null \
        | awk -v m="$major" '{v=$NF; if (v ~ "^" m "\\.[0-9].*-'$JDK_VENDOR'$") {print v; exit}}')
  [[ -n "$id" ]] || die "无法从 SDKMAN 获取 JDK $major ($JDK_VENDOR) 版本，请检查网络"
  echo "$id"
}
 
install_jdk() {
  local major="$1" id
  id=$(get_latest_jdk_id "$major")
  if [[ -d "$HOME/.sdkman/candidates/java/$id" ]]; then
    ok "JDK $id 已存在，跳过"
    return
  fi
  info "安装 JDK $id ..."
  # 用 here-string 提供 "n"（不设默认），避免 yes 管道在 pipefail 下被 SIGPIPE 误杀
  sdk_exec sdk install java "$id" <<< "n" >/dev/null || true
  if [[ ! -d "$HOME/.sdkman/candidates/java/$id" ]]; then
    die "JDK $id 安装失败（目标目录未创建），请检查网络后重试"
  fi
  ok "JDK $id 安装完成"
 
  # 询问是否设为默认（默认不设置）
  local ans
  if [[ "$INTERACTIVE" == "1" && -t 0 ]]; then
    read -r -p "> 是否将 JDK $id 设为默认？(y/N，回车默认不设置)：" ans
    case "${ans:-n}" in
      y|Y)
        if sdk_exec sdk default java "$id" >/dev/null 2>&1; then
          ok "已设 $id 为默认 JDK"
        else
          warn "设置默认失败，可手动执行: sdk default java $id"
        fi
        ;;
      *) ok "未设置默认（需要时执行: sdk default java $id）" ;;
    esac
  else
    ok "非交互模式，未设置默认（需要时执行: sdk default java $id）"
  fi
}
 
# ----------------------------- Maven ------------------------------------------
install_maven() {
  local ver
  ver=$(sdk_exec sdk list maven 2>/dev/null \
        | awk '$NF ~ /^[0-9]+\.[0-9]+\.[0-9]+$/ {print $NF; exit}')
  [[ -n "$ver" ]] || ver="3.10.0"
  if [[ -d "$HOME/.sdkman/candidates/maven/$ver" ]]; then
    ok "Maven $ver 已存在，跳过"
  else
    info "安装 Maven $ver ..."
    sdk_exec sdk install maven "$ver" <<< "n" >/dev/null || true
    if [[ ! -d "$HOME/.sdkman/candidates/maven/$ver" ]]; then
      die "Maven $ver 安装失败（目标目录未创建），请检查网络后重试"
    fi
    ok "Maven $ver 安装完成"
  fi
  sdk_exec sdk default maven "$ver" >/dev/null
}
 
# ----------------------------- Node -------------------------------------------
install_node() {
  local major="$1" f="node@$1" v
  if brew list --formula "$f" >/dev/null 2>&1; then
    v=$(/opt/homebrew/opt/$f/bin/node -v 2>/dev/null)
    ok "$f 已存在，跳过 ($v)"
    return
  fi
  info "brew 安装 $f ..."
  if ! brew install "$f" >/dev/null 2>&1; then
    die "brew 安装 $f 失败（该版本可能没有对应 formula；可用版本: $(brew search node@ 2>/dev/null | tr '\n' ' ')）"
  fi
  ok "$f 安装完成: $(/opt/homebrew/opt/$f/bin/node -v)"
}
 
link_node() {
  local top
  top=$(printf '%s\n' "${NODE_VERSIONS[@]}" | sort -n | tail -1)
  brew link "node@$top" --force --overwrite >/dev/null 2>&1 || true
  ok "node 命令链接到最高版本 $top: $(/opt/homebrew/bin/node -v)"
}
 
# ----------------------------- pnpm / yarn / uv --------------------------------
install_pnpm() {
  if command -v pnpm >/dev/null 2>&1; then
    ok "pnpm 已存在，跳过: $(pnpm --version)"
  else
    info "npm 全局安装 pnpm ..."
    /opt/homebrew/bin/npm install -g pnpm >/dev/null || die "pnpm 安装失败"
    ok "pnpm 安装完成: $(pnpm --version)"
  fi
  /opt/homebrew/bin/pnpm config set registry "$NPM_REGISTRY" || true
  ok "pnpm 镜像: $NPM_REGISTRY"
}
 
install_yarn() {
  if command -v yarn >/dev/null 2>&1; then
    ok "yarn 已存在，跳过: $(yarn --version)"
  else
    info "npm 全局安装 yarn ..."
    /opt/homebrew/bin/npm install -g yarn >/dev/null || die "yarn 安装失败"
    ok "yarn 安装完成: $(yarn --version)"
  fi
  /opt/homebrew/bin/yarn config set registry "$NPM_REGISTRY" >/dev/null || true
  ok "yarn 镜像: $NPM_REGISTRY"
}
 
install_uv() {
  if command -v uv >/dev/null 2>&1; then
    ok "uv 已存在，跳过: $(uv --version | head -1)"
    return
  fi
  brew_install_if_missing uv
  ok "uv 安装完成: $(uv --version | head -1)"
}
 
# ----------------------------- React Native -------------------------------------
install_rn_tools() {
  info "安装 React Native 依赖: watchman / CocoaPods ..."
  brew_install_if_missing watchman
  brew_install_if_missing cocoapods
  ok "watchman: $(watchman --version)"
  ok "CocoaPods: $(pod --version)"
}
 
install_android_sdk() {
  local sdk="$ANDROID_SDK_DIR" sdkmanager
  sdkmanager="$sdk/cmdline-tools/latest/bin/sdkmanager"
  if [[ -x "$sdk/platform-tools/adb" && -d "$sdk/platforms/$ANDROID_PLATFORM" ]]; then
    ok "Android SDK 已存在，跳过 (adb: $($sdk/platform-tools/adb --version | head -1))"
    return
  fi
  info "安装 Android SDK 到 $sdk ..."
  mkdir -p "$sdk/cmdline-tools"
  if [[ ! -x "$sdkmanager" ]]; then
    info "下载 cmdline-tools ..."
    curl -fsSL -o /tmp/cmdline-tools.zip "$CMDTOOLS_ZIP_URL" || die "cmdline-tools 下载失败"
    rm -rf /tmp/cmdtools && mkdir -p /tmp/cmdtools
    unzip -q /tmp/cmdline-tools.zip -d /tmp/cmdtools
    mv /tmp/cmdtools/cmdline-tools "$sdk/cmdline-tools/latest"
    rm -f /tmp/cmdline-tools.zip
  fi
  local jh
  if [[ -d "$HOME/.sdkman/candidates/java/current" ]]; then
    jh="$HOME/.sdkman/candidates/java/current"
  elif [[ -d "/Applications/Android Studio.app/Contents/jbr/Contents/Home" ]]; then
    jh="/Applications/Android Studio.app/Contents/jbr/Contents/Home"
  else
    die "未找到可用 JDK，请先安装 JDK 或 Android Studio"
  fi
  export JAVA_HOME="$jh"
  info "使用 JAVA_HOME=$JAVA_HOME 运行 sdkmanager"
  yes | "$sdkmanager" --licenses >/dev/null 2>&1 || true
  "$sdkmanager" "platform-tools" "platforms;$ANDROID_PLATFORM" \
    "build-tools;$ANDROID_BUILD_TOOLS" "emulator" >/dev/null || die "Android SDK 组件安装失败"
  ok "Android SDK 组件安装完成"
}
 
# ----------------------------- ~/.zshrc 配置（按所选模块生成）-------------------
configure_zshrc() {
  local zshrc="$HOME/.zshrc"
  if grep -q "DOUBAO_DEV_ENV_BEGIN" "$zshrc" 2>/dev/null; then
    ok "~/.zshrc 已包含配置段（跳过写入）"
    return
  fi
  cat >> "$zshrc" <<EOF
 
# ===== Doubao 开发环境一键脚本生成（DOUBAO_DEV_ENV_BEGIN 勿删）=====
# DOUBAO_DEV_ENV_BEGIN
$(is_selected homebrew && cat <<'INNER'
eval "$(/opt/homebrew/bin/brew shellenv)"
export HOMEBREW_BREW_GIT_REMOTE="https://mirrors.tuna.tsinghua.edu.cn/git/homebrew/brew.git"
export HOMEBREW_CORE_GIT_REMOTE="https://mirrors.tuna.tsinghua.edu.cn/git/homebrew/homebrew-core.git"
export HOMEBREW_CASK_GIT_REMOTE="https://mirrors.tuna.tsinghua.edu.cn/git/homebrew/homebrew-cask.git"
export HOMEBREW_API_DOMAIN="https://mirrors.tuna.tsinghua.edu.cn/homebrew-bottles/api"
export HOMEBREW_BOTTLE_DOMAIN="https://mirrors.tuna.tsinghua.edu.cn/homebrew-bottles"
INNER
)
$(is_selected node && cat <<'INNER'
export npm_config_registry="https://registry.npmmirror.com"
INNER
)
$(is_selected jdk && cat <<'INNER'
export JAVA_HOME="$HOME/.sdkman/candidates/java/current"
export PATH="$JAVA_HOME/bin:$PATH"
INNER
)
$(is_selected rn && cat <<'INNER'
export ANDROID_HOME="$HOME/Library/Android/sdk"
export PATH="$ANDROID_HOME/platform-tools:$ANDROID_HOME/emulator:$ANDROID_HOME/cmdline-tools/latest/bin:$PATH"
INNER
)
$(is_selected sdkman && cat <<'INNER'
# SDKMAN 初始化必须位于文件末尾
export SDKMAN_DIR="$HOME/.sdkman"
[[ -s "$HOME/.sdkman/bin/sdkman-init.sh" ]] && source "$HOME/.sdkman/bin/sdkman-init.sh"
INNER
)
# DOUBAO_DEV_ENV_END
EOF
  ok "已写入 ~/.zshrc（新终端生效）"
}
 
# ----------------------------- 验证 --------------------------------------------
verify_env() {
  echo
  echo "==================== 环境验证 ===================="
  zsh -c 'source "$HOME/.zshrc" 2>/dev/null
    for cmd in brew sdk java mvn node npm pnpm yarn uv watchman pod adb sdkmanager emulator; do
      if command -v $cmd >/dev/null 2>&1; then
        printf "  %-12s %s\n" "$cmd" "$(command -v $cmd)"
      else
        printf "  %-12s %s\n" "$cmd" "【未安装】"
      fi
    done
    echo "  --- 版本 ---"
    brew --version | head -1 | sed "s/^/  Homebrew:  /"
    java -version 2>&1 | head -1 | sed "s/^/  Java:      /"
    echo "  Maven:     $(mvn -v 2>/dev/null | head -1 | awk "{print \$3}")"
    echo "  Node:      $(node -v 2>/dev/null)"
    echo "  npm:       $(npm -v 2>/dev/null)"
    echo "  pnpm:      $(pnpm -v 2>/dev/null)"
    echo "  yarn:      $(yarn -v 2>/dev/null)"
    echo "  uv:        $(uv --version 2>/dev/null | awk "{print \$2}")"
    echo "  watchman:  $(watchman --version 2>/dev/null)"
    echo "  CocoaPods: $(pod --version 2>/dev/null)"
    echo "  ANDROID_HOME: ${ANDROID_HOME:-未设置}"
    echo "  JDK 已安装:"
    ls "$HOME/.sdkman/candidates/java/" 2>/dev/null | grep -v current | sed "s/^/    /"
    echo "  Node 已安装:"
    ls /opt/homebrew/opt/ 2>/dev/null | grep "^node@" | sed "s/^/    /"
    echo "  镜像 npm:  $(npm config get registry 2>/dev/null)"
    echo "  镜像 pnpm: $(pnpm config get registry 2>/dev/null)"
    echo "  镜像 yarn: $(yarn config get registry 2>/dev/null)"
  ' 2>&1 || true
  echo "=================================================="
}
 
# ----------------------------- 主流程 ------------------------------------------
main() {
  export PATH="/opt/homebrew/bin:$PATH"
  check_bash "$@"
  if [[ "$INTERACTIVE" == "1" ]]; then
    if [[ ! -t 0 || "${TERM:-dumb}" == "dumb" ]]; then
      warn "当前终端不支持交互菜单（非 TTY），改用数字输入模式"
      select_modules_interactive
    else
      menu_select
      is_selected jdk  && prompt_versions "JDK" "8 17 25" JDK_VERSIONS
      is_selected node && prompt_versions "Node" "22" NODE_VERSIONS
    fi
  fi
  resolve_dependencies
  apply_default_versions
 
  echo
  info "本次将安装："
  local m
  for m in "${MODULES_ALL[@]}"; do
    is_selected "$m" && printf "  - %s\n" "$m"
  done
  is_selected jdk && printf "    JDK 版本: %s\n" "${JDK_VERSIONS[*]}"
  is_selected node && printf "    Node 版本: %s\n" "${NODE_VERSIONS[*]}"
 
  is_selected homebrew && install_homebrew
  is_selected sdkman  && install_sdkman
  if is_selected jdk; then
    local major
    for major in "${JDK_VERSIONS[@]}"; do install_jdk "$major"; done
  fi
  is_selected maven   && install_maven
  if is_selected node; then
    local v
    for v in "${NODE_VERSIONS[@]}"; do install_node "$v"; done
    link_node
  fi
  is_selected pnpm    && install_pnpm
  is_selected yarn    && install_yarn
  is_selected uv      && install_uv
  if is_selected rn; then
    install_rn_tools
    install_android_sdk
  fi
 
  if [[ ${#SELECTED[@]} -gt 0 ]]; then
    configure_zshrc
  fi
  verify_env
  echo
  ok "全部完成！请新开终端使 ~/.zshrc 生效"
}
 
if [[ "$VERIFY_ONLY" == "1" ]]; then
  verify_env
else
  main "$@"
fi