devctl

#!/usr/bin/env bash
# devctl v1.0 - resilient macOS dev maintenance CLI (developer-friendly output)

set -u

DRY_RUN=0
ASSUME_YES=0
STRICT=0
FAILURES=0
WARNINGS=0

LOG_DIR="$HOME/.local/state/devctl"
mkdir -p "$LOG_DIR"
LOG_FILE="$LOG_DIR/devctl-$(date +%Y%m%d-%H%M%S).log"

# ---------- Colors ----------
if [[ -t 1 ]]; then
  RESET=$'\033[0m'
  RED=$'\033[31m'
  GREEN=$'\033[32m'
  YELLOW=$'\033[33m'
  CYAN=$'\033[36m'
  MAG=$'\033[35m'
  DIM=$'\033[2m'
else
  RESET=""; RED=""; GREEN=""; YELLOW=""; CYAN=""; MAG=""; DIM=""
fi

log() { printf "%s\n" "$*" >> "$LOG_FILE"; }
info() { printf "%s\n" "${CYAN}ℹ${RESET} $*"; log "$*"; }
ok()   { printf "%s\n" "${GREEN}✓${RESET} $*"; log "$*"; }
warn() { WARNINGS=$((WARNINGS+1)); printf "%s\n" "${YELLOW}⚠${RESET} $*"; log "$*"; }
fail() { FAILURES=$((FAILURES+1)); printf "%s\n" "${RED}✗${RESET} $*"; log "$*"; }
hr()   { printf "%s\n" "${DIM}------------------------------------------------------------${RESET}"; }

confirm() {
  if [[ "$ASSUME_YES" == "1" ]]; then return 0; fi
  read -r -p "$1 (y/n) " ans
  [[ "${ans:-n}" == "y" ]]
}

has() { command -v "$1" >/dev/null 2>&1; }

# Capture output + exit code without killing whole script; show tail on failure.
run_cmd() {
  local label="$1"; shift
  info "$label"

  if [[ "$DRY_RUN" == "1" ]]; then
    printf "%s\n" "  ${DIM}[dry-run]${RESET} $*"
    return 0
  fi

  "$@" >> "$LOG_FILE" 2>&1
  local rc=$?

  if [[ $rc -eq 0 ]]; then
    ok "$label"
  else
    fail "$label (exit $rc)"
    printf "%s\n" "  ${DIM}Last output:${RESET}"
    tail -n 20 "$LOG_FILE" 2>/dev/null | sed 's/^/  /'
    printf "%s\n" "  ${DIM}Log:${RESET} $LOG_FILE"

    if [[ "$STRICT" == "1" ]]; then
      printf "%s\n" "Strict mode enabled. Exiting."
      exit $rc
    fi
  fi

  return $rc
}

# Helper to print "before → after" versions.
print_change() {
  local label="$1" before="$2" after="$3"
  if [[ -z "$before" && -z "$after" ]]; then return; fi
  if [[ "$before" == "$after" ]]; then
    printf "%s\n" "${DIM}${label}:${RESET} $after (unchanged)"
  else
    printf "%s\n" "${MAG}${label}:${RESET} ${before:-unknown} → ${after:-unknown}"
  fi
}

# ---------- Version Snapshot ----------
# Grabs current versions for reporting. Safe if tools missing.
snapshot_versions() {
  SNAP_BREW=""; SNAP_NODE=""; SNAP_NPM=""; SNAP_PNPM=""; SNAP_DOCKER=""; SNAP_COREPACK=""

  if has brew; then SNAP_BREW="$(brew --version 2>/dev/null | head -n 1)"; fi
  if has node; then SNAP_NODE="$(node -v 2>/dev/null)"; fi
  if has npm; then SNAP_NPM="$(npm -v 2>/dev/null)"; fi
  if has pnpm; then SNAP_PNPM="$(pnpm -v 2>/dev/null)"; fi
  if has docker; then SNAP_DOCKER="$(docker --version 2>/dev/null)"; fi
  if has corepack; then SNAP_COREPACK="$(corepack --version 2>/dev/null)"; fi
}

print_snapshot() {
  printf "%s\n" "${MAG}Versions:${RESET}"
  printf "%s\n" "  brew:    ${SNAP_BREW:-not found}"
  printf "%s\n" "  node:    ${SNAP_NODE:-not found}"
  printf "%s\n" "  npm:     ${SNAP_NPM:-not found}"
  printf "%s\n" "  pnpm:    ${SNAP_PNPM:-not found}"
  printf "%s\n" "  corepack:${SNAP_COREPACK:-not found}"
  printf "%s\n" "  docker:  ${SNAP_DOCKER:-not found}"
}

# Print authoritative Node info from an nvm-loaded login shell (path + version + current)
print_node_resolution() {
  local nvm_dir="$1"
  info "Active Node resolution:"
  if [[ "$DRY_RUN" == "1" ]]; then
    printf "%s\n" "  ${DIM}[dry-run]${RESET} which node; node -v; nvm current"
    return 0
  fi

  bash -lc "source \"$nvm_dir/nvm.sh\" >/dev/null 2>&1 || true; \
    echo \"  node: \$(command -v node 2>/dev/null || echo 'not found')\"; \
    echo \"  version: \$(node -v 2>/dev/null || echo 'not found')\"; \
    echo \"  nvm current: \$(command -v nvm >/dev/null 2>&1 && nvm current || echo 'nvm not found')\";" \
    | tee -a "$LOG_FILE"
}

# ---------- Bundles ----------

brew_bundle() {
  printf "%s\n" "---- Homebrew ----"
  has brew || { warn "brew not found"; return; }

  local before_brew="$SNAP_BREW"

  run_cmd "brew update" brew update

  # Show what's outdated BEFORE upgrading (helpful for decision-making)
  info "Outdated packages (if any):"
  if [[ "$DRY_RUN" == "1" ]]; then
    printf "%s\n" "  ${DIM}[dry-run]${RESET} brew outdated"
  else
    local outdated
    outdated="$(brew outdated 2>/dev/null || true)"
    if [[ -z "$outdated" ]]; then
      printf "%s\n" "  (none)"
      log "  (none)"
    else
      printf "%s\n" "$outdated" | sed 's/^/  /' | tee -a "$LOG_FILE"
    fi
  fi

  if confirm "Upgrade installed formulae and casks?"; then
    run_cmd "brew upgrade" brew upgrade
  else
    info "Skipped brew upgrade"
  fi

  if confirm "Run brew cleanup (remove old versions)?"; then
    run_cmd "brew cleanup" brew cleanup
  else
    info "Skipped brew cleanup"
  fi

  # brew doctor returns non-zero when it finds warnings; treat as warning, not failure.
  if confirm "Run brew doctor (diagnostics)?"; then
    info "brew doctor (warnings are OK)"
    if [[ "$DRY_RUN" == "1" ]]; then
      printf "%s\n" "  ${DIM}[dry-run]${RESET} brew doctor"
    else
      brew doctor >> "$LOG_FILE" 2>&1
      local rc=$?
      if [[ $rc -eq 0 ]]; then
        ok "brew doctor"
      else
        warn "brew doctor reported warnings (exit $rc) — not treated as failure"
        printf "%s\n" "  ${DIM}Last output:${RESET}"
        tail -n 25 "$LOG_FILE" 2>/dev/null | sed 's/^/  /'
        printf "%s\n" "  ${DIM}Log:${RESET} $LOG_FILE"
      fi
    fi
  else
    info "Skipped brew doctor"
  fi

  # Update snapshot + report change
  snapshot_versions
  print_change "brew" "$before_brew" "$SNAP_BREW"
}

node_bundle() {
  printf "%s\n" "---- Node / NVM ----"

  local before_node="$SNAP_NODE"
  local before_npm="$SNAP_NPM"
  local before_pnpm="$SNAP_PNPM"
  local before_corepack="$SNAP_COREPACK"

  export NVM_DIR="$HOME/.nvm"
  if [[ -s "$NVM_DIR/nvm.sh" ]]; then
    # shellcheck source=/dev/null
    source "$NVM_DIR/nvm.sh"
  else
    warn "nvm not found ($HOME/.nvm/nvm.sh missing)"
  fi

  # Show currently installed Node versions if nvm available (useful context)
  if has nvm; then
    info "Installed Node versions (nvm ls):"
    if [[ "$DRY_RUN" == "1" ]]; then
      printf "%s\n" "  ${DIM}[dry-run]${RESET} nvm ls"
    else
      nvm ls 2>/dev/null | sed 's/^/  /' | tee -a "$LOG_FILE" || true
    fi
  fi

  if has nvm && confirm "Install latest Node LTS via nvm and set as default?"; then
    # Use subshell to avoid poisoning current shell state
    run_cmd "nvm install --lts" bash -lc "source \"$NVM_DIR/nvm.sh\" && nvm install --lts"
    run_cmd "nvm alias default lts/*" bash -lc "source \"$NVM_DIR/nvm.sh\" && nvm alias default lts/*"
    run_cmd "nvm use default" bash -lc "source \"$NVM_DIR/nvm.sh\" && nvm use default"
  else
    info "Skipped Node LTS install"
  fi

  # Authoritative resolution info (path + version + current)
  if [[ -s "$NVM_DIR/nvm.sh" ]]; then
    print_node_resolution "$NVM_DIR"
  fi

  # Print versions from current shell snapshot (may differ from nvm subshell; resolution info above is authoritative)
  snapshot_versions
  print_change "node" "$before_node" "$SNAP_NODE"
  print_change "npm"  "$before_npm"  "$SNAP_NPM"

  # npm update
  if has npm && confirm "Update npm globally (npm@latest)?"; then
    run_cmd "npm install -g npm" npm install -g npm
    snapshot_versions
    print_change "npm" "$before_npm" "$SNAP_NPM"
  else
    info "Skipped npm update"
  fi

  if has npm; then
    run_cmd "npm cache verify" npm cache verify
  fi

  # pnpm update (Corepack-first)
  if has pnpm; then
    print_change "pnpm" "$before_pnpm" "$SNAP_PNPM"
    if confirm "Update pnpm (prefer corepack if available)?"; then
      if has corepack; then
        run_cmd "corepack enable" corepack enable
        run_cmd "corepack prepare pnpm@latest --activate" corepack prepare pnpm@latest --activate
      elif has npm; then
        run_cmd "npm install -g pnpm" npm install -g pnpm
      else
        warn "No corepack or npm available to update pnpm"
      fi
      snapshot_versions
      print_change "pnpm" "$before_pnpm" "$SNAP_PNPM"
      print_change "corepack" "$before_corepack" "$SNAP_COREPACK"
    else
      info "Skipped pnpm update"
    fi

    if confirm "Prune pnpm store (safe cleanup)?"; then
      run_cmd "pnpm store prune" pnpm store prune
    else
      info "Skipped pnpm store prune"
    fi
  else
    if confirm "pnpm not found. Install pnpm?"; then
      if has corepack; then
        run_cmd "corepack enable" corepack enable
        run_cmd "corepack prepare pnpm@latest --activate" corepack prepare pnpm@latest --activate
      elif has npm; then
        run_cmd "npm install -g pnpm" npm install -g pnpm
      else
        warn "No corepack or npm available to install pnpm"
      fi
      snapshot_versions
      print_change "pnpm" "$before_pnpm" "$SNAP_PNPM"
    fi
  fi
}

docker_bundle() {
  printf "%s\n" "---- Docker ----"
  has docker || { warn "docker not found"; return; }

  # If daemon isn't running, skip to avoid hangs.
  if [[ "$DRY_RUN" != "1" ]]; then
    docker info >/dev/null 2>&1
    local daemon_rc=$?
    if [[ $daemon_rc -ne 0 ]]; then
      warn "Docker daemon not running; skipping Docker steps."
      return
    fi
  fi

  run_cmd "docker system df" docker system df

  if confirm "Prune unused docker resources (non-interactive)?"; then
    run_cmd "docker system prune -f" docker system prune -f
  else
    info "Skipped docker prune"
  fi
}

status() {
  printf "%s\n" "---- Status ----"
  snapshot_versions
  print_snapshot
  printf "%s\n" "Log: $LOG_FILE"
}

summary() {
  hr
  printf "%s\n" "Warnings: $WARNINGS"
  printf "%s\n" "Failures: $FAILURES"
  printf "%s\n" "Log: $LOG_FILE"
}

# ---------- CLI ----------
cmd="${1:-}"

case "$cmd" in
  run)
    hr
    info "devctl v1.0 starting"
    log "devctl start $(date)"

    snapshot_versions
    print_snapshot
    hr

    brew_bundle
    node_bundle
    docker_bundle

    hr
    info "Final versions:"
    snapshot_versions
    print_snapshot

    summary
    ;;
  status)
    status
    ;;
  ""|-h|--help)
    printf "%s\n" "devctl v1.0"
    printf "%s\n" "Usage:"
    printf "%s\n" "  devctl run"
    printf "%s\n" "  devctl status"
    printf "%s\n" ""
    printf "%s\n" "Notes:"
    printf "%s\n" "  - Docker steps are skipped if the daemon isn't running."
    printf "%s\n" "  - pnpm updates prefer corepack; fallback to npm."
    printf "%s\n" "  - brew doctor warnings are not treated as failures."
    printf "%s\n" "  - Logs: $LOG_DIR/"
    ;;
  *)
    printf "%s\n" "Unknown command: $cmd"
    printf "%s\n" "Try: devctl --help"
    exit 2
    ;;
esac