#!/bin/sh

# install.sh — agentty universal installer

#

# Usage:

# curl -fsSL https://raw.githubusercontent.com/1ay1/agentty/master/install.sh | sh

# curl -fsSL https://raw.githubusercontent.com/1ay1/agentty/master/install.sh | sh -s -- --prefix ~/.local

# curl -fsSL https://raw.githubusercontent.com/1ay1/agentty/master/install.sh | sh -s -- --version v0.2.0

# curl -fsSL https://raw.githubusercontent.com/1ay1/agentty/master/install.sh | sh -s -- --build --prefix ~/.local

#

# Detects OS+arch, downloads the matching binary from the GitHub release,

# verifies SHA256, installs to $PREFIX/bin (default /usr/local/bin or ~/.local/bin

# when not root). No build toolchain required.

#

# --build compiles from source instead of downloading a prebuilt binary — use

# it when the prebuilt artifact is broken or incompatible with your libc (e.g.

# a musl static binary that segfaults on glibc). Needs a C++26 toolchain

# (GCC 14+ / Clang 18+), CMake 3.28+, git, plus libssl-dev + libnghttp2-dev.

# The installer also auto-falls-back to a source build if the downloaded

# binary won't run on this system.

#

# Source builds default to -j2 (low RAM/CPU footprint — safe on Termux/phones

# where each template-heavy TU peaks near ~1.5 GB). Override with

# AGENTTY_BUILD_JOBS, e.g.

# AGENTTY_BUILD_JOBS=8 curl -fsSL .../install.sh | sh -s -- --build # faster, more cores

# AGENTTY_BUILD_JOBS=1 curl -fsSL .../install.sh | sh -s -- --build # RAM-starved

set -eu

REPO="1ay1/agentty"

VERSION="latest"

# Capture Termux's exported $PREFIX (…/com.termux/files/usr) BEFORE we clear our

# own PREFIX var below — it's the correct, on-PATH install root on Android.

TERMUX_PREFIX_ENV="${PREFIX:-}"

PREFIX=""

BIN_NAME="agentty"

BUILD=0

err() { printf 'install.sh: %s\n' "$*" >&2; exit 1; }

info() { printf '\033[1;34m::\033[0m %s\n' "$*"; }

ok() { printf '\033[1;32m✓\033[0m %s\n' "$*"; }

have() { command -v "$1" >/dev/null 2>&1; }

# build_from_source PREFIX VERSION

# Clones the repo at the requested ref and compiles a binary into $PREFIX/bin.

# Used when --build is given, or as an automatic fallback when a downloaded

# prebuilt binary won't run on this system (wrong libc, no PT_INTERP, etc).

build_from_source() {

_bfs_prefix="$1"

_bfs_version="$2"

_bfs_bindir="$_bfs_prefix/bin"

have git || err "--build needs git installed"

have cmake || err "--build needs cmake (3.28+) installed"

if ! have g++ && ! have clang++; then

err "--build needs a C++26 compiler (g++ 14+ or clang++ 18+)"

fi

# Resolve the git ref. "latest" builds the default branch tip; a pinned

# version like v0.2.0 checks out that tag.

if [ "$_bfs_version" = "latest" ]; then

_bfs_ref="master"

else

_bfs_ref="$_bfs_version"

fi

_bfs_src=$(mktemp -d)

# Don't clobber a $tmp cleanup the download path may have installed — remove

# both on exit.

# shellcheck disable=SC2064

trap "rm -rf '$_bfs_src' \"\${tmp:-}\"" EXIT

info "cloning $REPO ($_bfs_ref) for source build"

git clone --recursive --depth 1 --branch "$_bfs_ref" \

"https://github.com/$REPO.git" "$_bfs_src" 2>/dev/null \

|| git clone --recursive --depth 1 \

"https://github.com/$REPO.git" "$_bfs_src" \

|| err "git clone failed"

info "configuring (Release, standalone)"

cmake -S "$_bfs_src" -B "$_bfs_src/build" \

-DCMAKE_BUILD_TYPE=Release -DAGENTTY_STANDALONE=ON \

|| err "cmake configure failed - install a C++26 toolchain + libssl-dev + libnghttp2-dev"

info "compiling (this can take a few minutes)"

# Default to 2 parallel jobs, not nproc: this tree is template-heavy and

# each TU peaks at ~1-1.5 GB, so -j$(nproc) OOM-kills phones (Termux) and

# small VMs. 2 is a safe low-footprint default; override with e.g.

# AGENTTY_BUILD_JOBS=8 ... (more cores) or AGENTTY_BUILD_JOBS=1 (RAM-starved)

_bfs_jobs="${AGENTTY_BUILD_JOBS:-2}"

cmake --build "$_bfs_src/build" -j"$_bfs_jobs" || err "build failed"

_bfs_bin="$_bfs_src/build/agentty"

[ -x "$_bfs_bin" ] || _bfs_bin="$_bfs_src/build/$BIN_NAME"

[ -x "$_bfs_bin" ] || err "build produced no binary at $_bfs_src/build/agentty"

mkdir -p "$_bfs_bindir"

chmod +x "$_bfs_bin"

mv "$_bfs_bin" "$_bfs_bindir/$BIN_NAME"

ok "built + installed $_bfs_bindir/$BIN_NAME"

}

# fetch URL to stdout, trying curl then wget

fetch() {

if have curl; then

curl -fsSL "$1"

elif have wget; then

wget -qO- "$1"

else

err "need curl or wget installed"

fi

}

# download URL to a file ($2), trying curl then wget

download() {

if have curl; then

curl -fsSL "$1" -o "$2"

elif have wget; then

wget -q "$1" -O "$2"

else

err "need curl or wget installed"

fi

}

while [ $# -gt 0 ]; do

case "$1" in

--version) VERSION="$2"; shift 2 ;;

--prefix) PREFIX="$2"; shift 2 ;;

--build) BUILD=1; shift 1 ;;

-h|--help)

sed -n '2,26p' "$0" | sed 's/^# \{0,1\}//'

exit 0 ;;

*) err "unknown arg: $1" ;;

esac

done

# --- detect os/arch -----------------------------------------------------------

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

arch=$(uname -m)

case "$os" in

linux) os=linux ;;

darwin) os=darwin ;;

msys*|mingw*|cygwin*) os=windows ;;

*) err "unsupported OS: $os" ;;

esac

case "$arch" in

x86_64|amd64) arch=x86_64 ;;

aarch64|arm64) arch=aarch64 ;;

*) err "unsupported arch: $arch" ;;

esac

# --- build candidate asset suffixes -------------------------------------------

# Release assets are named like "agentty-<version>-<os>-<arch>" (and historically

# a few unversioned "agentty-<os>-<arch>"). OS/arch tokens have varied across

# releases (darwin vs macos, aarch64 vs arm64), so we try a list of plausible

# suffixes in priority order and take the first match.

if [ "$os" = "windows" ]; then

suffixes="windows-${arch}.exe windows-amd64.exe"

BIN_NAME="agentty.exe"

elif [ "$os" = "darwin" ]; then

case "$arch" in

aarch64) suffixes="macos-arm64 darwin-arm64 macos-aarch64 darwin-aarch64" ;;

*) suffixes="macos-${arch} darwin-${arch} macos-amd64 darwin-amd64" ;;

esac

else

case "$arch" in

aarch64) suffixes="linux-aarch64 linux-arm64" ;;

*) suffixes="linux-${arch} linux-amd64" ;;

esac

fi

# --- pick prefix (needed by both the build path and the download path) --------

if [ -z "$PREFIX" ]; then

if [ -n "${TERMUX_VERSION:-}" ] || [ -d /data/data/com.termux/files/usr ]; then

# Termux/Android: $PREFIX (…/com.termux/files/usr) is the ONLY dir on

# the default PATH. /usr/local and ~/.local don't exist / aren't on PATH,

# so installing there leaves `agentty` uncallable. Prefer the exported

# $PREFIX we captured at startup; fall back to the canonical path.

PREFIX="${TERMUX_PREFIX_ENV:-/data/data/com.termux/files/usr}"

elif [ "$(id -u)" -eq 0 ]; then

PREFIX=/usr/local

else

PREFIX="$HOME/.local"

fi

fi

bindir="$PREFIX/bin"

# --- explicit source build ----------------------------------------------------

# --build skips the prebuilt artifact entirely. Also the right recovery when a

# release binary is broken for your libc (e.g. v0.2.7's musl static binary

# segfaulting on glibc).

if [ "$BUILD" -eq 1 ]; then

build_from_source "$PREFIX" "$VERSION"

case ":$PATH:" in

*":$bindir:"*) ;;

*) printf '\n\033[1;33m!\033[0m %s\n' "add $bindir to PATH:"

printf ' export PATH=\"%s:\$PATH\"\n\n' "$bindir" ;;

esac

ok "run: $BIN_NAME"

exit 0

fi

# --- resolve release + asset URL via GitHub API -------------------------------

# The GitHub "latest/download/<name>" redirect only works for assets whose names

# are stable across releases; ours embed the version, so we query the API to get

# the real browser_download_url. Falls back to a constructed URL if the API is

# unavailable (e.g. rate-limited).

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

api_url="https://api.github.com/repos/$REPO/releases/latest"

else

api_url="https://api.github.com/repos/$REPO/releases/tags/$VERSION"

fi

info "resolving release ($VERSION) for $os/$arch"

api_json=$(fetch "$api_url" 2>/dev/null) || api_json=""

asset_url=""

sums_url=""

if [ -n "$api_json" ]; then

# Extract every browser_download_url, then pick the asset whose filename ends

# in one of our candidate suffixes. The '-' before the suffix keeps

# "linux-aarch64" from satisfying a "linux-x86_64" request, etc.

urls=$(printf '%s\n' "$api_json" \

| grep -o '"browser_download_url": *"[^"]*"' \

| sed 's/.*": *"//; s/"$//')

sums_url=$(printf '%s\n' "$urls" | grep -E '/SHA256SUMS$' | head -n1)

for sfx in $suffixes; do

asset_url=$(printf '%s\n' "$urls" | grep -E "/agentty(-[0-9][^/]*)?-${sfx}$" | head -n1)

[ -n "$asset_url" ] && break

done

fi

# Fallback: construct the legacy unversioned URL if the API gave us nothing.

if [ -z "$asset_url" ]; then

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

base="https://github.com/$REPO/releases/latest/download"

else

base="https://github.com/$REPO/releases/download/$VERSION"

fi

set -- $suffixes

asset_url="$base/agentty-$1"

sums_url="$base/SHA256SUMS"

info "GitHub API unavailable — falling back to $asset_url"

fi

asset=$(basename "$asset_url")

mkdir -p "$bindir"

# --- download + verify --------------------------------------------------------

tmp=$(mktemp -d)

trap 'rm -rf "$tmp"' EXIT

info "downloading $asset"

download "$asset_url" "$tmp/$asset" || err "download failed: $asset_url"

[ -s "$tmp/$asset" ] || err "downloaded file is empty: $asset_url"

if [ -n "$sums_url" ] && download "$sums_url" "$tmp/SHA256SUMS" 2>/dev/null; then

:

else

info "no SHA256SUMS published for $VERSION — skipping checksum verification"

SKIP_SUMS=1

fi

if [ -z "${SKIP_SUMS:-}" ]; then

info "verifying SHA256"

expected=$(grep " $asset\$" "$tmp/SHA256SUMS" | awk '{print $1}')

if [ -z "$expected" ]; then

info "no checksum line for $asset in SHA256SUMS — skipping verification"

elif have sha256sum; then

actual=$(sha256sum "$tmp/$asset" | awk '{print $1}')

[ "$expected" = "$actual" ] || err "checksum mismatch

expected $expected

actual $actual"

ok "checksum verified"

elif have shasum; then

actual=$(shasum -a 256 "$tmp/$asset" | awk '{print $1}')

[ "$expected" = "$actual" ] || err "checksum mismatch

expected $expected

actual $actual"

ok "checksum verified"

else

info "no sha256sum/shasum tool — skipping checksum verification"

fi

fi

# --- detect prior install (so updates announce themselves) -------------------

prior_version=""

if [ -x "$bindir/$BIN_NAME" ]; then

prior_version=$("$bindir/$BIN_NAME" --version 2>/dev/null | awk '/^agentty / {print $2}')

fi

chmod +x "$tmp/$asset"

mv "$tmp/$asset" "$bindir/$BIN_NAME"

new_version=$("$bindir/$BIN_NAME" --version 2>/dev/null | awk '/^agentty / {print $2}')

# The downloaded binary may be incompatible with this system — a musl static

# build with no PT_INTERP can segfault on glibc, or an arch/ABI mismatch slips

# past detection. If it won't even print its version, recover by building from

# source rather than leaving a broken binary in place. (Skip on Windows: no

# in-place toolchain assumption, and cross-exec checks don't apply here.)

if [ -z "$new_version" ] && [ "$os" != "windows" ]; then

info "prebuilt binary won't run on this system — falling back to a source build"

rm -f "$bindir/$BIN_NAME"

build_from_source "$PREFIX" "$VERSION"

new_version=$("$bindir/$BIN_NAME" --version 2>/dev/null | awk '/^agentty / {print $2}')

fi

if [ -n "$prior_version" ] && [ -n "$new_version" ] && [ "$prior_version" != "$new_version" ]; then

ok "updated $bindir/$BIN_NAME $prior_version → $new_version"

elif [ -n "$prior_version" ] && [ "$prior_version" = "$new_version" ]; then

ok "already on $new_version (reinstalled $bindir/$BIN_NAME)"

else

ok "installed $bindir/$BIN_NAME${new_version:+ ($new_version)}"

fi

# --- PATH hint ----------------------------------------------------------------

case ":$PATH:" in

*":$bindir:"*) ;;

*) printf '\n\033[1;33m!\033[0m %s\n' "add $bindir to PATH:"

printf ' export PATH=\"%s:\$PATH\"\n\n' "$bindir" ;;

esac

ok "run: $BIN_NAME"