bootstrap

#!/usr/bin/env bash
#
# bootstrap — install a mac dev environment.
#
# Usage:
#   bootstrap                  Interactive: ask machine type, then optional extras.
#   bootstrap --all            Non-interactive: run every core step (in scope).
#   bootstrap --only S1,S2     Run only the named steps (comma-separated).
#   bootstrap --doctor         Read-only: report current state. Installs nothing.
#   bootstrap --force          Re-run steps even if marked completed.
#   bootstrap --help           Show this help.
#
# Interactive flow:
#   Asks "work or personal?" — both run every core step (no per-step prompts).
#   A personal machine also gets Brewfile.home plus y/n prompts for music
#   production, games (Dungeon Crawl), and media apps.
#
# Core steps (run on every machine; also the --all set):
#   xcode homebrew brewfile claude chezmoi marta vim_anywhere bindings osx
#
# Extra steps (personal interactive flow, or via --only):
#   brewfile_home brewfile_music brewfile_media crawl
#
# Logs every run to ~/.local/state/setup/bootstrap-<date>.log
# State file at ~/.local/state/setup/completed tracks finished steps.

set -uo pipefail

# Resolve script root (follow symlinks).
TARGET_FILE=$0
cd "$(dirname "$TARGET_FILE")" || exit 1
TARGET_FILE=$(basename "$TARGET_FILE")
while [[ -L "$TARGET_FILE" ]]; do
  TARGET_FILE=$(readlink "$TARGET_FILE")
  cd "$(dirname "$TARGET_FILE")" || exit 1
  TARGET_FILE=$(basename "$TARGET_FILE")
done
export ROOT
ROOT=$(pwd -P)
cd - >/dev/null || exit 1

# shellcheck source=lib.sh
source "$ROOT/lib.sh"

###
# Defaults / config
###

# Steps included in --all and default-interactive. Order matters: each step
# may depend on earlier ones (e.g. brewfile needs homebrew).
ALL_STEPS=(xcode homebrew brewfile claude chezmoi marta vim_anywhere bindings osx)

# Extra steps not in --all (personal interactive flow, or opt-in via --only).
EXTRA_STEPS=(brewfile_home brewfile_music brewfile_media crawl)

MODE=interactive   # interactive | all | only | doctor
ONLY_STEPS=()
FORCE=false

###
# Arg parsing
###

usage() {
  sed -n '3,25p' "$0" | sed 's/^# \{0,1\}//'
}

while (( $# > 0 )); do
  case $1 in
    --all)    MODE=all ;;
    --only)
      MODE=only
      # Reject "--only" with nothing after, an empty arg, or another flag.
      # pick_steps runs in a process-substitution subshell so `exit 2` from
      # there doesn't reach the parent — validate here at parse time.
      if [[ -z "${2:-}" ]] || [[ "${2:0:2}" == "--" ]]; then
        log_error "--only requires a comma-separated step list"
        exit 2
      fi
      shift
      IFS=, read -r -a ONLY_STEPS <<< "$1"
      # Strip empty fragments from leading / trailing / doubled commas.
      _filtered=()
      for _s in "${ONLY_STEPS[@]}"; do
        [[ -n "$_s" ]] && _filtered+=("$_s")
      done
      ONLY_STEPS=("${_filtered[@]+"${_filtered[@]}"}")
      unset _filtered _s
      if (( ${#ONLY_STEPS[@]} == 0 )); then
        log_error "--only requires a non-empty step list"
        exit 2
      fi
      ;;
    --doctor) MODE=doctor ;;
    --force)  FORCE=true ;;
    --help|-h) usage; exit 0 ;;
    *) log_error "unknown flag: $1"; usage; exit 2 ;;
  esac
  shift
done

###
# Doctor mode (read-only short-circuit — must come BEFORE any state
# creation or logging side effects).
###

if [[ "$MODE" == "doctor" ]]; then
  doctor_report
  exit 0
fi

###
# Logging + state setup (modes that actually install things)
###

state_init
BOOTSTRAP_LOG="$(state_dir)/bootstrap-$(date +%Y%m%d-%H%M%S).log"
export BOOTSTRAP_LOG
touch "$BOOTSTRAP_LOG"
log_info "logging to $BOOTSTRAP_LOG"

###
# Pick the steps to run
###

# Yes/no prompt, default No. The prompt goes to stderr (via read -p) so it
# doesn't pollute the step list pick_steps prints to stdout. Returns 0 for yes.
_ask_yn() {
  local reply
  read -r -p "$1 [y/N] " reply
  case ${reply:-N} in
    [Yy]*) return 0 ;;
    *)     return 1 ;;
  esac
}

pick_steps() {
  case $MODE in
    all)
      printf '%s\n' "${ALL_STEPS[@]}"
      ;;
    only)
      # ONLY_STEPS is validated at parse time (see --only case above).
      printf '%s\n' "${ONLY_STEPS[@]}"
      ;;
    interactive)
      local reply machine=""
      while [[ "$machine" == "" ]]; do
        read -r -p "What kind of machine are you setting up? [work/personal] " reply
        case ${reply:-} in
          [Ww]*) machine=work ;;
          [Pp]*) machine=personal ;;
          *)     echo "  please answer 'work' or 'personal'" >&2 ;;
        esac
      done

      # Core steps run on every machine, no per-step prompting.
      printf '%s\n' "${ALL_STEPS[@]}"

      # Personal machines also get the home baseline plus optional extras.
      if [[ "$machine" == "personal" ]]; then
        printf '%s\n' brewfile_home
        _ask_yn "Install music production apps?"        && printf '%s\n' brewfile_music
        _ask_yn "Install games (Dungeon Crawl)?"        && printf '%s\n' crawl
        _ask_yn "Install media apps (Plex, YACReader)?" && printf '%s\n' brewfile_media
      fi
      ;;
  esac
}

# bash 3.2 compatible (no mapfile/readarray, which are bash 4+)
STEPS_TO_RUN=()
while IFS= read -r _line; do
  STEPS_TO_RUN+=("$_line")
done < <(pick_steps)
unset _line

if (( ${#STEPS_TO_RUN[@]} == 0 )); then
  log_warn "no steps selected; nothing to do"
  exit 0
fi

###
# Validate step names before running anything
###

valid_step() {
  local s=$1
  local known=("${ALL_STEPS[@]}" "${EXTRA_STEPS[@]}")
  local k
  for k in "${known[@]}"; do
    [[ "$k" == "$s" ]] && return 0
  done
  return 1
}

invalid=()
for s in "${STEPS_TO_RUN[@]}"; do
  valid_step "$s" || invalid+=("$s")
done
if (( ${#invalid[@]} > 0 )); then
  log_error "unknown step(s): ${invalid[*]}"
  log_info "valid steps: ${ALL_STEPS[*]} ${EXTRA_STEPS[*]}"
  exit 2
fi

###
# Run steps
###

run_step() {
  local name=$1
  # State-skip applies only to the default-interactive and --all flows,
  # where the user is doing a fresh setup. --only and --force are
  # explicit re-run requests; respect them.
  if [[ "$FORCE" != "true" ]] && [[ "$MODE" != "only" ]] && state_is_done "$name"; then
    log_skip "$name (already completed; --only or --force to re-run)"
    return 0
  fi
  log_step "$name"
  if "step_$name"; then
    state_mark_done "$name"
    return 0
  else
    local rc=$?
    log_error "step '$name' failed (exit $rc)"
    return "$rc"
  fi
}

failures=()
for s in "${STEPS_TO_RUN[@]}"; do
  run_step "$s" || failures+=("$s")
done

###
# Summary
###

echo
if (( ${#failures[@]} == 0 )); then
  log_ok "bootstrap complete: ${#STEPS_TO_RUN[@]} step(s) ran successfully"
else
  log_warn "bootstrap finished with failures: ${failures[*]}"
  log_info "see $BOOTSTRAP_LOG for details; re-run with --only ${failures[*]// /,} after fixing"
  exit 1
fi