The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
ci: keep the Linux smoke and browser jobs off Ubuntu's package mirrors (#1245)
kyle-elliott-asymptote0aadd043ef3f
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.ymlindex 4f76742c..60639a85 100644--- a/.github/workflows/ci.yml+++ b/.github/workflows/ci.yml@@ -55,8 +55,11 @@ jobs:# Node is only the build host -- the shipped artifact is browser JavaScript run# by Chrome -- so a matrix would triple the Chromium download and the serial# e2e wall time for no signal.+ # Pinned to 26.04 rather than ubuntu-latest, whose image is mid-move between releases: the job+ # relies on what the runner image ships (Edge, and Chromium's system libraries alongside Chrome)+ # instead of installing them from Ubuntu's mirrors, so the image has to be a known one.browser-extension:- runs-on: ubuntu-latest+ runs-on: ubuntu-26.04# The e2e launches a persistent Chromium context against a local HTTPS replay# server. A wedged browser is a plausible failure mode, so bound it rather# than holding a runner for the six-hour GitHub default.@@ -140,21 +143,22 @@ jobs:# Chromium leg only. The msedge leg installs nothing into this directory# but Playwright's .links bookkeeping, and saving that under the shared- # key would give the chromium leg a cache hit with no browser in it.+ # key would give the chromium leg a cache hit with no browser in it. The+ # runner image is in the key because a browser build is linked against its+ # libraries.- name: Cache Playwright browsersif: matrix.browser == 'chromium'id: pw-cacheuses: actions/cache@v6with:path: ~/.cache/ms-playwright- key: playwright-${{ runner.os }}-${{ steps.pw.outputs.version }}-- # Split from the browser download on purpose: the apt packages live outside- # ~/.cache/ms-playwright, so a cache hit must not skip them.- - name: Install Playwright system dependencies- working-directory: browser-extension- run: npx playwright install-deps chromium+ key: playwright-ubuntu-26.04-${{ steps.pw.outputs.version }}+ # No `playwright install-deps` or `--with-deps` here or below: those run apt+ # against Ubuntu's mirrors, and a mirror outage failed every browser job. The+ # runner image already carries Chromium's system libraries, which Google+ # Chrome needs too. The download itself comes from Playwright's CDN.+ ## The full Chromium build, not the headless shell: e2e/fixtures.ts uses# channel: 'chromium', which is what supports MV3 extensions in headless.- name: Install Chromium for Playwright@@ -162,15 +166,14 @@ jobs:working-directory: browser-extensionrun: npx playwright install chromium- # Edge stable installs from Microsoft's apt repository into- # /opt/microsoft/msedge, outside the Playwright cache, so it is installed- # on every run. Edge still honors --load-extension (checked on Edge 153),- # which is what lets the same harness load dist/. Branded Google Chrome- # stopped honoring it, which is why `chrome` is not a matrix leg.- - name: Install Microsoft Edge for Playwright+ # Edge stable is the runner image's own, at /opt/microsoft/msedge where the+ # msedge channel looks for it, so nothing is installed. Edge still honors+ # --load-extension (checked on Edge 153), which is what lets the same+ # harness load dist/. Branded Google Chrome stopped honoring it, which is+ # why `chrome` is not a matrix leg.+ - name: Check the runner's Microsoft Edgeif: matrix.browser == 'msedge'- working-directory: browser-extension- run: npx playwright install msedge+ run: /opt/microsoft/msedge/msedge --version# `npx playwright test`, not `npm test`: the pretest hook would rebuild# dist/ and hide a build failure inside the e2e step. GitHub sets CI=true,@@ -198,8 +201,9 @@ jobs:# Chrome, because that is what fleets run and it no longer loads unpacked# extensions from the command line. Linux reads machine policy from /etc with# no device-management check, and the runner's passwordless sudo writes it.+ # Pinned to 26.04 for the reason browser-extension is.browser-extension-policy:- runs-on: ubuntu-latest+ runs-on: ubuntu-26.04timeout-minutes: 20env:BROWSER_CHANNEL: chrome@@ -220,12 +224,12 @@ jobs:working-directory: browser-extensionrun: npm run build- # Google Chrome stable from Google's apt repository, plus its system- # libraries. It installs outside ~/.cache/ms-playwright, so there is- # nothing to cache.- - name: Install Google Chrome for Playwright- working-directory: browser-extension- run: npx playwright install --with-deps chrome+ # Google Chrome stable is the runner image's own, at /opt/google/chrome+ # where the chrome channel looks for it, so nothing is installed -- no+ # `--with-deps`, whose apt run against Ubuntu's mirrors failed this job in+ # a mirror outage.+ - name: Check the runner's Google Chrome+ run: /opt/google/chrome/chrome --version- name: Policy install e2eworking-directory: browser-extension@@ -460,8 +464,9 @@ jobs:# Runs the real dashboard with hostile fixture lenses (testdata/lens-e2e) and drives the session# page in headless Chromium: every way out of the lens sandbox in spec/lenses/SPEC.md must be# refused, and a lens that throws, stalls or navigates must give way to the full session.+ # Pinned to 26.04 for the reason browser-extension is.lens-e2e:- runs-on: ubuntu-latest+ runs-on: ubuntu-26.04timeout-minutes: 20defaults:run:@@ -484,8 +489,10 @@ jobs:run: make build-hooks-current- name: Install test dependenciesrun: npm ci+ # Chromium only, from Playwright's CDN. No `--with-deps`: the runner image carries Chromium's+ # system libraries, and the apt run against Ubuntu's mirrors failed this job in an outage.- name: Install Chromium- run: npx playwright install --with-deps chromium+ run: npx playwright install chromium- name: Run lens sandbox e2erun: npx playwright test- name: Upload Playwright report and traces@@ -709,8 +716,19 @@ jobs:# ours to install units into.linux-systemd-smoke:runs-on: ubuntu-latest+ permissions:+ contents: read+ packages: read+ env:+ # The container image comes prebuilt from smoke-images.yml, not from apt; see smoke/image.sh.+ BEACON_SMOKE_REGISTRY: ghcr.io/asymptote-labssteps:- uses: actions/checkout@v7+ # Not fatal: without a login the pull fails and image.sh builds the image itself.+ - name: Log in to GHCR+ run: echo "$GITHUB_TOKEN" | docker login ghcr.io -u "$GITHUB_ACTOR" --password-stdin || echo "::warning::GHCR login failed; the smoke image will be built locally"+ env:+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}- uses: ./.github/actions/setup-gowith:# The exporter is listed because builder.yaml compiles it into the@@ -745,8 +763,20 @@ jobs:# this covers the package postinstall doing it for the user, which is what they actually do.linux-package-smoke:runs-on: ubuntu-latest+ permissions:+ contents: read+ packages: read+ env:+ # The container images come prebuilt from smoke-images.yml, not from apt or dnf; see+ # smoke/image.sh.+ BEACON_SMOKE_REGISTRY: ghcr.io/asymptote-labssteps:- uses: actions/checkout@v7+ # Not fatal: without a login the pull fails and image.sh builds the image itself.+ - name: Log in to GHCR+ run: echo "$GITHUB_TOKEN" | docker login ghcr.io -u "$GITHUB_ACTOR" --password-stdin || echo "::warning::GHCR login failed; the smoke images will be built locally"+ env:+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}# Fast and needs nothing built: the install script's arguments, against a stub binary.- name: Validate the packaging scriptsrun: sh packaging/linux/test-endpoint-scripts.shdiff --git a/.github/workflows/smoke-images.yml b/.github/workflows/smoke-images.ymlnew file mode 100644index 00000000..3aec7495--- /dev/null+++ b/.github/workflows/smoke-images.yml@@ -0,0 +1,51 @@+name: Smoke images++# Publishes the container images the Linux smoke tests run in (packaging/linux/smoke/*.Dockerfile)+# to GHCR, so CI pulls them instead of running apt-get or dnf against the distribution mirrors on+# every pull request. Each image is tagged with a digest of its Dockerfile (see smoke/image.sh):+#+# - on a push to main that changes a Dockerfile, the new recipe is published under its new tag;+# - weekly, every image is rebuilt from a freshly pulled base under its existing tag, so the+# smoke tests keep running on a patched base without a pull request to bump anything.+#+# Until the first publish of a recipe, the smoke scripts build it themselves, as on a developer+# machine, so a pull request that changes a Dockerfile still tests the change.+on:+ push:+ branches:+ - main+ paths:+ - packaging/linux/smoke/**+ - .github/workflows/smoke-images.yml+ schedule:+ - cron: "17 6 * * 1"+ workflow_dispatch:++permissions:+ contents: read++concurrency:+ group: ${{ github.workflow }}+ cancel-in-progress: false++jobs:+ publish:+ runs-on: ubuntu-latest+ timeout-minutes: 20+ permissions:+ contents: read+ packages: write+ strategy:+ fail-fast: false+ matrix:+ image: [systemd, package-deb, package-rpm]+ steps:+ - uses: actions/checkout@v7+ - name: Log in to GHCR+ run: echo "$GITHUB_TOKEN" | docker login ghcr.io -u "$GITHUB_ACTOR" --password-stdin+ env:+ GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}+ - name: Build and push ${{ matrix.image }}+ run: |+ BEACON_SMOKE_REGISTRY="ghcr.io/$(echo "$GITHUB_REPOSITORY_OWNER" | tr '[:upper:]' '[:lower:]')" \+ sh packaging/linux/smoke/image.sh --publish "${{ matrix.image }}"diff --git a/CLAUDE.md b/CLAUDE.mdindex 9a6d0ea9..66e1fd0a 100644--- a/CLAUDE.md+++ b/CLAUDE.md@@ -738,11 +738,12 @@ developer mode.- `browser-extension` (Node 22, matrix over `chromium` and `msedge`): `npm run check`, `npm run test:unit`, `npm run build`, a check that the build is a loadable MV3 extension, `npm run lint:firefox` (the Firefox build plus `addons-linter --warnings-as-errors`), and the Playwright replay e2e running the real extension headless in that leg's browser (`BROWSER_CHANNEL`) against a local HTTPS replay server; the HTML report and traces upload on failure. Brave, Opera, Vivaldi and Arc have no Playwright channel; `BROWSER_EXECUTABLE` runs the same e2e against their binaries for the manual checklist in `docs/runtimes/browser-extension-chromium.mdx`.- `browser-extension-policy` (ubuntu, Google Chrome): `e2e/policy-install.spec.ts` with `POLICY_E2E=1`. It signs `dist/` with a throwaway key, serves the CRX and `updates.xml` from a local feed, writes Chrome machine policy under `/etc/opt/chrome/policies/managed` with sudo (a `*` blocklist, a force-install of the test ID with `override_update_url`, and managed values), then checks the install, the locked popup, a replayed chat arriving with metadata only at the locked endpoint, and an update to the next version. Linux is the only platform where Chrome honors an off-store force-install without a managed device, which is why it runs there.- `lens-e2e` (ubuntu): runs the real dashboard handler with hostile fixture lenses and the full `rules/` corpus installed (`cli/beacon/internal/endpoint/dashboard/e2eserver`, `testdata/lens-e2e`) and drives the session page in headless Chromium. Every escape from the lens sandbox must be refused, and a lens that throws, stalls or navigates must give way to the full session.+- The three browser jobs run on `ubuntu-26.04`, not `ubuntu-latest`, and install nothing with apt: no `playwright install-deps` or `--with-deps`. They use the runner image's Google Chrome and Microsoft Edge and the system libraries it carries for them, and download only Playwright's Chromium from its CDN, so an Ubuntu mirror outage does not fail them. A new runner image has to keep shipping Chrome and Edge; the Playwright version needs Ubuntu 26.04 support (1.61 or later).- `beacon-sandbox` (ubuntu): `go build`, `go vet`, and `go test` for the verification harness. Hermetic — no Modal account, no API key, no paid resources.- `terraform` (ubuntu): `terraform fmt -check`, `validate`, and `terraform test` (mocked providers) for every module under `terraform/`, and `validate` for each example.- `cross-build` (ubuntu): builds all five release targets and asserts the Linux binaries are statically linked (no `PT_INTERP`).- `package-smoke` (macOS): `packaging/macos/test-endpoint-scripts.sh`, a `build-pkg.sh` payload check, and `packaging/macos/smoke-endpoint.sh`.-- `linux-systemd-smoke` and `linux-package-smoke` (ubuntu): the real systemd install path, and installing the built `.deb` in a systemd container.+- `linux-systemd-smoke` and `linux-package-smoke` (ubuntu): the real systemd install path, and installing the built `.deb` and `.rpm` in a systemd container. The containers come prebuilt from GHCR (`ghcr.io/asymptote-labs/beacon-smoke-*`), published by `smoke-images.yml` from `packaging/linux/smoke/*.Dockerfile` on a change to `main` and weekly from a fresh base, and tagged by a digest of the Dockerfile; `packaging/linux/smoke/image.sh` pulls the tag and builds locally when it is not published yet. So these jobs never run apt or dnf against a distribution mirror.- `windows-package-smoke` (windows-2025): `packaging/windows/test-endpoint-scripts.ps1`, then fetching the pinned Vector, building the MSI and installing it.The Go jobs build the embedded hooks binary first (`make build-hooks-current`); `cli/beacon` testsdiff --git a/packaging/linux/smoke-package.sh b/packaging/linux/smoke-package.shindex e0e34f25..d7b0649a 100755--- a/packaging/linux/smoke-package.sh+++ b/packaging/linux/smoke-package.sh@@ -42,37 +42,22 @@ cleanup() { docker rm -f "$CONTAINER" >/dev/null 2>&1 || true; }trap cleanup EXIT INT TERMcleanup-# binutils is for readelf, which checks the packaged Vector is static. Rocky rather than Fedora for-# the rpm lane because RHEL and Rocky are what RPM fleets actually run; its image already has-# curl-minimal, which conflicts with the curl package.+# Pulled prebuilt when BEACON_SMOKE_REGISTRY is set, built from smoke/package-$FORMAT.Dockerfile+# otherwise; BEACON_SMOKE_BASE replaces the base image.+#+# The package manager reads no repository while the test runs: the image already carries the+# package's one dependency (systemd). dnf refreshes metadata it considers stale (after 48 hours;+# the image is rebuilt weekly), so the rpm lane disables every repository, which also makes a+# missing dependency fail at once instead of being downloaded. apt-get never refreshes its lists on+# install and fetches nothing for a package whose dependencies are installed; its --no-download+# cannot take a local .deb at all.case "$FORMAT" in- deb) IMAGE=beacon-package-smoke-deb- BASE="${BEACON_SMOKE_BASE:-ubuntu:24.04}"- INSTALL_PKGS="systemd systemd-sysv dbus libpam-systemd curl ca-certificates iproute2 binutils"- PKGMGR_INSTALL="apt-get install -y -qq /var/tmp/beacon.deb" ;;- rpm) IMAGE=beacon-package-smoke-rpm- BASE="${BEACON_SMOKE_BASE:-rockylinux/rockylinux:9}"- INSTALL_PKGS="systemd dbus ca-certificates iproute binutils"- PKGMGR_INSTALL="dnf install -y -q /var/tmp/beacon.rpm" ;;+ deb) PKGMGR_INSTALL="apt-get install -y -qq /var/tmp/beacon.deb" ;;+ rpm) PKGMGR_INSTALL="dnf install -y -q --disablerepo='*' /var/tmp/beacon.rpm" ;;*) echo "unsupported format $FORMAT" >&2; exit 1 ;;esac--echo "building $IMAGE ($ARCH, $FORMAT)"-if [ "$FORMAT" = deb ]; then- docker build -q -t "$IMAGE" - >/dev/null <<DOCKERFILE-FROM $BASE-RUN apt-get update -qq && apt-get install -y -qq $INSTALL_PKGS >/dev/null-STOPSIGNAL SIGRTMIN+3-CMD ["/sbin/init"]-DOCKERFILE-else- docker build -q -t "$IMAGE" - >/dev/null <<DOCKERFILE-FROM $BASE-RUN dnf install -y -q $INSTALL_PKGS >/dev/null-STOPSIGNAL SIGRTMIN+3-CMD ["/sbin/init"]-DOCKERFILE-fi+IMAGE="$(sh "$ROOT_DIR/packaging/linux/smoke/image.sh" "package-$FORMAT")"+echo "image: $IMAGE ($ARCH, $FORMAT)"echo "starting systemd container"docker run -d --name "$CONTAINER" --privileged --cgroupns=host \@@ -416,7 +401,7 @@ echo "ok: upgrade left the service running and the config in place"# collected telemetry.case "$FORMAT" indeb) docker exec "$CONTAINER" apt-get remove -y -qq beacon >/dev/null 2>&1 ;;- rpm) docker exec "$CONTAINER" dnf remove -y -q beacon >/dev/null 2>&1 ;;+ rpm) docker exec "$CONTAINER" dnf remove -y -q --disablerepo='*' beacon >/dev/null 2>&1 ;;esacafter="$(docker exec "$CONTAINER" systemctl is-active beacon-collector.service 2>/dev/null || true)"[ "$after" != active ] || { echo "collector still active after package removal" >&2; exit 1; }diff --git a/packaging/linux/smoke-systemd.sh b/packaging/linux/smoke-systemd.shindex a208d332..8f4510cd 100755--- a/packaging/linux/smoke-systemd.sh+++ b/packaging/linux/smoke-systemd.sh@@ -42,18 +42,13 @@ donecommand -v docker >/dev/null 2>&1 || { echo "docker is required" >&2; exit 1; }CONTAINER="${BEACON_SMOKE_CONTAINER:-beacon-systemd-smoke}"-IMAGE="${BEACON_SMOKE_IMAGE:-beacon-systemd-smoke}"cleanup() { docker rm -f "$CONTAINER" >/dev/null 2>&1 || true; }trap cleanup EXIT INT TERMcleanup-echo "building $IMAGE ($ARCH)"-docker build -q -t "$IMAGE" - >/dev/null <<'DOCKERFILE'-FROM ubuntu:24.04-RUN apt-get update -qq && apt-get install -y -qq systemd systemd-sysv dbus curl ca-certificates iproute2 >/dev/null-STOPSIGNAL SIGRTMIN+3-CMD ["/sbin/init"]-DOCKERFILE+# Pulled prebuilt when BEACON_SMOKE_REGISTRY is set, built from smoke/systemd.Dockerfile otherwise.+IMAGE="$(sh "$ROOT_DIR/packaging/linux/smoke/image.sh" systemd)"+echo "image: $IMAGE ($ARCH)"echo "starting systemd container"docker run -d --name "$CONTAINER" --privileged --cgroupns=host \diff --git a/packaging/linux/smoke/image.sh b/packaging/linux/smoke/image.shnew file mode 100755index 00000000..b69ad389--- /dev/null+++ b/packaging/linux/smoke/image.sh@@ -0,0 +1,70 @@+#!/bin/sh+# Resolves the container image a Linux smoke test runs in, and prints its reference on stdout.+#+# sh packaging/linux/smoke/image.sh NAME # NAME is a Dockerfile here: systemd, package-deb, package-rpm+# sh packaging/linux/smoke/image.sh --publish NAME # build with a fresh base and push to the registry+#+# The tag is a digest of the Dockerfile, so an image is only ever reused for the recipe it was built+# from. With BEACON_SMOKE_REGISTRY set (CI sets ghcr.io/<owner>), the prebuilt image is pulled from+# there, which is what keeps the smoke jobs off the distribution mirrors: an apt or dnf outage used to+# fail every one of them at `docker build`. When the pull fails -- the image is not published yet,+# because the Dockerfile changed in the pull request being tested, or nothing is logged in -- the image+# is built here, as it is on a developer machine. BEACON_SMOKE_BASE replaces the base image and always+# builds locally, since the registry holds only the default bases.+#+# The build output goes to stderr in full, so a mirror failure reads as one rather than as a bare+# `exit code: 100`.+set -eu++publish=0+if [ "${1:-}" = "--publish" ]; then+ publish=1+ shift+fi+name="${1:?usage: image.sh [--publish] NAME}"+dir="$(CDPATH='' cd -- "$(dirname -- "$0")" && pwd)"+dockerfile="$dir/$name.Dockerfile"+[ -f "$dockerfile" ] || { echo "image.sh: no $dockerfile" >&2; exit 1; }++if command -v sha256sum >/dev/null 2>&1; then+ digest="$(sha256sum "$dockerfile" | cut -c1-16)"+else+ digest="$(shasum -a 256 "$dockerfile" | cut -c1-16)"+fi+repo="beacon-smoke-$name"+registry="${BEACON_SMOKE_REGISTRY:-}"+base="${BEACON_SMOKE_BASE:-}"++if [ "$publish" = 1 ]; then+ [ -n "$registry" ] || { echo "image.sh: --publish needs BEACON_SMOKE_REGISTRY" >&2; exit 1; }+ ref="$registry/$repo:$digest"+ # --pull so the weekly rebuild picks up the base image's security updates under the same tag.+ # linux/amd64 is what the CI runners are, whatever machine publishes. The source label links the+ # GHCR package to the repository, which is what lets a workflow's job token pull a private one;+ # GHCR reads it only from a single image manifest, so no provenance index is pushed around it.+ # Publishing needs BuildKit (buildx), which GitHub's runners have.+ source="${GITHUB_SERVER_URL:-https://github.com}/${GITHUB_REPOSITORY:-asymptote-labs/agent-beacon}"+ docker build --pull --platform "${BEACON_SMOKE_PLATFORM:-linux/amd64}" --provenance=false \+ --label "org.opencontainers.image.source=$source" -t "$ref" -f "$dockerfile" "$dir" >&2+ docker push "$ref" >&2+ echo "$ref"+ exit 0+fi++if [ -n "$registry" ] && [ -z "$base" ]; then+ ref="$registry/$repo:$digest"+ if docker pull -q "$ref" >/dev/null 2>&1; then+ echo "$ref"+ exit 0+ fi+ echo "image.sh: $ref is not available; building $name locally" >&2+fi++ref="$repo:$digest"+if [ -n "$base" ]; then+ ref="$repo:local"+ docker build --build-arg "BASE=$base" -t "$ref" -f "$dockerfile" "$dir" >&2+else+ docker build -t "$ref" -f "$dockerfile" "$dir" >&2+fi+echo "$ref"diff --git a/packaging/linux/smoke/package-deb.Dockerfile b/packaging/linux/smoke/package-deb.Dockerfilenew file mode 100644index 00000000..dd19531d--- /dev/null+++ b/packaging/linux/smoke/package-deb.Dockerfile@@ -0,0 +1,8 @@+# The container smoke-package.sh installs the .deb in: Ubuntu with systemd as PID 1. binutils is for+# readelf, which checks the packaged Vector is static. Built by image.sh, which CI pulls prebuilt+# from GHCR (see .github/workflows/smoke-images.yml).+ARG BASE=ubuntu:24.04+FROM ${BASE}+RUN apt-get update -qq && apt-get install -y -qq systemd systemd-sysv dbus libpam-systemd curl ca-certificates iproute2 binutils >/dev/null+STOPSIGNAL SIGRTMIN+3+CMD ["/sbin/init"]diff --git a/packaging/linux/smoke/package-rpm.Dockerfile b/packaging/linux/smoke/package-rpm.Dockerfilenew file mode 100644index 00000000..d4249213--- /dev/null+++ b/packaging/linux/smoke/package-rpm.Dockerfile@@ -0,0 +1,9 @@+# The container smoke-package.sh installs the .rpm in: Rocky Linux with systemd as PID 1, because+# RHEL and its rebuilds are what RPM fleets run. Its image already has curl-minimal, which conflicts+# with the curl package. binutils is for readelf. Built by image.sh, which CI pulls prebuilt from+# GHCR (see .github/workflows/smoke-images.yml).+ARG BASE=rockylinux/rockylinux:9+FROM ${BASE}+RUN dnf install -y -q systemd dbus ca-certificates iproute binutils >/dev/null+STOPSIGNAL SIGRTMIN+3+CMD ["/sbin/init"]diff --git a/packaging/linux/smoke/systemd.Dockerfile b/packaging/linux/smoke/systemd.Dockerfilenew file mode 100644index 00000000..1b932da2--- /dev/null+++ b/packaging/linux/smoke/systemd.Dockerfile@@ -0,0 +1,7 @@+# The container smoke-systemd.sh runs `beacon endpoint install --system` in: Ubuntu with systemd as+# PID 1. Built by image.sh, which CI pulls prebuilt from GHCR (see .github/workflows/smoke-images.yml).+ARG BASE=ubuntu:24.04+FROM ${BASE}+RUN apt-get update -qq && apt-get install -y -qq systemd systemd-sysv dbus curl ca-certificates iproute2 >/dev/null+STOPSIGNAL SIGRTMIN+3+CMD ["/sbin/init"]diff --git a/packaging/linux/test-endpoint-scripts.sh b/packaging/linux/test-endpoint-scripts.shindex 0249efe7..30b99aa4 100644--- a/packaging/linux/test-endpoint-scripts.sh+++ b/packaging/linux/test-endpoint-scripts.sh@@ -10,7 +10,7 @@ INSTALL_SCRIPT="$ROOT_DIR/packaging/linux/install-endpoint.sh"TMP_DIR="$(mktemp -d)"trap 'rm -rf "$TMP_DIR"' EXIT INT TERM-for script in "$ROOT_DIR"/packaging/linux/*.sh "$ROOT_DIR"/packaging/linux/nfpm/*.sh; do+for script in "$ROOT_DIR"/packaging/linux/*.sh "$ROOT_DIR"/packaging/linux/nfpm/*.sh "$ROOT_DIR"/packaging/linux/smoke/*.sh; docase "$(head -n 1 "$script")" in*bash*) bash -n "$script" ;;*) sh -n "$script" ;;