setup_github_packages

#!/usr/bin/env bash
# Install some specific packages directly from GitHub. Specifically:
#
# - agg (asciinema gif generator)
# - browsh
# - bun
# - ctop
# - deno
# - docker-compose
# - github cli
# - fnm
# - helix
# - hugo
# - lazydocker
# - lazygit
# - neovim (latest)
# - sad
# - yq
# - zellij
#
# Usage `install_github_packages`

set -euo pipefail
IFS=$'\n\t'
export DEBIAN_FRONTEND=noninteractive

echo_stderr() {
  >&2 echo "${@}"
}

get_latest_release_url() {
  local repo="$1"
  local match="$2"
  local urls

  local release_json_url="https://api.github.com/repos/${repo}/releases/latest"
  urls=$(curl --silent "${release_json_url}" | jq -r '.assets[]?.browser_download_url' | grep "${match}")
  if [[ -z "${urls}" ]]; then
    echo_stderr "Error: Could not find url for ${repo} matching ${match}"
    exit 2
  fi
  echo "${urls}"| head -n 1
}

install_bin() {
  local repo="${1}"
  local match="${2}"
  local name="${3:-}"
  if [[ -z "${name}" ]]; then
    name="$(basename "${repo}")"
  fi

  local url
  url="$(get_latest_release_url "${repo}" "${match}")"

  local install_location="$HOME/.local/bin"
  mkdir -p "${install_location}"
  echo -n "Downloading ${name} ... "
  wget --quiet -O "${install_location}/${name}" "${url}"
  chmod 755 "${install_location}/${name}"
  echo "${name} installed"
}

install_deb() {
  local repo="${1}"
  local match="${2}"
  local name
  local download_dir

  name="$(basename "${repo}")"

  local url
  url="$(get_latest_release_url "${repo}" "${match}")"

  download_dir="$(mktemp --directory "${name}"XXX)"
  pushd "${download_dir}" > /dev/null
  wget --quiet -O "${name}.deb" "${url}"
  echo -n "Installing ${repo} (requires sudo) ... "
  sudo dpkg -i "${name}.deb"
  popd > /dev/null
  rm -rf "${download_dir}"
}

install_tarball() {
  local repo="${1}"
  local match="${2}"
  local name
  name="$(basename "${repo}")"

  local url
  url="$(get_latest_release_url "${repo}" "${match}")"

  local install_location="$HOME/.local/bin"

  local download_dir
  download_dir="$(mktemp --directory "${name}"XXX)"

  pushd "${download_dir}" > /dev/null
  wget --quiet -O "${name}.tar.gz" "${url}"
  echo -n "Expanding ${name}.tar.gz ... "
  tar xzvf "${name}.tar.gz"
  mv "${name}" "${install_location}/${name}"
  chmod 755 "${install_location}/${name}"
  popd > /dev/null
  rm -rf "${download_dir}"
  echo "${name} installed"
}

install_zip() {
  local repo="${1}"
  local match="${2}"
  local name
  name="$(basename "${repo}")"

  local url
  url="$(get_latest_release_url "${repo}" "${match}")"

  local install_location="$HOME/.local/bin"

  local download_dir
  download_dir="$(mktemp --directory "${name}"XXX)"

  pushd "${download_dir}" > /dev/null
  wget --quiet -O "${name}.zip" "${url}"
  echo -n "Unzipping ${name}.zip ... "
  unzip -q -o -j -d "${install_location}" "${name}.zip"
  chmod 755 "${install_location}/${name}"
  popd > /dev/null
  rm -rf "${download_dir}"
  echo "${name} installed"
}

install_agg() {
  install_bin 'asciinema/agg' 'agg-x86_64-unknown-linux-musl'
}

install_browsh() {
  echo "Installing browsh dependencies (requires sudo)"
  sudo apt-get install -qq --assume-yes --fix-broken --no-install-recommends \
    firefox-esr

  install_deb 'browsh-org/browsh' 'browsh_.*_linux_amd64.deb'
}

install_bun() {
  install_zip 'oven-sh/bun' 'bun-linux-x64-baseline.zip'

  echo "Generating bun bash completion"
  mkdir -p "$HOME/.local/completion.d"
  SHELL=bash bun completions "$HOME/.local/completion.d"
}

install_ctop() {
  install_bin 'bcicen/ctop' 'ctop-.*-linux-amd64'
}

install_deno() {
  install_zip 'denoland/deno' 'deno-x86_64-unknown-linux-gnu.zip'

  echo "Generating deno bash completion"
  mkdir -p "$HOME/.local/completion.d"
  deno completions bash > "$HOME/.local/completion.d/deno_completion"
}

install_docker_compose() {
  install_bin 'docker/compose' 'linux-x86_64' 'docker-compose'
}

install_github_cli() {
  install_deb 'cli/cli' 'gh_.*_linux_amd64.deb'
}

install_fnm() {
  install_zip 'Schniz/fnm' 'fnm-linux.zip'

  echo -n "Generating completions ... "
  mkdir -p "$HOME/.local/completion.d"
  fnm completions > "$HOME/.local/completion.d/fnm_completion"
  echo "Complete!"

  echo "Installing node LTS ... "
  fnm install --lts

  echo "Setting node version to LTS"
  fnm default lts-latest
}

install_helix() {
  local url
  url="$(get_latest_release_url 'helix-editor/helix' 'x86_64.AppImage')"
  local install_location="$HOME/.local/bin"
  mkdir -p "${install_location}"
  echo -n "Downloading helix ... "
  wget --quiet -O "${install_location}/hx" "${url}"
  chmod 755 "${install_location}/hx"
  echo "helix installed"
}

install_hugo() {
  install_deb 'gohugoio/hugo' 'hugo_extended_.*_linux-amd64.deb'

  echo "Generating hugo bash completion & man pages"
  mkdir -p "$HOME/.local/completion.d"
  hugo completion bash > "$HOME/.local/completion.d/hugo_completion"
  pushd "$(mktemp -d)" > /dev/null
  hugo gen man
  local man_dir_path="$HOME/.local/share/man/man1"
  mkdir -p "${man_dir_path}"
  mv man/* "${man_dir_path}"
  popd > /dev/null
  rm -rf "${man_dir_path}"
}

install_lazydocker() {
  install_tarball 'jesseduffield/lazydocker' 'lazydocker_.*_Linux_x86_64.tar.gz'
}

install_lazygit() {
  install_tarball 'jesseduffield/lazygit' 'lazygit_.*_Linux_x86_64.tar.gz'
}

install_sad() {
  install_deb 'ms-jpq/sad' 'x86_64-unknown-linux-gnu.deb'
}

install_neovim_stable() {
  local vim_path="$HOME/.local/bin/nvim"

  echo -n "Installing neovim stable ... "
  mkdir -p "$(dirname "${vim_path}")"
  wget "https://github.com/neovim/neovim/releases/download/stable/nvim.appimage" \
    --quiet --output-document "$vim_path"
  chmod +x "$vim_path"
  echo "neovim stable installed"

  if [[ -n "${IS_DOCKER:-}" ]]; then
    local vim_appimage_dir_path="$HOME/.local/appimages/nvim"
    echo "Expanding neovim AppImage"
    mkdir -p "${vim_appimage_dir_path}"
    (
      cd "${vim_appimage_dir_path}"
      mv "${vim_path}" .
      "${vim_appimage_dir_path}/nvim" --appimage-extract > /dev/null
      ln -s "${vim_appimage_dir_path}/squashfs-root/AppRun" "${vim_path}"
    )
  fi

  if [[ -d "$HOME/.local/share/nvim/lazy/lazy.nvim" ]]; then
    echo "Syncing plugins"
    "${vim_path}" --headless "+Lazy! sync" +qa
  else
    echo "Must manually launch Neovim to install plugins"
  fi

  echo "Setting neovim as default editor (requires sudo)"
  sudo update-alternatives --install /usr/bin/ex ex "${vim_path}" 110
  sudo update-alternatives --install /usr/bin/vi vi "${vim_path}" 110
  sudo update-alternatives --install /usr/bin/view view "${vim_path}" 110
  sudo update-alternatives --install /usr/bin/vim vim "${vim_path}" 110
  sudo update-alternatives --install /usr/bin/vimdiff vimdiff "${vim_path}" 110
}

install_yq() {
  install_bin 'mikefarah/yq' 'yq_linux_amd64'

  echo "Generating yq bash completion"
  mkdir -p "$HOME/.local/completion.d"
  yq shell-completion bash > "$HOME/.local/completion.d/yq_completion"
}

install_zellij() {
  install_tarball 'zellij-org/zellij' 'zellij-x86_64-unknown-linux-musl.tar.gz'
}

main() {
  . "${HOME}/.profile.local"

  install_agg
  # Requries Firefox, may not be wanted on headless machines
  [[ -z "${IS_HEADLESS:-}" ]] && install_browsh
  install_bun
  install_ctop
  install_deno
  install_docker_compose
  install_fnm
  # Bookworm tracking recent version already, can use apt
  # install_github_cli
  install_helix
  # Bookworm tracking recent version already, can use apt
  # install_hugo
  install_lazydocker
  install_lazygit
  install_neovim_stable
  install_sad
  install_yq
  install_zellij
}

main