Skip to content

Commit fd3a0b1

Browse files
speak-agentspeak-agent
authored
fix(ci): ci-fresh-install had two defects, both firing after every release (#350)
11 red jobs looked like many problems. It was two, each able to redden the whole matrix on its own, and neither introduced by any particular release — both fire after EVERY release. Analysis: .agents/docs/2026-08-04-ci-fresh-install-two-defects.md A. THE REPO'S WORKSPACE PIN AMBUSHED THE VERSION UNDER TEST. `actions/checkout` is the first step, so the repo's .xlings.json — which pins the BOOTSTRAP mcpp, hand-maintained and deliberately lagging — lands in the working directory. That pin is directory-scoped and beats anything installed globally, so the jobs installed MCPP_PIN and then ran something else, which was not installed at all: ✓ 1 package(s) installed [error] xlings: version '2026.8.3.2' not found for 'mcpp' [error] available: 2026.8.3.4 ci-aarch64-fresh-install.yml hit this and solved it by ordering the checkout last, with a thorough comment. That does not transfer: the `build mcpp` steps here run `mcpp clean && mcpp run` INSIDE the repo, so a checkout must be present while mcpp is invoked. The pin goes instead — this workflow tests the RELEASED mcpp, and the bootstrap pin has no standing in that. B. wait-index GUARDED A DIFFERENT DISTRIBUTION CHANNEL. It polled the index's GIT source, which updates the instant the bump PR merges. The jobs install from the PUBLISHED ARTIFACT (xlings-res/xim-index → pointer → tarball), which lags git by however long Publish Index Artifact plus release-CDN propagation takes. Measured on 2026.8.3.5: the guard reported ready and all 11 jobs then failed with [error] package 'mcpp@2026.8.3.5' not found A guard that measures a channel nobody installs from is not a guard. It now polls the artifact — verified against the live pointer, which resolves xim-index-e8ad461.tar.gz and does contain the released version. Both fixes, plus activation (`-u` and `xlings use`) and an ASSERTION, are collapsed into one shared script, .github/tools/install_released_mcpp.sh, called from all five jobs. The two Windows install steps move from pwsh to bash to share it. The knowledge existed in this repo — fully written out in ci-aarch64's comment — and the other workflow never learned it; a script is where that stops being a thing people have to remember. The assertion is the only part that defends against the NEXT one. It evaluates `mcpp` as resolved through PATH — the binary the later steps actually invoke — so any future silent redirection becomes a named failure instead of a matrix that quietly tests the wrong binary and reports green. It earned that on the bench, twice, before ever reaching CI: * my first version probed a GUESSED install path instead of PATH. That verifies a copy nobody runs — the exact mistake the analysis doc is about, made while writing the fix for it. * `-u` alone did not move the shim in an isolated environment (payload reported 2026.8.3.5, shim reported 2026.7.29.1). `xlings use` is a different code path; both are done now, with the assertion still final. Also bumps the bundled xlings 2026.7.28.4 → 2026.8.4.1 across all 16 pin sites (check_version_pins.sh found every one). That release implements the index snapshot version contract and auto-routing this repo asked for (openxlings/xlings#476): an index declares the client version it needs, and the client routes to the newest snapshot it can use — version skew becomes a routing decision instead of a hard failure. It supplies the half mcpp cannot do alone, since mcpp does not fetch indexes (update_index shells out to `xlings update`) and had no way to ask for a specific snapshot. `xlings index list --json` passes non-`xlings` `requires` keys through verbatim and `xlings index use` pins. Consuming that from mcpp needs the index to declare `requires.mcpp` first, so this commit only bumps and verifies: mcpp new/build/run all work against 2026.8.4.1, and all four platform artifacts (including the aarch64 one release.yml hardcodes) are published.
1 parent 44479d0 commit fd3a0b1

13 files changed

Lines changed: 639 additions & 48 deletions

File tree

‎.agents/docs/2026-08-04-ci-fresh-install-two-defects.md‎

Lines changed: 368 additions & 0 deletions
Large diffs are not rendered by default.

‎.github/actions/bootstrap-mcpp/action.yml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ inputs:
2525
# `package.name`, so one of the two was simply unreachable — and which one
2626
# depended on the machine, which is why CI failed on `compat:lua` on
2727
# Windows and `mcpplibs.capi:lua` on Linux. Never pin below that.
28-
default: '2026.7.28.4'
28+
default: '2026.8.4.1'
2929
cache-target:
3030
description: also restore/save target/ (build artifacts + BMIs)
3131
required: false

‎.github/actions/setup-macos-llvm/action.yml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ inputs:
1515
# Floor imposed by the index, not a routine bump — see
1616
# .github/actions/bootstrap-mcpp/action.yml for why 0.4.69 is required
1717
# (two packages named `lua` in one repo need openxlings/xlings#381).
18-
default: '2026.7.28.4'
18+
default: '2026.8.4.1'
1919

2020
runs:
2121
using: composite

‎.github/tools/install_released_mcpp.sh‎

Lines changed: 160 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,160 @@
1+
#!/usr/bin/env bash
2+
# install_released_mcpp.sh — make a specific PUBLISHED mcpp be the binary that
3+
# the bare `mcpp` shim actually runs, and prove it.
4+
#
5+
# Sibling of install_pinned_mcpp.sh. That one installs the BOOTSTRAP mcpp the
6+
# repo's .xlings.json pins (for self-host builds); this one installs the
7+
# VERSION UNDER TEST for the fresh-install matrix. Same discipline, opposite
8+
# source of truth — and the reason they are two scripts rather than one flag is
9+
# that confusing the two is precisely what broke ci-fresh-install.
10+
#
11+
# THREE THINGS THIS DOES THAT THE INLINE VERSION DID NOT
12+
#
13+
# 1. NEUTRALISE THE REPO'S WORKSPACE PIN.
14+
#
15+
# This repo's .xlings.json declares `workspace.mcpp` — the bootstrap version,
16+
# hand-maintained and DELIBERATELY lagging the newest release. It is scoped
17+
# to the working directory, and inside a checkout it beats anything installed
18+
# globally. So the fresh-install jobs, which check out the repo first and
19+
# then run `mcpp` from it, were resolving the bootstrap version instead of
20+
# the version under test — and failing outright, because only the latter was
21+
# installed:
22+
#
23+
# ✓ 1 package(s) installed
24+
# [error] xlings: version '2026.8.3.2' not found for 'mcpp'
25+
# [error] available: 2026.8.3.4
26+
#
27+
# Every job in the matrix died there, on every run after every release, since
28+
# "newest release != bootstrap pin" is the normal state.
29+
#
30+
# ci-aarch64-fresh-install.yml avoids this by ordering the checkout LAST.
31+
# That does not work here: the `build mcpp` steps run `mcpp clean && mcpp run`
32+
# INSIDE the repo, so a checkout must be present while mcpp is invoked. The
33+
# pin has to go instead — this workflow tests the released binary, and the
34+
# bootstrap pin has no standing in that question.
35+
#
36+
# 2. ACTIVATE, NOT JUST INSTALL (`-u`).
37+
#
38+
# `xlings install` reports success for "the bytes are on disk", which is not
39+
# the same claim as "`mcpp` now runs it". install_pinned_mcpp.sh already
40+
# documents this ("the piece a plain install leaves alone, and the reason CI
41+
# could install one version and then run another"); this path never got it.
42+
#
43+
# 3. WAIT FOR THE INDEX THE JOB ACTUALLY USES.
44+
#
45+
# The workflow's wait-index job polls the index's GIT source
46+
# (raw.githubusercontent.com/openxlings/xim-pkgindex). Jobs install from the
47+
# PUBLISHED ARTIFACT (xlings-res/xim-index → pointer → tarball), which lags
48+
# git by however long Publish Index Artifact plus release-CDN propagation
49+
# takes. Measured on the 2026.8.3.5 release: wait-index reported ready and
50+
# every job then failed with
51+
#
52+
# [error] package 'mcpp@2026.8.3.5' not found
53+
#
54+
# A guard that measures a channel nobody installs from is not a guard. The
55+
# retry below closes it from the consumer side, which also covers per-edge
56+
# CDN skew that no central check can see: the runner that polled is not the
57+
# runner that installs.
58+
#
59+
# Usage: bash .github/tools/install_released_mcpp.sh <version> [repo_dir]
60+
# stdout: the resolved binary path; diagnostics go to stderr.
61+
set -euo pipefail
62+
63+
VER="${1:?usage: install_released_mcpp.sh <version> [repo_dir]}"
64+
REPO_DIR="${2:-$(pwd)}"
65+
66+
case "$(uname -s)" in
67+
MINGW*|MSYS*|CYGWIN*) XL_HOME="${USERPROFILE:-$HOME}"; EXE=".exe" ;;
68+
*) XL_HOME="$HOME"; EXE="" ;;
69+
esac
70+
71+
# Address xlings by path, not through PATH: this runs as a child bash, and on
72+
# Windows MSYS re-derives PATH from the Windows environment on startup, dropping
73+
# the mixed-separator entry the caller exported. Same reasoning (and same
74+
# location) as install_pinned_mcpp.sh.
75+
XL="$XL_HOME/.xlings/subos/default/bin/xlings${EXE}"
76+
[ -x "$XL" ] || XL="$XL_HOME/.xlings/subos/current/bin/xlings${EXE}"
77+
[ -x "$XL" ] || XL=$(command -v "xlings${EXE}" 2>/dev/null || true)
78+
[ -n "$XL" ] && [ -x "$XL" ] || {
79+
echo "FAIL: no xlings under $XL_HOME/.xlings nor on PATH" >&2; exit 1; }
80+
81+
# ── 1. the repo's workspace pin must not decide what we are testing ──────────
82+
if [ -f "$REPO_DIR/.xlings.json" ]; then
83+
echo "note: removing $REPO_DIR/.xlings.json for this job — it pins the BOOTSTRAP" >&2
84+
echo " mcpp, which would override the version under test inside this checkout." >&2
85+
rm -f "$REPO_DIR/.xlings.json"
86+
fi
87+
88+
# ── 2. install, retrying while the index has not caught up ───────────────────
89+
# Bounded. A miss that is NOT index lag (a typo'd version, a withdrawn release)
90+
# must not cost ten minutes, so the loop reports every attempt and the message
91+
# says which of the two it is on the last one.
92+
attempts="${MCPP_INSTALL_ATTEMPTS:-20}"
93+
delay="${MCPP_INSTALL_RETRY_SECONDS:-30}"
94+
installed=0
95+
for i in $(seq 1 "$attempts"); do
96+
"$XL" update >/dev/null 2>&1 || true
97+
if "$XL" install "mcpp@${VER}" -y -g -u >&2; then
98+
installed=1
99+
break
100+
fi
101+
if [ "$i" -lt "$attempts" ]; then
102+
echo "note: mcpp@${VER} not installable yet (attempt $i/$attempts) — the published" >&2
103+
echo " index artifact may not have propagated; retrying in ${delay}s" >&2
104+
sleep "$delay"
105+
fi
106+
done
107+
[ "$installed" = 1 ] || {
108+
echo "FAIL: could not install mcpp@${VER} after $attempts attempts." >&2
109+
echo " Either the index never published it (check the xim-pkgindex bump PR)" >&2
110+
echo " or the version does not exist." >&2
111+
exit 1; }
112+
113+
# ── 3. prove the shim resolves it ────────────────────────────────────────────
114+
# `install` succeeding means the bytes landed, not that `mcpp` runs them, and
115+
# every later step in these jobs invokes the bare shim. Asserting here is what
116+
# turns any future ambient redirection — a workspace pin, a stale xvm
117+
# activation, a PATH surprise — into a named failure instead of a matrix that
118+
# silently tests the wrong binary and reports green.
119+
# Resolve it the way the JOB will: through PATH. That is the entire point of
120+
# the assertion — the steps after this one type `mcpp`, so `mcpp` is what has
121+
# to be checked. Probing a guessed install path instead would verify a binary
122+
# nobody runs, and would happily pass while PATH pointed somewhere else.
123+
# (The known locations are only a fallback for a PATH that is not exported
124+
# yet; `subos/current` and `subos/default` are both in use across the jobs.)
125+
MCPP=$(command -v "mcpp${EXE}" 2>/dev/null || true)
126+
for cand in "$XL_HOME/.xlings/subos/current/bin/mcpp${EXE}" \
127+
"$XL_HOME/.xlings/subos/default/bin/mcpp${EXE}"; do
128+
[ -n "$MCPP" ] && break
129+
[ -x "$cand" ] && MCPP="$cand"
130+
done
131+
[ -n "$MCPP" ] && [ -x "$MCPP" ] || {
132+
echo "FAIL: mcpp is not on PATH after a successful install" >&2; exit 1; }
133+
134+
probe() { "$MCPP" --version 2>/dev/null | head -1 \
135+
| grep -oE '[0-9]+(\.[0-9]+)+' | head -1 || true; }
136+
137+
GOT=$(probe)
138+
if [ "$GOT" != "$VER" ]; then
139+
# `-u` is install-time activation; `xlings use` is the explicit switch, and
140+
# is what xlings itself suggests when an install leaves the shim behind
141+
# ("installed, but 'mcpp' still resolves to X — `xlings use mcpp X` to
142+
# switch"). Doing both is belt and braces, not redundancy: they are two
143+
# different code paths in xlings and only one of them is load-bearing here.
144+
# The assertion below stays final either way — this completes the
145+
# activation, it does not excuse a failure to activate.
146+
echo "note: shim reported '${GOT:-?}' after install; switching explicitly" >&2
147+
"$XL" use mcpp "$VER" >&2 2>/dev/null || true
148+
GOT=$(probe)
149+
fi
150+
151+
[ "$GOT" = "$VER" ] || {
152+
echo "FAIL: mcpp resolves to '${GOT:-?}' but the version under test is '$VER'" >&2
153+
echo "hint: something is redirecting the shim. A .xlings.json workspace pin in" >&2
154+
echo " the working directory is the usual cause (this script removes the" >&2
155+
echo " repo's own, but a parent directory can carry one too); a stale xvm" >&2
156+
echo " activation is the other." >&2
157+
exit 1; }
158+
159+
echo "version under test: $MCPP ($GOT)" >&2
160+
echo "$MCPP"

‎.github/workflows/bootstrap-macos.yml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ jobs:
1717
# Dormant (workflow_dispatch only), but kept in step with the rest —
1818
# check_version_pins.sh holds it there. Floor: 0.4.69, below which the
1919
# index cannot resolve two packages that share a short name.
20-
XLINGS_VERSION: '2026.7.28.4'
20+
XLINGS_VERSION: '2026.8.4.1'
2121
steps:
2222
- uses: actions/checkout@v4
2323

‎.github/workflows/ci-fresh-install.yml‎

Lines changed: 64 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -91,19 +91,42 @@ jobs:
9191
esac
9292
echo "version=$VER" >> "$GITHUB_OUTPUT"
9393
echo "version under test: $VER"
94-
- name: Wait for xim-pkgindex to track the released mcpp
94+
- name: Wait for the PUBLISHED index artifact to track the released mcpp
9595
if: ${{ github.event_name == 'workflow_run' }}
9696
env:
9797
VER: ${{ steps.resolve.outputs.version }}
9898
run: |
99-
echo "released: $VER — waiting for index..."
100-
for i in $(seq 1 30); do
101-
if curl -fsSL "https://raw.githubusercontent.com/openxlings/xim-pkgindex/main/pkgs/m/mcpp.lua" | grep -q "\"$VER\""; then
102-
echo "index tracks $VER (after $((i*30))s)"; exit 0
99+
# Poll the ARTIFACT, not the git file.
100+
#
101+
# This used to curl raw.githubusercontent.com/openxlings/xim-pkgindex
102+
# — the index's git source of truth, which updates the instant the
103+
# bump PR merges. But the jobs install from the PUBLISHED ARTIFACT
104+
# (xlings-res/xim-index → pointer → tarball), and that channel lags
105+
# git by however long `Publish Index Artifact` plus release-CDN
106+
# propagation takes. Measured on the 2026.8.3.5 release: this guard
107+
# reported ready, and all 11 jobs then failed with
108+
# [error] package 'mcpp@2026.8.3.5' not found
109+
# A guard that measures a channel nobody installs from is not a guard.
110+
#
111+
# This narrows the window; it cannot close it, because the CDN
112+
# propagates per edge and the runner that polls is not the runner
113+
# that installs. install_released_mcpp.sh retries from the consumer
114+
# side for exactly that residue — this step exists so the retry is
115+
# rarely needed, not so it can be removed.
116+
echo "released: $VER — waiting for the published index artifact..."
117+
for i in $(seq 1 40); do
118+
ptr=$(curl -fsSL "https://github.com/xlings-res/xim-index/releases/download/latest/xim-index-latest.json" 2>/dev/null || true)
119+
# One line on purpose: an indented heredoc inside a YAML block
120+
# scalar is a trap — unindented content silently ends the block.
121+
name=$(printf '%s' "$ptr" | python3 -c 'import json,sys; d=json.load(sys.stdin); n=d.get("indexes",{}).get("xim",d); print(n.get("artifact",{}).get("name",""))' 2>/dev/null || true)
122+
if [ -n "$name" ] && curl -fsSL \
123+
"https://github.com/xlings-res/xim-index/releases/download/latest/$name" \
124+
| tar -xzO --wildcards '*pkgs/m/mcpp.lua' 2>/dev/null | grep -q "\"$VER\""; then
125+
echo "published index artifact ($name) tracks $VER (after $((i*30))s)"; exit 0
103126
fi
104127
sleep 30
105128
done
106-
echo "::error::index never tracked $VER within 15min — merge the bump PR (openxlings/xim-pkgindex) and re-run"
129+
echo "::error::the published index artifact never tracked $VER within 20min — check that the xim-pkgindex bump PR merged AND that Publish Index Artifact ran"
107130
exit 1
108131
- name: No wait needed (manual/cron trigger)
109132
if: ${{ github.event_name != 'workflow_run' }}
@@ -129,16 +152,17 @@ jobs:
129152
env:
130153
XLINGS_NON_INTERACTIVE: '1'
131154
run: |
132-
curl -fsSL https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.sh | bash -s v2026.7.28.4
155+
curl -fsSL https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.sh | bash -s v2026.8.4.1
133156
echo "$HOME/.xlings/subos/current/bin" >> "$GITHUB_PATH"
134157
135158
- name: Install mcpp and config mirror
159+
shell: bash
136160
run: |
137-
# The release tarball bundles a pkgindex snapshot frozen at
138-
# build time; refresh it so the pinned mcpp resolves.
139-
xlings update
140-
xlings install "mcpp@${MCPP_PIN}" -y -g # install to global
141-
mcpp --version
161+
# ONE implementation for "make the released mcpp@X be what `mcpp`
162+
# runs, and prove it" — see .github/tools/install_released_mcpp.sh
163+
# for the three defects the inline version had (workspace pin, no
164+
# activation, and waiting on the wrong index channel).
165+
bash .github/tools/install_released_mcpp.sh "${MCPP_PIN}" "$(pwd)"
142166
mcpp self config --mirror GLOBAL
143167
144168
echo "mcpp debug info:"
@@ -268,7 +292,7 @@ jobs:
268292

269293
- name: Install xlings + mcpp
270294
run: |
271-
curl -fsSL https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.sh | bash -s v2026.7.28.4
295+
curl -fsSL https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.sh | bash -s v2026.8.4.1
272296
# Deliberately NOT writing to $GITHUB_PATH here. On container
273297
# images that declare no PATH in their config (opensuse/
274298
# tumbleweed), appending a single dir to GITHUB_PATH makes the
@@ -278,11 +302,14 @@ jobs:
278302
# exports PATH itself, so the append is redundant anyway.
279303
280304
- name: Configure mcpp
305+
shell: bash
281306
run: |
282307
export PATH="$HOME/.xlings/subos/current/bin:$PATH"
283-
xlings update
284-
xlings install "mcpp@${MCPP_PIN}" -y -g
285-
mcpp --version
308+
# ONE implementation for "make the released mcpp@X be what `mcpp`
309+
# runs, and prove it" — see .github/tools/install_released_mcpp.sh
310+
# for the three defects the inline version had (workspace pin, no
311+
# activation, and waiting on the wrong index channel).
312+
bash .github/tools/install_released_mcpp.sh "${MCPP_PIN}" "$(pwd)"
286313
mcpp self config --mirror GLOBAL
287314
288315
- name: "Regression: new → run (loader env must not crash /bin/sh)"
@@ -336,15 +363,17 @@ jobs:
336363
# (older ones carry minos=15 and refuse to start).
337364
# v0.4.51+: in-process sha256 — this image has no sha256sum
338365
# binary, so pinned fetches failed before it.
339-
curl -fsSL https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.sh | bash -s v2026.7.28.4
366+
curl -fsSL https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.sh | bash -s v2026.8.4.1
340367
echo "$HOME/.xlings/subos/current/bin" >> "$GITHUB_PATH"
341368
342369
- name: Install mcpp and config mirror
370+
shell: bash
343371
run: |
344-
# Refresh the bundled pkgindex snapshot so the pinned mcpp resolves.
345-
xlings update
346-
xlings install "mcpp@${MCPP_PIN}" -y -g # install to global
347-
mcpp --version
372+
# ONE implementation for "make the released mcpp@X be what `mcpp`
373+
# runs, and prove it" — see .github/tools/install_released_mcpp.sh
374+
# for the three defects the inline version had (workspace pin, no
375+
# activation, and waiting on the wrong index channel).
376+
bash .github/tools/install_released_mcpp.sh "${MCPP_PIN}" "$(pwd)"
348377
mcpp self config --mirror GLOBAL
349378
350379
echo "mcpp debug info:"
@@ -413,16 +442,17 @@ jobs:
413442
$xlingsbin | Out-File -Append -FilePath $env:GITHUB_PATH -Encoding utf8
414443
415444
- name: Install mcpp and config mirror
416-
shell: pwsh
445+
shell: bash
417446
run: |
418-
# Refresh the bundled pkgindex snapshot so the pinned mcpp resolves.
419-
xlings update
420-
xlings install "mcpp@$env:MCPP_PIN" -y -g --verbose
421-
422-
cat "$env:USERPROFILE\.xlings\.xlings.json"
423-
mcpp --version
447+
# ONE implementation for "make the released mcpp@X be what `mcpp`
448+
# runs, and prove it" — see .github/tools/install_released_mcpp.sh
449+
# for the three defects the inline version had (workspace pin, no
450+
# activation, and waiting on the wrong index channel).
451+
bash .github/tools/install_released_mcpp.sh "${MCPP_PIN}" "$(pwd)"
424452
mcpp self config --mirror GLOBAL
425453
454+
cat "$USERPROFILE/.xlings/.xlings.json" || true
455+
426456
- name: "LLVM: mcpp new → run"
427457
shell: pwsh
428458
run: |
@@ -524,11 +554,13 @@ jobs:
524554
$xlingsbin | Out-File -Append -FilePath $env:GITHUB_PATH -Encoding utf8
525555
526556
- name: Install mcpp and config mirror
527-
shell: pwsh
557+
shell: bash
528558
run: |
529-
xlings update
530-
xlings install "mcpp@$env:MCPP_PIN" -y -g --verbose
531-
mcpp --version
559+
# ONE implementation for "make the released mcpp@X be what `mcpp`
560+
# runs, and prove it" — see .github/tools/install_released_mcpp.sh
561+
# for the three defects the inline version had (workspace pin, no
562+
# activation, and waiting on the wrong index channel).
563+
bash .github/tools/install_released_mcpp.sh "${MCPP_PIN}" "$(pwd)"
532564
mcpp self config --mirror GLOBAL
533565
534566
# The self-check, the fallback, persistence, a self-contained exe, and

‎.github/workflows/ci-linux-e2e.yml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -123,7 +123,7 @@ jobs:
123123
124124
- name: Bootstrap xlings + released mcpp
125125
run: |
126-
curl -fsSL https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.sh | bash -s v2026.7.28.4
126+
curl -fsSL https://raw.githubusercontent.com/openxlings/xlings/main/tools/other/quick_install.sh | bash -s v2026.8.4.1
127127
export PATH="$HOME/.xlings/subos/current/bin:$PATH"
128128
xlings update
129129
xlings install mcpp -y -g

‎.github/workflows/cross-build-test.yml‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -118,7 +118,7 @@ jobs:
118118
# release assets were uploaded in a broken state (records present,
119119
# blobs missing → 404 on GET); re-uploaded clean. The stale-INDEX
120120
# half is handled by the marker-clear below.
121-
XLINGS_VERSION: '2026.7.28.4'
121+
XLINGS_VERSION: '2026.8.4.1'
122122
run: |
123123
tarball="xlings-${XLINGS_VERSION}-linux-x86_64.tar.gz"
124124
curl -fsSL -o "/tmp/${tarball}" \
@@ -255,7 +255,7 @@ jobs:
255255
- name: Bootstrap mcpp via xlings
256256
env:
257257
XLINGS_NON_INTERACTIVE: '1'
258-
XLINGS_VERSION: '2026.7.28.4'
258+
XLINGS_VERSION: '2026.8.4.1'
259259
run: |
260260
tarball="xlings-${XLINGS_VERSION}-linux-x86_64.tar.gz"
261261
curl -fsSL -o "/tmp/${tarball}" \

0 commit comments

Comments
 (0)