diff --git a/install-coder.sh b/install-coder.sh
index c0e888d..68bb59b 100644
--- a/install-coder.sh
+++ b/install-coder.sh
@@ -1,871 +1,618 @@
-#!/usr/bin/env /bin/sh
+#!/bin/sh
 set -eu
 
-# Coder's automatic install script.
-# See https://github.com/coder/coder#install
-#
-# To run:
-# curl -L https://coder.com/install.sh | sh
+# code-server's automatic install script.
+# See https://coder.com/docs/code-server/latest/install
 
 usage() {
-	arg0="$0"
-	if [ "$0" = sh ]; then
-		arg0="curl -fsSL https://coder.com/install.sh | sh -s --"
-	else
-		not_curl_usage="The latest script is available at https://coder.com/install.sh
+  arg0="$0"
+  if [ "$0" = sh ]; then
+    arg0="curl -fsSL https://code-server.dev/install.sh | sh -s --"
+  else
+    not_curl_usage="The latest script is available at https://code-server.dev/install.sh
 "
-	fi
+  fi
 
-	cath <<EOF
-Installs Coder.
+  cath << EOF
+Installs code-server.
 It tries to use the system package manager if possible.
-After successful installation it explains how to start Coder.
+After successful installation it explains how to start using code-server.
 
-Pass in user@host to install Coder on user@host over ssh.
+Pass in user@host to install code-server on user@host over ssh.
 The remote host must have internet access.
 ${not_curl_usage-}
 Usage:
 
-  ${arg0} [--dry-run] [--mainline | --stable | --version X.X.X] [--method detect] \
+  $arg0 [--dry-run] [--version X.X.X] [--edge] [--method detect] \
         [--prefix ~/.local] [--rsh ssh] [user@host]
 
   --dry-run
       Echo the commands for the install process without running them.
 
-  --mainline
-      Install the latest mainline version (default).
-
-  --stable
-	  Install the latest stable version instead of the latest mainline version.
-
   --version X.X.X
       Install a specific version instead of the latest.
 
+  --edge
+      Install the latest edge version instead of the latest stable version.
+
   --method [detect | standalone]
       Choose the installation method. Defaults to detect.
       - detect detects the system package manager and tries to use it.
         Full reference on the process is further below.
-      - standalone installs a standalone release archive into /usr/local/bin
+      - standalone installs a standalone release archive into ~/.local
+        Add ~/.local/bin to your \$PATH to use it.
 
   --prefix <dir>
-      Sets the prefix used by standalone release archives. Defaults to /usr/local
-      and the binary is copied into /usr/local/bin
-      To install in \$HOME, pass --prefix=\$HOME/.local
-
-  --binary-name <name>
-	  Sets the name for the CLI in standalone release archives. Defaults to "coder"
-	  To use the CLI as coder2, pass --binary-name=coder2
-	  Note: in-product documentation will always refer to the CLI as "coder"
+      Sets the prefix used by standalone release archives. Defaults to ~/.local
+      The release is unarchived into ~/.local/lib/code-server-X.X.X
+      and the binary symlinked into ~/.local/bin/code-server
+      To install system wide pass --prefix=/usr/local
 
   --rsh <bin>
       Specifies the remote shell for remote installation. Defaults to ssh.
 
-  --with-terraform
-	  Installs Terraform binary from https://releases.hashicorp.com/terraform/${TERRAFORM_VERSION}/ source
-	  alongside coder.
-	  This is great for if you are having issues with Coder installing terraform, or if you
-	  just want it on your base system aswell.
-	  This supports most systems, however if you are unsure yours is supported you can check
-	  the link above.
-  --net-admin
-	  Adds \`CAP_NET_ADMIN\` to the installed binary. This allows Coder to
-	  increase network speeds, but has security implications.
-	  See: https://man7.org/linux/man-pages/man7/capabilities.7.html
-	  This only works on Linux based systems.
-
-
 The detection method works as follows:
   - Debian, Ubuntu, Raspbian: install the deb package from GitHub.
   - Fedora, CentOS, RHEL, openSUSE: install the rpm package from GitHub.
-  - Alpine: install the apk package from GitHub.
-  - macOS:  if \`brew\` is available, install from the coder/coder Homebrew tap.
-  - Otherwise, download from GitHub and install into \`--prefix\`.
+  - Arch Linux: install from the AUR (which pulls releases from GitHub).
+  - FreeBSD, Alpine: install from npm.
+  - macOS: install using Homebrew if installed otherwise install from GitHub.
+  - All others: install the release from GitHub.
 
-We build releases on GitHub for amd64, armv7, and arm64 on Windows, Linux, and macOS.
+We only build releases on GitHub for amd64 and arm64 on Linux and amd64 for
+macOS. When the detection method tries to pull a release from GitHub it will
+fall back to installing from npm when there is no matching release for the
+system's operating system and architecture.
 
-When the detection method tries to pull a release from GitHub it will
-fall back to installing standalone when there is no matching release for
-the system's operating system and architecture.
+The standalone method will force installion using GitHub releases. It will not
+fall back to npm so on architectures without pre-built releases this will error.
 
-The installer will cache all downloaded assets into ~/.cache/coder
+The installer will cache all downloaded assets into ~/.cache/code-server
+
+More installation docs are at https://coder.com/docs/code-server/latest/install
 EOF
 }
 
-echo_latest_stable_version() {
-	url="https://github.com/coder/coder/releases/latest"
-	# https://gist.github.com/lukechilds/a83e1d7127b78fef38c2914c4ececc3c#gistcomment-2758860
-	response=$(curl -sSLI -o /dev/null -w "\n%{http_code} %{url_effective}" ${url})
-	status_code=$(echo "$response" | tail -n1 | cut -d' ' -f1)
-	version=$(echo "$response" | tail -n1 | cut -d' ' -f2-)
-	body=$(echo "$response" | sed '$d')
-
-	if [ "$status_code" != "200" ]; then
-		echoerr "GitHub API returned status code: ${status_code}"
-		echoerr "URL: ${url}"
-		exit 1
-	fi
-
-	version="${version#https://github.com/coder/coder/releases/tag/v}"
-	echo "${version}"
+echo_latest_version() {
+  if [ "${EDGE-}" ]; then
+    version="$(curl -fsSL https://api.github.com/repos/coder/code-server/releases | awk 'match($0,/.*"html_url": "(.*\/releases\/tag\/.*)".*/)' | head -n 1 | awk -F '"' '{print $4}')"
+  else
+    # https://gist.github.com/lukechilds/a83e1d7127b78fef38c2914c4ececc3c#gistcomment-2758860
+    version="$(curl -fsSLI -o /dev/null -w "%{url_effective}" https://github.com/coder/code-server/releases/latest)"
+  fi
+  version="${version#https://github.com/coder/code-server/releases/tag/}"
+  version="${version#v}"
+  echo "$version"
 }
 
-echo_latest_mainline_version() {
-	# Fetch the releases from the GitHub API, sort by version number,
-	# and take the first result. Note that we're sorting by space-
-	# separated numbers and without utilizing the sort -V flag for the
-	# best compatibility.
-	url="https://api.github.com/repos/coder/coder/releases"
-	response=$(curl -sSL -w "\n%{http_code}" ${url})
-	status_code=$(echo "$response" | tail -n1)
-	body=$(echo "$response" | sed '$d')
+echo_npm_postinstall() {
+  echoh
+  cath << EOF
+npm package has been installed.
 
-	if [ "$status_code" != "200" ]; then
-		echoerr "GitHub API returned status code: ${status_code}"
-		echoerr "URL: ${url}"
-		echoerr "Response body: ${body}"
-		exit 1
-	fi
-
-	echo "$body" |
-		awk -F'"' '/"tag_name"/ {print $4}' |
-		tr -d v |
-		tr . ' ' |
-		sort -k1,1nr -k2,2nr -k3,3nr |
-		head -n1 |
-		tr ' ' .
+Extend your path to use code-server:
+  PATH="$NPM_BIN_DIR:\$PATH"
+Then run with:
+  code-server
+EOF
 }
 
 echo_standalone_postinstall() {
-	if [ "${DRY_RUN-}" ]; then
-		echo_dryrun_postinstall
-		return
-	fi
-
-	channel=
-	advisory="To install our stable release (v${STABLE_VERSION}), use the --stable flag. "
-	if [ "${STABLE}" = 1 ]; then
-		channel="stable "
-		advisory=""
-	fi
-	if [ "${MAINLINE}" = 1 ]; then
-		channel="mainline "
-	fi
-
-	cath <<EOF
-
-Coder ${channel}release v${VERSION} installed. ${advisory}See our releases documentation or GitHub for more information on versioning.
-
-The Coder binary has been placed in the following location:
-
-  $STANDALONE_INSTALL_PREFIX/bin/$STANDALONE_BINARY_NAME
+  echoh
+  cath << EOF
+Standalone release has been installed into $STANDALONE_INSTALL_PREFIX/lib/code-server-$VERSION
 
+Extend your path to use code-server:
+  PATH="$STANDALONE_INSTALL_PREFIX/bin:\$PATH"
+Then run with:
+  code-server
 EOF
-
-	CODER_COMMAND="$(command -v "$STANDALONE_BINARY_NAME" || true)"
-
-	if [ -z "${CODER_COMMAND}" ]; then
-		cath <<EOF
-Extend your path to use Coder:
-
-  $ PATH="$STANDALONE_INSTALL_PREFIX/bin:\$PATH"
-
-EOF
-	elif [ "$CODER_COMMAND" != "$STANDALONE_BINARY_LOCATION" ]; then
-		echo_path_conflict "$CODER_COMMAND"
-	else
-		cath <<EOF
-To run a Coder server:
-
-  $ $STANDALONE_BINARY_NAME server
-
-To connect to a Coder deployment:
-
-  $ $STANDALONE_BINARY_NAME login <deployment url>
-
-EOF
-	fi
 }
 
 echo_brew_postinstall() {
-	if [ "${DRY_RUN-}" ]; then
-		echo_dryrun_postinstall
-		return
-	fi
-
-	BREW_PREFIX="$(brew --prefix)"
-
-	cath <<EOF
-
-Coder has been installed to
-
-  $BREW_PREFIX/bin/coder
-
-EOF
-
-	CODER_COMMAND="$(command -v "coder" || true)"
-
-	if [ "$CODER_COMMAND" != "$BREW_PREFIX/bin/coder" ]; then
-		echo_path_conflict "$CODER_COMMAND"
-	fi
-
-	cath <<EOF
-To run a Coder server:
-
-  $ coder server
-
-To connect to a Coder deployment:
-
-  $ coder login <deployment url>
+  echoh
+  cath << EOF
+Brew release has been installed.
 
+Run with:
+  code-server
 EOF
 }
 
 echo_systemd_postinstall() {
-	if [ "${DRY_RUN-}" ]; then
-		echo_dryrun_postinstall
-		return
-	fi
-
-	echoh
-	cath <<EOF
+  echoh
+  cath << EOF
 $1 package has been installed.
 
-To run a Coder server:
-
-  # Start Coder now and on reboot
-  $ sudo systemctl enable --now coder
-  $ journalctl -u coder.service -b
-
-  # Or just run the server directly
-  $ coder server
-
-  Configuring Coder: https://coder.com/docs/admin/setup
-
-To connect to a Coder deployment:
-
-  $ coder login <deployment url>
-
+To have systemd start code-server now and restart on boot:
+  sudo systemctl enable --now code-server@\$USER
+Or, if you don't want/need a background service you can run:
+  code-server
 EOF
 }
 
-echo_dryrun_postinstall() {
-	cath <<EOF
-Dry-run complete.
-
-To install Coder, re-run this script without the --dry-run flag.
-
-EOF
-}
-
-echo_path_conflict() {
-	cath <<EOF
-There is another binary in your PATH that conflicts with the binary we've installed.
-
-  $1
-
-This is likely because of an existing installation of Coder in your \$PATH.
-
-Run \`which -a coder\` to view all installations.
-
-EOF
+echo_coder_postinstall() {
+  echoh
+  echoh "Deploy code-server for your team with Coder: https://github.com/coder/coder"
 }
 
 main() {
-	MAINLINE=1
-	STABLE=0
-	TERRAFORM_VERSION="1.11.4"
+  if [ "${TRACE-}" ]; then
+    set -x
+  fi
 
-	if [ "${TRACE-}" ]; then
-		set -x
-	fi
+  unset \
+    DRY_RUN \
+    METHOD \
+    OPTIONAL \
+    ALL_FLAGS \
+    RSH_ARGS \
+    EDGE \
+    RSH
 
-	unset \
-		DRY_RUN \
-		METHOD \
-		OPTIONAL \
-		ALL_FLAGS \
-		RSH_ARGS \
-		RSH \
-		WITH_TERRAFORM \
-		CAP_NET_ADMIN
+  ALL_FLAGS=""
+  while [ "$#" -gt 0 ]; do
+    case "$1" in
+      -*)
+        ALL_FLAGS="${ALL_FLAGS} $1"
+        ;;
+    esac
 
-	ALL_FLAGS=""
+    case "$1" in
+      --dry-run)
+        DRY_RUN=1
+        ;;
+      --method)
+        METHOD="$(parse_arg "$@")"
+        shift
+        ;;
+      --method=*)
+        METHOD="$(parse_arg "$@")"
+        ;;
+      --prefix)
+        STANDALONE_INSTALL_PREFIX="$(parse_arg "$@")"
+        shift
+        ;;
+      --prefix=*)
+        STANDALONE_INSTALL_PREFIX="$(parse_arg "$@")"
+        ;;
+      --version)
+        VERSION="$(parse_arg "$@")"
+        shift
+        ;;
+      --version=*)
+        VERSION="$(parse_arg "$@")"
+        ;;
+      --edge)
+        EDGE=1
+        ;;
+      --rsh)
+        RSH="$(parse_arg "$@")"
+        shift
+        ;;
+      --rsh=*)
+        RSH="$(parse_arg "$@")"
+        ;;
+      -h | --h | -help | --help)
+        usage
+        exit 0
+        ;;
+      --)
+        shift
+        # We remove the -- added above.
+        ALL_FLAGS="${ALL_FLAGS% --}"
+        RSH_ARGS="$*"
+        break
+        ;;
+      -*)
+        echoerr "Unknown flag $1"
+        echoerr "Run with --help to see usage."
+        exit 1
+        ;;
+      *)
+        RSH_ARGS="$*"
+        break
+        ;;
+    esac
 
-	while [ "$#" -gt 0 ]; do
-		case "$1" in
-		-*)
-			ALL_FLAGS="${ALL_FLAGS} $1"
-			;;
-		esac
+    shift
+  done
 
-		case "$1" in
-		--dry-run)
-			DRY_RUN=1
-			;;
-		--method)
-			METHOD="$(parse_arg "$@")"
-			shift
-			;;
-		--method=*)
-			METHOD="$(parse_arg "$@")"
-			;;
-		--prefix)
-			STANDALONE_INSTALL_PREFIX="$(parse_arg "$@")"
-			shift
-			;;
-		--prefix=*)
-			STANDALONE_INSTALL_PREFIX="$(parse_arg "$@")"
-			;;
-		--binary-name)
-			STANDALONE_BINARY_NAME="$(parse_arg "$@")"
-			shift
-			;;
-		--binary-name=*)
-			STANDALONE_BINARY_NAME="$(parse_arg "$@")"
-			;;
-		--version)
-			VERSION="$(parse_arg "$@")"
-			MAINLINE=0
-			STABLE=0
-			shift
-			;;
-		--version=*)
-			VERSION="$(parse_arg "$@")"
-			MAINLINE=0
-			STABLE=0
-			;;
-		# Support edge for backward compatibility.
-		--mainline | --edge)
-			VERSION=
-			MAINLINE=1
-			STABLE=0
-			;;
-		--stable)
-			VERSION=
-			MAINLINE=0
-			STABLE=1
-			;;
-		--rsh)
-			RSH="$(parse_arg "$@")"
-			shift
-			;;
-		--rsh=*)
-			RSH="$(parse_arg "$@")"
-			;;
-		-h | --h | -help | --help)
-			usage
-			exit 0
-			;;
-		--with-terraform)
-			WITH_TERRAFORM=1
-			;;
-		--net-admin)
-			CAP_NET_ADMIN=1
-			;;
-		--)
-			shift
-			# We remove the -- added above.
-			ALL_FLAGS="${ALL_FLAGS% --}"
-			RSH_ARGS="$*"
-			break
-			;;
-		-*)
-			echoerr "Unknown flag $1"
-			echoerr "Run with --help to see usage."
-			exit 1
-			;;
-		*)
-			RSH_ARGS="$*"
-			break
-			;;
-		esac
+  if [ "${RSH_ARGS-}" ]; then
+    RSH="${RSH-ssh}"
+    echoh "Installing remotely with $RSH $RSH_ARGS"
+    curl -fsSL https://code-server.dev/install.sh | prefix "$RSH_ARGS" "$RSH" "$RSH_ARGS" sh -s -- "$ALL_FLAGS"
+    return
+  fi
 
-		shift
-	done
+  METHOD="${METHOD-detect}"
+  if [ "$METHOD" != detect ] && [ "$METHOD" != standalone ]; then
+    echoerr "Unknown install method \"$METHOD\""
+    echoerr "Run with --help to see usage."
+    exit 1
+  fi
 
-	if [ "${RSH_ARGS-}" ]; then
-		RSH="${RSH-ssh}"
-		echoh "Installing remotely with $RSH $RSH_ARGS"
-		curl -fsSL https://coder.com/install.sh | prefix "$RSH_ARGS" "$RSH" "$RSH_ARGS" sh -s -- "$ALL_FLAGS"
-		return
-	fi
+  # These are used by the various install_* functions that make use of GitHub
+  # releases in order to download and unpack the right release.
+  CACHE_DIR=$(echo_cache_dir)
+  STANDALONE_INSTALL_PREFIX=${STANDALONE_INSTALL_PREFIX:-$HOME/.local}
+  VERSION=${VERSION:-$(echo_latest_version)}
+  # These can be overridden for testing but shouldn't normally be used as it can
+  # result in a broken code-server.
+  OS=${OS:-$(os)}
+  ARCH=${ARCH:-$(arch)}
 
-	# These can be overridden for testing but shouldn't normally be used as it can
-	# result in a broken coder.
-	OS=${OS:-$(os)}
-	ARCH=${ARCH:-$(arch)}
-	TERRAFORM_ARCH=${TERRAFORM_ARCH:-$(terraform_arch)}
+  distro_name
 
-	# If we've been provided a flag which is specific to the standalone installation
-	# method, we should "detect" standalone to be the appropriate installation method.
-	# This check needs to occur before we set these variables with defaults.
-	if [ "${STANDALONE_INSTALL_PREFIX-}" ] || [ "${STANDALONE_BINARY_NAME-}" ]; then
-		METHOD=standalone
-	fi
+  # Standalone installs by pulling pre-built releases from GitHub.
+  if [ "$METHOD" = standalone ]; then
+    if has_standalone; then
+      install_standalone
+      echo_coder_postinstall
+      exit 0
+    else
+      echoerr "There are no standalone releases for $ARCH"
+      echoerr "Please try again without '--method standalone'"
+      exit 1
+    fi
+  fi
 
-	METHOD="${METHOD-detect}"
-	if [ "$METHOD" != detect ] && [ "$METHOD" != standalone ]; then
-		echoerr "Unknown install method \"$METHOD\""
-		echoerr "Run with --help to see usage."
-		exit 1
-	fi
+  # DISTRO can be overridden for testing but shouldn't normally be used as it
+  # can result in a broken code-server.
+  DISTRO=${DISTRO:-$(distro)}
 
-	# We can't reasonably support installing specific versions of Coder through
-	# Homebrew, so if we're on macOS and the `--version` flag or the `--stable`
-	# flag (our tap follows mainline) was set, we should "detect" standalone to
-	# be the appropriate installation method. This check needs to occur before we
-	# set `VERSION` to a default of the latest release.
-	if [ "$OS" = "darwin" ] && { [ "${VERSION-}" ] || [ "${STABLE}" = 1 ]; }; then
-		METHOD=standalone
-	fi
+  case $DISTRO in
+    # macOS uses brew when available and falls back to standalone. We only have
+    # amd64 for macOS so for anything else use npm.
+    macos)
+      BREW_PATH="${BREW_PATH-brew}"
+      if command_exists "$BREW_PATH"; then
+        install_brew
+      else
+        echoh "Homebrew not installed."
+        echoh "Falling back to standalone installation."
+        npm_fallback install_standalone
+      fi
+      ;;
+    # The .deb and .rpm files are pulled from GitHub and we only have amd64 and
+    # arm64 there and need to fall back to npm otherwise.
+    debian) npm_fallback install_deb ;;
+    fedora | opensuse) npm_fallback install_rpm ;;
+    # Arch uses the AUR package which only supports amd64 and arm64 since it
+    # pulls releases from GitHub so we need to fall back to npm.
+    arch) npm_fallback install_aur ;;
+    # We don't have GitHub releases that work on Alpine or FreeBSD so we have no
+    # choice but to use npm here.
+    alpine | freebsd) install_npm ;;
+    # For anything else we'll try to install standalone but fall back to npm if
+    # we don't have releases for the architecture.
+    *)
+      echoh "Unsupported package manager."
+      echoh "Falling back to standalone installation."
+      npm_fallback install_standalone
+      ;;
+  esac
 
-	# These are used by the various install_* functions that make use of GitHub
-	# releases in order to download and unpack the right release.
-	CACHE_DIR=$(echo_cache_dir)
-	TERRAFORM_INSTALL_PREFIX=${TERRAFORM_INSTALL_PREFIX:-/usr/local}
-	STANDALONE_INSTALL_PREFIX=${STANDALONE_INSTALL_PREFIX:-/usr/local}
-	STANDALONE_BINARY_NAME=${STANDALONE_BINARY_NAME:-coder}
-	STABLE_VERSION=$(echo_latest_stable_version)
-	if [ "${MAINLINE}" = 1 ]; then
-		VERSION=$(echo_latest_mainline_version)
-		echoh "Resolved mainline version: v${VERSION}"
-	elif [ "${STABLE}" = 1 ]; then
-		VERSION=${STABLE_VERSION}
-		echoh "Resolved stable version: v${VERSION}"
-	fi
-
-	distro_name
-
-	if [ "${DRY_RUN-}" ]; then
-		echoh "Running with --dry-run; the following are the commands that would be run if this were a real installation:"
-		echoh
-	fi
-
-	# Start by installing Terraform, if requested
-	if [ "${WITH_TERRAFORM-}" ]; then
-		with_terraform
-	fi
-
-	# If the version is the same as the stable version, we're installing
-	# the stable version.
-	if [ "${MAINLINE}" = 1 ] && [ "${VERSION}" = "${STABLE_VERSION}" ]; then
-		echoh "The latest mainline version has been promoted to stable, selecting stable."
-		MAINLINE=0
-		STABLE=1
-	fi
-	# If the manually specified version is stable, mark it as such.
-	if [ "${MAINLINE}" = 0 ] && [ "${STABLE}" = 0 ] && [ "${VERSION}" = "${STABLE_VERSION}" ]; then
-		STABLE=1
-	fi
-
-	# Standalone installs by pulling pre-built releases from GitHub.
-	if [ "$METHOD" = standalone ]; then
-		if has_standalone; then
-			install_standalone
-			exit 0
-		else
-			echoerr "There are no standalone releases for $ARCH"
-			echoerr "Please try again without '--method standalone'"
-			exit 1
-		fi
-	fi
-
-	# DISTRO can be overridden for testing but shouldn't normally be used as it
-	# can result in a broken coder.
-	DISTRO=${DISTRO:-$(distro)}
-
-	case $DISTRO in
-	darwin) install_macos ;;
-	# The .deb and .rpm files are pulled from GitHub.
-	debian) install_deb ;;
-	fedora | opensuse) install_rpm ;;
-	# We don't have GitHub releases that work on Alpine or FreeBSD so we have no
-	# choice but to use npm here.
-	alpine) install_apk ;;
-	# For anything else we'll try to install standalone but fall back to npm if
-	# we don't have releases for the architecture.
-	*)
-		echoh "Unsupported package manager."
-		echoh "Falling back to standalone installation."
-		install_standalone
-		;;
-	esac
-
-	if [ "${CAP_NET_ADMIN:-}" ]; then
-		cap_net_admin
-	fi
-}
-
-cap_net_admin() {
-	if ! command_exists setcap && command_exists capsh; then
-		echo "Package 'libcap' not found. See install instructions for your distro: https://command-not-found.com/setcap"
-		return
-	fi
-
-	# Make sure we'e allowed to add CAP_NET_ADMIN.
-	if sudo_sh_c capsh --has-p=CAP_NET_ADMIN; then
-		sudo_sh_c setcap CAP_NET_ADMIN=+ep "$(command -v coder)" || true
-
-	# Unable to escalate perms, notify the user.
-	else
-		echo "Unable to setcap agent binary. Ensure the root user has CAP_NET_ADMIN permissions."
-	fi
+  echo_coder_postinstall
 }
 
 parse_arg() {
-	case "$1" in
-	*=*)
-		# Remove everything after first equal sign.
-		opt="${1%%=*}"
-		# Remove everything before first equal sign.
-		optarg="${1#*=}"
-		if [ ! "$optarg" ] && [ ! "${OPTIONAL-}" ]; then
-			echoerr "$opt requires an argument"
-			echoerr "Run with --help to see usage."
-			exit 1
-		fi
-		echo "$optarg"
-		return
-		;;
-	esac
+  case "$1" in
+    *=*)
+      # Remove everything after first equal sign.
+      opt="${1%%=*}"
+      # Remove everything before first equal sign.
+      optarg="${1#*=}"
+      if [ ! "$optarg" ] && [ ! "${OPTIONAL-}" ]; then
+        echoerr "$opt requires an argument"
+        echoerr "Run with --help to see usage."
+        exit 1
+      fi
+      echo "$optarg"
+      return
+      ;;
+  esac
 
-	case "${2-}" in
-	"" | -*)
-		if [ ! "${OPTIONAL-}" ]; then
-			echoerr "$1 requires an argument"
-			echoerr "Run with --help to see usage."
-			exit 1
-		fi
-		;;
-	*)
-		echo "$2"
-		return
-		;;
-	esac
+  case "${2-}" in
+    "" | -*)
+      if [ ! "${OPTIONAL-}" ]; then
+        echoerr "$1 requires an argument"
+        echoerr "Run with --help to see usage."
+        exit 1
+      fi
+      ;;
+    *)
+      echo "$2"
+      return
+      ;;
+  esac
 }
 
 fetch() {
-	URL="$1"
-	FILE="$2"
+  URL="$1"
+  FILE="$2"
 
-	if [ -e "$FILE" ]; then
-		echoh "+ Reusing $FILE"
-		return
-	fi
+  if [ -e "$FILE" ]; then
+    echoh "+ Reusing $FILE"
+    return
+  fi
 
-	sh_c mkdir -p "$CACHE_DIR"
-	sh_c curl \
-		-#fL \
-		-o "$FILE.incomplete" \
-		-C - \
-		"$URL"
-	sh_c mv "$FILE.incomplete" "$FILE"
+  sh_c mkdir -p "$CACHE_DIR"
+  sh_c curl \
+    -#fL \
+    -o "$FILE.incomplete" \
+    -C - \
+    "$URL"
+  sh_c mv "$FILE.incomplete" "$FILE"
 }
 
-with_terraform() {
-	# Check if the unzip package is installed. If not error peacefully.
-	if ! (command_exists unzip); then
-		echoh
-		echoerr "This script needs the unzip package to run."
-		echoerr "Please install unzip to use this function"
-		exit 1
-	fi
-	echoh "Installing Terraform version $TERRAFORM_VERSION $TERRAFORM_ARCH from the HashiCorp release repository."
-	echoh
+install_brew() {
+  echoh "Installing latest from Homebrew."
+  echoh
 
-	# Download from official source and save it to cache
-	fetch "https://releases.hashicorp.com/terraform/${TERRAFORM_VERSION}/terraform_${TERRAFORM_VERSION}_${OS}_${TERRAFORM_ARCH}.zip" \
-		"$CACHE_DIR/terraform_${TERRAFORM_VERSION}_${OS}_${TERRAFORM_ARCH}.zip"
+  sh_c "$BREW_PATH" install code-server
 
-	sh_c mkdir -p "$TERRAFORM_INSTALL_PREFIX" 2>/dev/null || true
-
-	sh_c="sh_c"
-	if [ ! -w "$TERRAFORM_INSTALL_PREFIX" ]; then
-		sh_c="sudo_sh_c"
-	fi
-	# Prepare /usr/local/bin/ and the binary for copying
-	"$sh_c" mkdir -p "$TERRAFORM_INSTALL_PREFIX/bin"
-	"$sh_c" unzip -d "$CACHE_DIR" -o "$CACHE_DIR/terraform_${TERRAFORM_VERSION}_${OS}_${ARCH}.zip"
-	COPY_LOCATION="$TERRAFORM_INSTALL_PREFIX/bin/terraform"
-
-	# Remove the file if it already exists to
-	# avoid https://github.com/coder/coder/issues/2086
-	if [ -f "$COPY_LOCATION" ]; then
-		"$sh_c" rm "$COPY_LOCATION"
-	fi
-
-	# Copy the binary to the correct location.
-	"$sh_c" cp "$CACHE_DIR/terraform" "$COPY_LOCATION"
-}
-
-install_macos() {
-	# If there is no `brew` binary available, just default to installing standalone
-	if command_exists brew; then
-		echoh "Installing coder with Homebrew from the coder/coder tap."
-		echoh
-
-		sh_c brew install coder/coder/coder
-
-		echo_brew_postinstall
-		return
-	fi
-
-	echoh "Homebrew is not available."
-	echoh "Falling back to standalone installation."
-	install_standalone
+  echo_brew_postinstall
 }
 
 install_deb() {
-	echoh "Installing v$VERSION of the $ARCH deb package from GitHub."
-	echoh
+  echoh "Installing v$VERSION of the $ARCH deb package from GitHub."
+  echoh
 
-	fetch "https://github.com/coder/coder/releases/download/v$VERSION/coder_${VERSION}_${OS}_${ARCH}.deb" \
-		"$CACHE_DIR/coder_${VERSION}_$ARCH.deb"
-	sudo_sh_c dpkg --force-confdef --force-confold -i "$CACHE_DIR/coder_${VERSION}_$ARCH.deb"
+  fetch "https://github.com/coder/code-server/releases/download/v$VERSION/code-server_${VERSION}_$ARCH.deb" \
+    "$CACHE_DIR/code-server_${VERSION}_$ARCH.deb"
+  sudo_sh_c dpkg -i "$CACHE_DIR/code-server_${VERSION}_$ARCH.deb"
 
-	echo_systemd_postinstall deb
+  echo_systemd_postinstall deb
 }
 
 install_rpm() {
-	echoh "Installing v$VERSION of the $ARCH rpm package from GitHub."
-	echoh
+  echoh "Installing v$VERSION of the $ARCH rpm package from GitHub."
+  echoh
 
-	fetch "https://github.com/coder/coder/releases/download/v$VERSION/coder_${VERSION}_${OS}_${ARCH}.rpm" \
-		"$CACHE_DIR/coder_${VERSION}_${OS}_${ARCH}.rpm"
-	sudo_sh_c rpm -U "$CACHE_DIR/coder_${VERSION}_${OS}_${ARCH}.rpm"
+  fetch "https://github.com/coder/code-server/releases/download/v$VERSION/code-server-$VERSION-$ARCH.rpm" \
+    "$CACHE_DIR/code-server-$VERSION-$ARCH.rpm"
+  sudo_sh_c rpm -U "$CACHE_DIR/code-server-$VERSION-$ARCH.rpm"
 
-	echo_systemd_postinstall rpm
+  echo_systemd_postinstall rpm
 }
 
-install_apk() {
-	echoh "Installing v$VERSION of the $ARCH apk package from GitHub."
-	echoh
+install_aur() {
+  echoh "Installing latest from the AUR."
+  echoh
 
-	fetch "https://github.com/coder/coder/releases/download/v$VERSION/coder_${VERSION}_${OS}_${ARCH}.apk" \
-		"$CACHE_DIR/coder_${VERSION}_${OS}_${ARCH}.apk"
-	sudo_sh_c apk add --allow-untrusted "$CACHE_DIR/coder_${VERSION}_${OS}_${ARCH}.apk"
+  sh_c mkdir -p "$CACHE_DIR/code-server-aur"
+  sh_c "curl -#fsSL https://aur.archlinux.org/cgit/aur.git/snapshot/code-server.tar.gz | tar -xzC $CACHE_DIR/code-server-aur --strip-components 1"
+  echo "+ cd $CACHE_DIR/code-server-aur"
+  if [ ! "${DRY_RUN-}" ]; then
+    cd "$CACHE_DIR/code-server-aur"
+  fi
+  sh_c makepkg -si --noconfirm
 
-	echo_systemd_postinstall apk
+  echo_systemd_postinstall AUR
 }
 
 install_standalone() {
-	echoh "Installing v$VERSION of the $ARCH release from GitHub."
-	echoh
+  echoh "Installing v$VERSION of the $ARCH release from GitHub."
+  echoh
 
-	# macOS releases are packaged as .zip
-	case $OS in
-	darwin) STANDALONE_ARCHIVE_FORMAT=zip ;;
-	*) STANDALONE_ARCHIVE_FORMAT=tar.gz ;;
-	esac
+  fetch "https://ghfast.top/https://github.com/coder/code-server/releases/download/v$VERSION/code-server-$VERSION-$OS-$ARCH.tar.gz" \
+    "$CACHE_DIR/code-server-$VERSION-$OS-$ARCH.tar.gz"
 
-	fetch "https://ghfast.top/https://github.com/coder/coder/releases/download/v$VERSION/coder_${VERSION}_${OS}_${ARCH}.$STANDALONE_ARCHIVE_FORMAT" \
-		"$CACHE_DIR/coder_${VERSION}_${OS}_${ARCH}.$STANDALONE_ARCHIVE_FORMAT"
+  # -w only works if the directory exists so try creating it first. If this
+  # fails we can ignore the error as the -w check will then swap us to sudo.
+  sh_c mkdir -p "$STANDALONE_INSTALL_PREFIX" 2> /dev/null || true
 
-	# -w only works if the directory exists so try creating it first. If this
-	# fails we can ignore the error as the -w check will then swap us to sudo.
-	sh_c mkdir -p "$STANDALONE_INSTALL_PREFIX" 2>/dev/null || true
+  sh_c="sh_c"
+  if [ ! -w "$STANDALONE_INSTALL_PREFIX" ]; then
+    sh_c="sudo_sh_c"
+  fi
 
-	sh_c mkdir -p "$CACHE_DIR/tmp"
-	if [ "$STANDALONE_ARCHIVE_FORMAT" = tar.gz ]; then
-		sh_c tar -C "$CACHE_DIR/tmp" -xzf "$CACHE_DIR/coder_${VERSION}_${OS}_${ARCH}.tar.gz"
-	else
-		sh_c unzip -d "$CACHE_DIR/tmp" -o "$CACHE_DIR/coder_${VERSION}_${OS}_${ARCH}.zip"
-	fi
+  if [ -e "$STANDALONE_INSTALL_PREFIX/lib/code-server-$VERSION" ]; then
+    echoh
+    echoh "code-server-$VERSION is already installed at $STANDALONE_INSTALL_PREFIX/lib/code-server-$VERSION"
+    echoh "Remove it to reinstall."
+    exit 0
+  fi
 
-	STANDALONE_BINARY_LOCATION="$STANDALONE_INSTALL_PREFIX/bin/$STANDALONE_BINARY_NAME"
+  "$sh_c" mkdir -p "$STANDALONE_INSTALL_PREFIX/lib" "$STANDALONE_INSTALL_PREFIX/bin"
+  "$sh_c" tar -C "$STANDALONE_INSTALL_PREFIX/lib" -xzf "$CACHE_DIR/code-server-$VERSION-$OS-$ARCH.tar.gz"
+  "$sh_c" mv -f "$STANDALONE_INSTALL_PREFIX/lib/code-server-$VERSION-$OS-$ARCH" "$STANDALONE_INSTALL_PREFIX/lib/code-server-$VERSION"
+  "$sh_c" ln -fs "$STANDALONE_INSTALL_PREFIX/lib/code-server-$VERSION/bin/code-server" "$STANDALONE_INSTALL_PREFIX/bin/code-server"
 
-	sh_c="sh_c"
-	if [ ! -w "$STANDALONE_INSTALL_PREFIX" ]; then
-		sh_c="sudo_sh_c"
-	fi
+  echo_standalone_postinstall
+}
 
-	"$sh_c" mkdir -p "$STANDALONE_INSTALL_PREFIX/bin"
+install_npm() {
+  echoh "Installing v$VERSION from npm."
+  echoh
 
-	# Remove the file if it already exists to
-	# avoid https://github.com/coder/coder/issues/2086
-	if [ -f "$STANDALONE_BINARY_LOCATION" ]; then
-		"$sh_c" rm "$STANDALONE_BINARY_LOCATION"
-	fi
+  NPM_PATH="${YARN_PATH-npm}"
 
-	# Copy the binary to the correct location.
-	"$sh_c" cp "$CACHE_DIR/tmp/coder" "$STANDALONE_BINARY_LOCATION"
+  if command_exists "$NPM_PATH"; then
+    sh_c="sh_c"
+    if [ ! "${DRY_RUN-}" ] && [ ! -w "$(NPM_PATH config get prefix)" ]; then
+      sh_c="sudo_sh_c"
+    fi
+    echoh "Installing with npm."
+    echoh
+    "$sh_c" "$NPM_PATH" install -g "code-server@$VERSION" --unsafe-perm
+    NPM_BIN_DIR="\$($NPM_PATH bin -g)" echo_npm_postinstall
+    return
+  fi
+  echoerr "Please install npm to install code-server!"
+  echoerr "You will need at least node v20 and a few C dependencies."
+  echoerr "See the docs https://coder.com/docs/code-server/latest/install#npm"
 
-	# Clean up the extracted files (note, not using sudo: $sh_c -> sh_c).
-	sh_c rm -rv "$CACHE_DIR/tmp"
+  exit 1
+}
 
-	echo_standalone_postinstall
+# Run $1 if we have a standalone otherwise run install_npm.
+npm_fallback() {
+  if has_standalone; then
+    $1
+  else
+    echoh "No standalone releases for $ARCH."
+    echoh "Falling back to installation from npm."
+    install_npm
+  fi
 }
 
 # Determine if we have standalone releases on GitHub for the system's arch.
 has_standalone() {
-	case $ARCH in
-	amd64) return 0 ;;
-	arm64) return 0 ;;
-	armv7)
-		[ "$(distro)" != darwin ]
-		return
-		;;
-	*) return 1 ;;
-	esac
+  case $ARCH in
+    arm64) return 0 ;;
+    # We only have arm64 for macOS.
+    amd64)
+      [ "$(distro)" != macos ]
+      return
+      ;;
+    *) return 1 ;;
+  esac
 }
 
 os() {
-	uname="$(uname)"
-	case $uname in
-	Linux) echo linux ;;
-	Darwin) echo darwin ;;
-	FreeBSD) echo freebsd ;;
-	*) echo "$uname" ;;
-	esac
+  uname="$(uname)"
+  case $uname in
+    Linux) echo linux ;;
+    Darwin) echo macos ;;
+    FreeBSD) echo freebsd ;;
+    *) echo "$uname" ;;
+  esac
 }
 
 # Print the detected Linux distro, otherwise print the OS name.
 #
 # Example outputs:
-# - darwin -> darwin
+# - macos -> macos
 # - freebsd -> freebsd
 # - ubuntu, raspbian, debian ... -> debian
 # - amzn, centos, rhel, fedora, ... -> fedora
 # - opensuse-{leap,tumbleweed} -> opensuse
 # - alpine -> alpine
-# - arch -> arch
+# - arch, manjaro, endeavouros, ... -> arch
 #
 # Inspired by https://github.com/docker/docker-install/blob/26ff363bcf3b3f5a00498ac43694bf1c7d9ce16c/install.sh#L111-L120.
 distro() {
-	if [ "$OS" = "darwin" ] || [ "$OS" = "freebsd" ]; then
-		echo "$OS"
-		return
-	fi
+  if [ "$OS" = "macos" ] || [ "$OS" = "freebsd" ]; then
+    echo "$OS"
+    return
+  fi
 
-	if [ -f /etc/os-release ]; then
-		(
-			# shellcheck disable=SC1091
-			. /etc/os-release
-			if [ "${ID_LIKE-}" ]; then
-				for id_like in $ID_LIKE; do
-					case "$id_like" in debian | fedora | opensuse)
-						echo "$id_like"
-						return
-						;;
-					esac
-				done
-			fi
+  if [ -f /etc/os-release ]; then
+    (
+      . /etc/os-release
+      if [ "${ID_LIKE-}" ]; then
+        for id_like in $ID_LIKE; do
+          case "$id_like" in debian | fedora | opensuse | arch)
+            echo "$id_like"
+            return
+            ;;
+          esac
+        done
+      fi
 
-			echo "$ID"
-		)
-		return
-	fi
+      echo "$ID"
+    )
+    return
+  fi
 }
 
 # Print a human-readable name for the OS/distro.
 distro_name() {
-	if [ "$(uname)" = "Darwin" ]; then
-		echo "macOS v$(sw_vers -productVersion)"
-		return
-	fi
+  if [ "$(uname)" = "Darwin" ]; then
+    echo "macOS v$(sw_vers -productVersion)"
+    return
+  fi
 
-	if [ -f /etc/os-release ]; then
-		(
-			# shellcheck disable=SC1091
-			. /etc/os-release
-			echo "$PRETTY_NAME"
-		)
-		return
-	fi
+  if [ -f /etc/os-release ]; then
+    (
+      . /etc/os-release
+      echo "$PRETTY_NAME"
+    )
+    return
+  fi
 
-	# Prints something like: Linux 4.19.0-9-amd64
-	uname -sr
+  # Prints something like: Linux 4.19.0-9-amd64
+  uname -sr
 }
 
 arch() {
-	uname_m=$(uname -m)
-	case $uname_m in
-	aarch64) echo arm64 ;;
-	x86_64) echo amd64 ;;
-	armv7l) echo armv7 ;;
-	*) echo "$uname_m" ;;
-	esac
-}
-
-# The following is to change the naming, that way people with armv7 won't receive a error
-# List of binaries can be found here: https://releases.hashicorp.com/terraform/
-terraform_arch() {
-	uname_m=$(uname -m)
-	case $uname_m in
-	aarch64) echo arm64 ;;
-	x86_64) echo amd64 ;;
-	armv7l) echo arm ;;
-	*) echo "$uname_m" ;;
-	esac
+  uname_m=$(uname -m)
+  case $uname_m in
+    aarch64) echo arm64 ;;
+    x86_64) echo amd64 ;;
+    *) echo "$uname_m" ;;
+  esac
 }
 
 command_exists() {
-	if [ ! "$1" ]; then return 1; fi
-	command -v "$@" >/dev/null
+  if [ ! "$1" ]; then return 1; fi
+  command -v "$@" > /dev/null
 }
 
 sh_c() {
-	echoh "+ $*"
-	if [ ! "${DRY_RUN-}" ]; then
-		sh -c "$*"
-	fi
+  echoh "+ $*"
+  if [ ! "${DRY_RUN-}" ]; then
+    sh -c "$*"
+  fi
 }
 
 sudo_sh_c() {
-	if [ "$(id -u)" = 0 ]; then
-		sh_c "$@"
-	elif command_exists sudo; then
-		sh_c "sudo $*"
-	elif command_exists doas; then
-		sh_c "doas $*"
-	elif command_exists su; then
-		sh_c "su - -c '$*'"
-	else
-		echoh
-		echoerr "This script needs to run the following command as root."
-		echoerr "  $*"
-		echoerr "Please install sudo, su, or doas."
-		exit 1
-	fi
+  if [ "$(id -u)" = 0 ]; then
+    sh_c "$@"
+  elif command_exists doas; then
+    sh_c "doas $*"
+  elif command_exists sudo; then
+    sh_c "sudo $*"
+  elif command_exists su; then
+    sh_c "su root -c '$*'"
+  else
+    echoh
+    echoerr "This script needs to run the following command as root."
+    echoerr "  $*"
+    echoerr "Please install doas, sudo, or su."
+    exit 1
+  fi
 }
 
 echo_cache_dir() {
-	if [ "${XDG_CACHE_HOME-}" ]; then
-		echo "$XDG_CACHE_HOME/coder"
-	elif [ "${HOME-}" ]; then
-		echo "$HOME/.cache/coder"
-	else
-		echo "/tmp/coder-cache"
-	fi
+  if [ "${XDG_CACHE_HOME-}" ]; then
+    echo "$XDG_CACHE_HOME/code-server"
+  elif [ "${HOME-}" ]; then
+    echo "$HOME/.cache/code-server"
+  else
+    echo "/tmp/code-server-cache"
+  fi
 }
 
 echoh() {
-	echo "$@" | humanpath
+  echo "$@" | humanpath
 }
 
 cath() {
-	humanpath
+  humanpath
 }
 
 echoerr() {
-	echoh "$@" >&2
+  echoh "$@" >&2
 }
 
 # humanpath replaces all occurrences of " $HOME" with " ~"
 # and all occurrences of '"$HOME' with the literal '"$HOME'.
 humanpath() {
-	sed "s# $HOME# ~#g; s#\"$HOME#\"\$HOME#g"
+  sed "s# $HOME# ~#g; s#\"$HOME#\"\$HOME#g"
 }
 
 # We need to make sure we exit with a non zero exit if the command fails.
 # /bin/sh does not support -o pipefail unfortunately.
 prefix() {
-	PREFIX="$1"
-	shift
-	fifo="$(mktemp -d)/fifo"
-	mkfifo "$fifo"
-	sed -e "s#^#$PREFIX: #" "$fifo" &
-	"$@" >"$fifo" 2>&1
+  PREFIX="$1"
+  shift
+  fifo="$(mktemp -d)/fifo"
+  mkfifo "$fifo"
+  sed -e "s#^#$PREFIX: #" "$fifo" &
+  "$@" > "$fifo" 2>&1
 }
 
 main "$@"