OpenACP/scripts/install.sh
0xmrpeter 1ff14957ad fix: show node binary path in check_node output for easier debugging
Display the resolved path from 'command -v node' alongside the version
so users and logs immediately show which node is active (e.g. nvm vs
system). Also bump installer version to 1.0.3.
2026-04-07 23:43:57 +07:00

1502 lines
46 KiB
Bash
Executable File
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#!/bin/bash
set -euo pipefail
# OpenACP Installer for macOS and Linux
# Usage: curl -fsSL https://raw.githubusercontent.com/Open-ACP/OpenACP/main/scripts/install.sh | bash
# ─── Section 1: Initialization & Utilities ────────────────────────────────────
BOLD='\033[1m'
ACCENT='\033[38;2;99;102;241m' # indigo #6366f1
INFO='\033[38;2;136;146;176m' # text-secondary #8892b0
SUCCESS='\033[38;2;34;197;94m' # green #22c55e
WARN='\033[38;2;250;204;21m' # yellow #facc15
ERROR='\033[38;2;239;68;68m' # red #ef4444
MUTED='\033[38;2;90;100;128m' # text-muted #5a6480
NC='\033[0m'
INSTALLER_VERSION="1.0.3"
DEFAULT_TAGLINE="AI coding agents, anywhere."
NODE_DEFAULT_MAJOR=20
NODE_MIN_MAJOR=20
NODE_MIN_MINOR=0
NODE_MIN_VERSION="${NODE_MIN_MAJOR}.${NODE_MIN_MINOR}"
# Initialize Homebrew PATH for non-login shells (macOS).
# ~/.zprofile is not sourced when running as 'bash install.sh' or 'curl | bash',
# so /opt/homebrew/bin (Apple Silicon) or /usr/local/bin (Intel) may be missing from PATH.
if [[ -x "/opt/homebrew/bin/brew" ]]; then
eval "$(/opt/homebrew/bin/brew shellenv)" 2>/dev/null || true
elif [[ -x "/usr/local/bin/brew" ]]; then
eval "$(/usr/local/bin/brew shellenv)" 2>/dev/null || true
fi
ORIGINAL_PATH="${PATH:-}"
TMPFILES=()
cleanup_tmpfiles() {
local f
for f in "${TMPFILES[@]:-}"; do
rm -rf "$f" 2>/dev/null || true
done
}
trap cleanup_tmpfiles EXIT
mktempfile() {
local f
f="$(mktemp)"
TMPFILES+=("$f")
echo "$f"
}
mktempdir() {
local d
d="$(mktemp -d)"
TMPFILES+=("$d")
echo "$d"
}
DOWNLOADER=""
detect_downloader() {
if command -v curl &>/dev/null; then
DOWNLOADER="curl"
return 0
fi
if command -v wget &>/dev/null; then
DOWNLOADER="wget"
return 0
fi
ui_error "Missing downloader (curl or wget required)"
exit 1
}
download_file() {
local url="$1"
local output="$2"
if [[ -z "$DOWNLOADER" ]]; then
detect_downloader
fi
if [[ "$DOWNLOADER" == "curl" ]]; then
curl -fsSL --proto '=https' --tlsv1.2 --retry 3 --retry-delay 1 --retry-connrefused -o "$output" "$url"
return
fi
wget -q --https-only --secure-protocol=TLSv1_2 --tries=3 --timeout=20 -O "$output" "$url"
}
is_non_interactive_shell() {
if [[ "${NO_PROMPT:-0}" == "1" ]]; then
return 0
fi
if [[ ! -t 0 || ! -t 1 ]]; then
return 0
fi
return 1
}
detect_os() {
case "$(uname -s 2>/dev/null || true)" in
Darwin) echo "Darwin" ;;
Linux) echo "Linux" ;;
*) echo "unsupported" ;;
esac
}
detect_arch() {
case "$(uname -m 2>/dev/null || true)" in
x86_64|amd64) echo "x86_64" ;;
arm64|aarch64) echo "arm64" ;;
i386|i686) echo "i386" ;;
armv7l|armv7) echo "armv7" ;;
armv6l|armv6) echo "armv6" ;;
*) echo "unknown" ;;
esac
}
verify_sha256sum_file() {
local checksums="$1"
if command -v sha256sum >/dev/null 2>&1; then
sha256sum --ignore-missing -c "$checksums" >/dev/null 2>&1
return $?
fi
if command -v shasum >/dev/null 2>&1; then
shasum -a 256 --ignore-missing -c "$checksums" >/dev/null 2>&1
return $?
fi
return 1
}
# ─── Section 2: Gum Bootstrap ─────────────────────────────────────────────────
GUM_VERSION="${OPENACP_GUM_VERSION:-0.17.0}"
GUM=""
GUM_STATUS="skipped"
GUM_REASON=""
gum_is_tty() {
if [[ -n "${NO_COLOR:-}" ]]; then
return 1
fi
if [[ "${TERM:-dumb}" == "dumb" ]]; then
return 1
fi
if [[ -t 2 || -t 1 ]]; then
return 0
fi
if [[ -r /dev/tty && -w /dev/tty ]]; then
return 0
fi
return 1
}
bootstrap_gum_temp() {
GUM=""
GUM_STATUS="skipped"
GUM_REASON=""
if is_non_interactive_shell; then
GUM_REASON="non-interactive shell (auto-disabled)"
return 1
fi
if ! gum_is_tty; then
GUM_REASON="terminal does not support gum UI"
return 1
fi
if command -v gum >/dev/null 2>&1; then
GUM="gum"
GUM_STATUS="found"
GUM_REASON="already installed"
return 0
fi
if ! command -v tar >/dev/null 2>&1; then
GUM_REASON="tar not found"
return 1
fi
local os arch asset base gum_tmpdir gum_path
os="$(detect_os)"
arch="$(detect_arch)"
if [[ "$os" == "unsupported" || "$arch" == "unknown" ]]; then
GUM_REASON="unsupported os/arch ($os/$arch)"
return 1
fi
asset="gum_${GUM_VERSION}_${os}_${arch}.tar.gz"
base="https://github.com/charmbracelet/gum/releases/download/v${GUM_VERSION}"
gum_tmpdir="$(mktempdir)"
if ! download_file "${base}/${asset}" "$gum_tmpdir/$asset"; then
GUM_REASON="download failed"
return 1
fi
if ! download_file "${base}/checksums.txt" "$gum_tmpdir/checksums.txt"; then
GUM_REASON="checksum unavailable or failed"
return 1
fi
if ! (cd "$gum_tmpdir" && verify_sha256sum_file "checksums.txt"); then
GUM_REASON="checksum verification failed"
return 1
fi
if ! tar -xzf "$gum_tmpdir/$asset" -C "$gum_tmpdir" >/dev/null 2>&1; then
GUM_REASON="extract failed"
return 1
fi
gum_path="$(find "$gum_tmpdir" -type f -name gum 2>/dev/null | head -n1 || true)"
if [[ -z "$gum_path" ]]; then
GUM_REASON="gum binary missing after extract"
return 1
fi
chmod +x "$gum_path" >/dev/null 2>&1 || true
if [[ ! -x "$gum_path" ]]; then
GUM_REASON="gum binary is not executable"
return 1
fi
GUM="$gum_path"
GUM_STATUS="installed"
GUM_REASON="temp, verified"
return 0
}
print_gum_status() {
case "$GUM_STATUS" in
found)
ui_success "gum available (${GUM_REASON})"
;;
installed)
ui_success "gum bootstrapped (${GUM_REASON}, v${GUM_VERSION})"
;;
*)
if [[ -n "$GUM_REASON" && "$GUM_REASON" != "non-interactive shell (auto-disabled)" ]]; then
ui_info "gum skipped (${GUM_REASON})"
fi
;;
esac
}
# ─── Section 3: UI Functions ──────────────────────────────────────────────────
print_installer_banner() {
if [[ -n "$GUM" ]]; then
local title tagline hint card
title="$("$GUM" style --foreground "#6366f1" --bold "⚡ OpenACP Installer")"
tagline="$("$GUM" style --foreground "#8892b0" "$TAGLINE")"
hint="$("$GUM" style --foreground "#5a6480" "installer v${INSTALLER_VERSION}")"
card="$(printf '%s\n%s\n%s' "$title" "$tagline" "$hint")"
"$GUM" style --border rounded --border-foreground "#6366f1" --padding "1 2" "$card"
echo ""
return
fi
echo -e "${ACCENT}${BOLD}"
echo " ⚡ OpenACP Installer"
echo -e "${NC}${INFO} ${TAGLINE}${NC}"
echo -e "${MUTED} installer v${INSTALLER_VERSION}${NC}"
echo ""
}
detect_os_or_die() {
OS="unknown"
if [[ "$OSTYPE" == "darwin"* ]]; then
OS="macos"
elif [[ "$OSTYPE" == "linux-gnu"* ]] || [[ -n "${WSL_DISTRO_NAME:-}" ]]; then
OS="linux"
fi
if [[ "$OS" == "unknown" ]]; then
ui_error "Unsupported operating system"
echo "This installer supports macOS and Linux (including WSL)."
exit 1
fi
ui_success "Detected: $OS"
}
ui_info() {
local msg="$*"
if [[ -n "$GUM" ]]; then
"$GUM" log --level info "$msg"
else
echo -e "${MUTED}·${NC} ${msg}"
fi
}
ui_warn() {
local msg="$*"
if [[ -n "$GUM" ]]; then
"$GUM" log --level warn "$msg"
else
echo -e "${WARN}!${NC} ${msg}"
fi
}
ui_success() {
local msg="$*"
if [[ -n "$GUM" ]]; then
local mark
mark="$("$GUM" style --foreground "#22c55e" --bold "✓")"
echo "${mark} ${msg}"
else
echo -e "${SUCCESS}✓${NC} ${msg}"
fi
}
ui_error() {
local msg="$*"
if [[ -n "$GUM" ]]; then
"$GUM" log --level error "$msg"
else
echo -e "${ERROR}✗${NC} ${msg}"
fi
}
INSTALL_STAGE_TOTAL=3
INSTALL_STAGE_CURRENT=0
ui_section() {
local title="$1"
if [[ -n "$GUM" ]]; then
"$GUM" style --bold --foreground "#6366f1" --padding "1 0" "$title"
else
echo ""
echo -e "${ACCENT}${BOLD}${title}${NC}"
fi
}
ui_stage() {
local title="$1"
INSTALL_STAGE_CURRENT=$((INSTALL_STAGE_CURRENT + 1))
ui_section "[${INSTALL_STAGE_CURRENT}/${INSTALL_STAGE_TOTAL}] ${title}"
}
ui_kv() {
local key="$1"
local value="$2"
if [[ -n "$GUM" ]]; then
local key_part value_part
key_part="$("$GUM" style --foreground "#5a6480" --width 20 "$key")"
value_part="$("$GUM" style --bold "$value")"
"$GUM" join --horizontal "$key_part" "$value_part"
else
echo -e "${MUTED}${key}:${NC} ${value}"
fi
}
is_gum_raw_mode_failure() {
local err_log="$1"
[[ -s "$err_log" ]] || return 1
grep -Eiq 'setrawmode' "$err_log"
}
run_with_spinner() {
local title="$1"
shift
if [[ -n "$GUM" ]] && gum_is_tty; then
local gum_err
gum_err="$(mktempfile)"
if "$GUM" spin --spinner dot --title "$title" -- "$@" 2>"$gum_err"; then
return 0
fi
local gum_status=$?
if is_gum_raw_mode_failure "$gum_err"; then
GUM=""
GUM_STATUS="skipped"
GUM_REASON="gum raw mode unavailable"
ui_warn "Spinner unavailable in this terminal; continuing without spinner"
"$@"
return $?
fi
if [[ -s "$gum_err" ]]; then
cat "$gum_err" >&2
fi
return "$gum_status"
fi
"$@"
}
run_quiet_step() {
local title="$1"
shift
if [[ "$VERBOSE" == "1" ]]; then
run_with_spinner "$title" "$@"
return $?
fi
local log
log="$(mktempfile)"
if [[ -n "$GUM" ]] && gum_is_tty; then
local cmd_quoted=""
local log_quoted=""
printf -v cmd_quoted '%q ' "$@"
printf -v log_quoted '%q' "$log"
if run_with_spinner "$title" bash -c "${cmd_quoted}>${log_quoted} 2>&1"; then
return 0
fi
else
if "$@" >"$log" 2>&1; then
return 0
fi
fi
ui_error "${title} failed — re-run with --verbose for details"
if [[ -s "$log" ]]; then
tail -n 80 "$log" >&2 || true
fi
return 1
}
show_install_plan() {
ui_section "Install plan"
ui_kv "OS" "$OS"
ui_kv "Install method" "$INSTALL_METHOD"
ui_kv "Requested version" "$INSTALL_TAG"
if [[ "$INSTALL_METHOD" == "git" ]]; then
ui_kv "Git directory" "$GIT_DIR"
fi
if [[ "$DRY_RUN" == "1" ]]; then
ui_kv "Dry run" "yes"
fi
if [[ "$NO_ONBOARD" == "1" ]]; then
ui_kv "Onboarding" "skipped"
fi
}
ui_celebrate() {
local msg="$1"
if [[ -n "$GUM" ]]; then
"$GUM" style --bold --foreground "#22c55e" "$msg"
else
echo -e "${SUCCESS}${BOLD}${msg}${NC}"
fi
}
# ─── Section 4: Argument Parsing ──────────────────────────────────────────────
NO_ONBOARD=${OPENACP_NO_ONBOARD:-0}
NO_PROMPT=${OPENACP_NO_PROMPT:-0}
DRY_RUN=${OPENACP_DRY_RUN:-0}
INSTALL_METHOD=${OPENACP_INSTALL_METHOD:-npm}
INSTALL_TAG=${OPENACP_VERSION:-latest}
GIT_DIR_DEFAULT="${HOME}/OpenACP"
GIT_DIR=${OPENACP_GIT_DIR:-$GIT_DIR_DEFAULT}
NO_GIT_UPDATE=0
VERBOSE="${OPENACP_VERBOSE:-0}"
DO_VERIFY="${OPENACP_VERIFY_INSTALL:-0}"
HELP=0
print_usage() {
cat <<EOF
OpenACP installer (macOS + Linux)
Usage:
curl -fsSL https://raw.githubusercontent.com/Open-ACP/OpenACP/main/scripts/install.sh | bash
curl -fsSL ... | bash -s -- [options]
Options:
--install-method, --method npm|git Install via npm (default) or from a git checkout
--npm Shortcut for --install-method npm
--git Shortcut for --install-method git
--version <version|dist-tag> npm install target (default: latest)
--git-dir, --dir <path> Checkout directory (default: ~/OpenACP)
--no-git-update Skip git pull for existing checkout
--no-onboard Skip onboarding after install
--no-prompt Disable prompts (CI/automation)
--verify Run a post-install smoke test
--dry-run Print what would happen (no changes)
--verbose Print debug output (set -x)
--help, -h Show this help
Environment variables:
OPENACP_INSTALL_METHOD=npm|git
OPENACP_VERSION=latest|<semver>
OPENACP_GIT_DIR=...
OPENACP_NO_PROMPT=1
OPENACP_VERIFY_INSTALL=1
OPENACP_DRY_RUN=1
OPENACP_NO_ONBOARD=1
OPENACP_VERBOSE=1
Examples:
curl -fsSL https://raw.githubusercontent.com/Open-ACP/OpenACP/main/scripts/install.sh | bash
curl -fsSL ... | bash -s -- --no-onboard
curl -fsSL ... | bash -s -- --version 2026.328.1
curl -fsSL ... | bash -s -- --install-method git
EOF
}
parse_args() {
while [[ $# -gt 0 ]]; do
case "$1" in
--no-onboard)
NO_ONBOARD=1
shift
;;
--dry-run)
DRY_RUN=1
shift
;;
--verbose)
VERBOSE=1
shift
;;
--verify)
DO_VERIFY=1
shift
;;
--no-prompt)
NO_PROMPT=1
shift
;;
--help|-h)
HELP=1
shift
;;
--install-method|--method)
INSTALL_METHOD="$2"
shift 2
;;
--version)
INSTALL_TAG="$2"
shift 2
;;
--npm)
INSTALL_METHOD="npm"
shift
;;
--git)
INSTALL_METHOD="git"
shift
;;
--git-dir|--dir)
GIT_DIR="$2"
shift 2
;;
--no-git-update)
NO_GIT_UPDATE=1
shift
;;
*)
shift
;;
esac
done
}
validate_args() {
# Validate --git-dir: reject paths with shell-unsafe characters
if [[ "$GIT_DIR" =~ [\'\"\ \`\$\;\&\|\<\>] ]]; then
echo "Error: --git-dir contains unsafe characters: $GIT_DIR" >&2
exit 1
fi
if [[ "$GIT_DIR" == *..* ]]; then
echo "Error: --git-dir must not contain '..': $GIT_DIR" >&2
exit 1
fi
# Validate --version: allow 'latest', 'main', semver (YYYY.MMDD.patch), or simple dist-tag
if [[ "$INSTALL_TAG" != "latest" && "$INSTALL_TAG" != "main" ]]; then
if ! [[ "$INSTALL_TAG" =~ ^[a-zA-Z0-9._-]+$ ]]; then
echo "Error: --version contains invalid characters: $INSTALL_TAG" >&2
exit 1
fi
fi
}
configure_verbose() {
if [[ "$VERBOSE" != "1" ]]; then
return 0
fi
set -x
}
is_promptable() {
if [[ "$NO_PROMPT" == "1" ]]; then
return 1
fi
if [[ -r /dev/tty && -w /dev/tty ]]; then
return 0
fi
return 1
}
prompt_choice() {
local prompt="$1"
local answer=""
if ! is_promptable; then
return 1
fi
printf '%b\n' "$prompt" >/dev/tty
read -r answer </dev/tty || true
echo "$answer"
}
choose_install_method_interactive() {
if ! is_promptable; then
return 1
fi
if [[ -n "$GUM" ]] && gum_is_tty; then
local selection
selection="$("$GUM" choose \
--header "Choose install method" \
--cursor-prefix "❯ " \
"npm · install globally via npm (recommended)" \
"git · clone and build from source" </dev/tty || true)"
case "$selection" in
npm*) echo "npm"; return 0 ;;
git*) echo "git"; return 0 ;;
esac
return 1
fi
local choice=""
choice="$(prompt_choice "$(cat <<EOF
Choose install method:
1) Install globally via npm (recommended)
2) Clone and build from source (git)
Enter 1 or 2:
EOF
)" || true)"
case "$choice" in
1) echo "npm"; return 0 ;;
2) echo "git"; return 0 ;;
esac
return 1
}
# ─── Section 5: Node.js Detection & Installation ──────────────────────────────
ensure_xcode_clt() {
if [[ "$OS" != "macos" ]]; then
return 0
fi
if xcode-select -p &>/dev/null 2>&1; then
return 0
fi
ui_info "Xcode Command Line Tools not found — installing..."
xcode-select --install 2>/dev/null || true
ui_info "A dialog appeared — click Install and wait for it to complete"
until xcode-select -p &>/dev/null 2>&1; do
sleep 5
done
ui_success "Xcode Command Line Tools installed"
}
node_major_version() {
if ! command -v node &>/dev/null; then
return 1
fi
local version major
version="$(node -v 2>/dev/null || true)"
major="${version#v}"
major="${major%%.*}"
if [[ "$major" =~ ^[0-9]+$ ]]; then
echo "$major"
return 0
fi
return 1
}
node_is_at_least_required() {
if ! command -v node &>/dev/null; then
return 1
fi
local version major minor
version="$(node -v 2>/dev/null || true)"
major="${version#v}"
major="${major%%.*}"
minor="${version#v}"
minor="${minor#*.}"
minor="${minor%%.*}"
if [[ ! "$major" =~ ^[0-9]+$ || ! "$minor" =~ ^[0-9]+$ ]]; then
return 1
fi
if [[ "$major" -gt "$NODE_MIN_MAJOR" ]]; then
return 0
fi
if [[ "$major" -eq "$NODE_MIN_MAJOR" && "$minor" -ge "$NODE_MIN_MINOR" ]]; then
return 0
fi
return 1
}
check_node() {
if command -v node &>/dev/null; then
local node_path
node_path="$(command -v node)"
if node_is_at_least_required; then
ui_success "Node.js v$(node -v | cut -d'v' -f2) found (${node_path})"
return 0
else
ui_info "Node.js $(node -v) found at ${node_path}, need v${NODE_MIN_VERSION}+"
return 1
fi
else
ui_info "Node.js not found, installing it now"
return 1
fi
}
ensure_default_node_active_shell() {
# Always try version managers first (nvm, fnm, nodenv) before falling back to
# system node. This is important because version-manager-installed node has a
# user-writable npm prefix, whereas system node (installed via pkg/brew without
# a version manager) typically uses /usr/local which may require sudo for global
# installs — even when the node version itself meets the minimum requirement.
# Try sourcing nvm.
# Check NVM_DIR first, then fall back to the default ~/.nvm location.
# The fallback is critical: in non-login shells (e.g. when launched from a
# GUI app like the OpenACP desktop), ~/.zshrc is never sourced so NVM_DIR
# is unset even when nvm is properly installed.
local nvm_sh=""
if [[ -n "${NVM_DIR:-}" && -s "${NVM_DIR}/nvm.sh" ]]; then
nvm_sh="${NVM_DIR}/nvm.sh"
elif [[ -s "${HOME}/.nvm/nvm.sh" ]]; then
nvm_sh="${HOME}/.nvm/nvm.sh"
elif [[ -n "${XDG_CONFIG_HOME:-}" && -s "${XDG_CONFIG_HOME}/nvm/nvm.sh" ]]; then
nvm_sh="${XDG_CONFIG_HOME}/nvm/nvm.sh"
fi
if [[ -n "$nvm_sh" ]]; then
# shellcheck source=/dev/null
source "$nvm_sh" 2>/dev/null || true
if node_is_at_least_required; then
return 0
fi
fi
# Try sourcing fnm
if command -v fnm &>/dev/null; then
eval "$(fnm env 2>/dev/null)" || true
if node_is_at_least_required; then
return 0
fi
fi
# Try nodenv
if command -v nodenv &>/dev/null; then
eval "$(nodenv init - 2>/dev/null)" || true
if node_is_at_least_required; then
return 0
fi
fi
# Fall back to whatever node is already in PATH (system node, Homebrew, etc.)
if node_is_at_least_required; then
return 0
fi
# Try Homebrew-managed Node (macOS) — covers cases where Homebrew shellenv
# was not initialized (e.g. non-login shell without ~/.zprofile sourced).
for brew_bin in "/opt/homebrew/bin" "/usr/local/bin"; do
if [[ -x "${brew_bin}/node" ]]; then
export PATH="${brew_bin}:${PATH}"
hash -r 2>/dev/null || true
if node_is_at_least_required; then
return 0
fi
fi
done
return 1
}
print_nvm_upgrade_hint() {
echo "nvm appears to be managing Node for this shell."
echo "Run:"
echo " nvm install ${NODE_DEFAULT_MAJOR}"
echo " nvm use ${NODE_DEFAULT_MAJOR}"
echo " nvm alias default ${NODE_DEFAULT_MAJOR}"
echo "Then open a new shell and rerun the installer."
}
# Ensure nvm init lines are present in all relevant shell config files.
# nvm's own installer only writes based on $SHELL, which may miss some configs.
# On macOS the primary shell is zsh — always patch ~/.zshrc regardless of other rc files.
patch_nvm_shell_configs() {
# shellcheck disable=SC2016
local nvm_init_lines
nvm_init_lines="$(cat <<'EOF'
export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
EOF
)"
local marker='nvm.sh'
patch_rc() {
local rc="$1"
if ! grep -q "$marker" "$rc" 2>/dev/null; then
printf '\n# nvm (Node Version Manager)\n%s\n' "$nvm_init_lines" >> "$rc"
ui_info "Added nvm init to $rc"
fi
}
if [[ "$OS" == "macos" ]]; then
# macOS default shell is zsh. On a fresh machine ~/.zshrc may not exist yet —
# nvm installer only appends to existing files, so we must ensure ~/.zshrc exists.
touch "$HOME/.zshrc"
patch_rc "$HOME/.zshrc"
# Also patch bash configs if they exist
for rc in "$HOME/.bashrc" "$HOME/.bash_profile"; do
[[ -f "$rc" ]] && patch_rc "$rc"
done
else
# Linux: patch whichever rc files exist; create ~/.bashrc if none present
local patched_any=0
for rc in "$HOME/.zshrc" "$HOME/.bashrc" "$HOME/.bash_profile"; do
if [[ -f "$rc" ]]; then
patch_rc "$rc"
patched_any=1
fi
done
if [[ "$patched_any" -eq 0 ]]; then
printf '# nvm (Node Version Manager)\n%s\n' "$nvm_init_lines" > "$HOME/.bashrc"
ui_info "Created ~/.bashrc with nvm init"
fi
fi
}
install_node() {
if [[ "$OS" == "macos" ]]; then
ensure_xcode_clt
# Install via nvm (no sudo required)
if [[ -z "${NVM_DIR:-}" ]] && [[ ! -s "${HOME}/.nvm/nvm.sh" ]] && [[ ! -s "${XDG_CONFIG_HOME:-}/nvm/nvm.sh" ]]; then
ui_info "Installing nvm (Node Version Manager)"
local nvm_install
nvm_install="$(mktempfile)"
download_file "https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.4/install.sh" "$nvm_install"
run_quiet_step "Installing nvm" bash "$nvm_install"
export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
# shellcheck source=/dev/null
[[ -s "${NVM_DIR}/nvm.sh" ]] && source "${NVM_DIR}/nvm.sh"
patch_nvm_shell_configs
fi
if [[ -s "${NVM_DIR:-${HOME}/.nvm}/nvm.sh" ]]; then
# shellcheck source=/dev/null
source "${NVM_DIR:-${HOME}/.nvm}/nvm.sh"
ui_info "Installing Node.js v${NODE_DEFAULT_MAJOR} via nvm"
run_quiet_step "Installing Node.js" nvm install "${NODE_DEFAULT_MAJOR}"
nvm use "${NODE_DEFAULT_MAJOR}" 2>/dev/null || true
nvm alias default "${NODE_DEFAULT_MAJOR}" 2>/dev/null || true
else
ui_error "Could not install nvm. Please install Node.js ${NODE_DEFAULT_MAJOR} manually: https://nodejs.org"
exit 1
fi
# Always ensure shell configs are patched (idempotent) — handles the case where
# nvm was already installed but ~/.zshrc didn't exist at that time.
patch_nvm_shell_configs
ui_success "Node.js v${NODE_DEFAULT_MAJOR} installed"
elif [[ "$OS" == "linux" ]]; then
# Check for nvm first, install it if not present.
# Note: nvm is a shell function, not a binary — command -v nvm is unreliable.
# Always detect nvm via NVM_DIR / nvm.sh presence.
if [[ -z "${NVM_DIR:-}" ]] && [[ ! -s "${HOME}/.nvm/nvm.sh" ]] && [[ ! -s "${XDG_CONFIG_HOME:-}/nvm/nvm.sh" ]]; then
ui_info "Installing nvm (Node Version Manager)"
local nvm_install
nvm_install="$(mktempfile)"
download_file "https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.4/install.sh" "$nvm_install"
run_quiet_step "Installing nvm" bash "$nvm_install"
export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
# shellcheck source=/dev/null
[[ -s "${NVM_DIR}/nvm.sh" ]] && source "${NVM_DIR}/nvm.sh"
patch_nvm_shell_configs
fi
if [[ -n "${NVM_DIR:-}" && -s "${NVM_DIR}/nvm.sh" ]] || [[ -s "${HOME}/.nvm/nvm.sh" ]]; then
# shellcheck source=/dev/null
[[ -s "${NVM_DIR:-${HOME}/.nvm}/nvm.sh" ]] && source "${NVM_DIR:-${HOME}/.nvm}/nvm.sh"
ui_info "Installing Node.js v${NODE_DEFAULT_MAJOR} via nvm"
run_quiet_step "Installing Node.js" nvm install "${NODE_DEFAULT_MAJOR}"
nvm use "${NODE_DEFAULT_MAJOR}" 2>/dev/null || true
nvm alias default "${NODE_DEFAULT_MAJOR}" 2>/dev/null || true
else
# Fallback: NodeSource
# Security note: NodeSource setup scripts are downloaded over TLS (--proto '=https'
# --tlsv1.2 enforced by download_file) and executed directly. NodeSource does not
# publish per-script SHA256 checksums, so content verification is not possible.
# This is the same accepted pattern used by Homebrew, Rust, and other major installers.
# Source: https://github.com/nodesource/distributions
ui_info "Installing Node.js via NodeSource"
require_sudo
if command -v apt-get &>/dev/null; then
local tmp
tmp="$(mktempfile)"
download_file "https://deb.nodesource.com/setup_${NODE_DEFAULT_MAJOR}.x" "$tmp"
if is_root; then
run_quiet_step "Configuring NodeSource" bash "$tmp"
run_quiet_step "Installing Node.js" apt-get install -y -qq nodejs
else
run_quiet_step "Configuring NodeSource" sudo -E bash "$tmp"
run_quiet_step "Installing Node.js" sudo apt-get install -y -qq nodejs
fi
elif command -v dnf &>/dev/null; then
local tmp
tmp="$(mktempfile)"
download_file "https://rpm.nodesource.com/setup_${NODE_DEFAULT_MAJOR}.x" "$tmp"
if is_root; then
run_quiet_step "Configuring NodeSource" bash "$tmp"
run_quiet_step "Installing Node.js" dnf install -y -q nodejs
else
run_quiet_step "Configuring NodeSource" sudo bash "$tmp"
run_quiet_step "Installing Node.js" sudo dnf install -y -q nodejs
fi
elif command -v yum &>/dev/null; then
local tmp
tmp="$(mktempfile)"
download_file "https://rpm.nodesource.com/setup_${NODE_DEFAULT_MAJOR}.x" "$tmp"
if is_root; then
run_quiet_step "Configuring NodeSource" bash "$tmp"
run_quiet_step "Installing Node.js" yum install -y -q nodejs
else
run_quiet_step "Configuring NodeSource" sudo bash "$tmp"
run_quiet_step "Installing Node.js" sudo yum install -y -q nodejs
fi
elif command -v pacman &>/dev/null; then
if is_root; then
run_quiet_step "Installing Node.js" pacman -Sy --noconfirm nodejs npm
else
run_quiet_step "Installing Node.js" sudo pacman -Sy --noconfirm nodejs npm
fi
else
ui_error "Could not detect package manager"
echo "Please install Node.js ${NODE_DEFAULT_MAJOR} manually: https://nodejs.org"
exit 1
fi
fi
# Always ensure shell configs are patched (idempotent)
if [[ -s "${HOME}/.nvm/nvm.sh" ]] || [[ -s "${NVM_DIR:-}/nvm.sh" ]]; then
patch_nvm_shell_configs
fi
ui_success "Node.js v${NODE_DEFAULT_MAJOR} installed"
fi
}
# ─── Section 6: Git, npm Permissions & Package Install ────────────────────────
check_git() {
if command -v git &>/dev/null; then
ui_success "Git already installed"
return 0
fi
ui_info "Git not found, installing it now"
return 1
}
is_root() {
[[ "$(id -u)" -eq 0 ]]
}
maybe_sudo() {
if is_root; then
if [[ "${1:-}" == "-E" ]]; then
shift
fi
"$@"
else
sudo "$@"
fi
}
require_sudo() {
if [[ "$OS" != "linux" ]]; then
return 0
fi
if is_root; then
return 0
fi
if command -v sudo &>/dev/null; then
if ! sudo -n true >/dev/null 2>&1; then
ui_info "Administrator privileges required; enter your password"
sudo -v
fi
return 0
fi
ui_error "sudo is required for system installs on Linux"
echo " Install sudo or re-run as root."
exit 1
}
install_git() {
if [[ "$OS" == "macos" ]]; then
if ! command -v brew &>/dev/null; then
ui_info "Installing Git via Xcode Command Line Tools"
xcode-select --install 2>/dev/null || true
ui_info "If prompted, complete the Xcode CLT install, then rerun this installer"
else
run_quiet_step "Installing Git" brew install git
fi
elif [[ "$OS" == "linux" ]]; then
require_sudo
if command -v apt-get &>/dev/null; then
if is_root; then
run_quiet_step "Updating package index" apt-get update -qq
run_quiet_step "Installing Git" apt-get install -y -qq git
else
run_quiet_step "Updating package index" sudo apt-get update -qq
run_quiet_step "Installing Git" sudo apt-get install -y -qq git
fi
elif command -v pacman &>/dev/null; then
if is_root; then
run_quiet_step "Installing Git" pacman -Sy --noconfirm git
else
run_quiet_step "Installing Git" sudo pacman -Sy --noconfirm git
fi
elif command -v dnf &>/dev/null; then
if is_root; then
run_quiet_step "Installing Git" dnf install -y -q git
else
run_quiet_step "Installing Git" sudo dnf install -y -q git
fi
elif command -v yum &>/dev/null; then
if is_root; then
run_quiet_step "Installing Git" yum install -y -q git
else
run_quiet_step "Installing Git" sudo yum install -y -q git
fi
else
ui_error "Could not detect package manager for Git"
exit 1
fi
fi
ui_success "Git installed"
}
fix_npm_permissions() {
local npm_prefix
npm_prefix="$(npm config get prefix 2>/dev/null || true)"
if [[ -z "$npm_prefix" ]]; then
return 0
fi
# Check if npm global installs would succeed by verifying write access to the
# node_modules directory specifically. Checking $prefix or $prefix/lib alone is
# not sufficient: on Intel Macs with Homebrew, /usr/local/lib is user-writable
# (Homebrew sets this up) but /usr/local/lib/node_modules may be owned by root
# if Node was previously installed via the official pkg installer.
local nm_dir="$npm_prefix/lib/node_modules"
if [[ -d "$nm_dir" && -w "$nm_dir" ]]; then
return 0
fi
if [[ ! -d "$nm_dir" && -w "$npm_prefix/lib" ]]; then
return 0
fi
ui_info "Configuring npm for user-local installs"
mkdir -p "$HOME/.npm-global"
npm config set prefix "$HOME/.npm-global"
# shellcheck disable=SC2016
local path_line='export PATH="$HOME/.npm-global/bin:$PATH"'
for rc in "$HOME/.bashrc" "$HOME/.zshrc"; do
if [[ -f "$rc" ]] && ! grep -q ".npm-global" "$rc"; then
echo "$path_line" >> "$rc"
fi
done
export PATH="$HOME/.npm-global/bin:$PATH"
ui_success "npm configured for user installs"
}
resolve_package_install_spec() {
local value="$1"
if [[ "$value" == "latest" ]]; then
echo "@openacp/cli@latest"
return 0
fi
echo "@openacp/cli@${value}"
}
install_openacp_npm() {
local spec="$1"
local log
log="$(mktempfile)"
local max_retries=3
local attempt=0
while [[ "$attempt" -lt "$max_retries" ]]; do
attempt=$((attempt + 1))
local -a cmd=(npm install -g --no-fund --no-audit "$spec")
if [[ "$VERBOSE" == "1" ]]; then
if "${cmd[@]}" 2>&1 | tee "$log"; then
ui_success "OpenACP npm package installed"
return 0
fi
else
if [[ -n "$GUM" ]] && gum_is_tty; then
local cmd_quoted="" log_quoted=""
printf -v cmd_quoted '%q ' "${cmd[@]}"
printf -v log_quoted '%q' "$log"
if run_with_spinner "Installing OpenACP (attempt ${attempt}/${max_retries})" bash -c "${cmd_quoted}>${log_quoted} 2>&1"; then
ui_success "OpenACP npm package installed"
return 0
fi
else
if "${cmd[@]}" >"$log" 2>&1; then
ui_success "OpenACP npm package installed"
return 0
fi
fi
fi
if [[ "$attempt" -lt "$max_retries" ]]; then
ui_warn "npm install failed (attempt ${attempt}/${max_retries}); retrying..."
sleep 2
fi
done
ui_error "npm install failed after ${max_retries} attempts"
ui_warn "Command: npm install -g ${spec}"
if [[ -s "$log" ]]; then
echo " Last log lines:"
tail -n 20 "$log" >&2 || true
fi
return 1
}
install_openacp_from_git() {
local repo_dir="$1"
local repo_url="https://github.com/Open-ACP/OpenACP.git"
if [[ -d "$repo_dir/.git" ]]; then
ui_info "Installing OpenACP from git checkout: ${repo_dir}"
else
ui_info "Installing OpenACP from GitHub (${repo_url})"
fi
if ! check_git; then
install_git
if ! command -v git &>/dev/null; then
ui_error "Git installation failed. Please install git manually and rerun."
exit 1
fi
hash -r 2>/dev/null || true
fi
# Ensure pnpm is available
if ! command -v pnpm &>/dev/null; then
ui_info "Installing pnpm"
if command -v corepack &>/dev/null; then
corepack enable >/dev/null 2>&1 || true
corepack prepare pnpm@latest --activate >/dev/null 2>&1 || true
hash -r 2>/dev/null || true
fi
if ! command -v pnpm &>/dev/null; then
run_quiet_step "Installing pnpm" npm install -g pnpm
hash -r 2>/dev/null || true
fi
fi
ui_success "pnpm ready"
if [[ ! -d "$repo_dir" ]]; then
run_quiet_step "Cloning OpenACP" git clone "$repo_url" "$repo_dir"
fi
if [[ "$NO_GIT_UPDATE" != "1" ]]; then
if [[ -z "$(git -C "$repo_dir" status --porcelain 2>/dev/null || true)" ]]; then
run_quiet_step "Updating repository" git -C "$repo_dir" pull --rebase || true
else
ui_info "Repo has local changes; skipping git pull"
fi
fi
run_quiet_step "Installing dependencies" pnpm -C "$repo_dir" install
run_quiet_step "Building OpenACP" pnpm -C "$repo_dir" build
# Create wrapper script
ensure_user_local_bin_on_path
# Write wrapper using printf to safely handle any special chars in repo_dir
printf '#!/usr/bin/env bash\nset -euo pipefail\nexec node %q/dist/cli.js "$@"\n' \
"$repo_dir" >"$HOME/.local/bin/openacp"
chmod +x "$HOME/.local/bin/openacp"
ui_success "OpenACP wrapper installed to ~/.local/bin/openacp"
}
# ─── Section 7: PATH Management & Verification ────────────────────────────────
ensure_user_local_bin_on_path() {
local target="$HOME/.local/bin"
mkdir -p "$target"
export PATH="$target:$PATH"
# shellcheck disable=SC2016
local path_line='export PATH="$HOME/.local/bin:$PATH"'
for rc in "$HOME/.bashrc" "$HOME/.zshrc"; do
if [[ -f "$rc" ]] && ! grep -q ".local/bin" "$rc"; then
echo "$path_line" >> "$rc"
fi
done
}
npm_global_bin_dir() {
local prefix=""
prefix="$(npm prefix -g 2>/dev/null || true)"
if [[ -n "$prefix" && "$prefix" == /* ]]; then
echo "${prefix%/}/bin"
return 0
fi
prefix="$(npm config get prefix 2>/dev/null || true)"
if [[ -n "$prefix" && "$prefix" != "undefined" && "$prefix" != "null" && "$prefix" == /* ]]; then
echo "${prefix%/}/bin"
return 0
fi
echo ""
return 1
}
ensure_npm_global_bin_on_path() {
local bin_dir=""
bin_dir="$(npm_global_bin_dir || true)"
if [[ -n "$bin_dir" ]]; then
export PATH="${bin_dir}:$PATH"
fi
}
refresh_shell_command_cache() {
hash -r 2>/dev/null || true
}
resolve_openacp_bin() {
refresh_shell_command_cache
local resolved=""
resolved="$(type -P openacp 2>/dev/null || true)"
if [[ -n "$resolved" && -x "$resolved" ]]; then
echo "$resolved"
return 0
fi
ensure_npm_global_bin_on_path
refresh_shell_command_cache
resolved="$(type -P openacp 2>/dev/null || true)"
if [[ -n "$resolved" && -x "$resolved" ]]; then
echo "$resolved"
return 0
fi
local npm_bin=""
npm_bin="$(npm_global_bin_dir || true)"
if [[ -n "$npm_bin" && -x "${npm_bin}/openacp" ]]; then
echo "${npm_bin}/openacp"
return 0
fi
echo ""
return 1
}
verify_installation() {
if [[ "${DO_VERIFY}" != "1" ]]; then
return 0
fi
ui_info "Verifying installation..."
local bin=""
bin="$(resolve_openacp_bin || true)"
if [[ -z "$bin" ]]; then
ui_error "Verification failed: openacp not found on PATH"
return 1
fi
local version_output=""
version_output="$("$bin" --version 2>/dev/null || true)"
if [[ -n "$version_output" ]]; then
ui_success "Verified: openacp ${version_output}"
return 0
fi
ui_error "Verification failed: openacp --version returned empty"
return 1
}
# ─── Section 8: Taglines & Main ───────────────────────────────────────────────
TAGLINES=()
TAGLINES+=("AI coding agents, anywhere.")
TAGLINES+=("Your agents. Your chat. Your rules.")
TAGLINES+=("From chat to code in seconds.")
TAGLINES+=("Talk to your codebase from anywhere.")
TAGLINES+=("One bridge, every platform.")
TAGLINES+=("Agents assembled. Ready to code.")
TAGLINES+=("Your terminal just got a lot smarter.")
TAGLINES+=("Send a message. The agent writes code.")
TAGLINES+=("Code from Telegram. Review from Slack. Ship from Discord.")
TAGLINES+=("The open bridge for AI coding agents.")
pick_tagline() {
local count=${#TAGLINES[@]}
if [[ "$count" -eq 0 ]]; then
echo "$DEFAULT_TAGLINE"
return
fi
if [[ -n "${OPENACP_TAGLINE_INDEX:-}" && "${OPENACP_TAGLINE_INDEX}" =~ ^[0-9]+$ ]]; then
local idx=$((OPENACP_TAGLINE_INDEX % count))
echo "${TAGLINES[$idx]}"
return
fi
local idx=$((RANDOM % count))
echo "${TAGLINES[$idx]}"
}
TAGLINE=$(pick_tagline)
warn_path_missing() {
local dir="${1%/}"
local label="$2"
if [[ -z "$dir" ]]; then
return 0
fi
# Skip if already present in the original PATH (before nvm/npm were loaded)
case ":${ORIGINAL_PATH}:" in
*":${dir}:"*) return 0 ;;
esac
# Also skip if this dir is inside the nvm prefix — nvm adds itself to PATH via
# shell rc files automatically, so no manual PATH fix is needed.
if [[ -n "${NVM_DIR:-}" && "$dir" == "${NVM_DIR}"* ]]; then
return 0
fi
if [[ "$dir" == "${HOME}/.nvm"* ]]; then
return 0
fi
echo ""
ui_warn "PATH missing ${label}: ${dir}"
echo " This can make openacp show as \"command not found\" in new terminals."
echo " Fix (zsh: ~/.zshrc, bash: ~/.bashrc):"
echo " export PATH=\"${dir}:\$PATH\""
}
main() {
if [[ "$HELP" == "1" ]]; then
print_usage
return 0
fi
bootstrap_gum_temp || true
print_installer_banner
print_gum_status
detect_os_or_die
if [[ "$INSTALL_METHOD" != "npm" && "$INSTALL_METHOD" != "git" ]]; then
ui_error "Invalid --install-method: ${INSTALL_METHOD}"
echo "Use: --install-method npm|git"
exit 2
fi
show_install_plan
if [[ "$DRY_RUN" == "1" ]]; then
ui_success "Dry run complete (no changes made)"
return 0
fi
# ── Stage 1: Prepare environment ──
ui_stage "Preparing environment"
# Attempt to activate an existing node installation (e.g. via nvm, fnm, nodenv,
# or Homebrew) before checking whether node is present. This is necessary because
# the script may run in a non-login shell (e.g. launched from a GUI app) where
# shell rc files are never sourced and PATH-based node managers are invisible.
# If activation fails silently here that is fine — check_node / install_node below
# will handle the missing-node case.
ensure_default_node_active_shell 2>/dev/null || true
if ! check_node; then
install_node
fi
if ! ensure_default_node_active_shell; then
local active_path active_version
active_path="$(command -v node 2>/dev/null || echo "not found")"
active_version="$(node -v 2>/dev/null || echo "missing")"
ui_error "Node.js v${NODE_MIN_VERSION}+ required but found ${active_version} (${active_path})"
if [[ -n "${NVM_DIR:-}" ]] || [[ -s "${HOME}/.nvm/nvm.sh" ]]; then
print_nvm_upgrade_hint
else
echo "Install Node.js ${NODE_DEFAULT_MAJOR}+ and ensure it is first on PATH, then rerun."
fi
exit 1
fi
# ── Stage 2: Install ──
ui_stage "Installing OpenACP"
# Fix npm permissions before any npm global install, regardless of install method.
# Both "npm" and "git" paths may call `npm install -g` (pnpm, openacp).
fix_npm_permissions
if [[ "$INSTALL_METHOD" == "git" ]]; then
if ! check_git; then
install_git
if ! command -v git &>/dev/null; then
ui_error "Git installation failed. Please install git manually and rerun."
exit 1
fi
hash -r 2>/dev/null || true
fi
install_openacp_from_git "$GIT_DIR"
else
local install_spec=""
install_spec="$(resolve_package_install_spec "$INSTALL_TAG")"
install_openacp_npm "$install_spec"
fi
# ── Stage 3: Finalize ──
ui_stage "Finalizing"
local OPENACP_BIN=""
OPENACP_BIN="$(resolve_openacp_bin || true)"
if [[ "$INSTALL_METHOD" == "npm" ]]; then
local npm_bin=""
npm_bin="$(npm_global_bin_dir || true)"
warn_path_missing "$npm_bin" "npm global bin dir"
fi
if [[ "$INSTALL_METHOD" == "git" ]]; then
warn_path_missing "$HOME/.local/bin" "user-local bin dir (~/.local/bin)"
fi
if ! verify_installation; then
exit 1
fi
# ── Celebrate ──
local installed_version=""
if [[ -n "$OPENACP_BIN" ]]; then
installed_version="$("$OPENACP_BIN" --version 2>/dev/null || true)"
fi
echo ""
if [[ -n "$installed_version" ]]; then
ui_celebrate "⚡ OpenACP installed successfully (${installed_version})!"
else
ui_celebrate "⚡ OpenACP installed successfully!"
fi
local messages=(
"Your agents are ready to chat. Let's go."
"Bridging the gap between AI and humans, one message at a time."
"All set. Time to connect your first agent."
"Installation complete. Your messaging platforms await."
"Ready to roll. Run openacp to get started."
)
local msg="${messages[RANDOM % ${#messages[@]}]}"
echo -e "${MUTED}${msg}${NC}"
echo ""
if [[ "$INSTALL_METHOD" == "git" ]]; then
ui_section "Source install details"
ui_kv "Checkout" "$GIT_DIR"
ui_kv "Wrapper" "$HOME/.local/bin/openacp"
fi
# If nvm was used to install Node, the current shell session doesn't have nvm sourced yet.
# Instruct user to open a new terminal (the simplest and most reliable approach).
if [[ -s "${NVM_DIR:-${HOME}/.nvm}/nvm.sh" ]]; then
echo ""
ui_warn "Open a new terminal tab/window before running openacp"
echo " (nvm needs to be loaded, which happens automatically in new terminals)"
fi
if [[ "$NO_ONBOARD" != "1" ]]; then
if [[ -n "$OPENACP_BIN" && -r /dev/tty && -w /dev/tty ]]; then
ui_info "Starting setup wizard..."
echo ""
exec </dev/tty
exec "$OPENACP_BIN"
else
ui_info "Then run: openacp"
fi
else
ui_info "Then run: openacp"
fi
}
if [[ "${OPENACP_INSTALL_SH_NO_RUN:-0}" != "1" ]]; then
parse_args "$@"
validate_args
configure_verbose
main
fi