Files
archie/scripts/archie-update-install
T
sam d8c65afad3 fix(update): back up the task store the daemon actually uses, or refuse
configured_task_db_path() read the top-level db_path and handed that literal
file to the watchdog as ARCHIE_TASK_DB_PATH (scripts/archie-update-install).
The daemon's task store is not that file: taskDBPath() in
internal/app/archied/main.go derives `<db_path>-tasks.sqlite`, and the
configured path is commonly a zero-byte placeholder beside it. The updater
therefore backed up an empty file, and a rollback would have restored that
empty file over the real database and deleted its -wal/-shm -- destroying the
task store the backup exists to protect.

That awk also matched db_path in any section. [indexing] owns its own
database, so a config listing it before the top-level key handed the watchdog
an unrelated database as ARCHIE_TASK_DB_PATH and backed that up instead.

Resolve the top-level key only, append the sibling suffix the daemon uses, and
refuse the update when the backup cannot be taken. The backup is the only
route back from a forward schema migration, so an update that cannot take one
must not start; it now runs as pre-flight, ahead of the adapter refresh, so a
refusal changes nothing on the host.

The tests drive the real script with a config file the harness controls; all
three fail against the previous adapter.
2026-09-12 03:01:58 +00:00

276 lines
12 KiB
Bash
Executable File

#!/usr/bin/env bash
# archie-update-install -- component-aware update installation adapter.
#
# CommandInstaller passes the freshly revalidated, approved snapshot through
# ARCHIE_UPDATE_{DAEMON,AGENT}_{PREVIOUS,VERSION}. A VERSION is non-empty only
# when that component changed in the approved snapshot. This script must never
# rediscover a broader plan after approval.
set -euo pipefail
json_escape() {
printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g'
}
SOURCE_URL="${ARCHIE_SOURCE_URL:-https://github.com/samcharles93/archie-core.git}"
BIN_DIR="${ARCHIE_BIN_DIR:-$HOME/.local/bin}"
CONFIG_PATH="${ARCHIE_CONFIG_PATH:-${XDG_CONFIG_HOME:-$HOME/.config}/archie/config.toml}"
export PATH="/usr/local/go/bin:$PATH"
# The worker image is daemon configuration, not an updater-specific setting.
# Honour an explicit environment override for nonstandard deployers; otherwise
# read the [containers] image from the same config archied starts with. This
# deliberately understands only that one scalar, rather than trying to parse
# general TOML in shell. The daemon remains the authority for validation.
configured_agent_image() {
local image
image="$(awk '
/^\[containers\][[:space:]]*(#.*)?$/ { in_containers = 1; next }
/^\[/ { in_containers = 0 }
in_containers && /^[[:space:]]*image[[:space:]]*=/ {
value = $0
sub(/^[[:space:]]*image[[:space:]]*=[[:space:]]*/, "", value)
sub(/[[:space:]]*(#.*)?$/, "", value)
if (value ~ /^".*"$/) {
sub(/^"/, "", value)
sub(/"$/, "", value)
print value
} else if (length(value) >= 2 && substr(value, 1, 1) == sprintf("%c", 39) && substr(value, length(value), 1) == sprintf("%c", 39)) {
print substr(value, 2, length(value) - 2)
}
exit
}
' "$CONFIG_PATH" 2>/dev/null || true)"
printf '%s' "$image"
}
# The task store is `<db_path>-tasks.sqlite`, not db_path itself: the daemon
# derives it with taskDBPath() in internal/app/archied/main.go, and the
# configured path may be a zero-byte placeholder while the real store sits
# beside it. Backing up the literal value would produce an empty backup, and a
# rollback would then restore that empty file over the database and delete its
# -wal/-shm -- destroying the task store it exists to protect.
#
# Only the top-level key counts. db_path also appears in other sections
# ([indexing] owns its own database), and the first match in the file can
# easily be one of those.
configured_task_db_path() {
local base
base="$(awk '
BEGIN { top = 1 }
/^[[:space:]]*\[/ { top = 0 }
top && /^[[:space:]]*db_path[[:space:]]*=/ {
value = $0
sub(/^[[:space:]]*db_path[[:space:]]*=[[:space:]]*/, "", value)
sub(/[[:space:]]*(#.*)?$/, "", value)
if (value ~ /^".*"$/) { sub(/^"/, "", value); sub(/"$/, "", value); print value }
else if (length(value) >= 2 && substr(value, 1, 1) == sprintf("%c", 39) && substr(value, length(value), 1) == sprintf("%c", 39)) print substr(value, 2, length(value) - 2)
exit
}
' "$CONFIG_PATH" 2>/dev/null || true)"
[ -n "$base" ] || return 0
printf '%s' "$base-tasks.sqlite"
}
AGENT_IMAGE="${ARCHIE_AGENT_IMAGE:-$(configured_agent_image)}"
AGENT_IMAGE="${AGENT_IMAGE:-ghcr.io/samcharles93/archie-agent:latest}"
AGENT_IMAGE_BACKUP="$BIN_DIR/archie-agent-image.prev.tar"
TASK_DB_PATH="${ARCHIE_TASK_DB_PATH:-$(configured_task_db_path)}"
TASK_DB_BACKUP="${ARCHIE_TASK_DB_BACKUP:-$BIN_DIR/archie-task-db.prev.sqlite}"
# The archied release is a set of processes, not one binary. Listed in start
# order: the State Store owns archie.db and every other process dials it, and
# the Gateway serves the chat contract archied and the UI dial, so each comes
# up before its consumers. archie-playbooks is a CLI, so it is installed but
# never restarted. deployments/systemd-user-service.md is the reference
# deployment; installing archied alone leaves the rest on the previous
# release, which is why a 1.23.0 update failed its health check
# (archie-core-hbqk).
GATEWAY_SERVICES="archie-state-store archie-gateway archied archie-ui"
GATEWAY_BINARIES="$GATEWAY_SERVICES archie-playbooks"
PREV_GW="${ARCHIE_UPDATE_DAEMON_PREVIOUS:-}"
PREV_RT="${ARCHIE_UPDATE_AGENT_PREVIOUS:-}"
GW_TARGET="${ARCHIE_UPDATE_DAEMON_VERSION:-}"
RT_TARGET="${ARCHIE_UPDATE_AGENT_VERSION:-}"
GW="$PREV_GW"
RT="$PREV_RT"
components=""
if [ -n "$GW_TARGET" ] && [ "$GW_TARGET" != "$PREV_GW" ]; then
GW="$GW_TARGET"
components="daemon"
fi
if [ -n "$RT_TARGET" ] && [ "$RT_TARGET" != "$PREV_RT" ]; then
case "$RT_TARGET" in
dev|unknown) echo "refusing to build a released runtime image with version '$RT_TARGET'" >&2; exit 1 ;;
esac
RT="$RT_TARGET"
components="${components:+$components,}agent"
fi
if [ -z "$components" ]; then
echo '==> no approved component changes; nothing to install'
echo 'ARCHIE_UPDATE_RESULT {"previous":{},"installed":{},"components":[],"restart_requested":false}'
exit 0
fi
valid_release_version() {
[[ "$1" =~ ^[0-9]+\.[0-9]+\.[0-9]+([+-][0-9A-Za-z.-]+)?$ ]]
}
for target in "$GW_TARGET" "$RT_TARGET"; do
if [ -n "$target" ] && ! valid_release_version "$target"; then
echo "refusing non-release component version '$target'" >&2
exit 1
fi
done
tmp="$(mktemp -d)"
source_dir="$tmp/source"
trap 'rm -rf "$tmp"' EXIT
echo "==> fetching approved component releases"
# Updates are independent of the agent/operator checkout. Fetch into an
# invocation-scoped clone, resolve the approved tags there, and build the
# installed binary from that isolated source tree.
git clone --quiet --filter=blob:none --no-checkout "$SOURCE_URL" "$source_dir"
git -C "$source_dir" fetch --quiet --tags origin
# Build from the exact approved release commit, not the moving branch tip. A
# temporary worktree keeps the operator's main checkout on its branch.
if [[ ",$components," == *,daemon,* ]]; then
gw_commit="$(git -C "$source_dir" rev-parse --verify "refs/tags/archied/v$GW^{commit}")"
fi
if [[ ",$components," == *,agent,* ]]; then
rt_commit="$(git -C "$source_dir" rev-parse --verify "refs/tags/archie/v$RT^{commit}")"
fi
case "$components" in
daemon) build_commit="$gw_commit" ;;
agent) build_commit="$rt_commit" ;;
daemon,agent)
if [ "$gw_commit" != "$rt_commit" ]; then
echo "approved component tags do not identify the same source commit" >&2
exit 1
fi
build_commit="$gw_commit"
;;
esac
git -C "$source_dir" checkout --quiet --detach "$build_commit"
cd "$source_dir"
# Refuse before touching anything if the release runs processes this host has
# no unit for. Installing the binaries anyway would leave archied dialling a
# State Store that nothing starts: it fails its health check and rolls back,
# which reads as a broken release rather than an incomplete deployment.
if [[ ",$components," == *,daemon,* ]]; then
missing_units=""
for svc in $GATEWAY_SERVICES; do
[ -d "$source_dir/cmd/$svc" ] || continue
if ! systemctl --user list-unit-files "$svc.service" --no-legend 2>/dev/null | grep -q .; then
missing_units="${missing_units:+$missing_units }$svc.service"
fi
done
if [ -n "$missing_units" ]; then
echo "refusing to install archied $GW: it runs as separate processes and this host has no unit for: $missing_units" >&2
echo "create them from deployments/systemd-user-service.md, then retry the update" >&2
exit 1
fi
fi
# Pre-flight, before any write to the host. The task database backup is the
# watchdog's only route back from a forward schema migration, so an update
# that cannot take one must not start: once binaries are replaced, a failure
# leaves the previous release unable to read the store it just migrated. This
# runs ahead of the adapter refresh below so a refusal changes nothing at all.
if [[ ",$components," == *,daemon,* ]] && [ -n "$TASK_DB_PATH" ] && [ -f "$TASK_DB_PATH" ]; then
echo "==> backing up task database for schema-safe rollback"
mkdir -p "$(dirname "$TASK_DB_BACKUP")"
if ! sqlite3 "$TASK_DB_PATH" ".backup '$TASK_DB_BACKUP'"; then
echo "refusing to install $GW: could not back up the task database at $TASK_DB_PATH, so a failed update could not be rolled back" >&2
exit 1
fi
fi
# Refresh adapters from the approved release source. The running shell
# continues with this copy; subsequent updates use the current contract.
install -m755 "$source_dir/scripts/archie-update-install" "$BIN_DIR/archie-update-install"
install -m755 "$source_dir/scripts/archie-update-watchdog" "$BIN_DIR/archie-update-watchdog"
install -m755 "$source_dir/scripts/archie-update-check" "$BIN_DIR/archie-update-check"
# built accumulates only the binaries this release actually ships, so an
# update to a release predating one of these processes stays buildable.
built=""
if [[ ",$components," == *,daemon,* ]]; then
ldflags="-X github.com/samcharles93/archie-core/internal/app/archied.gatewayVersion=$GW"
ldflags="$ldflags -X github.com/samcharles93/archie-core/internal/app/archied.runtimeVersion=$RT"
ldflags="$ldflags -X github.com/samcharles93/archie-core/internal/installtype.buildType=binary"
for cmd in $GATEWAY_BINARIES; do
[ -d "./cmd/$cmd" ] || continue
echo "==> building $cmd $GW"
go build -ldflags "$ldflags" -o "$tmp/$cmd" "./cmd/$cmd"
built="${built:+$built }$cmd"
done
echo "==> backing up current binaries"
for cmd in $built; do
if [ -f "$BIN_DIR/$cmd" ]; then
cp -f "$BIN_DIR/$cmd" "$BIN_DIR/$cmd.prev"
else
# New in this release: record that there was nothing here, so a
# rollback removes it instead of leaving a stray binary behind.
rm -f "$BIN_DIR/$cmd.prev"
fi
done
echo "==> installing $built"
for cmd in $built; do
install -m755 "$tmp/$cmd" "$BIN_DIR/$cmd"
done
fi
if [[ ",$components," == *,agent,* ]]; then
echo "==> saving managed worker image $AGENT_IMAGE for rollback"
docker image save --output "$AGENT_IMAGE_BACKUP" "$AGENT_IMAGE"
echo "==> rebuilding managed worker image $AGENT_IMAGE for runtime $RT"
docker build --build-arg "RUNTIME_VERSION=$RT" --tag "$AGENT_IMAGE" .
fi
echo "==> handing off to the update watchdog for restart and health verification"
systemd-run --user --unit=archied-update-restart --collect --quiet \
--setenv=ARCHIE_BIN_DIR="$BIN_DIR" \
--setenv=ARCHIE_HEALTH_URL="${ARCHIE_HEALTH_URL:-}" \
--setenv=ARCHIE_UPDATE_REPORT_PATH="${ARCHIE_UPDATE_REPORT_PATH:-}" \
--setenv=ARCHIE_UPDATE_CHANNEL="${ARCHIE_UPDATE_CHANNEL:-}" \
--setenv=ARCHIE_UPDATE_CHAT_ID="${ARCHIE_UPDATE_CHAT_ID:-0}" \
--setenv=ARCHIE_UPDATE_THREAD_ID="${ARCHIE_UPDATE_THREAD_ID:-0}" \
--setenv=ARCHIE_UPDATE_COMPONENTS="$components" \
--setenv=ARCHIE_UPDATE_UNITS="$GATEWAY_SERVICES" \
--setenv=ARCHIE_UPDATE_BINARIES="$built" \
--setenv=ARCHIE_UPDATE_PREVIOUS_GATEWAY="$PREV_GW" \
--setenv=ARCHIE_UPDATE_PREVIOUS_RUNTIME="$PREV_RT" \
--setenv=ARCHIE_UPDATE_INSTALLED_GATEWAY="$GW" \
--setenv=ARCHIE_UPDATE_INSTALLED_RUNTIME="$RT" \
--setenv=ARCHIE_AGENT_IMAGE="$AGENT_IMAGE" \
--setenv=ARCHIE_AGENT_IMAGE_BACKUP="$AGENT_IMAGE_BACKUP" \
--setenv=ARCHIE_TASK_DB_PATH="$TASK_DB_PATH" \
--setenv=ARCHIE_TASK_DB_BACKUP="$TASK_DB_BACKUP" \
"$BIN_DIR/archie-update-watchdog"
case "$components" in
daemon)
previous="{\"daemon\":\"$(json_escape "$PREV_GW")\"}"
installed="{\"daemon\":\"$(json_escape "$GW")\"}"
results='[{"id":"daemon","label":"daemon","status":"updated"}]'
;;
agent)
previous="{\"agent\":\"$(json_escape "$PREV_RT")\"}"
installed="{\"agent\":\"$(json_escape "$RT")\"}"
results='[{"id":"agent","label":"agent","status":"updated"}]'
;;
daemon,agent)
previous="{\"daemon\":\"$(json_escape "$PREV_GW")\",\"agent\":\"$(json_escape "$PREV_RT")\"}"
installed="{\"daemon\":\"$(json_escape "$GW")\",\"agent\":\"$(json_escape "$RT")\"}"
results='[{"id":"daemon","label":"daemon","status":"updated"},{"id":"agent","label":"agent","status":"updated"}]'
;;
esac
echo "ARCHIE_UPDATE_RESULT {\"previous\":$previous,\"installed\":$installed,\"components\":$results,\"restart_requested\":true}"