Skip to content

Commit 7993d9e

Browse files
speak-agentspeak-agent
committed
fix(ci): ci-fresh-install had two defects, both firing after every release
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 7993d9e

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)