#!/usr/bin/env bash # install.sh - installs Archie Core for the current user. # # curl -fsSL https://offloaded.dev/install.sh | bash # # Downloads a release from its OCI registry, verifies the release key signed # it and that the zip is the one signed, installs the # five services to ${XDG_BIN_HOME:-~/.local/bin}, runs `archied setup`, starts # the bundled PostgreSQL and installs systemd user units. # Config: ${XDG_CONFIG_HOME:-~/.config}/archie Data: ${XDG_DATA_HOME:-~/.local/share}/archie set -euo pipefail MODULE="github.com/samcharles93/archie-core" SOURCE_GIT="https://git.catlow.cloud/sam/archie.git" # Where releases come from: an OCI repository and the base64 ed25519 key that # must have signed them. A self-hosted source sets both. DEFAULT_RELEASES="git.catlow.cloud/sam/archie" DEFAULT_RELEASE_KEY="gIBqoQMwy+8WXmGfiuHtnUa50W0IqfzkTR6iF5q3dSM=" ARCHIE_RELEASES="${ARCHIE_RELEASES:-${DEFAULT_RELEASES}}" ARCHIE_RELEASE_KEY="${ARCHIE_RELEASE_KEY:-${DEFAULT_RELEASE_KEY}}" ARCHIE_CHANNEL="${ARCHIE_CHANNEL:-stable}" XDG_CONFIG_HOME="${XDG_CONFIG_HOME:-${HOME}/.config}" XDG_DATA_HOME="${XDG_DATA_HOME:-${HOME}/.local/share}" XDG_BIN_HOME="${XDG_BIN_HOME:-${HOME}/.local/bin}" ARCHIE_BIN_DIR="${XDG_BIN_HOME}" INSTANCE=archie PORT_BASE="" INSTALL_SYSTEMD=true ENABLE_LINGER=true AUTO_START=true FROM_SOURCE=false # Piped into bash, stdin is the script; setup reads its answers from the # terminal instead, so a pipe can still be interactive. INTERACTIVE=false if (: /dev/null; then INTERACTIVE=true; fi usage() { cat </NAME and its units end in -X --port-base N Use ports N..N+6 for web, health, gateway, state store, state store readiness, messaging and daemon --no-systemd Skip systemd user units --no-linger Skip loginctl enable-linger --no-start Install the units but do not start them --non-interactive Write an unattended config (no forge, Ollama) --help, -h Show this help EOF } VERSION="" while [ $# -gt 0 ]; do case "$1" in --version) VERSION="${2:?--version needs a value}"; shift ;; --instance) INSTANCE="${2:?--instance needs a value}"; shift ;; --port-base) PORT_BASE="${2:?--port-base needs a value}"; shift ;; --from-source) FROM_SOURCE=true ;; --no-systemd) INSTALL_SYSTEMD=false; AUTO_START=false ;; --no-linger) ENABLE_LINGER=false ;; --no-start) AUTO_START=false ;; --non-interactive|--batch) INTERACTIVE=false ;; --help|-h) usage; exit 0 ;; *) echo "Error: unknown option '$1'" >&2; usage >&2; exit 1 ;; esac shift done if ! [[ "${INSTANCE}" =~ ^archie(-[a-z0-9][a-z0-9-]{0,23})?$ ]]; then echo "Error: --instance '${INSTANCE}' must be archie or archie-, e.g. archie-dev" >&2; exit 1 fi if [ -n "${PORT_BASE}" ] && ! { [[ "${PORT_BASE}" =~ ^[0-9]+$ ]] && [ "${PORT_BASE}" -ge 1024 ] && [ "${PORT_BASE}" -le 65529 ]; }; then echo "Error: --port-base must be a number from 1024 to 65529" >&2; exit 1 fi export ARCHIE_INSTANCE="${INSTANCE}" ARCHIE_CONFIG_DIR="${XDG_CONFIG_HOME}/${INSTANCE}" ARCHIE_DATA_DIR="${XDG_DATA_HOME}/${INSTANCE}" ENV_FILE="${ARCHIE_CONFIG_DIR}/env" # The database roles a bundled install serves from: the least-privilege role # the services connect as, and the role that owns the schema and runs # migrations. The names mirror postgres.RuntimeRole/MigrationRole, which setup # writes into the bundled configuration. RUNTIME_ROLE=archie_runtime MIGRATION_ROLE=archie_migrator # The credential the bundled PostgreSQL is created with and the installer uses # once, to create the two roles. It lives in this Compose-only file, which the # systemd units never load, so no service holds a credential that owns the # cluster. PG_ADMIN_ENV="${ARCHIE_DATA_DIR}/postgres.env" # unit maps a base unit name to this instance's: unchanged for the default # instance, suffixed with the name after archie- otherwise. unit() { if [ "${INSTANCE}" = archie ]; then echo "$1"; else echo "$1-${INSTANCE#archie-}"; fi } U_DAEMON="$(unit archied)" U_STATE="$(unit archie-state-store)" U_GATEWAY="$(unit archie-gateway)" U_UI="$(unit archie-ui)" U_MESSAGING="$(unit archie-messaging)" # Ports in --port-base order; without it, today's defaults. if [ -n "${PORT_BASE}" ]; then P_WEB=${PORT_BASE}; P_HEALTH=$((PORT_BASE + 1)); P_GATEWAY=$((PORT_BASE + 2)) P_STATE=$((PORT_BASE + 3)); P_READY=$((PORT_BASE + 4)); P_MESSAGING=$((PORT_BASE + 5)); P_DAEMON=$((PORT_BASE + 6)) else P_WEB=8484; P_HEALTH=8485; P_GATEWAY=8585; P_STATE=9090; P_READY=9091; P_MESSAGING=8586; P_DAEMON=8587 fi need() { for cmd in "$@"; do command -v "$cmd" &>/dev/null || { echo "Error: '$cmd' is required but not installed." >&2; exit 1; } done } # install_release fetches the release on ARCHIE_CHANNEL (or VERSION) from # ARCHIE_RELEASES and unpacks it into TMP: the statement must verify against # ARCHIE_RELEASE_KEY and the zip must hash to the digest the statement names. install_release() { local registry="${ARCHIE_RELEASES%%/*}" repo="${ARCHIE_RELEASES#*/}" scheme=https tag="${ARCHIE_CHANNEL}" case "${registry}" in localhost | localhost:* | 127.* | "[::1]"*) scheme=http ;; esac [ -n "${VERSION}" ] && tag="v${VERSION#v}" local base="${scheme}://${registry}/v2/${repo}" auth=() # Registries hand anonymous readers a pull token named by the challenge. local challenge challenge="$(curl -fsS -o /dev/null -D - "${base}/manifests/${tag}" 2>/dev/null | tr -d '\r' | sed -n 's/^[Ww][Ww][Ww]-[Aa]uthenticate: *Bearer *//p')" || true if [ -n "${challenge}" ]; then local realm service token realm="$(sed -n 's/.*realm="\([^"]*\)".*/\1/p' <<<"${challenge}")" service="$(sed -n 's/.*service="\([^"]*\)".*/\1/p' <<<"${challenge}")" token="$(curl -fsSL -G "${realm}" --data-urlencode "service=${service}" --data-urlencode "scope=repository:${repo}:pull" | jq -r '.token // .access_token')" auth=(-H "Authorization: Bearer ${token}") fi echo "==> Fetching ${ARCHIE_RELEASES}:${tag}..." curl -fsSL "${auth[@]}" -H "Accept: application/vnd.oci.image.manifest.v1+json" "${base}/manifests/${tag}" -o "${TMP}/manifest.json" blob() { curl -fsSL "${auth[@]}" "${base}/blobs/$1" -o "$2" && [ "sha256:$(sha256sum "$2" | cut -d' ' -f1)" = "$1" ]; } local statement_digest statement_digest="$(jq -er '.layers[0].digest' "${TMP}/manifest.json")" blob "${statement_digest}" "${TMP}/statement.json" || { echo "Error: the release statement does not match its digest." >&2; exit 1; } jq -er '.annotations["dev.archie.release.signature.v1"]' "${TMP}/manifest.json" | base64 -d >"${TMP}/statement.sig" # An ed25519 public key is its 32 bytes behind a fixed SubjectPublicKeyInfo header. { printf '\x30\x2a\x30\x05\x06\x03\x2b\x65\x70\x03\x21\x00'; base64 -d <<<"${ARCHIE_RELEASE_KEY}"; } >"${TMP}/key.der" openssl pkeyutl -verify -pubin -inkey "${TMP}/key.der" -keyform DER -rawin \ -in "${TMP}/statement.json" -sigfile "${TMP}/statement.sig" >/dev/null 2>&1 || { echo "Error: ${ARCHIE_RELEASES}:${tag} is not signed by the release key." >&2; exit 1; } local zip_name zip_digest VERSION="$(jq -er .version "${TMP}/statement.json")" [ "$(jq -r .platform "${TMP}/statement.json")" = linux-amd64 ] || { echo "Error: the release is not built for linux-amd64." >&2; exit 1; } [ -z "${VERSION}" ] || [ "${tag}" = "${ARCHIE_CHANNEL}" ] || [ "v${VERSION}" = "${tag}" ] || { echo "Error: ${tag} carries the statement for ${VERSION}." >&2; exit 1; } zip_name="$(jq -er .zip.name "${TMP}/statement.json")" zip_digest="$(jq -er .zip.digest "${TMP}/statement.json")" RELEASE_NAME="${zip_name%.zip}" case "${RELEASE_NAME}" in archie-core-archied-v*-linux-amd64) ;; *) echo "Error: unexpected release zip ${zip_name}." >&2; exit 1 ;; esac echo "==> Downloading Archie ${VERSION}..." blob "${zip_digest}" "${TMP}/${zip_name}" || { echo "Error: ${zip_name} does not match the signed digest." >&2; exit 1; } unzip -q "${TMP}/${zip_name}" -d "${TMP}" } # 1. Prerequisites echo "==> Checking prerequisites..." # The installer depends on systemd user units and GNU tools. if [ "$(uname -s)" != "Linux" ]; then echo "Error: the installer supports Linux only. Detected: $(uname -s)" >&2 exit 1 fi if [ "${FROM_SOURCE}" = true ]; then need git go jq else [ "$(uname -m)" = x86_64 ] || { echo "Error: releases are built for x86_64 only; use --from-source." >&2; exit 1; } need curl unzip sha256sum openssl jq base64 fi if command -v docker &>/dev/null; then echo " [OK] $(docker --version)" else echo " [WARN] Docker not found. Agents run in containers and the bundled PostgreSQL needs it." fi mkdir -p "${ARCHIE_CONFIG_DIR}" "${ARCHIE_DATA_DIR}" "${ARCHIE_BIN_DIR}" # 2. Binaries. STAGE ends up holding the binaries and release.json, whichever # way they were obtained. TMP="$(mktemp -d)" trap 'rm -rf "${TMP}"' EXIT if [ "${FROM_SOURCE}" = true ]; then SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)" if [ -f "${SCRIPT_DIR}/go.mod" ] && grep -q "${MODULE}" "${SCRIPT_DIR}/go.mod"; then SRC_DIR="${SCRIPT_DIR}" else SRC_DIR="${TMP}/src" git clone --quiet --depth=1 "${SOURCE_GIT}" "${SRC_DIR}" fi echo "==> Building from ${SRC_DIR}..." # Selects (and under the default GOTOOLCHAIN=auto, downloads) the toolchain # go.mod requires, so a missing one fails here rather than mid-build. required="$(sed -n 's/^go //p' "${SRC_DIR}/go.mod")" if ! out="$(cd "${SRC_DIR}" && go list -m 2>&1)"; then echo "Error: Archie needs Go ${required}, which is not available: ${out}" >&2 echo "Install Go ${required} from https://go.dev/dl, or allow the download with GOTOOLCHAIN=auto and network access to proxy.golang.org." >&2 exit 1 fi STAGE="${TMP}/stage" mkdir -p "${STAGE}" # A source build is not a release: it says `dev`, and buildType=binary lets # it self-update. The agentworker stamp only lands in archie-agent. LDFLAGS="-X ${MODULE}/internal/buildinfo.Version=dev -X ${MODULE}/internal/buildinfo.Runtime=dev -X ${MODULE}/internal/installtype.buildType=binary -X ${MODULE}/internal/app/agentworker.version=dev" for cmd in $(jq -er '[.required_topology.units[], .required_topology.binaries[]?] | join(" ")' "${SRC_DIR}/release.json"); do (cd "${SRC_DIR}" && go build -ldflags "${LDFLAGS}" -o "${STAGE}/${cmd}" "./cmd/${cmd}") done cp "${SRC_DIR}/release.json" "${STAGE}/" else install_release STAGE="${TMP}/${RELEASE_NAME}" fi TOPOLOGY_UNITS="$(tr -d '\n' <"${STAGE}/release.json" | sed -n 's/.*"units": *\[\([^]]*\)\].*/\1/p' | tr -d '" ' | tr , ' ')" # Binaries that run beside the units without a service of their own are # installed and replaced with them. TOPOLOGY_BINARIES="$(tr -d '\n' <"${STAGE}/release.json" | sed -n 's/.*"binaries": *\[\([^]]*\)\].*/\1/p' | tr -d '" ' | tr , ' ')" for cmd in ${TOPOLOGY_UNITS} ${TOPOLOGY_BINARIES}; do install -m755 "${STAGE}/${cmd}" "${ARCHIE_BIN_DIR}/${cmd}" done echo " Installed ${TOPOLOGY_UNITS} ${TOPOLOGY_BINARIES} to ${ARCHIE_BIN_DIR}/" # 3. Configuration. archied setup asks every question and writes config.toml # plus any secrets to the env file beside it; this script asks nothing itself. if [ ! -f "${ARCHIE_CONFIG_DIR}/config.toml" ]; then echo "==> Generating config.toml (archied setup)..." if [ "${INTERACTIVE}" = true ]; then setup_args=(-config "${ARCHIE_CONFIG_DIR}/config.toml") else # Unattended: no forge and keyless Ollama, so the services boot without a secret. setup_args=(--defaults -config "${ARCHIE_CONFIG_DIR}/config.toml" -forge-type none) fi setup_in=/dev/null [ "${INTERACTIVE}" = true ] && setup_in=/dev/tty if ! "${ARCHIE_BIN_DIR}/archied" setup "${setup_args[@]}" <"${setup_in}"; then echo "ERROR: archied setup could not generate ${ARCHIE_CONFIG_DIR}/config.toml" >&2 exit 1 fi if [ "${ARCHIE_RELEASES}" != "${DEFAULT_RELEASES}" ] || [ "${ARCHIE_RELEASE_KEY}" != "${DEFAULT_RELEASE_KEY}" ]; then # The instance keeps updating from the source it was installed from. printf '\n[distribution]\nreleases = "%s"\nreleases_key = "%s"\n' "${ARCHIE_RELEASES}" "${ARCHIE_RELEASE_KEY}" >>"${ARCHIE_CONFIG_DIR}/config.toml" fi if [ -n "${PORT_BASE}" ]; then # The generated config names the default addresses; move them to this # instance's ports and pin the services the template leaves commented. sed -i -e "s/127\.0\.0\.1:8484/127.0.0.1:${P_WEB}/g" -e "s/127\.0\.0\.1:8485/127.0.0.1:${P_HEALTH}/g" \ -e "s/127\.0\.0\.1:8585/127.0.0.1:${P_GATEWAY}/g" -e "s/127\.0\.0\.1:9090/127.0.0.1:${P_STATE}/g" \ -e "s/127\.0\.0\.1:8586/127.0.0.1:${P_MESSAGING}/g" -e "s/127\.0\.0\.1:8587/127.0.0.1:${P_DAEMON}/g" \ "${ARCHIE_CONFIG_DIR}/config.toml" for section in messaging:${P_MESSAGING} daemon:${P_DAEMON}; do name="${section%%:*}" port="${section#*:}" grep -q "^\[services\.${name}\]" "${ARCHIE_CONFIG_DIR}/config.toml" || printf '\n[services.%s]\ntarget = "127.0.0.1:%s"\nlisten = "127.0.0.1:%s"\n' "${name}" "${port}" "${port}" >>"${ARCHIE_CONFIG_DIR}/config.toml" done fi else [ -n "${PORT_BASE}" ] && echo " [WARN] --port-base only applies to a new config; ${ARCHIE_CONFIG_DIR}/config.toml keeps its addresses." >&2 echo " [SKIP] ${ARCHIE_CONFIG_DIR}/config.toml already exists. Re-run 'archied setup' to change it." fi # provision_database reconciles the two database roles a bundled install # serves from: an archie_migrator that owns the schema and runs goose, and an # archie_runtime with row access only. It also moves the superuser password out # of the env file the units load: a config written before the split connects as # the bundled superuser, so its password is rotated to the Compose-only one # once the roles exist. Idempotent, so re-running the installer reconciles an # already-split install. provision_database() { local role_pw admin_pw connect_pw split=false role_pw="$(sed -n "s/^PGPASSWORD='\([^']*\)'$/\1/p" "${ENV_FILE}" | tail -n1)" admin_pw="$(sed -n "s/^POSTGRES_PASSWORD='\([^']*\)'$/\1/p" "${PG_ADMIN_ENV}" | tail -n1)" if [ -z "${role_pw}" ] || [ -z "${admin_pw}" ]; then echo " [WARN] Cannot provision database roles: ${ENV_FILE} needs PGPASSWORD and ${PG_ADMIN_ENV} needs POSTGRES_PASSWORD." >&2 return fi if ! grep -q '^migration_database_url' "${ARCHIE_CONFIG_DIR}/config.toml"; then split=true fi # A pre-split install authenticates as the superuser with the env file's # PGPASSWORD; a split one authenticates with the Compose-only password. if [ "${split}" = true ]; then connect_pw="${role_pw}"; else connect_pw="${admin_pw}"; fi echo "==> Provisioning the database roles..." if ! PGPASSWORD="${connect_pw}" ARCHIE_NEW_ADMIN_PASSWORD="${admin_pw}" \ "${ARCHIE_BIN_DIR}/archie-state-store" provision \ -admin-url "postgres://archie@/archie?host=${PG_SOCKET_DIR}" \ -runtime-url "postgres://${RUNTIME_ROLE}:${role_pw}@/archie?host=${PG_SOCKET_DIR}" \ -migration-url "postgres://${MIGRATION_ROLE}:${role_pw}@/archie?host=${PG_SOCKET_DIR}" \ -rotate-admin-password-env ARCHIE_NEW_ADMIN_PASSWORD; then echo " [WARN] Database role provisioning failed; not restarting the services until it succeeds. Re-run the installer once the database accepts the admin credential." >&2 AUTO_START=false return fi if [ "${split}" = true ]; then if grep -q '^database_url = "postgres://archie@' "${ARCHIE_CONFIG_DIR}/config.toml"; then sed -i "s#^database_url = \"postgres://archie@#database_url = \"postgres://${RUNTIME_ROLE}@#" "${ARCHIE_CONFIG_DIR}/config.toml" sed -i "/^database_url = /a migration_database_url = \"postgres://${MIGRATION_ROLE}@/archie?host=${PG_SOCKET_DIR}\"" "${ARCHIE_CONFIG_DIR}/config.toml" echo " [OK] config.toml now connects as ${RUNTIME_ROLE} and migrates as ${MIGRATION_ROLE}." else echo " [WARN] Could not move database_url to ${RUNTIME_ROLE}; set database_url and migration_database_url by hand." >&2 fi fi } # 4. PostgreSQL. Every service fails closed without it. The bundled database # has no network at all: the services reach it through its Unix socket, # mounted at PG_SOCKET_DIR, so it publishes no port and cannot collide with # another PostgreSQL. The superuser it is created with is only the installer's # bootstrap credential; the services connect as the two provisioned roles and # read their password from the env file's PGPASSWORD as before. PG_SOCKET_DIR="${ARCHIE_DATA_DIR}/postgres" PG_COMPOSE="${ARCHIE_DATA_DIR}/postgres.yml" if ! grep -qF "host=${PG_SOCKET_DIR}" "${ARCHIE_CONFIG_DIR}/config.toml"; then echo " [OK] Using the PostgreSQL server named by database_url." elif ! command -v docker &>/dev/null; then echo " [WARN] Docker not found: the bundled PostgreSQL needs it. Install Docker, or run 'archied setup' with your own PostgreSQL 18 URL." >&2 AUTO_START=false else echo "==> Starting the bundled PostgreSQL 18..." mkdir -p "${PG_SOCKET_DIR}" # The superuser password is generated here rather than reused from setup: it # is the one credential that must never be in the env file the units load. # Written before the first start so a failed run can be retried with it. if [ ! -f "${PG_ADMIN_ENV}" ]; then previous_umask="$(umask)" umask 077 printf "POSTGRES_PASSWORD='%s'\n" "$(od -An -N24 -tx1 /dev/urandom | tr -d ' \n')" >"${PG_ADMIN_ENV}" umask "${previous_umask}" fi cat >"${PG_COMPOSE}" <<'EOF' services: postgres: image: postgres:18 network_mode: none environment: POSTGRES_USER: archie POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-} POSTGRES_DB: archie POSTGRES_INITDB_ARGS: --auth-local=scram-sha-256 PGDATA: /var/lib/postgresql/data/pgdata volumes: - pg_data:/var/lib/postgresql/data # :z relabels the directory for SELinux hosts. - ./postgres:/var/run/postgresql:z restart: unless-stopped healthcheck: test: ["CMD-SHELL", "pg_isready -U archie -d archie"] interval: 5s timeout: 5s retries: 10 volumes: pg_data: EOF if ! docker compose -p "${INSTANCE}" --env-file "${PG_ADMIN_ENV}" -f "${PG_COMPOSE}" up -d --wait; then echo " [WARN] The bundled PostgreSQL did not start, so the services are installed but not started." >&2 echo " Check: docker compose -p "${INSTANCE}" -f ${PG_COMPOSE} logs" >&2 AUTO_START=false else provision_database fi fi # Extensions run in an unprivileged user namespace. Ubuntu 23.10+ forbids # those unless an AppArmor profile allows them, and only root can add one, so # print the profile that allows it for these binaries alone. if [ "$(cat /proc/sys/kernel/apparmor_restrict_unprivileged_userns 2>/dev/null)" = 1 ]; then echo " [WARN] This host restricts user namespaces, so extensions will not start until you run:" >&2 cat >&2 </dev/null <<'PROFILE' abi , include profile archie ${ARCHIE_BIN_DIR}/archie{d,-*} flags=(unconfined) { userns, } PROFILE sudo apparmor_parser -r /etc/apparmor.d/archie EOF fi # 5. Systemd user service setup & linger configuration SERVICE_INSTALLED=false if [ "${INSTALL_SYSTEMD}" = true ] && command -v systemctl &>/dev/null && [ -d "${XDG_CONFIG_HOME}" ]; then SYSTEMD_USER_DIR="${XDG_CONFIG_HOME}/systemd/user" echo "==> Configuring systemd user services..." mkdir -p "${SYSTEMD_USER_DIR}" # Every service this installer builds gets a unit, with the contents the # runbook used to tell an operator to paste by hand. The runbook is a # description now, not the mechanism: a fresh install must not need four # hand-written units before its own updater will run, and # the contents must not live in two places to drift apart. cat < "${SYSTEMD_USER_DIR}/${U_DAEMON}.service" [Unit] Description=Archie Core Orchestrator Daemon After=network.target # Give up after 5 failures in 5 minutes rather than restarting forever. A # genuinely broken install otherwise loops every RestartSec indefinitely, # burying the real error in the journal instead of surfacing a failed unit. StartLimitIntervalSec=300 StartLimitBurst=5 [Service] Type=notify NotifyAccess=main # Beats only while the run loop is polling, so a wedged loop is restarted. WatchdogSec=30s ExecStart=${ARCHIE_BIN_DIR}/archied -config ${ARCHIE_CONFIG_DIR}/config.toml EnvironmentFile=-${ENV_FILE} Environment=ARCHIE_INSTANCE=${INSTANCE} # archied reloads its configuration on SIGHUP. Without ExecReload, # 'systemctl --user reload archied' fails and the operator has to know # to run 'systemctl --user kill -s HUP' instead. ExecReload=/bin/kill -HUP \$MAINPID Restart=on-failure RestartSec=5s [Install] WantedBy=default.target EOF # The State Store owns the task data and is the process everything else dials, so # its unit is the first dependency the others name. cat < "${SYSTEMD_USER_DIR}/${U_STATE}.service" [Unit] Description=Archie State Store Service After=network.target [Service] Type=notify NotifyAccess=main ExecStart=${ARCHIE_BIN_DIR}/archie-state-store -config ${ARCHIE_CONFIG_DIR}/config.toml -listen 127.0.0.1:${P_STATE} -ready-addr 127.0.0.1:${P_READY} EnvironmentFile=-${ENV_FILE} Environment=ARCHIE_INSTANCE=${INSTANCE} Restart=on-failure RestartSec=5s [Install] WantedBy=default.target EOF cat < "${SYSTEMD_USER_DIR}/${U_GATEWAY}.service" [Unit] Description=Archie Gateway Service After=network.target [Service] Type=notify NotifyAccess=main ExecStart=${ARCHIE_BIN_DIR}/archie-gateway -config ${ARCHIE_CONFIG_DIR}/config.toml -listen 127.0.0.1:${P_GATEWAY} EnvironmentFile=-${ENV_FILE} Environment=ARCHIE_INSTANCE=${INSTANCE} Restart=on-failure RestartSec=5s [Install] WantedBy=default.target EOF cat < "${SYSTEMD_USER_DIR}/${U_UI}.service" [Unit] Description=Archie UI Service After=network.target ${U_STATE}.service Wants=${U_STATE}.service [Service] Type=simple ExecStart=${ARCHIE_BIN_DIR}/archie-ui -config ${ARCHIE_CONFIG_DIR}/config.toml EnvironmentFile=-${ENV_FILE} Environment=ARCHIE_INSTANCE=${INSTANCE} Restart=on-failure RestartSec=5s [Install] WantedBy=default.target EOF # The Telegram, email and webhook channels run here, not in archied: without # this unit a host looks healthy while its channels are dead. cat < "${SYSTEMD_USER_DIR}/${U_MESSAGING}.service" [Unit] Description=Archie Messaging Service After=network.target ${U_GATEWAY}.service ${U_STATE}.service Wants=${U_GATEWAY}.service ${U_STATE}.service [Service] Type=notify NotifyAccess=main ExecStart=${ARCHIE_BIN_DIR}/archie-messaging -config ${ARCHIE_CONFIG_DIR}/config.toml EnvironmentFile=-${ENV_FILE} Environment=ARCHIE_INSTANCE=${INSTANCE} Restart=on-failure RestartSec=5s [Install] WantedBy=default.target EOF INSTANCE_UNITS="" for base in $TOPOLOGY_UNITS; do INSTANCE_UNITS="${INSTANCE_UNITS:+${INSTANCE_UNITS} }$(unit "${base}")"; done systemctl --user daemon-reload || true SERVICE_INSTALLED=true for unit in $INSTANCE_UNITS; do test -f "${SYSTEMD_USER_DIR}/${unit}.service" || { echo "missing required unit: $unit" >&2; exit 1; } echo " Installed ${SYSTEMD_USER_DIR}/${unit}.service" done # Enable linger so systemd --user runs continuously without an active login # session. $(id -un) is used rather than $USER, which is unset in some # container and cron contexts and would abort under `set -u`. Only a # positive "Linger=yes" counts as already enabled -- a failed or empty # `loginctl show-user` (no logind session, a container) falls through to # enable-linger rather than being reported as already OK, since nothing # was actually observed. enable-linger is idempotent, so a redundant call # here is harmless. if [ "${ENABLE_LINGER}" = true ] && command -v loginctl &>/dev/null; then LINGER_USER="$(id -un)" if loginctl show-user "${LINGER_USER}" 2>/dev/null | grep -q "Linger=yes"; then echo " [OK] User linger is already enabled." else echo "==> Enabling systemd user linger (loginctl enable-linger ${LINGER_USER})..." loginctl enable-linger "${LINGER_USER}" || echo " Notice: Could not enable linger automatically. Run 'loginctl enable-linger ${LINGER_USER}' manually if needed." fi fi # Auto-enable and start the services, the store first so a fresh boot does # not race a dial it depends on. Restart rather than start, because a # reinstall over running services would otherwise leave the old binaries # running. if [ "${AUTO_START}" = true ]; then echo "==> Enabling and starting Archie services..." { systemctl --user enable $INSTANCE_UNITS && systemctl --user restart $INSTANCE_UNITS; } || echo " Notice: Could not start every service automatically. Check: systemctl --user status ${INSTANCE_UNITS}" fi fi # 6. Post-installation summary & instructions echo "" echo "============================================================" echo " ✓ Archie Core Installation Complete!" echo "============================================================" echo "" echo "Installation Details:" echo " - Binaries : ${ARCHIE_BIN_DIR}/{archied,archie-state-store,archie-gateway,archie-ui,archie-messaging}" echo " - Config : ${ARCHIE_CONFIG_DIR}/config.toml" echo " - Secrets : ${ENV_FILE}" if [ -f "${PG_ADMIN_ENV}" ]; then echo " - DB admin : ${PG_ADMIN_ENV} # compose-only, never loaded by the units" fi echo " - Data : ${ARCHIE_DATA_DIR}/" echo "" # Check PATH if [[ ":$PATH:" != *":${ARCHIE_BIN_DIR}:"* ]]; then echo "NOTE: ${ARCHIE_BIN_DIR} is not in your current PATH." echo "Add it to your shell configuration file (~/.bashrc or ~/.zshrc):" echo " export PATH=\"${ARCHIE_BIN_DIR}:\$PATH\"" echo "" fi if [ "${SERVICE_INSTALLED}" = true ] && [ "${AUTO_START}" = true ]; then echo "Service Management:" echo " - Units installed : ${INSTANCE_UNITS}" echo " - View live logs : journalctl --user -u ${U_DAEMON} -f" echo " - Service status : systemctl --user status ${INSTANCE_UNITS}" echo " - Restart daemon : systemctl --user restart ${U_DAEMON}" else echo "Manual Startup: start the five services as in https://offloaded.dev" fi echo "" SETUP_HINT="archied setup" [ "${INSTANCE}" = archie ] || SETUP_HINT="ARCHIE_INSTANCE=${INSTANCE} archied setup" echo "Dashboard: http://127.0.0.1:${P_WEB} Change the config: ${SETUP_HINT}" echo ""