rogee/go-sip
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
go-sip/install.sh
T

1729 lines
50 KiB
Bash
Raw Permalink Blame History

#!/bin/sh
PI_PACKAGE="@earendil-works/pi-coding-agent"
PI_CMD="pi"
PI_INSTALLER_API_BASE="${PI_INSTALLER_API_BASE:-https://pi.dev/api/installer/releases}"
PI_MANAGED_INSTALL_MARKER="managed-install.json"
# Pi publishes npm-shrinkwrap.json, so the explicit installer/reinstaller can
# bypass npm's release-age gate without reopening transitive dependency ranges.
PI_NPM_INSTALL_MIN_AGE_ARG="--min-release-age=4"
PI_ESC=$(printf '\033')
PI_CR=$(printf '\r')
PI_ETX=$(printf '\003')
readonly PI_PACKAGE PI_CMD PI_INSTALLER_API_BASE PI_MANAGED_INSTALL_MARKER PI_NPM_INSTALL_MIN_AGE_ARG PI_ESC PI_CR PI_ETX
pi_installer_main() {
set -eu
check_file="${TMPDIR:-/tmp}/pi-installer-checks.$$"
run_preflight_checks >"$check_file" &
check_pid=$!
pi_logo_animation
if wait "$check_pid"; then
check_status=0
else
check_status=$?
fi
printf '\033[1m Pi Installer\033[0m\n\033[2m There are many agent harnesses but this one is yours\033[0m\n\n'
if [ "$check_status" -eq 0 ]; then
cat "$check_file"
fi
rm -f "$check_file"
if [ "$check_status" -ne 0 ]; then
if ! install_node_npm_interactive; then
exit "$check_status"
fi
check_file="${TMPDIR:-/tmp}/pi-installer-checks.$$"
if run_preflight_checks >"$check_file"; then
check_status=0
else
check_status=$?
fi
cat "$check_file"
rm -f "$check_file"
if [ "$check_status" -ne 0 ]; then
exit "$check_status"
fi
fi
PI_EXISTING_PATH=$(command -v "$PI_CMD" 2>/dev/null || true)
export PI_EXISTING_PATH
if pi_managed_install_enabled; then
if ! ensure_managed_install_supported; then
exit 1
fi
PI_MANAGED_INSTALL_DIR=$(select_managed_install_dir "$PI_EXISTING_PATH")
PI_MANAGED_AGENT_DIR=${PI_MANAGED_INSTALL_DIR%/*}
PI_MANAGED_BIN_DIR=$(select_managed_path_bin_dir "$PI_MANAGED_AGENT_DIR" "$PI_MANAGED_INSTALL_DIR" "$PI_EXISTING_PATH")
PI_NPM_INSTALL_PREFIX=
export PI_MANAGED_INSTALL_DIR PI_MANAGED_AGENT_DIR PI_MANAGED_BIN_DIR
else
if ! PI_NPM_INSTALL_PREFIX=$(select_npm_install_prefix); then
exit 1
fi
fi
export PI_NPM_INSTALL_PREFIX
if pi_managed_install_enabled && managed_install_root_for_command "$PI_EXISTING_PATH" >/dev/null 2>&1; then
PI_NPM_UNINSTALL_PREFIX=
else
PI_NPM_UNINSTALL_PREFIX=$(select_npm_uninstall_prefix "$PI_EXISTING_PATH")
fi
export PI_NPM_UNINSTALL_PREFIX
choose_pi_action "$PI_EXISTING_PATH"
case "$PI_INSTALL_ACTION" in
uninstall)
uninstall_pi_package
printf '\nPi was uninstalled successfully.\n'
exit 0
;;
none)
exit 0
;;
esac
install_pi_package
if [ "$PI_INSTALL_ACTION" = reinstall ]; then
printf '\nPi was reinstalled successfully.\n'
else
printf '\nPi was installed successfully.\n'
fi
if pi_managed_install_enabled; then
printf '\nUpdate Pi later with: pi update\n'
fi
if installed_pi_is_first_on_path; then
printf '\nRun it with: pi\n'
if [ "${PI_NODE_INSTALLED_STANDALONE:-0}" = 1 ]; then
printf 'If pi is not found in your shell yet, add this to your shell profile:\n\n'
printf ' export PATH="%s:$PATH"\n' "$PI_STANDALONE_NODE_BIN"
fi
else
print_pi_not_on_path_message
fi
}
run_preflight_checks() {
status=0
if command -v node >/dev/null 2>&1; then
node_version=$(node --version)
if ! node -e 'const [maj,min,patch] = process.versions.node.split(".").map(Number); process.exit(maj > 22 || (maj === 22 && (min > 19 || (min === 19 && patch >= 0))) ? 0 : 1)' >/dev/null; then
printf 'error: Pi requires Node.js 22.19.0 or newer. Found %s.\n' "$node_version"
status=1
fi
else
printf 'error: Node.js 22.19.0 or newer is required to install Pi.\n'
status=1
fi
if ! command -v npm >/dev/null 2>&1; then
printf 'error: npm is required to install Pi.\n'
status=1
fi
if [ "$status" -ne 0 ]; then
printf '\n'
fi
return "$status"
}
install_node_npm_interactive() {
method=$(detect_node_install_method)
case "$method" in
homebrew) label="Homebrew" ;;
apt) label="apt" ;;
apk) label="apk" ;;
standalone) label="standalone Node.js" ;;
esac
if ! ( : <>/dev/tty ) 2>/dev/null; then
printf 'No terminal detected; install Node.js 22.19.0 or newer and npm, then run this installer again.\n'
return 1
fi
exec 3<>/dev/tty
printf 'Pi needs Node.js 22.19.0 or newer and npm. Install them now with %s? [Y/n] ' "$label" >&3
if ! IFS= read -r answer <&3; then
answer=
fi
exec 3>&-
case "$answer" in
n|N|no|NO) printf '\nInstall Node.js 22.19.0 or newer and npm, then run this installer again.\n'; return 1 ;;
*) ;;
esac
install_node_npm "$method" "$label"
}
detect_node_install_method() {
case "$(uname -s)" in
Darwin)
if command -v brew >/dev/null 2>&1; then
printf 'homebrew'
else
printf 'standalone'
fi
;;
Linux)
if command -v apt-cache >/dev/null 2>&1 && command -v apt-get >/dev/null 2>&1 && apt_node_candidate_is_new_enough; then
printf 'apt'
elif command -v apk >/dev/null 2>&1 && apk_node_candidate_is_new_enough; then
printf 'apk'
else
printf 'standalone'
fi
;;
*)
printf 'standalone'
;;
esac
}
apt_node_candidate_is_new_enough() {
version=$(apt-cache policy nodejs 2>/dev/null | awk '/Candidate:/ { print $2; exit }')
[ -n "$version" ] && [ "$version" != "(none)" ] && node_version_string_is_new_enough "$version"
}
apk_node_candidate_is_new_enough() {
version=$(apk search -x nodejs 2>/dev/null | awk -F- '/^nodejs-/ { print $2; exit }')
[ -n "$version" ] && node_version_string_is_new_enough "$version"
}
node_version_string_is_new_enough() {
version="${1#v}"
case "$version" in
[0-9]*) ;;
*) return 1 ;;
esac
version="${version%%[!0-9.]*}"
version_ifs=${IFS- }
IFS=.
set -- $version
IFS=$version_ifs
major="${1:-}"
minor="${2:-0}"
patch="${3:-0}"
case "$major" in ''|*[!0-9]*) return 1 ;; esac
case "$minor" in ''|*[!0-9]*) minor=0 ;; esac
case "$patch" in ''|*[!0-9]*) patch=0 ;; esac
[ "$major" -gt 22 ] && return 0
[ "$major" -eq 22 ] && [ "$minor" -gt 19 ] && return 0
[ "$major" -eq 22 ] && [ "$minor" -eq 19 ] && [ "$patch" -ge 0 ] && return 0
return 1
}
install_node_npm() {
method="$1"; label="$2"
if [ -t 1 ] && [ "${TERM:-}" != "dumb" ]; then
install_node_npm_with_progress "$method" "$label"
else
printf '\nInstalling Node.js and npm with %s...\n\n' "$label"
run_node_install_method "$method"
printf '\nNode.js and npm are installed.\n'
fi
if [ "$method" = standalone ]; then
load_standalone_node
PI_NODE_INSTALLED_STANDALONE=1
fi
hash -r
printf '\n'
}
install_node_npm_with_progress() {
method="$1"; label="$2"
log_file="${TMPDIR:-/tmp}/pi-installer-node.$$"
rm -f "$log_file"
: >"$log_file"
run_node_install_method "$method" >"$log_file" 2>&1 &
install_pid=$!
printf '\033[?25l'
animate_node_install "$log_file" "$label" &
progress_pid=$!
trap 'kill "$install_pid" 2>/dev/null || true; finish_install_progress "$progress_pid"; exit 130' INT TERM
if wait "$install_pid"; then
status=0
else
status=$?
fi
finish_install_progress "$progress_pid"
trap - INT TERM
if [ "$status" -ne 0 ]; then
printf '\033[31mNode.js installation failed.\033[0m\n\n'
cat "$log_file"
rm -f "$log_file"
return "$status"
fi
rm -f "$log_file"
if terminal_supports_unicode; then
printf ' \033[32m✓\033[0m Node.js and npm install complete\n'
else
printf ' \033[32mok\033[0m Node.js and npm install complete\n'
fi
}
run_node_install_method() {
case "$1" in
homebrew) install_node_with_homebrew ;;
apt) install_node_with_apt ;;
apk) install_node_with_apk ;;
standalone) install_node_standalone ;;
esac
}
install_node_with_homebrew() {
if brew list node >/dev/null 2>&1; then
brew upgrade node
else
brew install node
fi
}
install_node_with_apt() {
print_sudo_note
if [ "${EUID:-$(id -u)}" -eq 0 ]; then
apt-get update
apt-get install -y nodejs npm
else
sudo sh -c 'apt-get update && apt-get install -y nodejs npm'
fi
}
install_node_with_apk() {
print_sudo_note
run_with_sudo apk add --update-cache nodejs npm
}
install_node_standalone() {
node_platform=$(detect_node_binary_platform) || {
printf 'Unsupported operating system for automatic Node.js install: %s\n' "$(uname -s)"
return 1
}
node_arch=$(detect_node_binary_arch) || {
printf 'Unsupported CPU architecture for automatic Node.js install: %s\n' "$(uname -m)"
return 1
}
node_dist_base="https://nodejs.org/dist/latest-v22.x"
node_base_dir=$(node_standalone_base_dir)
node_tmp_dir="${TMPDIR:-/tmp}/pi-node.$$"
rm -rf "$node_tmp_dir"
mkdir -p "$node_tmp_dir" "$node_base_dir"
printf 'Resolving Node.js binary for %s-%s\n' "$node_platform" "$node_arch"
curl -fsSL "$node_dist_base/SHASUMS256.txt" -o "$node_tmp_dir/SHASUMS256.txt"
node_file=$(awk -v suffix="-$node_platform-$node_arch.tar.xz" '
index($2, "node-v") == 1 && length($2) >= length(suffix) && substr($2, length($2) - length(suffix) + 1) == suffix { print $2; exit }
' "$node_tmp_dir/SHASUMS256.txt")
if [ -z "$node_file" ]; then
printf 'No Node.js binary is available for %s-%s.\n' "$node_platform" "$node_arch"
rm -rf "$node_tmp_dir"
return 1
fi
printf 'Downloading Node.js %s\n' "${node_file%.tar.xz}"
curl -fsSL "$node_dist_base/$node_file" -o "$node_tmp_dir/$node_file"
verify_node_standalone_download "$node_tmp_dir" "$node_file"
ensure_node_standalone_extract_tools "$node_platform"
node_dir="$node_base_dir/${node_file%.tar.xz}"
rm -rf "$node_dir"
printf 'Extracting Node.js to %s\n' "$node_dir"
tar -xf "$node_tmp_dir/$node_file" -C "$node_base_dir"
rm -f "$node_base_dir/current"
ln -s "$node_dir" "$node_base_dir/current"
rm -rf "$node_tmp_dir"
printf 'Node.js installed at %s\n' "$node_dir"
}
verify_node_standalone_download() {
checksum_dir="$1"
checksum_file_name="$2"
awk -v file="$checksum_file_name" '$2 == file { print }' "$checksum_dir/SHASUMS256.txt" > "$checksum_dir/SHASUMS256.selected"
if command -v sha256sum >/dev/null 2>&1; then
printf 'Verifying Node.js download\n'
(cd "$checksum_dir" && sha256sum -c SHASUMS256.selected)
elif command -v shasum >/dev/null 2>&1; then
printf 'Verifying Node.js download\n'
(cd "$checksum_dir" && shasum -a 256 -c SHASUMS256.selected)
fi
}
ensure_node_standalone_extract_tools() {
extract_platform="$1"
if [ "$extract_platform" = linux ] && ! command -v xz >/dev/null 2>&1; then
printf 'Installing xz-utils for Node.js archive extraction\n'
print_sudo_note
if command -v apt-get >/dev/null 2>&1; then
run_with_sudo apt-get update
run_with_sudo apt-get install -y xz-utils
elif command -v apk >/dev/null 2>&1; then
run_with_sudo apk add --update-cache xz
else
printf 'xz is required to extract Node.js. Install xz and run this installer again.\n'
return 1
fi
fi
}
load_standalone_node() {
PI_STANDALONE_NODE_BIN="$(node_standalone_base_dir)/current/bin"
PATH="$PI_STANDALONE_NODE_BIN:$PATH"
export PI_STANDALONE_NODE_BIN PATH
}
node_standalone_base_dir() {
if [ -n "${XDG_DATA_HOME:-}" ]; then
printf '%s/pi-node' "$XDG_DATA_HOME"
else
printf '%s/.local/share/pi-node' "$HOME"
fi
}
detect_node_binary_platform() {
case "$(uname -s)" in
Darwin) printf 'darwin' ;;
Linux) printf 'linux' ;;
*) return 1 ;;
esac
}
detect_node_binary_arch() {
case "$(uname -m)" in
x86_64|amd64) printf 'x64' ;;
arm64|aarch64) printf 'arm64' ;;
armv7l) printf 'armv7l' ;;
ppc64le) printf 'ppc64le' ;;
s390x) printf 's390x' ;;
*) return 1 ;;
esac
}
print_sudo_note() {
if [ "${EUID:-$(id -u)}" -ne 0 ]; then
printf 'This may ask for your sudo password.\n\n'
fi
}
run_with_sudo() {
if [ "${EUID:-$(id -u)}" -eq 0 ]; then
"$@"
else
sudo "$@"
fi
}
select_npm_install_prefix() {
npm_prefix=$(npm_global_prefix)
if [ -n "$npm_prefix" ] && npm_prefix_supports_global_install "$npm_prefix"; then
return 0
fi
if existing_global_pi_blocks_user_local_install "$npm_prefix"; then
print_existing_global_pi_not_writable_message "$npm_prefix"
return 1
fi
printf '%s/.local' "$HOME"
}
select_npm_uninstall_prefix() {
existing_pi_path="$1"
[ -n "$existing_pi_path" ] || return 0
npm_prefix=$(npm_global_prefix)
if [ -n "$npm_prefix" ] && [ "$existing_pi_path" = "$npm_prefix/bin/$PI_CMD" ]; then
return 0
fi
if [ -n "${PI_NPM_INSTALL_PREFIX:-}" ] && [ "$existing_pi_path" = "$PI_NPM_INSTALL_PREFIX/bin/$PI_CMD" ]; then
printf '%s' "$PI_NPM_INSTALL_PREFIX"
return 0
fi
pi_bin_suffix="/bin/$PI_CMD"
case "$existing_pi_path" in
*"$pi_bin_suffix") printf '%s' "${existing_pi_path%$pi_bin_suffix}" ;;
esac
}
npm_global_prefix() {
npm prefix -g 2>/dev/null || npm config get prefix 2>/dev/null
}
npm_prefix_supports_global_install() {
prefix="$1"
path_is_writable_or_creatable "$prefix/lib/node_modules" && path_is_writable_or_creatable "$prefix/bin"
}
existing_global_pi_blocks_user_local_install() {
npm_prefix="$1"
[ -n "$npm_prefix" ] || return 1
[ -e "$npm_prefix/bin/$PI_CMD" ]
}
print_existing_global_pi_not_writable_message() {
npm_prefix="$1"
existing_pi_path="$npm_prefix/bin/$PI_CMD"
printf "npm's global directory is not writable: %s\n" "$npm_prefix" >&2
printf 'Pi is already installed at: %s\n\n' "$existing_pi_path" >&2
printf 'Installing another copy under %s/.local could leave your shell using the old global pi, so this installer stopped.\n\n' "$HOME" >&2
printf 'Update or remove the existing global install first. If it was installed with npm, you can run:\n\n' >&2
printf ' sudo npm install -g --ignore-scripts %s %s\n\n' "$PI_NPM_INSTALL_MIN_AGE_ARG" "$PI_PACKAGE" >&2
printf 'or uninstall it first with:\n\n' >&2
printf ' sudo npm uninstall -g %s\n\n' "$PI_PACKAGE" >&2
printf 'Then run this installer again.\n' >&2
}
path_is_writable_or_creatable() {
check_path="$1"
while [ ! -e "$check_path" ]; do
parent=${check_path%/*}
if [ -z "$parent" ] || [ "$parent" = "$check_path" ]; then
return 1
fi
check_path="$parent"
done
[ -d "$check_path" ] && [ -w "$check_path" ]
}
pi_install_bin_dir() {
if pi_managed_install_enabled; then
printf '%s' "$PI_MANAGED_BIN_DIR"
elif [ -n "${PI_NPM_INSTALL_PREFIX:-}" ]; then
printf '%s/bin' "$PI_NPM_INSTALL_PREFIX"
else
npm_prefix=$(npm_global_prefix)
if [ -n "$npm_prefix" ]; then
printf '%s/bin' "$npm_prefix"
fi
fi
}
pi_installed_path() {
pi_bin_dir=$(pi_install_bin_dir)
if [ -n "$pi_bin_dir" ]; then
printf '%s/%s' "$pi_bin_dir" "$PI_CMD"
fi
}
installed_pi_is_first_on_path() {
installed_pi_path=$(pi_installed_path)
[ -n "$installed_pi_path" ] || return 1
active_pi_path=$(command -v "$PI_CMD" 2>/dev/null) || return 1
[ "$active_pi_path" = "$installed_pi_path" ]
}
shell_config_file() {
current_shell=$(basename "${SHELL:-sh}")
case "$current_shell" in
fish) printf '%s/.config/fish/config.fish' "$HOME" ;;
zsh) printf '%s/.zshrc' "${ZDOTDIR:-$HOME}" ;;
bash)
if [ -f "$HOME/.bashrc" ]; then
printf '%s/.bashrc' "$HOME"
else
printf '%s/.profile' "$HOME"
fi
;;
*) printf '%s/.profile' "$HOME" ;;
esac
}
path_update_command() {
bin_dir="$1"
current_shell=$(basename "${SHELL:-sh}")
if [ "$bin_dir" = "$HOME/.local/bin" ]; then
bin_expr='$HOME/.local/bin'
else
bin_expr="$bin_dir"
fi
case "$current_shell" in
fish) printf 'fish_add_path "%s"' "$bin_expr" ;;
*) printf 'export PATH="%s:$PATH"' "$bin_expr" ;;
esac
}
config_file_mentions_path() {
config_file="$1"
command="$2"
[ -f "$config_file" ] || return 1
grep -Fxq "$command" "$config_file"
}
prompt_add_path_to_profile() {
bin_dir="$1"
if ! ( : <>/dev/tty ) 2>/dev/null; then
return 1
fi
config_file=$(shell_config_file)
command=$(path_update_command "$bin_dir")
if config_file_mentions_path "$config_file" "$command"; then
printf 'A PATH update for %s already exists in %s.\n' "$bin_dir" "$config_file"
return 0
fi
exec 3<>/dev/tty
printf 'Add %s to your PATH in %s now? [Y/n] ' "$bin_dir" "$config_file" >&3
if ! IFS= read -r answer <&3; then
answer=
fi
exec 3>&-
case "$answer" in
n|N|no|NO) return 1 ;;
*) ;;
esac
mkdir -p "${config_file%/*}"
touch "$config_file"
printf '\n# Pi\n%s\n' "$command" >> "$config_file"
printf 'Added %s to %s.\n' "$bin_dir" "$config_file"
}
print_pi_not_on_path_message() {
pi_bin_dir=$(pi_install_bin_dir)
active_pi_path=$(command -v "$PI_CMD" 2>/dev/null || true)
printf 'Pi was installed, but your shell is not using that install yet.\n'
if [ -n "$active_pi_path" ]; then
printf 'Your shell currently resolves pi to: %s\n' "$active_pi_path"
fi
if [ -n "$pi_bin_dir" ]; then
prompt_add_path_to_profile "$pi_bin_dir" || true
command=$(path_update_command "$pi_bin_dir")
printf 'Restart your shell or run:\n\n'
printf ' %s\n\n' "$command"
printf 'Then run: pi\n'
else
printf "Check npm's global prefix with:\n\n"
printf ' npm prefix -g\n\n'
printf 'Then add its bin directory to your shell PATH.\n'
fi
}
choose_pi_action() {
existing_pi_path="$1"
if ! ( : <>/dev/tty ) 2>/dev/null; then
print_pi_action_menu "$existing_pi_path"
printf 'No terminal detected; continuing without confirmation.\n'
if [ -n "$existing_pi_path" ]; then
PI_INSTALL_ACTION=reinstall
else
PI_INSTALL_ACTION=install
fi
print_pi_action_selection "$PI_INSTALL_ACTION"
return 0
fi
exec 3<>/dev/tty
trap 'exec 3>&-; trap - INT TERM; exit 130' INT TERM
print_pi_action_menu "$existing_pi_path" >&3
while :; do
key=$(read_tty_key)
case "$key" in
""|" "|"$PI_CR")
if [ -n "$existing_pi_path" ]; then
PI_INSTALL_ACTION=reinstall
else
PI_INSTALL_ACTION=install
fi
break
;;
y|Y)
if [ -n "$existing_pi_path" ]; then
PI_INSTALL_ACTION=reinstall
else
PI_INSTALL_ACTION=install
fi
break
;;
u|U)
if [ -n "$existing_pi_path" ]; then
PI_INSTALL_ACTION=uninstall
break
fi
;;
"$PI_ETX")
exit 130
;;
n|N|"$PI_ESC")
PI_INSTALL_ACTION=none
break
;;
esac
printf 'Please choose one of the listed keys.\n' >&3
done
print_pi_action_selection "$PI_INSTALL_ACTION" >&3
exec 3>&-
trap - INT TERM
}
print_pi_action_menu() {
existing_pi_path="$1"
reset=
dim=
bold=
cyan=
green=
red=
if [ -t 1 ] && [ "${TERM:-}" != "dumb" ]; then
reset="${PI_ESC}[0m"
dim="${PI_ESC}[2m"
bold="${PI_ESC}[1m"
cyan="${PI_ESC}[36m"
green="${PI_ESC}[32m"
red="${PI_ESC}[31m"
fi
if [ -n "$existing_pi_path" ]; then
printf '%sPi is already installed at:%s\n\n' "$bold" "$reset"
printf ' %s\n\n' "$existing_pi_path"
fi
if [ -n "${PI_NPM_INSTALL_PREFIX:-}" ]; then
printf "npm's global directory is not writable; Pi will be installed under %s.\n\n" "$PI_NPM_INSTALL_PREFIX"
fi
if pi_managed_install_enabled; then
if [ -n "$existing_pi_path" ]; then
printf '%sReinstallation:%s\n\n ' "$bold" "$reset"
else
printf '%sInstallation:%s\n\n ' "$bold" "$reset"
fi
elif [ -n "$existing_pi_path" ]; then
printf '%sReinstall command:%s\n\n ' "$bold" "$reset"
else
printf '%sInstall command:%s\n\n ' "$bold" "$reset"
fi
print_pi_install_command
printf '\n\n'
printf '%sChoose an action:%s\n\n' "$bold" "$reset"
if [ -n "$existing_pi_path" ]; then
printf ' %s%-4s%s %sReinstall Pi%s %s(default)%s\n' "$cyan" 'y' "$reset" "$green" "$reset" "$dim" "$reset"
printf ' %s%-4s%s %sUninstall Pi%s\n' "$cyan" 'u' "$reset" "$red" "$reset"
else
printf ' %s%-4s%s %sInstall Pi%s %s(default)%s\n' "$cyan" 'y' "$reset" "$green" "$reset" "$dim" "$reset"
fi
printf ' %s%-4s%s %sDo nothing%s\n' "$cyan" 'n' "$reset" "$dim" "$reset"
}
print_pi_action_selection() {
case "$1" in
install) message="Will install Pi." ;;
reinstall) message="Will reinstall Pi." ;;
uninstall) message="Will uninstall Pi." ;;
none) message="Chose to do nothing. Exiting." ;;
esac
printf '\n%s\n\n' "$message"
}
restore_tty_state() {
tty_state="$1"
[ -n "$tty_state" ] || return 0
stty "$tty_state" < /dev/tty 2>/dev/null || true
}
read_tty_key() {
old_tty_state=$(stty -g < /dev/tty 2>/dev/null || true)
trap 'restore_tty_state "$old_tty_state"; trap - INT TERM; exit 130' INT TERM
stty -icanon -echo min 1 time 0 < /dev/tty 2>/dev/null || true
if ! key=$(dd bs=1 count=1 2>/dev/null < /dev/tty); then
key=
fi
restore_tty_state "$old_tty_state"
trap - INT TERM
printf '%s' "$key"
}
print_pi_install_command() {
if pi_managed_install_enabled; then
printf 'Using experimental self managed installation\n Pi will install to %s/%s' "$PI_MANAGED_BIN_DIR" "$PI_CMD"
elif [ -n "${PI_NPM_INSTALL_PREFIX:-}" ]; then
printf 'npm install -g --ignore-scripts %s --prefix %s %s' "$PI_NPM_INSTALL_MIN_AGE_ARG" "$PI_NPM_INSTALL_PREFIX" "$PI_PACKAGE"
else
printf 'npm install -g --ignore-scripts %s %s' "$PI_NPM_INSTALL_MIN_AGE_ARG" "$PI_PACKAGE"
fi
}
pi_managed_install_enabled() {
[ "${PI_EXPERIMENTAL:-}" = 1 ]
}
ensure_managed_install_supported() {
case "$(uname -s)" in
Darwin|Linux) return 0 ;;
*)
printf 'Experimental managed Pi installs currently support macOS and Linux only.\n' >&2
return 1
;;
esac
}
managed_install_marker_is_valid() {
managed_root="$1"
marker_path="$managed_root/$PI_MANAGED_INSTALL_MARKER"
[ -f "$marker_path" ] || return 1
node - "$marker_path" <<'NODE' >/dev/null 2>&1
const fs = require("node:fs");
const marker = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));
if (
marker.kind !== "pi-managed-install" ||
marker.schemaVersion !== 1 ||
marker.layout !== "releases-v1"
) {
process.exit(1);
}
NODE
}
managed_install_root_for_command() {
managed_command_path="$1"
[ -n "$managed_command_path" ] || return 1
[ "${managed_command_path##*/}" = "$PI_CMD" ] || return 1
managed_candidate=${managed_command_path%/*}
if managed_install_marker_is_valid "$managed_candidate"; then
printf '%s' "$managed_candidate"
return 0
fi
if ! managed_resolved_command=$(node - "$managed_command_path" <<'NODE'
const fs = require("node:fs");
const path = require("node:path");
let resolved = path.resolve(process.argv[2]);
while (fs.lstatSync(resolved).isSymbolicLink()) {
const target = fs.readlinkSync(resolved);
resolved = path.resolve(path.dirname(resolved), target);
}
console.log(resolved);
NODE
); then
return 1
fi
[ "${managed_resolved_command##*/}" = "$PI_CMD" ] || return 1
managed_resolved_bin=${managed_resolved_command%/*}
[ "${managed_resolved_bin##*/}" = bin ] || return 1
managed_candidate=${managed_resolved_bin%/*}/install
if managed_install_marker_is_valid "$managed_candidate"; then
printf '%s' "$managed_candidate"
return 0
fi
return 1
}
select_managed_install_dir() {
existing_pi_path="$1"
if [ -n "${PI_MANAGED_INSTALL_ROOT:-}" ]; then
managed_candidate=${PI_MANAGED_INSTALL_ROOT%/}
if managed_install_marker_is_valid "$managed_candidate"; then
printf '%s' "$managed_candidate"
return 0
fi
fi
if managed_candidate=$(managed_install_root_for_command "$existing_pi_path"); then
printf '%s' "$managed_candidate"
return 0
fi
managed_agent_dir=${PI_CODING_AGENT_DIR:-$HOME/.pi/agent}
printf '%s/install' "${managed_agent_dir%/}"
}
select_managed_path_bin_dir() {
managed_agent_dir="$1"
managed_root="$2"
existing_pi_path="$3"
if [ -n "$existing_pi_path" ] && managed_existing_root=$(managed_install_root_for_command "$existing_pi_path") && [ "$managed_existing_root" = "$managed_root" ]; then
managed_existing_bin=${existing_pi_path%/*}
if [ "$managed_existing_bin" != "$managed_root" ]; then
printf '%s' "$managed_existing_bin"
return 0
fi
fi
managed_path_ifs=${IFS- }
IFS=:
for managed_path_dir in ${PATH:-}; do
IFS=$managed_path_ifs
managed_path_dir=${managed_path_dir%/}
case "$managed_path_dir" in
"$managed_agent_dir/bin"|"$HOME/.local/bin"|"$HOME/bin"|"$HOME/.bin"|"$HOME/local/bin")
if path_is_writable_or_creatable "$managed_path_dir"; then
printf '%s' "$managed_path_dir"
return 0
fi
;;
esac
IFS=:
done
IFS=$managed_path_ifs
printf '%s/bin' "$managed_agent_dir"
}
install_pi_package() {
if [ -t 1 ] && [ "${TERM:-}" != "dumb" ]; then
install_pi_package_with_progress
else
printf 'Installing Pi...\n\n'
run_pi_install error
fi
}
run_pi_install() {
npm_loglevel="$1"
if pi_managed_install_enabled; then
run_managed_install_pi "$npm_loglevel"
else
run_npm_install_pi "$npm_loglevel"
fi
}
run_npm_install_pi() {
npm_loglevel="$1"
if [ -n "${PI_NPM_INSTALL_PREFIX:-}" ]; then
npm install -g --ignore-scripts "$PI_NPM_INSTALL_MIN_AGE_ARG" --prefix "$PI_NPM_INSTALL_PREFIX" --no-fund --no-audit "--loglevel=$npm_loglevel" --progress=false "$PI_PACKAGE"
else
npm install -g --ignore-scripts "$PI_NPM_INSTALL_MIN_AGE_ARG" --no-fund --no-audit "--loglevel=$npm_loglevel" --progress=false "$PI_PACKAGE"
fi
}
download_installer_artifact() {
url="$1"
output="$2"
label="$3"
if ! command -v curl >/dev/null 2>&1; then
printf 'curl is not available for the managed installer.\n' >&2
return 1
fi
http_status=$(curl -L -sS -w '%{http_code}' -o "$output" "$url") || {
rm -f "$output"
printf 'Could not download %s from %s.\n' "$label" "$url" >&2
return 1
}
if [ "$http_status" = 200 ]; then
return 0
fi
rm -f "$output"
printf 'Managed installer %s is unavailable at %s (HTTP %s).\n' "$label" "$url" "$http_status" >&2
return 1
}
managed_install_release_version() {
metadata_path="$1"
node - "$metadata_path" <<'NODE'
const fs = require("node:fs");
const metadata = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));
const version = metadata.version;
if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(version ?? "")) {
throw new Error("managed installer metadata has an invalid version");
}
console.log(version);
NODE
}
download_managed_install_artifacts() {
managed_stage_dir="$1"
printf 'Downloading managed installer release metadata\n' >&2
download_installer_artifact "$PI_INSTALLER_API_BASE/latest" "$managed_stage_dir/metadata.json" "release metadata" || return 1
if ! managed_version=$(managed_install_release_version "$managed_stage_dir/metadata.json"); then
printf 'Managed installer release metadata is invalid.\n' >&2
return 1
fi
printf 'Downloading managed installer package.json for Pi %s\n' "$managed_version" >&2
download_installer_artifact "$PI_INSTALLER_API_BASE/$managed_version/package.json" "$managed_stage_dir/package.json" "package.json" || return 1
printf 'Downloading managed installer package-lock.json for Pi %s\n' "$managed_version" >&2
download_installer_artifact "$PI_INSTALLER_API_BASE/$managed_version/package-lock.json" "$managed_stage_dir/package-lock.json" "package-lock.json" || return 1
validate_managed_install_artifacts "$managed_stage_dir/package.json" "$managed_stage_dir/package-lock.json" "$managed_version"
}
validate_managed_install_artifacts() {
package_json_path="$1"
package_lock_path="$2"
managed_version="$3"
node - "$package_json_path" "$package_lock_path" "$PI_PACKAGE" "$managed_version" <<'NODE'
const fs = require("node:fs");
const packageJson = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));
const packageLock = JSON.parse(fs.readFileSync(process.argv[3], "utf8"));
const piPackage = process.argv[4];
const version = process.argv[5];
const root = packageLock.packages?.[""];
const piEntry = packageLock.packages?.[`node_modules/${piPackage}`];
if (packageJson.version !== version || packageJson.dependencies?.[piPackage] !== version) {
throw new Error(`managed installer package.json must describe ${piPackage}@${version}`);
}
if (packageLock.lockfileVersion !== 3) {
throw new Error("managed installer package-lock.json must use lockfileVersion 3");
}
if (packageLock.version !== version || root?.version !== version || root?.dependencies?.[piPackage] !== version) {
throw new Error(`managed installer package-lock.json root must describe ${piPackage}@${version}`);
}
if (piEntry?.version !== version) {
throw new Error(`managed installer package-lock.json does not include ${piPackage}@${version}`);
}
NODE
}
write_managed_install_marker() {
managed_root="$1"
managed_entrypoint_type="$2"
managed_entrypoint_path="$3"
marker_tmp="$managed_root/$PI_MANAGED_INSTALL_MARKER.tmp.$$"
node - "$marker_tmp" "$managed_entrypoint_type" "$managed_entrypoint_path" <<'NODE'
const fs = require("node:fs");
const markerPath = process.argv[2];
const entrypointType = process.argv[3];
const entrypointPath = process.argv[4];
fs.writeFileSync(
markerPath,
`${JSON.stringify(
{
kind: "pi-managed-install",
schemaVersion: 1,
layout: "releases-v1",
entrypoint: { type: entrypointType, path: entrypointPath },
},
null,
2,
)}\n`,
);
NODE
mv -f "$marker_tmp" "$managed_root/$PI_MANAGED_INSTALL_MARKER"
}
managed_install_entrypoint_path() {
managed_root="$1"
node - "$managed_root/$PI_MANAGED_INSTALL_MARKER" <<'NODE'
const fs = require("node:fs");
const marker = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));
if (typeof marker.entrypoint?.path !== "string" || !marker.entrypoint.path) process.exit(1);
console.log(marker.entrypoint.path);
NODE
}
write_managed_install_launcher() {
managed_agent_dir="$1"
managed_launcher_dir="$managed_agent_dir/bin"
managed_launcher="$managed_launcher_dir/$PI_CMD"
launcher_tmp="$managed_launcher.tmp.$$"
if [ -e "$managed_launcher" ]; then
[ -f "$managed_launcher" ] && [ -x "$managed_launcher" ]
return $?
fi
mkdir -p "$managed_launcher_dir"
cat >"$launcher_tmp" <<'EOF'
#!/bin/sh
case "$0" in
*/*) pi_launcher="$0" ;;
*) pi_launcher=$(command -v "$0") || exit 127 ;;
esac
while [ -L "$pi_launcher" ]; do
pi_link=$(readlink "$pi_launcher") || exit 1
case "$pi_link" in
/*) pi_launcher="$pi_link" ;;
*) pi_launcher=${pi_launcher%/*}/$pi_link ;;
esac
done
pi_bin_dir=${pi_launcher%/*}
pi_agent_dir=${pi_bin_dir%/*}
pi_current_file=$pi_agent_dir/install/current-version
if ! IFS= read -r pi_current_version < "$pi_current_file"; then
printf 'Could not read managed Pi version from %s.\n' "$pi_current_file" >&2
exit 1
fi
case "$pi_current_version" in
""|.|..|*[!0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz._+-]*)
printf 'Managed Pi version file is invalid: %s\n' "$pi_current_file" >&2
exit 1
;;
esac
pi_release_dir=$pi_agent_dir/install/releases/$pi_current_version
pi_release_bin=$pi_release_dir/node_modules/.bin/pi
if [ ! -x "$pi_release_bin" ]; then
printf 'Managed Pi executable is missing: %s\n' "$pi_release_bin" >&2
exit 1
fi
PI_MANAGED_INSTALL_ROOT=$pi_agent_dir/install
export PI_MANAGED_INSTALL_ROOT
exec "$pi_release_bin" "$@"
EOF
chmod 755 "$launcher_tmp"
mv -f "$launcher_tmp" "$managed_launcher"
}
write_managed_install_link() {
managed_agent_dir="$1"
managed_bin_dir="$2"
managed_launcher="$managed_agent_dir/bin/$PI_CMD"
managed_entrypoint="$managed_bin_dir/$PI_CMD"
if [ "$managed_entrypoint" = "$managed_launcher" ]; then
return 0
fi
mkdir -p "$managed_bin_dir"
if [ -e "$managed_entrypoint" ] && [ ! -L "$managed_entrypoint" ]; then
printf 'Refusing to replace the executable at %s.\n' "$managed_entrypoint" >&2
return 1
fi
managed_link_target=$(node - "$managed_bin_dir" "$managed_launcher" <<'NODE'
const path = require("node:path");
console.log(path.relative(process.argv[2], process.argv[3]));
NODE
)
managed_link_tmp="$managed_bin_dir/.$PI_CMD.tmp.$$"
rm -f "$managed_link_tmp"
ln -s "$managed_link_target" "$managed_link_tmp"
mv -f "$managed_link_tmp" "$managed_entrypoint"
}
write_managed_current_version() {
managed_root="$1"
managed_version="$2"
current_tmp="$managed_root/current-version.tmp.$$"
printf '%s\n' "$managed_version" >"$current_tmp"
mv -f "$current_tmp" "$managed_root/current-version"
}
run_managed_install_pi() {
npm_loglevel="$1"
managed_root="$PI_MANAGED_INSTALL_DIR"
if [ -n "${PI_EXISTING_PATH:-}" ]; then
if ! managed_existing_root=$(managed_install_root_for_command "$PI_EXISTING_PATH") || [ "$managed_existing_root" != "$managed_root" ]; then
printf 'Experimental managed install refused to replace Pi at %s. Uninstall it first.\n' "$PI_EXISTING_PATH" >&2
return 1
fi
fi
if [ -e "$managed_root/$PI_MANAGED_INSTALL_MARKER" ] && ! managed_install_marker_is_valid "$managed_root"; then
printf 'The managed install marker at %s is invalid.\n' "$managed_root/$PI_MANAGED_INSTALL_MARKER" >&2
return 1
fi
managed_launcher="$PI_MANAGED_AGENT_DIR/bin/$PI_CMD"
if { [ -e "$managed_launcher" ] || [ -L "$managed_launcher" ]; } && ! managed_install_marker_is_valid "$managed_root"; then
printf 'Refusing to replace the unrecognized executable at %s.\n' "$managed_launcher" >&2
return 1
fi
mkdir -p "$managed_root/staging" "$managed_root/releases"
managed_stage_dir="$managed_root/staging/install-$$-$(date +%s)"
rm -rf "$managed_stage_dir"
mkdir -p "$managed_stage_dir"
if ! download_managed_install_artifacts "$managed_stage_dir"; then
rm -rf "$managed_stage_dir"
return 1
fi
printf 'Installing managed Pi dependencies\n' >&2
if (cd "$managed_stage_dir" && npm ci --ignore-scripts "$PI_NPM_INSTALL_MIN_AGE_ARG" --omit=dev --include=optional --no-fund --no-audit "--loglevel=$npm_loglevel" --progress=false); then
managed_status=0
else
managed_status=$?
fi
if [ "$managed_status" -ne 0 ]; then
rm -rf "$managed_stage_dir"
return "$managed_status"
fi
managed_staged_bin="$managed_stage_dir/node_modules/.bin/$PI_CMD"
if [ ! -x "$managed_staged_bin" ]; then
printf 'Managed Pi executable was not created by npm ci.\n' >&2
rm -rf "$managed_stage_dir"
return 1
fi
printf 'Verifying managed Pi %s\n' "$managed_version" >&2
if managed_installed_version=$("$managed_staged_bin" --version); then
managed_status=0
else
managed_status=$?
fi
if [ "$managed_status" -ne 0 ]; then
rm -rf "$managed_stage_dir"
return "$managed_status"
fi
if [ "$managed_installed_version" != "$managed_version" ]; then
printf 'Managed Pi smoke test returned version %s; expected %s.\n' "$managed_installed_version" "$managed_version" >&2
rm -rf "$managed_stage_dir"
return 1
fi
managed_release_dir="$managed_root/releases/$managed_version"
printf 'Activating managed Pi %s\n' "$managed_version" >&2
if [ -d "$managed_release_dir" ]; then
rm -rf "$managed_stage_dir"
elif ! mv "$managed_stage_dir" "$managed_release_dir"; then
rm -rf "$managed_stage_dir"
return 1
fi
if [ "$PI_MANAGED_BIN_DIR/$PI_CMD" = "$PI_MANAGED_AGENT_DIR/bin/$PI_CMD" ]; then
managed_entrypoint_type=script
else
managed_entrypoint_type=symlink
fi
write_managed_install_marker "$managed_root" "$managed_entrypoint_type" "$PI_MANAGED_BIN_DIR/$PI_CMD"
write_managed_install_launcher "$PI_MANAGED_AGENT_DIR"
write_managed_install_link "$PI_MANAGED_AGENT_DIR" "$PI_MANAGED_BIN_DIR"
write_managed_current_version "$managed_root" "$managed_version"
hash -r
printf 'Managed Pi install complete\n' >&2
}
uninstall_pi_package() {
if managed_uninstall_root=$(managed_install_root_for_command "$PI_EXISTING_PATH"); then
printf 'Uninstalling managed Pi...\n\n'
managed_uninstall_agent=${managed_uninstall_root%/*}
managed_uninstall_launcher="$managed_uninstall_agent/bin/$PI_CMD"
managed_uninstall_entrypoint=$(managed_install_entrypoint_path "$managed_uninstall_root" 2>/dev/null || true)
if [ -n "$managed_uninstall_entrypoint" ] && [ "$managed_uninstall_entrypoint" != "$managed_uninstall_launcher" ] && [ -L "$managed_uninstall_entrypoint" ]; then
rm -f "$managed_uninstall_entrypoint"
fi
if [ "$PI_EXISTING_PATH" != "$managed_uninstall_launcher" ] && [ -L "$PI_EXISTING_PATH" ]; then
rm -f "$PI_EXISTING_PATH"
fi
rm -f "$managed_uninstall_launcher"
rm -rf "$managed_uninstall_root"
hash -r
if [ -e "$PI_EXISTING_PATH" ] || [ -L "$PI_EXISTING_PATH" ]; then
printf '\nManaged uninstall finished, but pi is still present at:\n\n %s\n' "$PI_EXISTING_PATH" >&2
return 1
fi
return 0
fi
if ! npm_package_is_installed_for_uninstall; then
printf 'I found pi at:\n\n %s\n\n' "$PI_EXISTING_PATH" >&2
printf 'but npm does not show %s installed there.\n' "$PI_PACKAGE" >&2
printf 'Nothing was removed.\n' >&2
return 1
fi
printf 'Uninstalling Pi...\n\n'
run_npm_uninstall_pi error
hash -r
if [ -e "$PI_EXISTING_PATH" ] || [ -L "$PI_EXISTING_PATH" ]; then
printf '\nnpm uninstall finished, but pi is still present at:\n\n %s\n' "$PI_EXISTING_PATH" >&2
return 1
fi
}
npm_package_is_installed_for_uninstall() {
if [ -n "${PI_NPM_UNINSTALL_PREFIX:-}" ]; then
npm ls -g --prefix "$PI_NPM_UNINSTALL_PREFIX" --depth=0 "$PI_PACKAGE" >/dev/null 2>&1
else
npm ls -g --depth=0 "$PI_PACKAGE" >/dev/null 2>&1
fi
}
run_npm_uninstall_pi() {
npm_loglevel="$1"
if [ -n "${PI_NPM_UNINSTALL_PREFIX:-}" ]; then
npm uninstall -g --prefix "$PI_NPM_UNINSTALL_PREFIX" --no-fund --no-audit "--loglevel=$npm_loglevel" --progress=false "$PI_PACKAGE"
else
npm uninstall -g --no-fund --no-audit "--loglevel=$npm_loglevel" --progress=false "$PI_PACKAGE"
fi
}
install_pi_package_with_progress() {
log_file="${TMPDIR:-/tmp}/pi-installer-npm.$$"
rm -f "$log_file"
: >"$log_file"
run_pi_install verbose >"$log_file" 2>&1 &
npm_pid=$!
printf '\033[?25l'
animate_npm_install "$log_file" &
progress_pid=$!
trap 'kill "$npm_pid" 2>/dev/null || true; finish_install_progress "$progress_pid"; exit 130' INT TERM
if wait "$npm_pid"; then
status=0
else
status=$?
fi
finish_install_progress "$progress_pid"
trap - INT TERM
if [ "$status" -ne 0 ]; then
printf '\033[31mInstallation failed.\033[0m\n\n'
cat "$log_file"
rm -f "$log_file"
return "$status"
fi
rm -f "$log_file"
if terminal_supports_unicode; then
printf ' \033[32m✓\033[0m install complete\n'
else
printf ' \033[32mok\033[0m install complete\n'
fi
}
finish_install_progress() {
progress_pid="$1"
kill "$progress_pid" 2>/dev/null || true
wait "$progress_pid" 2>/dev/null || true
printf '\r\033[K\033[?25h'
}
terminal_supports_unicode() {
locale="${LC_ALL:-${LC_CTYPE:-${LANG:-}}}"
case "$locale" in
*UTF-8*|*utf-8*|*UTF8*|*utf8*) return 0 ;;
esac
case "${TERM_PROGRAM:-}" in
Apple_Terminal|iTerm.app|vscode|WezTerm) return 0 ;;
esac
return 1
}
spinner_frame() {
frame_step="$1"
frame_count="$2"
if [ "$frame_count" -eq 10 ]; then
case $((frame_step % 10)) in
0) printf '⠋' ;;
1) printf '⠙' ;;
2) printf '⠹' ;;
3) printf '⠸' ;;
4) printf '⠼' ;;
5) printf '⠴' ;;
6) printf '⠦' ;;
7) printf '⠧' ;;
8) printf '⠇' ;;
*) printf '⠏' ;;
esac
else
case $((frame_step % 4)) in
0) printf '-' ;;
1) printf '\\' ;;
2) printf '|' ;;
*) printf '/' ;;
esac
fi
}
animate_npm_install() {
log_file="$1"
if terminal_supports_unicode; then
full="█"
empty="░"
frame_count=10
else
full="#"
empty="-"
frame_count=4
fi
step=0
if pi_managed_install_enabled; then
label="starting managed install"
else
label="starting npm install"
fi
while :; do
frame=$(spinner_frame "$step" "$frame_count")
if [ $((step % 5)) -eq 0 ]; then
label=$(npm_install_progress_label "$log_file" "$label")
fi
draw_install_progress "$step" "$frame" "$label" "$full" "$empty"
step=$((step + 1))
sleep 0.08
done
}
animate_node_install() {
log_file="$1"
method_label="$2"
if terminal_supports_unicode; then
full="█"
empty="░"
frame_count=10
else
full="#"
empty="-"
frame_count=4
fi
step=0
label="starting ${method_label} install"
while :; do
frame=$(spinner_frame "$step" "$frame_count")
if [ $((step % 5)) -eq 0 ]; then
label=$(node_install_progress_label "$log_file" "$label")
fi
draw_install_progress "$step" "$frame" "$label" "$full" "$empty" "Installing Node.js"
step=$((step + 1))
sleep 0.08
done
}
node_install_progress_label() {
log_file="$1"
label="$2"
while IFS= read -r line; do
line=${line##*"$PI_CR"}
case "$line" in
"") ;;
Resolving\ Node.js*) label="resolving Node.js binary" ;;
Downloading\ Node.js*) label="$line" ;;
Verifying\ Node.js*) label="verifying download" ;;
Installing\ xz-utils*) label="installing xz-utils" ;;
Extracting\ Node.js*) label="extracting Node.js" ;;
Node.js\ installed*) label="Node.js installed" ;;
Hit:*|Get:*|Ign:*) label="updating package lists" ;;
Reading\ package\ lists*) label="reading package lists" ;;
Building\ dependency\ tree*) label="resolving dependencies" ;;
The\ following\ NEW\ packages*) label="installing dependencies" ;;
Need\ to\ get*|Fetched\ *) label="$line" ;;
Selecting\ previously\ unselected\ package*) label="selecting packages" ;;
Preparing\ to\ unpack*) label="preparing packages" ;;
Unpacking\ *|Setting\ up\ *) label="$line" ;;
fetch\ *) label="fetching packages" ;;
*Installing\ nodejs*) label="$line" ;;
OK:\ *) label="$line" ;;
==\>\ Downloading*) label="downloading packages" ;;
==\>\ Installing*|==\>\ Upgrading*) label="$line" ;;
==\>\ Pouring*) label="installing package" ;;
*already\ installed*) label="$line" ;;
esac
done < "$log_file"
if [ "${#label}" -gt 64 ]; then
label=$(printf '%.61s...' "$label")
fi
printf '%s' "$label"
}
npm_install_progress_label() {
log_file="$1"
label="$2"
metadata_cache_count=0
metadata_fetch_count=0
tarball_cache_count=0
tarball_fetch_count=0
while IFS= read -r line; do
line=${line%"$PI_CR"}
case "$line" in
Downloading\ managed\ installer\ release\ metadata*)
label="resolving managed release"
;;
Downloading\ managed\ installer\ package.json*)
label="fetching managed package manifest"
;;
Downloading\ managed\ installer\ package-lock.json*)
label="fetching managed package lock"
;;
Installing\ managed\ Pi\ dependencies*)
label="installing managed dependencies"
;;
Verifying\ managed\ Pi*)
label="verifying managed package"
;;
Activating\ managed\ Pi*)
label="activating managed package"
;;
Managed\ Pi\ install\ complete*)
label="managed install complete"
;;
npm\ verbose\ title\ npm\ install*|npm\ verbose\ title\ npm\ ci*)
label="resolving packages"
;;
npm\ http\ fetch\ GET\ *https://registry.npmjs.org/*.tgz*)
tarball_fetch_count=$((tarball_fetch_count + 1))
label="fetching tarballs (${tarball_fetch_count})"
;;
npm\ http\ cache\ *@https://registry.npmjs.org/*.tgz*)
tarball_cache_count=$((tarball_cache_count + 1))
if [ "$tarball_fetch_count" -gt 0 ]; then
label="fetching tarballs (${tarball_fetch_count})"
else
label="checking tarballs (${tarball_cache_count})"
fi
;;
npm\ http\ fetch\ GET\ *https://registry.npmjs.org/*)
metadata_fetch_count=$((metadata_fetch_count + 1))
label="fetching package metadata (${metadata_fetch_count})"
;;
npm\ http\ cache\ https://registry.npmjs.org/*)
metadata_cache_count=$((metadata_cache_count + 1))
if [ "$metadata_fetch_count" -gt 0 ]; then
label="fetching package metadata (${metadata_fetch_count})"
else
label="checking cached metadata (${metadata_cache_count})"
fi
;;
npm\ info\ run\ *)
rest=${line#npm info run }
package=${rest%% *}
rest=${rest#* }
script=${rest%% *}
package=${package%@*}
case "$line" in
*\{\ code:*) label="finished ${script} for ${package}" ;;
*) label="running ${script} for ${package}" ;;
esac
;;
changed\ *|added\ *|removed\ *|updated\ *|up\ to\ date\ *)
label="$line"
;;
esac
done < "$log_file"
printf '%s' "$label"
}
draw_install_progress() {
step="$1"; frame="$2"; label="$3"; full="$4"; empty="$5"; title="${6:-Installing Pi}"
reset="${PI_ESC}[0m"
dim="${PI_ESC}[2m"
cyan="${PI_ESC}[36m"
red="${PI_ESC}[31m"
green="${PI_ESC}[32m"
orange="${PI_ESC}[33m"
bold="${PI_ESC}[1m"
width=28
trail=8
head=$((step % (width + trail)))
bar=""
i=0
while [ "$i" -lt "$width" ]; do
age=$((head - i))
if [ "$age" -ge 0 ] && [ "$age" -lt "$trail" ]; then
case "$age" in
0|1) cell="${green}${full}${reset}" ;;
2|3) cell="${cyan}${full}${reset}" ;;
4|5) cell="${red}${full}${reset}" ;;
*) cell="${orange}${full}${reset}" ;;
esac
else
cell="${dim}${empty}${reset}"
fi
bar="${bar}${cell}"
i=$((i + 1))
done
printf '\r\033[K %s%s%s %s %s%s%s %s' "$orange" "$frame" "$reset" "$bar" "$bold" "$title" "$reset" "$label"
}
pi_logo_animation() {
if [ ! -t 1 ] || [ "${TERM:-}" = "dumb" ]; then
print_static_logo
return
fi
esc="${PI_ESC}["
reset="${PI_ESC}[0m"
hide="${esc}?25l"
show="${esc}?25h"
clear="${esc}H"
trap 'printf "%s%s\n" "$reset" "$show"; trap - INT TERM; exit 130' INT TERM
printf '%s%s' "$hide" "${esc}2J${esc}H"
for y in 0 1 2 3; do draw_logo_frame "$clear" "$reset" 0 left 2 "$y" 0 0; sleep 0.075; done
for y in 0 1 2; do draw_logo_frame "$clear" "$reset" 1 top 2 "$y" 0 0; sleep 0.075; done
for y in 0 1 2 3 4; do draw_logo_frame "$clear" "$reset" 2 right 5 "$y" 0 0; sleep 0.075; done
draw_logo_frame "$clear" "$reset" 3 none 0 0 0 0; sleep 0.25
draw_logo_frame "$clear" "$reset" 3 none 0 0 1 0; sleep 0.08
draw_logo_frame "$clear" "$reset" 3 none 0 0 0 0; sleep 0.08
draw_logo_frame "$clear" "$reset" 3 none 0 0 1 0; sleep 0.08
draw_logo_frame "$clear" "$reset" 4 none 0 0 0 0; sleep 0.10
draw_logo_frame "$clear" "$reset" 5 none 0 0 0 0; sleep 0.45
draw_logo_frame "$clear" "$reset" 5 none 0 0 0 1; sleep 0.12
draw_logo_frame "$clear" "$reset" 5 none 0 0 0 0; sleep 0.12
draw_logo_frame "$clear" "$reset" 5 none 0 0 0 1; sleep 0.45
printf '%s%s\n' "$reset" "$show"
trap - INT TERM
}
draw_logo_frame() {
clear="$1"; reset="$2"; phase="$3"; active="$4"; ax="$5"; ay="$6"; flash="$7"; white="$8"
left=0
top=0
panel_cell="${reset} "
cyan_cell="${PI_ESC}[36m██"
red_cell="${PI_ESC}[31m██"
green_cell="${PI_ESC}[32m██"
orange_cell="${PI_ESC}[33m██"
white_cell="${PI_ESC}[39m██"
flash_cell="${PI_ESC}[33m██"
pad=$(repeat_space "$left")
clear_cell="$panel_cell"
frame="$clear"
i=0
while [ "$i" -lt "$top" ]; do frame="${frame}\n"; i=$((i + 1)); done
for y in 0 1 2 3 4 5 6 7 8; do
frame="${frame}${pad}"
for x in 1 2 3 4 5 6 7 8; do
set_logo_cell_color "$phase" "$active" "$ax" "$ay" "$flash" "$white" "$y" "$x"
case "$LOGO_COLOR" in
cyan) cell="$cyan_cell" ;;
red) cell="$red_cell" ;;
green) cell="$green_cell" ;;
orange) cell="$orange_cell" ;;
white) cell="$white_cell" ;;
flash) cell="$flash_cell" ;;
*) cell="$clear_cell" ;;
esac
frame="${frame}${cell}"
done
frame="${frame}${reset}\n"
done
printf '%b' "$frame" 2>/dev/null || true
}
set_logo_cell_color() {
phase="$1"; active="$2"; ax="$3"; ay="$4"; flash="$5"; white="$6"; y="$7"; x="$8"
if [ "$white" = 1 ]; then
if in_cells "$y" "$x" "3,2 3,3 3,4 4,2 4,4 5,2 5,3 5,5 6,2 6,5"; then LOGO_COLOR=white; else LOGO_COLOR=panel; fi
return
fi
if [ "$flash" = 1 ] && [ "$y" = 6 ] && [ "$x" -ge 1 ] && [ "$x" -le 6 ]; then LOGO_COLOR=flash; return; fi
case "$active" in
left) if in_piece "$y" "$x" "$ay" "$ax" "0,0 1,0 1,1 2,0"; then LOGO_COLOR=red; return; fi ;;
top) if in_piece "$y" "$x" "$ay" "$ax" "0,0 0,1 0,2 1,2"; then LOGO_COLOR=cyan; return; fi ;;
right) if in_piece "$y" "$x" "$ay" "$ax" "0,0 1,0 2,0 2,1"; then LOGO_COLOR=green; return; fi ;;
esac
if [ "$phase" = 4 ]; then
if in_cells "$y" "$x" "2,2 2,3 2,4 3,4"; then LOGO_COLOR=cyan; return; fi
if in_cells "$y" "$x" "3,2 4,2 4,3 5,2"; then LOGO_COLOR=red; return; fi
if in_cells "$y" "$x" "4,5 5,5"; then LOGO_COLOR=green; return; fi
LOGO_COLOR=panel; return
fi
if [ "$phase" -ge 5 ]; then
if in_cells "$y" "$x" "3,2 3,3 3,4 4,4"; then LOGO_COLOR=cyan; return; fi
if in_cells "$y" "$x" "4,2 5,2 5,3 6,2"; then LOGO_COLOR=red; return; fi
if in_cells "$y" "$x" "5,5 6,5"; then LOGO_COLOR=green; return; fi
LOGO_COLOR=panel; return
fi
if [ "$phase" -le 3 ] && in_cells "$y" "$x" "6,1 6,2 6,3 6,4"; then LOGO_COLOR=orange; return; fi
if [ "$phase" -ge 2 ] && in_cells "$y" "$x" "2,2 2,3 2,4 3,4"; then LOGO_COLOR=cyan; return; fi
if [ "$phase" -ge 1 ] && in_cells "$y" "$x" "3,2 4,2 4,3 5,2"; then LOGO_COLOR=red; return; fi
if [ "$phase" -ge 3 ] && in_cells "$y" "$x" "4,5 5,5 6,5 6,6"; then LOGO_COLOR=green; return; fi
LOGO_COLOR=panel
}
in_piece() {
y="$1"; x="$2"; py="$3"; px="$4"; cells="$5"
for item in $cells; do
dy=${item%,*}; dx=${item#*,}
[ "$y" -eq $((py + dy)) ] && [ "$x" -eq $((px + dx)) ] && return 0
done
return 1
}
in_cells() {
y="$1"; x="$2"; shift 2
for item in $1; do
[ "$item" = "$y,$x" ] && return 0
done
return 1
}
repeat_space() {
count="$1"; out=""
while [ "$count" -gt 0 ]; do out=" $out"; count=$((count - 1)); done
printf '%s' "$out"
}
print_static_logo() {
cat <<'EOF'
██████
██ ██
████ ██
██ ██
EOF
}
pi_installer_main "$@"
Reference in New Issue View Git Blame Copy Permalink