Skip to content

Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors

Rust

fix(wrapper): match multi-arch image digest and preserve volume mount modes

Felipe Griloc65df4f0a8ad
diff --git a/CHANGELOG.md b/CHANGELOG.md
index fe0cc8a7..f4f37e00 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -45,6 +45,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
summary or handoff was produced. The handlers are now `async` and await a
bounded (2s) drain of the pending request(s) before returning, mirroring
the joinable dispose-drain already used by the OpenCode integration (#676).
+- The `bin/ai-memory` container wrapper now matches multi-architecture image
+ manifests against the host's platform architecture, eliminating a
+ false-positive "a newer image is available on Docker Hub" warning on x86_64
+ and Podman. Additionally, `emit_docker_run_script` now preserves volume mount
+ modes (such as `:Z` on SELinux/Podman environments) and filters transient
+ runtime environment variables (`HOSTNAME`, `container=podman`).
## [2.1.1] - 2026-09-07
diff --git a/bin/ai-memory b/bin/ai-memory
index 94b43957..9d5db2a0 100755
--- a/bin/ai-memory
+++ b/bin/ai-memory
@@ -60,16 +60,47 @@ WRAPPER_SHA256_URL="${AI_MEMORY_WRAPPER_SHA256_URL:-${WRAPPER_URL}.sha256}"
# ---- version-check helpers (best-effort; never block the wrapper) --------
-local_digest() {
- "${DOCKER}" image inspect --format='{{index .RepoDigests 0}}' "${IMAGE}" 2>/dev/null \
- | sed 's/.*@//' || true
+local_digests() {
+ "${DOCKER}" image inspect --format='{{range .RepoDigests}}{{println .}}{{end}}{{println .Digest}}' "${IMAGE}" 2>/dev/null \
+ | sed 's/.*@//' | grep -v '^$' || true
}
remote_digest() {
+ local host_arch
+ case "$(uname -m 2>/dev/null || true)" in
+ x86_64 | amd64) host_arch="amd64" ;;
+ aarch64 | arm64) host_arch="arm64" ;;
+ *) host_arch="" ;;
+ esac
+
# docker manifest inspect was experimental pre-20.10; on modern
- # docker it's stable. Silent on failure (offline, podman, etc.).
- "${DOCKER}" manifest inspect "${IMAGE}" 2>/dev/null \
- | grep -oE 'sha256:[a-f0-9]{64}' | head -n 1 || true
+ # docker and podman it's stable. Silent on failure (offline, etc.).
+ "${DOCKER}" manifest inspect "${IMAGE}" 2>/dev/null | awk -v target_arch="${host_arch}" '
+ BEGIN { RS="}" }
+ {
+ block = $0
+ arch = ""
+ digest = ""
+ if (match(block, /sha256:[a-f0-9]{64}/)) {
+ digest = substr(block, RSTART, RLENGTH)
+ if (first_d == "") first_d = digest
+ }
+ if (match(block, /"architecture"[[:space:]]*:[[:space:]]*"[^"]+"/)) {
+ s = substr(block, RSTART, RLENGTH)
+ sub(/.*"architecture"[[:space:]]*:[[:space:]]*"/, "", s)
+ sub(/".*/, "", s)
+ arch = s
+ }
+ if (arch == target_arch && digest != "") {
+ print digest
+ found = 1
+ exit
+ }
+ }
+ END {
+ if (!found && first_d != "") print first_d
+ }
+ ' || true
}
maybe_warn_outdated() {
@@ -84,10 +115,10 @@ maybe_warn_outdated() {
mkdir -p "${CACHE_DIR}"
touch "${VERSION_CHECK_FILE}"
local local_d remote_d
- local_d=$(local_digest)
+ local_d=$(local_digests)
remote_d=$(remote_digest)
[ -n "${local_d}" ] && [ -n "${remote_d}" ] || return 0
- if [ "${local_d}" != "${remote_d}" ]; then
+ if ! printf '%s\n' "${local_d}" | grep -qxF "${remote_d}"; then
printf '\033[33mai-memory: a newer image is available on Docker Hub.\033[0m\n' >&2
printf ' run `ai-memory upgrade` to pull it + refresh hooks.\n' >&2
fi
@@ -177,7 +208,7 @@ emit_docker_run_script() {
ports="$("${DOCKER}" inspect "${container}" --format \
'{{range $p, $bindings := .HostConfig.PortBindings}}{{range $bindings}}-p {{if .HostIp}}{{.HostIp}}:{{end}}{{.HostPort}}:{{$p}} {{end}}{{end}}' 2>/dev/null)"
volumes="$("${DOCKER}" inspect "${container}" --format \
- '{{range .Mounts}}{{if eq .Type "volume"}}-v {{.Name}}:{{.Destination}} {{else}}-v {{.Source}}:{{.Destination}} {{end}}{{end}}' 2>/dev/null)"
+ '{{range .Mounts}}{{if eq .Type "volume"}}-v {{.Name}}:{{.Destination}}{{if .Mode}}:{{.Mode}}{{end}} {{else}}-v {{.Source}}:{{.Destination}}{{if .Mode}}:{{.Mode}}{{end}} {{end}}{{end}}' 2>/dev/null)"
restart="$("${DOCKER}" inspect "${container}" --format \
'{{with .HostConfig.RestartPolicy.Name}}{{if ne . "no"}}--restart {{.}}{{end}}{{end}}' 2>/dev/null)"
@@ -204,6 +235,9 @@ emit_docker_run_script() {
if printf '%s\n' "${image_env}" | grep -qxF -- "${kv}"; then
continue
fi
+ case "${kv}" in
+ HOSTNAME=*|container=*) continue ;;
+ esac
env_flags="${env_flags} -e $(printf '%q' "${kv}")"
done <<ENVEOF
${container_env}
diff --git a/tests/wrapper_upgrade.sh b/tests/wrapper_upgrade.sh
index 3eb18168..eff809fe 100755
--- a/tests/wrapper_upgrade.sh
+++ b/tests/wrapper_upgrade.sh
@@ -46,10 +46,14 @@ case "${1:-}" in
'{{.Id}}') printf 'running-container-id\n' ;;
'{{.Config.Image}}') printf 'akitaonrails/ai-memory:latest\n' ;;
*PortBindings*) printf '%s\n' '-p 127.0.0.1:49374:49374/tcp ' ;;
- *Mounts*) printf '%s\n' '-v ai-memory-data:/data ' ;;
+ *Mounts*) printf '%s\n' '-v ai-memory-data:/data:Z ' ;;
*RestartPolicy*) printf '%s\n' '--restart unless-stopped' ;;
'{{json .Config.Cmd}}') printf '[]\n' ;;
- *'.Config.Env'*) : ;;
+ *'.Config.Env'*)
+ if [ "${2:-}" = "ai-memory" ]; then
+ printf 'CUSTOM_VAR=custom_val\nHOSTNAME=container-id-123\ncontainer=podman\n'
+ fi
+ ;;
*) printf 'unexpected inspect format: %s\n' "${4:-<missing>}" >&2; exit 2 ;;
esac
;;
@@ -84,7 +88,10 @@ run_upgrade_case() {
run_upgrade_case standalone 0
assert_contains "${TMP_ROOT}/standalone/output.log" "does not manage the running ai-memory container"
assert_not_contains "${TMP_ROOT}/standalone/docker.log" "compose up -d"
-assert_contains "${TMP_ROOT}/standalone/cache/ai-memory/recreate-ai-memory.sh" "-v ai-memory-data:/data"
+assert_contains "${TMP_ROOT}/standalone/cache/ai-memory/recreate-ai-memory.sh" "-v ai-memory-data:/data:Z"
+assert_contains "${TMP_ROOT}/standalone/cache/ai-memory/recreate-ai-memory.sh" "-e CUSTOM_VAR=custom_val"
+assert_not_contains "${TMP_ROOT}/standalone/cache/ai-memory/recreate-ai-memory.sh" "HOSTNAME="
+assert_not_contains "${TMP_ROOT}/standalone/cache/ai-memory/recreate-ai-memory.sh" "container=podman"
assert_contains "${TMP_ROOT}/standalone/cache/ai-memory/recreate-ai-memory.sh" "${FAKE_DOCKER} stop ai-memory"
assert_not_contains "${TMP_ROOT}/standalone/cache/ai-memory/recreate-ai-memory.sh" "docker stop ai-memory"
@@ -95,4 +102,94 @@ if [ -e "${TMP_ROOT}/compose/cache/ai-memory/recreate-ai-memory.sh" ]; then
fail "Compose-owned container unexpectedly produced a standalone recreation script"
fi
+# ---- multi-arch manifest version-check tests -----------------------------
+
+if command -v python3 >/dev/null 2>&1; then
+ H_ARM="sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ H_AMD="sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+ H_OLD="sha256:0000000000000000000000000000000000000000000000000000000000000000"
+
+ MULTI_ARCH_JSON="{\"manifests\":[{\"digest\":\"${H_ARM}\",\"platform\":{\"architecture\":\"arm64\"}},{\"digest\":\"${H_AMD}\",\"platform\":{\"architecture\":\"amd64\"}}]}"
+
+ run_version_check_case() {
+ local name="$1" uname_m="$2" local_inspect="$3" remote_manifest="$4" expect_warn="$5"
+ local case_dir="${TMP_ROOT}/ver_${name}"
+ mkdir -p "${case_dir}/cache"
+ local fake_engine="${case_dir}/engine"
+ cat >"${fake_engine}" <<ENGINE
+#!/usr/bin/env bash
+case "\${1:-}" in
+ image)
+ printf '%b\n' '${local_inspect}'
+ ;;
+ manifest)
+ printf '%b\n' '${remote_manifest}'
+ ;;
+ info)
+ printf 'name=seccomp\n'
+ ;;
+ run)
+ exit 0
+ ;;
+ *)
+ exit 0
+ ;;
+esac
+ENGINE
+ chmod 0755 "${fake_engine}"
+
+ local fake_uname="${case_dir}/uname"
+ cat >"${fake_uname}" <<UNAME
+#!/usr/bin/env bash
+printf '%s\n' "${uname_m}"
+UNAME
+ chmod 0755 "${fake_uname}"
+
+ local out="${case_dir}/out.log"
+ python3 -c '
+import os, pty, sys
+master, slave = pty.openpty()
+pid = os.fork()
+if pid == 0:
+ os.close(master)
+ os.dup2(slave, 0)
+ os.dup2(slave, 1)
+ os.dup2(slave, 2)
+ os.close(slave)
+ env = dict(os.environ)
+ env["PATH"] = sys.argv[1] + ":" + env["PATH"]
+ env["AI_MEMORY_DOCKER"] = sys.argv[2]
+ env["AI_MEMORY_NO_TTY"] = "1"
+ env["XDG_CACHE_HOME"] = sys.argv[3]
+ env.pop("AI_MEMORY_NO_VERSION_CHECK", None)
+ os.execvpe(sys.argv[4], [sys.argv[4], "status"], env)
+else:
+ os.close(slave)
+ output = b""
+ while True:
+ try:
+ chunk = os.read(master, 1024)
+ if not chunk: break
+ output += chunk
+ except OSError:
+ break
+ os.close(master)
+ os.waitpid(pid, 0)
+ with open(sys.argv[5], "wb") as f:
+ f.write(output)
+' "${case_dir}" "${fake_engine}" "${case_dir}/cache" "${ROOT}/bin/ai-memory" "${out}"
+
+ if [ "${expect_warn}" -eq 1 ]; then
+ assert_contains "${out}" "a newer image is available on Docker Hub"
+ else
+ assert_not_contains "${out}" "a newer image is available on Docker Hub"
+ fi
+ }
+
+ run_version_check_case amd64_matching "x86_64" "sha256:index\n${H_AMD}" "${MULTI_ARCH_JSON}" 0
+ run_version_check_case amd64_outdated "x86_64" "sha256:index\n${H_OLD}" "${MULTI_ARCH_JSON}" 1
+ run_version_check_case arm64_matching "aarch64" "${H_ARM}" "${MULTI_ARCH_JSON}" 0
+ run_version_check_case arm64_outdated "aarch64" "${H_OLD}" "${MULTI_ARCH_JSON}" 1
+fi
+
printf 'wrapper upgrade ownership checks passed\n'