if have sha256sum; then sha256sum "$1" | cut -d' ' -f1

elif have shasum; then shasum -a 256 "$1" | cut -d' ' -f1

else printf ''; fi

case "$(printf '%s' "${RAVEN_NO_MIRROR:-}" | tr -d '[:space:]' | tr '[:upper:]' '[:lower:]')" in

1|true|yes|on) return 1 ;;

esac

return 0

case "${2:-000}" in

000|2??) ;;

5??) return 0 ;;

*) return 1 ;;

esac

case "$1" in

6|7|28|35|52|56|97) return 0 ;;

esac

return 1

code=0

tunnel="$(curl -sS -o /dev/null --connect-timeout 5 --max-time 10 -IL -w '%{http_connect}' "$1" 2>/dev/null)" || code=$?

! connection_failed "$code" "$tunnel"

os="$(uname -s)"

arch="$(uname -m)"

case "$os" in

Darwin) NODE_OS="darwin" ;;

Linux) NODE_OS="linux" ;;

*) die "Unsupported OS: $os (only macOS / Linux; on Windows use install.ps1)" ;;

esac

case "$arch" in

arm64|aarch64) NODE_ARCH="arm64" ;;

x86_64|amd64) NODE_ARCH="x64" ;;

*) die "Unsupported architecture: $arch" ;;

esac

if have uv; then

ok "uv already installed ($(uv --version))"

return

fi

info "uv not found, installing..."

# Fetched, then run, rather than piped: curl's exit code tells a host that

# answered with an error from one that could not be reached.

uv_fetch=0

uv_installer="$(mktemp "${TMPDIR:-/tmp}/raven-uv-installer.XXXXXX")" || die "Could not create a file for uv's installer."

uv_tunnel="$(curl -fsSL --connect-timeout 15 -w '%{http_connect}' "$UV_INSTALLER" -o "$uv_installer")" || uv_fetch=$?

if [ "$uv_fetch" -eq 0 ]; then sh "$uv_installer" || true; fi

rm -f "$uv_installer"

# uv installs to ~/.local/bin (or $XDG_BIN_HOME) -- make it visible for the

# rest of this script even before the shell profile is re-sourced.

export PATH="$HOME/.local/bin:$PATH"

if ! have uv && mirrors_allowed && ! uv_host_chosen && uv_unreachable "$uv_fetch" "$uv_tunnel"; then install_uv_from_mirror || true; fi

have uv || die "uv could not be installed, or is not where it was put; check PATH (expected in ~/.local/bin)"

ok "uv installed"

if [ "$1" -ne 0 ]; then

connection_failed "$1" "${2:-000}"

return

fi

! reachable "$PYTHON_DOWNLOADS" && ! reachable "$UV_GITHUB_RELEASE"

case "$2" in

http://*|https://*) printf '%s' "$2"; return 0 ;;

/*) printf '%s%s' "$(printf '%s' "$1" | sed 's|^\([a-z]*://[^/]*\).*|\1|')" "$2"; return 0 ;;

esac

href_base="${1%/}"

href_rest="$2"

while :; do

case "$href_rest" in

../*) href_base="${href_base%/*}"; href_rest="${href_rest#../}" ;;

./*) href_rest="${href_rest#./}" ;;

*) break ;;

esac

done

printf '%s/%s' "$href_base" "$href_rest"

case "$NODE_OS-$NODE_ARCH" in

linux-x64)

uv_tag="manylinux_2_17_x86_64"

if ldd --version 2>&1 | grep -qi musl; then uv_tag="musllinux_1_1_x86_64"; fi

;;

linux-arm64) uv_tag="manylinux_2_17_aarch64" ;;

darwin-x64) uv_tag="macosx_10_12_x86_64" ;;

darwin-arm64) uv_tag="macosx_11_0_arm64" ;;

*) return 1 ;;

esac

uv_indexes="$(uv_named_indexes)"

if [ -z "$uv_indexes" ]; then

if uv_index_chosen; then

warn "uv's installer could not reach its hosts, and the index a uv.toml names could not be read here, so uv does not come from the mirror; set UV_DEFAULT_INDEX to that index to fetch uv from it."

return 1

fi

uv_indexes="$PYPI_MIRROR"

fi

uv_work="$(mktemp -d)" || return 1

uv_href=""

set -f

for uv_index in $uv_indexes; do

uv_page="${uv_index%/}/uv/"

warn "uv's installer could not reach its hosts; fetching uv from $uv_page instead (RAVEN_NO_MIRROR=1 turns this off)."

# The newest release, compared field by field: an index lists files in

# name order, where 0.9.9 sorts after 0.13.4.

uv_href="$(

)" || uv_href=""

[ -z "$uv_href" ] || break

done

set +f

case "$uv_href" in

*'#sha256='*) uv_sha="${uv_href##*#sha256=}" ;;

*) uv_sha="" ;;

esac

uv_href="${uv_href%%#*}"

if [ -z "$uv_href" ] \

|| ! curl -fsSL --connect-timeout 15 -o "$uv_work/uv.whl" "$(resolve_href "$uv_page" "$uv_href")" \

|| { [ -n "$uv_sha" ] && [ "$(sha256_of "$uv_work/uv.whl")" != "$uv_sha" ]; }; then

rm -rf "$uv_work"

return 1

fi

if have unzip; then

unzip -q -o "$uv_work/uv.whl" -d "$uv_work/x" >/dev/null 2>&1 || { rm -rf "$uv_work"; return 1; }

elif have python3; then

python3 -m zipfile -e "$uv_work/uv.whl" "$uv_work/x" || { rm -rf "$uv_work"; return 1; }

else

rm -rf "$uv_work"

return 1

fi

mkdir -p "$HOME/.local/bin"

for exe in uv uvx; do

found="$(find "$uv_work/x" -path "*.data/scripts/$exe" -type f | head -n 1)"

if [ -n "$found" ]; then cp "$found" "$HOME/.local/bin/$exe" && chmod 755 "$HOME/.local/bin/$exe"; fi

done

rm -rf "$uv_work"

[ -x "$HOME/.local/bin/uv" ]

have node || return 1

v="$(node --version 2>/dev/null | sed 's/^v//; s/\..*//')"

[ -n "$v" ] && [ "$v" -ge "$MIN_NODE_MAJOR" ] 2>/dev/null

[ -z "$NODE_FROM" ] || return 0

NODE_FROM="$NODE_DIST"

if mirrors_allowed && ! reachable "$NODE_DIST/index.json"; then

warn "nodejs.org could not be reached; downloading Node from $NODE_MIRROR instead (RAVEN_NO_MIRROR=1 turns this off)."

NODE_FROM="$NODE_MIRROR"

fi

idx="$(curl -fsSL "$1/index.json" 2>/dev/null || true)"

ver="$(printf '%s' "$idx" | tr ',' '\n' | grep -o '"version":"v22\.[0-9.]*"' \

[ -n "$ver" ] && printf '%s' "$ver" || printf 'v22.20.0'

for n in "$NODE_RUNTIME_DIR"/node-v22*/bin/node; do

[ -x "$n" ] || continue

# Actually run it -- a half-extracted / corrupt binary is +x but won't run,

# and must NOT be mistaken for a ready runtime (else we'd never re-download).

"$n" --version >/dev/null 2>&1 && { printf '%s' "$n"; return 0; }

done

return 1

if system_node_ok; then

ok "Node.js already meets requirement ($(node --version))"

return

fi

# Already provisioned privately by a previous run?

if pn="$(private_node_bin)"; then

ok "Raven private Node already present ($pn)"

return

fi

info "Node.js >= $MIN_NODE_MAJOR not found; downloading a private runtime (does not touch the system)..."

provision_private_node

choose_node_dist

ver="$(latest_node_v22 "$NODE_FROM")"

pkg="node-${ver}-${NODE_OS}-${NODE_ARCH}"

url="$NODE_FROM/${ver}/${pkg}.tar.gz"

mkdir -p "$NODE_RUNTIME_DIR"

tmp="$(mktemp -d)"

info " $url"

curl -fsSL "$url" -o "$tmp/node.tar.gz" || die "Node download failed: $url"

# Verify the tarball against the SHASUMS256.txt published beside it before

# extracting/executing it: nodejs.org's, or the mirror's copy when the tarball

# came from the mirror, so the check catches a corrupt or truncated download.

# A tarball that cannot be verified is treated like one that fails

# verification: it is never extracted.

node_hint="Install Node.js >= ${MIN_NODE_MAJOR} with npm yourself and re-run; the installer then uses it instead of downloading one."

curl -fsSL "$NODE_FROM/${ver}/SHASUMS256.txt" -o "$tmp/SHASUMS256.txt" 2>/dev/null \

|| { rm -rf "$tmp"; die "Could not fetch SHASUMS256.txt for Node ${ver}, so the download cannot be verified. $node_hint"; }

expected="$(awk -v f="${pkg}.tar.gz" '$2==f {print $1}' "$tmp/SHASUMS256.txt")"

[ -n "$expected" ] \

|| { rm -rf "$tmp"; die "SHASUMS256.txt for Node ${ver} does not list ${pkg}.tar.gz, so the download cannot be verified. $node_hint"; }

actual="$(sha256_of "$tmp/node.tar.gz")"

[ -n "$actual" ] \

|| { rm -rf "$tmp"; die "Neither sha256sum nor shasum is available to verify the Node download. $node_hint"; }

if [ "$actual" != "$expected" ]; then

rm -rf "$tmp"

die "Node checksum mismatch (expected $expected, got $actual)"

fi

ok "Node tarball SHA256 verified"

tar -xzf "$tmp/node.tar.gz" -C "$NODE_RUNTIME_DIR"

rm -rf "$tmp"

[ -x "$NODE_RUNTIME_DIR/$pkg/bin/node" ] || die "Node executable not found after extraction"

# Run it once now: catches a libc mismatch (e.g. glibc tarball on Alpine/musl)

# at install time instead of letting `raven tui` fail later on the user's box.

"$NODE_RUNTIME_DIR/$pkg/bin/node" --version >/dev/null 2>&1 \

|| die "Downloaded Node cannot run on this machine (possible libc mismatch, e.g. Alpine/musl). Install Node >= ${MIN_NODE_MAJOR} via your system package manager."

ok "Node private runtime ready: $NODE_RUNTIME_DIR/$pkg"

# raven's find_node() globs ~/.raven/runtime/node-*/bin/node automatically,

# so no PATH change is needed for `raven tui` to find it.

artifact="$1"

shift

[ -f "$artifact" ] || return 0

for dir in "$@"; do

[ -d "$dir" ] || [ -f "$dir" ] || continue

# node_modules is rewritten by this script's own `npm ci`, which would

# leave the artifact permanently stale; dist and .modern hold build output,

# the artifact among it.

newer="$(

[ -z "$newer" ] || return 0

done

return 1

node_dir=""

blocker=""

node_bin="$(command -v node || true)"

[ -n "$node_bin" ] || node_bin="$(private_node_bin || true)"

if [ -z "$node_bin" ] || [ ! -x "$node_bin" ]; then

blocker="No usable node found"

return

fi

if PATH="$(dirname "$node_bin"):$PATH" command -v npm >/dev/null 2>&1; then

node_dir="$(dirname "$node_bin")"

return

fi

npm_node="$(private_node_bin || true)"

if [ -z "$npm_node" ]; then

info "Found node but not npm; fetching a private Node runtime that carries both..."

if ( provision_private_node ); then npm_node="$(private_node_bin || true)"; fi

fi

if [ -n "$npm_node" ] && PATH="$(dirname "$npm_node"):$PATH" command -v npm >/dev/null 2>&1; then

node_dir="$(dirname "$npm_node")"

else

blocker="Found node but not npm"

fi

if [ -z "$NPM_ANSWERS" ]; then

if reachable "$NPM_REGISTRY"; then NPM_ANSWERS=1; else NPM_ANSWERS=0; fi

fi

return 0

mirrors_allowed || return 0

[ -z "${npm_config_registry:-}${NPM_CONFIG_REGISTRY:-}" ] || return 0

# An npm that cannot say which registry it reads may be reading one the user

# chose, so only its own word for the default lets the mirror in.

configured="$(cd "$2" && PATH="$1:$PATH" npm config get registry 2>/dev/null)" || return 0

case "$configured" in

"$NPM_REGISTRY"|"${NPM_REGISTRY%/}") ;;

*) return 0 ;;

esac

npm_registry_answers

if [ "$NPM_ANSWERS" = 1 ]; then return 0; fi

warn "registry.npmjs.org could not be reached; installing packages from $NPM_MIRROR instead (RAVEN_NO_MIRROR=1 turns this off)."

printf '%s' "$NPM_MIRROR"

npm_registry_arg="$1"

npm_node_bin="$2"

npm_build_dir="$3"

shift 3

if [ -n "$npm_registry_arg" ]; then

( cd "$npm_build_dir" && PATH="$npm_node_bin:$PATH" npm_config_registry="$npm_registry_arg" "$@" )

else

( cd "$npm_build_dir" && PATH="$npm_node_bin:$PATH" "$@" )

fi

src="$1"

need_tui=0

need_page=0

if is_stale "$src/ui-tui/dist/entry.js" "$src/ui-tui"; then need_tui=1; fi

# The page inlines the shared catalogues -- the bundle reads

# i18n/messages.json and ui-shared/*.json -- so a catalogue-only change is

# a page change.

if is_stale "$src/ui-web/dist/index.html" "$src/ui-web" "$src/i18n" "$src/ui-shared"; then need_page=1; fi

[ "$need_tui" = 1 ] || [ "$need_page" = 1 ] || return 0

# One probe for both builds.

resolve_node_dir

if [ -z "$blocker" ]; then npm_registry_answers; fi

if [ "$need_tui" = 1 ]; then

if [ -n "$blocker" ]; then

warn "$blocker; skipping TUI build; raven tui may not work"

else

info "Building the TUI bundle (ui-tui/dist/entry.js)..."

npm_registry="$(use_npm_mirror "$node_dir" "$src/ui-tui")"

npm_run "$npm_registry" "$node_dir" "$src/ui-tui" npm ci \

&& npm_run "$npm_registry" "$node_dir" "$src/ui-tui" npm run build

fi

fi

if [ "$need_page" = 1 ]; then

if [ -n "$blocker" ]; then

warn "$blocker; skipping the served-page build; raven web will not start"

else

info "Building the served page (ui-web/dist/index.html)..."

# Warned rather than propagated, unlike the bundle above: bare `raven`

# opens the TUI, so a machine that cannot build the page still gets the

# surface this script exists to deliver.

build_page "$src" "$node_dir" \

|| warn "The served page did not build (see above); raven web will not start"

fi

fi

npm_registry="$(use_npm_mirror "$2" "$1/ui-web")"

npm_run "$npm_registry" "$2" "$1/ui-web" npm ci \

&& npm_run "$npm_registry" "$2" "$1/ui-web" npm run build \

&& uv run --no-project python "$1/ui-web/build.py"

if [ -n "${UV_CONFIG_FILE:-}" ]; then

printf '%s\n' "$UV_CONFIG_FILE"

return

fi

uv_ifs="$IFS"

IFS=:

set -f

set -- ${XDG_CONFIG_HOME:-$HOME/.config} ${XDG_CONFIG_DIRS:-/etc/xdg} /etc

set +f

IFS="$uv_ifs"

for uv_root in "$@"; do

printf '%s/uv/uv.toml\n' "$uv_root"

done

LC_ALL=C awk '

' "$1"

uv_config_files | {

while IFS= read -r uv_file; do

[ -f "$uv_file" ] && uv_config_text "$uv_file" | grep -Eq "$1" && exit 0

done

exit 1

}

uv_config_files | while IFS= read -r uv_file; do

[ -f "$uv_file" ] || continue

uv_found="$(LC_ALL=C awk '

if [ -n "$uv_found" ]; then

printf '%s\n' "$uv_found"

break

fi

done

[ -n "${UV_DEFAULT_INDEX:-}${UV_INDEX_URL:-}${UV_INDEX:-}" ] && return 0

uv_config_has '^[[:space:]]*"?index-url"?[[:space:]]*=' && return 0

# A default index is marked default = true, in an [[index]] table or inline.

uv_config_has '(^|[{,[:space:]]*)"?default"?[[:space:]]*=[[:space:]]*true'

set -f

for uv_entry in ${UV_INDEX:-}; do

printf '%s\n' "$uv_entry" | sed 's/^[A-Za-z0-9._-]*=//'

done

set +f

if [ -n "${UV_DEFAULT_INDEX:-}" ]; then

printf '%s\n' "$UV_DEFAULT_INDEX"

elif [ -n "${UV_INDEX_URL:-}" ]; then

printf '%s\n' "$UV_INDEX_URL"

else

uv_config_index

fi

mirrors_allowed || return 0

if ! uv_index_chosen && ! reachable "$PYPI_INDEX"; then

warn "pypi.org could not be reached; installing packages from $PYPI_MIRROR instead (RAVEN_NO_MIRROR=1 turns this off)."

use_mirror UV_DEFAULT_INDEX "$PYPI_MIRROR"

fi

# A Python source the user named counts in each form uv reads: a mirror it is

# given outranks a copy of releases.astral.sh, and fails outright beside a

# list of downloads that live elsewhere.

if [ -z "${UV_PYTHON_INSTALL_MIRROR:-}${UV_PYTHON_DOWNLOADS_JSON_URL:-}${UV_ASTRAL_MIRROR_URL:-}" ] \

&& ! uv_config_has '^[[:space:]]*"?python-(install-mirror|downloads-json-url)"?[[:space:]]*=' \

&& ! reachable "$PYTHON_DOWNLOADS"; then

warn "releases.astral.sh could not be reached; fetching any Python uv needs from $PYTHON_MIRROR instead (RAVEN_NO_MIRROR=1 turns this off)."

use_mirror UV_PYTHON_INSTALL_MIRROR "$PYTHON_MIRROR"

fi

use_package_mirrors

# Local mode: run from a raven source checkout -> editable install of the

# working tree (what a developer wants). Otherwise install the release wheel.

#

# "$0" names a real file only when this script runs as a file

# (./install.sh). Piped through `curl ... | sh` the script arrives on stdin,

# "$0" is "sh" and dirname "$0" is "." -- taking that as the source dir turns

# a one-line install started from inside a clone into a silent editable

# install of that working tree, whatever it happens to contain. So local mode

# requires "$0" to be a file; RAVEN_LOCAL_SRC is the explicit opt-in for a

# piped run.

script_dir=""

if [ -n "${RAVEN_LOCAL_SRC:-}" ]; then

script_dir="$(CDPATH= cd -- "$RAVEN_LOCAL_SRC" 2>/dev/null && pwd || true)"

[ -n "$script_dir" ] || die "RAVEN_LOCAL_SRC is not a directory: $RAVEN_LOCAL_SRC"

is_raven_source "$script_dir" || die "RAVEN_LOCAL_SRC is not a raven source checkout: $script_dir"

elif [ -f "$0" ]; then

script_dir="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"

is_raven_source "$script_dir" || script_dir=""

fi

if [ -n "$script_dir" ]; then

info "Local raven source detected; editable install: $script_dir"

build_web_assets "$script_dir"

# Pin to the locked dependency set so an install matches what we test.

constraints="$(mktemp)"

uv export -q --directory "$script_dir" --frozen --all-extras --no-hashes --no-emit-workspace -o "$constraints"

# Install all channel adapters by default. If the umbrella extra fails to

# resolve/build on this platform, fall back to base raven so one broken

# channel SDK cannot block the whole install.

# The default config names the everos memory backend, and a user can point

# memory at the hosted EverOS instead; each ships as its own distribution

# beside the wheel -- carry both, and degrade loudly (the host boots

# memoryless and `raven doctor` says why) if they cannot build.

memory_dir="$script_dir/plugins-dist/everos-memory"

cloud_dir="$script_dir/plugins-dist/everos-cloud-memory"

# Raven-Design and Raven-PPT keep their harness in a distribution too, and

# the roster gates on it: discovery reads the `engine` block in each

# agents/<product>/subagent.json and disables the row when that package is

# not importable where raven runs. Installing raven without them therefore

# yields two agents that are listed and cannot be dispatched to, with the

# remedy stated nowhere the installer ran.

design_dir="$script_dir/plugins-dist/design-engine"

ppt_dir="$script_dir/plugins-dist/ppt-engine"

# tool_install <target> [<plugin dir>...]. The directories ride in the

# positional parameters rather than in one string: sh has no arrays, and a

# checkout path holding a space must stay one argv entry -- encoding the

# option/path pairs into a scalar splits every one of them and ends the

# ladder at bare raven with no plugin installed. The loop rotates the list

# in place, taking each directory off the front and appending its option

# pair to the back, so what remains is exactly the pairs.

tool_install() {

spec="$1"

shift

remaining=$#

while [ "$remaining" -gt 0 ]; do

set -- "$@" --with-editable "$1"

shift

remaining=$((remaining - 1))

done

uv tool install --force -c "$constraints" "$@" -e "$spec"

}

# Four rungs, dropping one capability each: the engines carry native

# builds (PDF, raster, plotting) that a platform can refuse on its own, so

# they fall before the memory plugins rather than taking them down too.

if ! tool_install "$script_dir[channels]" "$memory_dir" "$cloud_dir" "$design_dir" "$ppt_dir"; then

warn "Channel dependencies failed to install; retrying with base raven. Some channels stay unavailable (see: raven channels list)."

if ! tool_install "$script_dir" "$memory_dir" "$cloud_dir" "$design_dir" "$ppt_dir"; then

warn "A product engine failed to build; Raven-Design and Raven-PPT stay disabled (raven doctor explains)."

if ! tool_install "$script_dir" "$memory_dir" "$cloud_dir"; then

warn "The EverOS memory plugins failed to install; long-term memory stays off (raven doctor explains)."

tool_install "$script_dir"

fi

fi

fi

else

# Remote mode: install the latest published release wheel, which bundles

# the prebuilt ui-tui/dist/entry.js (built by CI). We deliberately do NOT

# install from git here -- the TUI bundle is a gitignored build artifact,

# so a git install would yield a raven whose `raven tui` cannot start.

# Override RAVEN_WHEEL_URL to pin a specific wheel.

#

# One discovery step, no GitHub API: the release page redirect names the

# latest stable tag, and everything else is derived from it, because the

# wheel, the locked constraints and the plugin list sit in one release

# directory. The API caps unauthenticated callers at 60 requests/hour per

# IP, which a shared egress exhausts, and its JSON was only ever grepped

# for file names.

wheel_url="${RAVEN_WHEEL_URL:-}"

if [ -z "$wheel_url" ]; then

info "Resolving the latest raven release from GitHub..."

tag="$(curl -fsS -o /dev/null -w '%{redirect_url}' \

"https://github.com/EverMind-AI/Raven/releases/latest")" || tag=""

# Same shape the CLI and install.ps1 enforce: the redirect must land on this

# repository's tag page, and the version must be exactly three numeric fields

# with no leading zeros.

case "$tag" in

https://github.com/EverMind-AI/Raven/releases/tag/v*) version="${tag##*/}" ;;

*) version="" ;;

esac

version="${version#v}"

case "$version" in

*.*.*.*) version="" ;;

*.*.*) ;;

*) version="" ;;

esac

if [ -n "$version" ]; then

v_rest="${version#*.}"

for field in "${version%%.*}" "${v_rest%%.*}" "${v_rest#*.}"; do

case "$field" in

""|*[!0-9]*|0[0-9]*) version="" ;;

esac

done

fi

if [ -n "$version" ]; then

wheel_url="https://github.com/EverMind-AI/Raven/releases/download/v${version}/raven-${version}-py3-none-any.whl"

fi

fi

[ -n "$wheel_url" ] || die "Could not resolve the latest raven release wheel from GitHub. Retry later, or set RAVEN_WHEEL_URL to a wheel URL."

release_dir="${wheel_url%/*}"

# The locked constraints from the same release directory, so they always

# match the wheel being installed, including when RAVEN_WHEEL_URL pins an

# older wheel. Missing asset / download failure -> install without pinning

# rather than fail.

constraints="$(mktemp)"

c_args=""

if curl -fsSL "${RAVEN_CONSTRAINTS_URL:-$release_dir/raven-constraints.txt}" -o "$constraints" 2>/dev/null; then

c_args="-c $constraints"

else

warn "Could not download locked constraints; installing without version pinning."

fi

# The plugin list: the wheels this release ships beside raven, one

# `name @ url` line each, written by the release workflow from what it

# built. What a complete install is made of lives there, not here, and

# `raven upgrade` installs from the same file. A release without one

# (0.1.13 and older) installs raven alone, as it always did.

plugins="$(mktemp)"

memory_only="$(mktemp)"

p_args=""

m_args=""

if curl -fsSL "$release_dir/raven-plugins.txt" -o "$plugins" 2>/dev/null && grep -q '[^[:space:]]' "$plugins"; then

info " with the release's plugins:"

sed 's/^/ /' "$plugins"

# Both option pairs expand unquoted below and must stay two words each;

# mktemp paths carry no spaces.

p_args="--with-requirements $plugins"

grep -E '^(everos-memory|everos-cloud-memory) ' "$plugins" > "$memory_only" || true

if [ -s "$memory_only" ] && ! cmp -s "$plugins" "$memory_only"; then

m_args="--with-requirements $memory_only"

fi

else

warn "This release carries no plugin list; long-term memory, Raven-Design and Raven-PPT stay off (raven doctor explains)."

fi

info " installing $wheel_url"

# shellcheck disable=SC2086 # $c_args and $1 are intentional word-split option pairs.

install_rung() {

uv tool install --force $c_args $1 "$2"

}

# Two independent things can fail: the channel extras, and the plugins

# (the engines' native builds first, the memory plugin after). A failed

# attempt does not say which, so the rungs walk both axes and stop at the

# first that lands -- the largest install this machine can build -- and

# warn about exactly what that rung lacks:

# 1 channels + all plugins 4 base + memory plugin

# 2 base + all plugins 5 channels, no plugins

# 3 channels + memory plugin 6 base, no plugins

lost_channels="Channel dependencies failed to install; some channels stay unavailable (see: raven channels list)."

lost_engines="A product engine failed to install; Raven-Design and Raven-PPT stay disabled (raven doctor explains)."

lost_plugins="No plugin could be installed; long-term memory, Raven-Design and Raven-PPT stay off (raven doctor explains)."

if install_rung "$p_args" "raven[channels] @ $wheel_url"; then

:

elif install_rung "$p_args" "$wheel_url"; then

warn "$lost_channels"

elif [ -n "$m_args" ] && install_rung "$m_args" "raven[channels] @ $wheel_url"; then

warn "$lost_engines"

elif [ -n "$m_args" ] && install_rung "$m_args" "$wheel_url"; then

warn "$lost_engines"

warn "$lost_channels"

elif [ -n "$p_args" ] && install_rung "" "raven[channels] @ $wheel_url"; then

warn "$lost_plugins"

elif [ -n "$p_args" ] && install_rung "" "$wheel_url"; then

warn "$lost_plugins"

warn "$lost_channels"

else

die "Raven install failed."

fi

fi

# Ensure ~/.local/bin (uv tool bin dir) is on PATH for future shells.

uv tool update-shell || true

ok "raven installed"

# The browser tool drives chromium through the playwright library inside the

# raven tool venv, so both the probe and the download must use that venv's

# python -- the system python knows nothing about this install.

py="$(uv tool dir 2>/dev/null || true)/raven/bin/python"

if [ ! -x "$py" ]; then

warn "raven tool venv python not found; skipping the chromium download."

return 0

fi

# A pinned RAVEN_WHEEL_URL and the release-page fallback install no engine

# wheels, so playwright can be absent even after a green install.

if ! "$py" -c "import playwright" 2>/dev/null; then

warn "This install carries no browser library (a pinned wheel URL or the release-page fallback installs no engines); the browser tool stays off."

return 0

fi

info "Downloading chromium for the browser tool..."

# On Linux chromium may additionally need system libraries; playwright prints

# the exact sudo command for them (--with-deps). We never run sudo ourselves.

if "$py" -m playwright install chromium; then return 0; fi

# Playwright tries its own hosts in turn and reports only that none of them

# delivered, so the mirror gets one retry after the whole download failed --

# unless the user named a download host, or one of those hosts answered.

if mirrors_allowed && [ -z "${PLAYWRIGHT_DOWNLOAD_HOST:-}${PLAYWRIGHT_CHROMIUM_DOWNLOAD_HOST:-}" ] \

&& ! playwright_answers; then

warn "Chromium could not be downloaded; trying $PLAYWRIGHT_MIRROR instead (RAVEN_NO_MIRROR=1 turns this off)."

if PLAYWRIGHT_DOWNLOAD_HOST="$PLAYWRIGHT_MIRROR" "$py" -m playwright install chromium; then return 0; fi

fi

warn "Chromium download failed; the browser tool stays off. Retry later with: $py -m playwright install chromium"

for playwright_host in $PLAYWRIGHT_HOSTS; do

reachable "$playwright_host" && return 0

done

return 1

py="$(uv tool dir 2>/dev/null || true)/raven/bin/python"

if [ ! -x "$py" ]; then

warn "raven tool venv python not found; skipping the resource download."

return 0

fi

info "Downloading the word dictionary and parser models..."

"$py" -m raven.resources --optional \

|| warn "Resource download failed; raven still runs. Retry later with: raven resources"