install.sh

#!/bin/sh
# Archgate installer for macOS, Linux, and Windows (Git Bash / MSYS2)
# Usage: curl -fsSL https://raw.githubusercontent.com/archgate/cli/main/install.sh | sh
set -eu

REPO="archgate/cli"
INSTALL_DIR="${ARCHGATE_INSTALL_DIR:-$HOME/.archgate/bin}"

# --- Detect platform ---

detect_platform() {
  os="$(uname -s)"
  arch="$(uname -m)"

  case "$os" in
    Darwin)       platform="darwin" ;;
    Linux)        platform="linux" ;;
    MINGW*|MSYS*) platform="win32" ;;
    *)
      echo "Error: unsupported OS: $os" >&2
      echo "archgate supports macOS (ARM64), Linux (x86_64), and Windows (x64)." >&2
      exit 1
      ;;
  esac

  case "$arch" in
    arm64|aarch64) arch="arm64" ;;
    x86_64|amd64)  arch="x64" ;;
    *)
      echo "Error: unsupported architecture: $arch" >&2
      echo "archgate supports arm64 (macOS) and x64 (Linux, Windows)." >&2
      exit 1
      ;;
  esac

  # Validate supported combinations
  if [ "$platform" = "darwin" ] && [ "$arch" != "arm64" ]; then
    echo "Error: macOS is only supported on ARM64 (Apple Silicon)." >&2
    exit 1
  fi
  if [ "$platform" = "linux" ] && [ "$arch" != "x64" ]; then
    echo "Error: Linux is only supported on x86_64." >&2
    exit 1
  fi
  if [ "$platform" = "win32" ] && [ "$arch" != "x64" ]; then
    echo "Error: Windows is only supported on x86_64." >&2
    exit 1
  fi

  ARTIFACT="archgate-${platform}-${arch}"

  if [ "$platform" = "win32" ]; then
    EXT="zip"
  else
    EXT="tar.gz"
  fi
}

# --- Release asset helpers ---

asset_url() {
  echo "https://github.com/${REPO}/releases/download/${1}/${ARTIFACT}.${EXT}"
}

# Returns 0 when the platform asset for the given version tag actually exists
# on GitHub Releases. A version being advertised (version.json, releases/latest)
# does not guarantee its assets are uploaded yet - releases are published
# before the binary build workflow finishes, and a failed release pipeline can
# advertise a version that never gets assets at all.
asset_exists() {
  check_url="$(asset_url "$1")"
  if command -v curl >/dev/null 2>&1; then
    curl -fsIL -o /dev/null "$check_url" 2>/dev/null
  elif command -v wget >/dev/null 2>&1; then
    wget -q --spider "$check_url" 2>/dev/null
  else
    return 1
  fi
}

# --- Resolve version ---

resolve_version() {
  if [ -n "${ARCHGATE_VERSION:-}" ]; then
    VERSION="$ARCHGATE_VERSION"
    if ! asset_exists "$VERSION"; then
      echo "Error: no ${ARTIFACT}.${EXT} asset found for pinned ARCHGATE_VERSION='${VERSION}'." >&2
      echo "Check that the release exists and has finished building: https://github.com/${REPO}/releases" >&2
      exit 1
    fi
    return
  fi

  # Primary: static version endpoint (no rate limits)
  version_url="https://cli.archgate.dev/version.json"
  static_response=""

  if command -v curl >/dev/null 2>&1; then
    static_response="$(curl -fsSL "$version_url" 2>/dev/null || true)"
  elif command -v wget >/dev/null 2>&1; then
    static_response="$(wget -qO- "$version_url" 2>/dev/null || true)"
  fi

  if [ -n "$static_response" ]; then
    # tr -d '\r': jq on Windows (Git Bash) emits CRLF line endings, which
    # would otherwise leave a stray carriage return in the parsed value.
    if command -v jq >/dev/null 2>&1; then
      static_version="$(printf '%s' "$static_response" | jq -r '.version // empty' | tr -d '\r')"
    else
      static_version="$(printf '%s' "$static_response" | grep '"version"' | sed 's/.*"version": *"//;s/".*//' | tr -d '\r')"
    fi
    if [ -n "$static_version" ]; then
      # The version endpoint can advertise a release before its binaries are
      # uploaded (or one whose release pipeline failed). Trust it only when
      # the platform asset is actually downloadable.
      if asset_exists "$static_version"; then
        VERSION="$static_version"
        return
      fi
      echo "Warning: ${static_version} is advertised but its release assets are not available yet (release may be in progress)." >&2
      echo "Falling back to the newest installable release..." >&2
    fi
  fi

  # Fallback: walk recent GitHub releases (newest first) and pick the first
  # one whose platform asset exists. 'releases/latest' alone is not enough -
  # it returns a release as soon as it is published, before assets upload.
  api_url="https://api.github.com/repos/${REPO}/releases?per_page=10"
  auth_header=""
  if [ -n "${GITHUB_TOKEN:-}" ]; then
    auth_header="Authorization: token ${GITHUB_TOKEN}"
  fi

  if command -v curl >/dev/null 2>&1; then
    response="$(curl -fsSL ${auth_header:+-H "$auth_header"} "$api_url" || true)"
  elif command -v wget >/dev/null 2>&1; then
    response="$(wget -qO- ${auth_header:+--header="$auth_header"} "$api_url" 2>/dev/null || true)"
  else
    echo "Error: curl or wget is required." >&2
    exit 1
  fi

  # Basic sanity check that we got a JSON array back
  case "$response" in
    \[*)
      ;;
    *)
      echo "Error: unexpected response from GitHub releases API." >&2
      echo "Response (truncated): $(printf '%s' "$response" | cut -c1-200)" >&2
      exit 1
      ;;
  esac

  # tr -d '\r': jq on Windows (Git Bash) emits CRLF line endings, which would
  # otherwise leave a carriage return on every tag and fail validation below.
  if command -v jq >/dev/null 2>&1; then
    tags="$(printf '%s' "$response" | jq -r '.[].tag_name // empty' | tr -d '\r' || true)"
  else
    tags="$(printf '%s' "$response" | grep '"tag_name"' | sed 's/.*"tag_name": *"//;s/".*//' | tr -d '\r' || true)"
  fi

  if [ -z "$tags" ]; then
    echo "Error: could not determine latest version (no release tags found)." >&2
    exit 1
  fi

  for tag in $tags; do
    # Validate that the tag looks reasonable before using it in a URL
    case "$tag" in
      *[!A-Za-z0-9._-]*) continue ;;
    esac
    if asset_exists "$tag"; then
      VERSION="$tag"
      return
    fi
  done

  echo "Error: none of the recent releases have a ${ARTIFACT}.${EXT} asset." >&2
  echo "Visit https://github.com/${REPO}/releases or https://cli.archgate.dev/getting-started/installation/ for alternative install methods." >&2
  exit 1
}

# --- Download and install ---

download_and_install() {
  url="$(asset_url "$VERSION")"

  echo "Installing archgate ${VERSION} (${ARTIFACT})..."

  tmpdir="$(mktemp -d)"
  trap 'rm -rf "$tmpdir"' EXIT

  if command -v curl >/dev/null 2>&1; then
    curl -fsSL "$url" -o "$tmpdir/archgate.${EXT}"
  elif command -v wget >/dev/null 2>&1; then
    wget -qO "$tmpdir/archgate.${EXT}" "$url"
  else
    echo "Error: neither 'curl' nor 'wget' is installed. Please install one of them to download archgate." >&2
    exit 1
  fi

  mkdir -p "$INSTALL_DIR"

  if [ "$platform" = "win32" ]; then
    unzip -qo "$tmpdir/archgate.zip" -d "$tmpdir"
    mv "$tmpdir/archgate.exe" "$INSTALL_DIR/archgate.exe"
  else
    tar -xzf "$tmpdir/archgate.tar.gz" -C "$tmpdir"
    mv "$tmpdir/archgate" "$INSTALL_DIR/archgate"
    chmod +x "$INSTALL_DIR/archgate"
  fi
}

# --- Update PATH ---

get_shell_profiles() {
  profiles=""

  # Zsh
  for f in "$HOME/.zshrc" "$HOME/.zshenv" "$HOME/.zprofile"; do
    if [ -f "$f" ]; then
      profiles="$profiles $f"
      break
    fi
  done

  # Bash — login vs interactive, Linux vs macOS
  for f in "$HOME/.bashrc" "$HOME/.bash_profile" "$HOME/.profile"; do
    if [ -f "$f" ]; then
      profiles="$profiles $f"
      break
    fi
  done

  # Fish
  fish_config="$HOME/.config/fish/config.fish"
  if [ -f "$fish_config" ]; then
    profiles="$profiles $fish_config"
  fi

  # Nushell
  for f in "$HOME/.config/nushell/env.nu" "$HOME/Library/Application Support/nushell/env.nu"; do
    if [ -f "$f" ]; then
      profiles="$profiles $f"
      break
    fi
  done

  # Ion
  if [ -f "$HOME/.config/ion/initrc" ]; then
    profiles="$profiles $HOME/.config/ion/initrc"
  fi

  # Csh / Tcsh
  for f in "$HOME/.cshrc" "$HOME/.tcshrc"; do
    if [ -f "$f" ]; then
      profiles="$profiles $f"
      break
    fi
  done

  echo "$profiles"
}

path_line_for() {
  file="$1"
  case "$file" in
    *.fish)
      echo "fish_add_path ${INSTALL_DIR}" ;;
    *env.nu)
      echo "\$env.PATH = (\$env.PATH | prepend '${INSTALL_DIR}')" ;;
    *initrc)
      echo "let path = [ ${INSTALL_DIR} \$path ]" ;;
    *.cshrc|*.tcshrc)
      echo "set path = ( ${INSTALL_DIR} \$path )" ;;
    *)
      echo "export PATH=\"${INSTALL_DIR}:\$PATH\"" ;;
  esac
}

already_configured() {
  file="$1"
  grep -qF "${INSTALL_DIR}" "$file" 2>/dev/null
}

setup_path() {
  # Already on PATH — nothing to do
  case ":${PATH}:" in
    *":${INSTALL_DIR}:"*) return ;;
  esac

  profiles="$(get_shell_profiles)"

  if [ -z "$profiles" ]; then
    echo ""
    echo "Could not detect any shell profile files."
    echo "Manually add ${INSTALL_DIR} to your PATH."
    return
  fi

  # Collect profiles that still need the PATH line
  needs_update=""
  already_done=""
  for f in $profiles; do
    if already_configured "$f"; then
      already_done="$already_done $f"
    else
      needs_update="$needs_update $f"
    fi
  done

  if [ -n "$already_done" ]; then
    for f in $already_done; do
      echo "  Already configured: $f"
    done
  fi

  if [ -z "$needs_update" ]; then
    echo "PATH is already configured in all detected shell profiles."
    return
  fi

  echo ""
  echo "Detected shell profiles to update:"
  for f in $needs_update; do
    echo "  $f  ->  $(path_line_for "$f")"
  done
  echo ""

  # Prompt requires /dev/tty — available even when stdin is piped (curl | sh).
  # Use a subshell to test the actual open, because -r may pass on CI runners
  # that have /dev/tty present but no controlling terminal.
  if ! (exec </dev/tty) 2>/dev/null; then
    echo "No TTY available. To add archgate to your PATH manually, add the lines above to your shell profile."
    return
  fi

  printf "Update these files now? [Y/n] "
  if ! read -r answer </dev/tty 2>/dev/null; then
    echo ""
    echo "Could not read from terminal. To add archgate to your PATH manually, add the lines above to your shell profile."
    return
  fi
  case "$answer" in
    [nN]*)
      echo ""
      echo "Skipped. To add archgate to your PATH manually, add the lines above to your shell profile."
      return
      ;;
  esac

  for f in $needs_update; do
    line="$(path_line_for "$f")"
    printf '\n# archgate\n%s\n' "$line" >> "$f"
    echo "  Updated: $f"
  done
  echo ""
  echo "Restart your shell or open a new terminal to use archgate."
}

# --- Main ---

main() {
  detect_platform
  resolve_version
  download_and_install

  if [ "$platform" = "win32" ]; then
    echo "archgate ${VERSION} installed to ${INSTALL_DIR}/archgate.exe"
  else
    echo "archgate ${VERSION} installed to ${INSTALL_DIR}/archgate"
  fi
  setup_path

  echo ""
  echo "Run 'archgate --help' to get started."
}

main