#!/usr/bin/env sh

# Determine the platform using 'OS' and 'ARCH'

initPlatform() {

OS=$(uname -s | tr '[:upper:]' '[:lower:]')

ARCH=$(uname -m)

if [ "$OS" = "darwin" ] && [ "$ARCH" = "arm64" ]; then

PLATFORM="darwin_arm64"

elif [ "$OS" = "darwin" ] && [ "$ARCH" = "x86_64" ]; then

PLATFORM="darwin_amd64"

elif [ "$OS" = "linux" ] && [ "$ARCH" = "x86_64" ]; then

PLATFORM="linux_amd64"

elif [ "$OS" = "linux" ] && { [ "$ARCH" = "arm64" ] || [ "$ARCH" = "aarch64" ]; }; then

PLATFORM="linux_arm64"

else

printf "Platform not supported: os=%s arch=%s\n" "$OS" "$ARCH"

exit 1

fi

}

# Create a temporary directory and setup deletion on script exit using the 'EXIT' signal

initTmpDir() {

TMP_DIR=$(mktemp -d)

trap 'rm -rf -- "${TMP_DIR}"' EXIT

cd "$TMP_DIR"

}

# Check all required dependencies, printing messages for each missing one before exiting

checkDependencies() {

MISSING=false

if ! [ -x "$(command -v curl)" ]; then

printf "'curl' could not be found, this script depends on it, please install and try again.\n"

MISSING=true

fi

if ! [ -x "$(command -v unzip)" ]; then

printf "'unzip' could not be found, this script depends on it, please install and try again.\n"

MISSING=true

fi

if ! [ -x "$(command -v git)" ]; then

publishSyftEvent git_missing

printf "'git' could not be found, this script depends on it, please install and try again (see instructions at https://github.com/git-guides/install-git).\n"

MISSING=true

fi

if ! [ -x "$(command -v shasum)" ] && ! [ -x "$(command -v sha256sum)" ]; then

printf "Neither 'shasum' nor 'sha256sum' could be found, this script depends on one of them, please install one of them and try again.\n"

MISSING=true

fi

if [ "$MISSING" = "true" ]; then

exit 1

fi

}

# Verify a checksums file using whichever SHA256 tool is available

sha256Verify() {

if [ -x "$(command -v shasum)" ]; then

shasum --algorithm 256 --ignore-missing --check "$1"

else

sha256sum --ignore-missing --check "$1"

fi

}

# Download the binary and check the integrity using the SHA256 checksum

downloadBinary() {

CDN="cdn.rilldata.com"

LATEST_URL="https://${CDN}/rill/latest.txt"

if [ "${VERSION}" = "latest" ]; then

VERSION=$(curl --silent --show-error "${LATEST_URL}")

fi

BINARY_URL="https://${CDN}/rill/${VERSION}/rill_${PLATFORM}.zip"

CHECKSUM_URL="https://${CDN}/rill/${VERSION}/checksums.txt"

printf "Downloading binary: %s\n" "$BINARY_URL"

if [ "$NON_INTERACTIVE" = "true" ]; then

curl --location --silent --show-error "${BINARY_URL}" --output "rill_${PLATFORM}.zip"

else

curl --location --progress-bar "${BINARY_URL}" --output "rill_${PLATFORM}.zip"

fi

printf "\nDownloading checksum: %s\n" "$CHECKSUM_URL"

if [ "$NON_INTERACTIVE" = "true" ]; then

curl --location --silent --show-error "${CHECKSUM_URL}" --output checksums.txt

else

curl --location --progress-bar "${CHECKSUM_URL}" --output checksums.txt

fi

printf "\nVerifying the SHA256 checksum of the downloaded binary:\n"

sha256Verify checksums.txt

printf "\nUnpacking rill_%s.zip\n" "$PLATFORM"

unzip -q "rill_${PLATFORM}.zip"

}

# Print install options

printInstallOptions() {

printf "\nWhere would you like to install rill? (Default [1])\n\n"

printf "[1] /usr/local/bin/rill [recommended, but requires sudo privileges]\n"

printf "[2] ~/.rill/rill [directory will be created & path configured]\n"

printf "[3] ./rill [download to the current directory]\n\n"

}

# Ask for preferred install option

promptInstallChoice() {

printf "Pick install option: (1/2/3)\n"

read -r ans </dev/tty;

case $ans in

1|"")

INSTALL_DIR="/usr/local/bin"

;;

2)

INSTALL_DIR="$HOME/.rill"

;;

3)

INSTALL_DIR=$(pwd)

;;

*)

printf "\nInvalid option '%s'\n\n" "$ans"

promptInstallChoice

;;

esac

}

# Check conflicting installation and exit with a help message

checkConflictingInstallation() {

if [ -x "$(command -v rill)" ]; then

INSTALLED_RILL="$(command -v rill)"

if [ -x "$(command -v brew)" ] && brew list rilldata/tap/rill >/dev/null 2>&1; then

printf "There is a conflicting version of Rill installed using Brew.\n\n"

printf "To upgrade using Brew, run 'brew upgrade rilldata/tap/rill'.\n\n"

printf "To use this script to install Rill, run 'brew remove rilldata/tap/rill' to remove the conflicting version and try again.\n"

exit 1

elif [ "$INSTALLED_RILL" != "${INSTALL_DIR}/rill" ]; then

printf "There is a conflicting version of Rill installed at '%s'\n\n" "$INSTALLED_RILL"

printf "To use this script to install Rill, remove the conflicting version and try again.\n"

exit 1

fi

fi

}

# Install the binary, using sudo if the directory is not directly writable

installBinary() {

if { [ -d "$INSTALL_DIR" ] && [ -w "$INSTALL_DIR" ]; } || { [ ! -d "$INSTALL_DIR" ] && [ -w "$(dirname "$INSTALL_DIR")" ]; }; then

install -d "$INSTALL_DIR"

install rill "$INSTALL_DIR"

else

printf "\nElevated permissions required to install the Rill binary to: %s/rill\n" "$INSTALL_DIR"

sudo install -d "$INSTALL_DIR"

sudo install rill "$INSTALL_DIR"

fi

cd - > /dev/null

}

# Run the installed binary and print the version

testInstalledBinary() {

RILL_VERSION=$("$INSTALL_DIR"/rill version)

"$INSTALL_DIR"/rill verify-install 1>/dev/null || true

printf "\nInstallation of %s completed!\n" "$RILL_VERSION"

}

# Print 'rill start' help intrcutions

printStartHelp() {

# Resolve how to reference the binary in help text.

if [ "$INSTALL_DIR" = "/usr/local/bin" ] || [ "$INSTALL_DIR" = "$HOME/.rill" ]; then

binary="rill"

elif [ "$INSTALL_DIR" = "$(pwd)" ]; then

binary="./rill"

else

binary="$INSTALL_DIR/rill"

fi

# Print instructions for non-interactive callers.

if [ "$NON_INTERACTIVE" = "true" ]; then

printf "\nTo initialize a new project, run '%s init'. Run '%s -h' for an overview of available commands.\n" "$binary" "$binary"

return

fi

# Safely get bold formatting codes.

boldon=$(tput smso 2>/dev/null) || boldon=""

boldoff=$(tput rmso 2>/dev/null) || boldoff=""

# Print instructions for interactive callers.

if [ "$INSTALL_DIR" = "$HOME/.rill" ]; then

printf "\nTo start a new project in Rill, open a %snew terminal%s and execute the command:\n\n %s%s start my-rill-project%s\n\n" "$boldon" "$boldoff" "$boldon" "$binary" "$boldoff"

else

printf "\nTo start a new project in Rill, execute the command:\n\n %s%s start my-rill-project%s\n\n" "$boldon" "$binary" "$boldoff"

fi

}

# Publish Syft install telemetry event, can be disabled by setting the 'RILL_INSTALL_DISABLE_TELEMETRY' environment variable

publishSyftEvent() {

SYFT_URL=https://event.syftdata.com/log

SYFT_ID=clp76quhs0006l908bux79l4v

if [ -z "$RILL_INSTALL_DISABLE_TELEMETRY" ]; then

curl --silent --show-error --header "Authorization: ${SYFT_ID}" --header "Content-Type: application/json" --data "{\"event_name\":\"$1\"}" "$SYFT_URL" > /dev/null 2>&1 || true

fi

}

# Add the Rill binary to the PATH via configuration of the shells we detect on the system

addPathConfigEntries() {

PATH_CONFIG_LINE="export PATH=\$HOME/.rill:\$PATH # Added by Rill install"

if [ "$INSTALL_DIR" = "$HOME/.rill" ]; then

for f in "$HOME/.bashrc" "$HOME/.zshrc"; do

if [ -f "$f" ]; then

if ! grep -Fxq "$PATH_CONFIG_LINE" "$f"; then

printf "\nWould you like to add 'rill' to your PATH by adding an entry in '%s'? (Y/n)\n" "$f"

read -r ans </dev/tty;

case $ans in

n)

;;

*)

printf "\n%s\n" "$PATH_CONFIG_LINE" >> "$f"

;;

esac

fi

fi

done

fi

}

# Remove PATH configurations, we have to do handle this slightly different based on OS because of platform variations in 'sed' behaviour

removePathConfigEntries() {

for f in "$HOME/.bashrc" "$HOME/.zshrc"; do

if [ -f "$f" ]; then

if [ "$OS" = "darwin" ]; then

sed -i "" -e '/# Added by Rill install/d' "$f"

elif [ "$OS" = "linux" ]; then

sed -i -e '/# Added by Rill install/d' "$f"

fi

fi

done

}

# Check if we can install to INSTALL_DIR

installDirIsWritable() {

# Check if it is directly writable

if [ -d "$INSTALL_DIR" ] && [ -w "$INSTALL_DIR" ]; then

return 0

# If it doesn't exist yet, check if the parent directory is writable

elif [ ! -d "$INSTALL_DIR" ] && [ -w "$(dirname "$INSTALL_DIR")" ]; then

return 0

fi

# Lastly, we also consider it writable if we have passwordless sudo (since then we don't need to prompt/error due to lack of permissions)

sudo -n true 2>/dev/null

}

# Resolve the install directory

resolveInstallDir() {

# Detect previous installation

if [ -x "$(command -v rill)" ] && [ -z "${INSTALL_DIR}" ]; then

INSTALLED_RILL="$(command -v rill)"

if [ "$INSTALLED_RILL" = "/usr/local/bin/rill" ]; then

INSTALL_DIR="/usr/local/bin"

elif [ "$INSTALLED_RILL" = "$HOME/.rill/rill" ]; then

INSTALL_DIR="$HOME/.rill"

fi

fi

# Handle non-interactive scenarios where prompt or sudo are not possible

if [ "$NON_INTERACTIVE" = "true" ]; then

# Default to /usr/local/bin if not set.

if [ -z "$INSTALL_DIR" ]; then

INSTALL_DIR="/usr/local/bin"

fi

# Handle if the install directory is not writable and we can't prompt due to non-interactive mode.

if ! installDirIsWritable; then

# Error if the install directory was set explicitly.

if [ "$INSTALL_DIR_EXPLICIT" = "true" ]; then

printf "Install directory '%s' requires elevated permissions, which are not available in non-interactive mode.\n" "$INSTALL_DIR"

exit 1

fi

# Fall back to the current directory otherwise (which we assume is writable).

INSTALL_DIR=$(pwd)

fi

return

fi

# If there is a previous or explicit installation path, we're done

if [ -n "${INSTALL_DIR}" ]; then

return

fi

# Prompt for install directory if there is no previous installation and we are in an interactive shell

printInstallOptions

promptInstallChoice

checkConflictingInstallation # Only check for conflicts in interactive, non-explicit scenarios

}

# Install Rill on the system

installRill() {

if [ "$NON_INTERACTIVE" != "true" ]; then

publishSyftEvent install

fi

checkDependencies

initPlatform

resolveInstallDir

initTmpDir

downloadBinary

installBinary

testInstalledBinary

if [ "$NON_INTERACTIVE" != "true" ]; then

addPathConfigEntries

publishSyftEvent installed

fi

printStartHelp

}

# Uninstall Rill from the system, this function is aware of both the privileged and unprivileged install methods

uninstallRill() {

if ! [ -x "$(command -v sed)" ]; then

printf "'sed' could not be found, this script depends on it, please install and try again.\n"

exit 1

fi

initPlatform

if [ -f "/usr/local/bin/rill" ]

then

printf "\nElevated permissions required to uninstall the Rill binary from: '/usr/local/bin/rill'\n"

sudo rm /usr/local/bin/rill

fi

rm -f "$HOME/.rill/rill"

removePathConfigEntries

printf "Uninstall of Rill completed\n"

}

set -e

# Default values

INSTALL_DIR_EXPLICIT=false

# Detect non-interactive environments (CI, Docker, agents, subprocesses).

# When the script is piped (e.g. "curl | sh"), stdin is not a terminal, but a human may still be present.

# We check /dev/tty to distinguish: in a real terminal, /dev/tty is a terminal device; in CI/Docker/agents, it either doesn't exist or isn't a real terminal.

if [ -t 0 ]; then

# Stdin is a terminal; definitely interactive.

NON_INTERACTIVE=${NON_INTERACTIVE:-false}

elif [ -e /dev/tty ] && sh -c 'exec 3</dev/tty && test -t 3' 2>/dev/null; then

# Stdin is piped but /dev/tty is a real terminal; likely "curl | sh" in an interactive session.

NON_INTERACTIVE=${NON_INTERACTIVE:-false}

else

# Stdin is not a terminal and /dev/tty is not available; default to non-interactive.

NON_INTERACTIVE=${NON_INTERACTIVE:-true}

fi

NON_INTERACTIVE=${NON_INTERACTIVE:-false}

# Parse input flag

case $1 in

--uninstall)

uninstallRill

;;

--nightly)

VERSION=nightly

installRill

;;

--version)

VERSION=${2:-latest}

installRill

;;

--non-interactive)

if [ -n "$2" ]; then

INSTALL_DIR="$2"

INSTALL_DIR_EXPLICIT=true

fi

VERSION=${3:-latest}

NON_INTERACTIVE=true

installRill

;;

*)

VERSION=latest

installRill

;;

esac