Compare commits

..
269 Commits
Author SHA1 Message Date
noah 1fa4aa5532 Merge pull request 'next: find Alkane OS boards in the scan; install/update/uninstall only where they apply' (#35) from feature/alkane-scan into next
source / check (pull_request) Skipped
verify / verify (pull_request) Successful in 16m28s
verify / verify-windows (pull_request) Successful in 9m18s
next-build / windows (push) Successful in 4m21s
next-build / candidate (push) Successful in 19m23s
2026-11-12 15:13:17 -07:00
noahandClaude Opus 5.5 315c595714 gui: find boards running Alkane OS in the scan; offer install/update/uninstall only where they apply
verify / verify (pull_request) Skipped
source / check (pull_request) Successful in 7m17s
The fleet scan (asic-rs) recognises miners by their cgminer socket or vendor
web UI. A board running Alkane OS exposes neither, so it never appeared and
could not be right-clicked; the periodic refresh also marked it offline.

- alkane_detect: probe addresses asic-rs does not identify over HTTP:
  GET /api/identity (alkane-os 0.1.2+: os, version, board, MAC, hostname),
  falling back to /api/summary's "alkane-os" STATUS for older images. Used by
  the scan and the refresh. Rows show Firmware "Alkane" with the version, MAC,
  hostname and control board (XIL (C49) for zynq-7010).
- Context menu: "Install alkane OS..." only for a supported board (control
  board alkane-os has an image for; a stock Antminer on XIL (C49), or by model
  S17/S17 Pro/T17 when the stock miner software is down and reports no board)
  that is not running Alkane; "Update alkane OS..." for a supported board
  already running it (same dialog, updated in place); "Uninstall alkane OS"
  only for boards running Alkane. Mixed selections get neither install nor
  update.
- Docs updated.

Verified live on the bench S17: running Alkane -> found as Alkane 0.1.2,
XIL (C49), update + uninstall offered; restored to stock -> found as Antminer
S17 Stock, install offered. Unit tests for the probe parsing and the menu
rules; an ignored live scan test (ALKANE_TEST_SCAN_RANGE).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-12 16:01:40 -06:00
noah 50102800a3 Merge pull request 'main: promote next (alkane-os install/uninstall, genuine-firmware restore, Zynq fixes)' (#32) from next into main
build-test-release / windows (push) Successful in 7m25s
build-test-release / release (push) Successful in 19m26s
2026-11-12 13:11:50 -07:00
noah a998d7a3e3 Merge pull request 'next: ignore the curl-dependent asset-fetch test on Windows' (#34) from feature/afw-os-bundle into next
next-build / windows (push) Successful in 5m12s
next-build / candidate (push) Successful in 5m12s
verify / verify (pull_request) Successful in 11m50s
source / check (pull_request) Skipped
verify / verify-windows (pull_request) Successful in 6m55s
2026-11-12 12:51:54 -07:00
noahandClaude Opus 5.5 cd02ff47a5 test: ignore the curl-dependent asset-fetch test on Windows
verify / verify (pull_request) Skipped
source / check (pull_request) Successful in 4m15s
stock_method's fetch test shells out to curl. main's verify-windows gate runs
the test binaries under Wine, where curl is not on PATH, so it failed there
("could not run curl: program not found") and, being the first failure,
stopped the remaining Windows test binaries. Mark it ignored on Windows with
the reason, so it shows as ignored rather than passing silently. Locally under
Wine all headless crates' Windows tests pass; Windows-target clippy is clean.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-12 13:47:20 -06:00
noah 836a531e93 Merge pull request 'next: update the PR change-surface self-test for the GUI's new dependencies' (#33) from feature/afw-os-bundle into next
source / check (pull_request) Skipped
verify / verify (pull_request) Successful in 11m22s
verify / verify-windows (pull_request) Failing after 7m5s
next-build / windows (push) Failing after 7s
next-build / candidate (push) Skipped
2026-11-12 12:24:50 -07:00
noahandClaude Opus 5.5 8d72f07cf0 ci: update the PR change-surface self-test for the GUI's new dependencies
verify / verify (pull_request) Skipped
source / check (pull_request) Successful in 5m16s
alkane-gui now depends on alkane-flash and alkane-artifacts (right-click
install/uninstall, release picker), so a change in either reaches the GUI
graph and needs the full build. pr-surface.py already returns [] (not
headless) for those; the self-test still expected the old headless set and
failed main's verify gate. Pin the new graph: artifacts -> [], flash -> [],
access + flash -> [], access + cli -> [access, cli].

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-12 13:18:58 -06:00
noah bdea96229b Merge pull request 'next: rustfmt the afw/stock work (no behaviour change)' (#31) from feature/afw-os-bundle into next
next-build / candidate (push) Successful in 4m56s
source / check (pull_request) Skipped
verify / verify (pull_request) Failing after 31s
next-build / windows (push) Successful in 4m11s
verify / verify-windows (pull_request) Skipped
2026-11-12 12:13:07 -07:00
noahandClaude Opus 5.5 d318b734fa style: rustfmt the afw/stock work (no behaviour change)
verify / verify (pull_request) Skipped
source / check (pull_request) Successful in 4m17s
main's verify gate runs cargo fmt --check on the first-party crates; next's
gate does not, so the afw/stock feature work reached next unformatted. Pure
cargo fmt output. clippy -D warnings (workspace and GUI) and all tests pass.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-12 13:01:21 -06:00
noah 4305da5e57 Merge pull request 'next: Zynq restore uses the factory device tree; tier-2 in-place update and verify-live for Zynq' (#30) from feature/afw-os-bundle into next
next-build / windows (push) Successful in 3m56s
next-build / candidate (push) Successful in 4m18s
Merge pull request #30: Zynq restore uses the factory device tree; tier-2 in-place update and verify-live for Zynq
2026-11-12 11:04:00 -07:00
noahandClaude Opus 5.5 dc787f1f3b flash: Zynq tier-2 update in place through the verified writer; verify-live for Zynq
verify / verify (pull_request) Skipped
source / check (pull_request) Successful in 4m24s
The Zynq tier-2 install wrote raw images at device-relative offsets on
/dev/mtd0 and /dev/mtd1. On the current alkane image those are stock-cfg and
alkane-cfg, not the boot regions, so it would have erased alkane-cfg first, and
its raw zImage/cpio are not bootable by the stock U-Boot. Its preflight only
checked that mtd0 and mtd1 existed.

- Add StockMethod::update_in_place: refuses a board not running alkane,
  re-registers the boot regions (as restore does), saves every slot locally
  before any erase, writes rootfs/dtb/kernel as the uImages the stock U-Boot
  boots via the shared target builder (BOOT.bin guard, md5 readback), reboots
  and waits for alkane. --dry-run reports the live storage map and the plan.
- boards::zynq keeps the manifest gate; the plan is now in absolute NAND slots
  with ceilings that leave room for the uImage header. The stale writer and
  preflight are removed.
- CLI: Zynq preflight/install use the new path before the generic user
  transport connects.
- verify-live gains a Zynq check (HTTP marker, case-insensitive, plus root SSH
  reporting alkane and the installed kernel; prints the kernel cmdline). It
  previously fell through to the CV1835 check.
- Tests for the protected alkane map, registered and split boot maps, slot
  overrun, and the BOOT.bin guard.

Verified on an S17 (Zynq-7010): dry run, install from a RAM-booted alkane,
NAND boot confirmed on the serial console, verify-live PASS.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-12 11:49:53 -06:00
noahandClaude Opus 4.8 f63127d633 flash: restore uses the correct per-board device tree, not the package's
The kernel device tree is never in Bitmain's distributable firmware: all OTA
packages ship none, and the SD recovery image preserves the factory dtb rather
than writing one. The device tree I was taking from the SD recovery package was
its SD-boot dtb (a different partition layout), which does not match the genuine
rootfs and reboot-loops the board.

Fix: restore now takes only the genuine kernel + rootfs from the vendor package
(RestoreImages drops the dtb field), and the method supplies the correct
per-board device tree itself (fetched + verified from the public assets repo, the
same way the NAND-exposing helper is fetched). This pairs genuine kernel/rootfs
with the factory dtb that matches their partition layout. Any genuine package now
works (an OTA .tar.gz as well as an SD .zip), since the package's own dtb is no
longer needed.

cli/gui: --stock-firmware / the uninstall dialog no longer require a package with
a device tree. docs updated.

NOTE: not yet hardware-verified - the bench S17 is mid-recovery (serial-link
hardware issue) and must be brought back before this can be proven on the board.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-11 21:07:44 -06:00
noah b02a14bcfc Merge pull request 'next: refresh to main + afw OS bundle (install/uninstall, GUI, genuine-firmware restore)' (#29) from release/next-refresh into next
next-build / windows (push) Successful in 4m25s
next-build / candidate (push) Successful in 6m16s
2026-11-11 17:32:59 -07:00
noahandClaude Opus 4.8 20dff12c05 ci: align next-only bench-pages.yml to the canonical runner image
verify / verify (pull_request) Skipped
source / check (pull_request) Successful in 4m27s
The merge brought next's bench-pages.yml with its stale October runner-image
pin; align it to ci/runner-image.txt so the source gate passes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-11 18:27:57 -06:00
noah ac6bc20c68 Merge branch 'feature/afw-os-bundle' into release-next-stage
source / check (pull_request) Failing after 20s
verify / verify (pull_request) Skipped
2026-11-11 18:21:46 -06:00
noah 8f0accf21d Merge remote-tracking branch 'origin/main' into release-next-stage
# Conflicts:
#	.gitea/workflows/ci-badge.yml
#	.gitea/workflows/next.yml
#	.gitea/workflows/release.yml
#	.gitea/workflows/source.yml
#	.gitea/workflows/verify.yml
#	Cargo.lock
#	README.md
#	ci/bench-badge.py
#	ci/bench_history.py
#	ci/cleanup-generated.py
#	ci/coverage.sh
#	ci/gen-badges.py
#	ci/publish-metrics.py
#	ci/test-bench-badge.py
#	ci/test-bench-history.py
#	crates/alkane-access/src/lib.rs
#	crates/alkane-artifacts/Cargo.toml
#	crates/alkane-artifacts/src/lib.rs
#	crates/alkane-cli/Cargo.toml
#	crates/alkane-cli/src/main.rs
#	crates/alkane-gui/src/model.rs
2026-11-11 18:21:46 -06:00
noahandClaude Opus 4.8 69c5023f1e ci: bake the read-only release-reader token into GUI release builds
Pass ALKANE_EMBEDDED_TOKEN (a repo Actions secret, a restricted read-only token
scoped to the alkane-os repo) into the release and candidate workflow builds, so
the published GUI can list the private alkane-os releases in its install picker
with no user setup. The source tree carries no secret (option_env!); the value
lives only in CI-built binaries.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-11 18:11:26 -06:00
noahandClaude Opus 4.8 b242e34ca0 flash: restore to stock from genuine Bitmain firmware files
Restore-to-stock now writes the genuine Bitmain stock images (parsed from a
vendor firmware package) back to NAND, instead of carrying carved stock blobs.

- stock_firmware: new parser for genuine Bitmain Antminer packages - the OTA
  update .tar.gz (outer sign wrapper -> inner fw.tar.gz) and the SD recovery
  .zip. Extracts BOOT.bin / devicetree.dtb / uImage (kernel) / uramdisk (rootfs)
  and verifies the rootfs md5 when the package lists one. Shells out to the
  system tar/unzip. Verified against real S17 packages.
- stock: restore_to_stock now takes the stock images (RestoreImages); the stock
  kernel/dtb/rootfs are no longer carried as assets. The boot regions are not
  exposed to Linux on alkane, so the existing NAND-registration helper is kept to
  make them writable, then the supplied genuine images are written at the vendor
  offsets (dtb 0x1a00000, kernel 0x2000000, rootfs; BOOT.bin preserved).
- The SD recovery image is the complete source: it includes the device tree,
  which the stock legacy-uImage kernel needs at 0x1a00000 and which the OTA
  update packages omit. Restore requires it and points the user to the SD image
  when a package has no dtb.
- Post-reboot the board returns to stock under its stock MAC and typically takes
  a new DHCP lease, so a wait on the original address is best-effort and no longer
  reported as a failure.
- cli: afw restore-stock takes --stock-firmware <file>. gui: the uninstall dialog
  takes the firmware file path.

Also clear the branch's clippy debt so the full gate passes: a type alias/allow
for the hardware map tables and multi-arg write functions, plus small mechanical
fixes (useless format, op-ref, collapsible match). wx-rs patch 0011 records the
wxWidgets 3.2 build-compat edits.

Verified on the bench S17: install stock -> alkane, then restore alkane -> stock
from the genuine Bitmain SD recovery image; the board booted genuine stock
(stock kernel, stock device tree 5-partition NAND layout, Angstrom userspace),
confirmed on the serial console.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-11 18:08:09 -06:00
noahandClaude Opus 4.8 82492231bc gui: right-click install/uninstall of alkane-os via the self-contained engine
Wire the GUI to the toolkit's own compiled-in, network-only stock<->alkane engine
(alkane-flash::stock) and the .afw fetch/verify (alkane-artifacts), so a scanned
control board can be right-clicked to:

  - Install alkane OS (from stock): scans alkane-os releases on Gitea, picks one
    (newest first; pre-releases marked), downloads+verifies the .afw, and installs
    it onto each selected board over the network. Optional board password and an
    allow-unsigned (bench) toggle; typed FLASH confirmation.
  - Uninstall alkane OS (restore to stock): restores each selected board to
    genuine stock over the network, with the board's alkane root credential and a
    typed FLASH confirmation.

Both run on a background thread (stock_ops.rs), streaming progress/results to the
status bar, and share the exclusivity guards so they never race a scan/flash/
restore. These use the same engine the CLI drives; the GUI's older asic-rs
firmware-upload path stays disabled.

alkane-artifacts: add list_releases + fetch_afw_url for the release picker, and an
optional build-time embedded read-only token (option_env!("ALKANE_EMBEDDED_TOKEN"))
so a distributed GUI can scan the private alkane-os releases with no setup; the
env token still wins, and no secret is in the source tree.

wx-rs (vendored, patched): build on system wxWidgets 3.2 - guard the 3.3-only
wxApp::SetAppearance/Appearance behind wxCHECK_VERSION(3,3,0), and emit GTK's own
shared libs (pkg-config --libs gtk+-3.0) at link time since the widget bridge
calls GTK directly. Enables the Linux GUI release build.

docs/install.md: document the GUI actions and that the stock-assets repo is now
public (no token for install/restore; only release scanning needs one).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qKwKxq3oUPDKWicM6i
2026-11-11 14:18:24 -06:00
noahandClaude Opus 4.8 27e1dc15e8 docs: install guide reflects runtime-fetched assets + Gitea token
install --from-stock and restore-stock fetch their per-board assets from the
private blueflare/alkane-stock-assets repo on first use, so document the
required Gitea token (ALKANE_RELEASE_TOKEN/GITEA_TOKEN, passed via a 0600 curl
config), the ALKANE_STOCK_ASSETS_BASE override, --allow-unsigned for bench
images, and --password-file for restore.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBPjAXpCwmigUov5eQk
2026-11-11 11:21:33 -06:00
noahandClaude Opus 4.8 684be52d5a flash: stock method fetches its assets at runtime from Gitea (no embedded blobs)
The compiled-in network-only stock method (DSH-authored, sealed, not read or
edited by Claude) no longer embeds its ~30 MB of assets. It fetches them at
runtime from the private Gitea repo blueflare/alkane-stock-assets (release
zynq-7010-v1), authenticating with a token from ALKANE_RELEASE_TOKEN or
GITEA_TOKEN passed through a 0600 curl config (never argv), verifying each asset
against an embedded SHA-256, and caching them locally with re-verification. The
base URL is overridable via ALKANE_STOCK_ASSETS_BASE.

Result: the CLI binary drops from 31.7 MB to ~1.0 MB and the repo carries no
vendor blobs. The toolkit is still fully self-contained at runtime (no external
helper, no dsh/AI); it downloads its own assets from our Gitea, network-only.

Verified by Claude without reading the method:
- cargo build -p alkane-cli --release: clean, binary ~1.0 MB.
- cargo test -p alkane-flash: 64 passed.
- Live on the bench S17 over the network via the real CLI (assets fetched from
  Gitea on first use): install --from-stock took genuine stock -> alkane
  (console "Alkane", dropbear_2026.93), restore-stock took alkane -> genuine
  stock (lighttpd 401 antMiner, 22 closed). Board left on stock.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBPjAXpCwmigUov5eQk
2026-11-11 11:19:45 -06:00
noahandClaude Opus 4.8 76de56fef5 flash: make stock crossing self-contained (compiled-in method, no runtime helper)
Replace the ALKANE_STOCK_HELPER external-helper seam with a compiled-in method
module so the toolkit installs from stock and restores to stock entirely on its
own. A user's machine needs only this binary: no external helper, no runtime
dependency on any other tool, and no AI tooling in the toolkit.

- stock.rs is now the Claude-owned boundary: the StockMethod trait and
  StockError, plus thin install_from_stock/restore_to_stock entry points that
  call the compiled-in method.
- stock_method.rs holds the network-only method bodies. By project rule the
  stock-side steps are authored by DeepSeek Harness and are not read, reviewed,
  or edited by Claude; it is plain self-contained Rust compiled into the binary.
  Committed here as a build stub returning NotImplemented until DSH authors it.
- CLI no longer checks stock::available() or forwards the board credential
  through the environment to a helper; it reads the credential in-process and
  passes it to the method. install --from-stock and restore-stock call the
  in-process method directly.
- docs/install.md drops the ALKANE_STOCK_HELPER env instructions.

The install-from-stock path is network-only.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBPjAXpCwmigUov5eQk
2026-11-11 09:55:37 -06:00
noahandClaude Opus 4.8 ae9e2c67cc toolkit: --latest scans the releases list (finds pre-releases) + forward board cred to the stock helper
- fetch: resolve the latest .afw from the releases LIST (newest first) instead of
  releases/latest, so an early/bench pre-release is still found by --latest.
- restore-stock and install --from-stock now resolve the board password (via the
  usual --password-file / ALKANE_BOARD_PASSWORD[_FILE]) and export it to the
  environment the sealed helper inherits, so the restore (which runs from the
  alkane board and needs its root) works without the operator setting env by hand.

Hardware-proven on the S17 this session: toolkit `restore-stock` (alkane->stock)
and `install --from-stock` (stock->alkane, network-only helper) both PASS,
independently verified (stock = 401 lighttpd/antMiner, tcp22 closed; alkane =
dropbear + the UI console sign-in page on :80). Builds clean, tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBPjAXpCwmigUov5eQk
2026-11-11 09:34:44 -06:00
noahandClaude Opus 4.8 400edbe913 toolkit: install from local/latest afw + from-stock/restore seams + fix zynq offsets
Integrate the SDK installer into the toolkit so it can put alkane-os on a
compatible miner (for now the Antminer S17 / zynq-7010) from a local .afw or an
auto-pulled latest release, and remove it (back to stock). Release host is the
self-hosted Gitea (GitHub is retired).

- FIX (brick risk): boards/zynq.rs carried the superseded stage-2 offsets
  (BOOTBIN_PRESERVE 0x2200000, kernel 0x2200000, dtb 0x2700000). Corrected to the
  live S17 / SDK-plan layout: BOOT.bin floor 0x1a00000, dtb 0x1a00000, kernel
  0x2000000 (slot 0x800000), rootfs mtd1. The tier-2 update now writes the right
  slots; test updated to the new ceiling.
- alkane-artifacts/fetch.rs: resolve and download the latest .afw for a board
  from Gitea releases/latest (curl + serde_json), token read from
  ALKANE_RELEASE_TOKEN/GITEA_TOKEN at run time and passed via a 0600 curl config,
  never argv, never stored.
- alkane-flash/stock.rs: the seam to the sealed, DSH-owned stock-side methods
  (install-from-stock, restore-to-stock). Interface only - an external
  ALKANE_STOCK_HELPER the toolkit invokes and then verifies the board itself; the
  method is never embedded, read, or reviewed here.
- alkane-cli: new `afw compat` (shows supported boards), `afw fetch-latest`,
  `afw install --latest [--board] [--from-stock]`, and `afw restore-stock`. The
  install/restore commands gate on a supported board. --from-stock routes the
  first install through the sealed helper; the default install path is the
  tier-2 update of a board already on alkane.
- docs/install.md documents the flow and the two env seams.

alkane-artifacts + alkane-flash + alkane-cli build clean, 71 tests pass, the new
files are clippy-clean (the one type_complexity warning is pre-existing in
afw.rs, untouched). No emojis.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBPjAXpCwmigUov5eQk
2026-11-10 22:12:47 -06:00
noahandClaude Opus 4.8 462ced01a6 a113d: runtime UBI self-update flow + scrub anthillos->alkane
Rework the a113d flash module to match the NAND-enabled image: instead of
expecting an already-mounted ubifs volume, it detects the nvdata MTD from
/proc/mtd (the only MTD our DT exposes), ubiattach-es it, discovers the UBI
volume name (never assumed), mounts it, and overwrites the three OS files under
the alkane/ directory with staged + read-back md5 verification, then unmounts
and detaches. The structural brick guard is unchanged and now reinforced by the
DT: mtd0-5 are not MTD devices at all, and every destination is a bare basename
under alkane/. Renamed the directory anthillos -> alkane throughout (receipt
reports the discovered volume). New unit test for the /proc/mtd nvdata parse;
full flash suite 56 green.

NOTE: the live attach/mount/write flow is not yet hardware-validated - it needs
a NAND-enabled a113d image staged once via the stock/dsh path to test against.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qHxYpv7yf7Ah57g4rQ
2026-11-06 23:02:55 -06:00
noahandClaude Opus 4.8 c79ee1315d a113d (Amlogic AXG/S21 Pro): UBI-file flash module + CLI routing
Add the S21 Pro-class Amlogic A113D/AXG flash module to the toolkit, matching
the Zynq-7010 treatment, plus CLI routing for plan/preflight/install.

- crates/alkane-flash/src/boards/a113d.rs: A113dPlan::from_afw validates the
  verified manifest (a113d, arm64, preserve, no fip/spl/tpl/u-boot member,
  exactly kernel/dtb/rootfs with arm64-image/fdt/uimage formats, per-image
  ceilings and total <= nvdata, plus independent magic checks and a
  defense-in-depth refusal of any non-nvdata partition carrying an image).
  The installer is file-only: it resolves the anthillos/ directory on a
  mounted ubifs volume and copies the three files there with staged + read-back
  md5 verification. The brick guard is structural - there is no flash_erase,
  nandwrite or dd-to-/dev/mtd anywhere in the module, so the FIP (mtd0/1) and
  stock boot (mtd4) and mtd2/3/5 can never be touched; every destination is
  checked to be a bare basename.
- crates/alkane-flash/src/boards/mod.rs: register the module.
- crates/alkane-cli/src/main.rs: route a113d bundles through afw
  plan/preflight/install.
- crates/alkane-artifacts/src/afw.rs: correct the a113d / a113d-s21pro board
  profile from armv7 to arm64 (the A113D/AXG is an arm64 SoC).

8 new a113d unit tests; full suite: 55 alkane-flash, 12 alkane-artifacts, all
pass. End-to-end verified: make-afw.sh -> check-afw.py -> alkane-cli afw plan
on a stub a113d bundle.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qHxYpv7yf7Ah57g4rQ
2026-11-06 21:02:06 -06:00
noahandClaude Opus 4.8 cce24b6880 Add zynq-7010 toolkit flash module (tier-2 update, offset writes, BOOT.bin guard)
The toolkit now flashes the Zynq update path through the CLI like am335x/cv1835.
- boards/zynq.rs: ZynqPlan::from_afw (validates the zynq-7010 .afw: armv7, preserve,
  the kernel/dtb/rootfs image set, zimage/fdt/cpio-gzip formats, size ceilings,
  rejects any bootloader/spl/BOOT.bin member and a non-zImage kernel), preflight
  (alkane source, root, flash tools, mtd0/mtd1, BOOT.bin-preserve guard), install
  (OFFSET-AWARE: nanddump/flash_erase/nandwrite --start at the device-relative
  slot offset - kernel 0x2200000, dtb 0x2700000 in /dev/mtd0, rootfs in /dev/mtd1
  - with per-region backup + md5 readback), and a hard guard that refuses any
  /dev/mtd0 write below BOOTBIN_PRESERVE so BOOT.bin can never be clobbered.
- alkane-artifacts: add the strict 'zimage' image format (magic 0x016f2818 at 0x24).
- alkane-cli: route zynq-7010 through afw plan/preflight/install.
- 6 module tests (good plan, non-zImage, oversize, bootloader member, wrong
  board/arch, every-mtd0-target-above-BOOT.bin). Full flash suite 47 green,
  artifacts green; the real bundle renders its plan through the CLI.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qHxYpv7yf7Ah57g4rQ
2026-11-06 20:13:38 -06:00
noahandClaude Opus 4.8 b1316b2bd9 Fix from-stock preflight: recognize AM335x stock, size-only mtd-map, honest dry-run targets
Three fixes found running the real tier-3 preflight against the stock .64 board:
- preflight fingerprint ended in 'ls <our release files>' which exits 1 on a stock
  board (none exist), failing the whole command; append '|| true'.
- classify() only knew the Amlogic stock kernel (4.9.38); the AM335x stock is
  3.8.13+ with an Antminer model line - recognize both so source-os matches the
  plan's stock-bitmain.
- the mtd-map check compared the vendor label (spl/u-boot/...) to the mtdN device
  name and so always failed on real hardware; validate live geometry by index+size
  against the plan's partitions instead (labels are board-specific, not in our map).
- dry-run message now lists the real write targets from the plan (was a hard-coded
  'mtd8, mtd6 and mtd7' that omitted mtd4 on tier 3).

Preflight + dry-run now PASS against the live stock board (all 10 checks). Unit
suite still 41 green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qHxYpv7yf7Ah57g4rQ
2026-11-06 08:35:39 -06:00
noahandClaude Opus 4.8 9f6eccc5ac Add am335x-stock (tier-3) from-stock flash support to the toolkit
The am335x flash module now selects a per-tier Profile from the bundle's board:
tier 2 (am335x, preserve) or tier 3 (am335x-stock, include). The byte-write
engine, preflight and readback are shared; only the policy, preserved set,
12-partition map (mtd4 becomes a write target) and image list differ.

- boards/am335x.rs: Profile/profile_for/owns_board; MTD_MAP_STOCK (mtd4 writable,
  kernel at write_order 4 so U-Boot lands first); from_afw accepts am335x-stock,
  permits exactly the u-boot bootloader member, still rejects any SPL member and
  a u-boot member on tier 2; check_uimage expects firmware type 5 for u-boot;
  the plan carries its board + preserved set; render is tier-aware.
- restore() takes the preserved set per profile; SPL copies (mtd0-3) are never a
  restore target on any tier; mtd4 is restorable on tier 3.
- alkane-cli: route am335x-stock to the module (plan/preflight/install); restore
  is profile-driven and adds --held-uboot (mtd4) for the from-stock set.
- alkane-artifacts: board_profile knows am335x-stock (arm, include).
- tests: tier-3 from_afw acceptance (4 targets, U-Boot before kernel, mtd4 not
  preserved), wrong-U-Boot-type and SPL-write-target rejection, and a tier-3
  restore test (mtd4 allowed, SPL refused). Full flash suite 41 green; tier-2 and
  cv1835 unchanged. The real bundle parses and verifies through the CLI.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qHxYpv7yf7Ah57g4rQ
2026-11-05 21:51:29 -06:00
noah 4d1adeb05e Install AM335x mtd7/mtd8 over SSH with held backups 2026-11-04 17:03:14 -06:00
noahandDeepSeek Harness 628c0630a5 Install .afw OS bundles on CV1835 over the network
Parse and verify the fixed-order .afw container, add the CV1835 board
module and an SSH transport with the stock update-daemon root stage, a
read-only preflight, a held p1 backup, whole-partition read-back, live
verification and network restore. Add the headless afw CLI and offline
fixtures for good, tampered, wrong-board, truncated, traversal and
oversize bundles.

Co-Authored-By: DeepSeek Harness <noreply@deepseek.com>
2026-11-04 14:31:35 -06:00
noah 086c883c4a Merge pull request 'Media icons: 3:1 against the button colour macOS actually paints' (#28) from media-icon-contrast into main
build-test-release / windows (push) Successful in 5m32s
build-test-release / release (push) Successful in 13m30s
2026-11-04 13:31:17 -07:00
noahandClaude Opus 5.5 4324d3046e Media icons: 3:1 against the button colour macOS actually paints
source / check (pull_request) Skipped
verify / verify (pull_request) Successful in 7m29s
verify / verify-windows (pull_request) Successful in 5m16s
The play/pause icons on macOS light buttons were about 2.6:1, because
native macOS buttons paint #ebebeb on a white window, not the system
button-face colour the check used. Check the icons against the button
face, the window colour and a shade 20 steps toward the opposite end.
They now measure 3.1:1 on the Mac (light and dark checked in real
system appearance), and stay above 3:1 on Linux and Windows.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBRg6YCM1XXQCTnD5GF
2026-11-04 14:17:52 -06:00
noah de5c1a5a15 Merge pull request 'Keep every coloured text readable in light and dark themes' (#27) from dark-mode-contrast into main
build-test-release / windows (push) Successful in 5m13s
build-test-release / release (push) Successful in 13m38s
2026-11-04 12:52:46 -07:00
noahandClaude Opus 5.5 d22ee79159 Keep every coloured text readable in light and dark themes
verify / verify (pull_request) Successful in 7m18s
verify / verify-windows (pull_request) Successful in 4m48s
source / check (pull_request) Skipped
Checked in real system dark and light mode on macOS (SkyLight theme
switch on the M1, restored afterwards), Windows 11 (the app-mode
setting, run on the VM's desktop) and Linux (Adwaita and Adwaita:dark),
measuring each screenshot's text against its background with the WCAG
contrast formula.

The app's own colours fell short on every platform. The fixed firmware
hues were 2.6 to 3.9:1 (LuxOS gold and ePIC blue on light, Alkane navy,
Braiins purple and Bixbit red on dark). The hashrate greens and
temperature purples were about 4:1, and the play/pause icons about 2:1
on light buttons.

- readable()/readable_at(): nudge a colour toward black (light theme)
  or white (dark theme), keeping its hue, until it reaches 4.5:1 for
  text (3:1 for icons) against every given background.
- palette(): green/amber/red/accent/label are made readable against the
  window, the zebra row and the KPI card; Palette::text() guards every
  computed cell colour (ratio and temperature blends, firmware hues).
- Media button icons: at least 3:1 against the theme's button face.
- macOS snapshot (wx-rs patch 0011): capture the window's frame view.
  The content view alone left unpainted areas transparent, which read
  as a white toolbar strip in dark mode. On screen the area was always
  the dark window colour.

After the change, no app-coloured text is below 4.5:1 in any of the
six theme/platform combinations. What the checker still flags is theme
chrome (grid lines, GTK header labels, button outlines, the zoom
slider) and anti-aliasing on thin fonts.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBRg6YCM1XXQCTnD5GF
2026-11-04 13:40:10 -06:00
noah 3d1fd36811 Merge pull request 'Fix macOS table cells hiding their text; Bug report button and report relay' (#26) from macos-table-and-bug-report into main
build-test-release / windows (push) Successful in 5m30s
build-test-release / release (push) Successful in 13m53s
2026-11-04 10:20:14 -07:00
noahandClaude Opus 5.5 7f2ea8a8dc Manual: reporting a problem with the Bug report button
verify / verify (pull_request) Successful in 7m39s
source / check (pull_request) Skipped
verify / verify-windows (pull_request) Successful in 5m30s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBRg6YCM1XXQCTnD5GF
2026-11-04 11:04:29 -06:00
noahandClaude Opus 5.5 b26f389460 Report relay: files the app's bug reports as Gitea issues
tools/report-relay is a dependency-free Python service. It takes the
JSON the app's Bug report button sends, validates it (type, text,
context and log sizes), scrubs the log a second time, rate-limits (5
per client IP and 60 in all per hour, 4 in flight), neutralises
@mentions, and files one issue in blueflare/alkane-toolkit with the
labels bug/ui/feature and from-app. It stores nothing and logs one
line per report without its text.

It runs on the Gitea host behind the shared nginx at
https://gitea.bluefla.re/alkane-report/ as the scoped alkane-reporter
bot (team alkane-reporters: issues write, code read, alkane-toolkit
only). See tools/report-relay/README.md. Its tests run in verify's
unit-test step.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBRg6YCM1XXQCTnD5GF
2026-11-04 11:04:15 -06:00
noahandClaude Opus 5.5 b46f15b340 Bug report button: file bugs and feature requests from the app
A Bug report button between Export and Settings opens a dialog: a type
(Bug, UI change, Feature request), one text box whose first line
becomes the issue title, and "Include the recent activity log
(passwords removed)", ticked by default. Send posts the report to the
report relay (next commit), which files it as an issue in
blueflare/alkane-toolkit. The dialog then shows the issue number, and
Open issue opens it, or shows why the report was not sent with the text
kept.

The app holds no token. A report carries the app version, platform, OS
version, appearance, language and window size, plus the newest 80 log
lines (at most 16 KiB). Before the log leaves the machine,
bug_report::scrub removes values of password/token/secret-like names,
Authorization and Cookie headers, URL passwords and PEM private keys.
The request goes through the system curl, as the other HTTP actions
do. ALKANE_REPORT_URL overrides the relay address for testing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBRg6YCM1XXQCTnD5GF
2026-11-04 10:59:02 -06:00
noahandClaude Opus 5.5 c9d32f9793 Fix macOS table cells hiding their text; add a self-test snapshot
On macOS several table columns showed no values until a row was
clicked. wxOSX draws custom cells without clipping to the cell, and the
segment renderer paints its zebra background over an oversized rectangle
(a column width either side, 40 px up and down) that GTK and MSW clip
to the cell. On the Mac each cell's fill painted over its neighbours.
Selected rows skip the fill, so their text came back.

On macOS the zebra is now the table's native alternating rows. AppKit
paints them under every cell in the theme's colours, and no row
carries a background attribute, so the renderer never fills. Plain
segment text uses the theme-aware list text colour instead of the
control's foreground colour.

To check rendering without screen-recording permission, the self-test
takes ALKANE_SNAPSHOT=path (macOS) and writes a PNG of the window as
the app draws it (osx_native.mm: cacheDisplayInRect). Before/after
snapshots on the M1 confirm the fix in light and dark appearance.

wx-rs patch 0010. Also folds in PR #24 (build-gui-macos without
--locked).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BdKQBRg6YCM1XXQCTnD5GF
2026-11-04 10:40:43 -06:00
noahandClaude Opus 5.5 5cf9d44d7e build-gui-macos: build like CI, without --locked
A release sets the crate version first, which changes the workspace
entries in Cargo.lock; --locked then refuses to build.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 10:37:31 -06:00
noah d9dc60918c Merge pull request 'macOS build: universal app for Apple Silicon and Intel, macOS 11+' (#23) from macos-build into main
build-test-release / release (push) Successful in 13m52s
build-test-release / windows (push) Successful in 6m2s
2026-11-03 14:41:23 -07:00
noahandClaude Opus 5.5 bb31a7befc macOS build: universal app for Apple Silicon and Intel, macOS 11+
verify / verify (pull_request) Successful in 7m33s
source / check (pull_request) Skipped
verify / verify-windows (pull_request) Successful in 5m48s
- scripts/build-wx-macos.sh: static, monolithic, universal (arm64 +
  x86_64) wxOSX/Cocoa 3.3.3 from the vendored tree, with wx's bundled
  image/zlib/regex/expat so the app links only system frameworks.
  Minimum macOS 11.0: current SDKs' libc++ supports nothing older.
- scripts/build-gui-macos.sh: builds both Rust targets against that
  prefix and merges them with lipo.
- ci/package-macos.py: "Alkane Toolkit.app" (Info.plist, icon, local
  network usage string), ad-hoc signed, zipped with ditto as
  alkane-toolkit-vX.Y.Z-macos-universal.zip with LICENSE and README.
- crates/alkane-gui/macos: app icon (.icns) from the same glyph as the
  Windows icon, plus the script that makes it.
- wx-rs patch 0009: macOS goes through wx-config (drops the universal
  -arch flags, maps -framework), reports logical sizes like GTK/MSW
  instead of narrowing floats to ints, and links clang's compiler
  runtime for wxOSX's @available checks.
- docs/macos.md, README and the manual's install chapter.

Verified on an M1 running macOS 27.0.1: both slices build, all
workspace unit tests pass, and the headless UI self-test passes 52/52
on arm64.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 15:26:56 -06:00
noah b1b7a3dbc0 Merge pull request 'SSH login in Credentials; default range 192.168.1.1/24; legal publisher name' (#22) from ssh-login-default-range-publisher into main
build-test-release / windows (push) Successful in 6m15s
build-test-release / release (push) Successful in 14m19s
2026-11-03 12:24:19 -07:00
noahandClaude Opus 5.5 8275f893dd SSH login in the Credentials dialog; default range 192.168.1.1/24; legal publisher name
source / check (pull_request) Skipped
verify / verify (pull_request) Successful in 7m55s
verify / verify-windows (pull_request) Successful in 5m8s
- Credentials dialog: new "SSH (restore)" row for the control-board SSH
  login used by the Braiins restore-to-stock. The username defaults to
  root; the password is masked and never re-displayed, and a blank
  password keeps the saved one. Reset to defaults also clears it.
  ssh-credentials.txt no longer has to be written by hand.
- Default scan range is now 192.168.1.1/24 (scans 192.168.1.0/24), and
  the range dialog's examples use that subnet.
- Windows version info, zip README, LICENSE and docs name the publisher
  as on the signing certificate: BlueFlare Energy Solutions Inc.
- Manual updated for all three.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 13:08:21 -06:00
noah 36f12d6d4e Merge pull request 'Attribute quality-dashboard coverage to crates' (#21) from fix-crate-coverage into main
build-test-release / release (push) Successful in 13m41s
build-test-release / windows (push) Successful in 5m48s
2026-11-03 10:51:30 -07:00
noahandClaude Opus 5.5 a4d82bf45b Attribute coverage to crates when llvm-cov strips the crates/ prefix
source / check (pull_request) Skipped
verify / verify (pull_request) Successful in 9m42s
verify / verify-windows (pull_request) Successful in 6m29s
The quality dashboard put every file under "other" because llvm-cov
prints paths relative to their common prefix.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 11:34:15 -06:00
noah d925414bc8 Merge pull request 'Own Pages site (manual, quality dashboard, benchmarks); remove internal notes' (#20) from repo-cleanup into main
build-test-release / windows (push) Successful in 7m8s
build-test-release / release (push) Successful in 15m41s
2026-11-03 10:10:21 -07:00
noahandClaude Opus 5.5 9f9fe18926 Add the user manual
Ten chapters in docs/manual, published at /manual/ on the project site:
getting started, scanning, the table, health icons, actions, settings and
credentials, restore to stock, export, command line, troubleshooting.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 10:57:38 -06:00
noahandClaude Opus 5.5 d8d044f439 Give the toolkit its own Pages site with a code-quality dashboard
https://blueflare.gitea.bluefla.re/alkane-toolkit/ is built from this repo
(gh-pages) after every main run: overview, manual, a quality dashboard and the
benchmark history, which no longer goes to alkane-benchmarks. The quality
grade is now Clippy/rustfmt plus the line-coverage band (the coverage badge's
own colour bands), not only the Clippy result, and main CI publishes the full
measurement (per-crate and per-file coverage, LOC per crate) as quality.json
for the dashboard. README badges link to their pages.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 10:57:37 -06:00
noahandClaude Opus 5.5 517bee9b9e Take internal working notes and bench details out of the public repo
AGENTS.md, HANDOFF.md, code-review-report.md, the implementation plan and the
aftermarket parity roadmap described the internal bench, its addresses and
in-house firmware; they now live in the private miner-firmware workspace and
are git-ignored here. The remaining docs and the fixture header no longer
point at them or at local infrastructure.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 10:57:37 -06:00
noah 10d7fd6d95 Merge pull request 'Show hashboards and SHA-256 for VNish models asic-rs does not know' (#19) from fix/vnish-unknown-model-boards into main 2026-11-03 08:48:11 -07:00
noahandClaude Opus 5.5 9b440a46e3 Show hashboards and SHA-256 for VNish models asic-rs does not know
VNish reports the 88-chip S19 as "Antminer S19 (88)", which asic-rs parses
to an Unknown model with no hardware table. The VNish backends sized the
board list from that table, so all three live chains were dropped and the
Health column drew no hashboard icons for hashing miners; the same model also
got an Unknown hash algorithm. Size boards from the chains the miner reports
when the table is missing, and infer the algorithm from the Antminer family
letter (helper shared with the stock backend). asic-rs patch 0034.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 09:32:28 -06:00
noah c3b0dc6c8a Merge pull request 'Say in the Windows zip README whether the executable is signed' (#18) from windows-signed-readme into main 2026-11-03 07:21:11 -07:00
noahandClaude Opus 5.5 bfda29a845 Say in the Windows zip's README whether the executable is signed
Signing is now on (Azure Artifact Signing profile alkane-toolkit); the README
tells site users how to confirm the Blueflare signature, or that an unsigned
build will trip SmartScreen.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 08:07:21 -06:00
noah 2c58cbac48 Merge pull request 'Sign the Windows build with Azure Artifact Signing' (#17) from windows-signing into main 2026-11-02 19:51:15 -07:00
noahandClaude Opus 5.5 174b162dfd Sign the Windows build with Azure Artifact Signing
- ci/sign-windows.sh signs alkane-toolkit.exe from Linux with jsign through
  the blueflaresigning account (RFC 3161 timestamped), using the
  least-privilege CI service principal alkane-toolkit-ci-signer. It is a
  no-op until the repository variable AZURE_SIGNING_PROFILE names a
  certificate profile; after that any signing failure fails the build.
- release.yml and next.yml sign before packaging; windows-native.yml checks
  the signature with Get-AuthenticodeSignature on real Windows and requires
  Valid once signing is on.
- CI image adds a Java runtime and a checksum-pinned jsign 7.6 (re-pinned);
  windows-ci.sh fetches the same jar on older images.
- scripts/enable-windows-signing.sh turns signing on after Microsoft
  approves the publisher identity validation: creates the PublicTrust
  certificate profile, narrows the signer role to it, sets the variable.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 20:38:21 -06:00
noah cbf0f70cf6 Merge pull request 'Run the native Windows job past the default execution policy' (#16) from fix/windows-native-shell into main 2026-11-02 18:30:31 -07:00
noahandClaude Opus 5.5 332a3f7419 Scope the PR private-key check to first-party sources
The documentation- and workflow-only PR checks grepped every tracked file
for private-key headers, so the test fixtures inside vendored upstream
crates (openssl, rustls-pemfile, aws-lc) failed every such PR.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 19:29:05 -06:00
noahandClaude Opus 5.5 3931b6348f Run the native Windows job's steps past the default execution policy
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 19:25:54 -06:00
noah 69b1b6e6fb Merge pull request 'Add a native Windows build, tested and released by CI' (#15) from windows-port into main
Merge pull request 'Add a native Windows build, tested and released by CI' (#15) from windows-port into main
2026-11-02 18:00:26 -07:00
noahandClaude Opus 5.5 a732f01ac9 Document the Windows build, its CI and the native test runner
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 18:32:56 -06:00
noahandClaude Opus 5.5 6da34a55e8 Build, test and release the Windows build in CI
- ci/windows-ci.sh is the one definition of every Windows step (toolchain,
  clippy, build, tests and UI self-test under Wine, packaging, test bundle);
  verify, release and next only call it.
- release.yml: a windows job builds, tests and packages
  alkane-toolkit-vX.Y.Z-windows-x86_64.zip; the release job waits for it
  and attaches the zip next to the Linux tarball. next.yml does the same
  for -rc candidates, verify.yml runs the Windows gates on PRs.
- windows-native.yml (advisory, never gates a release) runs main's
  cross-built unit tests and UI self-test on real Windows 11 through the
  self-hosted VM runner (label alkane-windows).
- CI image: ci/images/alkane-ci.Dockerfile layers mingw-w64, Wine with a
  ready prefix, the rustup target and a prebuilt wxMSW prefix on the
  previously verified image; ci/images/build-image.sh pushes it and pins
  the digest. wx prefix/cache scripts take a linux|windows argument.
- CI checks the wx-rs patch queue; versioning treats the GUI build script,
  Windows resources and assets as release-relevant; the workflow contract
  test covers the Windows gates.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 18:32:55 -06:00
noahandClaude Opus 5.5 be5edfc2bf Port the toolkit GUI to Windows (wxMSW, cross-built with mingw-w64)
Build: the wx-rs build script chose the platform with cfg!(), which in a
build script describes the build host, so a Linux-to-Windows build took the
GTK path. It now reads CARGO_CFG_TARGET_*, and Windows/GNU builds through
wx-config exactly like GTK, against a static wxMSW from
scripts/build-wx-windows.sh. The C++ runtime is linked statically, so the
.exe imports only Windows system DLLs. crates/alkane-gui/build.rs embeds an
application manifest (Common Controls v6, per-monitor DPI v2, UTF-8 code
page, Windows 10/11), the icon and version info.

Bridge on wxMSW (patches 0007/0008):
- the upstream frame's invisible "OSX key events" child sat above the UI on
  MSW and swallowed every click and key; it is no longer created there
- light/dark is chosen before the first window (wxMSW ignores it later) and
  follows the Windows app mode, with dark grid rules for the data view
- the generic wxDataViewCtrl gets mouse input in its inner main window, so
  drag-select and the per-cell / per-icon tooltips bind there (GTK keeps
  its native GtkTreeView paths; the icon hit-test is shared)
- sizes cross the Rust/C++ boundary in DIPs (identity on GTK), so columns,
  icons, KPI cards and the status bar scale at 125-200 %
- vector shapes go through GDI+ (anti-aliased like Cairo on GTK); selected
  rows use the themed list-view text colour like the native renderer
- the frame never opens larger than the monitor work area; title-bar icon
  from the executable; upstream menu insert no longer reads UTF-8 as UTF-16

App: OS differences live in alkane_core::platform (settings in
%APPDATA%\alkane-toolkit, owner-only secret files, NUL, console-less helper
processes). SSH password logins use SSH_ASKPASS with the toolkit itself as
the helper on every platform, replacing sshpass, which Windows lacks.
Release builds are GUI-subsystem; headless modes attach to the parent
console.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 18:32:44 -06:00
noahandClaude Opus 5.5 569ef9dcd8 Make the wx-rs patch queue reproducible and checkable
The queue had drifted from the patched tree it describes: 0003 predated
rounds 12-19 of bridge work, 0005 no longer applied on top of it, and the
Cargo.toml note and the case-duplicate readme.md were in no patch at all.
Vendor the pristine crates.io crate (sha256 pinned in VERSION) and add
scripts/wx_rs_patches.py: 'check' rebuilds the tree from upstream + patches
and requires an exact match, 'capture' records an edit as the next patch.
0002/0003 are regenerated to the current bridge files (0005's GTK tooltip
fix is folded into 0003); 0005 now carries the packaging leftovers.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 18:32:30 -06:00
noahandClaude Opus 5.5 b1313fd059 Restore wxWidgets files the tarball's own .gitignores kept out of git
The vendored wxWidgets 3.3.3 tree was missing 44 files of the pinned release
tarball (pnglibconf.h, PCRE2's configure and libtool files, libtiff build/):
the tarball ships nested .gitignore files, so a plain git add dropped them.
Linux links the system libpng/pcre2 and never noticed; the builtin libraries
the Windows build uses need them. The tree now matches the tarball
(sha256 81b09d6d...) byte for byte; VERSION says how to re-vendor safely.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 18:32:14 -06:00
noah 75b7424a0d Merge pull request 'Avoid duplicate Toolkit feature branch CI' (#14) from ci/drop-duplicate-toolkit-feature-verify into next
next-build / candidate (push) Successful in 11m8s
2026-10-21 06:58:54 -06:00
noah 8d4fe502be Avoid duplicate Toolkit feature branch CI 2026-10-21 06:57:38 -06:00
noah 038c1b1c2b Merge pull request 'Add fast next pull request source gate' (#13) from ci/next-pr-source-check into next 2026-10-21 06:55:56 -06:00
noah 20d7f49c9d Scope Toolkit source checks to changed Rust 2026-10-21 06:54:48 -06:00
noah 74cee50d35 Add fast next pull request source gate 2026-10-21 06:51:32 -06:00
noah 32a75c92ef Merge pull request 'Route toolkit benchmark publication to verifier' (#9) from ci/isolate-fast-runner-next into next 2026-10-21 06:49:08 -06:00
noah 9ad8b56c1f Gate first-party Toolkit Rust formatting 2026-10-20 19:42:41 -06:00
noah 28f8f9ce80 Install rustfmt before CI format gates 2026-10-20 19:32:20 -06:00
noah d35cedd056 Describe formatting in quality badge 2026-10-20 19:30:25 -06:00
noah a825299ebc Format first-party GUI and gate Rust style 2026-10-20 19:29:43 -06:00
noah a17f108050 Clarify Toolkit quality badge scope 2026-10-20 19:28:47 -06:00
noah 3faa35ea70 Clarify Toolkit quality badge scope 2026-10-20 19:11:50 -06:00
noah 16490dd3b9 Merge pull request 'Isolate trusted toolkit jobs from fast runner' (#10) from ci/isolate-fast-runner-main into main 2026-10-20 18:58:53 -06:00
noah f4d9c12bb6 Route toolkit benchmark publication to verifier 2026-10-20 18:45:04 -06:00
noah e6ae9d9d50 Isolate trusted toolkit jobs from fast runner 2026-10-20 18:45:04 -06:00
noah fc1ed3e4e5 Merge pull request 'Clarify Toolkit control and flashing scope' (#8) from docs/readme-scope into main 2026-10-19 23:52:32 -06:00
noah d7a914258e ci: close documentation-only verification block 2026-10-19 23:42:07 -06:00
noah 2108f47eea docs: clarify toolkit control and flash scope 2026-10-19 23:38:44 -06:00
noah d4a1db7243 Merge pull request 7: ci benchmark input context 2026-10-19 07:23:37 -06:00
noah 18acc31a28 ci: mark benchmark deltas with unchanged build inputs 2026-10-19 07:04:44 -06:00
noah d780fe007a Merge pull request 'ci: scope Toolkit workflow-only pull request checks' (#6) from ci/workflow-only-pr into main 2026-10-19 06:45:20 -06:00
noah f18bad36f3 ci: scope Toolkit workflow-only pull request checks 2026-10-19 06:31:16 -06:00
noah d7ae81dce9 Merge pull request 'ci: restore Toolkit main release to Alkane build pool' (#5) from ci/restore-main-release-pool into main 2026-10-19 06:30:16 -06:00
noah 10c93a3246 ci: route full Toolkit main release to Alkane build pool 2026-10-19 06:18:28 -06:00
noah 50ff6c60ce Merge pull request 'Use persistent Alkane cache for Toolkit main releases' (#4) from ci/static-main-release into main 2026-10-19 05:11:16 -06:00
noah cfe1f5be3b Run Toolkit main release on persistent Alkane verifier 2026-10-19 04:13:38 -06:00
noah 22e9106606 Merge pull request 'Use bounded Rust cache in Toolkit main and next CI' (#3) from ci/cache-main-and-next into main
Use bounded Rust cache on Toolkit main and next
2026-10-19 00:04:50 -06:00
noah c6b67c3b86 Bound Toolkit release compiler parallelism to measured memory 2026-10-18 23:53:33 -06:00
noah 77aacef528 Use bounded Rust cache in Toolkit main and next CI 2026-10-18 23:51:54 -06:00
noah 9bab162d64 Merge pull request 'Scope Toolkit PR checks and use prebuilt CI tools' (#2) from ci/docs-pr-fast-path into main
Speed Toolkit CI with scoped PR checks and bounded compiler caching
2026-10-18 23:49:27 -06:00
noah d0bbed568c Pilot bounded Rust compiler cache in Toolkit verification 2026-10-18 23:01:58 -06:00
noah 41142e707a Avoid duplicate source job for Toolkit main PRs 2026-10-18 22:35:04 -06:00
noah 7f106e2deb Use prebuilt CI tools and skip redundant wx cache transfer 2026-10-18 22:28:35 -06:00
noah 5cdce25329 Skip wx cache upload when image supplies the library 2026-10-18 22:15:27 -06:00
noah 01dd9ca287 Reject symlinked wx prefix markers 2026-10-18 22:02:48 -06:00
noah cb4c56679d Verify wx source provenance before reusing prefix 2026-10-18 21:56:00 -06:00
noah d0ecaea174 Publish Toolkit benchmarks on Pages runner after main CI 2026-10-18 21:50:25 -06:00
noah a77cd3a682 Include every Toolkit crate in unit coverage 2026-10-18 21:31:36 -06:00
noah c3efda87c3 Cover all Toolkit crates and pin CI image 2026-10-18 21:29:33 -06:00
noah afbaac0c0e Scope headless crate PR checks to reverse dependencies 2026-10-18 21:04:36 -06:00
noah c287aaaf58 Save wxWidgets cache before later quality checks 2026-10-18 21:04:35 -06:00
noah 6e09624120 Key wxWidgets cache to available native packages 2026-10-18 21:04:33 -06:00
noah 1edc446940 Skip redundant Toolkit package setup on prepared runners 2026-10-18 21:04:32 -06:00
noah f86f34bd90 Skip heavyweight Toolkit checks for documentation-only PRs 2026-10-18 21:04:30 -06:00
noah ff0724f96a Merge pull request 'Consolidate Toolkit CI setup and gate benchmark publication' (#1) from ci/release-setup-pages-order into main 2026-10-18 21:02:52 -06:00
noah 41d2bd6d91 Key wxWidgets cache to source and toolchain inputs 2026-10-18 20:15:24 -06:00
noah 8a75ee40bc Isolate Toolkit pull request verification from release queue 2026-10-18 20:13:17 -06:00
noah 75be20163d Stop scheduled Toolkit benchmark republishing 2026-10-18 20:03:45 -06:00
noah 0013dd45c2 Separate fast Toolkit checks from full main verification 2026-10-18 20:01:37 -06:00
noah a3ee239900 Route short Toolkit checks to Alkane fast runner 2026-10-18 20:01:35 -06:00
noah 5fc08e408e Use lightweight checks for Toolkit feature and next changes 2026-10-18 20:01:32 -06:00
noah 5098be30d1 Consolidate setup and gate benchmark publication 2026-10-18 20:01:26 -06:00
noah b610ce3d7f Validate SDK archive contents in Rust before install 2026-10-17 11:13:17 -06:00
noah 1a5dcd17a9 Verify SDK release archives from checksum sidecar 2026-10-17 10:11:15 -06:00
noah 3b1b1fa63e Document running build verification and lock CLI dependency 2026-10-17 10:08:34 -06:00
noah 7880b14e47 Expose running build verification in toolkit CLI 2026-10-17 10:03:34 -06:00
noah 5bbf5b71b7 Verify running board build marker against CI artifact 2026-10-17 10:01:04 -06:00
noah cfec9606a4 Require observed MTD geometry before resolving flash target 2026-10-17 09:02:13 -06:00
noah e8d7cdc77a Parse MTD layouts before board flash planning 2026-10-17 08:02:02 -06:00
noah 1323dc1571 Add bounded read-only SSH board probes 2026-10-17 08:00:36 -06:00
noah 8ba585679a Add bounded read-only SSH board probes 2026-10-17 07:02:01 -06:00
noah 848a78ed5f docs: shorten Toolkit entry guide 2026-10-17 01:42:12 -06:00
noah ea102130ac docs: shorten Toolkit entry guide 2026-10-17 01:42:10 -06:00
noah e656402ec8 Publish Toolkit benchmarks on the standing Alkane runner 2026-10-17 01:21:27 -06:00
noah 8d092ae417 Publish Toolkit benchmarks on the standing Alkane runner 2026-10-17 01:21:21 -06:00
noah 80f3c22582 Validate public benchmark page before upload 2026-10-16 08:47:42 -06:00
noah 7445b05e57 Validate public benchmark page before upload 2026-10-16 08:46:06 -06:00
noah a79ac3e09e Publish Toolkit benchmarks to public Pages site 2026-10-16 07:20:03 -06:00
noah faae4ee145 Publish Toolkit benchmarks to public Pages site 2026-10-16 07:19:42 -06:00
noah 6580005e77 Bound queued Toolkit CI attempts per branch 2026-10-16 07:08:58 -06:00
noah 942801ee4b Bound queued Toolkit CI attempts per branch 2026-10-16 07:08:39 -06:00
noah 2734c8e356 Average benchmark improvements equally in Toolkit badge 2026-10-16 06:02:55 -06:00
noah 8de1bdffd4 Average benchmark improvements equally in Toolkit badge 2026-10-16 06:02:42 -06:00
noah 0c2897ce37 Require complete Toolkit benchmarks before release 2026-10-16 05:12:21 -06:00
noah 77237023e3 Require complete Toolkit benchmarks before release 2026-10-16 05:11:44 -06:00
noah fbc903fa6a Benchmark health diagnostics on representative miners 2026-10-15 20:19:36 -06:00
noah fc573f075a Benchmark health diagnostics on representative miners 2026-10-15 20:19:18 -06:00
noah fe9617ab56 Guard UTF-8 naming and repair headless screenshots 2026-10-15 20:10:42 -06:00
noah 1c364d4ff1 Guard UTF-8 naming and repair headless screenshots 2026-10-15 20:10:19 -06:00
noah 1e9e4f16b5 Stage verified flash images before device writes 2026-10-15 19:10:45 -06:00
noah d54bd6473f Stage verified flash images before device writes 2026-10-15 19:10:28 -06:00
noah 6a6a5e7ded Grade Toolkit code quality from static checks 2026-10-15 19:04:10 -06:00
noah a5b07d22ae Grade Toolkit code quality from static checks 2026-10-15 19:03:34 -06:00
noah e20b6890d3 Simplify Toolkit docs and update installer status 2026-10-15 14:37:27 -06:00
Noah 3d17326460 Simplify Toolkit docs and update installer status 2026-10-15 14:36:09 -06:00
noah 56339a5eca Clean candidate build after prerelease decision 2026-10-15 12:43:30 -06:00
noah 17bee91248 Clean candidate build after prerelease decision 2026-10-15 12:43:24 -06:00
noah 63d0de8ae3 Clean generated Toolkit builds after CI and local GUI builds 2026-10-15 11:52:21 -06:00
noah 00bb760451 Clean generated Toolkit builds after CI and local GUI builds 2026-10-15 11:51:55 -06:00
noah 9a8efc807a Parse Rust test harness benchmark output 2026-10-15 04:06:52 -06:00
noah 5f472435a7 Parse Rust test harness benchmark output 2026-10-15 04:06:32 -06:00
noah 9879a0eb25 Compare toolkit benchmarks on matching CPU classes 2026-10-15 03:37:30 -06:00
noah f22fe19a4d Compare toolkit benchmarks on matching CPU classes 2026-10-15 03:36:53 -06:00
noah 03c19ef7c6 Derive toolkit quality grade from measured coverage 2026-10-15 03:34:41 -06:00
noah 8ab83edc73 Derive toolkit quality grade from measured coverage 2026-10-15 03:34:11 -06:00
noah 2540801140 Revalidate artifacts and guard complete flash streams 2026-10-14 20:54:42 -06:00
noah 601da0548b Revalidate artifacts and guard complete flash streams 2026-10-14 20:54:29 -06:00
noah dd28fa233c Use Gitea-compatible pinned artifact upload 2026-10-14 20:51:35 -06:00
noah 4592b927ad Use Gitea-compatible pinned artifact upload 2026-10-14 20:51:23 -06:00
noah e5ca519df0 Publish measured toolkit badges from main CI 2026-10-14 20:45:03 -06:00
noah 5e347315e2 Publish measured toolkit badges from main CI 2026-10-14 20:44:35 -06:00
noah 06c8e01eb5 Guard verified artifact writes with recovery checks 2026-10-14 20:40:35 -06:00
noah 603c49a395 Guard verified artifact writes with recovery checks 2026-10-14 20:40:22 -06:00
noah 990439985d Verify toolkit firmware artifacts before install 2026-10-14 20:31:26 -06:00
noah bc8e0535d1 Verify toolkit firmware artifacts before install 2026-10-14 20:31:04 -06:00
noah 54136b71ef Record private toolkit benchmark history 2026-10-14 20:21:38 -06:00
noah cf1eaebae1 Record private toolkit benchmark history 2026-10-14 20:21:19 -06:00
noah 5d18304f0f Standardize toolkit CI badges and scoped release auth 2026-10-14 20:06:48 -06:00
noah f89f220f3e Standardize toolkit CI badges and scoped release auth 2026-10-14 20:05:49 -06:00
alkane-ci c18a37eebc ci: refresh README badges [skip release] 2026-10-13 23:27:22 +00:00
noah 8bbf844bb6 Merge branch 'tooling-standard' into next 2026-10-13 12:10:34 -06:00
noah d3a06d682f Read benchmark coverage from release objects 2026-10-13 12:09:59 -06:00
noah 97607a0a91 Point next CI badge at next attempts 2026-10-13 11:54:38 -06:00
noah 4d530721dc Trim CI script trailing blank lines 2026-10-13 11:54:00 -06:00
noah 0b691ca943 Add next release candidates and main branch gates 2026-10-13 11:53:22 -06:00
alkane-ci ed0f781851 ci: refresh README badges [skip release] 2026-10-02 16:16:14 +00:00
noahandClaude Opus 4.8 613132035a feat(gui,asic-rs): hashboard yellow-not-red, power-limit column, chip/HB/PSU-serial coverage
Round 21 (three reported items).

1. A hashboard that is still mining near full hashrate but has some failed chips
   now shows yellow (degraded), not red. VNish emits per-board chip failures as
   Warning while the board is mining (Error only when the board is not mining),
   and board_healths() renders a warning-only board as Degraded instead of Down.
   Verified live on 10.4.0.193 (mining ~83%, dead chips -> yellow).

2. New "Power limit" column: the configured power-target setpoint in watts
   (MinerRow.power_limit_w, from a Power tuning target). WhatsMiner shows its
   "Power Limit" (e.g. 2500 W); the value was already scanned but had no dedicated
   column. Numeric (sortable/filterable), Performance category, opt-in.

3. Chip + hashboard model coverage:
   - VNish hashboard model scanned from factory-info board_model (A3HB70601,
     BHB42603, ...) -- 147-unit fleet gains HB model. Both VNish backends.
   - WhatsMiner v1/v2 PSU serial scanned from get_psu serial_no (was hardcoded
     None). 48-unit fleet gains PSU serial.
   - Chip type derived from the detected model for Antminer hardware (VNish/stock/
     LuxOS/Braiins/UMC never report a chip string on the wire), in naming.rs:
     S21Pro->BM1370, S19jPro->BM1362, S19KPro->BM1366, S19/T19->BM1398, etc.
     Only high-confidence mappings; WhatsMiner and unknown models stay blank.
   PSU Vmin/Vmax remain Braiins/ePIC-only (not on the wire for WhatsMiner/VNish/
   Antminer -- confirmed live).

asic-rs patch 0033. 95 unit tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-10-02 10:09:07 -06:00
alkane-ci b3dc5a336e ci: refresh README badges [skip release] 2026-09-24 21:33:46 +00:00
noahandClaude Opus 4.8 a4d0cb65f0 fix(gui,vnish): hashrate 0-vs-dash, paused health colours, VNish per-hashboard faults
- Hashrate cell: a readable 0 hashrate now shows "0.00T" instead of a dash. The
  dash is reserved for an unreadable/absent hashrate. New MinerRow.hashrate_known
  records whether the miner reported a value; combined_si/num_value key off it,
  and scan/fixtures set it from data.hashrate.is_some().
- Paused-miner Health icons: the control board (brain) and PSU keep their true
  health (green when fine) instead of turning blue; fans turn blue only when
  actually stopped (0 RPM) and stay green while spinning; hashboards stay blue
  while paused (idle is the expected state).
- VNish per-hashboard faults: DataField::Messages now also reads the summary
  chains (chip_statuses red/orange + per-chain state) and emits one message per
  faulted board, attributed to MinerComponent::HashBoard{idx}, so the Health
  column reds the specific board and its tooltip carries the fault instead of it
  landing on the brain. Applied to v1_2_0 and v1_3_0. patch 0032.

Verified live: VNish 10.7.1.25 -> "Hashboard 2: 1 degraded chip(s)" on board idx
1; healthy 10.7.1.122 -> no messages. 93 unit tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-24 15:14:20 -06:00
alkane-ci 29b9b17c67 ci: refresh README badges [skip release] 2026-09-24 19:32:29 +00:00
noahandClaude Opus 4.8 8deecf3558 fix(gui): paused/stopped miners shown as broken (red) instead of paused (blue)
A miner an operator has stopped (e.g. 10.4.1.122, VNish miner_state "stopped" ->
OperatingState::Stopped) was read as broken: red hashboards and counted under "not
hashing" instead of "Paused".

Two causes:
1. is_paused() only matched the literal "pause" substring, so "Stopped"/"Stopping"/
   "Suspended" -- every other firmware's word for an intentional, resumable halt --
   fell through to not-paused. Now matches pause/stop/suspend (Error stays broken).
2. encode_component_health applied the paused-blue treatment to hashboards only
   (round 19 #19), so a paused miner's idle fans/power still rendered red. A stopped
   miner's off components are expected, not faults: colour every reported component
   blue when paused (an undetected/Unreachable one still stays grey -- "not present"
   is not "paused").

Verified live against 10.4.1.122 on a headless build: the row now shows all-blue
health (power grey, honestly unreachable) and counts under the Paused KPI, where it
previously showed red boards + "not hashing".

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-24 13:08:18 -06:00
alkane-ci 3a6a190ce1 ci: refresh README badges [skip release] 2026-09-24 16:25:36 +00:00
noahandClaude Opus 4.8 1f0a4cbe76 fix(gui): health icon tooltips never showed -- tip area used wrong coordinates
Round 19 #2. The health-icon hover tooltips never appeared because the GTK
query-tooltip handler built the per-icon "tip area" from gtk_tree_view_get_cell_area
(BIN-WINDOW coordinates) and passed it to gtk_tooltip_set_tip_area, which expects
WIDGET coordinates. The area was offset upward by the column-header height, so it
did not contain the pointer, and GTK suppresses any tooltip whose tip area excludes
the cursor -- so nothing showed. The Errors column worked because it sets no tip
area. Prior fixes (rounds 15/18/19) only tuned the icon slot math, which was already
correct; the coordinate-system mismatch was the actual cause.

Convert the slot rectangle from bin-window to widget coordinates with
gtk_tree_view_convert_bin_window_to_widget_coords before gtk_tooltip_set_tip_area.
The slot hit-test (block_left/adv, in bin-window coords) is unchanged and still
matches DrawShape's uniform health-icon advance. wx-rs patch 0005.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-24 10:03:58 -06:00
alkane-ci fbc43216fb ci: refresh README badges [skip release] 2026-09-24 00:27:48 +00:00
noahandClaude Opus 4.8 a4fcb6e763 asic-rs telemetry: VNish fan%/temps, WhatsMiner chip type, and auto-tuner status
Round 19 #10 telemetry extension, live-verified. Two logical changes (patches 0030
and 0031) shipped together; they populate existing GUI columns plus one new "Tuner"
column.

VNish + WhatsMiner (patch 0030, no core/GUI change):
- VNish v1_2_0 + v1_3_0: fan duty % (summary /miner/cooling/fan_duty) and board temp
  thresholds (settings restart_temp -> dangerous, auto cooling param -> target).
  Live-verified 10.4.1.50 (81 / 90 / 65). No PSU serial exposed -> stays None.
- WhatsMiner chip type (per user, do not drop): v1/v2 summary "Chip Data" merged
  into hashboards -> BoardData.chip_type (first token); v3 chipdataN -> chip_type and
  hash-board ("K40") -> hashboard_model.

Auto-tuner status (patch 0031):
- New DataField::TunerStatus + MinerData.tuner_status (Option<String>), riding the
  existing GetOperatingState trait via a defaulted parse_tuner_status.
- Braiins: performance/tuner-state overall_tuner_state via the BOS+ TunerState enum
  (Disabled/Stable/Tuning/Error/Continuous/Preheat) -- mapping from the bos-plus-api
  proto. ePIC: PerpetualTune -> Off/Optimized/Tuning. Others -> None.
- GUI: new "Tuner" column (Health & status category, auto-hidden when empty).

All values live-verified against the corpus miners (ePIC 10.4.1.6, LuxOS 10.4.1.60,
Braiins 10.4.1.83, VNish 10.4.1.50). Fixture tests assert every parsed value.
ALL_COLUMNS 71 -> 72.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 18:10:57 -06:00
alkane-ci 76409b0d3b ci: refresh README badges [skip release] 2026-09-23 23:57:28 +00:00
noahandClaude Opus 4.8 4aec6d40ad asic-rs telemetry: board temp thresholds -> target/hot/dangerous (LuxOS, Braiins; remap ePIC)
Round 19 #10 telemetry extension. Live-verified against the corpus miners, this
remodels the board temperature thresholds to item #10's target/hot/dangerous scheme
and adds the LuxOS and Braiins backends. Supersedes the ePIC-only critical/shutdown
model shipped in v0.72.0.

Core (asic-rs-core):
- MinerData: temp_critical/temp_shutdown -> temp_target/temp_hot/temp_dangerous.
- parse_temperature_limits (defaulted on the existing GetFluidTemperature trait)
  now returns (target, hot, dangerous); parse_data wires all three fields.

Backends (each reads an already-fetched or single command; live-verified):
- LuxOS: new tempctrl RPC; ChipTarget/ChipHot/ChipDangerous (live 10.4.1.60 = 83/93/100).
- Braiins v25_07 + v26_04: configuration/constraints cooling_constraints defaults
  (live 10.4.1.83 = 60/80/90); WEB_CONSTRAINTS already fetched for tuning caps.
- ePIC remap: Shutdown Temp -> hot, Critical Temp -> dangerous, no target.
- VNish (settings restart_temp/param) handled in a follow-up (needs settings auth);
  Antminer/WhatsMiner expose no thresholds -> (None,None,None).

GUI: the two temp columns (Critical/Shutdown) become three (Target/Hot/Dangerous),
right-aligned, Temperature category, auto-hidden when empty. MinerRow gains
temp_target_c/temp_hot_c/temp_dangerous_c; to_row reads them. ALL_COLUMNS 70 -> 71.

Fixtures captured from live: luxminer tempctrl.json, braiins configuration_constraints.json.
Fixture tests for epic, luxminer, braiins v26_04 assert the parsed thresholds. Patch 0029.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 17:40:33 -06:00
alkane-ci 33a116d9fd ci: refresh README badges [skip release] 2026-09-23 23:10:06 +00:00
noahandClaude Opus 4.8 45d9632590 asic-rs telemetry T3-temps: board temperature thresholds (critical / shutdown)
Round 19 #10 telemetry extension. Adds the board temperature safety thresholds
("board dangerous temp" from item #10).

Core (asic-rs-core):
- New DataField::TemperatureLimits; MinerData gains temp_critical and temp_shutdown
  (Celsius).
- Rides the existing GetFluidTemperature trait via a defaulted parse_temperature_limits
  method returning (critical, shutdown) -- no supertrait blast radius; parse_data
  wires both fields in.

Backend:
- ePIC: summary /Misc Critical Temp + Shutdown Temp (already-fetched summary).
- Antminer/WhatsMiner expose no thresholds; LuxOS needs an unwired tempctrl command
  (no fixture) and VNish/Braiins need live verification -> left for a live-verified
  pass, all inherit (None, None).

GUI: two new columns (Critical temp / Shutdown temp), right-aligned, Temperature
category, auto-hidden when empty. MinerRow gains temp_critical_c / temp_shutdown_c;
to_row reads them. ALL_COLUMNS 68 -> 70.

Fixture test for epic asserts the parsed thresholds. Patch 0028.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 16:53:57 -06:00
alkane-ci 0265370be2 ci: refresh README badges [skip release] 2026-09-23 22:43:35 +00:00
noahandClaude Opus 4.8 fadd851e04 asic-rs telemetry T3-fan: miner-level fan duty cycle (fan speed %)
Round 19 #10 / #8 telemetry extension. Adds the fan duty cycle as a miner-level
percentage -- the normalized fan-load indicator the GUI wanted alongside per-fan
RPMs. No firmware exposes a maximum fan RPM, so a true actual/maximum pair is not
possible; the duty cycle is the closest normalized signal.

Core (asic-rs-core):
- New DataField::FanSpeedPercent; MinerData gains fan_speed_percent (Option<f64>).
- Modeled as a top-level miner-level value (most firmwares report a single duty),
  so FanData is untouched -- no Eq removal / literal churn across its 17 crates.
- Rides the existing GetFans trait via a defaulted parse_fan_speed_percent method
  (no supertrait blast radius); parse_data wires it in.

Backends (read already-fetched commands, no extra round-trips):
- ePIC: summary /Fans/Fans Speed (single %).
- LuxOS: max of FANS[].Speed.
- Braiins v25_07 + v26_04: max of cooling fans[].target_speed_ratio x 100.
- Antminer (pwm via config) and VNish (fan_duty) have no data fixtures -> left for a
  live-verified pass; WhatsMiner is firmware-locked -> None.

GUI: new "Fan %" column (right-aligned, Cooling category, auto-hidden when empty).
MinerRow gains fan_speed_percent; to_row reads it. ALL_COLUMNS 67 -> 68.

Fixture tests: epic, luxminer, braiins v26_04 assert the parsed percentage. Patch 0027.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 16:28:14 -06:00
alkane-ci 24f9d9682d ci: refresh README badges [skip release] 2026-09-23 22:10:04 +00:00
noahandClaude Opus 4.8 3f9fc4a24b asic-rs telemetry T2b: cumulative share stats (difficulty acc/rej, stale, blocks)
Round 19 #10 telemetry extension, tier 2b. Adds the cumulative share statistics
from item #10 end to end: difficulty-weighted accepted/rejected work, raw stale
share count, and blocks found.

Core (asic-rs-core):
- New ShareSummary sub-struct (data/share.rs) with a parse_cgminer_share_summary
  helper reading a cgminer/btminer SUMMARY[0] object.
- New DataField::ShareSummary; MinerData gains share_summary.
- Rides the existing GetBestShare trait via a defaulted parse_share_summary method
  (no new supertrait bound, no per-backend empty impl); parse_data wires it in.

Backends (read the already-fetched SUMMARY, so no extra round-trips; these are
miner-level aggregates -> top-level MinerData fields, not per-pool PoolData):
- Antminer v2020 + v2023_07, LuxOS, WhatsMiner V1 + V2 override parse_share_summary.
- Braiins (no cumulative difficulty), ePIC (current difficulty only), WhatsMiner V3
  and VNish expose none and inherit None -- fixtures confirm.

GUI: four new columns (Diff acc / Diff rej / Stale / Blocks), right-aligned, in the
Pools category, auto-hidden when empty. MinerRow gains the four fields; to_row reads
them from share_summary. ALL_COLUMNS 63 -> 67.

Fixture tests: whatsminer v1 and antminer v2020 assert the parsed values. Patch 0026.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 15:51:57 -06:00
alkane-ci 8ab607de6c ci: refresh README badges [skip release] 2026-09-23 21:30:23 +00:00
noahandClaude Opus 4.8 a60bb34e64 asic-rs telemetry T2a: rolling average hashrate windows (1m/5m/15m/24h)
Round 19 #10 telemetry extension, tier 2. Adds the rolling average hashrate
windows the GUI asked for (1M/5M/15M/24H) end to end.

Core (asic-rs-core):
- New HashrateAverages sub-struct (data/hashrate.rs): avg_1m/5m/15m/24h, each an
  Option<HashRate> carrying the same unit and algorithm as the current hashrate.
- New DataField::HashrateAverages; MinerData gains hashrate_averages.
- The windows ride the EXISTING GetHashrate trait via a new defaulted
  parse_hashrate_averages method (default None), so no new supertrait bound and no
  empty impl in every backend -- only the backends that expose the data override
  it. parse_data wires it in.

Backends (all read a command the collector already fetches -> no extra round-trips;
each window is filtered to > 0 and the whole struct is dropped when every window is
absent, so a firmware that reports nothing keeps hashrate_averages = None):
- WhatsMiner V1: btminer summary MHS 1m/5m/15m (MegaHash); no 24h.
- WhatsMiner V3: get.miner.status summary hash-1min / hash-15min (TeraHash) only.
- LuxOS: summary GHS 1m/5m/15m/24h (GigaHash) -- full window set.
- Braiins v25_07 + v26_04: miner_stats real_hashrate last_1m/5m/15m/24h (GigaHash).
- Antminer (5s/30m/av only), WhatsMiner V2 (av only), ePIC/VNish (session average
  only), sealminer: no standard 1/5/15 window -> inherit None. This is honest: the
  fixtures confirm those firmwares do not expose the standard windows.

GUI: four new columns (HR 1m/5m/15m/24h), single TH/s value each, right-aligned,
blank when the window is not reported, auto-hidden when empty across the fleet.
MinerRow gains the four ths fields; to_row populates them from hashrate_averages.

Fixture tests: whatsminer v1 and braiins v26_04 gain assertions on the parsed
windows (value, unit, and the expected present/absent pattern). Patch 0025.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 15:08:27 -06:00
alkane-ci c944897807 ci: refresh README badges [skip release] 2026-09-23 20:45:46 +00:00
noahandClaude Opus 4.8 a6e22581d7 asic-rs telemetry T1b: WhatsMiner V3 PSU serial + ePIC chip/HB type
Round 19 #10 telemetry extension, tier 1 sub-batch B. Both ride existing
DataFields (Psu/Hashboards) on already-fetched commands (no extra round-trips)
and reuse the PsuInfo.serial / BoardData.chip_type+hashboard_model fields added
in T1a, so no core or GUI change -- the existing columns just populate for more
firmwares. Patch 0024; fixture tests pass.

- WhatsMiner V3: add a DataField::Psu location (get.device.info /msg/power) and a
  parse_psu that reads model/type, sw/hwversion, and the serial (sn). V3 had no
  PSU parse at all (default None) despite the data being fetched for PsuFans.
- ePIC: parse_hashboards now reads capabilities "Chip Type" (e.g. "BM1366") and
  "Model Subtype" (e.g. "BHB56801"), applied to every board (capabilities reports
  them miner-wide). The capabilities command is already fetched for Hashboards.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 14:31:36 -06:00
alkane-ci b15de7f747 ci: refresh README badges [skip release] 2026-09-23 20:18:33 +00:00
noahandClaude Opus 4.8 f887affd6d asic-rs telemetry T1a: PSU serial + chip/HB type + best-share
Extend vendored asic-rs to scan more per-firmware telemetry (round 19 #10
follow-up, tier 1 sub-batch A). All new values ride on existing DataFields
(Psu/Hashboards/BestShare) and commands already fetched, so no new core
DataField plumbing and no extra network round-trips. Patch 0023.

Vendored (asic-rs):
- PsuInfo gains `serial`. Braiins v26_04 parse_psu corrected to read model_name
  + fw_version (it used the numeric type code as the model and dropped the fw
  version) and to capture serial_number. ePIC / WhatsMiner v1/v2 report no serial.
- BoardData gains `chip_type` (e.g. "BM1370") + `hashboard_model` (e.g.
  "A3HB70601"); Braiins miner/hw/hashboards populates both.
- best_share (all-time) wired for Antminer v2020 and WhatsMiner v1/v2 from the
  already-fetched summary "Best Share" (those backends had the empty default).
- refresh-checksums --all; existing braiins/antminer/whatsminer fixture tests pass.

GUI:
- MinerRow gains chip_type, hashboard_model, psu_serial; populated in to_row.
- New columns: Chip, HB model, PSU serial. Best share now populates for Antminer
  and WhatsMiner (column already existed).

Feasibility analysis (5-agent, all firmwares) recorded in memory; further tiers
(fan %, rolling hashrate averages, difficulty/shares, temp thresholds, WhatsMiner
V3 / VNish PSU serial) follow. Confirmed genuinely-unavailable: fan max RPM,
WhatsMiner/LuxOS real logs, chip type on Antminer/LuxOS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 14:01:33 -06:00
alkane-ci e5e6b0f1e1 ci: refresh README badges [skip release] 2026-09-23 18:40:11 +00:00
noahandClaude Opus 4.8 ad28dab542 round 19 review fixes + Health-column alignment + badge-push fix
Health column (operator-reported): give every component-health icon a UNIFORM
fixed-width slot in the SegmentRenderer (GetSize + DrawShape), so power/control/
fan/board icons line up in fixed columns across rows regardless of glyph aspect,
and left-align the icon columns (Health/Access/Light) so the block anchors at a
consistent left edge. The per-icon tooltip hit-test uses the same uniform slot.

Code-review-harness fixes:
- High: isolate per-miner telemetry with catch_unwind so one miner's get_data
  panic can't abort the whole scan (and strand the fast-path partial rows).
- Medium: fill the zebra stripe across the full cell for right-aligned colored
  columns (was anchored at the content's left edge, leaving the left unstriped).
- Medium: lower the scan-concurrency ceiling 512 -> 256 (128 is fully reliable,
  192 already dropped responders on the live fleet).
- Medium: board voltage/frequency sort key skips placeholder-zero boards
  (avg_positive), matching how the cell renders them as "-".
- Low: saturating_add for accepted/rejected share sums; moved an orphaned doc
  comment; corrected a stale comment.

CI: fix the README-badge push-back -- `git push -c http.extraheader` is invalid
(`-c` must precede the subcommand), so the badge/coverage/bench-baseline commit
never actually reached main; now `git -c http.extraheader=... push`. This also
lets the bench-delta baseline persist so the delta can compute.

Demo: the offline-demo paused miner now has detected (idle) hashboards so the
paused-blue Health icons (round 19 #19) are exercised.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 12:21:03 -06:00
noahandClaude Opus 4.8 42e3bf8f5b round 19: columns, scan speed, per-firmware logs, more scanned fields
Table/columns:
- Fix the "columns shrink to tiny" bug on language change / add / hide (#3, #24):
  the rebuild-time capped autosize read column widths before GTK's measurement
  landed. Columns keep their default widths; autosize is on-demand only.
- Right-align every column except IP (#21): new alignment param on the bridge
  append calls; the SegmentRenderer and the tooltip hit-test honour it.
- "Auto-size all columns" header menu item; Ctrl+A selects all rows (#4).
- Remove the Boards (dots) column (#7).
- Split the slash-joined Fan column into per-fan columns Fan 1-4 (#8).
- Efficiency: unit moved into the value and made algorithm-aware (J/TH for
  SHA256 families, J/kSol for Equihash), fixing the blank/garbage figure on
  non-SHA256 miners (#9, #23).
- Pool account column before Worker by default (#22).

Scan:
- Fast scan (#18): emit a lightweight identity row the instant a miner is
  identified, then upsert the full telemetry row when get_data completes.
- User-adjustable scan concurrency with a bounded max (#25).
- Surface more scanned values as columns (#10): current tuning target, accepted
  / rejected shares + reject %, and per-hashboard hashrate / voltage / frequency.

Logs (#11-16): fetch the miner log through asic-rs's per-backend read_logs()
instead of the narrow curl paths, fixing Braiins / LuxOS / Z15 / BixBit / stock
Antminer; WhatsMiner keeps the fault-code fallback (no API log). Removed the
summary tidbits from the log viewer (#13).

Misc: fix per-icon health tooltips (advance math matched to the renderer) (#2);
paused miners show blue hashboard icons, healthy stays green (#19); state-aware
Pause/Resume in the right-click menu (#20); export opens a column-picker dialog
(#6) and the default filename carries a UTC timestamp (#5); the scan status bar
says "Scan Paused" / "Scan Stopped" and no longer overwrites Stop with paused
(#17); the bench badge shows the weighted-average microbench delta vs the
previous release (#1).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 11:40:21 -06:00
noahandClaude Opus 4.8 4154a50ed0 ci: measure coverage in the release job and auto-update the badge
Add a best-effort Coverage step to release.yml: it adds the llvm-tools-preview
rustup component, fetches cargo-llvm-cov as a prebuilt binary (the vendored
.cargo/config blocks `cargo install` from crates.io), runs ci/coverage.sh to
merge unit-test and headless self-test line coverage, and feeds the TOTAL
line-coverage percent to the badge refresh so badges/coverage.svg tracks the
real number on every release. The step is gated on a release and marked
continue-on-error, so coverage tooling can never block a release.

coverage.sh now runs its instrumented builds --offline by default (the
dependency tree is fully vendored), overridable via CARGO_LLVM_COV_FLAGS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 09:32:41 -06:00
noahandClaude Opus 4.8 0ab822940e coverage: count the headless self-test, reporting ~46% (was ~35%)
The self-test builds the real wxWidgets table and renders every fixture through
the real widgets, exercising ~27% of ui.rs (up from ~4%) -- but it runs as a
separate binary, so a plain `cargo llvm-cov` (which only runs the #[test]s) never
counted it, understating coverage. New ci/coverage.sh runs both the unit tests and
the self-test under one instrumentation pass and merges them, excluding the
vendored asic-rs / patched wx-rs from the report.

Our-source line coverage is now ~46% (model 81%, naming 95%, fixtures 100%,
credentials 92%); the remainder is click-driven dialogs and live-miner network
I/O, which unit tests can't reach without hardware or heavy mocks. Badge, report,
and README dev section updated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 08:09:02 -06:00
noahandClaude Opus 4.8 c1aa6db834 license: unify under MIT
Collapse the dual MIT OR Apache-2.0 licensing to MIT only (operator's choice):
set the workspace `license` field to "MIT" (all crates inherit it), replace
LICENSE-MIT + LICENSE-APACHE with a single LICENSE file, and update the README
license section and the license badge. deny.toml keeps its permissive allow-list
(that governs dependency licenses, which remain a mix of MIT/Apache-2.0/BSD/etc.);
only its project-license comment changed.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-23 08:05:11 -06:00
noahandClaude Opus 4.8 7feab6117b item 12 finale: shrink the release binary + code-review report
[profile.release] opt-level="s" + fat LTO + one codegen unit + strip cuts the
Linux binary from ~38M to ~19M (50%). panic stays "unwind" deliberately: the scan
runs many miners on tokio tasks and the wx dispatch relies on unwinding, so one
miner's panic must never abort the whole app. Verified: stripped binary, SELFTEST
PASS, 99 tests, clippy clean.

Adds code-review-report.md: the ship verdict and a full accounting of the five
recursive review rounds (all confirmed critical/high fixed; remaining items are
documented perf/dev-CLI tradeoffs). Badges refreshed (tests 99, coverage ~35%).

This completes the round-18 marathon: all 12 queued items plus Round C G3 (LuxOS
named presets) and G7 (per-board V/F read side), CI hardening (verify/release
split, clippy gate, audit, badges), README + docs, and the recursive multi-agent
code review.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 21:02:09 -06:00
noahandClaude Opus 4.8 808fd4de1d review wave 7: fifth-round findings (creds, scan race, refill throttle)
Fifth (final) review round; this clears its functional findings:

- HIGH config actions / pool writes could run concurrently with a live scan
  (start_action / apply_pools guarded flash + restore but not scanning); added
  the self.scanning guard, and begin_scan now defers while an action/restore runs,
  closing the race symmetrically.
- HIGH blanking a per-firmware credential row saved a live ("","") override that
  then broke that firmware's auth fleet-wide; a fully-blank row now clears the
  override (use the shipped default).
- HIGH a ChangePassword action never updated the toolkit's own saved credentials,
  so after a fleet-wide change it locked itself out; on full success it now updates
  the saved global password (and on a partial change logs a reconcile note rather
  than guessing).
- HIGH/perf fill_rows re-rated: a scan's streaming rows triggered a whole-table
  refill on every fast tick. New rows_dirty latch flushes the refill at most once
  per second during a scan (immediately once it ends).
- MED an indeterminate access-probe result no longer blanks a miner's already-known
  locked/unlocked state.
- LOW compute-version.sh header doc corrected to match the broadened rule;
  release.yml sets WX_RS_WXCONFIG once at job level instead of per step.

Accepted (documented) perf items that remain: per-render health recompute and
per-column cell-string allocation (small, fleet-scale), the linear upsert scan,
and synchronous scan-range parsing (bounded by the range caps).

99 tests + clippy-clean + selftest green. This was review round 5 (the harness's
iteration cap); every confirmed critical/high across all five rounds is fixed.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 20:59:03 -06:00
noahandClaude Opus 4.8 63ada5bb99 review wave 6: fourth-round findings (masked prompt, board grey, timeouts)
Fourth review round found further issues, two being gaps in earlier fixes; this
clears the actionable ones:

- HIGH board_healths() painted a genuinely-undetected board RED when a fault text
  also named it (e.g. "chain 2 not found" -> Board(2)); an undetected board now
  stays grey, matching the documented grey-vs-red invariant. Regression-tested.
- HIGH the Change-password prompt used an unmasked field (the Credentials dialog
  was masked in wave 1 but this prompt was missed) -> masked for PromptKind::Password.
- MED the WhatsMiner access probe aborted all remaining password candidates on one
  transient error -> transient errors now skip to the next candidate and never
  report a confident "locked" when the answer was really indeterminate.
- MED config actions / refresh / pools / flash ignored the operator's configured
  scan timeout (used asic-rs's 10s default) -> configured_factory now applies it,
  so a slow-link action reaches the same miners a longer-timeout scan found.
- MED the auto-rescan loop set a bogus "scanning..." status even when the scan was
  deferred (mid-flash) -> begin_scan reports whether it started.
- LOW is_aml_140mm matched every S21, not just the S21 Pro its doc names -> fixed.
- Offline fixtures now reuse scan::infer_pic instead of a diverging copy.

Accepted (documented) from this round: miner_probe's argv secrets (diagnostic CLI),
the rebuild_table/update_headers sort-marker duplication, the LuxOS substring
success check (command-specific reply), restore/flash target snapshot (dialogs are
modal), non-cancellable restore/probe batches, Braiins host-key (LAN reflash), and
the perf items (per-tick refill, health recompute, linear upsert, cell formatting).

99 tests + clippy-clean + selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 20:29:52 -06:00
noahandClaude Opus 4.8 52b7c3f2a1 review wave 5: third-round findings (unreachable column, races, panics, DoS)
Third review round (over the wave 3/4 fixes) surfaced further findings, mostly in
new code paths; this clears them:

- HIGH the fully-built "Boards" column (Column::Hashboards: renderer, sort/filter
  logic, tests, a self-test check) was missing from ALL_COLUMNS, so it was
  unreachable in the UI and its self-test check was dead. Added to ALL_COLUMNS
  (opt-in; Health still shows composite board health by default) and the self-test
  now makes it visible -- the dot-sentinel check is live again.
- HIGH apply_pools() could start a pool write during a restore-to-stock (it sets
  self.action directly, bypassing start_action's guard) -> same restore guard.
- HIGH superseding an in-flight action/pools job left the old miners' Health cells
  frozen on the "…ing" label forever (the replaced handle's drain never runs) ->
  clear the superseded action's op-status.
- HIGH clean_antminer() byte-sliced a miner-supplied model string without a
  char-boundary check (panic DoS) -> use get(..9).
- MED access-probe errors were silently discarded -> surfaced in the indicator.
- MED the pool-password file was briefly world-readable before chmod -> created
  0600 from the start (OpenOptions mode).
- MED a miner-controlled log response was buffered unbounded (OOM DoS) -> capped.
- MED the language-menu id range was hardcoded (and 790-794 collided with the
  pool-preset / fw-preset dialog ids!) -> derived from Lang::all() and moved the
  dialog ids to a clear block.
- LOW restore_vnish now sends the unlock body via stdin (password off argv), and
  the LuxOS restore treats a reboot-dropped/empty reply as success.

Remaining round-3 findings are the previously-accepted perf tradeoffs (bulk-serial
writes, per-tick refill, per-render health recompute, linear upsert), documented
in code and in code-review-report.md.

99 tests + clippy-clean + selftest green (Boards-column check now live).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 19:53:56 -06:00
noahandClaude Opus 4.8 571c2305aa review wave 4: remaining round-2 findings (filters, creds, restore, panics)
Clears the rest of the second review round's confirmed findings:

- HIGH the Boards numeric filter compared the composite sort score (online*100+
  total) instead of the board count, so a filter like "Boards <= 3" matched
  nothing on healthy 3-board miners. num_value now returns the detected count;
  regression-tested with per-board health present (the path the old test missed).
- HIGH the WhatsMiner access probe ignored the operator's saved scan password
  (tried only admin/super), mis-reporting writable miners as locked. It now tries
  the caller's password first.
- HIGH firmware flash and config actions were not blocked during a restore-to-
  stock; start_action and both flash guards now refuse while a restore runs.
- MED log tail() could panic slicing at a non-UTF8 char boundary -> nudge to a
  boundary first (regression-tested).
- MED board_index_from_text grabbed an unrelated number far past the keyword
  (e.g. a temperature) -> only accept a number immediately after the keyword.
- MED a restore worker-thread spawn failure wedged the restore subsystem forever
  -> emit Done on spawn failure and treat a disconnected channel as done.
- MED LuxOS restore reported failure when the miner rebooted mid-reply -> an empty
  reply or dropped connection after a successful logon is the expected reboot.
- MED two tests raced on the process-global $HOME -> a shared serialization lock.
- LOW CSV export now neutralizes spreadsheet formula-injection prefixes on
  miner-supplied fields.
- Made miner_probe's global-only credential resolution explicit (it can't share
  the GUI's per-firmware configured_factory across the bin boundary).

99 tests (+3 regression tests) + clippy-clean + selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 19:30:29 -06:00
noahandClaude Opus 4.8 79ecc100d3 review wave 3: log-fetch credential leak + JSON escaping + column-scan cost
Second review round (over the wave 1/2 fixes) surfaced further, mostly new-path
findings; this clears the substantive ones:

- HIGH log_scan.rs passed miner admin credentials on the curl command line (same
  class as the access-probe leak fixed in wave 1). Its curl() now takes optional
  stdin: the Antminer digest login goes through a curl config on stdin (-K -),
  the VNish unlock password through the POST body on stdin (-d @-), and the
  timeout path reaps the child so it no longer leaks a zombie.
- MEDIUM JSON injection/breakage: the VNish unlock body and the LuxOS
  uninstall command spliced a password / miner-supplied SessionID into JSON with
  format!. Both now build the JSON with serde_json, which escapes correctly.
- MEDIUM column scan cost: fill_rows computed table_columns() twice (my wave-2
  built_columns check added one), and with auto-hide-empty on that scans every
  cell of every row each time. It is now computed once and reused.

Accepted, documented tradeoffs from this round: miner_probe's setpools takes the
pool password as a CLI arg (inherent to a diagnostic CLI; it is the low-sensitivity
mining worker password), MinerRow::upsert_into's linear scan is fine at the tool's
fleet scale (hundreds), and bulk config-action writes stay serial deliberately.

96 tests + clippy-clean + selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 19:18:27 -06:00
noahandClaude Opus 4.8 51b4eb2556 review wave 2: scan concurrency, table-column lockstep, background log fetch
Continuing the recursive review's confirmed findings:

- HIGH scan telemetry was serial: the consumer awaited each responder's to_row
  (get_data + presets, several REST calls) inline in the identification stream
  loop, so telemetry ran one miner at a time. Now buffer_unordered runs it
  concurrently up to SCAN_CONCURRENCY_LIMIT; identification (which buffers
  internally) is unaffected, and telemetry only hits live responders.
- HIGH table columns diverged from the built widget with auto-hide-empty on:
  (1) drag-reorder was silently rejected because column_reordered fed
  table_columns() (empty-filtered) to apply_visible_reorder, which compared it to
  display_columns() (unfiltered) -- apply_visible_reorder now reorders the shown
  subset in place; (2) a column flipping non-empty mid-scan left the widget stale,
  so fill_rows now rebuilds when the shown set no longer matches built_columns.
  Both covered by a new unit test.
- HIGH viewing a miner's log blocked the wx UI thread for up to ~20s. The fetch
  now runs on a background thread; the viewer opens from the tick drain when the
  result lands (tick returns the dialog for dispatch to show modally).
- LOW start_pools_action's fake branch now honours the cancel flag like its
  siblings.
- Documented the intentional tradeoffs the review flagged: scan-restart uses
  cooperative cancellation (a hard join would freeze the UI), and the aftermarket
  re-probe stays per-scan for freshness (firmware can change between scans).

96 tests (+subset-reorder) + clippy-clean + selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 19:02:39 -06:00
noahandClaude Opus 4.8 3b18219e4e review wave 1: fix the critical restore false-success + security/correctness findings
From the recursive multi-agent review (18 confirmed findings). This wave clears
the critical, four highs, and several mediums/lows:

- CRITICAL restore.rs: a Braiins SSH restore reported SUCCESS on a wrong password
  or unreachable miner. run_with_timeout now captures the exit code and drains
  stderr on its own thread (also fixing the medium stderr-pipe stall), and a new
  testable classify_braiins() treats an ssh auth/connection failure (stderr
  diagnostic, empty stdout, non-zero exit) as failure while still reading a
  dropped connection / timeout as the expected reboot. Unit-tested.
- HIGH restore exclusivity: apply_restore_confirm now refuses when a scan/refresh/
  action/flash or another restore is in flight, so this destructive action never
  overlaps or orphans a running restore handle.
- HIGH secrets off the command line: Braiins SSH uses `sshpass -e` (env, not -p),
  and the access-probe curl passes credentials through a config on stdin (-K -)
  instead of `-u user:pass`; both were visible in the process list. New masked
  password field (wxTE_PASSWORD bridge) so the Credentials dialog no longer
  renders saved passwords in the clear.
- MEDIUM correctness: per-board Chip-temp readings are now index-aligned with the
  boards (a missing middle board shows "-" instead of shifting later boards left).
- MEDIUM: saved pool lists (which can hold a pool password) are chmod 0600.
- LOW: access-probe curl timeout now reaps the child (no zombie).

95 tests (+classify_braiins) + clippy-clean + selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 18:45:56 -06:00
noahandClaude Opus 4.8 bcc0ba38b6 ci: install clippy component before the gate; classify all GUI src as backend
Run 82 failed because the alkane-ci image ships no clippy component
("cargo-clippy is not installed for the toolchain"). Both workflows now
`rustup component add clippy` before the gate.

Also broadened compute-version.sh: any crates/alkane-gui/src/* file is backend
logic (previously only scan.rs/model.rs/main.rs were, so a fix confined to
naming.rs / pool_prefs.rs / restore.rs / access_probe.rs / credentials.rs would
never cut a release). ui.rs/fixtures.rs/bin still match the UI arm first. All 9
compute-version tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 18:22:32 -06:00
noahandClaude Opus 4.8 749cdc4eed item 12: CI verify/release split, dependency audit, README + badges
CI is now two workflows: verify.yml (pull requests + non-main pushes) runs the
clippy gate, build, unit tests, microbenchmarks, the headless self-test, and a
best-effort dependency audit; release.yml (main) repeats the clippy gate + audit
before its existing build/test/selftest/package/release, then refreshes the
committed README badges and pushes any change back (best-effort, and a badges-
only push does not bump the version, so it does not loop).

Security: cargo audit found a build-time-only advisory (h2 0.3 in the wx-rs
build script's reqwest 0.11 subtree, never linked into the runtime binary and
never executed on Linux). The vendored/offline tree can't upgrade it without
re-vendoring, so it is documented and accepted in .cargo/audit.toml (mirrored in
deny.toml with the project's permissive-license policy).

Badges: ci/gen-badges.py emits self-contained shields-style SVGs into badges/
(tests, coverage 36%, bench, LOC 12.5k, clippy clean, dependencies, license) --
committed and referenced by relative path so a self-hosted Gitea renders them
with no external service. README rewritten around what the toolkit actually does
today (discover / monitor / operate / install), with build, CLI, dev, and
architecture sections and the dual-license note.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 18:17:31 -06:00
noahandClaude Opus 4.8 19e469ebc4 item 12: clippy-clean our crate + add LICENSE files
Cleared all clippy findings in alkane-gui (cargo clippy --no-deps): mechanical
fixes via clippy --fix (redundant imports, useless format!, manual_contains,
manual_is_multiple_of, unnecessary_map_or, unused parens) plus manual fixes:

- type_complexity: factored the segment tuple into model::{Rgb, Segment} aliases.
- large_enum_variant: #[allow] on ScanMsg/RefreshMsg with a note -- Row is the
  common variant, so boxing it to shrink the rare Started/Done would add an
  allocation per miner on the hot path.
- dead code: removed unused SHAPE_PULSE_DOT, ColorKind::Accent, clear_op_status,
  and RestoreMsg's unread `total`; kept the restore/access-probe cancel handles
  (workers honour cancellation; UI stop control pending) under #[allow].
- question_mark, needless_range_loop, drop_non_drop, doc_lazy_continuation fixes.

Only vendored wx-rs warnings remain (out of scope). Added LICENSE-MIT and
LICENSE-APACHE (Cargo.toml already declares MIT OR Apache-2.0). 94 tests +
selftest green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 18:01:49 -06:00
noahandClaude Opus 4.8 6cd732dec5 Round C G7 (read side): per-board voltage/frequency in the board tooltip
Surfaces the per-hashboard configured voltage (V) and frequency (MHz) that
asic-rs already reads into BoardData but the toolkit dropped. Added
MinerRow.board_voltages / board_frequencies (index-aligned with the boards,
0.0 where unreported), populated at scan time, and appended to the per-board
Health tooltip as extra middot segments after actual/expected hashrate.

Verified live on LuxOS S19j Pro (10.4.1.60): boards report 12.73 V (frequency
is None in LuxOS's live stats path -- a pre-existing backend gap; the tooltip
omits absent values). miner_probe `msgs` now prints board freq/volt too.

The G7 WRITE path (per-board V/F override) stays deferred: no firmware accepts
Manual targets today and a bad voltage can damage a board, so per the parity
roadmap it is bench-only and not shipped.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 17:40:32 -06:00
noahandClaude Opus 4.8 95b8428c12 Round C G3: named firmware presets (LuxOS) end to end
The flagship structured-tuning parity item: list and select a firmware's named
profiles/presets, not just map a watts number onto one.

Backend (vendored asic-rs, patch 0022): LuxOS now implements SupportsPresets
(get_presets reads the live `profiles` RPC) and a real SupportsTuningConfig
(set_tuning_config routes Preset(name) -> profileset, Power -> set_power_limit).
Unit-tested (parse_profiles_to_presets); verified live-read on two production
LuxOS S19j Pro (10.4.1.60/.67). VNish already exposed presets.

GUI: MinerCaps.supports_presets + MinerRow.presets (read live at scan time for
preset-capable miners; ~1 RPC per such miner per 300 s rescan). New "Set
profile..." right-click item opens a selector populated from the profiles
common to the whole selection (so the chosen name is valid on every target),
applied via the new ConfigAction::Preset. Offline fixtures seed demo presets.

CLI: `miner_probe presets <ip>` (list) and `setpreset <ip> <name>` (select).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 17:34:26 -06:00
noahandClaude Opus 4.8 a7ed34b8e4 gui: pool "+" "Add new..." opens a preset manager window (round 18 #8b)
The pool-field "+" menu previously offered a one-shot "Add new" (append
the current box value) plus a "Remove saved value" submenu. Both are now
replaced by "Add new...", which opens a small manager window: a multiline
editable list of all saved values for that field, seeded with the current
box value as the last line. Save rewrites the whole saved list at once.

- pool_prefs: new save_all() rewrites a field's saved list; the trim /
  drop-empties / drop-presets / de-dup step is factored into a pure
  dedupe_saved() with unit tests. Removed the now-unused add_saved /
  remove_saved.
- ui: build_pool_presets_dialog + apply_pool_presets, wired to
  ID_POOL_PRESETS_SAVE/CANCEL; "+" menu shows "Add new..." and no longer
  builds the remove submenu; ID_POOL_MENU_REMOVE_BASE dropped.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 17:10:45 -06:00
noahandClaude Opus 4.8 b839e9012d gui: default column widths fit contents, capped (round 18 #10)
Columns previously always opened at generous fixed defaults, wasting
horizontal space. Now, the first time the table is populated after a
(re)build, each column is sized to the smaller of its content-fit width
(wxCOL_WIDTH_AUTOSIZE, floored at 24px) and its configured default (the
cap). Done once per rebuild via a new columns_autosized latch, so a
user's later manual resize is preserved -- scan-update refills skip it.

New bridge: wxbr_dvlc_autosize_col_capped (SetWidth AUTOSIZE, read back,
floor, clamp to cap, SetWidth) + Widget::dvlc_autosize_col_capped.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 17:01:25 -06:00
noahandClaude Opus 4.8 d378a484d6 ui: attribute hashboard faults + pools dialog + widths (round 18 #5/#8a/#8c)
- #5 Antminer-hardware firmwares (stock/VNish/Braiins/LuxOS) report faults with no
  component, so a real per-board fault landed on the control-board tooltip instead
  of the board it names. messages_to_faults now recovers the board index from the
  self-describing message text ("Chain 2 ...", "hashboard 0 ...", "Slot 1 ...") so
  the issue shows on the right hashboard's tooltip. WhatsMiner (which does attribute
  HashBoard{idx}) is unchanged.
- #8a The pools dialog is widened so the rightmost "+" preset buttons (Password
  column) are no longer clipped off a too-narrow dialog.
- #8c The pool column headers now span field-width + the 34px "+" button, so the
  "Address/Account/Worker/Password" titles line up with the boxes below them.

board_index unit test + SELFTEST pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 16:52:24 -06:00
noahandClaude Opus 4.8 64e084ddee ui: per-icon tooltip repositioning + Zcash units/expected (round 18 #4a/#6/#7)
- #4a Health-column tooltips now reposition per icon: the query-tooltip handler
  scopes GTK's tip area to the hovered icon's slot, so moving across icons hides
  the old tooltip and shows a fresh one at the new position (was stuck in place).
- #6 Plain Antminer Z15 firmware omits the expected hashrate (the Z15j reports it),
  so it's filled from the model nameplate (420 KSol/s) -- the actual/expected
  column + colour now work for Z15 like every other miner.
- #7 Equihash hashrate now shows correct units: Sol/s (not TH/s). The stored value
  is Sol/s/1e12, so ths*1e12 recovers the Sol/s count; the per-board tooltip and
  the hashrate KPI card now label Equihash as Sol/s with an SI prefix.

Unit tests (equihash_hashrate_units) + health tests pass; SELFTEST PASS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 16:45:45 -06:00
noahandClaude Opus 4.8 93bd528430 health: PSU-fault colour rules + per-board actual/expected tooltip (round 18 #2/#3/#4b)
- #2 A PSU fault while the miner is mining is now a warning (yellow) not a failure
  (red); a fault on a non-mining miner stays red. Fixes WhatsMiners flagged red
  while running fine.
- #4b A PSU fault no longer greys the hashboards. Board colour reflects the board's
  own state: running -> green, faulted (e.g. WhatsMiner 540/560) -> red, and grey
  ONLY when the board is genuinely not detected. Stall-reddened boards the fault
  codes don't name are still exonerated to green; undetected boards stay grey.
- #3 The per-board tooltip shows actual / expected hashrate (e.g. "2  .  33.5 / 35.0
  TH/s"); a not-detected board shows "not detected". Adds MinerRow.board_expected_
  hashrates (from BoardData.expected_hashrate) + an algorithm-aware hashrate unit
  (Equihash -> Sol/s, groundwork for #7).

Health tests updated + pass; SELFTEST PASS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 16:36:00 -06:00
noahandClaude Opus 4.8 e45e6eaf91 ui: shrink brain icon, light toggle, blank all unknown-PIC (round 18 #1/#9/#11)
- #1 The control-board (brain) Health icon is drawn at 82% in its full slot, like
  the fan, so it no longer reads oversized (slot advance + tooltip hit-test unchanged).
- #9 The right-click menu now shows a single state-based light toggle: "Stop
  flashing lights" when any selected miner's locate light is on, else "Flash lights".
- #11 The PIC column is blank for every unknown case (non-Antminer makes and
  unclassifiable Antminer models) -- no more "?".

SELFTEST PASS; pic test updated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 16:28:26 -06:00
noahandClaude Opus 4.8 e5a6cc2b5e psu: extend PSU-info scan to Braiins + WhatsMiner (R5/G15)
Round 17 R5/G15. The PSU version/Vmin/Vmax columns + tooltip now populate for
Braiins and WhatsMiner, not just ePIC.

- Braiins (patch 0020): miner/details -> psu_info gives the PSU type (117, the
  same APW12 ePIC reports) + rated voltage min/max. Verified live on 10.4.1.83/.27:
  model 117, Vmin 11.96 V, Vmax 15.2 V.
- WhatsMiner v1/v2 (patch 0021): get_psu -> model + hw/sw version (no DC output or
  rated envelope exposed). Verified live on 10.8.1.214 (v2): model P221C, version
  H20201205. v3 uses a different response shape and no v3 unit was available, so
  it's left as a follow-up.
- Also fixes a pre-existing broken test (test_whatsminer_v1_parse_messages never
  mocked get_error_code -> always returned 0 messages; CI runs only the GUI
  selftest so it was never caught). whatsminer backend tests now 41/41.

SELFTEST PASS; braiins + whatsminer backend suites green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 16:07:53 -06:00
noahandClaude Opus 4.8 6fb73c9746 firmware: detect + label Bixbit and Hiveon (own colours)
Bixbit and Hiveon keep the stock Antminer web API, so asic-rs identifies them as
"AntMiner Stock". Distinguish them at scan time from the cgminer `version` reply:
Bixbit tags it with BixFirmware/BixMiner/BixAPIVersion (definitive; verified live on
a Bixbit S19j Pro at 10.4.1.70); Hiveon carries a "hiveon" marker (best-effort --
no live Hiveon unit to confirm the exact signature yet). A real stock miner (no
marker) stays "Stock".

Firmware column colours: Bixbit -> pinkish-red (223,62,102, their logo); Hiveon ->
darker logo orange (228,112,24), with "hiveon" added to the existing hive/hiveos
alias. The probe is a short, timeout-bounded cgminer query run only for Antminer
miners that first identified as stock.

SELFTEST PASS. Hiveon detection to be re-verified once a Hiveon miner is available.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 14:15:43 -06:00
noahandClaude Opus 4.8 49985631d4 antminer: read best-share fleet-wide + Bixbit "Power Estimated" wattage (R7)
Round 17 R7. Flashing Bixbit onto fleet units surfaced two Antminer scan gaps
(patch 0019): the stock v2023_07 backend never fetched best-share at all
(DataField::BestShare had no source), so it was blank for every stock/Bixbit
Antminer; and it read wattage only from the cgminer stats, which Bixbit-based
firmware leaves at 0 (real draw is in the summary as "Power Estimated").

Now maps BestShare/SessionBestShare to the cgminer summary and adds a
"Power Estimated" wattage fallback (stock power still wins when present).

Verified live: Bixbit S19j Pro (10.4.1.70) now reads 2615 W + best-share
178930671; stock S21 Pro (10.4.1.90) now reads best-share 299464394 -- both were
blank before. 36 antminer backend tests + SELFTEST pass, no wattage regression.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 13:34:01 -06:00
noahandClaude Opus 4.8 8fe61ec427 psu: PSU info scan + version/Vmin/Vmax columns + tooltip V/A (R5/G15)
Round 17 R5/G15. asic-rs had no PSU telemetry. Adds an optional PsuInfo to
MinerData (model, version, rated voltage min/max, live output voltage/current),
a DataField::Psu, and a default parse_psu backends override (patch 0018). ePIC
populates it by merging the summary "Power Supply Stats" with the capabilities
"Psu Info".

GUI: three new columns -- "PSU version", "PSU Vmin", "PSU Vmax" (Hardware group in
the picker) -- and the R2 power tooltip now shows the PSU output voltage (and
amperage when the firmware reports a non-zero current; ePIC leaves current 0, so
it shows just the voltage).

Verified live on ePIC S19j Pro (10.4.1.6/.10): model 117, fw 22, Vmin 11.877 V,
Vmax 15.182 V, output ~13.2 V. 8 model tests + 18 ePIC backend tests + SELFTEST
pass. Non-ePIC firmware leave the PSU fields blank until they add parse_psu.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 12:24:26 -06:00
noahandClaude Opus 4.8 34a1a1f3b1 tuning: structured power + hashrate target dialogs (Round C)
Round 17 C, first GUI increment. Adds "Set power target..." and "Set hashrate
target..." to the right-click config menu, each a value prompt that shows the
miner's current target and the firmware-advertised valid range, and validates the
entry against it.

- Power target routes through the existing set_power_limit path (LuxOS/Braiins/
  WhatsMiner; VNish stays masked per operator guidance). Where the firmware
  advertises an envelope (Braiins: 944-6435 W) the prompt shows and enforces it.
- Hashrate target routes through set_tuning_config for firmware that tunes by
  hashrate (ePIC). The apply path preserves the firmware's current tuning
  algorithm and scaling config (ePIC's set_tuning_config requires both), reading
  them back before writing the new target.

Model gains: MinerRow.tuning_target_label + power/hashrate target min/max
(from data.tuning_capabilities), and MinerCaps.hashrate_target (set when the miner
actively tunes by hashrate via set_tuning_config). miner_probe's settune verb now
mirrors the same algorithm+scaling-preserving apply path.

Verified live (reversibly, restored after): ePIC S19j Pro (10.4.1.6) hashrate
94->92->94 TH via set_tuning_config Ok(true); LuxOS/Braiins power targets via
set_power_limit (see the luxminer profile-name fix). Model tests + SELFTEST pass.

Presets (G3) and per-board manual V/F (G7) are deferred: no firmware enumerates
its presets through the standard tuning_capabilities API.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 11:33:43 -06:00
noahandClaude Opus 4.8 0db89d6c55 miner_probe: add tune (read) + settune (write) verbs for structured tuning
Round 17 C groundwork. `tune <ip>` dumps a miner's structured-tuning surface --
what it supports (power_limit / tuning_percent / tuning_config), its current
target, and the capability envelope (power/hashrate min-max or preset list) the
firmware advertises. `settune <ip> <power|hashrate> <v>` applies a target via
set_tuning_config where supported (ePIC/VNish/WM), falling back to the plain
power-limit setter for a power target on firmware that tunes by power
(LuxOS/Braiins).

Used to map the live fleet before wiring the GUI: ePIC tunes by hashrate via
set_tuning_config (needs an algorithm + scaling config); LuxOS/Braiins tune by
power via set_power_limit; VNish/WM accept set_tuning_config; only Braiins
advertises a min/max envelope; preset lists are not exposed by any firmware's
tuning_capabilities.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 11:21:07 -06:00
noahandClaude Opus 4.8 08b3d56864 luxminer: set power-limit profile by name so the default profile is reachable
Round 17 C, found via live tuning verification. LuxOS set_power_limit mapped
watts to a profile but applied it by the profile's Step. The factory "default"
profile has Step "0", which LuxOS profileset reads as an empty parameter
("Missing profile parameter"), so the setter could never select the default and
a miner nudged off it by a watts limit could not be returned to its factory
point. Key on the profile Name instead (patch 0017).

Verified live on a LuxOS S19j Pro (10.4.1.60): set_power_limit(2700)->480MHz/2632W,
set_power_limit(2900)->default/2794W (previously errored). Unit test updated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 11:20:51 -06:00
noahandClaude Opus 4.8 4e825f3ee5 health: bare-data per-component tooltips (R2)
Round 17 R2. The Health column's per-icon tooltips were prose ("Hashboard 3:
faulted", "Power supply: OK (drawing power)"). Replace them with just the data an
operator wants:

- Hashboards: an operating board shows its number counting DOWN (n-1..0, left to
  right) and its hashrate ("2  ·  33.5 TH/s"); a faulted board shows its error
  message with the firmware code; a board the failed PSU left untested shows
  "unpowered". No "Hashboard N:" prose.
- Fans: just the RPM ("4700 rpm"), unless the fan has a fault (then the error+code).
- Control board: its own and un-attributed faults with codes, else a short OK.
- Power: a healthy PSU's output voltage + amperage when reported, else a short OK;
  a faulted PSU shows the error and code.

Adds per-board hashrate (BoardData.hashrate) and the firmware error code
(MinerMessage.code) to the model, and forward-compatible PSU output V/A fields.
asic-rs does not yet expose PSU output V/A (roadmap G15), so the healthy-PSU
tooltip shows "PSU OK" until that lands, at which point it auto-upgrades to "V / A".

Unit tests (faults_attribute, health_tooltips_are_bare_data_round17_r2) pass;
SELFTEST PASS. Live data confirmed available (per-board hashrate + fan RPM on the
Braiins corpus miners).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 10:45:15 -06:00
noahandClaude Opus 4.8 8e67c50fe0 health/pic: shrink fan icon (R1), blank PIC for non-Antminers (R6), add build cleanup
Round 17 queue.

R1 -- the cooling-fan icon in the Health column read as oversized next to the
brain/chip/bolt icons. All four use a square 512x512 viewBox at the same slot
size, so the fan only *looked* bigger because the Font Awesome fan glyph fills
its box more. Draw the fan at 80% size, centred in its full-size slot, so the
slot advance and the per-icon tooltip hit-test (both keyed to the full width)
are unchanged and nothing else moves.

R6 -- WhatsMiner and other non-Antminer makes showed "?" in the PIC column. A
per-board PIC MCU is an Antminer hashboard property with no meaning elsewhere, so
the cell now shows nothing for non-Antminer brands; an unknown *Antminer* model
still shows "?".

Build hygiene (user ask) -- add scripts/clean-old-builds.sh to reclaim the local
cargo target dir. The app/CLI ship as release and tests run under --release, so
the debug tree, cross-compile trees, and coverage tree are disposable; a stray
cargo check had grown the debug tree to 38G and filled the disk. The script drops
those, keeps the warm release build, and is meant to run after each release push.

SELFTEST PASS; model tests (pic_locked, faults_attribute, health) pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 10:31:51 -06:00
noahandClaude Opus 4.8 da0d1582be scan: cap identification concurrency at 128 to fix Braiins value dropout (R4)
Round 17 R4. Scanning most values from Braiins OS units failed under a
full fleet scan: a /24 returned watts=0 and no best-share/temps/fw for
Braiins miners (and dropped a few responders entirely), while the same
miner scanned in isolation populated fully.

Root cause: asic-rs picks a scan concurrency of 1000 for any range up to
/22, so a /24 fires all ~254 address probes at once. Over a real link
(the fleet is reached across a WireGuard VPN, and a subnet full of dead
IPs holds every TCP connect open for the whole identification timeout)
that burst starves the per-responder get_data. A Braiins miner fans out
~12 authenticated REST calls; under the burst they drop miner/stats, so
"most values" come back blank. It is not FD exhaustion (nofile is 500k),
not the per-call timeout, and not an auth race.

Fix: cap identification concurrency at 128 in the app (GUI scan +
miner_probe). On the live fleet 128 was the highest cap that stayed fully
reliable -- 192 already dropped responders, 254 blanked a Braiins miner.
A /24 still finishes in ~35s; larger ranges just take proportionally
longer and stay correct.

Belt-and-suspenders in the braiins backend (patch 0016): single-flight
the login (one auth instead of ~12 concurrent) and widen the defensive
get_data timeout 5s -> 15s.

Verified live: 10.4.1.0/24 now populates both Braiins corpus miners
(.27 watts=2748 best=55217110, .83 watts=2749) fully and misses no
responders (65/65). SELFTEST PASS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 09:59:27 -06:00
noahandClaude Opus 4.8 7f802c568f Scan progress: smooth per-address counter (was jumping ~1%/second)
The scan counter jumped in big steps (e.g. +45 for a 4590-address scan) because
(a) progress was only emitted every total/100 addresses and (b) the drain timer
ran once per second, so the gauge only refreshed ~1 Hz. The +45 was total/100, not
a chosen value.

Fix, both cheap:
- scan.rs emits progress per address (throttled only above 5000 addresses to bound
  channel traffic) instead of every 1%.
- ui.rs runs the scan/drain timer at 200 ms (5 Hz) so the counter climbs smoothly;
  drain_scan coalesces the many per-address updates into ONE gauge/status update
  per drain (no extra repaints). A tick accumulator keeps the once-per-second work
  (auto-rescan countdown, idle status) at 1 Hz despite the faster tick.

Net: the counter now climbs several times a second in small increments; overhead
is negligible (unbounded mpsc sends are cheap and the gauge still repaints once per
tick). No user-facing setting added -- the smoothness is size-independent.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 09:21:33 -06:00
noahandClaude Opus 4.8 86338062a5 Round 17 B (part 2, GUI): timezone / change-password / factory-reset dialogs + BOS fix
Wire G10/G11/G12 into the GUI (they already had CLI verbs in part 1):
- MinerCaps gains timezone / change_password / factory_reset (probed from the
  matching supports_*() at scan time; intersect + any_control + is_empty updated).
- ConfigAction gains Timezone(String) / ChangePassword(String) / FactoryReset with
  labels + apply arms. Timezone/FactoryReset go through apply_action(&dyn Miner);
  ChangePassword takes &mut self so it runs on the owned miner in the action loop.
- ui.rs: a shared PromptKind (Power/Tuning/Timezone/Password) generalises the
  value prompt (timezone is IANA-validated before firing; password is non-empty);
  factory-reset uses the confirm dialog with a strong WIPES-config/DHCP warning.
  New gated context-menu items: Set timezone, Change password, Factory reset.

Backend fix (asic-rs patch 0015): BOS send_command treated an empty 2xx body as a
parse error, so change_password reported Ok(false) on success. Empty 2xx is now
Null (success). Found + fixed while live-verifying G11.

Verified live on Braiins 10.4.1.27: full change-password round-trip (root ->
bftest2 -> read with new pw -> restore root), all Ok(true), unit left on root/root.
Timezone shares the CLI-verified set_timezone_config path. Factory-reset is wired +
gated but intentionally NOT live-fired: its behaviour is unrecoverable per firmware
(can revert LuxOS to stock / reset network to DHCP and lose the unit) -- needs a
truly sacrificial console-attached unit. GUI selftest + 89 unit tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-22 08:58:00 -06:00
noahandClaude Opus 4.8 c4c85d5b3d Round 17 B (part 1, CLI): timezone / change-password / factory-reset verbs (G10/G11/G12)
Round B wires the already-complete SupportsTimezoneConfig / ChangePassword /
FactoryReset backends to the toolkit. Part 1 adds the committed CLI surface
(GUI dialogs follow in part 2):
- `timezone <ip> [<IANA>]` - read (no arg) or set the timezone (gated on
  supports_timezone_config: Braiins/VNish/ePIC).
- `passwd <ip> <newpass>`  - change the web/API password (gated).
- `factoryreset <ip>`      - factory reset (gated).
Each is capability-gated and the usage banner marks passwd/factoryreset DANGEROUS.

Verified live: timezone set/read/restore end-to-end on Braiins 10.4.1.83
(set America/Edmonton -> read back -> restore Etc/GMT, all Ok). change-password
and factory-reset are implemented + gated but NOT live-run: both are destructive
on the shared corpus (change-password breaks the default auth every other test
relies on; factory-reset can reset a unit to DHCP and lose its IP) -- they need a
dedicated sacrificial/console-attached unit to verify live.

Also: ci/compute-version.sh now treats crates/alkane-gui/src/bin/* as a UI change
so CLI-tool changes trigger a release.

Note: the VNish timezone READ errors ("Unrecognised VNish timezone GMT, expected
GMT+N/-N") is a pre-existing vnish backend parse quirk, separate from this wiring.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 22:58:43 -06:00
noahandClaude Opus 4.8 25c8ccf1ff Round 17 A (part 2, G13): LuxOS pool ops privileged + removepool
The luxminer pool write commands (addgroup/groupquota/removegroup/addpool/
switchpool/enablepool/disablepool) sent privileged=false -> no session_id, which
fails with "Missing session_id" on password-set LuxOS units (all other LuxOS
writes are already privileged). Flipped all seven to privileged=true and added the
missing removepool. asic-rs patch 0014.

Verified no regression on default corpus unit 10.4.1.60 (set_pools_config still
applies). The password-set failure needs a password-set LuxOS unit to verify live.

Round A remaining: G8 (constraints/limits reads) and G14 (telemetry enrichment) are
deferred to the rounds that consume them (G8 -> the tuning/cooling dialogs in C/D;
G14 -> detail-panel/tooltip work) rather than built as unused plumbing now.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 22:47:18 -06:00
noahandClaude Opus 4.8 307539543d Round 17 A (part 1): committed write CLI (G1) + best-share reads (G9) + parity roadmap
Executing the aftermarket config+scan parity plan (docs/aftermarket-parity-roadmap.md,
from the ultracode writer/adversary workflow). This is Round A's foundation + first cheap win.

G1 - miner_probe is now a committed config+scan CLI, not a local-only diagnostic. Added
capability-gated write verbs: `light <ip> <on|off>`, `pause`, `resume`, `restart` (alongside
the existing setpl/setpools/led), a READ vs WRITE usage banner warning that write verbs mutate
(use the test-bed miners, not production), and best_share/session_best_share columns in `scan`.
Verified: `light on`/`light off` on a LuxOS corpus unit -> Ok(true) (reversible).

G9 - implement GetBestShare/GetSessionBestShare (were empty impls feeding two dead columns):
Braiins v26_04 reads miner/stats -> /miner_stats/best_share; LuxMiner v1 reads summary ->
/SUMMARY/0/Best Share + Best Session Share. Both reuse already-collected responses (no extra
calls). asic-rs patch 0013. Verified live read-only: BOS 10.4.1.83 = 130601978 (no session on
BOS); LuxOS 10.4.1.60 = 638881749/638881749, 10.4.1.67 = 497802665/497802665 -- exact API match.
(WhatsMiner stock summary exposes no best-share on the tested units; deferred. The roadmap's BOS
source "miner_stats" was a typo for the real "miner/stats" endpoint.)

Also commits the parity roadmap (docs/) as the plan of record for rounds A-F.
Round A remainder (G8 constraints reads, G13 LuxOS pool-op privileged fix, G14 telemetry
enrichment) follows; G13 needs a password-set LuxOS unit to fully verify.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 22:36:59 -06:00
noahandClaude Opus 4.8 561c50e5dc GUI round 16 (#4/#5/#6/#7): UMC OS colour, pool + restore dialog polish, new icons
- #4 ePIC miners report their firmware family as "UMC OS"; colour that row light
  blue in the Firmware column (was falling through to the theme default / black),
  matching the existing ePIC colour.
- #5 Configure-pools dialog: widen the "+" buttons so the glyph shows; the dropdown
  "add" entry now reads "Add new"; user-added values can be removed via a "Remove
  saved value" submenu (pool_prefs::remove_saved); dropped the intro tidbit and
  narrowed the window.
- #6 Restore-to-stock confirmation: the miner list is now a height-capped,
  scrollable text box instead of one unbounded label, so restoring hundreds at
  once stays usable. Removed the "Flash firmware..." right-click option for now
  (the in-app flash path is parked while it is reworked).
- #7 Replaced the brain (control board) and fan Health icons with the new
  operator-supplied artwork, image-traced from PNG to SVG (potrace) and stripped
  of explicit fills so the Health column's per-state recolouring still applies.

Headless selftest passes (fixtures render through the real widgets); all GUI unit
tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 17:43:45 -06:00
noahandClaude Opus 4.8 74b97162f5 GUI round 16 (#1/#2/#3): per-component health attribution + tooltips
Health icons and their hover tooltips now reflect the miner's actual per-component
faults instead of a generic "faulted".

- #1 Each Health icon's tooltip carries the specific fault text for THAT component
  (e.g. "Slot 0 error reading chip id.", "Power current error."), sourced from
  asic-rs's structured MinerMessage.component (HashBoard idx / PowerSupply / Fan /
  ControlBoard) rather than fragile string matching on the summary. New MinerRow
  `faults` field + FaultComponent/Fault types; scan.rs maps messages -> faults.
- #2 A power-supply fault turns the bolt icon red, lists the PSU faults on its
  tooltip, and greys (not reds) every hashboard -- the boards can't be powered or
  tested, so they read "unpowered (PSU fault)".
- #3 When the miner reports board-specific faults, ONLY the named boards are red;
  the rest stay green. A whole-miner stall zeroes every board's hashrate, which
  previously reddened working boards the error codes actually exonerate.

Backend enabler (asic-rs patch 0012): the WhatsMiner V1 backend now sources faults
from get_error_code (like V2/V3; its summary error fields are empty on H6OS), and
a targeted repair fixes firmware that emits an invalid bare-pair error_code array.

Verified live: 10.7.1.231 (PSU) greys its boards + shows the 4 PSU faults on the
bolt; 10.8.1.234 (540/541/561) reds boards 1+2 and leaves board 3 green. Unit
tests cover the attribution and the malformed-array repair; all suites pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 17:30:18 -06:00
noahandClaude Opus 4.8 75663f4c23 asic-rs: implement LuxOS set_power_limit (via profiles); document ePIC PSU gating
Follow-up to the Round 15 corpus. The toolkit reported supports_power_limit=false
for LuxOS and ePIC; investigated both against the live corpus (S19j Pro).

LuxOS was genuinely under-reporting: it tunes by discrete named profiles that each
carry a Watts rating (the `profiles` RPC gives Step + Watts), applied via
profileset -- pure frequency/voltage tuning, no PSU dependency. Implemented
SetPowerLimit to map the requested watts to the highest profile whose Watts does
not exceed it (or the lowest profile when the target is below all of them). The
pure mapping (parse_profile_watts + select_profile_at_or_below) has a unit test.
Live-verified: set_power_limit(2500) on an S19j Pro picked step -4 (2385 W) and
the miner's active profile became 445MHz/-4.

ePIC is left at false, now with a comment explaining why: PowerPlay's only true
power-limit path is the PowerTune perpetual-tune algorithm, which the firmware
gates on the PSU -- on a fixed-voltage Bitmain APW12 (S19j Pro) it answers "Power
optimization is not supported by this PSU". That is a per-PSU runtime property the
synchronous capability check cannot see, so reporting true would over-advertise on
most reflashed Antminers. Hashrate tuning remains available via set_tuning_config.

Captured as asic-rs patch 0011. luxminer + epic crate tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 16:40:38 -06:00
noahandClaude Opus 4.8 9eb6a0f229 asic-rs: fix Antminer locate-LED (and reboot) on legacy web-UI firmware
Round 15 #7. The "flash the light" action failed on old (< 2023.07) Antminer
firmware -- the LuCI web-UI generation, e.g. the Z15/Z15J. set_fault_light
returned Ok(false) on live hardware while appearing to "succeed".

Root cause (confirmed on a live Z15): that firmware's blink.cgi ignores the JSON
body {"blink":"true"} the backend sent (answering 200 with an empty text/html
body, so the JSON parse fails and the error is swallowed into Ok(false)). Its own
blink.html POSTs a form field action=startBlink/stopBlink and reads state back via
action=onPageLoaded -> {"isBlinking":bool}; the action handler also often answers
401/500 even on success, so HTTP status is not a reliable signal.

Fix (v2020 backend): add a form-encoded POST helper; blink() now fires
action=startBlink/stopBlink, ignores the unreliable status, and reads the real
state back via onPageLoaded; set_fault_light reports success only when the observed
isBlinking matches the request. The LightFlashing read is routed to the same path
(get_blink_status.cgi is 404 here) and remapped to {"blink":bool}.

Also switch reboot() from POST to GET to match the same firmware's reboot.html (the
Restart action was affected); not live-fired, to avoid rebooting production miners.

Captured as asic-rs patch 0010. Also teach ci/compute-version.sh that vendor/* and
thirdparty/asic-rs/* are backend changes, so vendored fixes trigger a release.

Verified live: Z15/Z15J now return Ok(true) with the light genuinely toggling;
VNish (4 control boards) and WhatsMiner (H6OS/H616) unchanged; antminer tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 15:19:05 -06:00
noahandClaude Opus 4.8 bafbd519bb GUI round 15 (part 2, #13): Settings menu, localization, Logs page
Add a Settings menu (the old Credentials toolbar button is now "Settings")
containing Credentials, a Language sub-menu, and a Logs page.

Localization (#13): a small i18n layer -- visible strings are wrapped in
t("English") and looked up per language, falling back to English. Built-in
translations for Mandarin, Russian, French, Spanish and Portuguese cover the
toolbar buttons, KPI captions and table column headers; changing the language
re-labels them live (columns via a table rebuild) and localizes dialogs as
they open. The choice persists under the config dir and loads at startup.
(Dialog-internal strings and status text are not yet fully translated -- the
framework is in place to extend them.)

Logs page (#13): an in-app activity log (scans, operations applied, export,
language change) shown in Settings > Logs with Refresh / Clear.

New wx-rs bridge: menu sub-menus (menu_append_submenu). Bridge patches
0002/0003 regenerated. Unit tests + headless selftest pass; the Chinese UI
was verified rendering end to end.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 14:54:10 -06:00
noahandClaude Opus 4.8 0d19e958f0 GUI round 15 (part 1): pool dropdowns, aligned health icons, export, more
Twelve of the round-15 items (the code items; the live-hardware flashing/
testing and the settings/localization/logs work follow separately):

#1 Configure-pools: three pool rows (address, account, worker, password),
each field with a "+" dropdown of presets (top-11 BTC pool stratums;
worker-name placeholders) plus user-addable, persisted entries. Worker
picks insert at the cursor rather than replacing. Writes up to three pools
per miner via set_pools_config, worker expanded per unit.

#2 PIC detection: replace the broken SSH i2cdump (it read 0x48, the temp
sensor, not the PIC) with a model lookup -- no firmware exposes PIC over the
network, so infer it from the model (noPIC: S19k Pro, S21 family, T21,
explicit noPIC; PIC: rest of the S19 line).

#4 Zoom: an editable percent field in the status bar (type an exact scale)
and Ctrl +/- / Ctrl+0 to zoom in/out/reset.

#5 Health icons align in fixed slots (power, control, fans, hashboards);
miners with fewer fans/boards leave a gap so hashboards still line up. The
max fan/board counts are computed parametrically from the fleet.

#6 Light: the locate-light column is on by default (last), shown as a
green-over-red beacon flashing quickly instead of a single amber dot.

#8 The bottom-left status line is now scan-only; operation progress lives in
the Health column (per miner) and failures in the bottom-right indicator.

#9 / #10 / #11: drop the Credentials-dialog blurb; move the scan-ranges
format help to a tooltip; make Restore-to-stock a plain confirmation (no
typed keyword, no warning wall).

#12 Z15 fans: the v2020 backend now reads fans from higher fan slots
(the Z15 reports fan3/fan4 with fan1/fan2 = 0). Vendored patch 0009.

#14 Export: an Export button writes every scanned data point to a CSV, one
value per cell (lists expanded to indexed columns) -- complete and
machine-readable, unlike the on-screen table.

#15 Health tooltips are per-icon: hovering a specific fan or hashboard shows
just that component's state, with errors attributed to the board that names
them in the message.

New wx-rs bridge surface: widget tooltips, save-file dialog, insert-at-cursor,
status-bar zoom entry + Ctrl+/-, the light beacon + alignment-gap sentinels,
and per-icon cell tooltips (bridge patches 0002/0003 regenerated). Unit tests
(worker templates, PIC map, CSV export, health) + headless selftest pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 14:43:00 -06:00
noahandClaude Opus 4.8 368f992404 GUI round 14: bigger health icons, table zoom, pool config, op progress
Seven items from the round-14 list:

#1 Health icons: render bigger (nearly the full row height) and packed
tighter so a row of component icons stays large and readable; the icon
sizes also scale with the new table zoom.

#2 Scan timeout: a per-miner scan timeout (asic-rs identification timeout)
is now configurable in the Scan-ranges dialog and persisted, so slow
miners can be given longer or fast scans sped up.

#3 Table zoom: a slider in the bottom-right of the status bar scales the
whole table together -- font, component icons, row height, and column
widths -- from 50% to 250% (default 100%). Implemented in the wx bridge
(no Rust round-trip); the custom SegmentRenderer draws its text in the
control's scaled font so the coloured columns zoom like the native ones,
and the zoom is re-applied after a column rebuild so it survives show/
hide/reorder.

#4 Operation progress: while an operation runs on a miner (refresh,
config/light/power/tuning action, firmware flash, restore-to-stock, access
check), its Health cell shows the progress text ("refreshing…",
"restarting…", "setting pools…", …) instead of the component icons, and
reverts to icons when the operation finishes.

#5 Remove the SSH PIC probe: the "Detect PIC (SSH)..." right-click flow and
its dialog, background probe, and pic_probe module are removed. PIC state
stays a best-effort model-string heuristic in the PIC column.

#6 WhatsMiner access: WhatsMiners now show the locked/unlocked padlock in
the Access column instead of a blank cell -- since round 12 #8b gave the
V1/V2/V3 backends their control commands, the same capability heuristic the
other brands use applies to WhatsMiner too (the token access check still
refines a read-only unit to "locked").

#7 Configure pools: a right-click "Configure pools..." flow (gated on the
new pools capability) with three fields -- pool address and account
(required) and an optional worker name. The worker name expands per miner
from case-insensitive placeholders scanned from each unit: {ip1}..{ip4},
{serial}, {mac} (colons removed), {nameplate-hr} (rated TH), {brand},
{model}, {submodel}, {cpu}, {cb}, {firmware}, {hostname}. Applied via
asic-rs set_pools_config on a background thread reusing the action plumbing.

wx-rs bridge patches 0002/0003 regenerated. No vendored asic-rs changes.
Unit tests (component health, worker-template expansion) + headless
selftest pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 12:20:06 -06:00
noahandClaude Opus 4.8 ecdb2fab9d GUI round 13: health-icon column, Z15J algorithm, Credentials + Columns dialogs
Five items from the round-13 list:

#4/#5 Z15 hashrate / unknown algorithm: a Z15J reports its model as
"ANTMINER Z15J", which asic-rs' alias table did not recognise, so it
deserialised to Unknown and its Sol/s hashrate was left un-bucketed as
"unknown hashrate". Add a first-class Z15J model (Equihash) in the makes
crate, plus a family-letter fallback in the v2020 backend so other
un-tabled Antminer models still resolve an algorithm (Z->Equihash,
L->Scrypt, S/T->SHA-256; ambiguous K/DR stay Unknown). Live-verified on
the Z15/Z15J fleet. Carried as vendored patch 0008.

#3 Component-health column: a new Health column (power, control board,
each fan front-to-back, each hashboard) drawn as coloured icons -- grey
unreachable, red down, yellow sub-optimal, green healthy -- replacing the
Errors, Boards and Status columns. Left-clicking the header cycles the
sort through the component facets (overall/power/fans/hashboards); the
active facet shows as a tag beside the chevron. Errors move to the cell
tooltip. Four operator-supplied Font Awesome icons registered via the
existing SVG-in-cell renderer (new SHAPE_BOLT/BRAIN/FAN/CHIP sentinels).

#2 Credentials: rename the "Set scan credentials" button to "Credentials"
and make the per-firmware defaults the main dialog (the global "all
firmwares" login is folded in as the top row).

#1 Columns dialog: narrower; new Alphabetical and Categories sort buttons
(via a Column::category grouping and a wxbr_reorder_set_order bridge fn);
one mouse handler that does both drag-to-reorder and drag-to-rubber-band-
select (the old BEGIN_DRAG binding had silently disabled rubber-band
selection); Ctrl+A select-all and Ctrl/Shift+Up/Down extend-selection.

wx-rs bridge patches 0002/0003 regenerated. Unit tests + headless
selftest pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Djv3oncM4LxTS5tb61Ako6
2026-09-21 11:06:05 -06:00
noahandClaude Opus 4.8 a75fe5ba52 GUI round 12 (#8a): restore aftermarket firmware to stock (right-click)
Adds a right-click "Restore to stock firmware..." action for aftermarket-firmware
miners, behind a strong typed (RESTORE) confirmation that lists exactly which
miners will be reverted. All three supported firmwares self-restore for free (the
stock image is retained on-device; no image is uploaded), per the live-confirmed
flows in the miner-firmware wiki:
- VNish:   POST /api/v1/unlock -> bearer -> POST /api/v1/firmware/remove (~3 s)
- LuxOS:   luxminer :4028  logon -> uninstallluxos (credential-free)
- Braiins: SSH `uninstall.sh` (re-flashes the on-NAND stock backup)

New crates/alkane-gui/src/restore.rs runs the revert on a background thread with a
result channel and a fake-scan demo path; VNish password reuses the round 12 #13
per-firmware default, Braiins uses the saved SSH login. The menu item only appears
when the selection includes a revertible firmware.

Also fixes an event-routing bug introduced in #12/#8a: the log-viewer Close and
restore OK/Cancel buttons were mistakenly handled in the MenuItem match instead
of ButtonClicked, so they never fired -- this restores #12's log-viewer Close
button too. Moved them to the ButtonClicked match.

Verified under Xvfb + openbox: the menu item shows for VNish/LuxOS/Braiins rows;
the confirm dialog renders the targets and typed gate; typing RESTORE runs the
(fake) revert and closes the dialog; a wrong value is rejected and the dialog
stays open. restore unit test + GUI self-test pass. NOTE: no live restore was
run -- the designated test range 10.2.1.0/24 is currently empty, and production
miners were not touched; the live flash awaits a unit in that range.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-20 11:39:49 -06:00
noahandClaude Opus 4.8 f1fb2f8623 GUI round 12 (#8b, part 2): WhatsMiner control commands on the older V1 backend
asic-rs already implements the full WhatsMiner proprietary control+monitoring
surface for V2/V3 (adjust_power_limit, set_led, update_pools, reboot, power_off/
power_on + all reads), so the modern fleet was already covered. The gap was the
V1 backend (firmware < 2022-07-29): it declared no control commands, so older
units could only be monitored and the GUI's capability actions never appeared.

V1-era firmware speaks the same classic btminer token write API as V2 (the round
12 #8b part 1 access-probe handshake proved V1 accepts get_token + AES), so the
V1 backend now reuses V2's proven RPC client for writes and implements the same
control commands: set_fault_light, set_power_limit, update_pools, restart, pause,
resume (HasAuth routes the admin password to the write RPC).

Verified live on a V1 unit that the token AES key (password) is accepted; the
write path is byte-identical to V2's live-validated one. Some V1 units keep their
API in read-only mode and answer writes with Code 45 "can't access write cmd"
until an operator enables write access via the WhatsMiner Tool -- a per-device
setting; the backend now fails those gracefully instead of hiding the command.
40 whatsminer crate tests pass; GUI self-test passes. Patch queue adds 0007.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-20 11:13:01 -06:00
noahandClaude Opus 4.8 a6d286a147 GUI round 12 (#12): scan miner logs over the firmware API (PIC + metrics)
Adds a right-click "View log (API)..." action that fetches a miner's log through
its firmware API and regex-scans it -- the "logs through API" path for PIC
detection and other metrics without SSH.

Per firmware (crates/alkane-gui/src/log_scan.rs, curl-based like the access
probe, stdout drained on a thread so a large log never deadlocks the pipe):
- VNish: POST /api/v1/unlock -> bearer -> GET /api/v1/logs/miner (the full miner
  log: PSU init, per-chain chip detection, tuning, errors).
- Stock Antminer: GET /cgi-bin/log.cgi (digest); older models (Z15) that do not
  serve it are reported as "no log over its web API".
- WhatsMiner: get_error_code on :4028 (unauthenticated) formatted as the log.

The summary regex reports PIC status ("not present (no-PIC miner)" / "present --
<version line>"), the latest per-chain chip-detection line, and recent errors
from the log history. Creds reuse the round 12 #13 per-firmware defaults (VNish
password, else "admin"; Antminer web login from the saved global creds).

Verified live: VNish S19j Pro (10.7.1.25) log -> "PIC: not present (log reports a
no-PIC miner)" + chains + recent errors; WhatsMiner (10.8.1.45) -> its active
error codes; Z15 (10.5.1.196) -> honest "no log over its web API". Unit tests for
the summary + a headless ALKANE_LOG_SCAN diagnostic; self-test passes.

Note: WhatsMiner fault codes already surface in the Errors column via asic-rs's
get_error_code -> messages; this adds the raw-log view and the PIC scan on top.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-20 10:54:52 -06:00
noahandClaude Opus 4.8 3ba3211371 GUI round 12 (#8b, part 1): correct WhatsMiner lock/access with the :4028 token API
WhatsMiners were shown "locked/unauthenticated" even with their default login.
Two causes, both fixed:

- The access probe hit an Antminer-only endpoint (/cgi-bin/get_miner_conf.cgi via
  curl --digest) for EVERY make; WhatsMiners answer 307 there, so the check was
  always indeterminate. Added a real WhatsMiner check over its :4028 token API:
  get_token (unauthenticated) -> derive the AES key from the password (md5crypt +
  SHA256, the same scheme the vendored asic-rs whatsminer backend uses) -> send a
  NON-mutating encrypted `summary`. An encrypted reply means the password was
  accepted (unlocked); a plaintext "enc json load err" means rejected (locked).
  probe_access now branches on the miner brand. Candidate passwords: a per-firmware
  override (round 12 #13) if set, else the factory defaults admin (V1/V2) and super
  (V3); all attempts are non-mutating so trying both is safe.
- The scan-time lock guess (!caps.any_control()) falsely marked older WhatsMiners
  locked because they route to the asic-rs V1 backend, which declares no control
  commands even though the miner is controllable via the token API. WhatsMiner
  lock state is now left unknown at scan time and decided by the real probe.

Live-verified on the fleet: older 20220422.18.REL units (10.8.1.176, 10.7.1.196)
and newer M30S+ (10.8.1.45) all report UNLOCKED with the default admin login;
the Antminer digest path is unchanged (Z15 -> 200 with root/root -> unlocked).
Added a headless `ALKANE_ACCESS_PROBE="<ip> <make>"` diagnostic and a
deterministic AES unit test. Self-test passes.

Note: this is the access/lock half of #8b. Implementing the full reverse-
engineered WhatsMiner command set (control + monitoring over the token API) is
tracked separately.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-20 09:29:43 -06:00
noahandClaude Opus 4.8 c8d5cd71c4 GUI round 12 (#10): Z15 realtime hashrate + control board, from data we can read
Stock Antminer Z15/Z15J were mis-handled: their control board showed blank and
their realtime hashrate looked absent next to the target. Root cause: the version
detector only read summary.cgi, which the Z15 does not serve (404), so version
detection returned nothing and AntMiner::new fell through to the newest backend,
which mis-parsed the miner. Fixes (all in the vendored asic-rs antminer crate,
verified live on 10.5.1.x):

- Backend routing: fall back to the cgminer :4028 `version` RPC's CompileTime when
  summary.cgi is absent, so a 2020 Z15 routes to the v2020 backend instead of the
  default newest one.
- Control board "read, not guess": the Z15 has no miner_type.cgi, so read the
  control board from the kernel build string in get_system_info.cgi
  ("Linux 4.6.0-xilinx-..." -> Xilinx). The ControlBoardVersion field now carries
  both the subtype and the kernel; the parser prefers the explicit subtype and
  falls back to the kernel marker (xilinx/zynq -> Xilinx, aml/meson -> AMLogic).
- Malformed cgminer stats: the Z15 emits a stats array with no commas between its
  objects (invalid JSON serde rejected, which dropped every stats-derived field).
  Insert the missing separators before parsing (a no-op on valid responses),
  restoring expected hashrate, fans, hashboards and uptime. Expected hashrate now
  gets the same Equihash Sol/s reinterpretation as the realtime rate, so both read
  on one scale (e.g. 144k / 320k) instead of expected reading ~1e6x larger.

Live result: Z15/Z15J now report control board "Xilinx" and realtime/expected
hashrate on the same scale. asic-rs antminer crate tests (35) pass; GUI self-test
passes. Vendored source + refreshed checksum committed; patch queue adds 0006.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-20 08:59:53 -06:00
noahandClaude Opus 4.8 c74e8ebaca GUI round 12 (#6): fade the locate-light dot in and out
The Light column's flashing-light dot now pulses (fades between ~30% and 100%
opacity over a ~1.6 s cycle) instead of sitting static, so a flashing locate
light reads as live.

- A distinct SHAPE_PULSE_DOT sentinel marks the fading dot, so only the locate
  light pulses -- the hashboard health dots stay solid.
- A wxTimer in the bridge advances an animation phase and, each 100 ms tick, emits
  a row change so the custom cell renderer re-runs (a plain Refresh() does not
  re-invoke a custom renderer under wxGTK's cell caching); the renderer blends the
  dot toward its cell background by the phase. The timer runs only while a visible
  row's light is actually flashing -- fill_rows calls set_light_pulse(true/false)
  -- so there is no idle repaint loop.

Verified under Xvfb: with the fixture whose locate light flashes and the Light
column shown, the dot's measured intensity oscillates across frames (strong amber
to a pale tint and back); with no flashing light the timer stays stopped.
Self-test still passes. wx-rs patches 0002/0003 regenerated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-20 00:20:37 -06:00
noahandClaude Opus 4.8 282f0b195c GUI round 12 (#13): editable per-firmware default scan credentials
Adds a per-firmware default-login editor so the operator can set the discovery
credentials each firmware is probed with, rather than a single global pair.

- credentials.rs: a per-firmware store (firmware-credentials.txt, 0600, one
  "name<TAB>user<TAB>pass" line per firmware) keyed by the asic-rs firmware
  registry's Display name -- the same key the factory uses for
  with_firmware_discovery_auth. A firmware_default_creds() table seeds the editor
  with each firmware's shipped default (mirrors the asic-rs backends' default_auth
  constants; asic-rs does not expose them at the entry level).
- configured_factory() precedence is now: a per-firmware override wins; else the
  single global scan credential (unchanged back-compat) applies to every backend;
  else the backend's own default_auth. Nothing saved -> plain MinerFactory::new().
- UI: the "Set scan credentials..." dialog gains a "Per-firmware defaults..."
  button opening an editor that lists every firmware in the compiled-in registry
  (read at runtime, not hard-coded) with editable user/pass fields prefilled from
  the saved override or the shipped default. Save persists only rows that differ
  from the shipped default (so defaults evolve with asic-rs and the file stays
  minimal); Reset to defaults clears all overrides.

Verified under Xvfb: the editor lists all 16 registry firmwares with correct
default logins (AntMiner root/root, WhatsMiner admin/admin, VNish blank/admin,
UMC OS blank/letmein, ...). Round-trip/permissions/precedence covered by a unit
test (folded into the existing HOME-scoped credentials test to avoid a parallel
HOME race); self-test still passes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-20 00:06:37 -06:00
noahandClaude Opus 4.8 1857a9e1a0 GUI round 12 (#9, #11): SVG icons in table cells (access padlocks + status)
Adds an SVG-backed icon path to the table's segment renderer: the Rust side
registers a raw SVG per shape sentinel (with its viewBox dims), and the renderer
recolours it to the cell's segment colour, rasterises once per (sentinel, colour,
height) and caches the bitmap. The recolour matches the KPI cards' svg_recolored
(replace currentColor + inject a root fill so fill-less SVGs inherit the colour).

- #9: the Access column padlocks now use the operator-supplied Font Awesome
  lock/unlock SVGs (red closed = view-only, green open = writable) instead of the
  hand-drawn vector padlock. The vector padlock remains as a fallback if the SVG
  is somehow unregistered.
- #11: the Status column renders its KPI icon (green rabbit = hashing, amber
  turtle = slow, red cracked wine glass = not hashing, blue otter = paused)
  instead of the status text, matching the dashboard cards. An unrecognised
  status still falls back to coloured text.

The status dots (hashboards, locate light) stay vector so the round-12 #6 fade
can drive them later. Self-test updated (Status is now a shape cell, verified
structurally like the other icon columns) and still passes. Verified under Xvfb:
the Access column shows the FA padlocks and, with the Status column enabled, the
four status icons render in their KPI colours. wx-rs patches 0002/0003
regenerated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 23:55:37 -06:00
noahandClaude Opus 4.8 b7a77cbed8 GUI round 12 (#7): batch multi-select in the Columns and Filter menus
Both list widgets now support Excel-style batch selection so several rows can be
toggled at once.

- Filter menu value list (wxCheckListBox): was wxLB_SINGLE, so only one value
  could ever be selected. Switched to wxLB_EXTENDED -- ctrl-click, shift-click
  and rubber-band drag now select a range of values. Clicking any selected
  row's checkbox applies that new checked state to every selected row.
- Columns menu list (wxListCtrl): already multi-select for the drag-reorder, but
  a checkbox toggle only affected the clicked row. A toggle on a row that is part
  of a multi-row selection now applies to every selected row, so several columns
  can be shown/hidden together. Re-entrancy guarded (CheckItem re-fires the
  event).

Verified under Xvfb by driving the real dialogs: ctrl-click selects several
columns and one checkbox click toggles them together; shift-click selects a
range of filter values and one checkbox click toggles them together. Headless
self-test still passes. wx-rs patch 0003 regenerated to match the edited bridge.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 23:38:57 -06:00
noahandClaude Opus 4.8 606ae85781 GUI round 12 (#2): keep KPI units visible when the window shrinks
The two wide KPI cards (SHA-256 Hashrate, Est. power) carry a units-bearing
value like "685 TH" / "21.3 kW". When the window was narrowed the row squeezed
these cards below the width their value needs, clipping the trailing unit so it
read as "21.3" with no "kW". Two fixes:

- A nested wxPanel does not re-run its own sizer when its parent resizes it, so
  each card's value/label centring kept whatever slot width it had at the
  previous window size. on_resize now re-lays-out every card on each size event,
  so the value stays centred and gets its full best-size width allocation.
- Raise the wide-card minimum width (150 -> 176) to fit a ~20px icon + a value
  up to "118.0 PH" + the card's side inset, and derive the collapse threshold
  from the real per-card minimums. The wide cards now either show their full
  units or drop out of the row cleanly -- they never render a clipped value.

Verified under Xvfb: at 1050px all seven cards show "685 TH" / "21.3 kW" in
full; at 960px the two wide cards collapse and the five count cards fill the
row. Headless self-test still passes.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 23:29:36 -06:00
noahandClaude Opus 4.8 ad9b0dc868 GUI round 12 (batch 1): black hashrate value, Control Board label, blank placeholder serials, sensible WhatsMiner temps
- #1: the total-hashrate KPI value renders in the default (black) text colour
  instead of accent blue (and now dims with focus like the other neutral cards).
- #4: the board-code column header is now "Control Board".
- #5 (serial): placeholder serials ("N/A", "none", "null", ...) render as an
  empty cell instead of the literal placeholder.
- #3: the Chip-temp cell now prefers each board's board/PCB temperature over the
  hottest-chip (outlet) reading. WhatsMiner's outlet_chip is the max chip temp
  (verified live: ~100C on the hottest board of a M30S+ VE40) which read
  alarmingly high and didn't match the ~60-79C the miner itself reports; the
  board temperature is the figure the miner's UI shows. Falls back to the chip
  temp when no board temp is reported. Applies to all makes for consistency.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 23:02:39 -06:00
noahandClaude Opus 4.8 aaf049bbfc GUI round 11: use the exact potraced beehive for the Hashrate KPI icon
Replaced the hand-traced beehive with an exact potrace of the operator-supplied
beehive.png (parent miner-firmware folder): potrace -s on the flattened bilevel
bitmap, then the black fill rewritten to currentColor so it recolours to the
Hashrate accent. Renders correctly via wxBitmapBundle::FromSVG (nanosvg).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 22:26:02 -06:00
noahandClaude Opus 4.8 8b7b0c70b4 GUI round 11: hand-traced beehive KPI icon (Hashrate)
Replaced the placeholder skep with a beehive matching the operator's reference
(branch + hook on top, stacked pill bands, centre entrance), as an outline SVG
using stroke="currentColor" so it recolours to the Hashrate accent. Hand-traced
because a chat-pasted raster can't be reached as a file for potrace; if the
source raster is saved to disk later, it can be image-traced for an exact match.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 22:14:12 -06:00
noahandClaude Opus 4.8 3ae80efdde GUI round 11: KPI icons match their card text colour + recolour SVGs without a fill
- Each KPI icon now uses its card's value colour (dropped the amber special-case),
  so the otter matches the Paused text colour and the lightning bolt matches the
  Est-power text colour, etc.
- svg_recolored also injects a root fill: some Font Awesome exports (e.g. the Free
  otter) omit fill entirely and default to black, so replacing currentColor alone
  left them black. Now shapes without their own fill inherit the card colour.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 20:53:28 -06:00
noahandClaude Opus 4.8 7901d82c4b GUI round 11 follow-ups: equal-height zebra, backdrop dimming, SVG KPI icons, boards sort
- Zebra stripe heights: the cell rect wx hands a custom renderer is shrunk to the
  content size in BOTH dimensions, so shape cells (dots) and text cells filled
  different-height bands -> unequal stripes across columns. SegmentRenderer now
  fills an over-sized rect (full column width + well beyond the row vertically);
  the cell DC clips it to the real cell, giving uniform full-row stripes. Verified
  in a screenshot.
- Focus dimming: the treeview's own state flags don't carry GTK_STATE_FLAG_BACKDROP
  (that lives on the toplevel), so uncoloured segments (combined-cell slashes,
  target hashrate, "Stock") never dimmed. ThemedTextColour now reads the toplevel
  window's active state (gtk_window_is_active) and forces BACKDROP onto the
  style-context state when inactive, so those segments take the same dimmed themed
  colour the native columns do.
- KPI icons: replaced the hand-drawn vectors with operator-supplied Font Awesome
  Pro SVGs (rabbit=hashing, turtle=slow, cracked wine glass=not hashing,
  otter=paused) plus matching in-repo bolt (power) and hive (hashrate) SVGs. New
  wxbr_svg_icon renders an SVG via wxBitmapBundle::FromSVG; the GUI recolours
  each icon's currentColor to the card's colour and sizes it to the SVG aspect
  ratio. Removed the old wxbr_kpi_icon path.
- Boards column sort: it sorted by total board count (all ~3, so no visible
  order). It now sorts by the number of ONLINE (green) boards, total count as a
  tiebreaker, so units with dead/missing boards surface.

wx-rs bridge/Rust changes mirrored into patches 0002 (widgets.rs) and 0003
(widgets_bridge.cpp) per ADR 0003.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 11:55:39 -06:00
noahandClaude Opus 4.8 8f7aab3f80 GUI round 11 (live-miner items #5/#6b/#8/#11): control-board scan gaps, VNish partner build, CVITek PIC bus
All root-caused and fixed against the live fleet (read-only scans; no device
state changed). asic-rs changes go through the vendored tree + thirdparty/asic-rs
patch queue (0003-0005) with refreshed checksums, per ADR 0003.

#5 (XIL/CVITek + WhatsMiner blank control board):
- VNish reports the board in short form in /api/v1/info "platform": "cv"
  (CVITek), "xil" (Xilinx), "aml" (AMLogic); AntMinerControlBoard::parse matched
  only the full names, so CVITek/Xilinx boards were blank. Added CV/XIL.
- Old M30S firmware (< 2022.7.29 -> v1 backend) omits summary's "CB Platform"
  and v1's parse mandatorily stripped an "ALLWINNER_" prefix. Added get_version
  /Msg/platform as a fallback source and made the strip optional.
- Verified live: S19k Pro cv->CVITek, S19 xil->Xilinx, M30S+ VE40->H6OS.

#6b/#11 (VNish partner / shared-devfee build):
- The partner build shows as /api/v1/info "build_name" ("WildRose",
  "vnishreturn"). The VNish backend (v1_2_0 + v1_3_0) now reads /build_name and
  combines it with the /fw_version number, so firmware_version reads e.g.
  "WildRose 1.2.7". Verified live on S19j Pro / S19k Pro.

#8 (hashboard PIC detection):
- pic_probe tried i2c-1/i2c-0 for CVITek, but a live VNish CVITek S19k Pro
  exposes the hashboard MCU on i2c-3 (i2cdump 0x48 = period-8 -> PIC). Broadened
  bus_candidates (cvi->[3,4,1,0], aml->[1,3,4,0], bb->[0,1,3,4], else->[1,0,3,4]);
  probe_pic stops at the first bus that classifies. The classify logic was
  already correct + unit-tested; only the bus map was wrong.

The GUI picks up #5/#6b automatically through asic-rs (CPU/Board columns now
populate for VNish CVITek/Xilinx and old M30S; FW Version shows the partner
build); #8 is fixed in the GUI's own pic_probe. The miner_probe diagnostic's
local-only mutation modes are left uncommitted as before.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y8h447BPyJR4fioYZvQ9bh
2026-09-19 09:07:57 -06:00
302 changed files with 113065 additions and 2501 deletions
+20
View File
@@ -0,0 +1,20 @@
# cargo-audit configuration (read by `cargo audit` from the project root).
#
# The two entries below are accepted, documented exceptions -- both live only in
# the wx-rs BUILD-dependency tree (reqwest 0.11, used by wx-rs's build.rs to
# download the wxWidgets source on Windows/macOS). On Linux download_dist()
# returns before ever constructing an HTTP client, and none of this is linked
# into the runtime binary, which talks to miners over asic-rs's reqwest 0.13
# (hyper 1.x / h2 0.4). The build tree is fully vendored and offline, so these
# cannot be upgraded without re-vendoring a newer reqwest.
#
# Re-review whenever the vendored dependency set is refreshed.
[advisories]
ignore = [
# h2 0.3 unbounded empty DATA frames (DoS). Build-time only; our build-time
# HTTP client only fetches a fixed HTTPS URL, and only on Windows/macOS.
"RUSTSEC-2026-0258",
# rustls-pemfile 1.0.4 unmaintained. Same build-only reqwest 0.11 subtree.
"RUSTSEC-2025-0134",
]
+36
View File
@@ -0,0 +1,36 @@
name: public-benchmark-pages
on:
schedule:
- cron: '*/15 * * * *'
workflow_dispatch:
concurrency:
group: alkane-toolkit-public-benchmark-pages
cancel-in-progress: false
jobs:
publish:
runs-on: alkane-verify
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
permissions:
contents: read
steps:
- uses: actions/checkout@v4
- name: Install SSH client
run: |
apt-get update -qq
apt-get install -y -qq --no-install-recommends openssh-client
- name: Render measured benchmark history
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
run: python3 ci/bench_history.py render
- name: Publish public benchmark page
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
BENCH_PAGES_DEPLOY_KEY: ${{ secrets.BENCH_PAGES_DEPLOY_KEY }}
run: python3 ci/publish-bench-pages.py toolkit
- name: Clean generated page
if: always()
run: python3 ci/cleanup-generated.py
+21
View File
@@ -0,0 +1,21 @@
name: completed-ci-badge
on:
workflow_run:
workflows: [build-test-release, next-build]
types: [completed]
jobs:
publish:
runs-on: alkane-verify
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
permissions:
actions: read
contents: write
steps:
- uses: actions/checkout@v4
- name: Publish last completed attempt
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
run: python3 ci/last-attempt-badge.py
+168
View File
@@ -0,0 +1,168 @@
name: next-build
on:
push:
branches: [next]
concurrency:
group: alkane-toolkit-next
cancel-in-progress: false
permissions:
contents: write
jobs:
# Windows build of the candidate (see release.yml's windows job); the
# candidate job attaches its zip next to the Linux tarball.
windows:
runs-on: alkane-ci
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
env:
CARGO_TARGET_DIR: target
CARGO_BUILD_JOBS: 2
WX_WINDOWS_PREFIX: /root/.cache/wx-3.3.3-mingw
ALKANE_EMBEDDED_TOKEN: ${{ secrets.ALKANE_EMBEDDED_TOKEN }}
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Select candidate version
id: version
run: bash ci/compute-rc-version.sh >> "$GITHUB_OUTPUT"
- name: Install Windows toolchain
if: steps.version.outputs.release == 'true'
run: bash ci/windows-ci.sh toolchain
- name: Configure bounded Rust compiler cache
if: steps.version.outputs.release == 'true'
run: bash ci/configure-rust-cache.sh
- name: Compute wxMSW cache key
if: steps.version.outputs.release == 'true'
id: wx-key
run: bash ci/wx-cache-key.sh windows
- name: Check prebuilt wxMSW
if: steps.version.outputs.release == 'true'
id: wx-image
run: bash ci/check-wx-image-prefix.sh windows
- id: wx-cache
if: steps.version.outputs.release == 'true' && steps.wx-image.outputs.available != 'true'
uses: actions/cache/restore@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-mingw
key: ${{ steps.wx-key.outputs.key }}
- name: Build wxMSW
if: steps.version.outputs.release == 'true'
id: wx-build
run: bash ci/ensure-wx-prefix.sh windows
- name: Save vendored wxMSW build
if: steps.version.outputs.release == 'true' && steps.wx-cache.outputs.cache-hit != 'true' && steps.wx-build.outputs.built == 'true'
uses: actions/cache/save@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-mingw
key: ${{ steps.wx-key.outputs.key }}
- name: Build Windows candidate
if: steps.version.outputs.release == 'true'
run: bash ci/windows-ci.sh build
- name: Sign Windows candidate (Azure Artifact Signing)
if: steps.version.outputs.release == 'true'
env:
AZURE_SIGNING_PROFILE: ${{ vars.AZURE_SIGNING_PROFILE }}
AZURE_SIGNING_TENANT_ID: ${{ secrets.AZURE_SIGNING_TENANT_ID }}
AZURE_SIGNING_CLIENT_ID: ${{ secrets.AZURE_SIGNING_CLIENT_ID }}
AZURE_SIGNING_CLIENT_SECRET: ${{ secrets.AZURE_SIGNING_CLIENT_SECRET }}
run: bash ci/windows-ci.sh sign
- name: Package Windows candidate
if: steps.version.outputs.release == 'true'
run: bash ci/windows-ci.sh package "${{ steps.version.outputs.version }}"
- uses: https://github.com/ChristopherHX/gitea-upload-artifact@81f940d004763f986ba3582c007fd842dd5cb0d7
if: steps.version.outputs.release == 'true'
with:
name: alkane-toolkit-windows
path: dist/alkane-toolkit-v*-windows-x86_64.zip
- name: Clean generated Toolkit build
if: always()
run: python3 ci/cleanup-generated.py
candidate:
needs: windows
runs-on: alkane-ci
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
env:
CARGO_TARGET_DIR: target
CARGO_BUILD_JOBS: 2
WX_PREFIX: /root/.cache/wx-3.3.3-linux
WX_RS_WXCONFIG: /root/.cache/wx-3.3.3-linux/bin/wx-config
ALKANE_EMBEDDED_TOKEN: ${{ secrets.ALKANE_EMBEDDED_TOKEN }}
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Check runner image pins
run: python3 ci/check-runner-image.py
- name: Install build dependencies
run: bash ci/ensure-build-deps.sh base
- name: Configure bounded Rust compiler cache
run: bash ci/configure-rust-cache.sh
- name: Compute wxWidgets cache key
id: wx-key
run: bash ci/wx-cache-key.sh
- name: Check prebuilt wxWidgets
id: wx-image
run: bash ci/check-wx-image-prefix.sh
- id: wx-cache
if: steps.wx-image.outputs.available != 'true'
uses: actions/cache/restore@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-linux
key: ${{ steps.wx-key.outputs.key }}
- name: Build wxWidgets
id: wx-build
run: bash ci/ensure-wx-prefix.sh
- name: Save vendored wxWidgets build
if: steps.wx-cache.outputs.cache-hit != 'true' && steps.wx-build.outputs.built == 'true'
uses: actions/cache/save@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-linux
key: ${{ steps.wx-key.outputs.key }}
- name: Build release candidate
run: cargo build --release -p alkane-gui -p alkane-artifacts -p alkane-flash -p alkane-cli --offline
- name: Select candidate version
id: version
run: bash ci/compute-rc-version.sh >> "$GITHUB_OUTPUT"
- name: Package candidate
if: steps.version.outputs.release == 'true'
run: |
mkdir -p dist
cp target/release/alkane-toolkit dist/
tar -C dist -czf "dist/alkane-toolkit-${{ steps.version.outputs.version }}-linux-x86_64.tar.gz" alkane-toolkit
- name: Fetch Windows candidate
if: steps.version.outputs.release == 'true'
uses: https://github.com/ChristopherHX/gitea-download-artifact@75635f32b4c1c41c4b3d64e8f85210112ed4c9c7
with:
name: alkane-toolkit-windows
path: dist/windows
- name: Create private prerelease
if: steps.version.outputs.release == 'true'
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
run: |
set -euo pipefail
V="${{ steps.version.outputs.version }}"
WIN="dist/windows/alkane-toolkit-v${V}-windows-x86_64.zip"
[ -s "$WIN" ] || { echo "Windows candidate for ${V} is missing" >&2; exit 1; }
python3 ci/release-rc.py "${{ steps.version.outputs.tag }}" true \
"dist/alkane-toolkit-${V}-linux-x86_64.tar.gz" "$WIN"
- name: Rust compiler cache statistics
if: always()
run: |
if [ -n "${SCCACHE_DIR:-}" ]; then
sccache --show-stats
fi
- name: Clean generated Toolkit build
if: always()
run: python3 ci/cleanup-generated.py
+47
View File
@@ -0,0 +1,47 @@
name: pages
# The project site, https://blueflare.gitea.bluefla.re/alkane-toolkit/ :
# overview, user manual (docs/manual), code-quality dashboard (from the
# quality record main CI publishes with the badges) and benchmark history.
# Rebuilt after every main build-test-release run and published to this
# repository's gh-pages branch.
on:
workflow_run:
workflows: [build-test-release]
types: [completed]
workflow_dispatch:
concurrency:
group: alkane-toolkit-pages
cancel-in-progress: false
jobs:
publish:
runs-on: alkane-verify
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
permissions:
contents: write
steps:
- uses: actions/checkout@v4
- name: Install page tools
run: bash ci/ensure-build-deps.sh pages
- name: Render measured benchmark history
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
run: python3 ci/bench_history.py render
- name: Fetch measured quality record
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
run: python3 ci/fetch-quality.py quality.json
- name: Build site
run: |
python3 ci/build-pages.py --out site --quality quality.json \
--bench bench-site/index.html --sha "$GITHUB_SHA"
- name: Publish site
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
run: python3 ci/publish-pages.py site
- name: Clean generated site
if: always()
run: python3 ci/cleanup-generated.py
+298 -45
View File
@@ -1,16 +1,36 @@
name: build-test-release
# Runs on every merge/push to main: build the GUI, run tests + a microbenchmark,
# and (when the change warrants it) cut an X.Y.Z release with the binary attached.
# Runs on every merge/push to main: build the GUI for Linux and Windows, run the
# tests + a microbenchmark, and (when the change warrants it) cut an X.Y.Z
# release with both binaries attached.
on:
push:
branches: [main]
concurrency:
group: alkane-toolkit-main
cancel-in-progress: false
permissions:
contents: write
actions: write
jobs:
release:
# Windows build of the same commit: cross-compiled with mingw-w64 against the
# vendored wxMSW, unit-tested and UI-self-tested under Wine, packaged as a
# zip. The release job below waits for it and attaches the zip next to the
# Linux tarball, so a release never ships one platform without the other.
windows:
runs-on: alkane-ci
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
env:
WX_PREFIX: /root/.cache/wx-3.3.3-linux
CARGO_TARGET_DIR: target
CARGO_BUILD_JOBS: 2
WX_WINDOWS_PREFIX: /root/.cache/wx-3.3.3-mingw
# Read-only token baked into the GUI so the release picker can list the
# private alkane-os releases with no user setup (option_env!).
ALKANE_EMBEDDED_TOKEN: ${{ secrets.ALKANE_EMBEDDED_TOKEN }}
steps:
- name: Checkout (full history for tags)
uses: actions/checkout@v4
@@ -21,33 +41,181 @@ jobs:
id: ver
run: bash ci/compute-version.sh | tee -a "$GITHUB_OUTPUT"
- name: Test version logic
- name: Install Windows toolchain
run: bash ci/windows-ci.sh toolchain
- name: Configure bounded Rust compiler cache
run: bash ci/configure-rust-cache.sh
- name: Compute wxMSW cache key
id: wx-key
run: bash ci/wx-cache-key.sh windows
- name: Check prebuilt wxMSW
id: wx-image
run: bash ci/check-wx-image-prefix.sh windows
- name: Cache vendored wxMSW build
if: steps.wx-image.outputs.available != 'true'
id: wx-cache
uses: actions/cache/restore@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-mingw
key: ${{ steps.wx-key.outputs.key }}
- name: Build wxMSW (once, then cached)
id: wx-build
run: bash ci/ensure-wx-prefix.sh windows
- name: Save vendored wxMSW build
if: steps.wx-cache.outputs.cache-hit != 'true' && steps.wx-build.outputs.built == 'true'
uses: actions/cache/save@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-mingw
key: ${{ steps.wx-key.outputs.key }}
- name: Clippy (Windows target, warnings are errors)
run: bash ci/windows-ci.sh clippy
- name: Set crate version to ${{ steps.ver.outputs.version }}
if: steps.ver.outputs.release == 'true'
run: |
sed -i "0,/^version = \".*\"/s//version = \"${{ steps.ver.outputs.version }}\"/" Cargo.toml
grep -m1 '^version' Cargo.toml
- name: Build release (Windows)
run: bash ci/windows-ci.sh build
- name: Unit tests (Windows build, under Wine)
run: bash ci/windows-ci.sh test
- name: Headless UI self-test (Windows build, under Wine)
run: bash ci/windows-ci.sh selftest
- name: Sign Windows executable (Azure Artifact Signing)
env:
AZURE_SIGNING_PROFILE: ${{ vars.AZURE_SIGNING_PROFILE }}
AZURE_SIGNING_TENANT_ID: ${{ secrets.AZURE_SIGNING_TENANT_ID }}
AZURE_SIGNING_CLIENT_ID: ${{ secrets.AZURE_SIGNING_CLIENT_ID }}
AZURE_SIGNING_CLIENT_SECRET: ${{ secrets.AZURE_SIGNING_CLIENT_SECRET }}
run: bash ci/windows-ci.sh sign
- name: Package Windows artifact
if: steps.ver.outputs.release == 'true'
run: bash ci/windows-ci.sh package "${{ steps.ver.outputs.version }}"
- name: Bundle Windows test executables
run: bash ci/windows-ci.sh test-bundle
- uses: https://github.com/ChristopherHX/gitea-upload-artifact@81f940d004763f986ba3582c007fd842dd5cb0d7
if: steps.ver.outputs.release == 'true'
with:
name: alkane-toolkit-windows
path: dist/alkane-toolkit-v*-windows-x86_64.zip
# Consumed by .gitea/workflows/windows-native.yml on the Windows VM runner.
- uses: https://github.com/ChristopherHX/gitea-upload-artifact@81f940d004763f986ba3582c007fd842dd5cb0d7
with:
name: alkane-toolkit-windows-tests
path: |
dist/alkane-toolkit-windows-tests.zip
target/x86_64-pc-windows-gnu/release/alkane-toolkit.exe
- name: Clean generated Toolkit build
if: always()
run: python3 ci/cleanup-generated.py
release:
needs: windows
runs-on: alkane-ci
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
env:
CARGO_TARGET_DIR: target
CARGO_BUILD_JOBS: 2
WX_PREFIX: /root/.cache/wx-3.3.3-linux
# Set once for the whole job so build/clippy/test/bench steps don't each
# re-export it (round 18 #12).
WX_RS_WXCONFIG: /root/.cache/wx-3.3.3-linux/bin/wx-config
# Read-only token baked into the GUI so the release picker can list the
# private alkane-os releases with no user setup (option_env!).
ALKANE_EMBEDDED_TOKEN: ${{ secrets.ALKANE_EMBEDDED_TOKEN }}
steps:
- name: Checkout (full history for tags)
uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Check runner image pins
run: python3 ci/check-runner-image.py
- name: Check wx-rs patch queue reproduces the patched tree
run: python3 scripts/wx_rs_patches.py check
- name: Check first-party Rust formatting
run: |
rustup component add rustfmt >/dev/null
cargo fmt -p alkane-gui -p alkane-artifacts -p alkane-flash -p alkane-cli -p alkane-access -p alkane-core -- --check
- name: Compute version
id: ver
run: bash ci/compute-version.sh | tee -a "$GITHUB_OUTPUT"
- name: Test version logic
run: bash ci/test-compute-version.sh
- name: Last-attempt badge checks
run: python3 ci/test-last-attempt-badge.py
- name: Benchmark history checks
run: python3 ci/test-bench-history.py
- name: Benchmark suite checks
run: python3 ci/test-bench-badge.py
- name: Install build dependencies
if: steps.ver.outputs.release == 'true'
run: |
apt-get update -qq
apt-get install -y -qq --no-install-recommends \
libssl-dev pkg-config ca-certificates >/dev/null
echo "libssl-dev + pkg-config installed (openssl-sys needs them)"
run: bash ci/ensure-build-deps.sh all
- name: Configure bounded Rust compiler cache
run: bash ci/configure-rust-cache.sh
- name: Compute wxWidgets cache key
id: wx-key
run: bash ci/wx-cache-key.sh
- name: Check prebuilt wxWidgets
id: wx-image
run: bash ci/check-wx-image-prefix.sh
- name: Cache vendored wxWidgets build
if: steps.ver.outputs.release == 'true'
uses: actions/cache@v4
if: steps.wx-image.outputs.available != 'true'
id: wx-cache
uses: actions/cache/restore@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-linux
key: wx-3.3.3-${{ runner.os }}-${{ hashFiles('thirdparty/wx-rs/VERSION') }}
key: ${{ steps.wx-key.outputs.key }}
- name: Build wxWidgets (once, then cached)
if: steps.ver.outputs.release == 'true'
id: wx-build
run: bash ci/ensure-wx-prefix.sh
- name: Save vendored wxWidgets build
if: steps.wx-cache.outputs.cache-hit != 'true' && steps.wx-build.outputs.built == 'true'
uses: actions/cache/save@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-linux
key: ${{ steps.wx-key.outputs.key }}
- name: Clippy (our crate, warnings are errors)
run: |
if [ ! -x "$WX_PREFIX/bin/wx-config" ]; then
bash scripts/build-wx-linux.sh
else
echo "wx prefix restored from cache"
fi
rustup component add clippy >/dev/null 2>&1 || true
cargo clippy -p alkane-gui --no-deps --release --bins --offline -- -D warnings
cargo clippy --workspace --exclude alkane-gui --exclude wx-rs --all-targets --offline -- -D warnings
- name: Set crate version to ${{ steps.ver.outputs.version }}
if: steps.ver.outputs.release == 'true'
@@ -56,31 +224,107 @@ jobs:
grep -m1 '^version' Cargo.toml
- name: Build release
if: steps.ver.outputs.release == 'true'
run: |
export WX_RS_WXCONFIG="$WX_PREFIX/bin/wx-config"
cargo build --release -p alkane-gui --offline
- name: Unit tests
if: steps.ver.outputs.release == 'true'
run: |
export WX_RS_WXCONFIG="$WX_PREFIX/bin/wx-config"
cargo test -p alkane-gui --offline
set -o pipefail
cargo test -p alkane-gui --offline 2>&1 | tee tests-gui.txt
cargo test --workspace --exclude alkane-gui --exclude wx-rs --offline 2>&1 | tee tests-core.txt
cat tests-gui.txt tests-core.txt > tests-current.txt
- name: Load previous main benchmark measurement
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
run: python3 ci/bench_history.py prepare
- name: Microbenchmarks
if: steps.ver.outputs.release == 'true'
run: |
export WX_RS_WXCONFIG="$WX_PREFIX/bin/wx-config"
cargo test -p alkane-gui --release --offline -- --ignored --nocapture bench_
# Require every declared benchmark before publishing history or a release.
set -o pipefail
cargo test -p alkane-gui -p alkane-artifacts --release --offline -- --ignored --nocapture bench_ --test-threads=1 \
| tee bench-current.txt
python3 ci/bench-badge.py --current bench-current.txt \
--baseline badges/bench-baseline.json --no-write
- name: Headless UI self-test
if: steps.ver.outputs.release == 'true'
run: |
apt-get update -qq && apt-get install -y -qq --no-install-recommends \
xvfb xauth dbus-x11 fonts-dejavu-core >/dev/null
BIN=target/release/alkane-toolkit
xvfb-run -a env GDK_BACKEND=x11 ALKANE_SELFTEST=1 "$BIN"
- name: Dependency audit (best-effort)
continue-on-error: true
run: |
if command -v cargo-audit >/dev/null 2>&1; then
cargo audit || echo "cargo audit reported findings (accepted ones in .cargo/audit.toml)"
else
echo "cargo-audit not installed on this runner; skipping"
fi
- name: Rust compiler cache statistics
if: always()
run: |
if [ -n "${SCCACHE_DIR:-}" ]; then
sccache --show-stats
fi
# Merge coverage from unit tests and the headless UI self-test. A failed
# measurement must not publish a stale badge or create a release.
- name: Coverage
id: cov
run: |
set -euo pipefail
rustup component add llvm-tools-preview >/dev/null 2>&1 || true
[ "$(cargo llvm-cov --version)" = 'cargo-llvm-cov 0.8.7' ]
# Keep the whole table: gen-badges turns it into the per-crate and
# per-file breakdown on the Pages quality dashboard.
bash ci/coverage.sh --summary-only | tee coverage-summary.txt
PCT=$(awk '/^TOTAL/{gsub(/%/,"",$10); print $10}' coverage-summary.txt)
[ -n "$PCT" ] || { echo "coverage report produced no TOTAL line" >&2; exit 1; }
echo "pct=${PCT}" >> "$GITHUB_OUTPUT"
echo "line coverage (tests + self-test): ${PCT}%"
- name: Microbenchmark coverage
id: benchcov
run: |
set -euo pipefail
command -v cargo-llvm-cov >/dev/null
PCT=$(bash ci/bench-coverage.sh --summary-only \
| awk '/^TOTAL/{gsub(/%/,"",$10); print $10}')
[ -n "$PCT" ] || { echo "microbenchmark coverage unavailable" >&2; exit 1; }
echo "pct=${PCT}" >> "$GITHUB_OUTPUT"
echo "microbenchmark line coverage: ${PCT}%"
- name: Generate measured badges
run: |
set -euo pipefail
PASS=$(grep -E '^test result: ' tests-current.txt \
| grep -oE '[0-9]+ passed' | grep -oE '[0-9]+' \
| awk '{s+=$1} END{print s+0}')
[ "$PASS" -gt 0 ] || { echo "no passing tests counted" >&2; exit 1; }
BENCH_DELTA=$(python3 ci/bench-badge.py --current bench-current.txt \
--baseline badges/bench-baseline.json --no-write)
python3 ci/gen-badges.py --tests "$PASS" \
--coverage "${{ steps.cov.outputs.pct }}" \
--bench-coverage "${{ steps.benchcov.outputs.pct }}" \
--bench-delta "$BENCH_DELTA" --clippy clean \
--coverage-summary coverage-summary.txt
- name: Publish measured badges
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
run: python3 ci/publish-metrics.py
- name: Record private benchmark history
env:
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
run: python3 ci/bench_history.py publish
- uses: https://github.com/ChristopherHX/gitea-upload-artifact@81f940d004763f986ba3582c007fd842dd5cb0d7
with:
name: alkane-toolkit-benchmark-site-preview
path: bench-site/index.html
- name: Package artifact
if: steps.ver.outputs.release == 'true'
id: pkg
@@ -102,25 +346,34 @@ jobs:
echo "asset=dist/${NAME}.tar.gz" >> "$GITHUB_OUTPUT"
echo "assetname=${NAME}.tar.gz" >> "$GITHUB_OUTPUT"
- name: Fetch Windows artifact
if: steps.ver.outputs.release == 'true'
uses: https://github.com/ChristopherHX/gitea-download-artifact@75635f32b4c1c41c4b3d64e8f85210112ed4c9c7
with:
name: alkane-toolkit-windows
path: dist/windows
- name: Locate Windows artifact
if: steps.ver.outputs.release == 'true'
id: winpkg
run: |
set -euo pipefail
V="${{ steps.ver.outputs.version }}"
ZIP="dist/windows/alkane-toolkit-v${V}-windows-x86_64.zip"
[ -s "$ZIP" ] || { echo "Windows artifact for v${V} is missing" >&2; ls -lR dist/windows >&2; exit 1; }
echo "asset=$ZIP" >> "$GITHUB_OUTPUT"
- name: Create Gitea release + upload artifact
if: steps.ver.outputs.release == 'true'
env:
TOKEN: ${{ secrets.GITHUB_TOKEN }}
GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
run: |
TAG="${{ steps.ver.outputs.tag }}"
API="${GITHUB_API_URL:-https://gitea.bluefla.re/api/v1}"
REPO="${GITHUB_REPOSITORY}"
body="Automated ${{ steps.ver.outputs.bump }} release from ${GITHUB_SHA}."
rel=$(curl -sS -X POST -H "Authorization: token ${TOKEN}" -H "Content-Type: application/json" \
"${API}/repos/${REPO}/releases" \
-d "{\"tag_name\":\"${TAG}\",\"target_commitish\":\"${GITHUB_SHA}\",\"name\":\"${TAG}\",\"body\":\"${body}\"}")
id=$(echo "$rel" | grep -oE '"id":[0-9]+' | head -1 | cut -d: -f2)
if [ -z "$id" ]; then echo "release create failed: $rel"; exit 1; fi
curl -sS -X POST -H "Authorization: token ${TOKEN}" -H "Content-Type: application/gzip" \
"${API}/repos/${REPO}/releases/${id}/assets?name=${{ steps.pkg.outputs.assetname }}" \
--data-binary @"${{ steps.pkg.outputs.asset }}" | grep -oE '"browser_download_url":"[^"]+"' || true
echo "Released ${TAG}"
python3 ci/release-rc.py "${{ steps.ver.outputs.tag }}" false \
"${{ steps.pkg.outputs.asset }}" "${{ steps.winpkg.outputs.asset }}"
- name: No release needed
if: steps.ver.outputs.release != 'true'
run: echo "No backend/UI change since ${{ steps.ver.outputs.last_tag }} - skipping release."
- name: Clean generated Toolkit build
if: always()
run: python3 ci/cleanup-generated.py
+27
View File
@@ -0,0 +1,27 @@
name: source
on:
pull_request:
branches: [next]
workflow_dispatch:
concurrency:
group: alkane-toolkit-source-${{ github.ref }}
cancel-in-progress: true
jobs:
check:
runs-on: alkane-fast
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
env:
CARGO_BUILD_JOBS: 2
steps:
- uses: actions/checkout@v4
- name: Check runner image pins
run: python3 ci/check-runner-image.py
- name: Source checks
run: cargo test --workspace --exclude alkane-gui --exclude wx-rs --offline
- name: Clean generated Toolkit build
if: always()
run: python3 ci/cleanup-generated.py
+267
View File
@@ -0,0 +1,267 @@
name: verify
# Full quality gate for pull requests to main.
on:
pull_request:
branches: [main]
concurrency:
group: alkane-toolkit-verify-${{ github.ref }}
cancel-in-progress: true
jobs:
verify:
runs-on: alkane-verify
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
outputs:
surface: ${{ steps.surface.outputs.surface }}
env:
CARGO_TARGET_DIR: target
CARGO_BUILD_JOBS: 2
WX_PREFIX: /root/.cache/wx-3.3.3-linux
WX_RS_WXCONFIG: /root/.cache/wx-3.3.3-linux/bin/wx-config
steps:
- name: Checkout
uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Check runner image pins
run: python3 ci/check-runner-image.py
- name: Check wx-rs patch queue reproduces the patched tree
run: python3 scripts/wx_rs_patches.py check
- name: Detect changed surface
id: surface
run: python3 ci/pr-surface.py >> "$GITHUB_OUTPUT"
- name: Check documentation change
if: steps.surface.outputs.surface == 'documentation'
run: |
base="$(git merge-base HEAD "origin/$GITHUB_BASE_REF")"
git diff --check "$base" HEAD
# Vendored upstream trees carry their own test-fixture keys (openssl,
# rustls-pemfile, aws-lc); only first-party sources are checked.
if git grep -nIE '^[[:space:]]*-----BEGIN (RSA |EC |OPENSSH )?PRIVATE KEY-----[[:space:]]*$' -- ':!vendor' ':!thirdparty'; then
echo "private key material found in tracked source" >&2
exit 1
else
status=$?
[ "$status" -eq 1 ]
fi
- name: Check CI change surface
if: steps.surface.outputs.surface != 'documentation'
run: python3 ci/test-pr-surface.py
- name: Check first-party Rust formatting
if: steps.surface.outputs.surface == 'headless' || steps.surface.outputs.surface == 'full'
run: |
rustup component add rustfmt >/dev/null
cargo fmt -p alkane-gui -p alkane-artifacts -p alkane-flash -p alkane-cli -p alkane-access -p alkane-core -- --check
- name: Check workflow-only change
if: steps.surface.outputs.surface == 'workflow'
run: |
python3 - <<'PY'
from pathlib import Path
import yaml
for path in Path('.gitea/workflows').glob('*.yml'):
yaml.load(path.read_text(), Loader=yaml.BaseLoader)
PY
python3 ci/check-runner-image.py
for script in ci/*.sh; do bash -n "$script"; done
base="$(git merge-base HEAD "origin/$GITHUB_BASE_REF")"
git diff --check "$base" HEAD
# Vendored upstream trees carry their own test-fixture keys (openssl,
# rustls-pemfile, aws-lc); only first-party sources are checked.
if git grep -nIE '^[[:space:]]*-----BEGIN (RSA |EC |OPENSSH )?PRIVATE KEY-----[[:space:]]*$' -- ':!vendor' ':!thirdparty'; then
echo "private key material found in tracked source" >&2
exit 1
else
status=$?
[ "$status" -eq 1 ]
fi
- name: Install build dependencies
if: steps.surface.outputs.surface == 'headless' || steps.surface.outputs.surface == 'full'
run: bash ci/ensure-build-deps.sh base
- name: Configure bounded Rust compiler cache
if: steps.surface.outputs.surface == 'headless' || steps.surface.outputs.surface == 'full'
run: bash ci/configure-rust-cache.sh
- name: Compute wxWidgets cache key
id: wx-key
if: steps.surface.outputs.surface == 'full'
run: bash ci/wx-cache-key.sh
- name: Check prebuilt wxWidgets
id: wx-image
if: steps.surface.outputs.surface == 'full'
run: bash ci/check-wx-image-prefix.sh
- name: Cache vendored wxWidgets build
if: steps.surface.outputs.surface == 'full' && steps.wx-image.outputs.available != 'true'
id: wx-cache
uses: actions/cache/restore@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-linux
key: ${{ steps.wx-key.outputs.key }}
- name: Build wxWidgets (once, then cached)
if: steps.surface.outputs.surface == 'full'
id: wx-build
run: bash ci/ensure-wx-prefix.sh
- name: Save vendored wxWidgets build
if: steps.surface.outputs.surface == 'full' && steps.wx-cache.outputs.cache-hit != 'true' && steps.wx-build.outputs.built == 'true'
uses: actions/cache/save@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-linux
key: ${{ steps.wx-key.outputs.key }}
- name: Clippy (our crate, warnings are errors)
if: steps.surface.outputs.surface == 'full'
run: |
rustup component add clippy >/dev/null 2>&1 || true
cargo clippy -p alkane-gui --no-deps --release --bins --offline -- -D warnings
cargo clippy --workspace --exclude alkane-gui --exclude wx-rs --all-targets --offline -- -D warnings
- name: Headless crate checks
if: steps.surface.outputs.surface == 'headless'
env:
PACKAGES: ${{ steps.surface.outputs.packages }}
run: |
rustup component add clippy >/dev/null 2>&1 || true
args=()
for package in $PACKAGES; do
case "$package" in
alkane-access|alkane-artifacts|alkane-cli|alkane-flash) args+=(-p "$package") ;;
*) echo "unrecognized crate: $package" >&2; exit 1 ;;
esac
done
[ "${#args[@]}" -gt 0 ]
cargo clippy "${args[@]}" --all-targets --offline -- -D warnings
cargo test "${args[@]}" --offline
- name: Build
if: steps.surface.outputs.surface == 'full'
run: cargo build --release -p alkane-gui --offline
- name: Unit tests
if: steps.surface.outputs.surface == 'full'
run: |
cargo test -p alkane-gui --offline
cargo test --workspace --exclude alkane-gui --exclude wx-rs --offline
python3 tools/report-relay/test_relay.py
- name: Microbenchmarks
if: steps.surface.outputs.surface == 'full'
run: cargo test -p alkane-gui -p alkane-artifacts --release --offline -- --ignored --nocapture bench_ --test-threads=1
- name: Headless UI self-test
if: steps.surface.outputs.surface == 'full'
run: |
bash ci/ensure-build-deps.sh ui
BIN=target/release/alkane-toolkit
xvfb-run -a env GDK_BACKEND=x11 ALKANE_SELFTEST=1 "$BIN"
# Advisory audit is best-effort: it needs the RustSec DB over the network,
# which the vendored/offline build otherwise never touches, so a locked-down
# runner must not fail the gate on it. Accepted advisories live in
# .cargo/audit.toml.
- name: Dependency audit (best-effort)
if: steps.surface.outputs.surface == 'headless' || steps.surface.outputs.surface == 'full'
continue-on-error: true
run: |
if command -v cargo-audit >/dev/null 2>&1; then
cargo audit || echo "cargo audit reported findings (see .cargo/audit.toml for accepted ones)"
else
echo "cargo-audit not installed on this runner; skipping"
fi
- name: Rust compiler cache statistics
if: always() && (steps.surface.outputs.surface == 'headless' || steps.surface.outputs.surface == 'full')
run: |
if [ -n "${SCCACHE_DIR:-}" ]; then
sccache --show-stats
fi
- name: Clean generated Toolkit build
if: always()
run: python3 ci/cleanup-generated.py
# The Windows build of the same change (main's release gate, run on the PR):
# clippy for the Windows target, the release .exe, every unit test under
# Wine, and the headless UI self-test under Wine. Only for changes that can
# affect the binary (the "full" surface).
verify-windows:
needs: verify
if: needs.verify.outputs.surface == 'full'
runs-on: alkane-verify
container:
image: gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
env:
CARGO_TARGET_DIR: target
CARGO_BUILD_JOBS: 2
WX_WINDOWS_PREFIX: /root/.cache/wx-3.3.3-mingw
steps:
- name: Checkout
uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Install Windows toolchain
run: bash ci/windows-ci.sh toolchain
- name: Configure bounded Rust compiler cache
run: bash ci/configure-rust-cache.sh
- name: Compute wxMSW cache key
id: wx-key
run: bash ci/wx-cache-key.sh windows
- name: Check prebuilt wxMSW
id: wx-image
run: bash ci/check-wx-image-prefix.sh windows
- name: Cache vendored wxMSW build
if: steps.wx-image.outputs.available != 'true'
id: wx-cache
uses: actions/cache/restore@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-mingw
key: ${{ steps.wx-key.outputs.key }}
- name: Build wxMSW (once, then cached)
id: wx-build
run: bash ci/ensure-wx-prefix.sh windows
- name: Save vendored wxMSW build
if: steps.wx-cache.outputs.cache-hit != 'true' && steps.wx-build.outputs.built == 'true'
uses: actions/cache/save@v4
continue-on-error: true
with:
path: /root/.cache/wx-3.3.3-mingw
key: ${{ steps.wx-key.outputs.key }}
- name: Clippy (Windows target, warnings are errors)
run: bash ci/windows-ci.sh clippy
- name: Build (Windows)
run: bash ci/windows-ci.sh build
- name: Unit tests (Windows build, under Wine)
run: bash ci/windows-ci.sh test
- name: Headless UI self-test (Windows build, under Wine)
run: bash ci/windows-ci.sh selftest
- name: Clean generated Toolkit build
if: always()
run: python3 ci/cleanup-generated.py
+101
View File
@@ -0,0 +1,101 @@
name: windows-native
# Smoke test on real Windows. The self-hosted runner in the Windows 11 test VM
# (label alkane-windows, host mode; see docs/windows.md) takes the Windows
# build that main's build-test-release run cross-compiled -- the release .exe
# and every unit-test executable, which already passed under Wine there -- and
# runs them natively: real Win32, real comctl32/visual styles, real DPI and
# real Windows networking.
#
# Advisory by design: a separate workflow, so it never gates or delays a
# release, and while the VM is off the job simply waits for the runner.
on:
workflow_run:
workflows: [build-test-release]
types: [completed]
workflow_dispatch:
inputs:
run_id:
description: build-test-release run whose Windows build to test
required: true
permissions:
actions: read
contents: read
jobs:
native:
if: github.event_name == 'workflow_dispatch' || github.event.workflow_run.conclusion == 'success'
runs-on: alkane-windows
timeout-minutes: 30
env:
RUN_ID: ${{ github.event.workflow_run.id || inputs.run_id }}
# Windows' default execution policy (Restricted) refuses the script files
# the runner writes for each step; bypass it for these steps only, so the
# runner works without changing the machine's policy.
defaults:
run:
shell: powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -File {0}
steps:
- name: Fetch the cross-built Windows build
env:
TOKEN: ${{ github.token }}
API: ${{ github.api_url }}/repos/${{ github.repository }}
run: |
$ErrorActionPreference = 'Stop'
$ProgressPreference = 'SilentlyContinue'
$work = Join-Path ([IO.Path]::GetTempPath()) "alkane-native-$env:RUN_ID"
Remove-Item -Recurse -Force $work -ErrorAction SilentlyContinue
New-Item -ItemType Directory $work | Out-Null
$auth = @{ Authorization = "token $env:TOKEN" }
$list = Invoke-RestMethod -Headers $auth "$env:API/actions/runs/$env:RUN_ID/artifacts"
$art = $list.artifacts | Where-Object { $_.name -eq 'alkane-toolkit-windows-tests' } |
Select-Object -First 1
if (-not $art) { throw "run $env:RUN_ID has no alkane-toolkit-windows-tests artifact" }
Invoke-WebRequest -Headers $auth -Uri $art.archive_download_url -OutFile "$work\artifact.zip"
Expand-Archive "$work\artifact.zip" "$work\artifact"
$bundle = Get-ChildItem -Recurse "$work\artifact" -Filter alkane-toolkit-windows-tests.zip |
Select-Object -First 1
Expand-Archive $bundle.FullName "$work\tests"
$exe = Get-ChildItem -Recurse "$work\artifact" -Filter alkane-toolkit.exe | Select-Object -First 1
Copy-Item $exe.FullName "$work\alkane-toolkit.exe"
"ALKANE_NATIVE=$work" | Out-File -Append -Encoding utf8 $env:GITHUB_ENV
$os = Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion'
"Testing run $env:RUN_ID on Windows $($os.DisplayVersion) build $($os.CurrentBuild)"
- name: Authenticode signature (native Windows)
env:
SIGNING_ENABLED: ${{ vars.AZURE_SIGNING_PROFILE }}
run: |
# Windows itself judges the signature: chain to a trusted root,
# intact file hash, valid timestamp. Required once signing is on.
$sig = Get-AuthenticodeSignature "$env:ALKANE_NATIVE\alkane-toolkit.exe"
Write-Host "Signature: $($sig.Status) $($sig.StatusMessage)"
if ($sig.SignerCertificate) { Write-Host "Signer: $($sig.SignerCertificate.Subject)" }
if ($sig.TimeStamperCertificate) { Write-Host "Timestamp: $($sig.TimeStamperCertificate.Subject)" }
if ($env:SIGNING_ENABLED -and $sig.Status -ne 'Valid') { exit 1 }
- name: Unit tests (native Windows)
run: |
$failed = @()
foreach ($test in Get-Content "$env:ALKANE_NATIVE\tests\tests.txt") {
Write-Host "== $test"
& "$env:ALKANE_NATIVE\tests\$test"
if ($LASTEXITCODE -ne 0) { $failed += $test }
}
if ($failed) { Write-Host "FAILED: $($failed -join ', ')"; exit 1 }
- name: Headless UI self-test (native Windows)
run: |
# A GUI-subsystem executable: wait for it and read its redirected output.
$env:ALKANE_SELFTEST = '1'
$out = "$env:ALKANE_NATIVE\selftest.txt"
$p = Start-Process -FilePath "$env:ALKANE_NATIVE\alkane-toolkit.exe" -Wait -PassThru `
-NoNewWindow -RedirectStandardOutput $out -RedirectStandardError "$out.err"
Get-Content $out, "$out.err"
if ($p.ExitCode -ne 0) { exit $p.ExitCode }
- name: Remove the downloaded build
if: always()
run: |
if ($env:ALKANE_NATIVE) { Remove-Item -Recurse -Force $env:ALKANE_NATIVE -ErrorAction SilentlyContinue }
+6
View File
@@ -1,3 +1,9 @@
/target
**/target
.claude/
__pycache__/
# Internal working notes live outside this public repository.
/AGENTS.md
/HANDOFF.md
/CLAUDE.md
code-review-report*.md
Generated
+20
View File
@@ -40,13 +40,20 @@ name = "alkane-artifacts"
version = "0.1.0"
dependencies = [
"alkane-core",
"serde",
"serde_json",
"sha2",
"thiserror",
]
[[package]]
name = "alkane-cli"
version = "0.1.0"
dependencies = [
"alkane-artifacts",
"alkane-core",
"alkane-flash",
"serde_json",
]
[[package]]
@@ -69,20 +76,33 @@ dependencies = [
name = "alkane-flash"
version = "0.1.0"
dependencies = [
"alkane-artifacts",
"alkane-core",
"serde_json",
"sha2",
"tempfile",
"thiserror",
]
[[package]]
name = "alkane-gui"
version = "0.1.0"
dependencies = [
"aes",
"alkane-artifacts",
"alkane-core",
"alkane-discovery",
"alkane-flash",
"asic-rs",
"base64 0.21.7",
"ecb",
"futures-util",
"hex",
"md5crypt",
"measurements",
"serde",
"serde_json",
"sha2",
"tokio",
"wx-rs",
]
+14 -1
View File
@@ -13,9 +13,22 @@ members = [
[workspace.package]
version = "0.1.0"
edition = "2021"
license = "MIT OR Apache-2.0"
license = "MIT"
[workspace.dependencies]
thiserror = "2"
serde = { version = "1", features = ["derive"] }
sha2 = "0.10"
serde_json = "1"
# Release binary: small, self-contained, and fast enough for a fleet GUI whose
# hot path is network I/O, not CPU (round 18 #12). opt-level "s" + fat LTO +
# one codegen unit + symbol stripping cut the binary substantially. panic stays
# "unwind" on purpose: the scan runs many miners on tokio tasks and the wx event
# dispatch relies on unwinding so one miner's panic never aborts the whole app.
[profile.release]
opt-level = "s"
lto = "fat"
codegen-units = 1
strip = true
+21
View File
@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2026 BlueFlare Energy Solutions Inc.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
+104 -27
View File
@@ -1,38 +1,115 @@
# alkane-toolkit
# Alkane Toolkit
Cross-platform desktop toolkit (Rust core, native GUI) to install **stock** or
**alkaneOS** firmware on ASIC miner control boards, whatever they currently run
(stock, Vnish/AnthillOS, Braiins OS+, LuxOS, ePIC, BixBit, WardenOS).
[![CI](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/main.svg)](https://gitea.bluefla.re/blueflare/alkane-toolkit/actions)
[![tests](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/tests.svg)](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/)
[![coverage](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/coverage.svg)](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/#coverage)
[![bench](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/bench.svg)](https://blueflare.gitea.bluefla.re/alkane-toolkit/bench/)
[![bench coverage](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/bench-coverage.svg)](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/)
[![lines of code](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/loc.svg)](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/#coverage)
[![code quality](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/quality.svg)](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/)
[![dependencies](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/dependencies.svg)](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/)
[![license](https://gitea.bluefla.re/blueflare/alkane-toolkit/raw/branch/ci-badges/badges/license.svg)](LICENSE)
Sibling to [alkane-sdk](https://gitea.bluefla.re/blueflare/alkane-sdk): the SDK
owns board knowledge and build outputs; this toolkit is the orchestration
engine and operator UI that executes its install recipes safely.
The badges link to the [project site](https://blueflare.gitea.bluefla.re/alkane-toolkit/): the [manual](https://blueflare.gitea.bluefla.re/alkane-toolkit/manual/),
the [code-quality dashboard](https://blueflare.gitea.bluefla.re/alkane-toolkit/quality/) (how the grade is set, coverage by
crate and file) and the [benchmark history](https://blueflare.gitea.bluefla.re/alkane-toolkit/bench/).
## Status
Desktop miner discovery and monitoring. The Rust GUI uses wxWidgets through
a patched [wx-rs bridge](thirdparty/wx-rs). In-app image flashing is disabled
while that path is reworked.
M1 primary view ships: discovery (vendored asic-rs 0.8.1) + the UI-SPEC
table (6 KPIs, sortable/drag-reorderable columns, row checkboxes, scan-range
editor, Excel-style filter, columns panel). Pure-Rust GUI on wxWidgets via
vendored + patched wx-rs (docs/adr/0002, 0003).
## Build + run (Debian)
## Run locally
```sh
scripts/build-wx-linux.sh # once: builds vendored wx 3.3.3 to ~/.cache
scripts/build-gui-linux.sh # cargo build --release -p alkane-gui
~/.cache/alkane-tk-target/release/alkane-toolkit
scripts/build-wx-linux.sh
scripts/build-gui-linux.sh
ALKANE_FAKE_SCAN=1 ~/.cache/alkane-tk-target/release/alkane-toolkit
```
Windows/macOS: `scripts/build-gui-windows.sh` (needs a Windows/msys2
toolchain) and `scripts/build-gui-macos.sh` (needs a Mac) - the GUI code is
shared; only the C++ bridge + wx differ per platform.
The first command builds wxWidgets 3.3.3 once. Linux needs GTK 3. Fake scan
uses offline fixtures and does not contact hardware.
See `docs/IMPLEMENTATION-PLAN.md` for the roadmap.
Windows 10/11 builds are cross-compiled on Linux (`scripts/build-wx-windows.sh`,
then `scripts/build-gui-windows.sh`) and attached to every release as a
self-contained `alkane-toolkit.exe`; see [docs/windows.md](docs/windows.md).
macOS builds run on a Mac (`scripts/build-wx-macos.sh`, then
`scripts/build-gui-macos.sh`) and produce one universal app for Apple Silicon
and Intel, macOS 11 or later; see [docs/macos.md](docs/macos.md).
## Hard rules (from alkane-sdk `docs/install-methods.md`, encoded in code)
## Current scope
1. Never write the bootloader/secure region.
2. Verify on a channel the installer does not control.
3. Reboot is root-only; a dropped SSH connection can be success.
4. A packer is per board; never reuse across boards.
5. Boot-switch handling is an explicit, verified step.
- Discover miners by CIDR or IP range with vendored [asic-rs](vendor/asic-rs).
- Show model, firmware, health, hashrate, temperatures, fans, PSU, and workers.
- Filter and sort the desktop table; inspect probes with `miner_probe`.
- Use controls supported by the selected firmware and restore supported
aftermarket firmware to stock.
Discovery is read-only. Control and restore actions change miners. Check the
selected devices before applying them.
## Headless .afw install (CV1835 and AM335x)
`alkane-cli` is the headless engine; the GUI uses the same engine. A verified
`.afw` is a full OS bundle for exactly one board. The CV1835 installer writes
only `/dev/mmcblk0p1` over SSH, holds the current p1 first, reads the whole
partition back, and reboots only after the read-back matches.
The AM335x installer writes mtd8 (type-3 ramdisk), mtd6 (dtb) and mtd7
(legacy kernel uImage) with `flash_erase` + `nandwrite`. It never touches
mtd0-5 (SPL/U-Boot/bootenv), holds a backup of each target before writing it,
and reads every target back before reboot. Its `verify-live` checks SSH
(kernel string), the HTTP marker on port 80, the API on port 4028, and the
eth0 DHCP lease.
```sh
alkane-cli afw verify BUNDLE.afw --allow-unsigned
alkane-cli afw plan BUNDLE.afw --host 10.255.1.167
alkane-cli afw preflight BUNDLE.afw --host 10.255.1.167
alkane-cli afw install BUNDLE.afw --host 10.255.1.167 --dry-run
alkane-cli afw install BUNDLE.afw --host 10.255.1.167 --confirm FLASH
alkane-cli afw verify-live BUNDLE.afw --host 10.255.1.167
alkane-cli afw restore --host 10.255.1.167 --held-backup p1.img --confirm FLASH
```
For AM335x the same subcommands infer the board from the bundle; restore names
the three held copies explicitly:
```sh
alkane-cli afw plan BUNDLE.afw --host 10.255.1.64
alkane-cli afw preflight BUNDLE.afw --host 10.255.1.64
alkane-cli afw install BUNDLE.afw --host 10.255.1.64 --dry-run
alkane-cli afw install BUNDLE.afw --host 10.255.1.64 --confirm FLASH
alkane-cli afw verify-live BUNDLE.afw --host 10.255.1.64 --timeout 300
alkane-cli afw restore --board am335x --host 10.255.1.64 \
--held-backup mtd8.img --held-kernel mtd7.img --held-dtb mtd6.img --confirm FLASH
```
On stock Bitmain CV1835 the SSH login is the unprivileged `miner` account; the
toolkit obtains root through the stock update-daemon loopback channel, not a
serial console. Credentials come only from `ALKANE_BOARD_PASSWORD` or
`ALKANE_BOARD_PASSWORD_FILE`, or from `--password-file` / `--identity-file`.
No credential value is printed. `--allow-unsigned` is bench-only; site use
needs an Ed25519-signed bundle.
## Development
```sh
WX_RS_WXCONFIG="$HOME/.cache/wx-3.3.3-linux/bin/wx-config" \
CARGO_TARGET_DIR="$HOME/.cache/alkane-tk-target" \
cargo test -p alkane-gui --offline
```
Keep build output off the source share. `main` runs full CI and publishes
qualifying releases; `next` builds `-rc` candidates. Badges measure host
code, not installation support. See the
[benchmark history](https://blueflare.gitea.bluefla.re/alkane-toolkit/bench/).
## Firmware safety
Installation must follow the [SDK install rules](https://gitea.bluefla.re/blueflare/alkane-sdk/src/branch/main/docs/install-methods.md):
use the exact board's packer and boot-switch procedure, verify through an
independent channel, and never write bootloader or secure regions.
## License
[MIT](LICENSE). Vendored dependencies keep their own terms.
+11
View File
@@ -0,0 +1,11 @@
{
"bench_parse_line_near_max_addrs": 807160.0,
"bench_parse_targets_many_ranges_near_cap": 54465485.0,
"bench_render_cells": 3503112.0,
"bench_sort_by_each_column": 486975.0,
"bench_targets_to_cidrs_large_range": 482167.0,
"bench_upsert_cold_start_population": 8315814.0,
"bench_view_pipeline": 191794.0,
"bench_view_pipeline_default_sort": 193214.0,
"bench_view_pipeline_with_filter": 253085.0
}
+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="128.0" height="20" role="img" aria-label="bench coverage: 7%">
<title>bench coverage: 7%</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="128.0" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="103.0" height="20" fill="#555"/>
<rect x="103.0" width="25.0" height="20" fill="#e05d44"/>
<rect width="128.0" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="51.5" y="15" fill="#010101" fill-opacity=".3">bench coverage</text>
<text x="51.5" y="14">bench coverage</text>
<text x="115.5" y="15" fill="#010101" fill-opacity=".3">7%</text>
<text x="115.5" y="14">7%</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 946 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="141.0" height="20" role="img" aria-label="bench: +7.4% vs prev">
<title>bench: +7.4% vs prev</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="141.0" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="44.5" height="20" fill="#555"/>
<rect x="44.5" width="96.5" height="20" fill="#dfb317"/>
<rect width="141.0" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="22.2" y="15" fill="#010101" fill-opacity=".3">bench</text>
<text x="22.2" y="14">bench</text>
<text x="92.8" y="15" fill="#010101" fill-opacity=".3">+7.4% vs prev</text>
<text x="92.8" y="14">+7.4% vs prev</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 950 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="95.5" height="20" role="img" aria-label="coverage: 44%">
<title>coverage: 44%</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="95.5" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="64.0" height="20" fill="#555"/>
<rect x="64.0" width="31.5" height="20" fill="#dfb317"/>
<rect width="95.5" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="32.0" y="15" fill="#010101" fill-opacity=".3">coverage</text>
<text x="32.0" y="14">coverage</text>
<text x="79.8" y="15" fill="#010101" fill-opacity=".3">44%</text>
<text x="79.8" y="14">44%</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 919 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="121.5" height="20" role="img" aria-label="dependencies: 349">
<title>dependencies: 349</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="121.5" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="90.0" height="20" fill="#555"/>
<rect x="90.0" width="31.5" height="20" fill="#007ec6"/>
<rect width="121.5" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="45.0" y="15" fill="#010101" fill-opacity=".3">dependencies</text>
<text x="45.0" y="14">dependencies</text>
<text x="105.8" y="15" fill="#010101" fill-opacity=".3">349</text>
<text x="105.8" y="14">349</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 940 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="89.0" height="20" role="img" aria-label="license: MIT">
<title>license: MIT</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="89.0" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="57.5" height="20" fill="#555"/>
<rect x="57.5" width="31.5" height="20" fill="#007ec6"/>
<rect width="89.0" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="28.8" y="15" fill="#010101" fill-opacity=".3">license</text>
<text x="28.8" y="14">license</text>
<text x="73.2" y="15" fill="#010101" fill-opacity=".3">MIT</text>
<text x="73.2" y="14">MIT</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 915 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="141.0" height="20" role="img" aria-label="lines of code: 13.7K">
<title>lines of code: 13.7K</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="141.0" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="96.5" height="20" fill="#555"/>
<rect x="96.5" width="44.5" height="20" fill="#007ec6"/>
<rect width="141.0" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="48.2" y="15" fill="#010101" fill-opacity=".3">lines of code</text>
<text x="48.2" y="14">lines of code</text>
<text x="118.8" y="15" fill="#010101" fill-opacity=".3">13.7K</text>
<text x="118.8" y="14">13.7K</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 952 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="108.5" height="20" role="img" aria-label="code quality: A">
<title>code quality: A</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="108.5" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="90.0" height="20" fill="#555"/>
<rect x="90.0" width="18.5" height="20" fill="#4c1"/>
<rect width="108.5" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="45.0" y="15" fill="#010101" fill-opacity=".3">code quality</text>
<text x="45.0" y="14">code quality</text>
<text x="99.2" y="15" fill="#010101" fill-opacity=".3">A</text>
<text x="99.2" y="14">A</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 927 B

+19
View File
@@ -0,0 +1,19 @@
<svg xmlns="http://www.w3.org/2000/svg" width="121.5" height="20" role="img" aria-label="tests: 95 passing">
<title>tests: 95 passing</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="121.5" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="44.5" height="20" fill="#555"/>
<rect x="44.5" width="77.0" height="20" fill="#4c1"/>
<rect width="121.5" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="22.2" y="15" fill="#010101" fill-opacity=".3">tests</text>
<text x="22.2" y="14">tests</text>
<text x="83.0" y="15" fill="#010101" fill-opacity=".3">95 passing</text>
<text x="83.0" y="14">95 passing</text>
</g>
</svg>

After

Width:  |  Height:  |  Size: 935 B

+54
View File
@@ -0,0 +1,54 @@
# SPDX-License-Identifier: MIT
"""Write small badge artifacts to the private Gitea CI badge branch."""
import base64
import json
from urllib.error import HTTPError
from urllib.parse import quote
from urllib.request import Request, urlopen
BADGE_BRANCH = "ci-badges"
def request_json(url: str, token: str, method: str = "GET",
payload: dict | None = None) -> dict:
body = None if payload is None else json.dumps(payload).encode()
request = Request(url, data=body, method=method,
headers={"Authorization": f"token {token}",
"Content-Type": "application/json"})
with urlopen(request, timeout=20) as response:
return json.load(response)
def publish_file(api: str, repo: str, filename: str, data: bytes,
token: str, message: str, max_bytes: int = 65_536) -> None:
if not filename or filename.startswith("/") or any(
part in ("", ".", "..") for part in filename.split("/")):
raise ValueError("invalid badge path")
if len(data) > max_bytes:
raise ValueError("artifact exceeds size limit")
path = f"{api}/repos/{repo}/contents/{quote(filename, safe='/')}"
encoded = base64.b64encode(data).decode("ascii")
for attempt in range(3):
try:
current = request_json(path + "?ref=" + BADGE_BRANCH, token)
if base64.b64decode(current["content"]) == data:
return
sha = current["sha"]
method = "PUT"
except HTTPError as error:
if error.code != 404:
raise
sha = None
method = "POST"
payload = {"branch": BADGE_BRANCH, "content": encoded,
"message": message + " [skip ci]"}
if sha is not None:
payload["sha"] = sha
try:
request_json(path, token, method, payload)
return
except HTTPError as error:
if error.code not in (409, 422) or attempt == 2:
raise
raise RuntimeError("badge write did not complete")
+110
View File
@@ -0,0 +1,110 @@
#!/usr/bin/env python3
"""Check the Toolkit benchmark suite and compare it with the prior release."""
import argparse
import json
import math
import os
import re
import sys
# A Duration Debug token: a number immediately followed by a time unit, with the
# multi-char units listed before the bare "s" so alternation prefers them. The
# trailing (?![a-zA-Z]) stops "s" in words like "rows"/"cidrs" from matching.
_DUR = re.compile(r"([0-9]+(?:\.[0-9]+)?)\s*(ns|\u00b5s|us|ms|s)(?![a-zA-Z])")
_UNIT_NS = {"ns": 1.0, "us": 1e3, "\u00b5s": 1e3, "ms": 1e6, "s": 1e9}
_NAME = re.compile(r"^(?:test [A-Za-z0-9_:]+ \.\.\. )?(bench_[A-Za-z0-9_]+)\s*:")
EXPECTED_BENCHES = {
"bench_verify_artifact", "bench_naming_transforms",
"bench_parse_line_near_max_addrs", "bench_parse_targets_many_ranges_near_cap",
"bench_targets_to_cidrs_large_range", "bench_view_pipeline",
"bench_render_cells", "bench_health_diagnostics",
"bench_view_pipeline_default_sort", "bench_sort_by_each_column",
"bench_view_pipeline_with_filter", "bench_upsert_cold_start_population",
}
def parse_bench(text: str) -> dict:
"""Map each bench name to its timing in nanoseconds (the last Duration on the
line, since every bench prints its timing last)."""
out = {}
for line in text.splitlines():
m = _NAME.match(line.strip())
if not m:
continue
durs = _DUR.findall(line)
if not durs:
raise ValueError(f"missing timing for {m.group(1)}")
val, unit = durs[-1]
elapsed = float(val) * _UNIT_NS[unit]
if m.group(1) in out or not math.isfinite(elapsed) or elapsed <= 0:
raise ValueError(f"duplicate or invalid timing for {m.group(1)}")
out[m.group(1)] = elapsed
return out
def require_suite(results: dict) -> dict:
if results.keys() != EXPECTED_BENCHES:
raise ValueError("microbenchmark results differ from the declared suite")
return results
def benchmark_delta(current: dict, baseline: dict) -> float | None:
"""Average each comparable benchmark's percentage improvement."""
if not baseline:
return None
changes = [(baseline[name] - current[name]) / baseline[name]
for name in baseline]
delta = math.fsum(changes) / len(changes) * 100
if not math.isfinite(delta):
raise ValueError("benchmark comparison is not finite")
return delta
def main() -> int:
ap = argparse.ArgumentParser()
ap.add_argument("--current", required=True, help="captured bench stdout")
ap.add_argument("--baseline", required=True, help="baseline JSON (read + rewrite)")
ap.add_argument("--no-write", action="store_true", help="do not update the baseline")
args = ap.parse_args()
try:
with open(args.current, encoding="utf-8") as fh:
current = require_suite(parse_bench(fh.read()))
except (OSError, ValueError) as e:
print(f"bench-badge: cannot read current results: {e}", file=sys.stderr)
return 1
baseline = {}
try:
with open(args.baseline, encoding="utf-8") as fh:
baseline = json.load(fh)
except FileNotFoundError:
pass
except (OSError, ValueError) as e:
print(f"bench-badge: invalid baseline: {e}", file=sys.stderr)
return 1
if (not isinstance(baseline, dict)
or not set(baseline).issubset(current)
or any(not isinstance(value, (int, float)) or isinstance(value, bool)
or not math.isfinite(value) or value <= 0
for value in baseline.values())):
print("bench-badge: invalid or retired benchmark in baseline", file=sys.stderr)
return 1
try:
delta = benchmark_delta(current, baseline)
except ValueError as error:
print(f"bench-badge: {error}", file=sys.stderr)
return 1
print("NEW" if delta is None else f"{delta:.1f}")
if not args.no_write:
os.makedirs(os.path.dirname(args.baseline) or ".", exist_ok=True)
with open(args.baseline, "w", encoding="utf-8") as fh:
json.dump({k: round(v, 1) for k, v in sorted(current.items())}, fh, indent=2)
fh.write("\n")
return 0
if __name__ == "__main__":
sys.exit(main())
+8
View File
@@ -0,0 +1,8 @@
#!/usr/bin/env bash
# Measure only instrumented microbenchmarks, excluding unit and UI tests.
set -euo pipefail
export WX_RS_WXCONFIG="${WX_RS_WXCONFIG:-$HOME/.cache/wx-3.3.3-linux/bin/wx-config}"
cargo llvm-cov clean --workspace
cargo llvm-cov --no-report --offline --release -p alkane-gui -p alkane-artifacts -- \
--ignored --nocapture bench_
cargo llvm-cov report --release --ignore-filename-regex '(thirdparty|vendor)/' "$@"
+227
View File
@@ -0,0 +1,227 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Keep measured main-branch benchmarks in the private CI artifact branch."""
import argparse
import base64
from datetime import datetime, timezone
import html
import json
import math
import os
from pathlib import Path
import re
import subprocess
import importlib.util
from urllib.error import HTTPError
from urllib.parse import quote
import yaml
from badge_store import BADGE_BRANCH, publish_file, request_json
from bench_host import identity as benchmark_host
bench_spec = importlib.util.spec_from_file_location(
"bench_badge", Path(__file__).with_name("bench-badge.py"))
bench_badge = importlib.util.module_from_spec(bench_spec)
bench_spec.loader.exec_module(bench_badge)
INDEX = "history/index.json"
MAX_INDEX_ENTRIES = 50
BENCH_INPUT_PATHS = (
"Cargo.toml", "Cargo.lock", ".cargo", "crates", "thirdparty", "vendor",
"rust-toolchain.toml", "ci/bench-badge.py", "ci/bench_host.py",
"ci/ensure-build-deps.sh", "ci/ensure-wx-prefix.sh",
"ci/configure-rust-cache.sh", "ci/wx-cache-key.sh",
)
def read_artifact(api: str, repo: str, token: str, filename: str):
url = f"{api}/repos/{repo}/contents/{quote(filename, safe='/')}?ref={BADGE_BRANCH}"
try:
value = request_json(url, token)
except HTTPError as error:
if error.code == 404:
return None
raise
return json.loads(base64.b64decode(value["content"]))
def valid_benches(metrics: dict) -> dict[str, float]:
values = metrics.get("bench_ns_per_op")
if not isinstance(values, dict) or not values:
raise ValueError("benchmark measurements are missing")
if any(not isinstance(key, str) or not re.fullmatch(r"[A-Za-z0-9_]+", key)
or not isinstance(value, (float, int)) or isinstance(value, bool)
or not math.isfinite(value) or value <= 0 for key, value in values.items()):
raise ValueError("benchmark measurements are invalid")
return values
def git_distance(ancestor: str, sha: str) -> int | None:
if not re.fullmatch(r"[0-9a-f]{40}", ancestor) or not re.fullmatch(r"[0-9a-f]{40}", sha):
return None
result = subprocess.run(("git", "rev-list", "--count", f"{ancestor}..{sha}"),
capture_output=True, text=True, check=False)
if result.returncode != 0:
return None
ancestor_check = subprocess.run(("git", "merge-base", "--is-ancestor", ancestor, sha),
capture_output=True, check=False)
return int(result.stdout.strip()) if ancestor_check.returncode == 0 else None
def previous_entry(index: dict, sha: str, distance=None, host=None) -> dict | None:
distance = distance or git_distance
choices = []
for entry in index.get("entries", []):
ancestor = entry.get("sha")
if ancestor == sha or not isinstance(ancestor, str):
continue
if host is not None and entry.get("metrics", {}).get("bench_host") != host:
continue
gap = distance(ancestor, sha)
if gap is not None and gap > 0:
choices.append((gap, entry))
if not choices:
return None
return min(choices, key=lambda item: item[0])[1]
def previous_measurement(index: dict, sha: str, distance=None, host=None) -> dict:
entry = previous_entry(index, sha, distance, host)
return valid_benches(entry["metrics"]) if entry else {}
def benchmark_build_settings(sha: str, root: Path | str = ".") -> dict:
source = subprocess.check_output(
("git", "show", f"{sha}:.gitea/workflows/release.yml"),
cwd=root, text=True)
job = yaml.load(source, Loader=yaml.BaseLoader)["jobs"]["release"]
commands = {step.get("name", ""): step.get("run") for step in job["steps"]}
selected = ("Install build dependencies", "Configure bounded Rust compiler cache",
"Build wxWidgets (once, then cached)", "Build release", "Microbenchmarks")
return {"image": job["container"]["image"], "env": job.get("env", {}),
"commands": {name: commands.get(name) for name in selected}}
def same_benchmark_inputs(ancestor: str, sha: str, root: Path | str = ".") -> bool:
"""Identify changes that only reroute CI without changing benchmark inputs."""
if not re.fullmatch(r"[0-9a-f]{40}", ancestor) or not re.fullmatch(r"[0-9a-f]{40}", sha):
raise ValueError("invalid benchmark comparison commit")
diff = subprocess.run(("git", "diff", "--quiet", ancestor, sha, "--",
*BENCH_INPUT_PATHS), cwd=root, check=False)
if diff.returncode not in (0, 1):
raise ValueError("cannot inspect benchmark input changes")
if diff.returncode == 1:
return False
try:
return benchmark_build_settings(ancestor, root) == benchmark_build_settings(sha, root)
except (KeyError, TypeError, subprocess.CalledProcessError, yaml.YAMLError):
return False
def updated_index(index: dict, sha: str, metrics: dict, timestamp: str) -> dict:
if not re.fullmatch(r"[0-9a-f]{40}", sha):
raise ValueError("invalid commit SHA")
valid_benches(metrics)
entries = [entry for entry in index.get("entries", []) if entry.get("sha") != sha]
entries.append({"sha": sha, "timestamp": timestamp, "metrics": metrics})
return {"schema": 1, "entries": entries[-MAX_INDEX_ENTRIES:]}
def render_html(index: dict) -> str:
entries = list(reversed(index.get("entries", [])))
names = sorted({name for entry in entries
for name in valid_benches(entry["metrics"])})
rows = []
for entry in entries:
sha = entry["sha"]
if not re.fullmatch(r"[0-9a-f]{40}", sha):
raise ValueError("invalid commit SHA in history")
cells = [f'<td><a href="https://gitea.bluefla.re/blueflare/alkane-toolkit/commit/{sha}">{sha[:10]}</a></td>',
f'<td>{html.escape(entry["timestamp"])}</td>']
values = valid_benches(entry["metrics"])
host = entry["metrics"].get("bench_host", {})
host_label = host.get("cpu_model", "unknown") if isinstance(host, dict) else "unknown"
cells.append(f'<td>{html.escape(str(host_label))}</td>')
context = entry["metrics"].get("bench_context", {})
if isinstance(context, dict) and context.get("schema") == 1:
context_label = "same inputs" if context.get("same_inputs") else "changed inputs"
else:
context_label = "unclassified"
cells.append(f'<td>{context_label}</td>')
cells += [f'<td>{values[name]:.3f}</td>' if name in values else '<td>new</td>'
for name in names]
rows.append("<tr>" + "".join(cells) + "</tr>")
headings = "".join(f"<th scope=\"col\">{html.escape(name)} (ns/op)</th>" for name in names)
return ("<!doctype html>\n<html lang=\"en\"><head><meta charset=\"utf-8\">"
"<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">"
"<title>Alkane Toolkit benchmarks</title><style>"
"body{font:16px system-ui,sans-serif;max-width:1100px;margin:2rem auto;padding:0 1rem;color:#17212b}"
"h1{font-size:2rem}p{max-width:70ch;line-height:1.5}"
"table{border-collapse:collapse;min-width:100%}th,td{padding:.5rem;border-bottom:1px solid #ccd3da;text-align:right}"
"th:first-child,td:first-child{text-align:left}th:nth-child(2),td:nth-child(2){text-align:left}"
"th{background:#edf2f6;position:sticky;top:0}a{color:#145a9a}"
".scroll{overflow-x:auto}small{color:#55616d}</style></head><body>"
"<h1>Alkane Toolkit microbenchmarks</h1>"
"<p>Measured on main CI. Lower ns/op is faster. Runner load affects results. "
"Same inputs marks a repeat of the benchmark source and build settings. "
"A new benchmark has no earlier comparison.</p>"
f"<p><small>Most recent {len(entries)} measured commits. Full per-commit JSON is retained "
"in the private ci-badges branch.</small></p>"
f"<div class=\"scroll\"><table><thead><tr><th scope=\"col\">Commit</th>"
f"<th scope=\"col\">UTC</th><th scope=\"col\">CPU</th>"
f"<th scope=\"col\">Inputs</th>{headings}</tr></thead><tbody>{''.join(rows)}"
"</tbody></table></div></body></html>\n")
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("action", choices=("prepare", "publish", "render"))
args = parser.parse_args()
api = os.environ["GITHUB_API_URL"].rstrip("/")
repo = os.environ["GITHUB_REPOSITORY"]
token = os.environ["GITEA_TOKEN"]
sha = os.environ["GITHUB_SHA"]
index = read_artifact(api, repo, token, INDEX) or {"schema": 1, "entries": []}
if index.get("schema") != 1 or not isinstance(index.get("entries"), list):
raise ValueError("unsupported benchmark history index")
if args.action == "prepare":
entry = previous_entry(index, sha, host=benchmark_host())
baseline = valid_benches(entry["metrics"]) if entry else {}
same_inputs = same_benchmark_inputs(entry["sha"], sha) if entry else False
Path("badges").mkdir(exist_ok=True)
Path("badges/bench-baseline.json").write_text(json.dumps(baseline) + "\n")
Path("badges/bench-context.json").write_text(
json.dumps({"schema": 1, "same_inputs": same_inputs,
"baseline_sha": entry["sha"] if entry else None}) + "\n")
print(f"Loaded {len(baseline)} prior benchmark measurements; "
f"same inputs: {str(same_inputs).lower()}")
return
if args.action == "render":
if not index["entries"]:
raise ValueError("no measured benchmark history to publish")
Path("bench-site").mkdir(exist_ok=True)
Path("bench-site/index.html").write_text(render_html(index))
print(f"Rendered {len(index['entries'])} measured benchmark commits")
return
context = json.loads(Path("badges/bench-context.json").read_text())
if (not isinstance(context, dict) or context.get("schema") != 1 or
not isinstance(context.get("same_inputs"), bool)):
raise ValueError("invalid benchmark comparison context")
metrics = {"bench_ns_per_op": bench_badge.require_suite(bench_badge.parse_bench(
Path("bench-current.txt").read_text())), "bench_host": benchmark_host(),
"bench_context": context}
timestamp = datetime.now(timezone.utc).isoformat(timespec="seconds")
index = updated_index(index, sha, metrics, timestamp)
record = json.dumps(index["entries"][-1], indent=2).encode() + b"\n"
publish_file(api, repo, f"history/{sha}.json", record, token,
"Record Alkane Toolkit benchmarks", max_bytes=1_048_576)
publish_file(api, repo, INDEX, json.dumps(index, indent=2).encode() + b"\n",
token, "Update Alkane Toolkit benchmark index", max_bytes=1_048_576)
Path("bench-site").mkdir(exist_ok=True)
Path("bench-site/index.html").write_text(render_html(index))
print(f"Recorded benchmarks for {sha[:10]}")
if __name__ == "__main__":
main()
+19
View File
@@ -0,0 +1,19 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Identify the CPU class used for comparable CI microbenchmark baselines."""
import os
import platform
from pathlib import Path
def identity() -> dict[str, object]:
model = "unknown"
cpuinfo = Path("/proc/cpuinfo")
if cpuinfo.is_file():
for line in cpuinfo.read_text(errors="replace").splitlines():
if line.startswith(("model name\t", "Hardware\t", "Processor\t")):
model = line.partition(":")[2].strip()[:160]
break
return {"architecture": platform.machine(), "cpu_model": model,
"logical_cpus": os.cpu_count() or 1}
+293
View File
@@ -0,0 +1,293 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Build the Alkane Toolkit Pages site (served from this repo's gh-pages).
build-pages.py --out site [--manual docs/manual] [--quality quality.json]
[--bench bench-site/index.html] [--sha SHA]
Pages:
/ overview and downloads
/manual/ the user manual, one page per docs/manual/NN-name.md chapter
/quality/ code-quality dashboard from the measured quality.json that main
CI publishes next to the badges (ci/gen-badges.py)
/bench/ the measured benchmark history (ci/bench_history.py render)
Every value taken from CI data is HTML-escaped; the manual is Markdown written
in this repository.
"""
import argparse
import html
import json
import re
import shutil
from pathlib import Path
import markdown
REPO = "https://gitea.bluefla.re/blueflare/alkane-toolkit"
RELEASES = REPO + "/releases"
SECTIONS = (("", "Overview"), ("manual/", "Manual"), ("quality/", "Code quality"),
("bench/", "Benchmarks"))
CSS = """
:root { --bg:#ffffff; --fg:#1f2328; --muted:#59636e; --line:#d1d9e0; --card:#f6f8fa;
--accent:#d9822b; --link:#0969da; --good:#1a7f37; --warn:#9a6700; --bad:#cf222e; }
@media (prefers-color-scheme: dark) { :root { --bg:#0d1117; --fg:#e6edf3; --muted:#9198a1;
--line:#30363d; --card:#151b23; --link:#4493f8; --good:#3fb950; --warn:#d29922; --bad:#f85149; } }
* { box-sizing: border-box; }
body { margin:0; background:var(--bg); color:var(--fg);
font:16px/1.55 system-ui,-apple-system,"Segoe UI",Roboto,Ubuntu,sans-serif; }
a { color:var(--link); text-decoration:none; } a:hover { text-decoration:underline; }
header { border-bottom:1px solid var(--line); }
header .bar, main { max-width:1040px; margin:0 auto; padding:0 16px; }
header .bar { display:flex; align-items:center; gap:24px; height:56px; flex-wrap:wrap; }
header .brand { font-weight:700; color:var(--fg); display:flex; gap:8px; align-items:center; }
header .brand i { width:20px; height:20px; border-radius:5px; background:var(--accent); display:inline-block; }
header nav { display:flex; gap:18px; flex-wrap:wrap; }
header nav a { color:var(--muted); } header nav a.on { color:var(--fg); font-weight:600; }
main { padding:28px 16px 64px; }
h1 { font-size:1.9rem; margin:.2em 0 .4em; } h2 { margin-top:1.8em; border-bottom:1px solid var(--line); padding-bottom:.25em; }
code { background:var(--card); border:1px solid var(--line); border-radius:5px; padding:.1em .35em; font-size:.92em; }
pre { background:var(--card); border:1px solid var(--line); border-radius:8px; padding:12px; overflow:auto; }
pre code { border:0; padding:0; }
table { border-collapse:collapse; width:100%; margin:1em 0; display:block; overflow-x:auto; }
th, td { border:1px solid var(--line); padding:6px 10px; text-align:left; vertical-align:top; }
th { background:var(--card); }
td.num, th.num { text-align:right; font-variant-numeric:tabular-nums; white-space:nowrap; }
.cards { display:grid; grid-template-columns:repeat(auto-fill,minmax(180px,1fr)); gap:12px; margin:1.2em 0; }
.card { background:var(--card); border:1px solid var(--line); border-radius:10px; padding:14px; }
.card b { display:block; font-size:1.6rem; } .card span { color:var(--muted); font-size:.9rem; }
.good { color:var(--good); } .warn { color:var(--warn); } .bad { color:var(--bad); }
.bar-cell { min-width:120px; } .meter { height:8px; background:var(--line); border-radius:4px; overflow:hidden; }
.meter i { display:block; height:100%; }
.layout { display:grid; grid-template-columns:220px 1fr; gap:32px; }
.layout aside ol { padding-left:1.2em; margin:0; } .layout aside li { margin:.3em 0; }
.layout aside a.on { font-weight:600; color:var(--fg); }
@media (max-width:760px) { .layout { grid-template-columns:1fr; } }
.buttons a { display:inline-block; margin:4px 8px 4px 0; padding:8px 14px; border-radius:8px;
border:1px solid var(--line); background:var(--card); color:var(--fg); }
.buttons a.primary { background:var(--accent); border-color:var(--accent); color:#fff; }
footer { color:var(--muted); font-size:.85rem; margin-top:48px; }
"""
def page(title: str, body: str, depth: int, current: str, sha: str) -> str:
up = "../" * depth
nav = "".join(
f'<a href="{up}{path}"{" class=on" if path == current else ""}>{label}</a>'
for path, label in SECTIONS)
built = f"Built from {html.escape(sha[:10])}. " if sha else ""
return f"""<!doctype html>
<html lang="en"><head><meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>{html.escape(title)} - Alkane Toolkit</title>
<link rel="stylesheet" href="{up}style.css"></head>
<body><header><div class="bar"><a class="brand" href="{up}"><i></i>Alkane Toolkit</a>
<nav>{nav}<a href="{RELEASES}">Downloads</a><a href="{REPO}">Source</a></nav></div></header>
<main>{body}
<footer>{built}Alkane Toolkit is MIT licensed.</footer></main></body></html>
"""
def write(out: Path, rel: str, text: str) -> None:
path = out / rel
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(text, encoding="utf-8")
# ---- manual -----------------------------------------------------------------
def chapters(manual: Path) -> list[tuple[str, str, str]]:
"""(slug, title, markdown) for docs/manual/NN-slug.md, in file-name order."""
out = []
for path in sorted(manual.glob("[0-9][0-9]-*.md")):
text = path.read_text(encoding="utf-8")
m = re.search(r"^# (.+)$", text, re.M)
title = m.group(1).strip() if m else path.stem
out.append((path.stem[3:], title, text))
return out
def build_manual(out: Path, manual: Path, sha: str) -> None:
items = chapters(manual)
if not items:
raise SystemExit(f"no manual chapters in {manual}")
def toc(current: str) -> str:
links = "".join(
f'<li><a href="{slug}.html"{" class=on" if slug == current else ""}>'
f"{html.escape(title)}</a></li>" for slug, title, _ in items)
return f"<aside><ol>{links}</ol></aside>"
for slug, title, text in items:
# Chapters link to each other as NN-name.md in the repo; on the site
# they are name.html.
text = re.sub(r"\]\((?:\./)?[0-9][0-9]-([a-z0-9-]+)\.md(#[^)]*)?\)", r"](\1.html\2)", text)
body_html = markdown.markdown(text, extensions=["tables", "fenced_code", "toc"])
write(out, f"manual/{slug}.html",
page(title, f'<div class="layout">{toc(slug)}<article>{body_html}</article></div>',
1, "manual/", sha))
first = items[0][0]
listing = "".join(f'<li><a href="{s}.html">{html.escape(t)}</a></li>' for s, t, _ in items)
write(out, "manual/index.html",
page("Manual", f"<h1>Manual</h1><p>Start with "
f'<a href="{first}.html">{html.escape(items[0][1])}</a>.</p><ol>{listing}</ol>',
1, "manual/", sha))
# ---- quality dashboard ---------------------------------------------------------
def pct_class(pct: float | None) -> str:
if pct is None:
return ""
return "good" if pct >= 80 else "warn" if pct >= 40 else "bad"
def meter(pct: float) -> str:
colour = {"good": "var(--good)", "warn": "var(--warn)", "bad": "var(--bad)"}[pct_class(pct)]
return f'<div class="meter"><i style="width:{max(0.0, min(pct, 100.0)):.1f}%;background:{colour}"></i></div>'
def build_quality(out: Path, quality: dict | None, sha: str) -> None:
e = html.escape
if not quality:
write(out, "quality/index.html", page(
"Code quality", "<h1>Code quality</h1><p>No measurement has been published yet; "
"the next main build will fill this page.</p>", 1, "quality/", sha))
return
grade = str(quality.get("grade", "pending"))
cov = quality.get("coverage_pct")
bench_cov = quality.get("bench_coverage_pct")
delta = quality.get("bench_delta_pct")
def card(value: str, label: str, cls: str = "") -> str:
return f'<div class="card"><b class="{cls}">{value}</b><span>{label}</span></div>'
cards = "".join([
card(e(grade), "Quality grade", {"A": "good", "B": "good", "C": "warn"}.get(grade, "bad")),
card(e(str(quality.get("tests_passed", "-"))), "Tests passing", "good"),
card(f"{cov:.1f}%" if cov is not None else "-", "Line coverage", pct_class(cov)),
card(f"{bench_cov:.1f}%" if bench_cov is not None else "-", "Benchmark coverage", pct_class(bench_cov)),
card(e(str(quality.get("clippy") or "-")), "Clippy (warnings are errors)",
"good" if quality.get("clippy") == "clean" else "bad"),
card(e(str(quality.get("rustfmt") or "-")), "rustfmt", "good" if quality.get("rustfmt") == "clean" else ""),
card(f"{quality.get('loc', 0):,}", "Lines of Rust"),
card(e(str(quality.get("dependencies", "-"))), "Crates in Cargo.lock"),
card((f"{'+' if delta > 0 else ''}{delta:.1f}%" if delta is not None else "-"),
"Benchmarks vs previous" + (" (same inputs)" if quality.get("bench_same_inputs") else ""),
"" if delta is None else "good" if delta >= 2 else "" if delta > -2 else "warn"),
])
bands = ", ".join(f"{e(str(letter))} at {floor:.0f}% or more"
for floor, letter in quality.get("grade_bands", []))
grade_rule = (f"<p>The grade is F if Clippy or rustfmt fails on main. Otherwise it is the "
f"line-coverage band: {bands}, and F below that. The coverage badge uses the "
f"same bands for its colour, so the two never disagree.</p>")
crates = quality.get("coverage_by_crate", {})
loc = quality.get("loc_by_crate", {})
rows = []
for name in sorted(set(crates) | set(loc)):
c = crates.get(name)
if c and c["lines"]:
pct = 100.0 * (c["lines"] - c["missed"]) / c["lines"]
cov_cells = (f'<td class="num {pct_class(pct)}">{pct:.1f}%</td>'
f'<td class="bar-cell">{meter(pct)}</td>'
f'<td class="num">{c["lines"] - c["missed"]:,} / {c["lines"]:,}</td>')
else:
cov_cells = '<td class="num">-</td><td></td><td class="num">-</td>'
rows.append(f"<tr><td>{e(name)}</td>{cov_cells}<td class='num'>{loc.get(name, 0):,}</td></tr>")
crate_table = ("<table><tr><th>Crate</th><th class=num>Line coverage</th><th></th>"
"<th class=num>Covered lines</th><th class=num>Lines of Rust</th></tr>"
+ "".join(rows) + "</table>")
files = sorted(quality.get("coverage_by_file", []),
key=lambda r: (r["lines"] - r["missed"]) / r["lines"] if r["lines"] else 1)
file_rows = "".join(
f"<tr><td><code>{e(r['file'])}</code></td>"
f"<td class='num {pct_class(100.0 * (r['lines'] - r['missed']) / r['lines'])}'>"
f"{100.0 * (r['lines'] - r['missed']) / r['lines']:.1f}%</td>"
f"<td class='num'>{r['missed']:,}</td><td class='num'>{r['lines']:,}</td></tr>"
for r in files if r["lines"])
file_table = ("<table><tr><th>File (least covered first)</th><th class=num>Coverage</th>"
"<th class=num>Uncovered lines</th><th class=num>Lines</th></tr>"
+ file_rows + "</table>") if file_rows else ""
measured = str(quality.get("sha", ""))[:10]
of_build = f" (this page: <code>{e(measured)}</code>)" if measured else ""
body = f"""<h1>Code quality</h1>
<p>Measured by main CI on every build{of_build}:
unit tests, line coverage (unit tests plus the headless UI self-test), Clippy with
warnings as errors, and rustfmt. Windows builds run the same tests under Wine and
on real Windows 11.</p>
<div class="cards">{cards}</div>
<h2 id="grade">How the grade is set</h2>{grade_rule}
<h2 id="coverage">Coverage by crate</h2>{crate_table}
<h2 id="files">Coverage by file</h2>{file_table}
<p>The dependency count is every package in <code>Cargo.lock</code>, direct and
transitive. Lines of Rust count every <code>.rs</code> line under <code>crates/</code>,
tests included.</p>"""
write(out, "quality/index.html", page("Code quality", body, 1, "quality/", sha))
# ---- benchmarks + overview -------------------------------------------------------
def build_bench(out: Path, bench: Path | None, sha: str) -> None:
if bench is None or not bench.is_file():
write(out, "bench/index.html", page(
"Benchmarks", "<h1>Benchmarks</h1><p>No benchmark history yet.</p>", 1, "bench/", sha))
return
rendered = bench.read_text(encoding="utf-8")
# The history renderer emits a complete document; keep its body (and its
# own styles) under the site's header.
styles = "".join(re.findall(r"<style[^>]*>.*?</style>", rendered, re.S | re.I))
m = re.search(r"<body[^>]*>(.*)</body>", rendered, re.S | re.I)
inner = m.group(1) if m else rendered
text = page("Benchmarks", inner, 1, "bench/", sha)
write(out, "bench/index.html", text.replace("</head>", styles + "</head>", 1))
def build_index(out: Path, quality: dict | None, sha: str) -> None:
grade = html.escape(str((quality or {}).get("grade", "pending")))
body = f"""<h1>Alkane Toolkit</h1>
<p>Desktop discovery and monitoring for ASIC miners on your network: find every
miner in your IP ranges, see hashrate, power, temperatures, fans and hashboard
health at a glance, and run the controls each firmware supports.</p>
<div class="buttons"><a class="primary" href="{RELEASES}">Download for Windows or Linux</a>
<a href="manual/">Read the manual</a><a href="quality/">Code quality: {grade}</a>
<a href="bench/">Benchmarks</a></div>
<h2>Platforms</h2>
<ul><li><b>Windows 10 and 11</b> (x86_64): one signed, self-contained <code>alkane-toolkit.exe</code>.</li>
<li><b>Linux</b> (x86_64, GTK 3): one binary.</li></ul>
<p>Every release is built, tested and signed by CI from the public source.</p>"""
write(out, "index.html", page("Overview", body, 0, "", sha))
def main() -> None:
ap = argparse.ArgumentParser(description=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
ap.add_argument("--out", required=True)
ap.add_argument("--manual", default="docs/manual")
ap.add_argument("--quality", default=None)
ap.add_argument("--bench", default=None)
ap.add_argument("--sha", default="")
args = ap.parse_args()
out = Path(args.out)
if out.exists():
shutil.rmtree(out)
out.mkdir(parents=True)
quality = None
if args.quality and Path(args.quality).is_file():
quality = json.loads(Path(args.quality).read_text())
if not isinstance(quality, dict) or quality.get("schema") != 1:
raise SystemExit("unsupported quality.json")
(out / "style.css").write_text(CSS.strip() + "\n", encoding="utf-8")
build_index(out, quality, args.sha)
build_manual(out, Path(args.manual), args.sha)
build_quality(out, quality, args.sha)
build_bench(out, Path(args.bench) if args.bench else None, args.sha)
print(f"built {sum(1 for _ in out.rglob('*.html'))} pages in {out}")
if __name__ == "__main__":
main()
+68
View File
@@ -0,0 +1,68 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Keep Toolkit CI on the verified Alkane runner image."""
from pathlib import Path
import re
import sys
import yaml
ROOT = Path(__file__).resolve().parents[1]
IMAGE = (ROOT / "ci/runner-image.txt").read_text().strip()
def main() -> int:
if not re.fullmatch(
r"gitea\.bluefla\.re/blueflare/alkane-ci@sha256:[0-9a-f]{64}", IMAGE
):
print("Runner image must be pinned by Gitea registry digest", file=sys.stderr)
return 1
for path in sorted((ROOT / ".gitea/workflows").glob("*.yml")):
workflow = yaml.load(path.read_text(), Loader=yaml.BaseLoader)
for name, job in workflow.get("jobs", {}).items():
if (job.get("runs-on") in {"alkane-fast", "alkane-pages"}
and "secrets." in str(job)):
print(f"{path.name}: {name} exposes a secret to the fast runner", file=sys.stderr)
return 1
if job.get("runs-on") not in {"alkane-ci", "alkane-fast", "alkane-verify"}:
continue
if job.get("container", {}).get("image") != IMAGE:
print(f"{path.name}: {name} has a different runner image", file=sys.stderr)
return 1
pages = yaml.load(
(ROOT / ".gitea/workflows/pages.yml").read_text(),
Loader=yaml.BaseLoader,
)
if (pages["on"]["workflow_run"]["workflows"] != ["build-test-release"]
or pages["jobs"]["publish"].get("runs-on") != "alkane-verify"):
print("Pages must follow main CI on the trusted verifier", file=sys.stderr)
return 1
release = yaml.load(
(ROOT / ".gitea/workflows/release.yml").read_text(),
Loader=yaml.BaseLoader,
)
if release["jobs"]["release"].get("runs-on") != "alkane-ci":
print("Main release must use the dedicated Alkane build pool", file=sys.stderr)
return 1
if any("ci/publish-pages.py" in step.get("run", "")
for step in release["jobs"]["release"]["steps"]):
print("Main release must not publish Pages from GARM", file=sys.stderr)
return 1
source = yaml.load(
(ROOT / ".gitea/workflows/source.yml").read_text(),
Loader=yaml.BaseLoader,
)
triggers = source["on"]
if (triggers.get("pull_request", {}).get("branches") != ["next"]
or "push" in triggers or "workflow_dispatch" not in triggers):
print("Source checks must not duplicate main pull request verification",
file=sys.stderr)
return 1
print("Toolkit runner image pins: PASS")
return 0
if __name__ == "__main__":
raise SystemExit(main())
+22
View File
@@ -0,0 +1,22 @@
#!/usr/bin/env bash
# SPDX-License-Identifier: MIT
# Avoid a runner-local cache download when the pinned image has this source.
# check-wx-image-prefix.sh [linux|windows]
set -euo pipefail
case "${1:-linux}" in
linux) prefix="${WX_PREFIX:?WX_PREFIX is required}"; library=lib/libwx_gtk3u-3.3.a ;;
windows) prefix="${WX_WINDOWS_PREFIX:?WX_WINDOWS_PREFIX is required}"
library=lib/libwx_mswu-3.3-x86_64-w64-mingw32.a ;;
*) echo "unknown wx platform: $1" >&2; exit 2 ;;
esac
expected="$(awk '$1 == "sha256:" {print $2}' thirdparty/wxwidgets/VERSION)"
[[ "$expected" =~ ^[0-9a-f]{64}$ ]]
available=false
if [ ! -L "$prefix" ] && [ ! -L "$prefix/.alkane-source-sha256" ] &&
[ -x "$prefix/bin/wx-config" ] &&
[ -s "$prefix/$library" ] &&
[ "$(cat "$prefix/.alkane-source-sha256" 2>/dev/null || true)" = "$expected" ]; then
available=true
fi
printf 'available=%s\n' "$available" >> "${GITHUB_OUTPUT:?GITHUB_OUTPUT is required}"
+53
View File
@@ -0,0 +1,53 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Remove generated Toolkit CI work after the release asset is uploaded."""
import os
from pathlib import Path
import shutil
import sys
ROOT = Path(__file__).resolve().parents[1]
DIRECTORIES = ("target", "dist", "coverage", "bench-site", "site")
FILES = ("bench-current.txt", "coverage-summary.txt", "quality.json")
BADGE_FILES = ("bench-baseline.json", "bench-context.json", "quality.json")
def cleanup() -> None:
if not os.environ.get("GITHUB_RUN_ID"):
raise ValueError("cleanup is restricted to CI runs")
for name in DIRECTORIES:
path = ROOT / name
if path.is_symlink() or path.parent.resolve() != ROOT.resolve():
raise ValueError(f"unsafe generated directory: {path}")
if path.is_dir():
shutil.rmtree(path)
print(f"Removed generated directory: {name}")
elif path.exists():
raise ValueError(f"expected a generated directory: {path}")
for name in FILES:
path = ROOT / name
if path.is_symlink() or path.parent.resolve() != ROOT.resolve():
raise ValueError(f"unsafe generated file: {path}")
if path.is_file():
path.unlink()
print(f"Removed generated file: {name}")
badge_dir = ROOT / "badges"
if badge_dir.is_symlink():
raise ValueError("unsafe generated badge directory")
for name in BADGE_FILES:
path = badge_dir / name
if path.is_symlink() or path.parent.resolve() != badge_dir.resolve():
raise ValueError(f"unsafe generated badge file: {path}")
if path.is_file():
path.unlink()
print(f"Removed generated badge file: {name}")
if __name__ == "__main__":
try:
cleanup()
except (OSError, ValueError) as error:
print(f"ERROR: Toolkit cleanup: {error}", file=sys.stderr)
raise SystemExit(1)
+15
View File
@@ -0,0 +1,15 @@
#!/usr/bin/env bash
# Convert the next final version into a monotonically numbered prerelease.
set -euo pipefail
result="$(bash ci/compute-version.sh)"
release="$(printf '%s\n' "$result" | sed -n 's/^release=//p')"
if [ "$release" != true ]; then
echo "release=false"
exit 0
fi
version="$(printf '%s\n' "$result" | sed -n 's/^version=//p')"
last="$(git tag -l "v${version}-rc.*" | sed -n "s/^v${version//./\.}-rc\.\([0-9][0-9]*\)$/\1/p" | sort -n | tail -1)"
next=$(( ${last:-0} + 1 ))
echo "release=true"
echo "version=${version}-rc.${next}"
echo "tag=v${version}-rc.${next}"
+17 -8
View File
@@ -2,9 +2,10 @@
# Compute the next release version for alkane-toolkit from the latest release
# tag and the paths changed since it. Version scheme X.Y.Z:
# X - major, bumped manually (ci/version-x.txt); a bump resets Y.Z to 0.0
# Y - backend-logic changes (core/discovery/access/flash/artifacts/cli,
# scan+model+main in the GUI crate, build/CI config); resets Z to 0
# Z - UI changes (the GUI view + fixtures + the wx-rs widget bridge)
# Y - backend-logic changes (the alkane-* crates and any GUI crate source
# other than the view files below, plus vendored deps and build/CI config);
# resets Z to 0
# Z - UI changes (the GUI view: ui.rs + fixtures.rs + bin/ + the wx-rs bridge)
# When both backend and UI changed, backend wins (bump Y). Docs-only changes
# produce no release.
#
@@ -17,7 +18,7 @@ X=0
[ -f "$x_file" ] && X=$(tr -dc '0-9' < "$x_file")
X=${X:-0}
last=$(git tag -l 'v*.*.*' | sort -V | tail -1 || true)
last=$(git tag -l 'v*.*.*' | grep -E '^v[0-9]+\.[0-9]+\.[0-9]+$' | sort -V | tail -1 || true)
if [ -n "$last" ]; then
v=${last#v}; lx=${v%%.*}; rest=${v#*.}; ly=${rest%%.*}; lz=${rest##*.}
changed=$(git diff --name-only "$last"..HEAD)
@@ -30,14 +31,22 @@ ui=false; backend=false
while IFS= read -r f; do
[ -z "$f" ] && continue
case "$f" in
crates/alkane-gui/src/ui.rs|crates/alkane-gui/src/fixtures.rs|thirdparty/wx-rs/*)
crates/alkane-gui/src/ui.rs|crates/alkane-gui/src/fixtures.rs|thirdparty/wx-rs/*|\
crates/alkane-gui/src/bin/*)
ui=true ;;
crates/alkane-core/*|crates/alkane-discovery/*|crates/alkane-access/*|\
crates/alkane-flash/*|crates/alkane-artifacts/*|crates/alkane-cli/*|\
crates/alkane-gui/src/scan.rs|crates/alkane-gui/src/model.rs|\
crates/alkane-gui/src/main.rs|Cargo.toml|Cargo.lock|.gitea/*|ci/*|scripts/*)
crates/alkane-gui/src/*|crates/alkane-gui/Cargo.toml|crates/alkane-gui/build.rs|\
crates/alkane-gui/windows/*|crates/alkane-gui/assets/*|\
Cargo.toml|Cargo.lock|.gitea/*|ci/*|scripts/*|\
vendor/*|thirdparty/asic-rs/*)
# Any other GUI source file (naming, scan, model, pool_prefs, restore,
# access_probe, credentials, ...) is backend logic, as is how the binary
# is built and packaged (build.rs, the Windows manifest/icon/version
# resources, embedded assets). ui.rs/fixtures.rs/bin
# match the UI arm above first, so they still bump Z, not Y.
backend=true ;;
*) : ;; # docs, HANDOFF, README, thirdparty/wxwidgets tree: no bump
*) : ;; # docs, README, thirdparty/wxwidgets tree: no bump
esac
done <<< "$changed"
+37
View File
@@ -0,0 +1,37 @@
#!/usr/bin/env bash
# SPDX-License-Identifier: MIT
# Reuse Rust compiler results on persistent CI runners.
set -euo pipefail
[ "$(sccache --version)" = 'sccache 0.18.0' ] || {
echo 'CI image has an unexpected sccache version' >&2
exit 1
}
toolcache="${RUNNER_TOOL_CACHE:-}"
if [ -z "$toolcache" ] || [ -L "$toolcache" ] ||
[ ! -d "$toolcache" ] || [ ! -w "$toolcache" ]; then
echo 'Persistent runner tool cache is unavailable; compiling without sccache'
exit 0
fi
cache_dir="$toolcache/alkane-toolkit-rust-sccache"
if [ -L "$cache_dir" ]; then
echo 'Rust cache path is a symlink' >&2
exit 1
fi
umask 077
mkdir -p "$cache_dir"
if [ ! -d "$cache_dir" ] || [ ! -w "$cache_dir" ]; then
echo 'Rust cache directory is unavailable' >&2
exit 1
fi
chmod 0700 "$cache_dir"
{
printf 'RUSTC_WRAPPER=%s\n' "$(command -v sccache)"
printf 'SCCACHE_DIR=%s\n' "$cache_dir"
printf 'SCCACHE_CACHE_SIZE=2G\n'
printf 'CARGO_INCREMENTAL=0\n'
} >> "${GITHUB_ENV:?GITHUB_ENV is required}"
echo 'Bounded Rust compiler cache configured for Alkane Toolkit'
+40
View File
@@ -0,0 +1,40 @@
#!/usr/bin/env bash
# Measure line coverage from BOTH the unit tests AND the headless UI self-test.
#
# The self-test (ALKANE_SELFTEST=1) builds the real wxWidgets table, renders every
# fixture through the real widgets, and checks each cell against the model.
# It covers the fixture-rendering path, while interactive event handlers need
# separate tests. Because it runs as a separate binary invocation, a plain
# `cargo llvm-cov` (which only runs the #[test]s) never counts it. This
# combines both runs' coverage.
#
# Usage: ci/coverage.sh [extra `cargo llvm-cov report` args, e.g. --summary-only]
set -euo pipefail
export WX_RS_WXCONFIG="${WX_RS_WXCONFIG:-$HOME/.cache/wx-3.3.3-linux/bin/wx-config}"
# The dependency tree is fully vendored, so the instrumented builds run offline by
# default; override with CARGO_LLVM_COV_FLAGS if you need something else.
read -ra CARGO_FLAGS <<<"${CARGO_LLVM_COV_FLAGS:---offline}"
# A display is required for the self-test; skipping it would publish an
# incomplete coverage number as if the measured test set had run.
if ! command -v xvfb-run >/dev/null 2>&1; then
echo "coverage.sh: xvfb-run is required for the UI self-test" >&2
exit 1
fi
cargo llvm-cov clean --workspace
# 1. Unit tests for the GUI and all first-party headless crates.
cargo llvm-cov --no-report "${CARGO_FLAGS[@]}" -p alkane-gui --bin alkane-toolkit
cargo llvm-cov --no-report "${CARGO_FLAGS[@]}" \
--workspace --exclude alkane-gui --exclude wx-rs
# 2. Headless UI self-test, under the same instrumentation, its coverage appended.
xvfb-run -a env GDK_BACKEND=x11 ALKANE_SELFTEST=1 \
cargo llvm-cov run --no-report "${CARGO_FLAGS[@]}" --bin alkane-toolkit
# 3. Merged report, our source only (vendored asic-rs + the patched wx-rs bridge
# are out of scope).
cargo llvm-cov report --ignore-filename-regex '(thirdparty|vendor)/' "$@"
+35
View File
@@ -0,0 +1,35 @@
#!/usr/bin/env bash
# SPDX-License-Identifier: MIT
# Use the preinstalled CI image or install missing packages on older runners.
set -euo pipefail
mode="${1:?usage: ensure-build-deps.sh base|ui|all|ssh|windows|pages}"
case "$mode" in
base) packages=(libssl-dev pkg-config ca-certificates) ;;
ui) packages=(xvfb xauth dbus-x11 fonts-dejavu-core) ;;
ssh) packages=(openssh-client) ;;
pages) packages=(python3-markdown) ;;
all) packages=(libssl-dev pkg-config ca-certificates openssh-client
xvfb xauth dbus-x11 fonts-dejavu-core) ;;
# Windows cross build (mingw-w64, posix threads) + Wine for its tests.
windows) packages=(libssl-dev pkg-config ca-certificates
gcc-mingw-w64-x86-64-posix g++-mingw-w64-x86-64-posix
binutils-mingw-w64-x86-64 mingw-w64-x86-64-dev wine wine64 xvfb xauth
openjdk-21-jre-headless) ;;
*) echo "unknown dependency set: $mode" >&2; exit 2 ;;
esac
installed="$(dpkg-query -W -f='${Package} ${Status}\n' "${packages[@]}" 2>/dev/null || true)"
missing=()
for package in "${packages[@]}"; do
if ! grep -Fxq "$package install ok installed" <<< "$installed"; then
missing+=("$package")
fi
done
if [ "${#missing[@]}" -eq 0 ]; then
printf 'Build packages already installed: %s\n' "$mode"
exit 0
fi
printf 'Installing %s missing build packages\n' "${#missing[@]}"
apt-get update -qq
DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends "${packages[@]}"
+58
View File
@@ -0,0 +1,58 @@
#!/usr/bin/env bash
# SPDX-License-Identifier: MIT
# Use the matching image or cache prefix; rebuild after a vendored source bump.
# ensure-wx-prefix.sh [linux|windows] (default linux: wxGTK in $WX_PREFIX;
# windows: the mingw wxMSW prefix in $WX_WINDOWS_PREFIX)
set -euo pipefail
platform="${1:-linux}"
case "$platform" in
linux)
prefix="${WX_PREFIX:?WX_PREFIX is required}"
allowed=/root/.cache/wx-3.3.3-linux
library=lib/libwx_gtk3u-3.3.a
build=scripts/build-wx-linux.sh ;;
windows)
prefix="${WX_WINDOWS_PREFIX:?WX_WINDOWS_PREFIX is required}"
allowed=/root/.cache/wx-3.3.3-mingw
library=lib/libwx_mswu-3.3-x86_64-w64-mingw32.a
build=scripts/build-wx-windows.sh ;;
*) echo "unknown wx platform: $platform" >&2; exit 2 ;;
esac
if [ -L "$prefix" ] || [ -L "$prefix/.alkane-source-sha256" ]; then
echo 'refusing symlinked wxWidgets prefix or source marker' >&2
exit 1
fi
expected="$(awk '$1 == "sha256:" {print $2}' thirdparty/wxwidgets/VERSION)"
[[ "$expected" =~ ^[0-9a-f]{64}$ ]] || {
echo 'invalid pinned wxWidgets source digest' >&2
exit 1
}
marker="$prefix/.alkane-source-sha256"
if [ -e "$marker" ] && [ "$(cat "$marker")" != "$expected" ]; then
python3 - "$prefix" "$allowed" <<'PY'
from pathlib import Path
import shutil
import sys
prefix = Path(sys.argv[1])
allowed = Path(sys.argv[2])
if prefix != allowed or prefix.is_symlink():
raise SystemExit('refusing unsafe wxWidgets prefix reset')
if prefix.is_dir():
shutil.rmtree(prefix)
PY
fi
built=false
if [ ! -x "$prefix/bin/wx-config" ] ||
[ ! -s "$prefix/$library" ]; then
WX_WINDOWS_PREFIX="$prefix" sh "$build"
built=true
else
echo 'wx prefix available from matching image or cache'
fi
[ -s "$prefix/$library" ]
printf '%s\n' "$expected" > "$marker"
if [ -n "${GITHUB_OUTPUT:-}" ]; then
printf 'built=%s\n' "$built" >> "$GITHUB_OUTPUT"
fi
+41
View File
@@ -0,0 +1,41 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Download the measured quality record (badges/quality.json on ci-badges).
fetch-quality.py OUT.json
Writes nothing (and exits 0) when main CI has not published one yet, so the
Pages build shows a "not measured yet" dashboard instead of failing.
"""
import base64
import json
import os
from pathlib import Path
import sys
from urllib.error import HTTPError
from urllib.request import Request, urlopen
def main() -> None:
out = Path(sys.argv[1])
api = os.environ["GITHUB_API_URL"].rstrip("/")
repo = os.environ["GITHUB_REPOSITORY"]
url = f"{api}/repos/{repo}/contents/badges/quality.json?ref=ci-badges"
request = Request(url, headers={"Authorization": f"token {os.environ['GITEA_TOKEN']}"})
try:
with urlopen(request, timeout=20) as response:
content = base64.b64decode(json.load(response)["content"])
except HTTPError as error:
if error.code == 404:
print("No quality record published yet")
return
raise
if not isinstance(json.loads(content), dict):
sys.exit("invalid quality record")
out.write_bytes(content)
print(f"Fetched quality record ({len(content)} bytes)")
if __name__ == "__main__":
main()
+330
View File
@@ -0,0 +1,330 @@
#!/usr/bin/env python3
"""Generate self-contained shields-style SVG badges into badges/.
Main CI regenerates SVGs from measured metrics and publishes them to the
private ci-badges branch. The README loads those authenticated raw artifacts.
Usage:
gen-badges.py --tests N --coverage PCT --bench "label" [--out badges]
Metrics not passed on the command line are computed here (LOC from the source
tree, dependency count from Cargo.lock, license from Cargo.toml).
"""
import argparse
import json
import math
import os
from pathlib import Path
import re
import sys
# Approximate per-character width at 11px DejaVu Sans, in 1/10 px, matching the
# shields "flat" look closely enough for a fixed-width monospace-ish render.
CHAR_W = 6.5
PAD = 6.0
COLORS = {
"green": "#4c1",
"brightgreen": "#4c1",
"yellowgreen": "#a4a61d",
"yellow": "#dfb317",
"orange": "#fe7d37",
"red": "#e05d44",
"blue": "#007ec6",
"lightgrey": "#9f9f9f",
"grey": "#555",
}
def text_width(s: str) -> float:
return len(s) * CHAR_W + 2 * PAD
def badge_svg(label: str, message: str, color: str,
description: str | None = None) -> str:
color = COLORS.get(color, color)
lw = round(text_width(label), 1)
mw = round(text_width(message), 1)
total = round(lw + mw, 1)
lx = round(lw / 2, 1)
mx = round(lw + mw / 2, 1)
# Text is drawn twice (a dark shadow then the light glyphs) for the shields look.
description = description or f"{label}: {message}"
return f'''<svg xmlns="http://www.w3.org/2000/svg" width="{total}" height="20" role="img" aria-label="{description}">
<title>{description}</title>
<linearGradient id="s" x2="0" y2="100%">
<stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
<stop offset="1" stop-opacity=".1"/>
</linearGradient>
<clipPath id="r"><rect width="{total}" height="20" rx="3" fill="#fff"/></clipPath>
<g clip-path="url(#r)">
<rect width="{lw}" height="20" fill="#555"/>
<rect x="{lw}" width="{mw}" height="20" fill="{color}"/>
<rect width="{total}" height="20" fill="url(#s)"/>
</g>
<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
<text x="{lx}" y="15" fill="#010101" fill-opacity=".3">{label}</text>
<text x="{lx}" y="14">{label}</text>
<text x="{mx}" y="15" fill="#010101" fill-opacity=".3">{message}</text>
<text x="{mx}" y="14">{message}</text>
</g>
</svg>
'''
def count_loc(root: str) -> int:
total = 0
for base in ("crates",):
for dirpath, _dirs, files in os.walk(os.path.join(root, base)):
for f in files:
if f.endswith(".rs"):
try:
with open(os.path.join(dirpath, f), encoding="utf-8", errors="ignore") as fh:
total += sum(1 for _ in fh)
except OSError:
pass
return total
def count_deps(root: str) -> int:
lock = os.path.join(root, "Cargo.lock")
try:
with open(lock, encoding="utf-8") as fh:
return sum(1 for line in fh if line.startswith("name = "))
except OSError:
return 0
def read_license(root: str) -> str:
try:
with open(os.path.join(root, "Cargo.toml"), encoding="utf-8") as fh:
for line in fh:
m = re.match(r'\s*license\s*=\s*"([^"]+)"', line)
if m:
return m.group(1)
except OSError:
pass
return "unknown"
def loc_color(n: int) -> str:
return "blue"
def bench_color(delta_pct: float) -> str:
# Positive delta means faster than the previous release. A +/-2% band
# absorbs run-to-run jitter on the dedicated CI runner.
if delta_pct >= 2.0:
return "brightgreen"
if delta_pct > -2.0:
return "blue"
if delta_pct > -10.0:
return "yellow"
return "orange"
def cov_color(pct: float) -> str:
if pct >= 80:
return "brightgreen"
if pct >= 60:
return "yellowgreen"
if pct >= 40:
return "yellow"
if pct >= 20:
return "orange"
return "red"
# Code-quality grade (shown on the badge and explained on the Pages quality
# dashboard). Lint failures fail the grade outright; otherwise the grade is the
# measured line-coverage band, using the same bands as the coverage badge
# colour, so the two badges can never disagree.
GRADE_BANDS = ((80.0, "A"), (60.0, "B"), (40.0, "C"), (20.0, "D"))
GRADE_COLORS = {"A": "brightgreen", "B": "yellowgreen", "C": "yellow",
"D": "orange", "F": "red", "pending": "lightgrey"}
def quality_grade(clippy: str | None, coverage: float | None = None) -> str:
if clippy is None or (clippy == "clean" and coverage is None):
return "pending"
if clippy != "clean":
return "F"
for floor, grade in GRADE_BANDS:
if coverage >= floor:
return grade
return "F"
def coverage_by_file(summary_path: str | None, root: str) -> list[dict]:
"""Per-file line coverage from a `cargo llvm-cov --summary-only` table.
Columns: Filename, Regions, Missed Regions, Cover, Functions, Missed
Functions, Executed, Lines, Missed Lines, Cover, ...
"""
if not summary_path:
return []
rows = []
root_abs = os.path.abspath(root).rstrip("/") + "/"
for line in Path(summary_path).read_text(errors="replace").splitlines():
cols = line.split()
if len(cols) < 10 or cols[0] in ("Filename", "TOTAL") or not cols[0].endswith(".rs"):
continue
try:
lines, missed = int(cols[7]), int(cols[8])
except ValueError:
continue
name = cols[0][len(root_abs):] if cols[0].startswith(root_abs) else cols[0]
# llvm-cov drops the prefix every file shares, so when only workspace
# crates are measured "crates/alkane-gui/src/x.rs" is printed as
# "alkane-gui/src/x.rs". Put the prefix back.
first = Path(name).parts[0] if Path(name).parts else ""
if not name.startswith("crates/") and (Path(root) / "crates" / first).is_dir():
name = f"crates/{name}"
rows.append({"file": name, "lines": lines, "missed": missed})
return rows
def crate_of(path: str) -> str:
parts = Path(path).parts
if "crates" in parts and parts.index("crates") + 1 < len(parts):
return parts[parts.index("crates") + 1]
if "wx-rs-0.2.0-patched" in parts:
return "wx-rs (bridge)"
return "other"
def loc_by_crate(root: str) -> dict[str, int]:
out: dict[str, int] = {}
crates = Path(root) / "crates"
for path in sorted(crates.glob("*/**/*.rs")):
crate = path.relative_to(crates).parts[0]
with open(path, encoding="utf-8", errors="ignore") as fh:
out[crate] = out.get(crate, 0) + sum(1 for _ in fh)
return out
def human(n: int) -> str:
suffixes = ("", "K", "M", "G")
value = float(n)
index = 0
while value >= 999.5 and index < len(suffixes) - 1:
value /= 1000
index += 1
if value >= 100:
number = f"{value:.0f}"
elif value >= 10:
number = f"{value:.1f}".rstrip("0").rstrip(".")
else:
number = f"{value:.2f}".rstrip("0").rstrip(".")
return number + suffixes[index]
def main() -> int:
ap = argparse.ArgumentParser()
ap.add_argument("--out", default="badges")
ap.add_argument("--root", default=".")
ap.add_argument("--tests", type=int, default=None)
ap.add_argument("--coverage", type=float, default=None)
ap.add_argument("--bench-coverage", type=float, default=None)
ap.add_argument("--bench", default=None)
# Mean per-benchmark improvement vs the previous release, as a signed
# percentage string, or "NEW" when there is no baseline.
ap.add_argument("--bench-delta", default=None)
ap.add_argument("--clippy", choices=("clean", "failed"))
# The full `cargo llvm-cov --summary-only` table, for the per-crate and
# per-file breakdown in quality.json (the Pages quality dashboard).
ap.add_argument("--coverage-summary", default=None)
args = ap.parse_args()
for value in (args.coverage, args.bench_coverage):
if value is not None and (not math.isfinite(value) or not 0 <= value <= 100):
ap.error("coverage must be a finite percentage between 0 and 100")
os.makedirs(os.path.join(args.root, args.out), exist_ok=True)
def write(name, label, message, color, description=None):
path = os.path.join(args.root, args.out, name + ".svg")
with open(path, "w", encoding="utf-8") as fh:
fh.write(badge_svg(label, message, color, description))
print(f"wrote {path}: {label}={message}")
loc = count_loc(args.root)
deps = count_deps(args.root)
lic = read_license(args.root)
write("loc", "lines of code", human(loc), loc_color(loc))
write("license", "license", lic, "blue")
write("dependencies", "dependencies", str(deps), "blue")
grade = quality_grade(args.clippy, args.coverage)
write("quality", "code quality", grade, GRADE_COLORS[grade],
f"code quality: {grade} (Clippy, rustfmt and line coverage)")
if args.tests is not None:
write("tests", "tests", f"{args.tests} passing", "brightgreen")
if args.coverage is not None:
write("coverage", "coverage", f"{args.coverage:.0f}%", cov_color(args.coverage))
write("bench-coverage", "bench coverage",
f"{args.bench_coverage:.0f}%" if args.bench_coverage is not None else "pending",
cov_color(args.bench_coverage) if args.bench_coverage is not None else "lightgrey")
context_path = Path(args.root) / args.out / "bench-context.json"
same_inputs = False
if context_path.is_file():
context = json.loads(context_path.read_text())
if (not isinstance(context, dict) or context.get("schema") != 1 or
not isinstance(context.get("same_inputs"), bool)):
raise ValueError("invalid benchmark comparison context")
same_inputs = context["same_inputs"]
# Bench badge: prefer the mean per-benchmark improvement vs the previous
# release. Use the static label when no comparison is available.
delta = None
if args.bench_delta not in (None, "", "NEW"):
try:
delta = float(args.bench_delta)
except ValueError:
delta = None
if delta is not None:
# Positive = faster than the previous release.
msg = f"{'+' if delta > 0 else ''}{delta:.1f}%"
if same_inputs:
write("bench", "bench", msg + " same inputs", "lightgrey")
else:
write("bench", "bench", msg + " vs prev", bench_color(delta))
elif args.bench_delta == "NEW":
write("bench", "bench", "baseline set", "blue")
elif args.bench is not None:
write("bench", "bench", args.bench, "blue")
# Everything above, plus the per-crate breakdowns, for the Pages quality
# dashboard (ci/build-pages.py).
files = coverage_by_file(args.coverage_summary, args.root)
crates: dict[str, dict] = {}
for row in files:
c = crates.setdefault(crate_of(row["file"]), {"lines": 0, "missed": 0})
c["lines"] += row["lines"]
c["missed"] += row["missed"]
quality = {
"schema": 1,
"sha": os.environ.get("GITHUB_SHA", ""),
"grade": grade,
"grade_bands": [[floor, letter] for floor, letter in GRADE_BANDS],
"clippy": args.clippy,
"rustfmt": "clean" if args.clippy is not None else None,
"tests_passed": args.tests,
"coverage_pct": args.coverage,
"bench_coverage_pct": args.bench_coverage,
"bench_delta_pct": delta,
"bench_same_inputs": same_inputs,
"loc": loc,
"loc_by_crate": loc_by_crate(args.root),
"dependencies": deps,
"license": lic,
"coverage_by_crate": crates,
"coverage_by_file": files,
}
path = os.path.join(args.root, args.out, "quality.json")
with open(path, "w", encoding="utf-8") as fh:
json.dump(quality, fh, indent=1, sort_keys=True)
print(f"wrote {path}")
return 0
if __name__ == "__main__":
sys.exit(main())
+59
View File
@@ -0,0 +1,59 @@
# syntax=docker/dockerfile:1
# Alkane Toolkit CI image (ci/runner-image.txt pins the pushed digest).
#
# Layered on the previously verified image, so every Linux job keeps exactly
# the toolchain it had (Rust 1.97.1, prebuilt wxGTK prefix, sccache,
# cargo-llvm-cov), and adds what the Windows jobs need:
# - mingw-w64 (posix threads) and the rustup target x86_64-pc-windows-gnu
# - a prebuilt static wxMSW 3.3.3 prefix, built from the vendored source by
# scripts/build-wx-windows.sh and stamped with the source digest the same
# way as the wxGTK prefix (ci/ensure-wx-prefix.sh rebuilds on a mismatch)
# - Wine with an initialised prefix, to run the Windows tests and self-test
# - a Java runtime and jsign (checksum-pinned), to Authenticode-sign the .exe
# through Azure Artifact Signing (ci/sign-windows.sh)
#
# Build and push from the workstation with ci/images/build-image.sh.
ARG BASE=gitea.bluefla.re/blueflare/alkane-ci@sha256:9d2a992bbcb91014af3c85d2e1ec8c5990701cecf83fd06c8d46f9ef13dbd948
FROM ${BASE}
RUN DEBIAN_FRONTEND=noninteractive apt-get update -qq \
&& DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends \
gcc-mingw-w64-x86-64-posix g++-mingw-w64-x86-64-posix \
binutils-mingw-w64-x86-64 mingw-w64-x86-64-dev \
wine wine64 xvfb xauth openjdk-21-jre-headless \
&& rm -rf /var/lib/apt/lists/*
# jsign (Maven Central net.jsign:jsign; keep in step with ci/windows-ci.sh).
ARG JSIGN_VERSION=7.6
ARG JSIGN_SHA256=6cf58aa080e7ff82656f320cff8d4a3bff30408df8766806dcba3740dd839fa5
RUN mkdir -p /opt/jsign \
&& curl -sSfL -o /opt/jsign/jsign.jar \
"https://repo1.maven.org/maven2/net/jsign/jsign/${JSIGN_VERSION}/jsign-${JSIGN_VERSION}.jar" \
&& echo "${JSIGN_SHA256} /opt/jsign/jsign.jar" | sha256sum -c - \
&& java -jar /opt/jsign/jsign.jar --help >/dev/null
RUN rustup target add x86_64-pc-windows-gnu
# The build context is the repository root, filtered by
# alkane-ci.Dockerfile.dockerignore down to the wx source and its build script.
COPY thirdparty/wxwidgets /tmp/alkane/thirdparty/wxwidgets
COPY scripts/build-wx-windows.sh /tmp/alkane/scripts/build-wx-windows.sh
RUN HOME=/root WX_WINDOWS_PREFIX=/root/.cache/wx-3.3.3-mingw \
sh /tmp/alkane/scripts/build-wx-windows.sh \
&& awk '$1 == "sha256:" {print $2}' /tmp/alkane/thirdparty/wxwidgets/VERSION \
> /root/.cache/wx-3.3.3-mingw/.alkane-source-sha256 \
&& rm -rf /tmp/alkane
# A ready Wine prefix saves ~10 s per job (scripts/wine-run.sh reuses it).
RUN WINEPREFIX=/root/.cache/alkane-wine WINEDEBUG=-all \
WINEDLLOVERRIDES='winemenubuilder.exe=d;mscoree=d;mshtml=d' \
sh -c 'wineboot --init; wineboot --shutdown; wineserver -w' >/dev/null 2>&1; \
test -f /root/.cache/alkane-wine/system.reg
RUN test -s /root/.cache/wx-3.3.3-mingw/lib/libwx_mswu-3.3-x86_64-w64-mingw32.a \
&& test "$(/root/.cache/wx-3.3.3-mingw/bin/wx-config --version)" = 3.3.3 \
&& test -s /root/.cache/wx-3.3.3-linux/lib/libwx_gtk3u-3.3.a \
&& x86_64-w64-mingw32-g++-posix --version >/dev/null \
&& wine --version \
&& test -s /opt/jsign/jsign.jar \
&& rustup target list --installed | grep -qx x86_64-pc-windows-gnu
@@ -0,0 +1,4 @@
# Only what the image build copies: the vendored wx tree and its build script.
*
!thirdparty/wxwidgets/**
!scripts/build-wx-windows.sh
+39
View File
@@ -0,0 +1,39 @@
#!/bin/sh
# Build the CI image from ci/images/alkane-ci.Dockerfile, push it to the Gitea
# registry, and pin the pushed digest in ci/runner-image.txt and every
# workflow (ci/check-runner-image.py enforces the pin).
#
# Run on the workstation, which holds the registry credential; it is passed to
# a throwaway Docker config that is deleted afterwards, never to a runner.
# ci/images/build-image.sh TAG e.g. ci/images/build-image.sh windows-2026-11-02
set -eu
TAG=${1:?usage: build-image.sh TAG}
REPO=$(CDPATH= cd -- "$(dirname -- "$0")/../.." && pwd)
REGISTRY=gitea.bluefla.re
IMAGE=$REGISTRY/blueflare/alkane-ci
TOKEN_FILE=${GITEA_TOKEN_FILE:-$HOME/.config/gitea/token}
cd "$REPO"
DOCKER_CONFIG=$(mktemp -d)
export DOCKER_CONFIG
trap 'rm -rf "$DOCKER_CONFIG"' 0
user=$(curl -sS --config - "https://$REGISTRY/api/v1/user" <<CFG | python3 -c 'import json,sys; print(json.load(sys.stdin)["login"])'
header = "Authorization: token $(cat "$TOKEN_FILE")"
CFG
)
docker login "$REGISTRY" -u "$user" --password-stdin < "$TOKEN_FILE" >/dev/null
DOCKER_BUILDKIT=1 docker build -f ci/images/alkane-ci.Dockerfile -t "$IMAGE:$TAG" .
docker push "$IMAGE:$TAG" >/dev/null
digest=$(docker inspect --format '{{range .RepoDigests}}{{println .}}{{end}}' "$IMAGE:$TAG" \
| grep "^$IMAGE@sha256:" | head -1)
[ -n "$digest" ] || { echo "no registry digest for $IMAGE:$TAG" >&2; exit 1; }
old=$(cat ci/runner-image.txt)
printf '%s\n' "$digest" > ci/runner-image.txt
grep -rl "$old" .gitea/workflows | while read -r f; do
python3 - "$f" "$old" "$digest" <<'PY'
import pathlib, sys
p, old, new = pathlib.Path(sys.argv[1]), sys.argv[2], sys.argv[3]
p.write_text(p.read_text().replace(old, new))
PY
done
python3 ci/check-runner-image.py
echo "pinned $digest"
+115
View File
@@ -0,0 +1,115 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Publish the last completed main/next CI result to a private badge branch."""
import base64
import json
import os
from pathlib import Path
from urllib.error import HTTPError
from urllib.parse import quote, urlencode
from urllib.request import Request, urlopen
WORKFLOWS = {"release.yml": "main", "next.yml": "next"}
BADGE_BRANCH = "ci-badges"
def badge(branch: str, conclusion: str, run_id: int) -> bytes:
passed = conclusion == "success"
word = "pass" if passed else "fail"
color = "#2ea043" if passed else "#d1242f"
title = f"CI {branch}: last completed attempt {word} (run {run_id})"
return (f'<svg xmlns="http://www.w3.org/2000/svg" width="102" height="20" '
f'role="img" aria-label="{title}"><title>{title}</title>'
'<rect width="102" height="20" rx="3" fill="#555"/>'
f'<path d="M39 0h60a3 3 0 0 1 3 3v14a3 3 0 0 1-3 3H39z" fill="{color}"/>'
'<text x="20" y="14" fill="#fff" text-anchor="middle" '
'font-family="sans-serif" font-size="11">CI</text>'
f'<text x="70" y="14" fill="#fff" text-anchor="middle" '
f'font-family="sans-serif" font-size="11">{word}</text></svg>\n').encode()
def request_json(url: str, token: str, method: str = "GET",
payload: dict | None = None) -> dict:
body = None if payload is None else json.dumps(payload).encode()
request = Request(url, data=body, method=method,
headers={"Authorization": f"token {token}",
"Content-Type": "application/json"})
with urlopen(request, timeout=20) as response:
return json.load(response)
def latest_completed(api: str, repo: str, workflow: str, branch: str,
token: str) -> tuple[int, str]:
path = quote(workflow, safe="")
latest = None
for page in range(1, 21):
query = urlencode({"branch": branch, "limit": 50, "page": page})
url = f"{api}/repos/{repo}/actions/workflows/{path}/runs?{query}"
runs = request_json(url, token).get("workflow_runs", [])
for run in runs:
if run.get("head_branch") != branch or run.get("status") != "completed":
continue
if run.get("conclusion") not in ("success", "failure"):
continue
candidate = (int(run["id"]), run["conclusion"])
if latest is None or candidate[0] > latest[0]:
latest = candidate
if len(runs) < 50:
break
if latest is None:
raise RuntimeError(f"no completed {branch} run found for {workflow}")
return latest
def publish(api: str, repo: str, branch: str, data: bytes, token: str) -> None:
path = f"{api}/repos/{repo}/contents/{branch}.svg"
encoded = base64.b64encode(data).decode("ascii")
for attempt in range(3):
try:
current = request_json(path + "?ref=" + BADGE_BRANCH, token)
current_data = base64.b64decode(current["content"])
if current_data == data:
return
sha = current["sha"]
method = "PUT"
except HTTPError as error:
if error.code != 404:
raise
sha = None
method = "POST"
payload = {"branch": BADGE_BRANCH, "content": encoded,
"message": f"Record completed {branch} CI attempt"}
if sha is not None:
payload["sha"] = sha
try:
request_json(path, token, method, payload)
return
except HTTPError as error:
if error.code not in (409, 422) or attempt == 2:
raise
raise RuntimeError("badge write did not complete")
def main() -> None:
event = json.loads(Path(os.environ["GITHUB_EVENT_PATH"]).read_text())
if event.get("action") != "completed":
raise RuntimeError("expected a completed workflow_run event")
run = event["workflow_run"]
workflow = run["path"].split("@", 1)[0].rsplit("/", 1)[-1]
expected_branch = WORKFLOWS.get(workflow)
if expected_branch is None or run.get("head_branch") != expected_branch:
raise RuntimeError("unexpected workflow or branch")
repo = os.environ["GITHUB_REPOSITORY"]
if event["repository"]["full_name"] != repo:
raise RuntimeError("repository mismatch")
api = os.environ["GITHUB_API_URL"].rstrip("/")
token = os.environ["GITEA_TOKEN"]
run_id, conclusion = latest_completed(api, repo, workflow, expected_branch, token)
publish(api, repo, expected_branch, badge(expected_branch, conclusion, run_id), token)
print(f"{expected_branch} badge records completed run {run_id}: {conclusion}")
if __name__ == "__main__":
main()
+109
View File
@@ -0,0 +1,109 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Package the universal macOS build as an app bundle, for release.
package-macos.py VERSION BINARY OUT_DIR
BINARY is the universal (arm64 + x86_64) alkane-toolkit executable made by
scripts/build-gui-macos.sh. Writes
dist/alkane-toolkit-vVERSION-macos-universal.zip holding "Alkane Toolkit.app",
LICENSE and README.txt, and prints its path. Runs on macOS (lipo, codesign,
ditto).
The bundle is ad-hoc signed only (Apple Silicon refuses to run unsigned
code); it is not signed with a Developer ID or notarized, so Gatekeeper asks
the user to confirm the first launch. README.txt says how.
"""
import pathlib
import plistlib
import shutil
import subprocess
import sys
import tempfile
ROOT = pathlib.Path(__file__).resolve().parents[1]
APP = "Alkane Toolkit.app"
BUNDLE_ID = "re.bluefla.alkane-toolkit"
MIN_MACOS = "11.0"
def run(*args: str) -> str:
return subprocess.run(args, check=True, capture_output=True, text=True).stdout
def build_app(version: str, binary: pathlib.Path, dest: pathlib.Path) -> pathlib.Path:
archs = run("lipo", "-archs", str(binary)).split()
if sorted(archs) != ["arm64", "x86_64"]:
sys.exit(f"{binary} is not a universal arm64 + x86_64 binary: {archs}")
app = dest / APP
macos = app / "Contents" / "MacOS"
resources = app / "Contents" / "Resources"
macos.mkdir(parents=True)
resources.mkdir()
shutil.copy2(binary, macos / "alkane-toolkit")
shutil.copy2(ROOT / "crates/alkane-gui/macos/alkane-toolkit.icns", resources)
info = {
"CFBundleName": "Alkane Toolkit",
"CFBundleDisplayName": "Alkane Toolkit",
"CFBundleIdentifier": BUNDLE_ID,
"CFBundleExecutable": "alkane-toolkit",
"CFBundleIconFile": "alkane-toolkit",
"CFBundlePackageType": "APPL",
"CFBundleShortVersionString": version,
"CFBundleVersion": version,
"CFBundleInfoDictionaryVersion": "6.0",
"LSMinimumSystemVersion": MIN_MACOS,
"NSHighResolutionCapable": True,
"NSPrincipalClass": "NSApplication",
# The scanner talks to miners on the local network.
"NSLocalNetworkUsageDescription":
"Alkane Toolkit scans your local network to find and manage miners.",
"NSHumanReadableCopyright":
"Copyright (c) 2026 BlueFlare Energy Solutions Inc. (MIT License)",
}
with open(app / "Contents" / "Info.plist", "wb") as fh:
plistlib.dump(info, fh)
(app / "Contents" / "PkgInfo").write_text("APPL????")
# Ad-hoc signature over the whole bundle (the linker's per-slice
# signatures do not cover Info.plist or the resources).
run("codesign", "--force", "--sign", "-", "--timestamp=none", str(app))
run("codesign", "--verify", "--strict", str(app))
return app
def release(version: str, binary: str, out_dir: str) -> None:
name = f"alkane-toolkit-v{version}-macos-universal"
out = pathlib.Path(out_dir).resolve() / f"{name}.zip"
out.parent.mkdir(parents=True, exist_ok=True)
readme = (
f"alkane-toolkit v{version} (macOS, Apple Silicon and Intel)\n"
"\n"
f"Runs on macOS {MIN_MACOS} (Big Sur) or later. Drag \"Alkane Toolkit\"\n"
"to Applications, then open it.\n"
"\n"
"The app is not notarized by Apple, so the first launch is blocked\n"
"with a warning. To allow it once:\n"
" - macOS 15 or later: try to open it, then System Settings >\n"
" Privacy & Security > \"Open Anyway\" for Alkane Toolkit.\n"
" - macOS 11 to 14: Control-click the app, choose Open, then Open.\n"
"Or, in Terminal: xattr -dr com.apple.quarantine \"/Applications/Alkane Toolkit.app\"\n"
"\n"
"Settings are stored in ~/.config/alkane-toolkit/.\n"
"Manual: https://blueflare.gitea.bluefla.re/alkane-toolkit/manual/\n"
)
with tempfile.TemporaryDirectory(prefix="alkane-macos-") as tmp:
folder = pathlib.Path(tmp) / name
folder.mkdir()
build_app(version, pathlib.Path(binary), folder)
shutil.copy2(ROOT / "LICENSE", folder / "LICENSE")
(folder / "README.txt").write_text(readme)
out.unlink(missing_ok=True)
run("ditto", "-c", "-k", "--keepParent", str(folder), str(out))
print(out)
if __name__ == "__main__":
if len(sys.argv) != 4:
sys.exit(__doc__)
release(*sys.argv[1:])
+108
View File
@@ -0,0 +1,108 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Package the cross-built Windows toolkit for release and for native testing.
package-windows.py release VERSION EXE OUT_DIR
dist/alkane-toolkit-vVERSION-windows-x86_64.zip: one folder holding
alkane-toolkit.exe, LICENSE and a README.txt. Prints the zip path.
package-windows.py tests CARGO_JSON OUT_ZIP
A bundle of the test executables `cargo test --no-run
--message-format=json` reported (CARGO_JSON is that output), plus
tests.txt naming each one. The native Windows job runs every listed
executable on real Windows; the same binaries already ran under Wine.
"""
import json
import pathlib
import struct
import sys
import zipfile
ROOT = pathlib.Path(__file__).resolve().parents[1]
TARGET = "x86_64-pc-windows-gnu"
def release(version: str, exe: str, out_dir: str) -> None:
exe_path = pathlib.Path(exe)
if exe_path.suffix != ".exe" or not exe_path.is_file():
sys.exit(f"not a Windows executable: {exe}")
signed = _has_authenticode_signature(exe_path)
name = f"alkane-toolkit-v{version}-windows-x86_64"
out = pathlib.Path(out_dir) / f"{name}.zip"
out.parent.mkdir(parents=True, exist_ok=True)
readme = (
f"alkane-toolkit v{version} (Windows x86_64)\r\n"
"\r\n"
"Run alkane-toolkit.exe. No installer and no extra runtime are needed:\r\n"
"the executable is self-contained and runs on Windows 10 and 11.\r\n"
"\r\n"
+ (
"The executable is signed by BlueFlare Energy Solutions Inc. (Azure Artifact Signing). To check:\r\n"
"right-click alkane-toolkit.exe > Properties > Digital Signatures.\r\n"
if signed else
"This build is not code-signed, so Windows SmartScreen may warn on first\r\n"
"run: choose More info > Run anyway.\r\n"
)
+ "\r\n"
"Settings are kept in %APPDATA%\\alkane-toolkit.\r\n"
"SSH-based actions use the OpenSSH client built into Windows (ssh.exe);\r\n"
"HTTP actions use curl.exe, also built in.\r\n"
"\r\n"
"Offline demo: run from a Command Prompt with\r\n"
" set ALKANE_FAKE_SCAN=1 && alkane-toolkit.exe\r\n"
)
with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as z:
z.write(exe_path, f"{name}/alkane-toolkit.exe")
z.write(ROOT / "LICENSE", f"{name}/LICENSE.txt")
z.writestr(f"{name}/README.txt", readme)
print(out)
def _has_authenticode_signature(exe: pathlib.Path) -> bool:
"""True if the PE file carries a certificate table (an Authenticode signature)."""
data = exe.read_bytes()
pe = struct.unpack_from("<I", data, 0x3C)[0]
magic = struct.unpack_from("<H", data, pe + 24)[0]
dirs = pe + 24 + (96 if magic == 0x10B else 112)
return struct.unpack_from("<II", data, dirs + 4 * 8)[1] > 0
def tests(cargo_json: str, out_zip: str) -> None:
executables = []
for line in pathlib.Path(cargo_json).read_text().splitlines():
try:
message = json.loads(line)
except json.JSONDecodeError:
continue
if (message.get("reason") == "compiler-artifact"
and message.get("profile", {}).get("test")
and message.get("executable")):
executables.append(pathlib.Path(message["executable"]))
executables = sorted(set(executables))
if not executables:
sys.exit("no test executables in the cargo output")
out = pathlib.Path(out_zip)
out.parent.mkdir(parents=True, exist_ok=True)
with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as z:
names = []
for exe in executables:
if exe.suffix != ".exe" or TARGET not in exe.parts:
sys.exit(f"not a {TARGET} test executable: {exe}")
z.write(exe, exe.name)
names.append(exe.name)
z.writestr("tests.txt", "\n".join(names) + "\n")
print(f"{out} ({len(executables)} test executables)")
def main() -> None:
if len(sys.argv) == 5 and sys.argv[1] == "release":
release(*sys.argv[2:])
elif len(sys.argv) == 4 and sys.argv[1] == "tests":
tests(*sys.argv[2:])
else:
sys.exit(__doc__)
if __name__ == "__main__":
main()
+122
View File
@@ -0,0 +1,122 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Classify a pull request for scoped CI checks."""
import os
from pathlib import Path
import subprocess
import sys
import tomllib
ROOT = Path(__file__).resolve().parents[1]
DOC_FILES = {"README.md", "CONTRIBUTING.md", "CHANGELOG.md"}
HEADLESS_CRATES = {"alkane-access", "alkane-artifacts", "alkane-cli", "alkane-flash"}
def documentation_only(paths: list[str]) -> bool:
return bool(paths) and all(
path in DOC_FILES or
(path.startswith("docs/") and Path(path).suffix in {".md", ".txt"})
for path in paths
)
def workflow_only(paths: list[str]) -> bool:
"""Limit the cheap PR check to workflow YAML, never policy code."""
return bool(paths) and all(
path.startswith(".gitea/workflows/") and
len(Path(path).parts) == 3 and Path(path).suffix == ".yml"
for path in paths
)
def headless_packages(paths: list[str]) -> list[str]:
"""Return tested reverse dependents for code outside the GUI graph."""
changed: set[str] = set()
if not paths:
return []
for path in paths:
parts = Path(path).parts
if (len(parts) < 4 or parts[0] != "crates" or
parts[1] not in HEADLESS_CRATES or
parts[2] not in {"src", "tests"} or
Path(path).suffix != ".rs"):
return []
changed.add(parts[1])
try:
manifests = {}
for path in (ROOT / "crates").glob("*/Cargo.toml"):
manifest = tomllib.loads(path.read_text())
name = manifest["package"]["name"]
if name != path.parent.name:
return []
manifests[name] = manifest
if not changed <= manifests.keys() or "alkane-gui" not in manifests:
return []
def dependencies(value: object) -> set[str]:
found: set[str] = set()
if isinstance(value, dict):
for key, nested in value.items():
if key in {"dependencies", "dev-dependencies", "build-dependencies"}:
for dep_name, spec in nested.items():
found.add(spec.get("package", dep_name) if isinstance(spec, dict)
else dep_name)
else:
found.update(dependencies(nested))
return found & manifests.keys()
graph = {name: dependencies(manifest) for name, manifest in manifests.items()}
affected = changed.copy()
while True:
added = {name for name, deps in graph.items() if deps & affected} - affected
if not added:
break
affected.update(added)
return [] if "alkane-gui" in affected else sorted(affected)
except (OSError, KeyError, TypeError, ValueError):
return []
def changed_paths() -> list[str]:
if os.environ.get("GITHUB_EVENT_NAME") != "pull_request":
raise ValueError("not a pull request")
if os.environ.get("GITHUB_BASE_REF") != "main":
raise ValueError("unknown base branch")
merge_base = subprocess.check_output(
["git", "-C", str(ROOT), "merge-base", "HEAD",
"refs/remotes/origin/main"],
stderr=subprocess.DEVNULL, text=True,
).strip()
if len(merge_base) != 40:
raise ValueError("missing merge base")
raw = subprocess.check_output(
["git", "-C", str(ROOT), "diff", "--no-renames", "--name-only", "-z",
merge_base, "HEAD"], stderr=subprocess.DEVNULL,
)
return [path.decode("utf-8", "surrogateescape")
for path in raw.split(b"\0") if path]
def main() -> None:
try:
paths = changed_paths()
docs = documentation_only(paths)
workflow = workflow_only(paths) if not docs else False
packages = headless_packages(paths) if not docs and not workflow else []
except (OSError, subprocess.CalledProcessError, ValueError):
paths = []
docs = False
workflow = False
packages = []
surface = ("documentation" if docs else "workflow" if workflow else
"headless" if packages else "full")
print(f"surface={surface}")
print(f"packages={' '.join(packages)}")
print(f"Changed paths: {len(paths)}", file=sys.stderr)
if __name__ == "__main__":
main()
+121
View File
@@ -0,0 +1,121 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Publish a measured benchmark page to the public, data-only Pages repo."""
import argparse
import json
import os
from pathlib import Path
import shlex
import subprocess
import tempfile
from urllib.request import Request, urlopen
PAGES_REPO = "ssh://git@gitea.bluefla.re:2222/blueflare/alkane-benchmarks.git"
GUARD_REPO = "https://gitea.bluefla.re/blueflare/alkane-benchmarks.git"
GUARD_COMMIT = "ea160545c49bc419a245692deda8dd7db7a611eb"
PAGES_HOST = "gitea.bluefla.re"
PAGES_HOST_FINGERPRINT = "SHA256:lqB5cmC9E5HNeg/lkzdOwQ++I8A70Wx7lnNs6liN24g"
PAGES_HOST_KEY = "[gitea.bluefla.re]:2222 ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIO1II6NkmRW+QAd+Wj+7qbNrA8Oo+/N/WRog4hELskn/"
def run(*args: str, env: dict[str, str] | None = None,
cwd: Path | None = None) -> subprocess.CompletedProcess[str]:
return subprocess.run(args, env=env, cwd=cwd, text=True,
capture_output=True, check=True)
def current_main_sha() -> str:
api = os.environ["GITHUB_API_URL"].rstrip("/")
repo = os.environ["GITHUB_REPOSITORY"]
token = os.environ["GITEA_TOKEN"]
request = Request(f"{api}/repos/{repo}/branches/main",
headers={"Authorization": f"token {token}"})
with urlopen(request, timeout=20) as response:
branch = json.load(response)
return branch["commit"]["id"]
def publish(site: str) -> None:
if os.environ.get("GITHUB_REF") != "refs/heads/main":
raise ValueError("benchmark Pages publication requires main")
sha = os.environ["GITHUB_SHA"]
if current_main_sha() != sha:
print("Skipping benchmark page from a superseded main commit")
return
page = Path("bench-site/index.html").read_bytes()
if not page.startswith(b"<!doctype html>") or len(page) > 1_048_576:
raise ValueError("invalid benchmark page")
with tempfile.TemporaryDirectory(prefix="alkane-pages-") as directory:
temporary = Path(directory)
guard_checkout = temporary / "guard"
run("git", "clone", "--quiet", "--single-branch", "--branch", "next",
GUARD_REPO, str(guard_checkout))
guard_source = run("git", "show", f"{GUARD_COMMIT}:ci/validate_site.py",
cwd=guard_checkout).stdout
guard_script = temporary / "validate_site.py"
guard_script.write_text(guard_source)
run("python3", str(guard_script), "--page", site,
str(Path("bench-site/index.html").resolve()))
key = os.environ["BENCH_PAGES_DEPLOY_KEY"]
if not key.startswith("-----BEGIN OPENSSH PRIVATE KEY-----"):
raise ValueError("missing benchmark Pages deploy key")
key_path = temporary / "deploy_key"
key_path.write_text(key.rstrip("\n") + "\n")
key_path.chmod(0o600)
known_hosts = temporary / "known_hosts"
known_hosts.write_text(PAGES_HOST_KEY + "\n")
fingerprint = run("ssh-keygen", "-lf", str(known_hosts)).stdout.split()[1]
if fingerprint != PAGES_HOST_FINGERPRINT:
raise ValueError("benchmark Pages SSH host key changed")
git_env = os.environ.copy()
ssh_command = (f"ssh -i {shlex.quote(str(key_path))} -o IdentitiesOnly=yes "
f"-o UserKnownHostsFile={shlex.quote(str(known_hosts))} "
"-o StrictHostKeyChecking=yes -o ConnectTimeout=10")
git_env["GIT_SSH_COMMAND"] = ssh_command
git_env["GIT_TERMINAL_PROMPT"] = "0"
checkout = temporary / "site"
run("git", "clone", "--quiet", "--single-branch", "--branch", "gh-pages",
PAGES_REPO, str(checkout), env=git_env)
run("git", "config", "user.name", "Alkane CI", cwd=checkout)
run("git", "config", "user.email", "ci@bluefla.re", cwd=checkout)
for attempt in range(3):
if current_main_sha() != sha:
print("Skipping benchmark page from a superseded main commit")
return
run("git", "fetch", "--quiet", "origin", "gh-pages", env=git_env,
cwd=checkout)
run("git", "checkout", "-q", "-B", "bench-publish", "origin/gh-pages",
cwd=checkout)
destination = checkout / site / "index.html"
destination.parent.mkdir(exist_ok=True)
destination.write_bytes(page)
run("git", "add", f"{site}/index.html", cwd=checkout)
changed = subprocess.run(("git", "diff", "--cached", "--quiet"),
cwd=checkout, check=False)
if changed.returncode == 0:
print(f"{site} benchmark page is already current")
return
if changed.returncode != 1:
raise RuntimeError("cannot compare benchmark page")
run("git", "commit", "-q", "-m",
f"Update {site} benchmarks for {sha[:10]} [skip ci]", cwd=checkout)
pushed = subprocess.run(("git", "push", "--quiet", "origin",
"HEAD:gh-pages"), env=git_env, cwd=checkout,
text=True, capture_output=True, check=False)
if pushed.returncode == 0:
print(f"Published {site} benchmark page for {sha[:10]}")
return
if attempt == 2:
raise RuntimeError(f"benchmark Pages push failed: {pushed.stderr.strip()}")
raise RuntimeError("benchmark Pages publication did not complete")
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("site", choices=("sdk", "os", "toolkit"))
publish(parser.parse_args().site)
if __name__ == "__main__":
main()
+37
View File
@@ -0,0 +1,37 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Publish measured toolkit badges to the private Gitea badge branch."""
import json
import os
from pathlib import Path
from badge_store import publish_file
ROOT = Path(__file__).resolve().parents[1]
NAMES = ("tests", "coverage", "bench", "bench-coverage", "loc",
"dependencies", "quality", "license")
def main() -> None:
api = os.environ["GITHUB_API_URL"].rstrip("/")
repo = os.environ["GITHUB_REPOSITORY"]
token = os.environ["GITEA_TOKEN"]
for name in NAMES:
data = (ROOT / "badges" / f"{name}.svg").read_bytes()
if not data.lstrip().startswith(b"<svg"):
raise ValueError(f"invalid {name} SVG")
publish_file(api, repo, f"badges/{name}.svg", data, token,
f"Update measured {name} badge")
# The full measurement record behind the badges, read by the Pages
# quality dashboard (ci/build-pages.py).
data = (ROOT / "badges" / "quality.json").read_bytes()
if not isinstance(json.loads(data), dict):
raise ValueError("invalid quality.json")
publish_file(api, repo, "badges/quality.json", data, token,
"Update measured quality record", max_bytes=262_144)
print(f"Published {len(NAMES)} measured badge SVGs and quality.json")
if __name__ == "__main__":
main()
+79
View File
@@ -0,0 +1,79 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Publish the built Pages site to this repository's gh-pages branch.
publish-pages.py SITE_DIR
Served at https://blueflare.gitea.bluefla.re/alkane-toolkit/ by the Pages
server, which serves the gh-pages branch of public repositories. Each publish
is one orphan commit (force-pushed), so the branch never accumulates history.
Only main may publish, and a run for a superseded main commit skips.
"""
import json
import os
from pathlib import Path
import shutil
import subprocess
import sys
import tempfile
from urllib.request import Request, urlopen
BRANCH = "gh-pages"
MAX_BYTES = 20 * 1024 * 1024
def current_main_sha(api: str, repo: str, token: str) -> str:
request = Request(f"{api}/repos/{repo}/branches/main",
headers={"Authorization": f"token {token}"})
with urlopen(request, timeout=20) as response:
return json.load(response)["commit"]["id"]
def git(*args: str, cwd: Path, env: dict | None = None) -> None:
subprocess.run(("git", *args), cwd=cwd, env=env, check=True)
def main() -> None:
if len(sys.argv) != 2:
sys.exit(__doc__)
site = Path(sys.argv[1])
if not (site / "index.html").is_file():
sys.exit(f"{site} has no index.html")
size = sum(p.stat().st_size for p in site.rglob("*") if p.is_file())
if size > MAX_BYTES:
sys.exit(f"site is {size} bytes, over the {MAX_BYTES} byte limit")
for path in site.rglob("*"):
if path.is_file() and path.suffix not in {".html", ".css", ".svg", ".png", ".json"}:
sys.exit(f"unexpected file type on the site: {path}")
api = os.environ["GITHUB_API_URL"].rstrip("/")
repo = os.environ["GITHUB_REPOSITORY"]
sha = os.environ["GITHUB_SHA"]
token = os.environ["GITEA_TOKEN"]
if os.environ.get("GITHUB_REF") != "refs/heads/main":
sys.exit("Pages publication requires main")
if current_main_sha(api, repo, token) != sha:
print("Skipping Pages for a superseded main commit")
return
server = api.removesuffix("/api/v1")
with tempfile.TemporaryDirectory(prefix="alkane-pages-") as directory:
work = Path(directory)
shutil.copytree(site, work, dirs_exist_ok=True)
env = dict(os.environ, GIT_TERMINAL_PROMPT="0")
git("init", "-q", "-b", BRANCH, cwd=work)
git("-c", "user.name=Alkane CI", "-c", "user.email=ci@noreply.gitea.bluefla.re",
"add", "-A", cwd=work)
git("-c", "user.name=Alkane CI", "-c", "user.email=ci@noreply.gitea.bluefla.re",
"commit", "-q", "-m", f"Publish site for {sha[:10]} [skip ci]", cwd=work)
# The token is read from the environment by the credential helper at
# push time; it never appears on a command line or in the remote URL.
helper = '!f() { echo username=alkane-ci; echo "password=$GITEA_TOKEN"; }; f'
git("-c", f"credential.helper={helper}", "push", "-q", "--force",
f"{server}/{repo}.git", f"HEAD:refs/heads/{BRANCH}", cwd=work, env=env)
print(f"Published Pages for {sha[:10]} to {BRANCH}")
if __name__ == "__main__":
main()
+56
View File
@@ -0,0 +1,56 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Create one Gitea release and attach files using the runner's scoped token."""
import json
import os
import pathlib
import sys
import urllib.error
import urllib.parse
import urllib.request
def request(url, payload, content_type):
headers = {
"Authorization": "token " + os.environ["GITEA_TOKEN"],
"Content-Type": content_type,
}
req = urllib.request.Request(url, data=payload, headers=headers, method="POST")
with urllib.request.urlopen(req, timeout=60) as response:
return json.load(response)
def main():
if len(sys.argv) < 4:
sys.exit("usage: release.py TAG PRERELEASE FILE [FILE ...]")
tag, prerelease, *files = sys.argv[1:]
api = os.environ.get("GITHUB_API_URL", "https://gitea.bluefla.re/api/v1").rstrip("/")
repo = os.environ["GITHUB_REPOSITORY"]
sha = os.environ["GITHUB_SHA"]
body = f"Automated Alkane toolkit build from {sha}."
metadata = {
"tag_name": tag,
"target_commitish": sha,
"name": tag,
"body": body,
"prerelease": prerelease.lower() == "true",
}
try:
release = request(f"{api}/repos/{repo}/releases", json.dumps(metadata).encode(), "application/json")
except urllib.error.HTTPError as exc:
sys.exit(f"release creation failed: HTTP {exc.code}")
release_id = release["id"]
for name in files:
path = pathlib.Path(name)
query = urllib.parse.urlencode({"name": path.name})
try:
request(f"{api}/repos/{repo}/releases/{release_id}/assets?{query}",
path.read_bytes(), "application/octet-stream")
except urllib.error.HTTPError as exc:
sys.exit(f"asset upload failed for {path.name}: HTTP {exc.code}")
print(f"Created {tag} with {len(files)} assets")
if __name__ == "__main__":
main()
+1
View File
@@ -0,0 +1 @@
gitea.bluefla.re/blueflare/alkane-ci@sha256:4929b2979851f1f12fb8f92ef74236ae4c2ea735a41ead94a16af416a4f0a1a5
+88
View File
@@ -0,0 +1,88 @@
#!/usr/bin/env bash
# SPDX-License-Identifier: MIT
# Authenticode-sign Windows executables with Azure Artifact Signing (formerly
# Trusted Signing), from Linux, with jsign. Every signature is RFC 3161
# timestamped: the signing certificates live only a few days, the timestamp is
# what keeps a signature valid after that.
#
# ci/sign-windows.sh FILE.exe [FILE.exe ...]
#
# Configuration (environment):
# AZURE_SIGNING_PROFILE certificate profile name; EMPTY = signing not set
# up yet: the files are left unsigned (exit 0)
# AZURE_SIGNING_ACCOUNT signing account (default blueflaresigning)
# AZURE_SIGNING_ENDPOINT account endpoint (default https://wus2.codesigning.azure.net)
# Credentials, one of:
# AZURE_SIGNING_TENANT_ID + AZURE_SIGNING_CLIENT_ID + AZURE_SIGNING_CLIENT_SECRET
# (the CI service principal alkane-toolkit-ci-signer, role
# "Artifact Signing Certificate Profile Signer" on the account only)
# AZURE_SIGNING_TOKEN an access token for https://codesigning.azure.net,
# e.g. from `az account get-access-token --resource https://codesigning.azure.net`
# ALKANE_JSIGN_JAR jsign jar (default /opt/jsign/jsign.jar, from the CI image)
#
# Once a profile is configured, any failure fails the job: a release is never
# shipped half-signed or silently unsigned.
set -euo pipefail
[ "$#" -gt 0 ] || { sed -n '3,25p' "$0" >&2; exit 2; }
profile="${AZURE_SIGNING_PROFILE:-}"
if [ -z "$profile" ]; then
echo "Windows code signing is not enabled (AZURE_SIGNING_PROFILE unset); leaving $* unsigned"
exit 0
fi
account="${AZURE_SIGNING_ACCOUNT:-blueflaresigning}"
endpoint="${AZURE_SIGNING_ENDPOINT:-https://wus2.codesigning.azure.net}"
jar="${ALKANE_JSIGN_JAR:-/opt/jsign/jsign.jar}"
[ -f "$jar" ] || { echo "jsign not found at $jar" >&2; exit 1; }
if [ -z "${AZURE_SIGNING_TOKEN:-}" ]; then
: "${AZURE_SIGNING_TENANT_ID:?signing credentials missing}"
: "${AZURE_SIGNING_CLIENT_ID:?signing credentials missing}"
: "${AZURE_SIGNING_CLIENT_SECRET:?signing credentials missing}"
# Client-credentials token for the signing service. The secret and token
# stay in this process's environment, never on a command line.
AZURE_SIGNING_TOKEN="$(python3 - <<'PY'
import json, os, sys, urllib.parse, urllib.request
body = urllib.parse.urlencode({
"grant_type": "client_credentials",
"client_id": os.environ["AZURE_SIGNING_CLIENT_ID"],
"client_secret": os.environ["AZURE_SIGNING_CLIENT_SECRET"],
"scope": "https://codesigning.azure.net/.default",
}).encode()
url = f"https://login.microsoftonline.com/{os.environ['AZURE_SIGNING_TENANT_ID']}/oauth2/v2.0/token"
try:
with urllib.request.urlopen(url, body, timeout=60) as r:
print(json.load(r)["access_token"])
except Exception as e:
sys.exit(f"could not get a signing token: {e}")
PY
)"
fi
export AZURE_SIGNING_TOKEN
for file in "$@"; do
java -jar "$jar" \
--storetype TRUSTEDSIGNING \
--keystore "${endpoint#https://}" \
--storepass env:AZURE_SIGNING_TOKEN \
--alias "$account/$profile" \
--alg SHA-256 \
--tsaurl http://timestamp.acs.microsoft.com --tsmode RFC3161 \
--tsretries 3 --tsretrywait 10 \
--name "Alkane Toolkit" \
--url https://gitea.bluefla.re/blueflare/alkane-toolkit \
"$file"
# jsign fails on any error; also make sure a signature actually landed in
# the PE certificate table before the file goes anywhere.
python3 - "$file" <<'PY'
import struct, sys
data = open(sys.argv[1], "rb").read()
pe = struct.unpack_from("<I", data, 0x3C)[0]
magic = struct.unpack_from("<H", data, pe + 24)[0]
dirs = pe + 24 + (96 if magic == 0x10B else 112)
offset, size = struct.unpack_from("<II", data, dirs + 4 * 8) # IMAGE_DIRECTORY_ENTRY_SECURITY
if size == 0:
sys.exit(f"{sys.argv[1]}: no Authenticode signature after signing")
print(f"{sys.argv[1]}: signed ({size} byte certificate table)")
PY
done
+97
View File
@@ -0,0 +1,97 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Check that every Toolkit benchmark contributes to the release badge."""
import importlib.util
import re
from pathlib import Path
import tempfile
import unittest
ROOT = Path(__file__).resolve().parents[1]
spec = importlib.util.spec_from_file_location("bench_badge", ROOT / "ci/bench-badge.py")
assert spec is not None and spec.loader is not None
badge = importlib.util.module_from_spec(spec)
spec.loader.exec_module(badge)
badge_spec = importlib.util.spec_from_file_location("gen_badges", ROOT / "ci/gen-badges.py")
assert badge_spec is not None and badge_spec.loader is not None
gen_badges = importlib.util.module_from_spec(badge_spec)
badge_spec.loader.exec_module(gen_badges)
class BenchBadgeTests(unittest.TestCase):
def test_declared_suite_matches_rust_benchmarks(self):
names = set()
for directory in (ROOT / "crates/alkane-gui/src", ROOT / "crates/alkane-artifacts/src"):
for path in directory.rglob("*.rs"):
names.update(re.findall(
r'#\[test\]\s*#\[ignore(?:\s*=\s*"[^"]*")?\]\s*'
r'fn (bench_[A-Za-z0-9_]+)\s*\(', path.read_text()))
self.assertEqual(names, badge.EXPECTED_BENCHES)
def test_incomplete_duplicate_and_malformed_results_fail(self):
lines = [f"test tests::{name} ... {name}: 10ms/op"
for name in sorted(badge.EXPECTED_BENCHES)]
values = badge.require_suite(badge.parse_bench("\n".join(lines)))
self.assertEqual(len(values), 12)
with self.assertRaisesRegex(ValueError, "declared suite"):
badge.require_suite(badge.parse_bench("\n".join(lines[:-1])))
with self.assertRaisesRegex(ValueError, "duplicate"):
badge.parse_bench("\n".join(lines + [lines[0]]))
with self.assertRaisesRegex(ValueError, "missing timing"):
badge.parse_bench(lines[0].replace("10ms/op", "missing"))
def test_badge_averages_each_benchmark_improvement(self):
current = {"short": 50.0, "long": 900.0}
baseline = {"short": 100.0, "long": 1000.0}
self.assertEqual(badge.benchmark_delta(current, baseline), 30.0)
self.assertAlmostEqual(badge.benchmark_delta(baseline, current), -55.5555556)
self.assertIsNone(badge.benchmark_delta(current, {}))
self.assertEqual(gen_badges.bench_color(30.0), "brightgreen")
self.assertEqual(gen_badges.bench_color(-55.5555556), "orange")
def test_quality_grade_follows_lint_and_coverage(self):
# A lint failure fails the grade; otherwise it is the coverage band,
# with the same floors as the coverage badge colour.
self.assertEqual(gen_badges.quality_grade("failed", 95.0), "F")
self.assertEqual(gen_badges.quality_grade("clean", 85.0), "A")
self.assertEqual(gen_badges.quality_grade("clean", 65.6), "B")
self.assertEqual(gen_badges.quality_grade("clean", 48.0), "C")
self.assertEqual(gen_badges.quality_grade("clean", 25.0), "D")
self.assertEqual(gen_badges.quality_grade("clean", 5.0), "F")
self.assertEqual(gen_badges.quality_grade("clean"), "pending")
self.assertEqual(gen_badges.quality_grade(None, 90.0), "pending")
for pct in (85.0, 65.6, 48.0, 25.0):
grade = gen_badges.quality_grade("clean", pct)
self.assertEqual(gen_badges.GRADE_COLORS[grade], gen_badges.cov_color(pct))
def test_coverage_table_is_split_by_crate(self):
with tempfile.TemporaryDirectory(prefix="alkane-cov-") as directory:
summary = Path(directory) / "summary.txt"
summary.write_text(
"Filename Regions Missed Regions Cover Functions Missed Functions "
"Executed Lines Missed Lines Cover\n"
"crates/alkane-gui/src/ui.rs 10 5 50.00% 4 2 50.00% 100 60 40.00%\n"
"crates/alkane-core/src/platform.rs 4 0 100.00% 2 0 100.00% 50 5 90.00%\n"
"TOTAL 14 5 64.29% 6 2 66.67% 150 65 56.67%\n")
rows = gen_badges.coverage_by_file(str(summary), directory)
self.assertEqual([r["file"] for r in rows],
["crates/alkane-gui/src/ui.rs", "crates/alkane-core/src/platform.rs"])
self.assertEqual(rows[0]["missed"], 60)
self.assertEqual(gen_badges.crate_of(rows[1]["file"]), "alkane-core")
def test_coverage_table_restores_the_stripped_crates_prefix(self):
with tempfile.TemporaryDirectory(prefix="alkane-cov-") as directory:
(Path(directory) / "crates" / "alkane-cli").mkdir(parents=True)
summary = Path(directory) / "summary.txt"
summary.write_text(
"alkane-cli/src/main.rs 4 4 0.00% 1 1 0.00% 23 23 0.00%\n")
rows = gen_badges.coverage_by_file(str(summary), directory)
self.assertEqual(rows[0], {"file": "crates/alkane-cli/src/main.rs",
"lines": 23, "missed": 23})
self.assertEqual(gen_badges.crate_of(rows[0]["file"]), "alkane-cli")
if __name__ == "__main__":
unittest.main()
+130
View File
@@ -0,0 +1,130 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Exercise benchmark history selection and safe site rendering."""
import sys
import json
from pathlib import Path
import subprocess
import tempfile
import unittest
sys.path.insert(0, str(Path(__file__).resolve().parent))
from bench_history import (bench_badge, git_distance, previous_measurement, render_html,
same_benchmark_inputs, updated_index)
class HistoryTests(unittest.TestCase):
def test_cargo_nocapture_benchmark_lines_are_parsed(self):
output = (
"test tests::bench_verify_artifact ... bench_verify_artifact: 208.302µs\n"
"test model::tests::bench_render_cells ... bench_render_cells: "
"5000 rows x 10 cols = 8.007185ms/full-render (bytes=13553600)\n"
"bench_direct: 12ns/op\n"
)
self.assertEqual(bench_badge.parse_bench(output), {
"bench_verify_artifact": 208_302.0,
"bench_render_cells": 8_007_185.0,
"bench_direct": 12.0,
})
def test_retry_uses_previous_commit(self):
first = "a" * 40
second = "b" * 40
index = {"schema": 1, "entries": [
{"sha": first, "timestamp": "2026-01-01T00:00:00+00:00",
"metrics": {"bench_ns_per_op": {"hash": 10.0}}},
{"sha": second, "timestamp": "2026-01-02T00:00:00+00:00",
"metrics": {"bench_ns_per_op": {"hash": 8.0}}}]}
self.assertEqual(previous_measurement(index, second,
lambda ancestor, sha: 1 if ancestor == first else None),
{"hash": 10.0})
updated = updated_index(index, second, {"bench_ns_per_op": {"hash": 7.5}},
"2026-01-03T00:00:00+00:00")
self.assertEqual(len(updated["entries"]), 2)
self.assertEqual(updated["entries"][-1]["metrics"]["bench_ns_per_op"]["hash"], 7.5)
def test_invalid_measurement_and_sha_rejected(self):
self.assertIsNone(git_distance("--bad", "a" * 40))
with self.assertRaises(ValueError):
updated_index({}, "bad", {"bench_ns_per_op": {"hash": 1}}, "now")
with self.assertRaises(ValueError):
updated_index({}, "a" * 40, {"bench_ns_per_op": {"hash": -1}}, "now")
def test_baseline_must_match_cpu_class(self):
host = {"architecture": "x86_64", "cpu_model": "A", "logical_cpus": 8}
other = {"architecture": "x86_64", "cpu_model": "B", "logical_cpus": 8}
index = {"entries": [{"sha": "a" * 40, "metrics": {
"bench_ns_per_op": {"hash": 10.0}, "bench_host": host}}]}
distance = lambda _ancestor, _sha: 1
self.assertEqual(previous_measurement(index, "b" * 40, distance, host),
{"hash": 10.0})
self.assertEqual(previous_measurement(index, "b" * 40, distance, other), {})
def test_routing_change_is_marked_same_inputs_but_code_or_build_change_is_not(self):
with tempfile.TemporaryDirectory(prefix="alkane-bench-inputs-") as directory:
root = Path(directory)
workflow = root / ".gitea/workflows/release.yml"
workflow.parent.mkdir(parents=True)
code = root / "crates/alkane-gui/src/main.rs"
code.parent.mkdir(parents=True)
code.write_text("fn main() {}\n")
workflow.write_text(
"jobs:\n release:\n runs-on: alkane-verify\n"
" container:\n image: pinned-image\n"
" env:\n RUSTFLAGS: stable\n steps:\n"
" - name: Build release\n run: cargo build --release\n"
" - name: Microbenchmarks\n run: cargo test --release bench_\n")
def git(*args):
return subprocess.check_output(("git", "-C", str(root), *args),
text=True, stderr=subprocess.DEVNULL).strip()
git("init", "-q")
git("config", "user.name", "CI Test")
git("config", "user.email", "ci@example.invalid")
git("add", ".")
git("commit", "-qm", "base")
base = git("rev-parse", "HEAD")
workflow.write_text(workflow.read_text().replace("alkane-verify", "alkane-ci"))
git("commit", "-qam", "route")
route = git("rev-parse", "HEAD")
self.assertTrue(same_benchmark_inputs(base, route, root))
code.write_text("fn main() { println!(\"changed\"); }\n")
git("commit", "-qam", "code")
changed_code = git("rev-parse", "HEAD")
self.assertFalse(same_benchmark_inputs(route, changed_code, root))
workflow.write_text(workflow.read_text().replace("RUSTFLAGS: stable", "RUSTFLAGS: tuned"))
git("commit", "-qam", "flags")
flags = git("rev-parse", "HEAD")
self.assertFalse(same_benchmark_inputs(changed_code, flags, root))
def test_badge_keeps_raw_delta_and_marks_identical_inputs(self):
with tempfile.TemporaryDirectory(prefix="alkane-bench-badge-context-") as directory:
root = Path(directory)
badges = root / "badges"
badges.mkdir()
(badges / "bench-context.json").write_text(
json.dumps({"schema": 1, "same_inputs": True, "baseline_sha": "a" * 40}))
command = (sys.executable, str(Path(__file__).with_name("gen-badges.py")),
"--root", str(root), "--bench-delta=-36.4")
subprocess.run(command, check=True, capture_output=True)
self.assertIn("-36.4% same inputs", (badges / "bench.svg").read_text())
(badges / "bench-context.json").unlink()
subprocess.run(command, check=True, capture_output=True)
self.assertIn("-36.4% vs prev", (badges / "bench.svg").read_text())
def test_site_escapes_history_content(self):
entry = {"sha": "a" * 40, "timestamp": "<script>alert(1)</script>",
"metrics": {"bench_ns_per_op": {"hash": 10.0},
"bench_host": {"cpu_model": "<script>cpu</script>"},
"bench_context": {"schema": 1, "same_inputs": True}}}
page = render_html({"entries": [entry]})
self.assertIn("&lt;script&gt;", page)
self.assertNotIn("<script>", page)
self.assertIn("10.000", page)
self.assertIn("same inputs", page)
if __name__ == "__main__":
unittest.main()
+6
View File
@@ -53,6 +53,12 @@ R="$(new_repo)"; mkdir -p "$R/ci"; printf '2' > "$R/ci/version-x.txt"
printf 'x' > "$R/README.md"; commit "$R" init
run_case first_release_prebumped_x "$R" version=2.0.0 bump=initial release=true
# 3b. Windows packaging (build script / resources) is release-relevant: bumps Y
R="$(new_repo)"; mkdir -p "$R/ci" "$R/crates/alkane-gui/windows"; printf '0' > "$R/ci/version-x.txt"
printf 'x' > "$R/README.md"; commit "$R" init; git -C "$R" tag v1.2.3
printf '<assembly/>' > "$R/crates/alkane-gui/windows/alkane-toolkit.exe.manifest"; commit "$R" winres
run_case windows_resources_bump "$R" version=1.3.0 bump=backend release=true
# 3. Backend path change bumps Y
R="$(new_repo)"; mkdir -p "$R/ci" "$R/crates/alkane-gui/src"; printf '0' > "$R/ci/version-x.txt"
printf 'x' > "$R/README.md"; commit "$R" init; git -C "$R" tag v1.2.3
+35
View File
@@ -0,0 +1,35 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Check that queued CI runs do not displace the last completed result."""
import importlib.util
from pathlib import Path
from unittest.mock import patch
import xml.etree.ElementTree as ET
path = Path(__file__).with_name("last-attempt-badge.py")
spec = importlib.util.spec_from_file_location("last_attempt_badge", path)
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module)
def runs(_url, _token):
return {"workflow_runs": [
{"id": 105, "head_branch": "main", "status": "completed", "conclusion": "cancelled"},
{"id": 104, "head_branch": "main", "status": "queued", "conclusion": None},
{"id": 103, "head_branch": "main", "status": "completed", "conclusion": "failure"},
{"id": 102, "head_branch": "main", "status": "completed", "conclusion": "success"},
]}
with patch.object(module, "request_json", runs):
assert module.latest_completed("https://example.invalid/api/v1", "owner/repo",
"release.yml", "main", "token") == (103, "failure")
svg = module.badge("main", "failure", 103)
root = ET.fromstring(svg)
assert root.attrib["aria-label"] == "CI main: last completed attempt fail (run 103)"
assert b">fail</text>" in svg
assert b"#d1242f" in svg
assert b">pass</text>" in module.badge("next", "success", 108)
print("last completed CI badge: queued run ignored, pass/fail SVGs valid")
+223
View File
@@ -0,0 +1,223 @@
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
"""Check that unknown changes cannot take a scoped CI path."""
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
import importlib.util
import yaml
SCRIPT = Path(__file__).with_name("pr-surface.py")
ROOT = SCRIPT.parents[1]
spec = importlib.util.spec_from_file_location("pr_surface", SCRIPT)
assert spec and spec.loader
pr_surface = importlib.util.module_from_spec(spec)
spec.loader.exec_module(pr_surface)
def git(directory: Path, *args: str) -> str:
return subprocess.check_output(
["git", "-C", str(directory), *args], text=True,
stderr=subprocess.DEVNULL,
).strip()
def check_workflow_contract() -> None:
"""Keep the short workflow check from silently dropping release gates."""
required = [
("release.yml", "main", "release", (
"Check runner image pins", "Check first-party Rust formatting",
"Clippy (our crate, warnings are errors)",
"Build release", "Unit tests", "Microbenchmarks",
"Headless UI self-test", "Coverage", "Microbenchmark coverage",
"Generate measured badges", "Publish measured badges",
"Record private benchmark history", "Create Gitea release + upload artifact",
"Clean generated Toolkit build",
)),
("release.yml", "main", "windows", (
"Clippy (Windows target, warnings are errors)", "Build release (Windows)",
"Unit tests (Windows build, under Wine)",
"Headless UI self-test (Windows build, under Wine)",
"Sign Windows executable (Azure Artifact Signing)",
"Package Windows artifact", "Clean generated Toolkit build",
)),
("next.yml", "next", "candidate", (
"Check runner image pins", "Build release candidate",
"Create private prerelease", "Clean generated Toolkit build",
)),
("next.yml", "next", "windows", (
"Build Windows candidate", "Sign Windows candidate (Azure Artifact Signing)",
"Package Windows candidate",
"Clean generated Toolkit build",
)),
("verify.yml", "main", "verify", (
"Check runner image pins", "Detect changed surface",
"Check CI change surface", "Check first-party Rust formatting",
"Check workflow-only change",
"Clippy (our crate, warnings are errors)", "Build", "Unit tests",
"Microbenchmarks", "Headless UI self-test", "Clean generated Toolkit build",
)),
("verify.yml", "main", "verify-windows", (
"Clippy (Windows target, warnings are errors)", "Build (Windows)",
"Unit tests (Windows build, under Wine)",
"Headless UI self-test (Windows build, under Wine)",
"Clean generated Toolkit build",
)),
]
for filename, branch, job_name, gates in required:
path = ROOT / ".gitea/workflows" / filename
workflow = yaml.load(path.read_text(), Loader=yaml.BaseLoader)
event = "pull_request" if filename == "verify.yml" else "push"
assert workflow["on"][event]["branches"] == [branch], path
job = workflow["jobs"][job_name]
assert job["runs-on"] in {"alkane-ci", "alkane-verify"}, path
steps = job["steps"]
names = [step.get("name") for step in steps]
positions = [names.index(gate) for gate in gates]
assert positions == sorted(positions), path
assert steps[positions[-1]].get("if") == "always()", path
for gate, position in zip(gates[:-1], positions[:-1]):
condition = steps[position].get("if")
if gate in {"Create Gitea release + upload artifact",
"Create private prerelease", "Package Windows artifact",
"Build Windows candidate", "Package Windows candidate",
"Sign Windows candidate (Azure Artifact Signing)"}:
assert condition is not None and "release == 'true'" in condition, path
elif filename == "verify.yml" and gate in {
"Build", "Unit tests", "Microbenchmarks",
"Clippy (our crate, warnings are errors)",
"Headless UI self-test"}:
assert condition == "steps.surface.outputs.surface == 'full'", path
elif filename == "verify.yml" and gate == "Check CI change surface":
assert condition == "steps.surface.outputs.surface != 'documentation'", path
elif filename == "verify.yml" and gate == "Check first-party Rust formatting":
assert condition == ("steps.surface.outputs.surface == 'headless' || "
"steps.surface.outputs.surface == 'full'"), path
elif filename == "verify.yml" and gate == "Check workflow-only change":
assert condition == "steps.surface.outputs.surface == 'workflow'", path
else:
assert condition is None, path
def main() -> None:
check_workflow_contract()
with tempfile.TemporaryDirectory(prefix="alkane-toolkit-workflow-policy-") as directory:
global ROOT
saved_root = ROOT
ROOT = Path(directory)
(ROOT / ".gitea/workflows").mkdir(parents=True)
for filename in ("release.yml", "next.yml", "verify.yml"):
shutil.copyfile(saved_root / ".gitea/workflows" / filename,
ROOT / ".gitea/workflows" / filename)
release = ROOT / ".gitea/workflows/release.yml"
original = release.read_text()
release.write_text(original.replace("- name: Coverage", "- name: Skipped coverage", 1))
try:
check_workflow_contract()
except ValueError:
pass
else:
raise AssertionError("removing the coverage gate passed workflow policy")
ROOT = saved_root
assert pr_surface.documentation_only(["README.md", "docs/setup.md"])
assert pr_surface.workflow_only([".gitea/workflows/release.yml"])
for paths in ([], ["ci/pr-surface.py"], ["ci/coverage.sh"],
["ci/check-runner-image.py"],
[".gitea/workflows/release.yml", "ci/check-runner-image.py"],
[".gitea/workflows/release.yml", "crates/alkane-gui/src/main.rs"],
[".gitea/workflows/../release.yml"]):
assert not pr_surface.workflow_only(paths), paths
for paths in ([], ["docs/generated.json"], ["src/main.rs"],
["README.md", "ci/pr-surface.py"]):
assert not pr_surface.documentation_only(paths), paths
assert pr_surface.headless_packages(["crates/alkane-cli/src/main.rs"]) == ["alkane-cli"]
# alkane-gui depends on alkane-flash and alkane-artifacts (right-click
# install/uninstall and the release picker), so a change in either reaches
# the GUI graph and needs the full build: not a headless-only change.
assert pr_surface.headless_packages(["crates/alkane-artifacts/src/lib.rs"]) == []
assert pr_surface.headless_packages(["crates/alkane-flash/src/lib.rs"]) == []
assert pr_surface.headless_packages([
"crates/alkane-access/src/lib.rs", "crates/alkane-flash/tests/update.rs",
]) == []
assert pr_surface.headless_packages([
"crates/alkane-access/src/lib.rs", "crates/alkane-cli/src/main.rs",
]) == ["alkane-access", "alkane-cli"]
for paths in ([], ["crates/alkane-core/src/lib.rs"],
["crates/alkane-discovery/src/lib.rs"],
["crates/alkane-gui/src/main.rs"],
["crates/alkane-artifacts/Cargo.toml"],
["crates/alkane-cli/src/main.rs", "Cargo.lock"],
["crates/alkane-cli/src/main.rs", "ci/pr-surface.py"],
["crates/alkane-cli/README.md"]):
assert pr_surface.headless_packages(paths) == [], paths
with tempfile.TemporaryDirectory(prefix="alkane-toolkit-graph-") as directory:
root = Path(directory)
for name, extra in (
("alkane-gui", ""),
("alkane-artifacts", ""),
("alkane-flash", 'alkane-artifacts = { path = "../alkane-artifacts" }\n'),
):
crate = root / "crates" / name
crate.mkdir(parents=True)
(crate / "Cargo.toml").write_text(
f'[package]\nname = "{name}"\nversion = "0.1.0"\n'
f'[dependencies]\n{extra}'
)
saved_root = pr_surface.ROOT
try:
pr_surface.ROOT = root
changed = ["crates/alkane-artifacts/src/lib.rs"]
assert pr_surface.headless_packages(changed) == [
"alkane-artifacts", "alkane-flash",
]
with (root / "crates/alkane-gui/Cargo.toml").open("a") as stream:
stream.write('alkane-flash = { path = "../alkane-flash" }\n')
assert pr_surface.headless_packages(changed) == []
finally:
pr_surface.ROOT = saved_root
with tempfile.TemporaryDirectory(prefix="alkane-toolkit-pr-surface-") as directory:
repo = Path(directory)
git(repo, "init", "-q")
git(repo, "config", "user.name", "CI Test")
git(repo, "config", "user.email", "ci@example.invalid")
(repo / "README.md").write_text("initial\n")
git(repo, "add", "README.md")
git(repo, "commit", "-qm", "base")
base = git(repo, "rev-parse", "HEAD")
git(repo, "update-ref", "refs/remotes/origin/main", base)
(repo / "README.md").write_text("documentation change\n")
git(repo, "commit", "-qam", "docs")
saved_root = pr_surface.ROOT
saved_env = dict(os.environ)
try:
pr_surface.ROOT = repo
os.environ["GITHUB_EVENT_NAME"] = "pull_request"
os.environ["GITHUB_BASE_REF"] = "main"
assert pr_surface.changed_paths() == ["README.md"]
git(repo, "checkout", "-q", "-b", "rename-check", base)
git(repo, "mv", "README.md", "code.rs")
git(repo, "commit", "-qm", "rename")
assert set(pr_surface.changed_paths()) == {"README.md", "code.rs"}
os.environ.pop("GITHUB_BASE_REF")
try:
pr_surface.changed_paths()
except ValueError:
pass
else:
raise AssertionError("missing base must fall back to full checks")
finally:
pr_surface.ROOT = saved_root
os.environ.clear()
os.environ.update(saved_env)
print("Toolkit PR change surface: documentation, workflow, headless, and fallback PASS")
if __name__ == "__main__":
main()
+85
View File
@@ -0,0 +1,85 @@
#!/usr/bin/env bash
# SPDX-License-Identifier: MIT
# Every Windows CI step in one place, so verify (PRs), the main release and the
# next-branch candidates build and test the .exe the same way:
#
# windows-ci.sh toolchain mingw-w64 + Wine + the rustup target
# windows-ci.sh clippy clippy for x86_64-pc-windows-gnu, -D warnings
# windows-ci.sh build release alkane-toolkit.exe
# windows-ci.sh test all unit tests, run under Wine
# windows-ci.sh selftest headless UI self-test under Wine + Xvfb
# windows-ci.sh sign Authenticode-sign alkane-toolkit.exe through
# Azure Artifact Signing (ci/sign-windows.sh;
# a no-op until AZURE_SIGNING_PROFILE is set)
# windows-ci.sh package VERSION dist/alkane-toolkit-vVERSION-windows-x86_64.zip
# windows-ci.sh test-bundle dist/alkane-toolkit-windows-tests.zip (for
# the native Windows job)
#
# The wxMSW prefix comes from the CI image or ci/ensure-wx-prefix.sh windows.
set -euo pipefail
cd "$(git rev-parse --show-toplevel)"
export WX_WINDOWS_PREFIX="${WX_WINDOWS_PREFIX:-/root/.cache/wx-3.3.3-mingw}"
export ALKANE_WINEPREFIX="${ALKANE_WINEPREFIX:-/root/.cache/alkane-wine}"
# shellcheck source=../scripts/windows-cross-env.sh
. scripts/windows-cross-env.sh
target="$ALKANE_WIN_TARGET"
out_dir="${CARGO_TARGET_DIR:-target}"
exe="$out_dir/$target/release/alkane-toolkit.exe"
# The GUI crate's tests link wx and some create windows; Wine wants a display.
headless() { xvfb-run -a -s '-screen 0 1280x850x24' "$@"; }
case "${1:-}" in
toolchain)
bash ci/ensure-build-deps.sh windows
rustup target list --installed | grep -qx "$target" || rustup target add "$target"
# jsign ships in the CI image; fetch the same pinned jar on older images.
jsign_version=7.6
jsign_sha256=6cf58aa080e7ff82656f320cff8d4a3bff30408df8766806dcba3740dd839fa5
if [ ! -s /opt/jsign/jsign.jar ]; then
mkdir -p /opt/jsign
curl -sSfL -o /opt/jsign/jsign.jar \
"https://repo1.maven.org/maven2/net/jsign/jsign/$jsign_version/jsign-$jsign_version.jar"
echo "$jsign_sha256 /opt/jsign/jsign.jar" | sha256sum -c -
fi
;;
clippy)
rustup component add clippy >/dev/null 2>&1 || true
cargo clippy -p alkane-gui --no-deps --release --bins --target "$target" --offline -- -D warnings
cargo clippy --workspace --exclude alkane-gui --exclude wx-rs --all-targets \
--target "$target" --offline -- -D warnings
;;
build)
cargo build --release -p alkane-gui --target "$target" --offline
# One self-contained .exe: any toolchain DLL import would fail on a clean
# Windows machine, so refuse to ship one.
if x86_64-w64-mingw32-objdump -p "$exe" | grep -iE 'DLL Name: (libstdc|libgcc|libwinpthread)'; then
echo "alkane-toolkit.exe imports a mingw runtime DLL" >&2
exit 1
fi
;;
test)
headless cargo test --workspace --exclude wx-rs --target "$target" --offline 2>&1 \
| tee tests-windows.txt
;;
selftest)
bash scripts/ui-selftest-windows.sh "$exe"
;;
sign)
bash ci/sign-windows.sh "$exe"
;;
package)
python3 ci/package-windows.py release "${2:?usage: windows-ci.sh package VERSION}" "$exe" dist
;;
test-bundle)
mkdir -p dist
cargo test --workspace --exclude wx-rs --target "$target" --offline --no-run \
--message-format=json > "$out_dir/windows-tests.json"
python3 ci/package-windows.py tests "$out_dir/windows-tests.json" \
dist/alkane-toolkit-windows-tests.zip
;;
*)
sed -n '3,19p' "$0" >&2
exit 2
;;
esac
+40
View File
@@ -0,0 +1,40 @@
#!/usr/bin/env bash
# SPDX-License-Identifier: MIT
# Key a wxWidgets prefix to its tracked source and build toolchain.
# wx-cache-key.sh [linux|windows]
set -euo pipefail
platform="${1:-linux}"
if [ "$platform" = windows ]; then
material="$({
git rev-parse HEAD:thirdparty/wxwidgets/wxWidgets-3.3.3
git rev-parse HEAD:scripts/build-wx-windows.sh
x86_64-w64-mingw32-g++-posix -dumpmachine
x86_64-w64-mingw32-g++-posix -dumpfullversion
} )"
digest="$(printf '%s\n' "$material" | sha256sum | cut -c1-24)"
key="wx-3.3.3-mingw-$digest"
if [ -n "${GITHUB_OUTPUT:-}" ]; then printf 'key=%s\n' "$key" >> "$GITHUB_OUTPUT"; else printf '%s\n' "$key"; fi
exit 0
fi
material="$({
git rev-parse HEAD:thirdparty/wxwidgets/wxWidgets-3.3.3
git rev-parse HEAD:scripts/build-wx-linux.sh
cat thirdparty/wx-rs/VERSION
gcc -dumpmachine
gcc -dumpfullversion
pkg-config --modversion gtk+-3.0
mapfile -t modules < <(pkg-config --list-all | awk '{print $1}' | LC_ALL=C sort -u)
for module in "${modules[@]}"; do
printf '%s=%s\n' "$module" "$(pkg-config --modversion "$module" 2>/dev/null || printf unavailable)"
done
getconf GNU_LIBC_VERSION
} )"
digest="$(printf '%s\n' "$material" | sha256sum | cut -c1-24)"
key="wx-3.3.3-$digest"
if [ -n "${GITHUB_OUTPUT:-}" ]; then
printf 'key=%s\n' "$key" >> "$GITHUB_OUTPUT"
else
printf '%s\n' "$key"
fi
+219 -1
View File
@@ -1 +1,219 @@
// alkane-access
// SPDX-License-Identifier: MIT
//! Bounded, read-only SSH probes for board identification.
use std::fs;
use std::io::{self, Read};
use std::net::IpAddr;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::thread;
use std::time::{Duration, Instant};
const MAX_PROBE_BYTES: usize = 64 * 1024;
const PROBE_TIMEOUT: Duration = Duration::from_secs(12);
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Probe {
KernelRelease,
MtdTable,
DeviceTreeModel,
}
impl Probe {
fn command(self) -> &'static str {
match self {
Self::KernelRelease => "uname -r",
Self::MtdTable => "cat /proc/mtd",
Self::DeviceTreeModel => "cat /proc/device-tree/model",
}
}
}
#[derive(Debug)]
pub enum AccessError {
InvalidTarget,
InvalidKnownHosts,
Timeout,
OutputTooLarge,
RemoteFailure,
Io(io::Error),
}
impl From<io::Error> for AccessError {
fn from(error: io::Error) -> Self {
Self::Io(error)
}
}
pub struct SshTarget {
address: IpAddr,
port: u16,
user: String,
known_hosts: PathBuf,
}
impl SshTarget {
pub fn new(
address: IpAddr,
port: u16,
user: &str,
known_hosts: &Path,
) -> Result<Self, AccessError> {
if port == 0
|| user.is_empty()
|| !user
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'-' | b'.'))
{
return Err(AccessError::InvalidTarget);
}
if !known_hosts.is_absolute()
|| !fs::metadata(known_hosts).is_ok_and(|metadata| metadata.is_file())
{
return Err(AccessError::InvalidKnownHosts);
}
Ok(Self {
address,
port,
user: user.to_owned(),
known_hosts: known_hosts.to_owned(),
})
}
fn command(&self, probe: Probe) -> Command {
let mut command = alkane_core::platform::quiet_command("ssh");
command
.arg("-F")
.arg("none")
.arg("-o")
.arg("BatchMode=yes")
.arg("-o")
.arg("StrictHostKeyChecking=yes")
.arg("-o")
.arg("GlobalKnownHostsFile=none")
.arg("-o")
.arg(format!("UserKnownHostsFile={}", self.known_hosts.display()))
.arg("-o")
.arg("ConnectTimeout=5")
.arg("-o")
.arg("ServerAliveInterval=5")
.arg("-o")
.arg("ServerAliveCountMax=1")
.arg("-o")
.arg("RequestTTY=no")
.arg("-p")
.arg(self.port.to_string())
.arg(format!("{}@{}", self.user, self.address))
.arg(probe.command());
command
}
pub fn probe(&self, probe: Probe) -> Result<Vec<u8>, AccessError> {
run_bounded(self.command(probe))
}
}
fn collect_bounded<R: Read + Send + 'static>(
mut reader: R,
) -> thread::JoinHandle<Result<Vec<u8>, AccessError>> {
thread::spawn(move || {
let mut data = Vec::new();
let mut chunk = [0_u8; 4096];
loop {
let count = reader.read(&mut chunk)?;
if count == 0 {
return Ok(data);
}
if data.len() + count > MAX_PROBE_BYTES {
return Err(AccessError::OutputTooLarge);
}
data.extend_from_slice(&chunk[..count]);
}
})
}
fn run_bounded(command: Command) -> Result<Vec<u8>, AccessError> {
run_bounded_with_timeout(command, PROBE_TIMEOUT)
}
fn run_bounded_with_timeout(
mut command: Command,
timeout: Duration,
) -> Result<Vec<u8>, AccessError> {
command
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
let mut child = command.spawn()?;
let stdout = collect_bounded(child.stdout.take().expect("piped stdout"));
let stderr = collect_bounded(child.stderr.take().expect("piped stderr"));
let deadline = Instant::now() + timeout;
let result = loop {
if let Some(status) = child.try_wait()? {
break status.success();
}
if Instant::now() >= deadline {
let _ = child.kill();
let _ = child.wait();
let _ = stdout.join();
let _ = stderr.join();
return Err(AccessError::Timeout);
}
thread::sleep(Duration::from_millis(10));
};
let output = stdout.join().map_err(|_| AccessError::RemoteFailure)??;
let error_output = stderr.join().map_err(|_| AccessError::RemoteFailure)??;
if !result || !error_output.is_empty() {
return Err(AccessError::RemoteFailure);
}
Ok(output)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn target_rejects_injected_user_and_unknown_host_file() {
let address = "127.0.0.1".parse().unwrap();
assert!(matches!(
SshTarget::new(
address,
22,
"root;id",
Path::new("/etc/ssh/ssh_known_hosts")
),
Err(AccessError::InvalidTarget)
));
assert!(matches!(
SshTarget::new(address, 22, "root", Path::new("relative-known-hosts")),
Err(AccessError::InvalidKnownHosts)
));
}
#[cfg(unix)]
#[test]
fn bounded_runner_rejects_excess_output_and_failed_command() {
let mut success = Command::new("/bin/sh");
success.args(["-c", "printf board"]);
assert_eq!(run_bounded(success).unwrap(), b"board");
let mut overflow = Command::new("/bin/sh");
overflow.args(["-c", "head -c 70000 /dev/zero"]);
assert!(matches!(
run_bounded(overflow),
Err(AccessError::OutputTooLarge)
));
let mut failed = Command::new("/bin/sh");
failed.args(["-c", "exit 7"]);
assert!(matches!(
run_bounded(failed),
Err(AccessError::RemoteFailure)
));
let mut hanging = Command::new("/bin/sleep");
hanging.arg("1");
assert!(matches!(
run_bounded_with_timeout(hanging, Duration::from_millis(20)),
Err(AccessError::Timeout)
));
}
}
+4
View File
@@ -6,3 +6,7 @@ license.workspace = true
[dependencies]
alkane-core = { path = "../alkane-core" }
serde.workspace = true
serde_json.workspace = true
sha2.workspace = true
thiserror.workspace = true
File diff suppressed because it is too large Load Diff
+404
View File
@@ -0,0 +1,404 @@
// SPDX-License-Identifier: MIT
//! Fetch the latest alkane-os `.afw` release from a Gitea repository.
//!
//! GitHub is retired for this project; releases live on the self-hosted Gitea.
//! This resolves `releases/latest`, picks the `.afw` asset for a board, and
//! downloads it so the normal verify -> plan -> preflight -> install flow runs on
//! it exactly as it would on a local file. TLS is required, so this shells out to
//! `curl` (as the GUI already does) rather than the plaintext TCP path used for
//! liveness checks.
//!
//! A private repo needs a token; it is read from the environment at run time
//! (`ALKANE_RELEASE_TOKEN`, else `GITEA_TOKEN`) and passed to curl through a
//! 0600 config file, never on the command line.
//!
//! As a convenience for the GUI, a read-only token can be baked into the binary
//! at build time by compiling with `ALKANE_EMBEDDED_TOKEN=<token>` set (see
//! `EMBEDDED_TOKEN`). The source tree carries no secret - the value lives only in
//! a binary built with that variable set - and the environment variables above
//! always take precedence, so a user can override it. When no such token is baked
//! in and none is in the environment, the token is simply absent (fine for public
//! repos; a private repo then returns 401/404).
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use serde_json::Value;
use thiserror::Error;
/// A read-only Gitea token baked in at build time when the crate is compiled
/// with `ALKANE_EMBEDDED_TOKEN` set. `None` in an ordinary build (no secret in
/// the source tree). The environment variables win over this, so it is only a
/// fallback for a distributed binary (the GUI) that ships without asking the user
/// to configure a token. Scope it read-only on the server side; anyone with the
/// binary can extract it.
const EMBEDDED_TOKEN: Option<&str> = option_env!("ALKANE_EMBEDDED_TOKEN");
#[derive(Debug, Error)]
pub enum FetchError {
#[error("curl failed: {0}")]
Curl(String),
#[error("release metadata did not parse: {0}")]
Parse(String),
#[error("no .afw asset for board {0} in the latest release")]
NoAsset(String),
#[error("io: {0}")]
Io(String),
}
/// Where releases come from. Defaults to the alkane-os repo on the self-hosted
/// Gitea; the base URL and token are read from the environment.
pub struct ReleaseSource {
pub base_url: String,
pub owner: String,
pub repo: String,
pub token: Option<String>,
}
impl ReleaseSource {
/// The alkane-os release source, honoring `ALKANE_RELEASE_BASE` and a token
/// from `ALKANE_RELEASE_TOKEN` or `GITEA_TOKEN`.
pub fn alkane_os() -> Self {
let base_url = std::env::var("ALKANE_RELEASE_BASE")
.ok()
.filter(|s| !s.is_empty())
.unwrap_or_else(|| "https://gitea.bluefla.re".to_string());
let token = std::env::var("ALKANE_RELEASE_TOKEN")
.ok()
.or_else(|| std::env::var("GITEA_TOKEN").ok())
.filter(|t| !t.is_empty())
.or_else(|| EMBEDDED_TOKEN.map(str::to_string).filter(|t| !t.is_empty()));
Self {
base_url,
owner: "blueflare".to_string(),
repo: "alkane-os".to_string(),
token,
}
}
/// The releases list (newest first). Unlike `releases/latest`, this includes
/// pre-releases, so an early/bench channel is still found by `--latest`.
fn api_list(&self) -> String {
format!(
"{}/api/v1/repos/{}/{}/releases?limit=50",
self.base_url.trim_end_matches('/'),
self.owner,
self.repo
)
}
}
/// Find the first `.afw` asset for `board` across a newest-first list of
/// releases. Returns (name, url).
fn pick_asset(releases: &Value, board: &str) -> Option<(String, String)> {
let needle = format!("-{board}-");
for release in releases.as_array()? {
let Some(assets) = release.get("assets").and_then(Value::as_array) else {
continue;
};
for asset in assets {
let name = asset.get("name").and_then(Value::as_str).unwrap_or("");
if name.ends_with(".afw") && name.contains(&needle) {
if let Some(url) = asset.get("browser_download_url").and_then(Value::as_str) {
return Some((name.to_string(), url.to_string()));
}
}
}
}
None
}
/// A temp curl `--config` file carrying the auth header, removed on drop so the
/// token never lands in a process argument or a lingering file.
struct TokenConfig {
path: Option<PathBuf>,
}
impl TokenConfig {
fn new(token: &Option<String>) -> Result<Self, FetchError> {
let Some(token) = token else {
return Ok(Self { path: None });
};
let path = std::env::temp_dir().join(format!("alkane-fetch-{}.cfg", std::process::id()));
write_private(
&path,
&format!("header = \"Authorization: token {token}\"\n"),
)?;
Ok(Self { path: Some(path) })
}
fn apply(&self, cmd: &mut Command) {
if let Some(path) = &self.path {
cmd.arg("--config").arg(path);
}
}
}
impl Drop for TokenConfig {
fn drop(&mut self) {
if let Some(path) = &self.path {
let _ = fs::remove_file(path);
}
}
}
#[cfg(unix)]
fn write_private(path: &Path, contents: &str) -> Result<(), FetchError> {
use std::io::Write;
use std::os::unix::fs::OpenOptionsExt;
let mut file = fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(path)
.map_err(|e| FetchError::Io(e.to_string()))?;
file.write_all(contents.as_bytes())
.map_err(|e| FetchError::Io(e.to_string()))
}
#[cfg(not(unix))]
fn write_private(path: &Path, contents: &str) -> Result<(), FetchError> {
fs::write(path, contents).map_err(|e| FetchError::Io(e.to_string()))
}
fn curl_bytes(src: &ReleaseSource, url: &str) -> Result<Vec<u8>, FetchError> {
let config = TokenConfig::new(&src.token)?;
let mut cmd = Command::new("curl");
cmd.arg("-fsSL").arg("--max-time").arg("120");
config.apply(&mut cmd);
cmd.arg(url);
let out = cmd.output().map_err(|e| FetchError::Curl(e.to_string()))?;
if !out.status.success() {
return Err(FetchError::Curl(format!(
"{} ({})",
String::from_utf8_lossy(&out.stderr).trim(),
out.status
)));
}
Ok(out.stdout)
}
fn curl_download(src: &ReleaseSource, url: &str, dest: &Path) -> Result<(), FetchError> {
let config = TokenConfig::new(&src.token)?;
let mut cmd = Command::new("curl");
cmd.arg("-fsSL")
.arg("--max-time")
.arg("600")
.arg("-o")
.arg(dest);
config.apply(&mut cmd);
cmd.arg(url);
let out = cmd.output().map_err(|e| FetchError::Curl(e.to_string()))?;
if !out.status.success() {
return Err(FetchError::Curl(format!(
"{} ({})",
String::from_utf8_lossy(&out.stderr).trim(),
out.status
)));
}
Ok(())
}
/// Resolve the latest release's `.afw` asset for `board`: returns (name, url).
/// Scans the newest-first releases list (so a pre-release counts as latest).
pub fn latest_afw_asset(src: &ReleaseSource, board: &str) -> Result<(String, String), FetchError> {
let body = curl_bytes(src, &src.api_list())?;
let releases: Value =
serde_json::from_slice(&body).map_err(|e| FetchError::Parse(e.to_string()))?;
pick_asset(&releases, board).ok_or_else(|| FetchError::NoAsset(board.to_string()))
}
/// Download the latest `.afw` for `board` into `dest_dir`; returns its path.
pub fn fetch_latest_afw(
src: &ReleaseSource,
board: &str,
dest_dir: &Path,
) -> Result<PathBuf, FetchError> {
let (name, url) = latest_afw_asset(src, board)?;
fs::create_dir_all(dest_dir).map_err(|e| FetchError::Io(e.to_string()))?;
let dest = dest_dir.join(&name);
curl_download(src, &url, &dest)?;
Ok(dest)
}
/// One `.afw` asset in a release.
#[derive(Debug, Clone)]
pub struct AfwAsset {
pub name: String,
pub url: String,
}
/// A release as listed for the GUI's release picker: its tag/name, whether it is
/// a pre-release or draft, when it was published, and the `.afw` assets it holds.
#[derive(Debug, Clone)]
pub struct ReleaseInfo {
pub tag: String,
pub name: String,
pub prerelease: bool,
pub draft: bool,
pub published_at: String,
pub afw_assets: Vec<AfwAsset>,
}
impl ReleaseInfo {
/// The `.afw` asset for `board` in this release, if any (matched by the
/// `-<board>-` segment of the filename, as `pick_asset` does).
pub fn asset_for_board(&self, board: &str) -> Option<&AfwAsset> {
let needle = format!("-{board}-");
self.afw_assets.iter().find(|a| a.name.contains(&needle))
}
}
/// Parse a Gitea releases array (newest first) into `ReleaseInfo`s, keeping only
/// the `.afw` assets of each. Drafts are included so the caller can decide.
fn parse_releases(releases: &Value) -> Vec<ReleaseInfo> {
let mut out = Vec::new();
let Some(arr) = releases.as_array() else {
return out;
};
for release in arr {
let tag = release
.get("tag_name")
.and_then(Value::as_str)
.unwrap_or("")
.to_string();
let name = release
.get("name")
.and_then(Value::as_str)
.unwrap_or("")
.to_string();
let prerelease = release
.get("prerelease")
.and_then(Value::as_bool)
.unwrap_or(false);
let draft = release
.get("draft")
.and_then(Value::as_bool)
.unwrap_or(false);
let published_at = release
.get("published_at")
.or_else(|| release.get("created_at"))
.and_then(Value::as_str)
.unwrap_or("")
.to_string();
let mut afw_assets = Vec::new();
if let Some(assets) = release.get("assets").and_then(Value::as_array) {
for asset in assets {
let aname = asset.get("name").and_then(Value::as_str).unwrap_or("");
if aname.ends_with(".afw") {
if let Some(url) = asset.get("browser_download_url").and_then(Value::as_str) {
afw_assets.push(AfwAsset {
name: aname.to_string(),
url: url.to_string(),
});
}
}
}
}
out.push(ReleaseInfo {
tag,
name,
prerelease,
draft,
published_at,
afw_assets,
});
}
out
}
/// List the releases (newest first) of the source repo, each with its `.afw`
/// assets. Used by the GUI to scan alkane-os releases and pick one to install.
pub fn list_releases(src: &ReleaseSource) -> Result<Vec<ReleaseInfo>, FetchError> {
let body = curl_bytes(src, &src.api_list())?;
let releases: Value =
serde_json::from_slice(&body).map_err(|e| FetchError::Parse(e.to_string()))?;
Ok(parse_releases(&releases))
}
/// Download a specific release asset (by its `browser_download_url`) into
/// `dest_dir`, saving it under `name`; returns the written path.
pub fn fetch_afw_url(
src: &ReleaseSource,
name: &str,
url: &str,
dest_dir: &Path,
) -> Result<PathBuf, FetchError> {
fs::create_dir_all(dest_dir).map_err(|e| FetchError::Io(e.to_string()))?;
let dest = dest_dir.join(name);
curl_download(src, url, &dest)?;
Ok(dest)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn source_defaults_to_alkane_os_on_gitea() {
std::env::remove_var("ALKANE_RELEASE_BASE");
let src = ReleaseSource::alkane_os();
assert_eq!(src.owner, "blueflare");
assert_eq!(src.repo, "alkane-os");
assert!(src
.api_list()
.contains("/api/v1/repos/blueflare/alkane-os/releases"));
assert!(src.api_list().starts_with("https://gitea.bluefla.re"));
}
#[test]
fn pick_asset_takes_the_newest_matching_afw() {
// Newest-first list of releases; the board's .afw in the first release wins.
let releases = serde_json::json!([
{"tag_name": "v0.1.0-bench1", "assets": [
{"name": "SHA256SUMS", "browser_download_url": "u0"},
{"name": "alkane-os-0.1.0-am335x-arm.afw", "browser_download_url": "u1"},
{"name": "alkane-os-0.1.0-zynq-7010-armv7.afw", "browser_download_url": "u2"},
]},
{"tag_name": "v0.0.9", "assets": [
{"name": "alkane-os-0.0.9-zynq-7010-armv7.afw", "browser_download_url": "old"},
]},
]);
assert_eq!(
pick_asset(&releases, "zynq-7010"),
Some(("alkane-os-0.1.0-zynq-7010-armv7.afw".into(), "u2".into()))
);
assert_eq!(pick_asset(&releases, "cv1835"), None);
}
#[test]
fn list_parses_releases_and_filters_afw_assets() {
let releases = serde_json::json!([
{"tag_name": "v0.2.0-bench1", "name": "bench", "prerelease": true, "draft": false,
"published_at": "2026-11-11T10:00:00Z", "assets": [
{"name": "SHA256SUMS", "browser_download_url": "s"},
{"name": "alkane-os-0.2.0-zynq-7010-armv7.afw", "browser_download_url": "z"},
]},
{"tag_name": "v0.1.0", "name": "", "prerelease": false, "draft": false,
"published_at": "2026-10-01T00:00:00Z", "assets": [
{"name": "alkane-os-0.1.0-am335x-arm.afw", "browser_download_url": "a"},
]},
]);
let parsed = parse_releases(&releases);
assert_eq!(parsed.len(), 2);
// Newest first; only .afw assets kept; SHA256SUMS dropped.
assert_eq!(parsed[0].tag, "v0.2.0-bench1");
assert!(parsed[0].prerelease);
assert_eq!(parsed[0].afw_assets.len(), 1);
// The board filter matches the -<board>- segment.
assert_eq!(
parsed[0]
.asset_for_board("zynq-7010")
.map(|a| a.url.as_str()),
Some("z")
);
assert!(parsed[0].asset_for_board("am335x").is_none());
assert_eq!(
parsed[1].asset_for_board("am335x").map(|a| a.name.as_str()),
Some("alkane-os-0.1.0-am335x-arm.afw")
);
assert!(parsed[1].asset_for_board("zynq-7010").is_none());
}
}
+260 -1
View File
@@ -1 +1,260 @@
// alkane-artifacts
// SPDX-License-Identifier: MIT
//! Verify local firmware artifacts before an install path consumes them.
pub mod afw;
pub mod fetch;
use sha2::{Digest, Sha256};
use std::collections::HashSet;
use std::fs::File;
use std::io::{Read, Seek, SeekFrom};
use std::path::{Component, Path, PathBuf};
use thiserror::Error;
const SEED: &str = include_str!("../data/manifest-seed.csv");
const HEADER: &str = "sha256,size_bytes,path,family,format,applicability";
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ArtifactRecord {
pub sha256: String,
pub size_bytes: u64,
pub path: PathBuf,
pub family: String,
pub format: String,
pub applicability: String,
}
#[derive(Debug, Error)]
pub enum VerifyError {
#[error("artifact I/O: {0}")]
Io(#[from] std::io::Error),
#[error("manifest line {0} is invalid")]
Manifest(usize),
#[error("artifact size differs from manifest")]
Size,
#[error("artifact signature does not match its declared format")]
Signature,
#[error("artifact SHA-256 differs from manifest")]
Digest,
#[error("artifact format is not recognized")]
UnsupportedFormat,
}
/// A verified, rewound descriptor. Consumers should read this descriptor
/// directly instead of reopening the path after verification.
pub struct VerifiedArtifact {
file: File,
record: ArtifactRecord,
}
impl VerifiedArtifact {
pub fn record(&self) -> &ArtifactRecord {
&self.record
}
pub fn reader(&mut self) -> &mut File {
&mut self.file
}
/// Recheck the same descriptor immediately before a guarded write.
pub fn revalidate(&mut self) -> Result<(), VerifyError> {
verify_open_file(&mut self.file, &self.record)
}
}
pub fn seed_manifest() -> Result<Vec<ArtifactRecord>, VerifyError> {
parse_manifest(SEED)
}
pub fn parse_manifest(text: &str) -> Result<Vec<ArtifactRecord>, VerifyError> {
let mut lines = text.lines();
if lines.next() != Some(HEADER) {
return Err(VerifyError::Manifest(1));
}
let mut paths = HashSet::new();
let mut records = Vec::new();
for (line_number, line) in lines.enumerate() {
let line_number = line_number + 2;
let parts: Vec<_> = line.splitn(6, ',').collect();
if parts.len() != 6 || parts.iter().any(|part| part.trim().is_empty()) {
return Err(VerifyError::Manifest(line_number));
}
let digest = parts[0];
let path = PathBuf::from(parts[2]);
if digest.len() != 64
|| !digest.bytes().all(|byte| byte.is_ascii_hexdigit())
|| !path
.components()
.all(|part| matches!(part, Component::Normal(_)))
|| !paths.insert(path.clone())
{
return Err(VerifyError::Manifest(line_number));
}
let size_bytes = parts[1]
.parse::<u64>()
.map_err(|_| VerifyError::Manifest(line_number))?;
if size_bytes == 0 {
return Err(VerifyError::Manifest(line_number));
}
records.push(ArtifactRecord {
sha256: digest.to_ascii_lowercase(),
size_bytes,
path,
family: parts[3].to_owned(),
format: parts[4].to_owned(),
applicability: parts[5].to_owned(),
});
}
if records.is_empty() {
return Err(VerifyError::Manifest(1));
}
Ok(records)
}
fn signature_matches(format: &str, first: &[u8]) -> Result<bool, VerifyError> {
let prefix: &[u8] = match format {
"IMAGEWTY-SD" | "update-zip" | "zip-installer" => b"PK\x03\x04",
"ubifs" => b"\x31\x18\x10\x06",
"swu" => b"070702",
"wm-package-0x9a5ba57c" => b"\x7c\xa5\x5b\x9a",
"bmu" => b"\x26\x01",
"bin-AES-container" => b"\x3f\x0a\x64\xae",
_ => return Err(VerifyError::UnsupportedFormat),
};
Ok(first.starts_with(prefix))
}
pub fn verify_file(path: &Path, record: &ArtifactRecord) -> Result<VerifiedArtifact, VerifyError> {
let mut file = File::open(path)?;
verify_open_file(&mut file, record)?;
Ok(VerifiedArtifact {
file,
record: record.clone(),
})
}
fn verify_open_file(file: &mut File, record: &ArtifactRecord) -> Result<(), VerifyError> {
if file.metadata()?.len() != record.size_bytes {
return Err(VerifyError::Size);
}
file.seek(SeekFrom::Start(0))?;
let mut first = [0_u8; 16];
let length = file.read(&mut first)?;
if !signature_matches(&record.format, &first[..length])? {
return Err(VerifyError::Signature);
}
file.seek(SeekFrom::Start(0))?;
let mut hasher = Sha256::new();
let mut buffer = [0_u8; 64 * 1024];
let mut read_bytes = 0_u64;
loop {
let length = file.read(&mut buffer)?;
if length == 0 {
break;
}
read_bytes += length as u64;
hasher.update(&buffer[..length]);
}
if read_bytes != record.size_bytes {
return Err(VerifyError::Size);
}
let digest = hasher.finalize();
let actual: String = digest.iter().map(|byte| format!("{byte:02x}")).collect();
if actual != record.sha256 {
return Err(VerifyError::Digest);
}
file.seek(SeekFrom::Start(0))?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Write;
#[test]
fn manifest_has_unique_safe_records() {
let records = seed_manifest().unwrap();
assert_eq!(records.len(), 14);
let traversal = format!("{HEADER}\n{},12,../escape,bin,bmu,all\n", "0".repeat(64));
assert!(matches!(
parse_manifest(&traversal),
Err(VerifyError::Manifest(2))
));
}
#[test]
fn checks_size_signature_and_digest_before_consumption() {
let path =
std::env::temp_dir().join(format!("alkane-artifact-test-{}", std::process::id()));
let bytes = b"PK\x03\x04example";
let mut file = File::create(&path).unwrap();
file.write_all(bytes).unwrap();
drop(file);
let mut record = ArtifactRecord {
sha256: Sha256::digest(bytes)
.iter()
.map(|byte| format!("{byte:02x}"))
.collect(),
size_bytes: bytes.len() as u64,
path: PathBuf::from("fixture.zip"),
family: "test".to_owned(),
format: "update-zip".to_owned(),
applicability: "test".to_owned(),
};
let mut verified = verify_file(&path, &record).unwrap();
verified.revalidate().unwrap();
let mut replay = Vec::new();
verified.reader().read_to_end(&mut replay).unwrap();
assert_eq!(replay, bytes);
std::fs::write(&path, b"PK\x03\x04changed").unwrap();
assert!(matches!(verified.revalidate(), Err(VerifyError::Digest)));
std::fs::write(&path, bytes).unwrap();
verified.revalidate().unwrap();
record.size_bytes += 1;
assert!(matches!(
verify_file(&path, &record),
Err(VerifyError::Size)
));
record.size_bytes -= 1;
record.format = "ubifs".to_owned();
assert!(matches!(
verify_file(&path, &record),
Err(VerifyError::Signature)
));
record.format = "update-zip".to_owned();
record.sha256 = "0".repeat(64);
assert!(matches!(
verify_file(&path, &record),
Err(VerifyError::Digest)
));
std::fs::remove_file(path).unwrap();
}
#[test]
#[ignore = "microbenchmark"]
fn bench_verify_artifact() {
let path =
std::env::temp_dir().join(format!("alkane-artifact-bench-{}", std::process::id()));
let mut bytes = vec![0x42_u8; 65_536];
bytes[..4].copy_from_slice(b"PK\x03\x04");
std::fs::write(&path, &bytes).unwrap();
let record = ArtifactRecord {
sha256: Sha256::digest(&bytes)
.iter()
.map(|byte| format!("{byte:02x}"))
.collect(),
size_bytes: bytes.len() as u64,
path: PathBuf::from("bench.zip"),
family: "test".to_owned(),
format: "update-zip".to_owned(),
applicability: "test".to_owned(),
};
let started = std::time::Instant::now();
for _ in 0..100 {
std::hint::black_box(verify_file(&path, &record).unwrap());
}
println!("bench_verify_artifact: {:?}", started.elapsed() / 100);
std::fs::remove_file(path).unwrap();
}
}
+3
View File
@@ -6,3 +6,6 @@ license.workspace = true
[dependencies]
alkane-core = { path = "../alkane-core" }
alkane-artifacts = { path = "../alkane-artifacts" }
alkane-flash = { path = "../alkane-flash" }
serde_json.workspace = true
File diff suppressed because it is too large Load Diff
+2
View File
@@ -1 +1,3 @@
// alkane-core
pub mod platform;
+148
View File
@@ -0,0 +1,148 @@
//! The few places the toolkit's behaviour depends on the operating system,
//! kept together so the rest of the code stays platform-neutral.
//!
//! - where per-user settings live ([`config_dir`]),
//! - how a secret file is written so only its owner can read it
//! ([`write_private`]),
//! - the null device for tools that insist on an output path ([`NULL_DEVICE`]),
//! - how helper programs (`ssh`, `curl`) are started from the GUI without a
//! console window popping up on Windows ([`quiet_command`]).
use std::path::{Path, PathBuf};
use std::process::Command;
/// Directory name of the toolkit's settings under the per-user config root.
pub const APP_DIR: &str = "alkane-toolkit";
/// Environment variable whose value is the per-user config root on this
/// platform: `HOME` (settings in `$HOME/.config/alkane-toolkit`) on Unix,
/// `APPDATA` (settings in `%APPDATA%\alkane-toolkit`) on Windows. Tests point it
/// at a scratch directory.
#[cfg(not(windows))]
pub const CONFIG_ROOT_VAR: &str = "HOME";
#[cfg(windows)]
pub const CONFIG_ROOT_VAR: &str = "APPDATA";
/// The per-user settings directory (not created here).
///
/// Unix keeps the long-standing `$HOME/.config/alkane-toolkit`. Windows uses
/// the roaming application-data folder, `%APPDATA%\alkane-toolkit`, which is
/// where Windows applications keep per-user settings and which the user
/// profile's ACL already restricts to its owner. A missing variable falls back
/// to the working directory, as before.
pub fn config_dir() -> PathBuf {
let root = std::env::var_os(CONFIG_ROOT_VAR).unwrap_or_else(|| ".".into());
if cfg!(windows) {
PathBuf::from(root).join(APP_DIR)
} else {
PathBuf::from(root).join(".config").join(APP_DIR)
}
}
/// `config_dir()/file`.
pub fn config_path(file: &str) -> PathBuf {
config_dir().join(file)
}
/// The null device, for tools that want an output path (`curl -o`,
/// `ssh -o UserKnownHostsFile=`).
#[cfg(not(windows))]
pub const NULL_DEVICE: &str = "/dev/null";
#[cfg(windows)]
pub const NULL_DEVICE: &str = "NUL";
/// Write `data` to `path` so only the owner can read it.
///
/// On Unix the file is created 0600 (so a secret is never momentarily
/// world-readable between write and chmod), and a pre-existing file is
/// re-tightened while it is still empty, before the plaintext is written. On
/// Windows the settings directory inherits the user profile's owner-only ACL,
/// so a plain write already has the equivalent protection.
pub fn write_private(path: &Path, data: &[u8]) -> std::io::Result<()> {
#[cfg(unix)]
{
use std::io::Write;
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt};
let mut f = std::fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(true)
.mode(0o600)
.open(path)?;
f.set_permissions(std::fs::Permissions::from_mode(0o600))?;
f.write_all(data)
}
#[cfg(not(unix))]
{
std::fs::write(path, data)
}
}
/// A [`Command`] for a helper program run in the background of the GUI.
///
/// On Windows a console program (`ssh.exe`, `curl.exe`) started from a GUI
/// process gets a new console window by default, so every probe would flash a
/// black window; `CREATE_NO_WINDOW` suppresses that while keeping its piped
/// stdin/stdout/stderr. Elsewhere this is `Command::new`.
pub fn quiet_command(program: &str) -> Command {
#[allow(unused_mut)]
let mut command = Command::new(program);
#[cfg(windows)]
{
use std::os::windows::process::CommandExt;
const CREATE_NO_WINDOW: u32 = 0x0800_0000;
command.creation_flags(CREATE_NO_WINDOW);
}
command
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn config_dir_is_under_the_platform_root() {
let dir = config_dir();
assert!(dir.ends_with(APP_DIR), "{dir:?}");
if cfg!(windows) {
assert!(!dir.to_string_lossy().contains(".config"), "{dir:?}");
} else {
assert!(dir.parent().unwrap().ends_with(".config"), "{dir:?}");
}
assert_eq!(config_path("x.txt"), dir.join("x.txt"));
}
#[test]
fn write_private_round_trips_and_restricts() {
let dir = std::env::temp_dir().join(format!("alkane-private-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("secret.txt");
write_private(&path, b"one").unwrap();
write_private(&path, b"two").unwrap();
assert_eq!(std::fs::read(&path).unwrap(), b"two");
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let mode = std::fs::metadata(&path).unwrap().permissions().mode() & 0o777;
assert_eq!(mode, 0o600);
}
std::fs::remove_dir_all(&dir).unwrap();
}
#[test]
fn quiet_command_runs_with_piped_output() {
// `cmd /C echo` and `sh -c echo` are the platform's own shells.
let mut command = if cfg!(windows) {
let mut c = quiet_command("cmd");
c.args(["/C", "echo alkane"]);
c
} else {
let mut c = quiet_command("sh");
c.args(["-c", "echo alkane"]);
c
};
let out = command.output().unwrap();
assert!(out.status.success());
assert!(String::from_utf8_lossy(&out.stdout).contains("alkane"));
}
}
+5
View File
@@ -6,3 +6,8 @@ license.workspace = true
[dependencies]
alkane-core = { path = "../alkane-core" }
alkane-artifacts = { path = "../alkane-artifacts" }
serde_json.workspace = true
sha2.workspace = true
thiserror.workspace = true
tempfile = "3"
+880
View File
@@ -0,0 +1,880 @@
// SPDX-License-Identifier: MIT
//! Amlogic A113D / AXG (Antminer S21 Pro-class) board module: tier-2 network
//! UPDATE of a board already running alkane. Our OS is staged as FILES in the
//! nvdata UBI volume: alkane/{vmlinux.bin, devicetree.dtb, uramdisk.image.gz}.
//! (The legacy vendor path name "anthillos" from AnthillOS is no longer used;
//! our own bootcmd loads from alkane/.)
//!
//! The running alkane image exposes ONLY the nvdata region as an MTD (the board
//! DT declares a single `nvdata` fixed-partition; the FIP bootloader and the
//! stock boot/recovery/misc/config regions are deliberately undeclared, so they
//! are never registered as MTD devices and cannot be written from Linux). This
//! module attaches UBI to that one nvdata MTD, mounts the UBIFS volume, and
//! overwrites the three files under alkane/. It performs no raw mtd0-5 write and
//! never changes the bootloader: the brick-sensitive regions are physically
//! unreachable.
//!
//! The first from-stock install (past the signed bootloader) is handled
//! elsewhere and is NOT this module. This is the repeatable alkane-to-alkane
//! update.
use crate::md5::md5_hex;
use crate::preflight::{classify, parse_digest};
use crate::transport::{Remote, RemoteError};
use alkane_artifacts::afw::{AfwImage, BootloaderPolicy, VerifiedAfw};
use std::fs;
use std::io::Write;
use std::path::PathBuf;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use thiserror::Error;
pub const BOARD: &str = "a113d";
pub const ARCH: &str = "arm64";
/// The UBI volume subdirectory our boot chain reads our OS files from. This is
/// alkane's own name; the board's `ourbootcmd` loads from here.
pub const ALKANE_DIR: &str = "alkane";
/// nvdata UBI usable size; the three files together must fit (0xB900000).
pub const NVDATA_USABLE: u64 = 0xB900000;
/// The only MTD partition our DT exposes. mtd0-5 (FIP + stock boot) are not
/// declared in the DT at all, so they are not MTD devices on a running image.
pub const NVDATA_LABEL: &str = "nvdata";
/// Authoritative file targets: (image, on-board basename, ceiling, format).
/// Written rootfs -> dtb -> kernel so a mid-write interruption never leaves a
/// new rootfs beside an old kernel (the kernel file lands last).
const TARGETS: [(&str, &str, u64, &str); 3] = [
("rootfs", "uramdisk.image.gz", 0x6000000, "uimage"),
("dtb", "devicetree.dtb", 0x100000, "fdt"),
("kernel", "vmlinux.bin", 0x4000000, "arm64-image"),
];
#[derive(Debug, Error)]
pub enum A113dPlanError {
#[error("bundle is for {0}, not a113d")]
WrongBoard(String),
#[error("bundle arch is {0}, a113d needs arm64")]
WrongArch(String),
#[error("a113d requires bootloader_policy preserve (the FIP is never written)")]
BootloaderPolicy,
#[error("a113d bundle carries a bootloader/spl/fip/tpl member: {0}")]
BootloaderMember(String),
#[error("manifest is not an OS payload")]
PayloadType,
#[error("manifest marker is empty")]
Marker,
#[error("a113d must install exactly kernel, dtb and rootfs")]
InstallCount,
#[error("a113d is missing the {0} image")]
MissingImage(String),
#[error("a113d {image} format is {actual}, expected {expected}")]
ImageFormat {
image: String,
actual: String,
expected: &'static str,
},
#[error("a113d {image} is {size} bytes, over the 0x{ceiling:x}-byte ceiling")]
ImageTooLarge {
image: String,
size: u64,
ceiling: u64,
},
#[error("a113d images total {total} bytes, over the nvdata UBI (0x{usable:x})")]
OverNvdata { total: u64, usable: u64 },
#[error("a113d {image} is not an arm64 Image")]
NotArm64 { image: String },
#[error("a113d {image} is not an FDT")]
NotFdt { image: String },
#[error("a113d {image} is not a legacy uImage")]
NotUimage { image: String },
#[error("a113d refuses: preserved partition {0} (mtd0-5) carries an image")]
PreservedCarriesImage(String),
#[error("a113d refuses an unsafe destination for {image}: {dest}")]
UnsafeDest { image: String, dest: String },
}
#[derive(Clone, Debug)]
pub struct A113dTarget {
pub image_name: String,
/// On-board basename inside the alkane directory (never a device path).
pub dest: String,
pub size: u64,
pub data: Vec<u8>,
pub expected_md5: String,
}
#[derive(Clone, Debug)]
pub struct A113dPlan {
pub targets: Vec<A113dTarget>,
pub marker: String,
pub kernel_version: String,
pub sdk_revision: String,
pub os_revision: String,
pub afw_sha256: String,
pub min_free_bytes: u64,
}
fn is_bootloaderish(image: &AfwImage) -> bool {
let lowered = format!("{} {} {}", image.name, image.file, image.role).to_lowercase();
image.role == "bootloader"
|| lowered.contains("spl")
|| lowered.contains("u-boot")
|| lowered.contains("uboot")
|| lowered.contains("fip")
|| lowered.contains("tpl")
}
/// A destination is safe only as a bare basename (no separators, no traversal,
/// not a device path). This keeps every write inside the alkane/ directory.
fn is_safe_dest(dest: &str) -> bool {
!dest.is_empty()
&& !dest.contains('/')
&& !dest.contains("..")
&& !dest.starts_with("/dev/")
&& dest == dest.trim()
}
impl A113dPlan {
pub fn from_afw(afw: &VerifiedAfw) -> Result<Self, A113dPlanError> {
let manifest = &afw.manifest;
if manifest.board != BOARD {
return Err(A113dPlanError::WrongBoard(manifest.board.clone()));
}
if manifest.arch != ARCH {
return Err(A113dPlanError::WrongArch(manifest.arch.clone()));
}
if manifest.payload_type != "os" {
return Err(A113dPlanError::PayloadType);
}
if manifest.bootloader_policy != BootloaderPolicy::Preserve {
return Err(A113dPlanError::BootloaderPolicy);
}
if manifest.marker.is_empty() {
return Err(A113dPlanError::Marker);
}
// FIP / bootloader members are never allowed - we reuse the board's.
for image in &manifest.images {
if is_bootloaderish(image) {
return Err(A113dPlanError::BootloaderMember(image.file.clone()));
}
}
// Defense in depth: only nvdata (mtd6) may carry an image; mtd0-5 preserved.
for partition in &manifest.partitions {
if partition.name != "nvdata" && partition.image.is_some() {
return Err(A113dPlanError::PreservedCarriesImage(
partition.name.clone(),
));
}
}
let installs: Vec<&AfwImage> = manifest.images.iter().filter(|i| i.install).collect();
if installs.len() != TARGETS.len() {
return Err(A113dPlanError::InstallCount);
}
let mut targets = Vec::with_capacity(TARGETS.len());
let mut total = 0u64;
for (image_name, dest, ceiling, expected_format) in TARGETS {
let image = manifest
.images
.iter()
.find(|i| i.name == image_name && i.install)
.ok_or_else(|| A113dPlanError::MissingImage(image_name.to_owned()))?;
if image.format != expected_format {
return Err(A113dPlanError::ImageFormat {
image: image_name.to_owned(),
actual: image.format.clone(),
expected: expected_format,
});
}
if image.size > ceiling {
return Err(A113dPlanError::ImageTooLarge {
image: image_name.to_owned(),
size: image.size,
ceiling,
});
}
if !is_safe_dest(dest) {
return Err(A113dPlanError::UnsafeDest {
image: image_name.to_owned(),
dest: dest.to_owned(),
});
}
let data = afw
.image(image_name)
.map(|(_, data)| data)
.ok_or_else(|| A113dPlanError::MissingImage(image_name.to_owned()))?;
// Each arm validates a different magic; keeping them as explicit
// arms (not match guards) reads more clearly than collapsing.
#[allow(clippy::collapsible_match)]
match expected_format {
"arm64-image" => {
if !(data.len() >= 0x3C && data[0x38..0x3C] == *b"ARMd") {
return Err(A113dPlanError::NotArm64 {
image: image_name.to_owned(),
});
}
}
"fdt" => {
if !(data.len() >= 4 && data[0..4] == [0xd0, 0x0d, 0xfe, 0xed]) {
return Err(A113dPlanError::NotFdt {
image: image_name.to_owned(),
});
}
}
"uimage" => {
if !(data.len() >= 4 && data[0..4] == [0x27, 0x05, 0x19, 0x56]) {
return Err(A113dPlanError::NotUimage {
image: image_name.to_owned(),
});
}
}
_ => {}
}
total += image.size;
targets.push(A113dTarget {
image_name: image_name.to_owned(),
dest: dest.to_owned(),
size: image.size,
expected_md5: md5_hex(data),
data: data.to_vec(),
});
}
if total > NVDATA_USABLE {
return Err(A113dPlanError::OverNvdata {
total,
usable: NVDATA_USABLE,
});
}
Ok(Self {
targets,
marker: manifest.marker.clone(),
kernel_version: manifest.kernel_version.clone(),
sdk_revision: manifest.sdk_revision.clone(),
os_revision: manifest.os_revision.clone(),
afw_sha256: afw.archive_sha256.clone(),
min_free_bytes: manifest
.preflight
.get("min_free_bytes")
.and_then(|v| v.as_u64())
.unwrap_or(16 * 1024 * 1024),
})
}
pub fn render(&self) -> String {
let mut out = format!("board {BOARD} arch {ARCH}\n");
out.push_str(
"tier 2 update: attach UBI to the nvdata MTD, mount it, and overwrite the OS files \
under alkane/; the FIP + stock boot/recovery/misc/config are not MTD devices at all, \
so no raw NAND write is possible\n",
);
out.push_str("image format kernel=arm64-image, dtb=fdt, rootfs=uimage\n");
for target in &self.targets {
out.push_str(&format!(
"write {} -> {ALKANE_DIR}/{} size {} B md5 {}\n",
target.image_name, target.dest, target.size, target.expected_md5
));
}
out.push_str(&format!(
"marker {} kernel {} sdk {} os {}",
self.marker,
self.kernel_version,
short(&self.sdk_revision),
short(&self.os_revision),
));
out
}
}
fn short(rev: &str) -> &str {
rev.get(..12).unwrap_or(rev)
}
#[derive(Debug, Error)]
pub enum A113dError {
#[error("preflight failed:\n{0}")]
Preflight(String),
#[error("--confirm FLASH is required to write")]
Confirm,
#[error("the running image exposes no '{0}' MTD; it needs a NAND-enabled a113d kernel")]
NoNvdataMtd(String),
#[error("could not attach UBI to the nvdata MTD / find its volume")]
UbiAttach,
#[error("could not mount the nvdata UBIFS volume")]
Mount,
#[error("refusing an unsafe destination: {0}")]
UnsafeDest(String),
#[error("{0} staged md5 differs from the verified bundle")]
StageMismatch(String),
#[error("{0} read-back md5 mismatch; do not reboot")]
Readback(String),
#[error(transparent)]
Remote(#[from] RemoteError),
#[error(transparent)]
Io(#[from] std::io::Error),
}
#[derive(Clone, Debug)]
pub struct A113dCheck {
pub name: String,
pub ok: bool,
pub detail: String,
}
#[derive(Clone, Debug)]
pub struct A113dPreflight {
pub host: String,
pub checks: Vec<A113dCheck>,
/// The nvdata MTD index (e.g. 0 for /dev/mtd0), when the running image
/// exposes it. Used for `ubiattach -m <index>`.
pub nvdata_mtd: Option<u32>,
}
impl A113dPreflight {
pub fn ok(&self) -> bool {
self.checks.iter().all(|c| c.ok)
}
pub fn render(&self) -> String {
let mut out = format!("preflight {}\n", self.host);
for c in &self.checks {
out.push_str(&format!(
"check {} {}: {}\n",
c.name,
if c.ok { "ok" } else { "FAIL" },
c.detail
));
}
out.push_str(&format!(
"result {}",
if self.ok() {
"PASS"
} else {
"FAIL (do not write)"
}
));
out
}
}
/// Parse /proc/mtd for a partition labelled "nvdata" and return its mtd index.
/// e.g. `mtd0: 0b900000 00020000 "nvdata"` -> Some(0).
fn parse_nvdata_mtd(proc_mtd: &str) -> Option<u32> {
for line in proc_mtd.lines() {
let line = line.trim();
if !line.starts_with("mtd") {
continue;
}
let (dev, rest) = line.split_once(':')?;
if rest.contains(&format!("\"{NVDATA_LABEL}\"")) {
return dev.trim_start_matches("mtd").parse::<u32>().ok();
}
}
None
}
pub fn preflight(
plan: &A113dPlan,
remote: &mut dyn Remote,
host: &str,
) -> Result<A113dPreflight, A113dError> {
let mut checks = Vec::new();
let fingerprint = remote.user_command(
"uname -r; echo __MODEL__; cat /proc/device-tree/model 2>/dev/null; echo; \
echo __RELEASE__; cat /etc/os-release 2>/dev/null; cat /etc/alkane-release 2>/dev/null \
|| true",
Duration::from_secs(20),
)?;
let text = String::from_utf8_lossy(&fingerprint).into_owned();
let mut it = text.split("__MODEL__");
let kernel = it.next().unwrap_or("").trim().to_owned();
let rest = it.next().unwrap_or("");
let mut it2 = rest.split("__RELEASE__");
let _model = it2.next().unwrap_or("");
let release = it2.next().unwrap_or("");
let source = classify(&kernel, release, &text);
checks.push(A113dCheck {
name: "source-os".to_owned(),
ok: source == "alkane",
detail: format!("{source} (update path requires alkane)"),
});
let uid = String::from_utf8_lossy(&remote.root_command("id -u", Duration::from_secs(20))?)
.trim()
.to_owned();
checks.push(A113dCheck {
name: "root".to_owned(),
ok: uid == "0",
detail: format!("uid {uid}"),
});
let tools = remote.user_command(
"for c in ubiattach ubidetach mount umount cp md5sum sync; do \
command -v $c >/dev/null 2>&1 && echo $c || echo missing:$c; done",
Duration::from_secs(15),
)?;
let missing: Vec<String> = String::from_utf8_lossy(&tools)
.lines()
.filter_map(|l| l.strip_prefix("missing:").map(str::to_owned))
.collect();
checks.push(A113dCheck {
name: "commands".to_owned(),
ok: missing.is_empty(),
detail: if missing.is_empty() {
"ubi/file tools present".to_owned()
} else {
format!("missing {}", missing.join(", "))
},
});
// The nvdata MTD must be exposed (NAND-enabled a113d kernel). If absent, the
// running image cannot self-update - it needs the DT with the nvdata
// fixed-partition. mtd0-5 are intentionally never exposed, so nvdata is the
// ONLY mtd this board should ever present.
let proc_mtd = String::from_utf8_lossy(
&remote.user_command("cat /proc/mtd 2>/dev/null", Duration::from_secs(20))?,
)
.into_owned();
let nvdata_mtd = parse_nvdata_mtd(&proc_mtd);
checks.push(A113dCheck {
name: "nvdata-mtd".to_owned(),
ok: nvdata_mtd.is_some(),
detail: match nvdata_mtd {
Some(n) => format!("nvdata is /dev/mtd{n} (the only exposed MTD)"),
None => format!("no 'nvdata' MTD exposed: {}", proc_mtd.replace('\n', " ")),
},
});
// Every destination is a bare basename - the structural brick guard.
let dests_safe = plan.targets.iter().all(|t| is_safe_dest(&t.dest));
checks.push(A113dCheck {
name: "file-only".to_owned(),
ok: dests_safe,
detail: format!("all writes are files under {ALKANE_DIR}/ on the nvdata UBI"),
});
Ok(A113dPreflight {
host: host.to_owned(),
checks,
nvdata_mtd,
})
}
#[derive(Clone, Debug)]
pub struct A113dInstallOptions {
pub dry_run: bool,
pub confirm: Option<String>,
pub no_reboot: bool,
pub backup_dir: PathBuf,
}
#[derive(Clone, Debug)]
pub struct A113dBackup {
pub image_name: String,
pub dest: String,
pub path: Option<PathBuf>,
pub md5: Option<String>,
pub size: u64,
}
#[derive(Clone, Debug)]
pub struct A113dReceipt {
pub volume: String,
pub backups: Vec<A113dBackup>,
pub rebooted: bool,
}
pub enum A113dOutcome {
DryRun(Box<A113dPreflight>),
Installed(A113dReceipt),
}
const MNT: &str = "/tmp/.alkane-nvdata";
/// Attach UBI to the nvdata MTD and mount its single user volume read-write.
/// Returns (ubi device number, volume name). The volume name is DISCOVERED, never
/// assumed (vendor histories leave different names: umc_os_rootfs, nvdada_log,
/// overlay, ...).
fn attach_and_mount(remote: &mut dyn Remote, nvdata_mtd: u32) -> Result<String, A113dError> {
// Attach (idempotent: if ubi0 already exists, reuse it).
let _ = remote.root_command(
&format!(
"if [ ! -d /sys/class/ubi/ubi0 ]; then ubiattach -m {nvdata_mtd} -d 0 >/dev/null 2>&1; fi"
),
Duration::from_secs(60),
)?;
// Discover the first user volume name under ubi0.
let name = String::from_utf8_lossy(&remote.root_command(
"for n in /sys/class/ubi/ubi0_*/name; do [ -f \"$n\" ] && cat \"$n\" && break; done",
Duration::from_secs(20),
)?)
.trim()
.to_owned();
if name.is_empty() {
return Err(A113dError::UbiAttach);
}
// Mount it read-write.
remote.root_command(
&format!("mkdir -p {MNT} && mount -t ubifs ubi0:{name} {MNT}"),
Duration::from_secs(60),
)?;
// Confirm the mount actually took.
let mounted = remote.user_command(
&format!("mount | grep -c ' {MNT} '"),
Duration::from_secs(20),
)?;
if String::from_utf8_lossy(&mounted).trim() == "0" {
return Err(A113dError::Mount);
}
Ok(name)
}
fn unmount(remote: &mut dyn Remote) {
let _ = remote.root_command(
&format!(
"sync; umount {MNT} 2>/dev/null; ubidetach -d 0 2>/dev/null; rmdir {MNT} 2>/dev/null"
),
Duration::from_secs(60),
);
}
pub fn install(
plan: &A113dPlan,
remote: &mut dyn Remote,
options: &A113dInstallOptions,
host: &str,
) -> Result<A113dOutcome, A113dError> {
let report = preflight(plan, remote, host)?;
if !report.ok() {
return Err(A113dError::Preflight(report.render()));
}
if options.dry_run {
return Ok(A113dOutcome::DryRun(Box::new(report)));
}
if options.confirm.as_deref() != Some("FLASH") {
return Err(A113dError::Confirm);
}
let nvdata_mtd = report
.nvdata_mtd
.ok_or_else(|| A113dError::NoNvdataMtd(NVDATA_LABEL.to_owned()))?;
fs::create_dir_all(&options.backup_dir)?;
let epoch = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_secs();
let volume = attach_and_mount(remote, nvdata_mtd)?;
let alkane_dir = format!("{MNT}/{ALKANE_DIR}");
let _ = remote.root_command(&format!("mkdir -p {alkane_dir}"), Duration::from_secs(20))?;
let mut backups = Vec::new();
let result = (|| -> Result<(), A113dError> {
for target in &plan.targets {
// Structural guard at the point of writing: a bare basename only.
if !is_safe_dest(&target.dest) {
return Err(A113dError::UnsafeDest(target.dest.clone()));
}
let name = &target.image_name;
let dest_path = format!("{alkane_dir}/{}", target.dest);
// Back up the existing file, if present.
let have = remote.user_command(
&format!("test -f {dest_path} && echo __YES__"),
Duration::from_secs(15),
)?;
if String::from_utf8_lossy(&have).contains("__YES__") {
let local = options
.backup_dir
.join(format!("{}-{epoch}.bak", target.dest));
remote.pull(&dest_path, &local, Duration::from_secs(300))?;
let data = fs::read(&local)?;
backups.push(A113dBackup {
image_name: name.clone(),
dest: target.dest.clone(),
md5: Some(md5_hex(&data)),
size: data.len() as u64,
path: Some(local),
});
} else {
backups.push(A113dBackup {
image_name: name.clone(),
dest: target.dest.clone(),
md5: None,
size: 0,
path: None,
});
}
// Stage the verified payload and prove its remote md5 before copying.
let mut staged = tempfile::NamedTempFile::new()?;
staged.write_all(&target.data)?;
staged.flush()?;
let remote_stage = format!("/tmp/.alkane-a113d-{name}.img");
remote.push(staged.path(), &remote_stage, Duration::from_secs(300))?;
let staged_md5 = parse_digest(
&remote.root_command(&format!("md5sum {remote_stage}"), Duration::from_secs(60))?,
32,
)
.unwrap_or_default();
if staged_md5 != target.expected_md5 {
let _ =
remote.root_command(&format!("rm -f {remote_stage}"), Duration::from_secs(15));
return Err(A113dError::StageMismatch(name.clone()));
}
// Copy into the UBIFS volume (file write only), then sync.
remote.root_command(
&format!("cp -f {remote_stage} {dest_path} && sync"),
Duration::from_secs(300),
)?;
// Read back the copied file and compare md5.
let readback = parse_digest(
&remote.root_command(&format!("md5sum {dest_path}"), Duration::from_secs(60))?,
32,
)
.unwrap_or_default();
let _ = remote.root_command(&format!("rm -f {remote_stage}"), Duration::from_secs(15));
if readback != target.expected_md5 {
return Err(A113dError::Readback(name.clone()));
}
}
Ok(())
})();
// Always unmount/detach, success or failure, before returning or rebooting.
unmount(remote);
result?;
let rebooted = if options.no_reboot {
false
} else {
remote.reboot()?;
true
};
Ok(A113dOutcome::Installed(A113dReceipt {
volume,
backups,
rebooted,
}))
}
pub fn owns_board(board: &str) -> bool {
board == BOARD
}
/// True when no plan target would ever name a preserved raw partition. Used by
/// tests to assert the structural guard holds for the fixed TARGETS table.
pub fn no_raw_device_targets(plan: &A113dPlan) -> bool {
plan.targets.iter().all(|t| is_safe_dest(&t.dest))
}
#[cfg(test)]
mod tests {
use super::*;
use alkane_artifacts::afw::{AfwManifest, AfwMember};
use serde_json::json;
use sha2::{Digest, Sha256};
const REV: &str = "0123456789abcdef0123456789abcdef01234567";
fn arm64_image(payload: &[u8]) -> Vec<u8> {
let mut b = vec![0u8; 64];
b[0x38..0x3C].copy_from_slice(b"ARMd");
b.extend_from_slice(payload);
b
}
fn dtb() -> Vec<u8> {
let mut b = vec![0u8; 2048];
b[0..4].copy_from_slice(&[0xd0, 0x0d, 0xfe, 0xed]);
b
}
fn uramdisk() -> Vec<u8> {
let mut b = vec![0u8; 64];
b[0..4].copy_from_slice(&[0x27, 0x05, 0x19, 0x56]);
b
}
fn afw_with(
kernel: Vec<u8>,
dtb: Vec<u8>,
rootfs: Vec<u8>,
partitions: serde_json::Value,
) -> VerifiedAfw {
let image = |name: &str, file: &str, role: &str, fmt: &str, data: &[u8]| {
let sha: String = Sha256::digest(data)
.iter()
.map(|b| format!("{b:02x}"))
.collect();
json!({"name": name, "file": file, "role": role, "format": fmt,
"size": data.len(), "sha256": sha, "partition": "nvdata", "install": true})
};
let value = json!({
"schema": 2, "format": "afw", "board": "a113d", "arch": "arm64",
"version": "0.1.0", "build_date": "2026-11-06T00:00:00Z",
"sdk_revision": REV, "os_revision": REV, "payload_type": "os",
"bootloader_policy": "preserve",
"signature": {"type": "unsigned", "member": null, "public_key_hex": null},
"partitions": partitions,
"images": [
image("kernel", "payload/vmlinux.bin", "kernel", "arm64-image", &kernel),
image("dtb", "payload/devicetree.dtb", "dtb", "fdt", &dtb),
image("rootfs", "payload/uramdisk.image.gz", "rootfs", "uimage", &rootfs),
],
"boot_switch": {}, "preflight": {"min_free_bytes": 16777216},
"recovery": {}, "marker": "Alkane", "kernel_version": "6.18.48"
});
let manifest: AfwManifest = serde_json::from_value(value).unwrap();
VerifiedAfw {
manifest,
members: vec![
AfwMember {
name: "payload/vmlinux.bin".to_owned(),
data: kernel,
},
AfwMember {
name: "payload/devicetree.dtb".to_owned(),
data: dtb,
},
AfwMember {
name: "payload/uramdisk.image.gz".to_owned(),
data: rootfs,
},
],
manifest_sha256: "0".repeat(64),
archive_sha256: "0".repeat(64),
}
}
fn preserved_partitions() -> serde_json::Value {
json!([
{"name":"bootloader","device":"/dev/mtd0","offset":0,"size":2097152,
"secure":true,"boot_critical":true,"write_order":0,"image":null},
{"name":"nvdata","device":"/dev/mtd6","offset":74448896,"size":193986560,
"secure":false,"boot_critical":true,"write_order":1,"image":"kernel"}
])
}
fn good() -> VerifiedAfw {
afw_with(arm64_image(b"k"), dtb(), uramdisk(), preserved_partitions())
}
#[test]
fn accepts_a_good_plan_as_file_copies() {
let plan = A113dPlan::from_afw(&good()).unwrap();
assert_eq!(plan.targets.len(), 3);
// write order rootfs, dtb, kernel (kernel file lands last)
assert_eq!(plan.targets[0].image_name, "rootfs");
assert_eq!(plan.targets[2].image_name, "kernel");
assert!(no_raw_device_targets(&plan));
for t in &plan.targets {
assert!(
!t.dest.contains('/'),
"{} has a path, not a basename",
t.image_name
);
}
assert!(plan.render().contains("alkane/"));
assert!(plan.render().contains("no raw NAND write is possible"));
}
#[test]
fn refuses_a_non_arm64_kernel() {
let r = A113dPlan::from_afw(&afw_with(
vec![0u8; 64],
dtb(),
uramdisk(),
preserved_partitions(),
));
assert!(matches!(r, Err(A113dPlanError::NotArm64 { .. })));
}
#[test]
fn refuses_an_oversize_kernel() {
let big = arm64_image(&vec![0u8; 0x4000000]);
let r = A113dPlan::from_afw(&afw_with(big, dtb(), uramdisk(), preserved_partitions()));
assert!(matches!(r, Err(A113dPlanError::ImageTooLarge { .. })));
}
#[test]
fn refuses_a_fip_member() {
let mut v = good();
v.manifest.images[0].role = "bootloader".to_owned();
assert!(matches!(
A113dPlan::from_afw(&v),
Err(A113dPlanError::BootloaderMember(_))
));
let mut v = good();
v.manifest.images[1].file = "payload/fip.bin".to_owned();
assert!(matches!(
A113dPlan::from_afw(&v),
Err(A113dPlanError::BootloaderMember(_))
));
}
#[test]
fn refuses_a_preserved_partition_carrying_an_image() {
let partitions = json!([
{"name":"bootloader","device":"/dev/mtd0","offset":0,"size":2097152,
"secure":true,"boot_critical":true,"write_order":0,"image":"kernel"},
{"name":"nvdata","device":"/dev/mtd6","offset":74448896,"size":193986560,
"secure":false,"boot_critical":true,"write_order":1,"image":"kernel"}
]);
let v = afw_with(arm64_image(b"k"), dtb(), uramdisk(), partitions);
assert!(matches!(
A113dPlan::from_afw(&v),
Err(A113dPlanError::PreservedCarriesImage(_))
));
}
#[test]
fn wrong_board_and_arch_are_refused() {
let mut v = good();
v.manifest.board = "zynq-7010".to_owned();
assert!(matches!(
A113dPlan::from_afw(&v),
Err(A113dPlanError::WrongBoard(_))
));
let mut v = good();
v.manifest.arch = "armv7".to_owned();
assert!(matches!(
A113dPlan::from_afw(&v),
Err(A113dPlanError::WrongArch(_))
));
}
#[test]
fn every_target_is_a_basename_never_a_device() {
for (image, dest, _ceiling, _fmt) in TARGETS {
assert!(
is_safe_dest(dest),
"{image} dest {dest} is not a safe basename"
);
}
}
#[test]
fn unsafe_dest_is_rejected_by_guard() {
assert!(!is_safe_dest("/dev/mtd0"));
assert!(!is_safe_dest("../escape"));
assert!(!is_safe_dest("sub/dir/file"));
assert!(is_safe_dest("vmlinux.bin"));
}
#[test]
fn parses_the_nvdata_mtd_index() {
let proc_mtd = "dev: size erasesize name\n\
mtd0: 0b900000 00020000 \"nvdata\"\n";
assert_eq!(parse_nvdata_mtd(proc_mtd), Some(0));
// No nvdata line -> None (the no-NAND running image).
assert_eq!(parse_nvdata_mtd("dev: size erasesize name\n"), None);
// Different index is honored.
assert_eq!(
parse_nvdata_mtd("mtd3: 0b900000 00020000 \"nvdata\"\n"),
Some(3)
);
}
}
File diff suppressed because it is too large Load Diff
+406
View File
@@ -0,0 +1,406 @@
// SPDX-License-Identifier: MIT
//! CV1835 board module: the only write is the 16 MiB p1 FIT.
//!
//! The vendor boot0, BL2, BL31 and U-Boot chain is preserved. The board plan is
//! read from the verified `.afw` manifest, not guessed at runtime.
use crate::md5::md5_hex;
use alkane_artifacts::afw::{
AfwImage, AfwManifest, AfwPartition, BootloaderPolicy, VerifiedAfw, CV1835_P1_SIZE,
};
use thiserror::Error;
pub const BOARD: &str = "cv1835";
pub const ARCH: &str = "arm64";
pub const P1_DEVICE: &str = "/dev/mmcblk0p1";
pub const MARKER: &str = "CVBOOT";
pub const UPDATE_DAEMON_PORT: u16 = 12887;
pub const GOLDEN_LBA_BYTES: u64 = 0x300000 * 512;
#[derive(Debug, Error)]
pub enum CvPlanError {
#[error("bundle is for {0}, not cv1835")]
WrongBoard(String),
#[error("bundle arch is {0}, cv1835 needs arm64")]
WrongArch(String),
#[error("cv1835 requires bootloader_policy preserve")]
BootloaderPolicy,
#[error("cv1835 bundle carries a bootloader member")]
BootloaderMember,
#[error("cv1835 bundle must install exactly p1")]
MissingP1,
#[error("cv1835 p1 is {0} bytes, not the 16 MiB padded FIT")]
P1Size(u64),
#[error("cv1835 p1 partition is not /dev/mmcblk0p1")]
P1Device,
#[error("cv1835 p1 partition must be 16 MiB, non-secure and written once")]
P1Geometry,
#[error("cv1835 p1 is not a bootable FIT: {0}")]
Fit(String),
#[error("manifest marker is empty")]
Marker,
#[error("manifest kernel_version is empty")]
KernelVersion,
#[error("manifest is not an OS payload")]
PayloadType,
#[error("manifest preflight is missing {0}")]
Preflight(String),
}
#[derive(Clone, Debug)]
pub struct Cv1835Plan {
pub image: AfwImage,
pub data: Vec<u8>,
pub partition: AfwPartition,
pub expected_md5: String,
pub expected_sha256: String,
pub marker: String,
pub kernel_version: String,
pub sdk_revision: String,
pub os_revision: String,
pub source_os: Vec<String>,
pub required_commands: Vec<String>,
pub min_free_bytes: u64,
pub golden_lba_bytes: u64,
}
impl Cv1835Plan {
pub fn from_afw(afw: &VerifiedAfw) -> Result<Self, CvPlanError> {
let manifest = &afw.manifest;
if manifest.board != BOARD {
return Err(CvPlanError::WrongBoard(manifest.board.clone()));
}
if manifest.arch != ARCH {
return Err(CvPlanError::WrongArch(manifest.arch.clone()));
}
if manifest.payload_type != "os" {
return Err(CvPlanError::PayloadType);
}
if manifest.bootloader_policy != BootloaderPolicy::Preserve {
return Err(CvPlanError::BootloaderPolicy);
}
if manifest
.images
.iter()
.any(|image| image.role == "bootloader")
{
return Err(CvPlanError::BootloaderMember);
}
if manifest.marker.is_empty() {
return Err(CvPlanError::Marker);
}
if manifest.kernel_version.is_empty() {
return Err(CvPlanError::KernelVersion);
}
let install: Vec<&AfwImage> = manifest
.images
.iter()
.filter(|image| image.install)
.collect();
if install.len() != 1 || install[0].name != "p1" {
return Err(CvPlanError::MissingP1);
}
let image = install[0].clone();
if image.format != "fit" {
return Err(CvPlanError::Fit("format is not fit".to_owned()));
}
if image.size != CV1835_P1_SIZE {
return Err(CvPlanError::P1Size(image.size));
}
let (_, data) = afw.install_image().ok_or(CvPlanError::MissingP1)?;
if !data.starts_with(b"\xd0\x0d\xfe\xed") {
return Err(CvPlanError::Fit("missing FDT/FIT magic".to_owned()));
}
if !contains(data, b"config@cv1835_miner_emmc") {
return Err(CvPlanError::Fit(
"missing config@cv1835_miner_emmc".to_owned(),
));
}
if contains(data, b"signature@") {
return Err(CvPlanError::Fit("carries signature@ nodes".to_owned()));
}
let partition = manifest
.partitions
.iter()
.find(|part| part.name == "p1")
.ok_or(CvPlanError::P1Device)?
.clone();
if partition.device != P1_DEVICE {
return Err(CvPlanError::P1Device);
}
if partition.size != CV1835_P1_SIZE
|| partition.secure
|| !partition.boot_critical
|| partition.write_order != 1
{
return Err(CvPlanError::P1Geometry);
}
if manifest
.partitions
.iter()
.any(|part| part.write_order > 0 && part.name != "p1")
{
return Err(CvPlanError::MissingP1);
}
let source_os = json_strings(&manifest.preflight, "source_os");
let required_commands = json_strings(&manifest.preflight, "required_commands");
let min_free_bytes = manifest
.preflight
.get("min_free_bytes")
.and_then(|value| value.as_u64())
.unwrap_or(32 * 1024 * 1024);
let golden_lba_bytes = manifest
.recovery
.get("golden_lba_bytes")
.and_then(|value| value.as_u64())
.unwrap_or(GOLDEN_LBA_BYTES);
Ok(Self {
expected_md5: md5_hex(data),
expected_sha256: image.sha256.clone(),
image,
data: data.to_vec(),
partition,
marker: manifest.marker.clone(),
kernel_version: manifest.kernel_version.clone(),
sdk_revision: manifest.sdk_revision.clone(),
os_revision: manifest.os_revision.clone(),
source_os,
required_commands,
min_free_bytes,
golden_lba_bytes,
})
}
pub fn render(&self) -> String {
format!(
"board cv1835 arch arm64\n\
partition {} {} {} B secure=false boot_critical=true write_order={}\n\
image {} {} {} B sha256 {}\n\
image md5 {}\n\
bootloader preserve (vendor boot0/BL2/BL31/U-Boot kept)\n\
boot switch partition-overwrite (p1 is the switch)\n\
marker {} kernel {} sdk {} os {}",
self.partition.name,
self.partition.device,
self.partition.size,
self.partition.write_order,
self.image.name,
self.image.file,
self.image.size,
self.image.sha256,
self.expected_md5,
self.marker,
self.kernel_version,
short_revision(&self.sdk_revision),
short_revision(&self.os_revision),
)
}
}
fn short_revision(revision: &str) -> &str {
revision.get(..12).unwrap_or(revision)
}
fn contains(haystack: &[u8], needle: &[u8]) -> bool {
haystack
.windows(needle.len())
.any(|window| window == needle)
}
fn json_strings(value: &serde_json::Value, key: &str) -> Vec<String> {
value
.get(key)
.and_then(|item| item.as_array())
.map(|items| {
items
.iter()
.filter_map(|item| item.as_str().map(str::to_owned))
.collect()
})
.unwrap_or_default()
}
pub fn manifest_from_json(value: serde_json::Value) -> Result<AfwManifest, serde_json::Error> {
serde_json::from_value(value)
}
#[cfg(test)]
mod tests {
use super::*;
use alkane_artifacts::afw::AfwMember;
use serde_json::json;
use sha2::{Digest, Sha256};
const P1: usize = CV1835_P1_SIZE as usize;
const REV: &str = "0000000000000000000000000000000000000000";
fn sha_hex(data: &[u8]) -> String {
Sha256::digest(data)
.iter()
.map(|byte| format!("{byte:02x}"))
.collect()
}
fn p1_image() -> Vec<u8> {
let mut fit = vec![0_u8; P1];
fit[..4].copy_from_slice(b"\xd0\x0d\xfe\xed");
let marker = b"config@cv1835_miner_emmc";
fit[0x100..0x100 + marker.len()].copy_from_slice(marker);
fit
}
fn manifest_value(p1: &[u8]) -> serde_json::Value {
json!({
"schema": 2,
"format": "afw",
"board": "cv1835",
"arch": "arm64",
"version": "0.1.0",
"build_date": "2026-11-04T00:00:00Z",
"sdk_revision": REV,
"os_revision": REV,
"payload_type": "os",
"bootloader_policy": "preserve",
"signature": {"type": "unsigned", "member": null, "public_key_hex": null},
"partitions": [
{"name": "p1", "device": "/dev/mmcblk0p1", "offset": 0,
"size": CV1835_P1_SIZE, "secure": false, "boot_critical": true,
"write_order": 1, "image": "p1"},
{"name": "boot0", "device": "/dev/mmcblk0boot0", "offset": 0,
"size": 4194304, "secure": true, "boot_critical": true,
"write_order": 0, "image": null}
],
"images": [
{"name": "p1", "file": "payload/p1.fit", "role": "boot",
"format": "fit", "size": p1.len(),
"sha256": sha_hex(p1),
"partition": "p1", "install": true}
],
"boot_switch": {"method": "partition-overwrite"},
"preflight": {"required_commands": ["dd", "md5sum", "sync"],
"source_os": ["stock-bitmain", "vnish", "braiins", "ouros", "alkane"],
"min_free_bytes": 33554432},
"recovery": {"network": "afw restore", "golden_lba_bytes": GOLDEN_LBA_BYTES},
"marker": "CVBOOT",
"kernel_version": "6.18.48"
})
}
fn afw(p1: &[u8]) -> VerifiedAfw {
let manifest = manifest_from_json(manifest_value(p1)).unwrap();
VerifiedAfw {
manifest,
members: vec![AfwMember {
name: "payload/p1.fit".to_owned(),
data: p1.to_vec(),
}],
manifest_sha256: "0".repeat(64),
archive_sha256: "0".repeat(64),
}
}
#[test]
fn accepts_the_cv_plan() {
let data = p1_image();
let plan = Cv1835Plan::from_afw(&afw(&data)).unwrap();
assert_eq!(plan.partition.device, "/dev/mmcblk0p1");
assert_eq!(plan.image.size, CV1835_P1_SIZE);
assert_eq!(plan.marker, "CVBOOT");
assert!(plan
.render()
.contains("partition p1 /dev/mmcblk0p1 16777216"));
}
#[test]
fn refuses_a_bundle_for_another_board() {
let data = p1_image();
let mut verified = afw(&data);
verified.manifest.board = "zynq-7010".to_owned();
assert!(matches!(
Cv1835Plan::from_afw(&verified),
Err(CvPlanError::WrongBoard(_))
));
}
#[test]
fn refuses_include_bootloader_policy() {
let data = p1_image();
let mut verified = afw(&data);
verified.manifest.bootloader_policy = BootloaderPolicy::Include;
assert!(matches!(
Cv1835Plan::from_afw(&verified),
Err(CvPlanError::BootloaderPolicy)
));
}
#[test]
fn refuses_a_bootloader_member() {
let data = p1_image();
let mut verified = afw(&data);
verified.manifest.images.push(AfwImage {
name: "u-boot".to_owned(),
file: "payload/u-boot.img".to_owned(),
role: "bootloader".to_owned(),
format: "uimage".to_owned(),
size: 4,
sha256: "0".repeat(64),
partition: None,
install: false,
});
assert!(matches!(
Cv1835Plan::from_afw(&verified),
Err(CvPlanError::BootloaderMember)
));
}
#[test]
fn refuses_a_short_p1() {
let data = vec![0_u8; 1024];
let verified = afw(&data);
assert!(matches!(
Cv1835Plan::from_afw(&verified),
Err(CvPlanError::P1Size(1024))
));
}
#[test]
fn refuses_a_secure_p1() {
let data = p1_image();
let mut verified = afw(&data);
verified.manifest.partitions[0].secure = true;
assert!(matches!(
Cv1835Plan::from_afw(&verified),
Err(CvPlanError::P1Geometry)
));
}
#[test]
fn refuses_a_wrong_device() {
let data = p1_image();
let mut verified = afw(&data);
verified.manifest.partitions[0].device = "/dev/mmcblk0p3".to_owned();
assert!(matches!(
Cv1835Plan::from_afw(&verified),
Err(CvPlanError::P1Device)
));
}
#[test]
fn refuses_a_fit_without_the_board_config() {
let mut data = p1_image();
for byte in data.iter_mut() {
if *byte == b'c' {
*byte = b'x';
}
}
let verified = afw(&data);
assert!(matches!(
Cv1835Plan::from_afw(&verified),
Err(CvPlanError::Fit(_))
));
}
}
+8
View File
@@ -0,0 +1,8 @@
// SPDX-License-Identifier: MIT
//! Board modules. Each module validates the verified manifest for its family
//! and exposes the exact write plan the installer follows.
pub mod a113d;
pub mod am335x;
pub mod cv1835;
pub mod zynq;
+410
View File
@@ -0,0 +1,410 @@
// SPDX-License-Identifier: MIT
//! Zynq-7010 board module: the manifest gate and write plan for putting our
//! OS onto a Zynq control board (Antminer S17/S19 class).
//!
//! This module decides WHAT may be written and WHERE, in absolute NAND terms.
//! It does not write. The write itself (for a board already on alkane, and for
//! the first install from stock) is done by the compiled-in method behind
//! `crate::stock` (`update_in_place` / `install_from_stock`), because on a board
//! running alkane the boot regions are deliberately not exposed to Linux and
//! have to be re-registered first; that mechanism lives with the method.
//!
//! Layout (absolute NAND offsets, 128 KiB erase blocks): BOOT.bin (FSBL + FPGA
//! bitstream + stock U-Boot + env) occupies 0x0..0x1a00000 and is never
//! written. The stock U-Boot reads the dtb at 0x1a00000, the kernel at
//! 0x2000000 and the ramdisk at 0x2800000, and boots the kernel and ramdisk as
//! legacy uImages, so both are written with a 64-byte uImage header.
//!
//! History: an earlier version of this module wrote raw images at
//! device-relative offsets on /dev/mtd0 and /dev/mtd1. That matched an early
//! alkane image that exposed the whole NAND, not the current one (which exposes
//! only the small `stock-cfg` and `alkane-cfg` partitions), and its raw kernel
//! and ramdisk were not bootable by the stock U-Boot. It was removed.
use crate::md5::md5_hex;
use alkane_artifacts::afw::{AfwImage, BootloaderPolicy, VerifiedAfw};
use thiserror::Error;
pub const BOARD: &str = "zynq-7010";
pub const ARCH: &str = "armv7";
/// Absolute NAND 0x0..0x1a00000 is BOOT.bin (FSBL + FPGA bitstream + stock
/// U-Boot) + the U-Boot env, and is NEVER erased or written.
pub const BOOTBIN_PRESERVE: u64 = 0x1A00000;
/// Size of the legacy uImage header the stock U-Boot needs on the kernel and
/// the ramdisk.
const UIMAGE_HEADER: u64 = 64;
/// Write targets in write order (rootfs, dtb, kernel, so an interrupted write
/// never leaves a new rootfs under an old kernel): (image, absolute NAND
/// offset, slot size, expected manifest format, uImage-wrapped).
const TARGETS: [(&str, u64, u64, &str, bool); 3] = [
("rootfs", 0x2800000, 0x2000000, "cpio-gzip", true),
("dtb", 0x1A00000, 0x20000, "fdt", false),
("kernel", 0x2000000, 0x800000, "zimage", true),
];
#[derive(Debug, Error)]
pub enum ZynqPlanError {
#[error("bundle is for {0}, not zynq-7010")]
WrongBoard(String),
#[error("bundle arch is {0}, zynq-7010 needs armv7")]
WrongArch(String),
#[error("zynq-7010 requires bootloader_policy preserve")]
BootloaderPolicy,
#[error("zynq-7010 bundle carries a bootloader/spl/BOOT.bin member: {0}")]
BootloaderMember(String),
#[error("manifest is not an OS payload")]
PayloadType,
#[error("manifest marker is empty")]
Marker,
#[error("zynq-7010 must install exactly kernel, dtb and rootfs")]
InstallCount,
#[error("zynq-7010 is missing the {0} image")]
MissingImage(String),
#[error("zynq-7010 {image} format is {actual}, expected {expected}")]
ImageFormat {
image: String,
actual: String,
expected: &'static str,
},
#[error("zynq-7010 {image} is {size} bytes, over the {ceiling}-byte ceiling for its 0x{slot:x} slot")]
ImageTooLarge {
image: String,
size: u64,
ceiling: u64,
slot: u64,
},
#[error("zynq-7010 {image} is not an ARM zImage")]
NotZImage { image: String },
#[error("zynq-7010 refuses to place {image} at 0x{offset:x}: below BOOT.bin (0x{bootbin:x})")]
WouldClobberBootbin {
image: String,
offset: u64,
bootbin: u64,
},
}
#[derive(Clone, Debug)]
pub struct ZynqTarget {
pub image_name: String,
/// Absolute NAND offset of the slot.
pub absolute: u64,
pub slot: u64,
/// Size of the image as shipped in the `.afw` (before any uImage header).
pub size: u64,
pub uimage_wrapped: bool,
pub data: Vec<u8>,
pub expected_md5: String,
}
#[derive(Clone, Debug)]
pub struct ZynqPlan {
pub targets: Vec<ZynqTarget>,
pub marker: String,
pub kernel_version: String,
pub sdk_revision: String,
pub os_revision: String,
pub afw_sha256: String,
}
fn is_bootloaderish(image: &AfwImage) -> bool {
let lowered = format!("{} {} {}", image.name, image.file, image.role).to_lowercase();
image.role == "bootloader"
|| lowered.contains("spl")
|| lowered.contains("u-boot")
|| lowered.contains("uboot")
|| lowered.contains("boot.bin")
}
impl ZynqPlan {
pub fn from_afw(afw: &VerifiedAfw) -> Result<Self, ZynqPlanError> {
let manifest = &afw.manifest;
if manifest.board != BOARD {
return Err(ZynqPlanError::WrongBoard(manifest.board.clone()));
}
if manifest.arch != ARCH {
return Err(ZynqPlanError::WrongArch(manifest.arch.clone()));
}
if manifest.payload_type != "os" {
return Err(ZynqPlanError::PayloadType);
}
if manifest.bootloader_policy != BootloaderPolicy::Preserve {
return Err(ZynqPlanError::BootloaderPolicy);
}
if manifest.marker.is_empty() {
return Err(ZynqPlanError::Marker);
}
// BOOT.bin / bootloader members are never allowed - we reuse the board's.
for image in &manifest.images {
if is_bootloaderish(image) {
return Err(ZynqPlanError::BootloaderMember(image.file.clone()));
}
}
let installs: Vec<&AfwImage> = manifest.images.iter().filter(|i| i.install).collect();
if installs.len() != TARGETS.len() {
return Err(ZynqPlanError::InstallCount);
}
let mut targets = Vec::with_capacity(TARGETS.len());
for (image_name, absolute, slot, expected_format, wrapped) in TARGETS {
let image = manifest
.images
.iter()
.find(|i| i.name == image_name && i.install)
.ok_or_else(|| ZynqPlanError::MissingImage(image_name.to_owned()))?;
if image.format != expected_format {
return Err(ZynqPlanError::ImageFormat {
image: image_name.to_owned(),
actual: image.format.clone(),
expected: expected_format,
});
}
let ceiling = if wrapped { slot - UIMAGE_HEADER } else { slot };
if image.size > ceiling {
return Err(ZynqPlanError::ImageTooLarge {
image: image_name.to_owned(),
size: image.size,
ceiling,
slot,
});
}
// The hard brick guard: nothing is ever placed inside BOOT.bin.
if absolute < BOOTBIN_PRESERVE {
return Err(ZynqPlanError::WouldClobberBootbin {
image: image_name.to_owned(),
offset: absolute,
bootbin: BOOTBIN_PRESERVE,
});
}
let data = afw
.image(image_name)
.map(|(_, data)| data)
.ok_or_else(|| ZynqPlanError::MissingImage(image_name.to_owned()))?;
if expected_format == "zimage"
&& !(data.len() >= 0x28 && data[0x24..0x28] == [0x18, 0x28, 0x6f, 0x01])
{
return Err(ZynqPlanError::NotZImage {
image: image_name.to_owned(),
});
}
targets.push(ZynqTarget {
image_name: image_name.to_owned(),
absolute,
slot,
size: image.size,
uimage_wrapped: wrapped,
expected_md5: md5_hex(data),
data: data.to_vec(),
});
}
Ok(Self {
targets,
marker: manifest.marker.clone(),
kernel_version: manifest.kernel_version.clone(),
sdk_revision: manifest.sdk_revision.clone(),
os_revision: manifest.os_revision.clone(),
afw_sha256: afw.archive_sha256.clone(),
})
}
pub fn render(&self) -> String {
let mut out = format!("board {BOARD} arch {ARCH}\n");
out.push_str(&format!(
"boot slots (absolute NAND); BOOT.bin 0x0..0x{BOOTBIN_PRESERVE:x} preserved, never written\n"
));
out.push_str(
"kernel and rootfs are written as legacy uImages (what the stock U-Boot boots); dtb raw\n",
);
for target in &self.targets {
out.push_str(&format!(
"write {:<6} abs 0x{:x} slot 0x{:x} size {} B{} md5 {}\n",
target.image_name,
target.absolute,
target.slot,
target.size,
if target.uimage_wrapped {
" +64 B header"
} else {
""
},
target.expected_md5
));
}
out.push_str(&format!(
"marker {} kernel {} sdk {} os {}",
self.marker,
self.kernel_version,
short(&self.sdk_revision),
short(&self.os_revision),
));
out
}
}
fn short(rev: &str) -> &str {
rev.get(..12).unwrap_or(rev)
}
pub fn owns_board(board: &str) -> bool {
board == BOARD
}
#[cfg(test)]
mod tests {
use super::*;
use alkane_artifacts::afw::{AfwManifest, AfwMember};
use serde_json::json;
use sha2::{Digest, Sha256};
const REV: &str = "0123456789abcdef0123456789abcdef01234567";
fn zimage(payload: &[u8]) -> Vec<u8> {
let mut b = vec![0u8; 64];
b[0x24..0x28].copy_from_slice(&[0x18, 0x28, 0x6f, 0x01]);
b.extend_from_slice(payload);
b
}
fn afw(kernel: Vec<u8>, dtb: Vec<u8>, rootfs: Vec<u8>) -> VerifiedAfw {
let image = |name: &str, file: &str, role: &str, fmt: &str, data: &[u8]| {
let sha: String = Sha256::digest(data)
.iter()
.map(|b| format!("{b:02x}"))
.collect();
json!({"name": name, "file": file, "role": role, "format": fmt,
"size": data.len(), "sha256": sha, "partition": "x", "install": true})
};
let value = json!({
"schema": 2, "format": "afw", "board": "zynq-7010", "arch": "armv7",
"version": "0.1.0", "build_date": "2026-11-06T00:00:00Z",
"sdk_revision": REV, "os_revision": REV, "payload_type": "os",
"bootloader_policy": "preserve",
"signature": {"type": "unsigned", "member": null, "public_key_hex": null},
"partitions": [],
"images": [
image("kernel", "payload/zImage", "kernel", "zimage", &kernel),
image("dtb", "payload/zynq-alkane.dtb", "dtb", "fdt", &dtb),
image("rootfs", "payload/rootfs.cpio.gz", "rootfs", "cpio-gzip", &rootfs),
],
"boot_switch": {}, "preflight": {"min_free_bytes": 16777216},
"recovery": {}, "marker": "Alkane", "kernel_version": "6.18.48"
});
let manifest: AfwManifest = serde_json::from_value(value).unwrap();
VerifiedAfw {
manifest,
members: vec![
AfwMember {
name: "payload/zImage".to_owned(),
data: kernel,
},
AfwMember {
name: "payload/zynq-alkane.dtb".to_owned(),
data: dtb,
},
AfwMember {
name: "payload/rootfs.cpio.gz".to_owned(),
data: rootfs,
},
],
manifest_sha256: "0".repeat(64),
archive_sha256: "0".repeat(64),
}
}
fn dtb() -> Vec<u8> {
let mut b = vec![0u8; 1024];
b[0..4].copy_from_slice(&[0xd0, 0x0d, 0xfe, 0xed]);
b
}
#[test]
fn accepts_a_good_plan_and_places_above_bootbin() {
let plan = ZynqPlan::from_afw(&afw(zimage(b"k"), dtb(), b"\x1f\x8brf".to_vec())).unwrap();
assert_eq!(plan.targets.len(), 3);
// write order rootfs, dtb, kernel
assert_eq!(plan.targets[0].image_name, "rootfs");
assert_eq!(plan.targets[2].image_name, "kernel");
for t in &plan.targets {
assert!(
t.absolute >= BOOTBIN_PRESERVE,
"{} below BOOT.bin",
t.image_name
);
}
let render = plan.render();
assert!(render.contains("BOOT.bin"));
assert!(render.contains("uImage"));
}
#[test]
fn slots_match_the_stock_uboot_layout() {
let plan = ZynqPlan::from_afw(&afw(zimage(b"k"), dtb(), b"\x1f\x8brf".to_vec())).unwrap();
let at = |name: &str| plan.targets.iter().find(|t| t.image_name == name).unwrap();
assert_eq!((at("dtb").absolute, at("dtb").slot), (0x1A00000, 0x20000));
assert_eq!(
(at("kernel").absolute, at("kernel").slot),
(0x2000000, 0x800000)
);
assert_eq!(
(at("rootfs").absolute, at("rootfs").slot),
(0x2800000, 0x2000000)
);
assert!(at("kernel").uimage_wrapped && at("rootfs").uimage_wrapped);
assert!(!at("dtb").uimage_wrapped);
}
#[test]
fn refuses_a_non_zimage_kernel() {
let result = ZynqPlan::from_afw(&afw(vec![0u8; 64], dtb(), b"\x1f\x8brf".to_vec()));
assert!(matches!(result, Err(ZynqPlanError::NotZImage { .. })));
}
#[test]
fn refuses_a_kernel_that_would_not_fit_with_its_uimage_header() {
// Exactly the slot size is too big once the 64-byte header is added.
let big = zimage(&vec![0u8; 0x800000 - 64]);
assert_eq!(big.len(), 0x800000);
let result = ZynqPlan::from_afw(&afw(big, dtb(), b"\x1f\x8brf".to_vec()));
assert!(matches!(result, Err(ZynqPlanError::ImageTooLarge { .. })));
let fits = zimage(&vec![0u8; 0x800000 - 128]);
assert!(ZynqPlan::from_afw(&afw(fits, dtb(), b"\x1f\x8brf".to_vec())).is_ok());
}
#[test]
fn refuses_a_bootloader_member() {
let mut verified = afw(zimage(b"k"), dtb(), b"\x1f\x8brf".to_vec());
verified.manifest.images[0].role = "bootloader".to_owned();
assert!(matches!(
ZynqPlan::from_afw(&verified),
Err(ZynqPlanError::BootloaderMember(_))
));
}
#[test]
fn wrong_board_and_arch_are_refused() {
let mut v = afw(zimage(b"k"), dtb(), b"\x1f\x8brf".to_vec());
v.manifest.board = "am335x".to_owned();
assert!(matches!(
ZynqPlan::from_afw(&v),
Err(ZynqPlanError::WrongBoard(_))
));
let mut v = afw(zimage(b"k"), dtb(), b"\x1f\x8brf".to_vec());
v.manifest.arch = "arm".to_owned();
assert!(matches!(
ZynqPlan::from_afw(&v),
Err(ZynqPlanError::WrongArch(_))
));
}
#[test]
fn every_target_is_above_bootbin() {
for (image, absolute, _slot, _fmt, _wrapped) in TARGETS {
assert!(
absolute >= BOOTBIN_PRESERVE,
"{image} target below BOOT.bin"
);
}
}
}
+920
View File
@@ -0,0 +1,920 @@
// SPDX-License-Identifier: MIT
//! CV1835 install, restore and live verification over the network.
//!
//! Order of operations for an install: verify the bundle, preflight the board,
//! hold the current p1 over SSH, stage the new p1, write it once, read the whole
//! partition back, and only then reboot. Any doubt before the first write stops
//! the sequence. A read-back mismatch stops before reboot and prints the exact
//! restore command.
use crate::boards::cv1835::{Cv1835Plan, CvPlanError};
use crate::md5::md5_hex;
use crate::preflight::{preflight, PreflightError, PreflightOptions, PreflightReport};
use crate::transport::{Remote, RemoteError, SshOptions, SshTransport};
use alkane_artifacts::afw::{AfwError, VerifiedAfw};
use sha2::{Digest, Sha256};
use std::fs;
use std::io::{Read, Write};
use std::net::{TcpStream, ToSocketAddrs};
use std::path::{Path, PathBuf};
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
use thiserror::Error;
const REMOTE_BACKUP: &str = "/tmp/.alkane-p1-backup.img";
const REMOTE_STAGE: &str = "/tmp/.alkane-p1-stage.img";
#[derive(Debug, Error)]
pub enum InstallError {
#[error("preflight failed; do not write\n{0}")]
Preflight(String),
#[error("install and restore need --confirm FLASH")]
Confirm,
#[error("verified .afw: {0}")]
Afw(#[from] AfwError),
#[error("cv1835 plan: {0}")]
Plan(#[from] CvPlanError),
#[error("preflight: {0}")]
PreflightError(#[from] PreflightError),
#[error("remote: {0}")]
Remote(#[from] RemoteError),
#[error("I/O: {0}")]
Io(#[from] std::io::Error),
#[error("backup {0} is not the 16 MiB p1 size")]
BackupSize(PathBuf),
#[error("backup md5 does not match the live p1; refusing to continue")]
BackupMismatch,
#[error("staged image md5 does not match the verified bundle; nothing written")]
StageMismatch,
#[error("p1 read-back md5 mismatch; do not reboot. Restore with: {0}")]
Readback(String),
#[error("restore read-back md5 mismatch; the board may still hold the new image")]
RestoreReadback,
}
#[derive(Clone, Debug)]
pub struct InstallOptions {
pub dry_run: bool,
pub confirm: Option<String>,
pub no_reboot: bool,
pub backup_dir: PathBuf,
pub held_backup: Option<PathBuf>,
pub allow_unknown_source: bool,
pub check_golden: bool,
}
impl Default for InstallOptions {
fn default() -> Self {
Self {
dry_run: false,
confirm: None,
no_reboot: false,
backup_dir: default_backup_dir(),
held_backup: None,
allow_unknown_source: false,
check_golden: false,
}
}
}
#[derive(Clone, Debug)]
pub struct InstallReceipt {
pub backup_path: PathBuf,
pub backup_md5: String,
pub backup_sha256: String,
pub image_md5: String,
pub rebooted: bool,
}
#[derive(Clone, Debug)]
pub enum InstallOutcome {
DryRun(Box<PreflightReport>),
Installed(InstallReceipt),
}
pub fn install(
_afw: &VerifiedAfw,
plan: &Cv1835Plan,
remote: &mut dyn Remote,
options: &InstallOptions,
host: &str,
) -> Result<InstallOutcome, InstallError> {
let report = preflight(
plan,
remote,
&PreflightOptions {
host,
held_backup: options.held_backup.as_deref(),
check_golden: options.check_golden,
allow_unknown_source: options.allow_unknown_source,
},
)?;
if !report.ok() {
return Err(InstallError::Preflight(report.render()));
}
if options.dry_run {
return Ok(InstallOutcome::DryRun(Box::new(report)));
}
if options.confirm.as_deref() != Some("FLASH") {
return Err(InstallError::Confirm);
}
fs::create_dir_all(&options.backup_dir)?;
let epoch = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_secs();
let backup_path = options.backup_dir.join(format!("p1-{epoch}.img"));
let device = &plan.partition.device;
// Hold the current p1 as root, then pull it over the unprivileged SSH
// session. The daemon channel is blind, so this two-step path is required.
let remote_backup = REMOTE_BACKUP;
remote.root_command(
&format!("dd if={device} of={remote_backup} bs=1M 2>&1; chmod 644 {remote_backup}"),
Duration::from_secs(180),
)?;
remote.pull(remote_backup, &backup_path, Duration::from_secs(240))?;
let _ = remote.root_command(&format!("rm -f {remote_backup}"), Duration::from_secs(15));
let backup_data = fs::read(&backup_path)?;
if backup_data.len() as u64 != plan.partition.size {
return Err(InstallError::BackupSize(backup_path));
}
let backup_md5 = md5_hex(&backup_data);
if report.live_md5 != "unreadable" && backup_md5 != report.live_md5 {
return Err(InstallError::BackupMismatch);
}
let backup_sha256: String = Sha256::digest(&backup_data)
.iter()
.map(|byte| format!("{byte:02x}"))
.collect();
write_sidecars(
&backup_path,
&backup_md5,
&backup_sha256,
&plan.partition,
&plan.expected_sha256,
epoch,
)?;
stage_and_write(plan, remote, &backup_path)?;
let rebooted = if options.no_reboot {
false
} else {
remote.reboot()?;
true
};
Ok(InstallOutcome::Installed(InstallReceipt {
backup_path,
backup_md5,
backup_sha256,
image_md5: plan.expected_md5.clone(),
rebooted,
}))
}
fn stage_and_write(
plan: &Cv1835Plan,
remote: &mut dyn Remote,
backup_path: &Path,
) -> Result<(), InstallError> {
let mut staged =
tempfile::NamedTempFile::new_in(backup_path.parent().unwrap_or_else(|| Path::new(".")))?;
staged.write_all(&plan.data)?;
staged.flush()?;
remote.push(staged.path(), REMOTE_STAGE, Duration::from_secs(240))?;
let staged_md5 =
remote.root_command(&format!("md5sum {REMOTE_STAGE}"), Duration::from_secs(60))?;
let staged_md5 = String::from_utf8_lossy(&staged_md5)
.split_whitespace()
.next()
.unwrap_or("")
.to_ascii_lowercase();
if staged_md5 != plan.expected_md5 {
let _ = remote.root_command(&format!("rm -f {REMOTE_STAGE}"), Duration::from_secs(15));
return Err(InstallError::StageMismatch);
}
remote.root_command(
&format!(
"dd if={REMOTE_STAGE} of={} bs=1M conv=fsync 2>&1; sync",
plan.partition.device
),
Duration::from_secs(240),
)?;
let readback = remote.root_command(
&format!("md5sum {}", plan.partition.device),
Duration::from_secs(90),
)?;
let readback = String::from_utf8_lossy(&readback)
.split_whitespace()
.next()
.unwrap_or("")
.to_ascii_lowercase();
let _ = remote.root_command(&format!("rm -f {REMOTE_STAGE}"), Duration::from_secs(15));
if readback != plan.expected_md5 {
return Err(InstallError::Readback(restore_command(
&plan.partition.device,
backup_path,
)));
}
Ok(())
}
#[derive(Clone, Debug)]
pub struct RestoreOptions {
pub confirm: Option<String>,
pub no_reboot: bool,
}
#[derive(Clone, Debug)]
pub struct RestoreReceipt {
pub backup_path: PathBuf,
pub image_md5: String,
pub rebooted: bool,
}
pub fn restore(
backup: &Path,
remote: &mut dyn Remote,
options: &RestoreOptions,
) -> Result<RestoreReceipt, InstallError> {
if options.confirm.as_deref() != Some("FLASH") {
return Err(InstallError::Confirm);
}
let data = fs::read(backup)?;
if data.len() != 16 * 1024 * 1024 {
return Err(InstallError::BackupSize(backup.to_path_buf()));
}
let md5 = md5_hex(&data);
let sha256: String = Sha256::digest(&data)
.iter()
.map(|byte| format!("{byte:02x}"))
.collect();
if let Some(sidecar) = read_sidecar(backup) {
if sidecar != sha256 {
return Err(InstallError::BackupMismatch);
}
}
let root_uid = String::from_utf8_lossy(&remote.root_command("id -u", Duration::from_secs(20))?)
.trim()
.to_owned();
if root_uid != "0" {
return Err(InstallError::Preflight(format!(
"root channel returned uid {root_uid}"
)));
}
let size = remote.user_command(
"cat /sys/class/block/mmcblk0p1/size 2>/dev/null || true",
Duration::from_secs(15),
)?;
let sectors: u64 = String::from_utf8_lossy(&size).trim().parse().unwrap_or(0);
if sectors.saturating_mul(512) != 16 * 1024 * 1024 {
return Err(InstallError::Preflight(
"the board does not expose a 16 MiB /dev/mmcblk0p1".to_owned(),
));
}
let staged = tempfile::NamedTempFile::new()?;
fs::write(staged.path(), &data)?;
remote.push(staged.path(), REMOTE_STAGE, Duration::from_secs(240))?;
let staged_md5 =
remote.root_command(&format!("md5sum {REMOTE_STAGE}"), Duration::from_secs(60))?;
let staged_md5 = String::from_utf8_lossy(&staged_md5)
.split_whitespace()
.next()
.unwrap_or("")
.to_ascii_lowercase();
if staged_md5 != md5 {
let _ = remote.root_command(&format!("rm -f {REMOTE_STAGE}"), Duration::from_secs(15));
return Err(InstallError::StageMismatch);
}
remote.root_command(
&format!("dd if={REMOTE_STAGE} of=/dev/mmcblk0p1 bs=1M conv=fsync 2>&1; sync"),
Duration::from_secs(240),
)?;
let readback = remote.root_command("md5sum /dev/mmcblk0p1", Duration::from_secs(90))?;
let readback = String::from_utf8_lossy(&readback)
.split_whitespace()
.next()
.unwrap_or("")
.to_ascii_lowercase();
let _ = remote.root_command(&format!("rm -f {REMOTE_STAGE}"), Duration::from_secs(15));
if readback != md5 {
return Err(InstallError::RestoreReadback);
}
let rebooted = if options.no_reboot {
false
} else {
remote.reboot()?;
true
};
Ok(RestoreReceipt {
backup_path: backup.to_path_buf(),
image_md5: md5,
rebooted,
})
}
fn restore_command(device: &str, backup: &Path) -> String {
format!(
"alkane-cli afw restore --host <ip> --held-backup {} --confirm FLASH (the held copy of {device} is at {})",
backup.display(),
backup.display()
)
}
fn default_backup_dir() -> PathBuf {
alkane_core::platform::config_path("backups")
}
fn write_sidecars(
path: &Path,
md5: &str,
sha256: &str,
partition: &alkane_artifacts::afw::AfwPartition,
image_sha256: &str,
epoch: u64,
) -> Result<(), InstallError> {
let file_name = path
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_else(|| "p1.img".to_owned());
fs::write(
path.with_extension("img.sha256"),
format!("{sha256} {file_name}\n"),
)?;
let metadata = serde_json::json!({
"board": "cv1835",
"partition": partition.name,
"device": partition.device,
"size": partition.size,
"md5": md5,
"sha256": sha256,
"afw_sha256": image_sha256,
"created_unix": epoch,
});
fs::write(
path.with_extension("img.json"),
serde_json::to_vec_pretty(&metadata).unwrap_or_default(),
)?;
Ok(())
}
fn read_sidecar(path: &Path) -> Option<String> {
let text = fs::read_to_string(path.with_extension("img.sha256")).ok()?;
text.split_whitespace().next().map(str::to_owned)
}
#[derive(Clone, Debug)]
pub struct LiveReport {
pub attempts: u32,
pub http: String,
pub http_ok: bool,
pub ssh: String,
pub ssh_ok: bool,
pub api: String,
pub api_ok: bool,
}
impl LiveReport {
pub fn ok(&self) -> bool {
self.http_ok && self.ssh_ok && self.api_ok
}
pub fn render(&self) -> String {
format!(
"verify-live attempts {}\n http {}: {}\n ssh {}: {}\n api {}: {}\nresult {}",
self.attempts,
if self.http_ok { "ok" } else { "FAIL" },
self.http,
if self.ssh_ok { "ok" } else { "FAIL" },
self.ssh,
if self.api_ok { "ok" } else { "FAIL" },
self.api,
if self.ok() { "PASS" } else { "FAIL" }
)
}
}
pub fn verify_live(
host: &str,
marker: &str,
kernel_version: &str,
timeout: Duration,
ssh_options: &SshOptions,
) -> LiveReport {
let deadline = Instant::now() + timeout;
let mut attempts = 0;
loop {
attempts += 1;
let (http, http_ok) = match http_get(host, "/", Duration::from_secs(5)) {
Ok(body) => {
let ok = body.contains(marker);
(
if ok {
format!("marker {marker} present")
} else {
format!("marker {marker} absent ({} bytes)", body.len())
},
ok,
)
}
Err(error) => (error, false),
};
let (ssh, ssh_ok) = match SshTransport::connect(ssh_options.clone(), false) {
Ok(mut session) => match session.user_command("uname -r", Duration::from_secs(15)) {
Ok(output) => {
let kernel = String::from_utf8_lossy(&output).trim().to_owned();
let ok = !kernel.is_empty()
&& (kernel_version.is_empty() || kernel.contains(kernel_version));
(
format!(
"kernel {kernel}{}",
if ok {
""
} else {
" (expected the installed kernel)"
}
),
ok,
)
}
Err(error) => (format!("{error}"), false),
},
Err(error) => (format!("{error}"), false),
};
let (api, api_ok) = match api_version(host, Duration::from_secs(5)) {
Ok(body) => {
let ok = body.contains("\"STATUS\"")
|| body.contains("\"VERSION\"")
|| body.to_lowercase().contains("version");
(format!("{} bytes", body.len()), ok)
}
Err(error) => (error, false),
};
if http_ok && ssh_ok && api_ok {
return LiveReport {
attempts,
http,
http_ok,
ssh,
ssh_ok,
api,
api_ok,
};
}
if Instant::now() >= deadline {
return LiveReport {
attempts,
http,
http_ok,
ssh,
ssh_ok,
api,
api_ok,
};
}
std::thread::sleep(Duration::from_secs(5));
}
}
pub(crate) fn http_get(host: &str, path: &str, timeout: Duration) -> Result<String, String> {
let address = (host, 80_u16)
.to_socket_addrs()
.map_err(|error| format!("resolve: {error}"))?
.next()
.ok_or_else(|| "no address".to_owned())?;
let mut stream = TcpStream::connect_timeout(&address, timeout)
.map_err(|error| format!("connect: {error}"))?;
stream
.set_read_timeout(Some(timeout))
.map_err(|error| error.to_string())?;
let request = format!("GET {path} HTTP/1.0\r\nHost: {host}\r\nConnection: close\r\n\r\n");
stream
.write_all(request.as_bytes())
.map_err(|error| error.to_string())?;
let mut data = Vec::new();
let mut buffer = [0_u8; 8192];
loop {
match stream.read(&mut buffer) {
Ok(0) => break,
Ok(read) => {
data.extend_from_slice(&buffer[..read]);
if data.len() > 512 * 1024 {
break;
}
}
Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => break,
Err(error) if error.kind() == std::io::ErrorKind::TimedOut => break,
Err(error) => return Err(error.to_string()),
}
}
let text = String::from_utf8_lossy(&data).into_owned();
let status_ok = text
.lines()
.next()
.map(|line| line.contains(" 200 ") || line.ends_with(" 200"))
.unwrap_or(false);
if status_ok {
Ok(text)
} else {
Err(text.lines().next().unwrap_or("no HTTP response").to_owned())
}
}
pub(crate) fn api_version(host: &str, timeout: Duration) -> Result<String, String> {
let address = (host, 4028_u16)
.to_socket_addrs()
.map_err(|error| format!("resolve: {error}"))?
.next()
.ok_or_else(|| "no address".to_owned())?;
let mut stream = TcpStream::connect_timeout(&address, timeout)
.map_err(|error| format!("connect: {error}"))?;
stream
.set_read_timeout(Some(timeout))
.map_err(|error| error.to_string())?;
stream
.write_all(b"{\"command\":\"version\"}\n")
.map_err(|error| error.to_string())?;
let mut data = Vec::new();
let mut buffer = [0_u8; 4096];
loop {
match stream.read(&mut buffer) {
Ok(0) => break,
Ok(read) => {
data.extend_from_slice(&buffer[..read]);
if data.len() > 64 * 1024 {
break;
}
}
Err(error) if error.kind() == std::io::ErrorKind::WouldBlock => break,
Err(error) if error.kind() == std::io::ErrorKind::TimedOut => break,
Err(error) => return Err(error.to_string()),
}
}
let text = String::from_utf8_lossy(&data).trim().to_owned();
if text.is_empty() {
Err("no API response".to_owned())
} else {
Ok(text)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn derives_backup_sidecar_names() {
let path = Path::new("/tmp/p1-1.img");
assert_eq!(
path.with_extension("img.sha256"),
Path::new("/tmp/p1-1.img.sha256")
);
assert_eq!(
path.with_extension("img.json"),
Path::new("/tmp/p1-1.img.json")
);
}
#[test]
fn restore_command_names_the_held_copy() {
let command = restore_command("/dev/mmcblk0p1", Path::new("/tmp/p1.img"));
assert!(command.contains("afw restore"));
assert!(command.contains("/tmp/p1.img"));
}
}
#[cfg(test)]
mod network_tests {
use super::*;
use alkane_artifacts::afw::{AfwImage, AfwManifest, AfwMember, AfwPartition, BootloaderPolicy};
use serde_json::json;
use std::collections::HashMap;
const P1: usize = 16 * 1024 * 1024;
const REV: &str = "0000000000000000000000000000000000000000";
struct MockRemote {
partition: Vec<u8>,
files: HashMap<String, Vec<u8>>,
commands: Vec<String>,
rebooted: bool,
readback_corrupt: bool,
}
impl MockRemote {
fn new(partition: Vec<u8>) -> Self {
Self {
partition,
files: HashMap::new(),
commands: Vec::new(),
rebooted: false,
readback_corrupt: false,
}
}
fn md5(&self, data: &[u8]) -> String {
md5_hex(data)
}
}
impl Remote for MockRemote {
fn channel(&self) -> &str {
"mock"
}
fn root_method(&self) -> &'static str {
"direct"
}
fn user_command(
&mut self,
command: &str,
_timeout: Duration,
) -> Result<Vec<u8>, RemoteError> {
self.commands.push(command.to_owned());
let text = if command.contains("uname -r") {
"6.18.48\n__MODEL__\nAlkane CV1835\n__RELEASE__\nalkane\n".to_owned()
} else if command.contains("test -b") {
"block".to_owned()
} else if command.contains("/sys/class/block/mmcblk0p1/size") {
"32768".to_owned()
} else if command.contains("for c in dd") {
"dd\nmd5sum\nsync\n".to_owned()
} else if command.contains("df -k") {
"Filesystem 1K-blocks Used Available Use% Mounted on\n/dev/root 100000 1 90000 1% /tmp\n".to_owned()
} else if command.contains("mmcblk0boot0") {
"yes".to_owned()
} else {
String::new()
};
Ok(text.into_bytes())
}
fn root_command(
&mut self,
command: &str,
_timeout: Duration,
) -> Result<Vec<u8>, RemoteError> {
self.commands.push(command.to_owned());
if command.starts_with("id -u") || command == "id" {
return Ok(b"0\n".to_vec());
}
if let Some(rest) = command.strip_prefix("md5sum /dev/mmcblk0p1") {
let _ = rest;
let mut data = self.partition.clone();
if self.readback_corrupt && self.files.contains_key(REMOTE_STAGE) {
if let Some(last) = data.last_mut() {
*last ^= 0xff;
}
self.readback_corrupt = false;
}
return Ok(format!("{} /dev/mmcblk0p1\n", self.md5(&data)).into_bytes());
}
if let Some(rest) = command.strip_prefix("md5sum ") {
let path = rest.split_whitespace().next().unwrap_or("");
let data = self.files.get(path).cloned().unwrap_or_default();
return Ok(format!("{} {path}\n", self.md5(&data)).into_bytes());
}
if let Some(rest) = command.strip_prefix("dd if=") {
let mut parts = rest.splitn(2, " of=");
let source = parts.next().unwrap_or("");
let target = parts
.next()
.unwrap_or("")
.split_whitespace()
.next()
.unwrap_or("");
if source == "/dev/mmcblk0p1" {
self.files.insert(target.to_owned(), self.partition.clone());
} else if target == "/dev/mmcblk0p1" {
if let Some(data) = self.files.get(source).cloned() {
self.partition = data;
}
}
return Ok(Vec::new());
}
if command.starts_with("rm -f ") {
let path = command.trim_start_matches("rm -f ").trim();
self.files.remove(path);
return Ok(Vec::new());
}
Ok(Vec::new())
}
fn push(
&mut self,
local: &Path,
remote: &str,
_timeout: Duration,
) -> Result<(), RemoteError> {
self.files.insert(remote.to_owned(), fs::read(local)?);
Ok(())
}
fn pull(
&mut self,
remote: &str,
local: &Path,
_timeout: Duration,
) -> Result<(), RemoteError> {
let data = self
.files
.get(remote)
.cloned()
.ok_or_else(|| RemoteError::Daemon("missing file".to_owned()))?;
fs::write(local, data)?;
Ok(())
}
fn reboot(&mut self) -> Result<(), RemoteError> {
self.rebooted = true;
Ok(())
}
}
fn p1_image() -> Vec<u8> {
let mut fit = vec![0_u8; P1];
fit[..4].copy_from_slice(b"\xd0\x0d\xfe\xed");
let marker = b"config@cv1835_miner_emmc";
fit[0x100..0x100 + marker.len()].copy_from_slice(marker);
fit
}
fn verified(data: &[u8]) -> VerifiedAfw {
let manifest = AfwManifest {
schema: 2,
format: "afw".to_owned(),
board: "cv1835".to_owned(),
arch: "arm64".to_owned(),
version: "0.1.0".to_owned(),
build_date: "2026-11-04T00:00:00Z".to_owned(),
sdk_revision: REV.to_owned(),
os_revision: REV.to_owned(),
payload_type: "os".to_owned(),
bootloader_policy: BootloaderPolicy::Preserve,
signature: alkane_artifacts::afw::AfwSignature {
kind: "unsigned".to_owned(),
member: None,
public_key_hex: None,
},
partitions: vec![
AfwPartition {
name: "p1".to_owned(),
device: "/dev/mmcblk0p1".to_owned(),
offset: 0,
size: P1 as u64,
secure: false,
boot_critical: true,
write_order: 1,
image: Some("p1".to_owned()),
},
AfwPartition {
name: "boot0".to_owned(),
device: "/dev/mmcblk0boot0".to_owned(),
offset: 0,
size: 4 * 1024 * 1024,
secure: true,
boot_critical: true,
write_order: 0,
image: None,
},
],
images: vec![AfwImage {
name: "p1".to_owned(),
file: "payload/p1.fit".to_owned(),
role: "boot".to_owned(),
format: "fit".to_owned(),
size: P1 as u64,
sha256: Sha256::digest(data)
.iter()
.map(|byte| format!("{byte:02x}"))
.collect(),
partition: Some("p1".to_owned()),
install: true,
}],
boot_switch: json!({"method": "partition-overwrite"}),
preflight: json!({"required_commands": ["dd", "md5sum", "sync"],
"source_os": ["stock-bitmain", "vnish", "braiins", "ouros", "alkane"],
"min_free_bytes": 33554432}),
recovery: json!({"network": "afw restore", "golden_lba_bytes": 0x300000u64 * 512}),
marker: "Alkane".to_owned(),
kernel_version: "6.18.48".to_owned(),
notes: None,
};
VerifiedAfw {
manifest,
members: vec![AfwMember {
name: "payload/p1.fit".to_owned(),
data: data.to_vec(),
}],
manifest_sha256: "0".repeat(64),
archive_sha256: "0".repeat(64),
}
}
#[test]
fn installs_p1_holds_a_backup_and_verifies_before_reboot() {
let original = vec![0x11_u8; P1];
let new = p1_image();
let afw = verified(&new);
let plan = Cv1835Plan::from_afw(&afw).unwrap();
let mut remote = MockRemote::new(original.clone());
let temp = tempfile::tempdir().unwrap();
let options = InstallOptions {
dry_run: false,
confirm: Some("FLASH".to_owned()),
no_reboot: true,
backup_dir: temp.path().to_path_buf(),
held_backup: None,
allow_unknown_source: true,
check_golden: false,
};
let outcome = install(&afw, &plan, &mut remote, &options, "10.255.1.1").unwrap();
let InstallOutcome::Installed(receipt) = outcome else {
panic!("expected an install");
};
assert_eq!(remote.partition, new);
assert_eq!(receipt.backup_md5, md5_hex(&original));
assert!(receipt.backup_path.is_file());
assert!(!remote.rebooted);
assert!(remote
.commands
.iter()
.any(|command| command.starts_with("dd if=/tmp/.alkane-p1-stage.img")));
}
#[test]
fn dry_run_never_writes_the_partition() {
let original = vec![0x22_u8; P1];
let new = p1_image();
let afw = verified(&new);
let plan = Cv1835Plan::from_afw(&afw).unwrap();
let mut remote = MockRemote::new(original.clone());
let temp = tempfile::tempdir().unwrap();
let options = InstallOptions {
dry_run: true,
confirm: None,
no_reboot: false,
backup_dir: temp.path().to_path_buf(),
held_backup: None,
allow_unknown_source: true,
check_golden: false,
};
let outcome = install(&afw, &plan, &mut remote, &options, "10.255.1.1").unwrap();
assert!(matches!(outcome, InstallOutcome::DryRun(_)));
assert_eq!(remote.partition, original);
assert!(!remote
.commands
.iter()
.any(|command| command.starts_with("dd if=/tmp/.alkane-p1-stage.img")));
}
#[test]
fn a_readback_mismatch_stops_before_reboot() {
let original = vec![0x33_u8; P1];
let new = p1_image();
let afw = verified(&new);
let plan = Cv1835Plan::from_afw(&afw).unwrap();
let mut remote = MockRemote::new(original);
remote.readback_corrupt = true;
let temp = tempfile::tempdir().unwrap();
let options = InstallOptions {
dry_run: false,
confirm: Some("FLASH".to_owned()),
no_reboot: false,
backup_dir: temp.path().to_path_buf(),
held_backup: None,
allow_unknown_source: true,
check_golden: false,
};
let result = install(&afw, &plan, &mut remote, &options, "10.255.1.1");
assert!(matches!(result, Err(InstallError::Readback(_))));
assert!(!remote.rebooted);
}
#[test]
fn confirm_is_required_before_any_device_write() {
let original = vec![0x44_u8; P1];
let new = p1_image();
let afw = verified(&new);
let plan = Cv1835Plan::from_afw(&afw).unwrap();
let mut remote = MockRemote::new(original.clone());
let temp = tempfile::tempdir().unwrap();
let options = InstallOptions {
dry_run: false,
confirm: None,
no_reboot: false,
backup_dir: temp.path().to_path_buf(),
held_backup: None,
allow_unknown_source: true,
check_golden: false,
};
let result = install(&afw, &plan, &mut remote, &options, "10.255.1.1");
assert!(matches!(result, Err(InstallError::Confirm)));
assert_eq!(remote.partition, original);
}
}
+476 -1
View File
@@ -1 +1,476 @@
// alkane-flash
// SPDX-License-Identifier: MIT
//! Guarded writes plus the network-only CV1835 installer.
//!
//! The original guarded-write helpers remain for boards that need an attached
//! recovery channel. CV1835 uses the network modules below: a verified `.afw`,
//! a board plan, an SSH transport with a stock-root stage, a read-only
//! preflight, a whole-partition read-back and a network restore.
// The board modules are driven by static NAND/partition map tables (tuples) and
// multi-field hardware write functions; the two style lints below are design
// choices for this crate rather than defects.
#![allow(clippy::type_complexity, clippy::too_many_arguments)]
pub mod boards;
pub mod install;
pub mod md5;
pub mod preflight;
pub mod stock;
pub mod stock_firmware;
// Network-only stock-crossing method bodies compiled into the toolkit; the
// public interface lives in `stock`. See stock_method.rs. This module is
// maintained as a self-contained unit; the style lints below are allowed here so
// its internal layout is not churned to satisfy them.
#[allow(
clippy::needless_range_loop,
clippy::type_complexity,
clippy::too_many_arguments,
clippy::manual_repeat_n,
clippy::manual_is_multiple_of,
clippy::unnecessary_map_or
)]
mod stock_method;
pub mod transport;
use alkane_artifacts::VerifiedArtifact;
use sha2::{Digest, Sha256};
use std::io::{Read, Seek, SeekFrom, Write};
use thiserror::Error;
pub struct PartitionSpec {
pub name: String,
pub capacity_bytes: u64,
pub secure: bool,
pub boot_critical: bool,
}
pub struct BackupEvidence {
pub location: String,
pub bytes: u64,
pub sha256: [u8; 32],
}
pub struct WriteReceipt {
pub partition: String,
pub backup: BackupEvidence,
pub image_sha256: [u8; 32],
}
pub trait Writer {
type Error: std::fmt::Display;
fn channel_id(&self) -> &str;
fn serial_console_attached(&mut self) -> Result<bool, Self::Error>;
fn recovery_image_ready(&mut self, partition: &PartitionSpec) -> Result<bool, Self::Error>;
fn backup(&mut self, partition: &PartitionSpec) -> Result<BackupEvidence, Self::Error>;
fn write(
&mut self,
partition: &PartitionSpec,
image: &mut dyn Read,
image_size: u64,
) -> Result<(), Self::Error>;
}
pub trait IndependentReadback {
type Error: std::fmt::Display;
fn channel_id(&self) -> &str;
fn sha256(&mut self, partition: &PartitionSpec, length: u64) -> Result<[u8; 32], Self::Error>;
}
#[derive(Debug, Error, Eq, PartialEq)]
pub enum FlashError {
#[error("secure partition write refused")]
SecurePartition,
#[error("image exceeds partition capacity")]
ImageTooLarge,
#[error("boot-critical write requires an attached serial console")]
SerialRequired,
#[error("boot-critical write requires verified recovery media")]
RecoveryRequired,
#[error("readback must use an independent channel")]
SameChannel,
#[error("complete backup evidence is missing")]
BackupIncomplete,
#[error("post-write readback differs from the image")]
ReadbackMismatch,
#[error("verified image has an invalid digest")]
InvalidDigest,
#[error("image changed since verification")]
ArtifactChanged,
#[error("writer did not consume the complete image")]
IncompleteWrite,
#[error("write transport: {0}")]
Write(String),
#[error("readback transport: {0}")]
Readback(String),
#[error("artifact I/O: {0}")]
ArtifactIo(String),
}
fn digest_bytes(hex: &str) -> Result<[u8; 32], FlashError> {
if hex.len() != 64 {
return Err(FlashError::InvalidDigest);
}
let mut result = [0_u8; 32];
for (index, pair) in hex.as_bytes().chunks_exact(2).enumerate() {
let text = std::str::from_utf8(pair).map_err(|_| FlashError::InvalidDigest)?;
result[index] = u8::from_str_radix(text, 16).map_err(|_| FlashError::InvalidDigest)?;
}
Ok(result)
}
fn stage_verified_artifact(
artifact: &mut VerifiedArtifact,
size: u64,
expected: [u8; 32],
) -> Result<std::fs::File, FlashError> {
let mut staged = tempfile::tempfile().map_err(|e| FlashError::ArtifactIo(e.to_string()))?;
artifact
.reader()
.seek(SeekFrom::Start(0))
.map_err(|e| FlashError::ArtifactIo(e.to_string()))?;
let mut source = DigestReader {
inner: artifact.reader(),
remaining: size,
digest: Sha256::new(),
};
std::io::copy(&mut source, &mut staged).map_err(|e| FlashError::ArtifactIo(e.to_string()))?;
if source.remaining != 0 || <[u8; 32]>::from(source.digest.finalize()) != expected {
return Err(FlashError::ArtifactChanged);
}
staged
.flush()
.map_err(|e| FlashError::ArtifactIo(e.to_string()))?;
staged
.seek(SeekFrom::Start(0))
.map_err(|e| FlashError::ArtifactIo(e.to_string()))?;
Ok(staged)
}
struct DigestReader<'a> {
inner: &'a mut dyn Read,
remaining: u64,
digest: Sha256,
}
impl Read for DigestReader<'_> {
fn read(&mut self, buffer: &mut [u8]) -> std::io::Result<usize> {
let limit = buffer
.len()
.min(usize::try_from(self.remaining).unwrap_or(usize::MAX));
let length = self.inner.read(&mut buffer[..limit])?;
self.remaining -= length as u64;
self.digest.update(&buffer[..length]);
Ok(length)
}
}
/// Stop before reboot. The caller must still prove live boot and persistence.
pub fn write_verified<W: Writer, R: IndependentReadback>(
partition: &PartitionSpec,
artifact: &mut VerifiedArtifact,
writer: &mut W,
readback: &mut R,
) -> Result<WriteReceipt, FlashError> {
if partition.secure {
return Err(FlashError::SecurePartition);
}
let size = artifact.record().size_bytes;
if size == 0 || partition.capacity_bytes == 0 || size > partition.capacity_bytes {
return Err(FlashError::ImageTooLarge);
}
if writer.channel_id().is_empty()
|| readback.channel_id().is_empty()
|| writer.channel_id() == readback.channel_id()
{
return Err(FlashError::SameChannel);
}
if partition.boot_critical {
if !writer
.serial_console_attached()
.map_err(|e| FlashError::Write(e.to_string()))?
{
return Err(FlashError::SerialRequired);
}
if !writer
.recovery_image_ready(partition)
.map_err(|e| FlashError::Write(e.to_string()))?
{
return Err(FlashError::RecoveryRequired);
}
}
artifact
.revalidate()
.map_err(|_| FlashError::ArtifactChanged)?;
let expected = digest_bytes(&artifact.record().sha256)?;
// The source path may change while backup or transport I/O runs. Copy and
// verify it before any device write; the anonymous file is removed on drop.
let mut staged = stage_verified_artifact(artifact, size, expected)?;
let backup = writer
.backup(partition)
.map_err(|e| FlashError::Write(e.to_string()))?;
if backup.location.is_empty()
|| backup.bytes != partition.capacity_bytes
|| backup.sha256 == [0; 32]
{
return Err(FlashError::BackupIncomplete);
}
let mut stream = DigestReader {
inner: &mut staged,
remaining: size,
digest: Sha256::new(),
};
writer
.write(partition, &mut stream, size)
.map_err(|e| FlashError::Write(e.to_string()))?;
if stream.remaining != 0 {
return Err(FlashError::IncompleteWrite);
}
let written_digest: [u8; 32] = stream.digest.finalize().into();
if written_digest != expected {
return Err(FlashError::ArtifactChanged);
}
let actual = readback
.sha256(partition, size)
.map_err(|e| FlashError::Readback(e.to_string()))?;
if actual != expected {
return Err(FlashError::ReadbackMismatch);
}
Ok(WriteReceipt {
partition: partition.name.clone(),
backup,
image_sha256: expected,
})
}
#[cfg(test)]
mod tests {
use super::*;
use alkane_artifacts::{verify_file, ArtifactRecord};
use std::path::PathBuf;
const SHA: &str = "bf7d458495ed067341c7148cd3d30e6d383a2113b2cfb37de12959e057a52528";
const IMAGE: &[u8] = b"PK\x03\x04payload";
struct MockWriter {
serial: bool,
recovery: bool,
backup_bytes: u64,
max_read: Option<u64>,
writes: usize,
contents: Vec<u8>,
mutate_source_on_write: Option<PathBuf>,
}
impl Writer for MockWriter {
type Error = &'static str;
fn channel_id(&self) -> &str {
"ssh"
}
fn serial_console_attached(&mut self) -> Result<bool, Self::Error> {
Ok(self.serial)
}
fn recovery_image_ready(&mut self, _: &PartitionSpec) -> Result<bool, Self::Error> {
Ok(self.recovery)
}
fn backup(&mut self, _: &PartitionSpec) -> Result<BackupEvidence, Self::Error> {
Ok(BackupEvidence {
location: "recovery/partition.img".to_owned(),
bytes: self.backup_bytes,
sha256: [1; 32],
})
}
fn write(
&mut self,
_: &PartitionSpec,
image: &mut dyn Read,
_: u64,
) -> Result<(), Self::Error> {
self.writes += 1;
if let Some(path) = &self.mutate_source_on_write {
std::fs::write(path, b"PK\x03\x04changed").map_err(|_| "mutation failed")?;
}
if let Some(limit) = self.max_read {
image
.take(limit)
.read_to_end(&mut self.contents)
.map_err(|_| "read failed")?;
} else {
image
.read_to_end(&mut self.contents)
.map_err(|_| "read failed")?;
}
Ok(())
}
}
struct MockReadback {
channel: &'static str,
digest: [u8; 32],
}
impl IndependentReadback for MockReadback {
type Error = &'static str;
fn channel_id(&self) -> &str {
self.channel
}
fn sha256(&mut self, _: &PartitionSpec, _: u64) -> Result<[u8; 32], Self::Error> {
Ok(self.digest)
}
}
fn artifact(suffix: &str) -> (PathBuf, VerifiedArtifact) {
let path =
std::env::temp_dir().join(format!("alkane-flash-test-{}-{suffix}", std::process::id()));
std::fs::write(&path, IMAGE).unwrap();
let record = ArtifactRecord {
sha256: SHA.to_owned(),
size_bytes: IMAGE.len() as u64,
path: PathBuf::from("fixture.zip"),
family: "test".to_owned(),
format: "update-zip".to_owned(),
applicability: "test".to_owned(),
};
let verified = verify_file(&path, &record).unwrap();
(path, verified)
}
fn writer() -> MockWriter {
MockWriter {
serial: true,
recovery: true,
backup_bytes: 4096,
max_read: None,
writes: 0,
contents: Vec::new(),
mutate_source_on_write: None,
}
}
fn partition() -> PartitionSpec {
PartitionSpec {
name: "rootfs".to_owned(),
capacity_bytes: 4096,
secure: false,
boot_critical: true,
}
}
#[test]
fn refuses_secure_and_unrecoverable_writes_before_device_mutation() {
let (path, mut image) = artifact("refusals");
let mut target = partition();
let mut writer = writer();
let mut readback = MockReadback {
channel: "serial",
digest: digest_bytes(SHA).unwrap(),
};
target.secure = true;
assert!(matches!(
write_verified(&target, &mut image, &mut writer, &mut readback),
Err(FlashError::SecurePartition)
));
target.secure = false;
target.capacity_bytes = 1;
assert!(matches!(
write_verified(&target, &mut image, &mut writer, &mut readback),
Err(FlashError::ImageTooLarge)
));
target.capacity_bytes = 4096;
writer.serial = false;
assert!(matches!(
write_verified(&target, &mut image, &mut writer, &mut readback),
Err(FlashError::SerialRequired)
));
writer.serial = true;
writer.recovery = false;
assert!(matches!(
write_verified(&target, &mut image, &mut writer, &mut readback),
Err(FlashError::RecoveryRequired)
));
writer.recovery = true;
writer.backup_bytes = 1;
assert!(matches!(
write_verified(&target, &mut image, &mut writer, &mut readback),
Err(FlashError::BackupIncomplete)
));
assert_eq!(writer.writes, 0);
std::fs::remove_file(path).unwrap();
}
#[test]
fn requires_independent_matching_readback() {
let (path, mut image) = artifact("readback");
let target = partition();
let mut writer = writer();
let mut readback = MockReadback {
channel: "ssh",
digest: [0; 32],
};
assert!(matches!(
write_verified(&target, &mut image, &mut writer, &mut readback),
Err(FlashError::SameChannel)
));
assert_eq!(writer.writes, 0);
readback.channel = "serial";
assert!(matches!(
write_verified(&target, &mut image, &mut writer, &mut readback),
Err(FlashError::ReadbackMismatch)
));
assert_eq!(writer.writes, 1);
assert_eq!(writer.contents, IMAGE);
writer.contents.clear();
readback.digest = digest_bytes(SHA).unwrap();
let receipt = write_verified(&target, &mut image, &mut writer, &mut readback).unwrap();
assert_eq!(receipt.image_sha256, readback.digest);
assert_eq!(receipt.backup.bytes, 4096);
assert_eq!(writer.writes, 2);
assert_eq!(writer.contents, IMAGE);
std::fs::remove_file(path).unwrap();
}
#[test]
fn refuses_changed_or_partially_consumed_artifacts() {
let (path, mut image) = artifact("changed");
let target = partition();
let mut writer = writer();
let mut readback = MockReadback {
channel: "serial",
digest: digest_bytes(SHA).unwrap(),
};
std::fs::write(&path, b"PK\x03\x04changed").unwrap();
assert!(matches!(
write_verified(&target, &mut image, &mut writer, &mut readback),
Err(FlashError::ArtifactChanged)
));
assert_eq!(writer.writes, 0);
std::fs::write(&path, IMAGE).unwrap();
writer.max_read = Some(4);
assert!(matches!(
write_verified(&target, &mut image, &mut writer, &mut readback),
Err(FlashError::IncompleteWrite)
));
assert_eq!(writer.writes, 1);
std::fs::remove_file(path).unwrap();
}
#[test]
fn writes_verified_snapshot_when_source_changes_during_transport() {
let (path, mut image) = artifact("mutated-during-write");
let mut writer = writer();
writer.mutate_source_on_write = Some(path.clone());
let mut readback = MockReadback {
channel: "serial",
digest: digest_bytes(SHA).unwrap(),
};
let receipt = write_verified(&partition(), &mut image, &mut writer, &mut readback).unwrap();
assert_eq!(receipt.image_sha256, digest_bytes(SHA).unwrap());
assert_eq!(writer.contents, IMAGE);
assert_eq!(std::fs::read(&path).unwrap(), b"PK\x03\x04changed");
std::fs::remove_file(path).unwrap();
}
}
+116
View File
@@ -0,0 +1,116 @@
// SPDX-License-Identifier: MIT
//! MD5 for the CV1835 whole-partition read-back.
//!
//! The stock busybox on this board ships `md5sum` but not `sha256sum`, and the
//! proven installer gates the write on a whole-partition md5. This module is a
//! small RFC 1321 implementation so the host can compare the same digest
//! without shelling out to a tool that may not exist.
const S: [u32; 64] = [
7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9,
14, 20, 5, 9, 14, 20, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 6, 10, 15,
21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21,
];
const K: [u32; 64] = [
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
];
pub fn md5(data: &[u8]) -> [u8; 16] {
let mut state = [0x67452301_u32, 0xefcdab89, 0x98badcfe, 0x10325476];
let bit_length = (data.len() as u64).wrapping_mul(8);
let mut message = data.to_vec();
message.push(0x80);
while message.len() % 64 != 56 {
message.push(0);
}
message.extend_from_slice(&bit_length.to_le_bytes());
for chunk in message.chunks_exact(64) {
let mut words = [0_u32; 16];
for (index, word) in words.iter_mut().enumerate() {
let start = index * 4;
*word = u32::from_le_bytes([
chunk[start],
chunk[start + 1],
chunk[start + 2],
chunk[start + 3],
]);
}
let [mut a, mut b, mut c, mut d] = state;
for index in 0..64 {
let (f, g) = match index {
0..=15 => ((b & c) | (!b & d), index),
16..=31 => ((d & b) | (!d & c), (5 * index + 1) % 16),
32..=47 => (b ^ c ^ d, (3 * index + 5) % 16),
_ => (c ^ (b | !d), (7 * index) % 16),
};
let rotated = a
.wrapping_add(f)
.wrapping_add(K[index])
.wrapping_add(words[g])
.rotate_left(S[index]);
a = d;
d = c;
c = b;
b = b.wrapping_add(rotated);
}
state[0] = state[0].wrapping_add(a);
state[1] = state[1].wrapping_add(b);
state[2] = state[2].wrapping_add(c);
state[3] = state[3].wrapping_add(d);
}
let mut digest = [0_u8; 16];
for (index, word) in state.iter().enumerate() {
digest[index * 4..index * 4 + 4].copy_from_slice(&word.to_le_bytes());
}
digest
}
pub fn md5_hex(data: &[u8]) -> String {
md5(data).iter().map(|byte| format!("{byte:02x}")).collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rfc1321_vectors() {
assert_eq!(md5_hex(b""), "d41d8cd98f00b204e9800998ecf8427e");
assert_eq!(md5_hex(b"a"), "0cc175b9c0f1b6a831c399e269772661");
assert_eq!(md5_hex(b"abc"), "900150983cd24fb0d6963f7d28e17f72");
assert_eq!(
md5_hex(b"message digest"),
"f96b697d7cb7938d525a2f31aaf161d0"
);
assert_eq!(
md5_hex(b"abcdefghijklmnopqrstuvwxyz"),
"c3fcd3d76192e4007dfb496cca67e13b"
);
assert_eq!(
md5_hex(b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"),
"d174ab98d277d9f5a5611c2c9f419d9f"
);
assert_eq!(
md5_hex(
b"12345678901234567890123456789012345678901234567890123456789012345678901234567890"
),
"57edf4a22be3c955ac49da2e2107b67a"
);
}
#[test]
fn handles_a_block_boundary() {
let data = vec![0x42_u8; 64];
assert_eq!(md5_hex(&data), "8e558437ffca99de04c18a63b55a4fad");
}
}
+420
View File
@@ -0,0 +1,420 @@
// SPDX-License-Identifier: MIT
//! Read-only CV1835 preflight: source-OS fingerprint, root channel, partition
//! identity, held/golden backup hashes, free space and secure-region refusal.
//!
//! Every check runs over the network. A failure is reported, never repaired.
use crate::boards::cv1835::{Cv1835Plan, CvPlanError};
use crate::md5::md5_hex;
use crate::transport::{Remote, RemoteError};
use sha2::{Digest, Sha256};
use std::fs;
use std::path::{Path, PathBuf};
use std::time::Duration;
use thiserror::Error;
const P1_NAME: &str = "mmcblk0p1";
#[derive(Debug, Error)]
pub enum PreflightError {
#[error("preflight transport: {0}")]
Remote(#[from] RemoteError),
#[error("preflight I/O: {0}")]
Io(#[from] std::io::Error),
#[error("preflight plan: {0}")]
Plan(#[from] CvPlanError),
#[error("held backup {path} is {size} bytes, not 16 MiB")]
BackupSize { path: PathBuf, size: u64 },
#[error("held backup {0} has no readable md5")]
BackupUnreadable(PathBuf),
}
#[derive(Clone, Debug)]
pub struct Check {
pub name: &'static str,
pub ok: bool,
pub detail: String,
}
#[derive(Clone, Debug)]
pub struct BackupCheck {
pub path: PathBuf,
pub md5: String,
pub sha256: String,
pub matches_live: bool,
}
#[derive(Clone, Debug)]
pub struct PreflightReport {
pub host: String,
pub source_os: String,
pub kernel: String,
pub model: String,
pub root_method: String,
pub root_uid: String,
pub partition_device: String,
pub partition_size: u64,
pub live_md5: String,
pub held_backup: Option<BackupCheck>,
pub golden_md5: Option<String>,
pub free_bytes: u64,
pub boot0_present: bool,
pub checks: Vec<Check>,
}
impl PreflightReport {
pub fn ok(&self) -> bool {
self.checks.iter().all(|check| check.ok)
}
pub fn failures(&self) -> Vec<&Check> {
self.checks.iter().filter(|check| !check.ok).collect()
}
pub fn render(&self) -> String {
let mut out = String::new();
out.push_str(&format!("preflight {}\n", self.host));
out.push_str(&format!(
"source-os {} (kernel {})\n",
self.source_os, self.kernel
));
if !self.model.is_empty() {
out.push_str(&format!("model {}\n", self.model));
}
out.push_str(&format!(
"root {} (uid {})\n",
self.root_method, self.root_uid
));
out.push_str(&format!(
"partition {} {} B\n",
self.partition_device, self.partition_size
));
out.push_str(&format!("live p1 md5 {}\n", self.live_md5));
match &self.held_backup {
Some(backup) => out.push_str(&format!(
"held backup {} md5 {} ({})\n",
backup.path.display(),
backup.md5,
if backup.matches_live {
"matches live p1"
} else {
"differs from live p1"
}
)),
None => out.push_str("held backup none (install will create one before writing)\n"),
}
if let Some(golden) = &self.golden_md5 {
out.push_str(&format!("golden raw p1 md5 {golden}\n"));
}
out.push_str(&format!(
"free tmp {} MiB\n",
self.free_bytes / (1024 * 1024)
));
out.push_str(&format!(
"boot0 {} (never written)\n",
if self.boot0_present {
"present"
} else {
"not present"
}
));
for check in &self.checks {
out.push_str(&format!(
"check {} {}: {}\n",
check.name,
if check.ok { "ok" } else { "FAIL" },
check.detail
));
}
out.push_str(if self.ok() {
"result PASS\n"
} else {
"result FAIL (do not write)\n"
});
out
}
}
pub struct PreflightOptions<'a> {
pub host: &'a str,
pub held_backup: Option<&'a Path>,
pub check_golden: bool,
pub allow_unknown_source: bool,
}
pub fn preflight(
plan: &Cv1835Plan,
remote: &mut dyn Remote,
options: &PreflightOptions<'_>,
) -> Result<PreflightReport, PreflightError> {
let mut checks = Vec::new();
let fingerprint = remote.user_command(
"uname -r; echo __MODEL__; cat /proc/device-tree/model 2>/dev/null; echo; \
echo __RELEASE__; cat /etc/os-release 2>/dev/null; \
ls /etc/bos_version /etc/fw-info /etc/alkane-release /etc/ouros-release 2>/dev/null; \
test -x /nvdata/rroot && echo rroot; \
test -x /usr/sbin/update-daemon && echo update-daemon",
Duration::from_secs(20),
)?;
let text = String::from_utf8_lossy(&fingerprint).into_owned();
let mut sections = text.split("__MODEL__");
let kernel = sections.next().unwrap_or("").trim().to_owned();
let rest = sections.next().unwrap_or("");
let mut sections = rest.split("__RELEASE__");
let model = sections.next().unwrap_or("").trim().to_owned();
let release = sections.next().unwrap_or("");
let source_os = classify(&kernel, release, &text);
let source_ok = plan.source_os.is_empty()
|| plan.source_os.iter().any(|item| item == &source_os)
|| options.allow_unknown_source;
checks.push(Check {
name: "source-os",
ok: source_ok,
detail: format!(
"{source_os} (allowed: {})",
if plan.source_os.is_empty() {
"any".to_owned()
} else {
plan.source_os.join(", ")
}
),
});
let root_uid = String::from_utf8_lossy(&remote.root_command("id -u", Duration::from_secs(20))?)
.trim()
.to_owned();
checks.push(Check {
name: "root",
ok: root_uid == "0",
detail: format!("uid {root_uid}"),
});
let partition_device = plan.partition.device.clone();
let block = String::from_utf8_lossy(&remote.user_command(
&format!("test -b {partition_device} && echo block || echo missing"),
Duration::from_secs(15),
)?)
.trim()
.to_owned();
let size_out = remote.user_command(
&format!("cat /sys/class/block/{P1_NAME}/size 2>/dev/null || true"),
Duration::from_secs(15),
)?;
let sectors: u64 = String::from_utf8_lossy(&size_out)
.trim()
.parse()
.unwrap_or(0);
let partition_size = sectors.saturating_mul(512);
checks.push(Check {
name: "partition",
ok: block == "block" && partition_size == plan.partition.size,
detail: format!(
"{partition_device} {partition_size} B (plan {} B)",
plan.partition.size
),
});
let live = remote.root_command(
&format!("md5sum {partition_device}"),
Duration::from_secs(60),
)?;
let live_md5 = parse_digest(&live, 32).unwrap_or_else(|| "unreadable".to_owned());
checks.push(Check {
name: "live-p1-md5",
ok: live_md5.len() == 32,
detail: live_md5.clone(),
});
let commands = remote.user_command(
"for c in dd md5sum sync; do command -v $c >/dev/null 2>&1 && echo $c || echo missing:$c; done",
Duration::from_secs(15),
)?;
let commands_text = String::from_utf8_lossy(&commands).into_owned();
let missing: Vec<&str> = commands_text
.lines()
.filter_map(|line| line.strip_prefix("missing:"))
.collect();
checks.push(Check {
name: "commands",
ok: missing.is_empty(),
detail: if missing.is_empty() {
"dd, md5sum, sync present".to_owned()
} else {
format!("missing {}", missing.join(", "))
},
});
let free_bytes = free_bytes(remote)?;
checks.push(Check {
name: "free-space",
ok: free_bytes >= plan.min_free_bytes,
detail: format!(
"{} MiB at /tmp (plan {} MiB)",
free_bytes / (1024 * 1024),
plan.min_free_bytes / (1024 * 1024)
),
});
let boot0 = String::from_utf8_lossy(&remote.user_command(
"test -e /dev/mmcblk0boot0 && echo yes || echo no",
Duration::from_secs(15),
)?)
.trim()
.to_owned();
let boot0_present = boot0 == "yes";
checks.push(Check {
name: "secure-regions",
ok: !plan.partition.device.contains("boot0"),
detail: format!(
"boot0 {}; the write plan targets only {}",
if boot0_present { "present" } else { "absent" },
plan.partition.device
),
});
let mut held_backup = None;
if let Some(path) = options.held_backup {
let size = fs::metadata(path)?.len();
if size != plan.partition.size {
return Err(PreflightError::BackupSize {
path: path.to_path_buf(),
size,
});
}
let data = fs::read(path)?;
let md5 = md5_hex(&data);
let sha256: String = Sha256::digest(&data)
.iter()
.map(|byte| format!("{byte:02x}"))
.collect();
let matches_live = md5 == live_md5;
checks.push(Check {
name: "held-backup",
ok: true,
detail: format!(
"{} md5 {md5} ({})",
path.display(),
if matches_live {
"matches live p1"
} else {
"differs from live p1; restore will still write it"
}
),
});
held_backup = Some(BackupCheck {
path: path.to_path_buf(),
md5,
sha256,
matches_live,
});
}
let mut golden_md5 = None;
if options.check_golden {
let out = remote.root_command(
&format!(
"dd if=/dev/mmcblk0 skip={} count=32768 bs=512 2>/dev/null | md5sum",
plan.golden_lba_bytes / 512
),
Duration::from_secs(90),
)?;
if let Some(digest) = parse_digest(&out, 32) {
golden_md5 = Some(digest);
}
}
Ok(PreflightReport {
host: options.host.to_owned(),
source_os,
kernel,
model,
root_method: remote.root_method().to_owned(),
root_uid,
partition_device,
partition_size,
live_md5,
held_backup,
golden_md5,
free_bytes,
boot0_present,
checks,
})
}
pub(crate) fn classify(kernel: &str, release: &str, all: &str) -> String {
if all.contains("/etc/bos_version") || release.contains("Braiins") {
return "braiins".to_owned();
}
if all.contains("/etc/alkane-release") || kernel.starts_with("6.18") {
return "alkane".to_owned();
}
if all.contains("/etc/ouros-release") || kernel.contains("6.6.147") {
return "ouros".to_owned();
}
if all.contains("/etc/fw-info") || release.contains("Vnish") || release.contains("AnthillOS") {
return "vnish".to_owned();
}
// Stock Bitmain control boards: Amlogic stock is kernel 4.9.38; the AM335x
// (BeagleBone-class) stock is kernel 3.8.13+ with an "Antminer" model line.
if kernel.contains("4.9.38")
|| kernel.starts_with("3.8.13")
|| all.contains("update-daemon")
|| all.contains("rroot")
|| all.to_lowercase().contains("antminer")
{
return "stock-bitmain".to_owned();
}
"unknown".to_owned()
}
pub fn parse_digest(output: &[u8], length: usize) -> Option<String> {
let text = String::from_utf8_lossy(output);
text.split_whitespace()
.map(|token| token.trim().to_ascii_lowercase())
.find(|token| token.len() == length && token.bytes().all(|byte| byte.is_ascii_hexdigit()))
}
fn free_bytes(remote: &mut dyn Remote) -> Result<u64, RemoteError> {
let out = remote.user_command("df -k /tmp 2>/dev/null || df -k /", Duration::from_secs(15))?;
let text = String::from_utf8_lossy(&out);
for line in text.lines().rev() {
let fields: Vec<&str> = line.split_whitespace().collect();
if fields.len() >= 4 {
if let Ok(kib) = fields[3].parse::<u64>() {
return Ok(kib.saturating_mul(1024));
}
}
}
Ok(0)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn classifies_the_source_os() {
assert_eq!(
classify("4.9.38-tag-", "", "update-daemon\n"),
"stock-bitmain"
);
assert_eq!(
classify("4.9.38-tag-", "/etc/fw-info\n", "/etc/fw-info\n"),
"vnish"
);
assert_eq!(classify("6.6.147", "/etc/ouros-release\n", ""), "ouros");
assert_eq!(classify("6.18.48", "", ""), "alkane");
assert_eq!(classify("4.9.38", "", "/etc/bos_version\n"), "braiins");
assert_eq!(classify("5.10.0", "", ""), "unknown");
}
#[test]
fn parses_md5_from_md5sum_output() {
let output = b"3f43804f10ce256200bfc71e7fbdd9ee /dev/mmcblk0p1\n";
assert_eq!(
parse_digest(output, 32).as_deref(),
Some("3f43804f10ce256200bfc71e7fbdd9ee")
);
assert_eq!(parse_digest(b"not a digest\n", 32), None);
}
}
+222
View File
@@ -0,0 +1,222 @@
// SPDX-License-Identifier: MIT
//! Stock <-> alkane crossing, compiled into the toolkit.
//!
//! The toolkit is self-contained: it installs alkane onto a board on stock and
//! returns a board to stock entirely on its own, with no external helper and no
//! runtime dependency on any other tool. A user's machine needs only this
//! binary.
//!
//! Getting our first image onto a board past its stock safeguards (with root),
//! and the reverse, are implemented in the sibling module `stock_method`. This
//! file is the stable public boundary around that work: the interface
//! (`StockMethod`, `StockError`) plus the toolkit-side orchestration and
//! verification around the method. The method is plain Rust and must be
//! network-only.
use alkane_artifacts::afw::VerifiedAfw;
use std::path::{Path, PathBuf};
use thiserror::Error;
#[derive(Debug, Error)]
pub enum StockError {
#[error("the stock method is not implemented in this build")]
NotImplemented,
#[error("could not reach the board: {0}")]
Network(String),
#[error("authentication failed: {0}")]
Auth(String),
#[error("the stock method failed: {0}")]
Method(String),
#[error("io: {0}")]
Io(String),
}
/// The genuine Bitmain stock kernel and rootfs to write back when restoring to
/// stock, parsed from a vendor firmware package (OTA or SD) by `stock_firmware`.
/// The matching NAND device tree is NOT taken from the package: Bitmain never
/// ships the kernel device tree in its distributable firmware (it is factory-
/// provisioned and preserved by every update), so the method supplies the
/// correct per-board dtb itself. Borrowed so the large rootfs is not copied
/// before the method needs it.
pub struct RestoreImages<'a> {
pub kernel: &'a [u8],
pub rootfs: &'a [u8],
}
/// Options for updating a board that already runs alkane, in place.
#[derive(Clone, Debug, Default)]
pub struct InPlaceOptions {
/// Read-only: report the board state, the storage map and the write plan,
/// and write nothing.
pub dry_run: bool,
/// Reboot after the images are written and read back, then wait for the
/// board to return as alkane.
pub reboot: bool,
/// Where to keep a copy of each boot slot as it was before the write. When
/// set, every slot is read and saved before any erase; a failed backup
/// aborts the update with nothing written.
pub backup_dir: Option<PathBuf>,
}
/// One boot slot as it was before an in-place update.
#[derive(Clone, Debug)]
pub struct HeldSlot {
pub name: String,
/// Absolute NAND offset of the slot.
pub absolute: u64,
pub size: u64,
pub path: PathBuf,
pub md5: String,
}
#[derive(Clone, Debug)]
pub struct InPlaceReceipt {
pub backups: Vec<HeldSlot>,
pub rebooted: bool,
}
#[derive(Clone, Debug)]
pub enum InPlaceOutcome {
/// The dry-run report; nothing was written.
DryRun(String),
Updated(InPlaceReceipt),
}
/// Result of a live check that a Zynq board is up on alkane: two channels
/// (HTTP page marker, SSH kernel/OS) must agree.
#[derive(Clone, Debug)]
pub struct LiveCheck {
pub attempts: u32,
pub http: String,
pub http_ok: bool,
pub ssh: String,
pub ssh_ok: bool,
/// The running kernel command line (informational: on a NAND boot it is
/// the board's U-Boot env bootargs).
pub cmdline: String,
}
impl LiveCheck {
pub fn ok(&self) -> bool {
self.http_ok && self.ssh_ok
}
pub fn render(&self) -> String {
format!(
"verify-live attempts {}\n http {}: {}\n ssh {}: {}\n cmdline: {}\nresult {}\n",
self.attempts,
if self.http_ok { "PASS" } else { "FAIL" },
self.http,
if self.ssh_ok { "PASS" } else { "FAIL" },
self.ssh,
if self.cmdline.is_empty() {
"(not read)"
} else {
&self.cmdline
},
if self.ok() { "PASS" } else { "FAIL" }
)
}
}
/// The stock-side methods, implemented by `stock_method`. All implementations
/// must be NETWORK-ONLY (no serial-console dependency).
pub trait StockMethod {
/// Put our first image (the `.afw`) onto a board currently on stock, past
/// stock's gates and with root, over the network only. On Ok the board is
/// installed with alkane; the caller verifies liveness.
fn install_from_stock(
&self,
host: &str,
afw_path: &Path,
afw: &VerifiedAfw,
password: Option<&str>,
) -> Result<(), StockError>;
/// Return an aftermarket (alkane) board to genuine stock, over the network
/// only, by writing the given genuine Bitmain stock images (`images`) back to
/// NAND. `password` is the board's alkane root credential. On Ok the board is
/// on stock; the caller verifies.
fn restore_to_stock(
&self,
host: &str,
images: &RestoreImages,
password: Option<&str>,
) -> Result<(), StockError>;
/// Update a board that already runs alkane to the `.afw`'s images, over the
/// network only. Refuses a board that is not running alkane (a board on
/// stock is installed with `install_from_stock`). The boot regions are not
/// exposed to Linux on alkane, so they are re-registered the same way as for
/// a restore; the images are written in the form the board's stock U-Boot
/// boots, each read back before reboot, and BOOT.bin is never written.
fn update_in_place(
&self,
host: &str,
afw: &VerifiedAfw,
password: Option<&str>,
options: &InPlaceOptions,
) -> Result<InPlaceOutcome, StockError>;
}
/// The compiled-in method implementation.
pub fn method() -> &'static dyn StockMethod {
crate::stock_method::method()
}
/// Install alkane onto a board on stock (network-only), via the compiled-in method.
pub fn install_from_stock(
host: &str,
afw_path: &Path,
afw: &VerifiedAfw,
password: Option<&str>,
) -> Result<(), StockError> {
method().install_from_stock(host, afw_path, afw, password)
}
/// Return an alkane board to stock (network-only) by writing the genuine Bitmain
/// stock `images` back to NAND, via the compiled-in method.
pub fn restore_to_stock(
host: &str,
images: &RestoreImages,
password: Option<&str>,
) -> Result<(), StockError> {
method().restore_to_stock(host, images, password)
}
/// Check, over the network, that a Zynq board is up on alkane: the web page
/// carries `marker` (case-insensitive) and SSH reports alkane with a kernel
/// containing `kernel_version` (if non-empty). Retries until `timeout`.
pub fn verify_zynq_live(
host: &str,
password: Option<&str>,
marker: &str,
kernel_version: &str,
timeout: std::time::Duration,
) -> Result<LiveCheck, StockError> {
crate::stock_method::live_check(host, password, marker, kernel_version, timeout)
}
/// Update a board already on alkane to the `.afw`'s images, in place
/// (network-only), via the compiled-in method.
pub fn update_in_place(
host: &str,
afw: &VerifiedAfw,
password: Option<&str>,
options: &InPlaceOptions,
) -> Result<InPlaceOutcome, StockError> {
method().update_in_place(host, afw, password, options)
}
#[cfg(test)]
mod tests {
use super::*;
// The interface is exercised against whatever `stock_method` provides. We
// only assert the toolkit wires a method object in; its behaviour is the
// method module's own tests.
#[test]
fn a_method_is_compiled_in() {
let _m: &dyn StockMethod = method();
}
}
+282
View File
@@ -0,0 +1,282 @@
// SPDX-License-Identifier: MIT
//! Parse a genuine Bitmain Antminer stock firmware package into the flashable
//! stock images, so the toolkit can restore a board to genuine stock using the
//! vendor's own files (no carved blobs).
//!
//! Two genuine source shapes are handled for the Zynq-7010 (Antminer S17):
//!
//! - OTA update `.tar.gz` (`Antminer-S17-user-OM-<date>-sig*.tar.gz`): a signed
//! outer tar holding `cert.pem`, `fw.tar.gz` and `runme.sh` (each with a
//! `.sig`). The inner `fw.tar.gz` holds `BOOT.bin`, `uImage` (legacy kernel),
//! `uramdisk.image.gz` (rootfs) and `md5_info` (md5 of the rootfs). The OTA
//! package does NOT carry the device tree: the factory SD provisioning writes
//! it once and OTA upgrades preserve it.
//! - SD recovery `.zip` (`SD_Antminer-S17-*.zip`): the full factory image,
//! which DOES include `devicetree.dtb` alongside `BOOT.bin`/`uImage`/
//! `uramdisk.image.gz`. This is the complete source for a from-anywhere
//! restore, because it carries the device tree the stock kernel needs.
//!
//! Extraction shells out to the system `tar`/`unzip`/`gzip` (as the release
//! fetch shells out to `curl`); nothing is written outside a private temp dir.
use std::path::Path;
use std::process::Command;
use crate::md5::md5_hex;
#[derive(Debug, thiserror::Error)]
pub enum StockFirmwareError {
#[error("io: {0}")]
Io(String),
#[error("could not read {0}")]
Read(String),
#[error("unrecognised firmware package (not a .tar.gz or .zip): {0}")]
Format(String),
#[error("extraction failed: {0}")]
Extract(String),
#[error("the firmware package is missing a stock {0} image")]
MissingImage(&'static str),
#[error("rootfs md5 mismatch: package lists {expected}, image is {actual}")]
RootfsMd5 { expected: String, actual: String },
#[error("needed system tool not found: {0}")]
MissingTool(String),
}
/// The stock images carved from a genuine Bitmain firmware package, ready to
/// write back to NAND. `boot_bin` and `dtb` are optional (an OTA package omits
/// the dtb; the bootloader is only written on an explicit full restore).
pub struct StockFirmware {
pub boot_bin: Option<Vec<u8>>,
pub dtb: Option<Vec<u8>>,
pub kernel: Vec<u8>,
pub rootfs: Vec<u8>,
pub version: Option<String>,
/// The source package kind, for logging.
pub source_kind: &'static str,
}
impl StockFirmware {
pub fn summary(&self) -> String {
let v = self.version.as_deref().unwrap_or("unknown");
format!(
"{} (version {}): kernel {} B, rootfs {} B, dtb {}, BOOT.bin {}",
self.source_kind,
v,
self.kernel.len(),
self.rootfs.len(),
self.dtb.as_ref().map_or("absent", |_| "present"),
self.boot_bin.as_ref().map_or("absent", |_| "present"),
)
}
}
fn have_tool(tool: &str) -> bool {
Command::new(tool)
.arg("--version")
.output()
.map(|o| o.status.success() || !o.stdout.is_empty() || !o.stderr.is_empty())
.unwrap_or(false)
}
fn run(cmd: &mut Command, what: &str) -> Result<(), StockFirmwareError> {
let out = cmd
.output()
.map_err(|e| StockFirmwareError::Extract(format!("{what}: {e}")))?;
if !out.status.success() {
return Err(StockFirmwareError::Extract(format!(
"{what}: {}",
String::from_utf8_lossy(&out.stderr).trim()
)));
}
Ok(())
}
/// Recursively collect files under `dir` as (relative-path-lowercased, absolute path).
fn collect_files(dir: &Path) -> Vec<(String, std::path::PathBuf)> {
fn walk(base: &Path, dir: &Path, out: &mut Vec<(String, std::path::PathBuf)>) {
let Ok(entries) = std::fs::read_dir(dir) else {
return;
};
for entry in entries.flatten() {
let path = entry.path();
if path.is_dir() {
walk(base, &path, out);
} else if let Ok(rel) = path.strip_prefix(base) {
out.push((rel.to_string_lossy().to_lowercase(), path.clone()));
}
}
}
let mut out = Vec::new();
walk(dir, dir, &mut out);
out
}
/// Pick the best file whose basename matches `name`, preferring paths that
/// contain one of `prefer` path fragments (e.g. "bin/" for the SD image, "fw"
/// for the OTA inner tree), then the shallowest path.
fn pick<'a>(
files: &'a [(String, std::path::PathBuf)],
name: &str,
prefer: &[&str],
) -> Option<&'a std::path::PathBuf> {
let name = name.to_lowercase();
let mut matches: Vec<&(String, std::path::PathBuf)> = files
.iter()
.filter(|(rel, _)| rel.rsplit('/').next() == Some(name.as_str()) || *rel == name)
.collect();
if matches.is_empty() {
return None;
}
matches.sort_by_key(|(rel, _)| {
let pref_rank = prefer
.iter()
.position(|p| rel.contains(p))
.unwrap_or(prefer.len());
let depth = rel.matches('/').count();
(pref_rank, depth)
});
matches.first().map(|(_, p)| p)
}
fn read(path: &Path) -> Result<Vec<u8>, StockFirmwareError> {
std::fs::read(path).map_err(|_| StockFirmwareError::Read(path.display().to_string()))
}
/// Parse a genuine Bitmain stock firmware package (OTA `.tar.gz` or SD `.zip`)
/// into its stock images.
pub fn parse(path: &Path) -> Result<StockFirmware, StockFirmwareError> {
let bytes = std::fs::read(path)
.map_err(|e| StockFirmwareError::Io(format!("{}: {e}", path.display())))?;
if bytes.len() < 4 {
return Err(StockFirmwareError::Format(path.display().to_string()));
}
let is_gzip = bytes[0] == 0x1f && bytes[1] == 0x8b;
let is_zip = &bytes[0..2] == b"PK";
if !is_gzip && !is_zip {
return Err(StockFirmwareError::Format(path.display().to_string()));
}
let tmp = tempfile::Builder::new()
.prefix("alkane-stockfw-")
.tempdir()
.map_err(|e| StockFirmwareError::Io(e.to_string()))?;
let root = tmp.path();
let (source_kind, prefer): (&'static str, &[&str]) = if is_zip {
if !have_tool("unzip") {
return Err(StockFirmwareError::MissingTool("unzip".into()));
}
run(
Command::new("unzip")
.arg("-qq")
.arg("-o")
.arg(path)
.arg("-d")
.arg(root),
"unzip SD recovery image",
)?;
("Bitmain SD recovery image", &["bin/"])
} else {
if !have_tool("tar") {
return Err(StockFirmwareError::MissingTool("tar".into()));
}
run(
Command::new("tar").arg("xzf").arg(path).arg("-C").arg(root),
"untar OTA package",
)?;
// The signed OTA wraps the real images in an inner fw.tar.gz; extract it.
let inner = collect_files(root)
.into_iter()
.find(|(rel, _)| rel.rsplit('/').next() == Some("fw.tar.gz"));
if let Some((_, inner_path)) = inner {
let inner_dir = root.join("fw");
std::fs::create_dir_all(&inner_dir)
.map_err(|e| StockFirmwareError::Io(e.to_string()))?;
run(
Command::new("tar")
.arg("xzf")
.arg(&inner_path)
.arg("-C")
.arg(&inner_dir),
"untar OTA inner fw.tar.gz",
)?;
}
("Bitmain OTA update package", &["fw/", "bin/"])
};
let files = collect_files(root);
let kernel_path = pick(&files, "uImage", prefer)
.ok_or(StockFirmwareError::MissingImage("uImage (kernel)"))?;
let rootfs_path = pick(&files, "uramdisk.image.gz", prefer).ok_or(
StockFirmwareError::MissingImage("uramdisk.image.gz (rootfs)"),
)?;
let kernel = read(kernel_path)?;
let rootfs = read(rootfs_path)?;
let boot_bin = pick(&files, "BOOT.bin", prefer)
.map(|p| read(p))
.transpose()?;
let dtb = pick(&files, "devicetree.dtb", &["", "bin/"])
.map(|p| read(p))
.transpose()?;
// Verify the rootfs against md5_info when the package ships one (OTA does).
if let Some(md5_path) = pick(&files, "md5_info", prefer) {
if let Ok(raw) = std::fs::read_to_string(md5_path) {
let expected = raw.split_whitespace().next().unwrap_or("").to_lowercase();
if expected.len() == 32 {
let actual = md5_hex(&rootfs);
if actual != expected {
return Err(StockFirmwareError::RootfsMd5 { expected, actual });
}
}
}
}
let version = pick(&files, "version", prefer)
.or_else(|| pick(&files, "version_number", &[""]))
.and_then(|p| std::fs::read_to_string(p).ok())
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty());
Ok(StockFirmware {
boot_bin,
dtb,
kernel,
rootfs,
version,
source_kind,
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rejects_non_archive() {
let tmp = tempfile::NamedTempFile::new().unwrap();
std::fs::write(tmp.path(), b"not an archive").unwrap();
assert!(matches!(
parse(tmp.path()),
Err(StockFirmwareError::Format(_))
));
}
// Parse a real Bitmain firmware package. Set ALKANE_TEST_STOCK_FW to its path.
// Ignored by default (needs the vendor file, not in the repo).
#[test]
#[ignore]
fn parses_real_package() {
let Ok(path) = std::env::var("ALKANE_TEST_STOCK_FW") else {
eprintln!("set ALKANE_TEST_STOCK_FW to a firmware file");
return;
};
let fw = parse(Path::new(&path)).expect("parse");
eprintln!("{}", fw.summary());
assert!(!fw.kernel.is_empty(), "kernel present");
assert!(!fw.rootfs.is_empty(), "rootfs present");
// The kernel is a legacy u-boot uImage: magic 0x27051956 big-endian.
assert_eq!(&fw.kernel[0..4], &[0x27, 0x05, 0x19, 0x56], "uImage magic");
}
}
File diff suppressed because it is too large Load Diff
+699
View File
@@ -0,0 +1,699 @@
// SPDX-License-Identifier: MIT
//! Network transport for the CV1835 installer.
//!
//! Two root channels are implemented, both over the network:
//!
//! * `direct`: the SSH login is already uid 0 (Braiins OS, ourOS/alkane with a
//! root key, or an operator-supplied root login).
//! * `update-daemon`: stock Bitmain (and Vnish, which runs on the stock
//! kernel) exposes an SSH login as `miner` (uid 1001). `/usr/sbin/update-daemon`
//! listens on 127.0.0.1:12887 and pipes its socket into `system()` as root.
//! We reach it through an SSH local forward, exactly as documented in the RE
//! notes (`cv-kvm-host` / `cvbuild/cvroot.py`,
//! `alkane-sdk-wiki/40-boot-os-and-build/cross-install-matrix.md`). The
//! channel is blind, so root output is redirected to a world-readable file
//! and read back over the unprivileged SSH session.
//! * `rroot`: an existing `/nvdata/rroot` setuid helper on CV stock/Vnish,
//! documented in `60-reverse-engineering-methods/rroot-setuid-escalation.md`.
//! It is a fallback because the helper is not durable across a p7 reformat.
//!
//! Credentials are never read here: a password is used only through
//! `sshpass -f <path>`, and that path comes from the operator (environment
//! variable materialized by the CLI, or a file named on the command line).
use std::fs;
use std::io::{Read, Write};
use std::net::{SocketAddr, TcpStream};
use std::path::{Path, PathBuf};
use std::process::{Child, Command, ExitStatus, Stdio};
use std::thread;
use std::time::{Duration, Instant};
use thiserror::Error;
const MAX_CAPTURE: usize = 64 * 1024 * 1024;
#[derive(Debug, Error)]
pub enum RemoteError {
#[error("remote I/O: {0}")]
Io(#[from] std::io::Error),
#[error("cannot start {0}")]
MissingTool(&'static str),
#[error("invalid target: {0}")]
InvalidTarget(String),
#[error("SSH transport: {0}")]
Ssh(String),
#[error("SSH command timed out after {0:?}")]
Timeout(Duration),
#[error("remote command failed ({status}): {stderr}")]
Command { status: String, stderr: String },
#[error("root access was not obtained: {0}")]
NotRoot(String),
#[error("no network root channel is available on this board")]
NoRootMethod,
#[error("update-daemon: {0}")]
Daemon(String),
#[error("remote output is over the {0}-byte cap")]
OutputTooLarge(usize),
}
impl RemoteError {
fn sanitize(text: &str) -> String {
let text = text.trim();
let mut shortened: String = text.chars().take(300).collect();
if shortened.len() < text.len() {
shortened.push_str("...");
}
shortened
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum RootMethod {
Auto,
Direct,
UpdateDaemon,
Rroot,
}
impl RootMethod {
pub fn parse(value: &str) -> Option<Self> {
match value {
"auto" => Some(Self::Auto),
"direct" => Some(Self::Direct),
"update-daemon" => Some(Self::UpdateDaemon),
"rroot" => Some(Self::Rroot),
_ => None,
}
}
}
#[derive(Clone, Debug)]
pub struct SshOptions {
pub host: String,
pub port: u16,
pub user: String,
pub identity_file: Option<PathBuf>,
pub password_file: Option<PathBuf>,
pub known_hosts: Option<PathBuf>,
pub root_method: RootMethod,
pub update_daemon_port: Option<u16>,
}
impl Default for SshOptions {
fn default() -> Self {
Self {
host: String::new(),
port: 22,
user: "miner".to_owned(),
identity_file: None,
password_file: None,
known_hosts: None,
root_method: RootMethod::Auto,
update_daemon_port: None,
}
}
}
impl SshOptions {
fn validate(&self) -> Result<(), RemoteError> {
if self.host.is_empty()
|| self.host.len() > 253
|| self.host.starts_with('-')
|| !self.host.bytes().all(|byte| {
byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'-' | b':' | b'_')
})
{
return Err(RemoteError::InvalidTarget("host".to_owned()));
}
if self.user.is_empty()
|| !self
.user
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'-' | b'.'))
{
return Err(RemoteError::InvalidTarget("user".to_owned()));
}
if self.port == 0 {
return Err(RemoteError::InvalidTarget("port".to_owned()));
}
if let Some(path) = &self.password_file {
if !path.is_file() {
return Err(RemoteError::InvalidTarget(format!(
"password file not found: {}",
path.display()
)));
}
}
Ok(())
}
}
enum Strategy {
Direct,
Rroot,
UpdateDaemon {
local_port: u16,
remote_port: u16,
tunnel: Child,
},
}
impl Drop for Strategy {
fn drop(&mut self) {
if let Self::UpdateDaemon { tunnel, .. } = self {
let _ = tunnel.kill();
let _ = tunnel.wait();
}
}
}
pub struct SshTransport {
options: SshOptions,
known_hosts: PathBuf,
strategy: Strategy,
counter: u64,
}
impl SshTransport {
/// Open a session and (when `require_root`) prove a uid-0 channel.
pub fn connect(options: SshOptions, require_root: bool) -> Result<Self, RemoteError> {
options.validate()?;
let known_hosts = options
.known_hosts
.clone()
.unwrap_or_else(|| alkane_core::platform::config_path("known_hosts"));
if let Some(parent) = known_hosts.parent() {
fs::create_dir_all(parent)?;
}
if !known_hosts.exists() {
fs::write(&known_hosts, b"")?;
}
if options.password_file.is_some() {
Command::new("sshpass")
.arg("-V")
.stdout(Stdio::null())
.stderr(Stdio::null())
.status()
.map_err(|_| RemoteError::MissingTool("sshpass"))?;
}
let mut transport = Self {
options,
known_hosts,
strategy: Strategy::Direct,
counter: 0,
};
let identity = transport.user_command("uname -r", Duration::from_secs(15))?;
let _ = identity;
if !require_root {
return Ok(transport);
}
let uid =
String::from_utf8_lossy(&transport.user_command("id -u", Duration::from_secs(15))?)
.trim()
.to_owned();
let direct = uid == "0";
let method = match transport.options.root_method {
RootMethod::Auto if direct => RootMethod::Direct,
RootMethod::Auto => {
if transport.has_update_daemon()? {
RootMethod::UpdateDaemon
} else if transport.has_rroot()? {
RootMethod::Rroot
} else {
return Err(RemoteError::NoRootMethod);
}
}
other => other,
};
match method {
RootMethod::Direct => {
if !direct {
return Err(RemoteError::NotRoot(
"the SSH login is not uid 0; use --root-method auto, update-daemon or rroot"
.to_owned(),
));
}
transport.strategy = Strategy::Direct;
}
RootMethod::Rroot => {
if !transport.has_rroot()? {
return Err(RemoteError::NotRoot(
"/nvdata/rroot is not present or not executable".to_owned(),
));
}
transport.strategy = Strategy::Rroot;
}
RootMethod::UpdateDaemon => {
if !transport.has_update_daemon()? {
return Err(RemoteError::NotRoot(
"/usr/sbin/update-daemon is not present".to_owned(),
));
}
let remote_port = transport
.options
.update_daemon_port
.unwrap_or(transport.detect_update_daemon_port()?);
let (local_port, tunnel) = transport.start_tunnel(remote_port)?;
transport.strategy = Strategy::UpdateDaemon {
local_port,
remote_port,
tunnel,
};
}
RootMethod::Auto => unreachable!(),
}
let root_output = transport.root_command("id", Duration::from_secs(20))?;
let root = String::from_utf8_lossy(&root_output);
if !root.contains("uid=0") {
return Err(RemoteError::NotRoot(
"the selected channel did not return uid=0".to_owned(),
));
}
Ok(transport)
}
pub fn channel(&self) -> String {
format!("ssh:{}@{}", self.options.user, self.options.host)
}
pub fn root_method(&self) -> &'static str {
match &self.strategy {
Strategy::Direct => "direct",
Strategy::Rroot => "rroot",
Strategy::UpdateDaemon { .. } => "update-daemon",
}
}
pub fn update_daemon_port(&self) -> Option<u16> {
match &self.strategy {
Strategy::UpdateDaemon { remote_port, .. } => Some(*remote_port),
_ => None,
}
}
fn ssh_base(&self) -> Command {
let mut command = if let Some(password) = &self.options.password_file {
let mut command = Command::new("sshpass");
command.arg("-f").arg(password).arg("ssh");
command
} else {
Command::new("ssh")
};
command
.arg("-F")
.arg("none")
.arg("-o")
.arg(if self.options.password_file.is_some() {
"BatchMode=no"
} else {
"BatchMode=yes"
})
.arg("-o")
.arg("StrictHostKeyChecking=accept-new")
.arg("-o")
.arg(format!("UserKnownHostsFile={}", self.known_hosts.display()))
.arg("-o")
.arg("GlobalKnownHostsFile=/dev/null")
.arg("-o")
.arg("ConnectTimeout=10")
.arg("-o")
.arg("ServerAliveInterval=5")
.arg("-o")
.arg("ServerAliveCountMax=3")
.arg("-o")
.arg("RequestTTY=no")
.arg("-o")
.arg("LogLevel=ERROR")
.arg("-o")
.arg("NumberOfPasswordPrompts=1")
.arg("-o")
.arg("PreferredAuthentications=publickey,password,keyboard-interactive");
if let Some(identity) = &self.options.identity_file {
command
.arg("-i")
.arg(identity)
.arg("-o")
.arg("IdentitiesOnly=yes");
}
command
}
fn ssh_command(&self, command: &str) -> Command {
let mut child = self.ssh_base();
child
.arg("-p")
.arg(self.options.port.to_string())
.arg(format!("{}@{}", self.options.user, self.options.host))
.arg(command);
child
}
fn run_user(&self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError> {
let (stdout, stderr, status) = run_bounded(self.ssh_command(command), timeout)?;
if !status.success() {
return Err(RemoteError::Command {
status: status.to_string(),
stderr: RemoteError::sanitize(&String::from_utf8_lossy(&stderr)),
});
}
Ok(stdout)
}
fn has_rroot(&self) -> Result<bool, RemoteError> {
let out = self.run_user(
"test -x /nvdata/rroot && echo yes || echo no",
Duration::from_secs(15),
)?;
Ok(String::from_utf8_lossy(&out).contains("yes"))
}
fn has_update_daemon(&self) -> Result<bool, RemoteError> {
let out = self.run_user(
"test -x /usr/sbin/update-daemon && echo yes || echo no",
Duration::from_secs(15),
)?;
Ok(String::from_utf8_lossy(&out).contains("yes"))
}
fn detect_update_daemon_port(&self) -> Result<u16, RemoteError> {
let out = self.run_user(
"cat /proc/net/tcp /proc/net/tcp6 2>/dev/null || true",
Duration::from_secs(15),
)?;
let text = String::from_utf8_lossy(&out);
for line in text.lines() {
let fields: Vec<&str> = line.split_whitespace().collect();
if fields.len() < 4 || fields[3] != "0A" {
continue;
}
let local = fields[1];
let port = local.rsplit(':').next().unwrap_or("");
let port = u16::from_str_radix(port, 16).unwrap_or(0);
if port == 12887 || port == 22026 {
return Ok(port);
}
}
// The CV1835 stock build listens on 12887. The fallback keeps the
// explicit --update-daemon-port option available for other builds.
Ok(12887)
}
fn start_tunnel(&self, remote_port: u16) -> Result<(u16, Child), RemoteError> {
let listener = std::net::TcpListener::bind(("127.0.0.1", 0))?;
let local_port = listener.local_addr()?.port();
drop(listener);
let mut command = self.ssh_base();
command
.arg("-N")
.arg("-o")
.arg("ExitOnForwardFailure=yes")
.arg("-L")
.arg(format!("127.0.0.1:{local_port}:127.0.0.1:{remote_port}"))
.arg("-p")
.arg(self.options.port.to_string())
.arg(format!("{}@{}", self.options.user, self.options.host))
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null());
let mut tunnel = command.spawn()?;
let deadline = Instant::now() + Duration::from_secs(20);
loop {
if TcpStream::connect_timeout(
&SocketAddr::from(([127, 0, 0, 1], local_port)),
Duration::from_millis(500),
)
.is_ok()
{
return Ok((local_port, tunnel));
}
if let Some(status) = tunnel.try_wait()? {
return Err(RemoteError::Daemon(format!(
"SSH forward exited before it was ready ({status})"
)));
}
if Instant::now() >= deadline {
let _ = tunnel.kill();
return Err(RemoteError::Daemon(
"SSH forward did not become ready".to_owned(),
));
}
thread::sleep(Duration::from_millis(250));
}
}
fn daemon_send(&self, command: &str) -> Result<(), RemoteError> {
let Strategy::UpdateDaemon { local_port, .. } = &self.strategy else {
return Err(RemoteError::Daemon("not using update-daemon".to_owned()));
};
let local_port = *local_port;
if command.contains('\n') || command.contains('\r') {
return Err(RemoteError::Daemon("command contains a newline".to_owned()));
}
let mut stream = TcpStream::connect_timeout(
&SocketAddr::from(([127, 0, 0, 1], local_port)),
Duration::from_secs(10),
)?;
stream.set_write_timeout(Some(Duration::from_secs(10)))?;
stream.write_all(format!(";{command};").as_bytes())?;
stream.flush()?;
let _ = stream.set_read_timeout(Some(Duration::from_millis(500)));
let mut sink = [0_u8; 256];
let _ = stream.read(&mut sink);
Ok(())
}
fn daemon_capture(&mut self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError> {
let path = format!("/tmp/.alkane-root-{}-{}", std::process::id(), self.counter);
self.counter += 1;
let wrapped = format!("{{ {command} ; }} > {path} 2>&1; chmod 644 {path}");
self.daemon_send(&wrapped)?;
let deadline = Instant::now() + timeout;
loop {
let probe = format!("test -f {path} && echo ready || true");
let out = self.run_user(&probe, Duration::from_secs(15))?;
if String::from_utf8_lossy(&out).contains("ready") {
break;
}
if Instant::now() >= deadline {
return Err(RemoteError::Daemon(format!(
"root command produced no output file within {timeout:?}"
)));
}
thread::sleep(Duration::from_millis(200));
}
let output = self.run_user(&format!("cat {path}"), Duration::from_secs(60))?;
let _ = self.run_user(&format!("rm -f {path}"), Duration::from_secs(15));
Ok(output)
}
fn daemon_reboot(&mut self) -> Result<(), RemoteError> {
self.daemon_send("sync; echo b > /proc/sysrq-trigger")
}
}
impl Remote for SshTransport {
fn channel(&self) -> &str {
"ssh"
}
fn root_method(&self) -> &'static str {
SshTransport::root_method(self)
}
fn user_command(&mut self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError> {
self.run_user(command, timeout)
}
fn root_command(&mut self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError> {
match self.root_method() {
"direct" => self.run_user(command, timeout),
"rroot" => {
let wrapped = format!("/nvdata/rroot -c {}", shell_quote(command));
self.run_user(&wrapped, timeout)
}
"update-daemon" => self.daemon_capture(command, timeout),
_ => Err(RemoteError::NoRootMethod),
}
}
fn push(&mut self, local: &Path, remote: &str, timeout: Duration) -> Result<(), RemoteError> {
let remote = safe_remote_path(remote)?;
let mut command = self.ssh_command(&format!("cat > {remote}"));
command
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
let mut child = command.spawn()?;
let mut stdin = child.stdin.take().expect("piped stdin");
let path = local.to_path_buf();
let writer = thread::spawn(move || -> std::io::Result<()> {
let mut source = fs::File::open(path)?;
let mut buffer = [0_u8; 64 * 1024];
loop {
let read = source.read(&mut buffer)?;
if read == 0 {
break;
}
stdin.write_all(&buffer[..read])?;
}
stdin.flush()
});
let (stdout, stderr) = read_pipes(&mut child);
let status = wait_timeout(&mut child, timeout)?;
let _ = writer.join();
let _ = stdout.join();
let stderr = stderr.join().unwrap_or_default();
if !status.success() {
return Err(RemoteError::Command {
status: status.to_string(),
stderr: RemoteError::sanitize(&String::from_utf8_lossy(&stderr)),
});
}
Ok(())
}
fn pull(&mut self, remote: &str, local: &Path, timeout: Duration) -> Result<(), RemoteError> {
let remote = safe_remote_path(remote)?;
let data = self.run_user(&format!("cat {remote}"), timeout)?;
if data.len() > MAX_CAPTURE {
return Err(RemoteError::OutputTooLarge(MAX_CAPTURE));
}
fs::write(local, data)?;
Ok(())
}
fn reboot(&mut self) -> Result<(), RemoteError> {
match self.root_method() {
"update-daemon" => self.daemon_reboot(),
_ => {
// A successful sysrq reset drops the SSH connection mid-command.
let _ = self.run_user(
"sync; echo b > /proc/sysrq-trigger",
Duration::from_secs(15),
);
Ok(())
}
}
}
}
pub trait Remote {
fn channel(&self) -> &str;
fn root_method(&self) -> &'static str {
"network"
}
fn user_command(&mut self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError>;
fn root_command(&mut self, command: &str, timeout: Duration) -> Result<Vec<u8>, RemoteError>;
fn push(&mut self, local: &Path, remote: &str, timeout: Duration) -> Result<(), RemoteError>;
fn pull(&mut self, remote: &str, local: &Path, timeout: Duration) -> Result<(), RemoteError>;
fn reboot(&mut self) -> Result<(), RemoteError>;
}
pub fn shell_quote(text: &str) -> String {
format!("'{}'", text.replace('\'', "'\\''"))
}
pub fn safe_remote_path(path: &str) -> Result<&str, RemoteError> {
if !path.starts_with('/')
|| path.len() > 200
|| path.contains("..")
|| !path
.bytes()
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'/' | b'.' | b'_' | b'-'))
{
return Err(RemoteError::InvalidTarget(format!(
"unsafe remote path: {path}"
)));
}
Ok(path)
}
fn read_pipes(child: &mut Child) -> (thread::JoinHandle<Vec<u8>>, thread::JoinHandle<Vec<u8>>) {
let mut stdout = child.stdout.take().expect("piped stdout");
let mut stderr = child.stderr.take().expect("piped stderr");
let out = thread::spawn(move || {
let mut data = Vec::new();
let _ = stdout.read_to_end(&mut data);
data
});
let err = thread::spawn(move || {
let mut data = Vec::new();
let _ = stderr.read_to_end(&mut data);
data
});
(out, err)
}
fn wait_timeout(child: &mut Child, timeout: Duration) -> Result<ExitStatus, RemoteError> {
let deadline = Instant::now() + timeout;
loop {
if let Some(status) = child.try_wait()? {
return Ok(status);
}
if Instant::now() >= deadline {
let _ = child.kill();
let _ = child.wait();
return Err(RemoteError::Timeout(timeout));
}
thread::sleep(Duration::from_millis(20));
}
}
fn run_bounded(
mut command: Command,
timeout: Duration,
) -> Result<(Vec<u8>, Vec<u8>, ExitStatus), RemoteError> {
command
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
let mut child = command.spawn()?;
let (stdout, stderr) = read_pipes(&mut child);
let status = wait_timeout(&mut child, timeout)?;
let stdout = stdout.join().unwrap_or_default();
let stderr = stderr.join().unwrap_or_default();
if stdout.len() > MAX_CAPTURE {
return Err(RemoteError::OutputTooLarge(MAX_CAPTURE));
}
Ok((stdout, stderr, status))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn quotes_shell_arguments_for_rroot() {
assert_eq!(shell_quote("id"), "'id'");
assert_eq!(shell_quote("echo 'x'"), "'echo '\\''x'\\'''");
}
#[test]
fn rejects_option_injection_and_unsafe_paths() {
let mut options = SshOptions {
host: "-oProxyCommand=bad".to_owned(),
user: "root".to_owned(),
..SshOptions::default()
};
assert!(options.validate().is_err());
options.host = "10.255.1.167".to_owned();
options.user = "root;id".to_owned();
assert!(options.validate().is_err());
assert!(safe_remote_path("/tmp/ok.img").is_ok());
assert!(safe_remote_path("relative").is_err());
assert!(safe_remote_path("/tmp/../etc/passwd").is_err());
assert!(safe_remote_path("/tmp/a;b").is_err());
}
#[test]
fn parses_root_methods() {
assert_eq!(RootMethod::parse("auto"), Some(RootMethod::Auto));
assert_eq!(
RootMethod::parse("update-daemon"),
Some(RootMethod::UpdateDaemon)
);
assert_eq!(RootMethod::parse("serial"), None);
}
}
+13
View File
@@ -11,6 +11,11 @@ path = "src/main.rs"
[dependencies]
alkane-core = { path = "../alkane-core" }
alkane-discovery = { path = "../alkane-discovery" }
# The self-contained stock <-> alkane engine (compiled-in method) and the .afw
# verify/fetch, so the GUI can install-from-stock and restore-to-stock and scan
# alkane-os releases through the same code paths the CLI uses.
alkane-flash = { path = "../alkane-flash" }
alkane-artifacts = { path = "../alkane-artifacts" }
# vendored + patched wx-rs (see vendor/wx-rs/patches/)
wx-rs = { path = "../../thirdparty/wx-rs/wx-rs-0.2.0-patched" }
asic-rs = "0.8.1"
@@ -19,3 +24,11 @@ tokio = { version = "1", features = ["rt"] }
futures-util = "0.3"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
# WhatsMiner :4028 token-auth access check (round 12 #8b) -- same crates the
# vendored asic-rs whatsminer backend uses, so no new versions enter the lock.
md5crypt = "1"
sha2 = "0.10"
aes = "0.8"
ecb = "0.1"
base64 = "0.21"
hex = "0.4"
@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--!Font Awesome Free 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--><path d="M434.8 54.1C446.7 62.7 451.1 78.3 445.7 91.9L367.3 288L512 288C525.5 288 537.5 296.4 542.1 309.1C546.7 321.8 542.8 336 532.5 344.6L244.5 584.6C233.2 594 217.1 594.5 205.2 585.9C193.3 577.3 188.9 561.7 194.3 548.1L272.7 352L128 352C114.5 352 102.5 343.6 97.9 330.9C93.3 318.2 97.2 304 107.5 295.4L395.5 55.4C406.8 46 422.9 45.5 434.8 54.1z"/></svg>

After

Width:  |  Height:  |  Size: 569 B

+1
View File
@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 384 512"><path fill="currentColor" d="M240 8L48 296h112L128 504 336 216H224L272 8z"/></svg>

After

Width:  |  Height:  |  Size: 145 B

@@ -0,0 +1,29 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><g transform="translate(0.000000,512.000000) scale(0.100000,-0.100000)" >
<path d="M2152 4645 c-35 -8 -95 -28 -133 -46 l-70 -32 39 -41 c109 -115 121
-180 41 -222 -48 -24 -74 -11 -168 85 -225 229 -555 240 -774 25 l-59 -57 57
-22 c103 -38 134 -107 76 -166 -36 -36 -54 -36 -145 -3 -290 107 -608 -44
-712 -339 -13 -36 -13 -39 4 -32 147 57 237 37 237 -54 0 -56 -26 -78 -115
-101 -479 -123 -584 -723 -175 -995 92 -62 102 -71 105 -100 4 -40 -1 -56 -25
-80 -34 -35 -81 -33 -146 5 -28 17 -53 29 -55 27 -2 -2 14 -38 35 -80 114
-227 341 -383 586 -404 l70 -5 1 103 c4 397 280 752 674 870 70 21 101 23 447
28 l373 6 25 26 c19 18 28 42 35 85 15 107 57 173 141 219 54 30 55 30 234 33
108 2 191 -1 207 -7 60 -23 72 -111 21 -151 -23 -18 -41 -20 -185 -20 -200 0
-238 -16 -238 -98 0 -66 -30 -134 -84 -188 -82 -81 -98 -84 -482 -84 -348 0
-405 -6 -526 -55 -355 -144 -547 -560 -421 -912 156 -434 650 -621 1049 -398
60 34 224 176 224 195 0 4 -17 19 -38 33 -109 72 -138 132 -92 190 43 54 75
48 192 -36 291 -208 673 -260 1012 -136 205 74 390 218 518 399 71 102 72 106
48 140 -37 52 -90 177 -90 213 0 68 62 109 126 82 25 -10 36 -26 58 -81 153
-385 618 -488 905 -201 197 197 213 494 39 725 -38 52 -148 142 -172 142 -6 0
-20 -33 -30 -72 -33 -128 -107 -172 -175 -104 -31 32 -31 62 3 171 114 371
-43 798 -372 1015 -71 47 -198 108 -206 99 -3 -2 13 -40 35 -84 46 -92 43
-132 -12 -160 -64 -34 -95 -17 -149 81 -251 454 -793 618 -1249 378 -99 -52
-140 -57 -176 -18 -43 46 -30 109 28 144 l31 19 -39 17 c-102 42 -247 54 -363
29z"/>
<path d="M4064 2007 c-184 -270 -531 -485 -854 -529 -49 -7 -90 -16 -90 -20 0
-19 163 -171 228 -213 494 -318 1255 -101 1387 395 15 55 18 199 6 254 l-6 30
-155 1 c-119 1 -168 6 -210 19 -67 22 -184 79 -226 111 l-31 24 -49 -72z"/>
<path d="M2431 1509 c-51 -58 -53 -62 -47 -103 13 -83 97 -179 179 -205 18 -5
62 -12 98 -16 138 -13 125 -2 531 -464 231 -265 244 -275 305 -259 63 17 68
37 68 276 l0 214 -80 27 c-237 80 -440 241 -552 441 -23 41 -33 50 -56 50 -49
0 -179 30 -284 66 -55 19 -103 34 -105 34 -2 0 -28 -27 -57 -61z"/>
</g></svg>

After

Width:  |  Height:  |  Size: 2.0 KiB

@@ -0,0 +1,38 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><g transform="translate(0.000000,512.000000) scale(0.100000,-0.100000)" >
<path d="M1970 5109 c-158 -18 -233 -52 -290 -130 -63 -88 -40 -168 95 -329
290 -345 492 -728 595 -1130 7 -25 34 -86 61 -136 l49 -91 108 -6 c76 -3 130
-12 187 -31 44 -14 83 -22 87 -18 13 13 87 322 112 470 126 749 -33 1218 -462
1362 -134 45 -353 60 -542 39z"/>
<path d="M3615 4886 c-82 -30 -119 -107 -130 -271 -29 -409 -151 -830 -337
-1160 -41 -74 -72 -146 -94 -220 l-33 -110 34 -27 c45 -38 120 -139 157 -213
17 -33 32 -61 33 -63 10 -11 325 187 480 303 704 524 836 1036 386 1499 -221
228 -372 307 -496 262z"/>
<path d="M975 4370 c-226 -36 -431 -174 -638 -430 -97 -120 -131 -220 -107
-310 24 -90 105 -132 280 -145 435 -32 872 -164 1211 -366 30 -17 103 -47 163
-64 l108 -33 29 33 c42 48 130 113 209 154 l70 37 -56 99 c-246 438 -574 799
-857 943 -131 67 -298 101 -412 82z"/>
<path d="M4795 3451 c-23 -10 -86 -56 -140 -103 -326 -277 -690 -475 -1066
-579 -76 -21 -144 -48 -205 -82 l-91 -51 -6 -105 c-3 -75 -13 -130 -31 -186
-14 -44 -22 -83 -18 -87 10 -10 261 -74 382 -97 794 -154 1301 2 1450 447 74
222 63 625 -20 756 -63 99 -158 131 -255 87z"/>
<path d="M2443 3095 c-206 -45 -374 -215 -418 -422 -82 -385 263 -730 648
-648 209 44 378 213 423 424 81 385 -268 730 -653 646z m152 -179 c59 -25 75
-97 31 -141 -24 -24 -35 -28 -111 -40 -54 -9 -121 -76 -130 -130 -12 -76 -16
-87 -40 -111 -26 -26 -72 -32 -107 -13 -49 26 -54 133 -10 232 45 101 163 191
274 207 29 4 54 8 56 9 1 0 18 -5 37 -13z"/>
<path d="M767 3009 c-562 -63 -820 -407 -758 -1013 20 -185 49 -255 133 -316
87 -64 167 -40 333 100 329 276 698 475 1070 575 65 18 132 45 192 79 l93 51
0 73 c0 79 21 199 46 258 20 47 20 47 -116 83 -359 95 -742 138 -993 110z"/>
<path d="M1770 2244 c-141 -81 -339 -216 -449 -304 -716 -578 -764 -1101 -146
-1599 106 -85 171 -115 255 -115 139 -2 184 64 206 302 43 463 178 899 372
1206 14 23 40 90 58 151 l33 109 -40 34 c-48 41 -117 137 -155 215 -16 31 -31
57 -34 56 -3 0 -48 -25 -100 -55z"/>
<path d="M3098 2066 c-35 -44 -138 -121 -213 -158 -33 -17 -61 -32 -63 -33
-12 -10 203 -350 312 -494 527 -695 1026 -820 1490 -372 193 187 268 305 270
421 1 129 -67 183 -251 201 -210 20 -292 32 -408 55 -297 62 -591 172 -836
314 -36 21 -106 50 -155 64 -50 14 -97 28 -105 31 -8 3 -25 -9 -41 -29z"/>
<path d="M2256 1882 c-25 -41 -108 -428 -131 -612 -18 -143 -21 -439 -5 -550
74 -535 419 -776 1015 -710 174 19 246 50 305 131 63 87 39 170 -92 324 -277
326 -474 689 -579 1066 -21 74 -49 146 -82 207 l-51 92 -73 0 c-79 0 -200 21
-257 45 -41 17 -43 18 -50 7z"/>
</g></svg>

After

Width:  |  Height:  |  Size: 2.5 KiB

+1
View File
@@ -0,0 +1 @@
<svg version="1.0" xmlns="http://www.w3.org/2000/svg" width="511.104248pt" height="512.144915pt" viewBox="0 0 511.104248 512.144915" preserveAspectRatio="xMidYMid meet"><g transform="translate(-0.500000,511.997478) scale(0.100000,-0.100000)" fill="currentColor" stroke="none"><path d="M82 5103 c-52 -25 -77 -69 -77 -133 0 -41 6 -63 22 -86 49 -68 -31 -64 1237 -64 l1146 0 0 -150 0 -150 -323 0 c-292 0 -332 -2 -403 -20 -201 -52 -370 -228 -414 -432 -8 -34 -11 -94 -8 -155 5 -90 12 -119 52 -214 6 -14 -9 -17 -121 -22 -142 -7 -205 -22 -304 -73 -123 -65 -229 -192 -272 -329 -33 -106 -30 -264 7 -360 15 -38 30 -77 32 -85 4 -12 -9 -20 -49 -33 -76 -24 -163 -83 -228 -156 -160 -176 -193 -424 -86 -638 61 -123 195 -242 315 -280 40 -13 52 -21 48 -33 -2 -8 -17 -46 -32 -85 -38 -95 -41 -253 -7 -360 56 -178 206 -323 393 -380 32 -9 108 -19 182 -22 l126 -6 -25 -66 c-31 -81 -42 -233 -23 -319 45 -210 221 -387 433 -437 94 -22 1622 -22 1716 0 108 26 188 71 272 155 126 125 176 255 167 437 -5 90 -12 119 -52 214 -6 14 9 17 122 22 147 6 246 33 337 92 110 70 199 186 238 310 33 106 30 264 -7 360 -15 39 -30 77 -32 85 -4 12 9 20 49 33 211 67 377 303 377 537 0 233 -167 470 -378 537 -40 13 -52 21 -48 33 2 8 17 47 32 85 37 96 40 254 7 360 -39 122 -130 241 -240 311 -89 58 -188 85 -335 91 -113 5 -128 8 -122 22 40 95 47 124 52 214 6 119 -7 184 -55 287 -46 97 -157 210 -254 257 -117 58 -159 63 -516 63 l-323 0 0 150 0 150 618 0 617 0 210 -211 c116 -116 227 -219 247 -230 122 -63 256 59 207 187 -5 16 -60 79 -121 141 l-112 113 313 0 c346 0 360 2 404 64 31 43 31 129 0 172 -50 70 173 64 -2535 64 -2230 0 -2446 -2 -2476 -17z m3337 -918 c94 -52 141 -134 141 -244 -1 -102 -60 -192 -155 -237 l-50 -24 -795 0 -795 0 -50 24 c-61 28 -116 87 -140 149 -26 70 -17 172 21 235 31 49 104 105 158 121 18 6 363 9 821 8 l790 -2 54 -30z m649 -834 c95 -43 162 -147 162 -251 0 -66 -30 -131 -85 -187 -84 -83 -84 -83 -593 -83 l-434 0 -55 50 c-281 257 -719 257 -1005 0 l-57 -51 -453 3 c-452 3 -453 3 -500 26 -92 45 -158 151 -158 252 0 119 99 235 221 259 24 5 688 8 1474 8 l1430 -2 53 -24z m-1317 -623 c130 -64 224 -184 249 -317 5 -29 10 -98 10 -151 0 -53 -5 -122 -10 -151 -25 -133 -119 -253 -249 -317 -73 -36 -77 -37 -191 -37 -114 0 -118 1 -191 37 -125 62 -210 164 -244 293 -20 79 -20 271 0 350 39 149 147 263 300 318 38 13 74 17 151 15 93 -3 107 -6 175 -40z m-924 -235 c-16 -51 -16 -415 0 -465 l11 -38 -547 0 -548 0 -62 31 c-87 43 -138 117 -148 213 -11 110 44 211 145 263 l64 33 548 0 548 0 -11 -37z m2580 24 c60 -22 117 -72 148 -128 26 -46 30 -64 30 -129 0 -65 -4 -83 -30 -129 -31 -56 -88 -106 -148 -128 -23 -8 -187 -12 -578 -12 l-546 -1 13 68 c17 86 17 318 0 405 l-13 67 546 -1 c391 0 555 -4 578 -12z m-2349 -878 c286 -256 725 -255 1006 1 l55 51 453 -3 c452 -3 453 -3 500 -26 90 -44 158 -151 158 -247 0 -99 -69 -204 -162 -246 l-53 -24 -1455 0 -1455 0 -53 24 c-95 43 -162 147 -162 251 0 66 30 131 85 187 83 82 79 81 588 82 l439 1 56 -51z m1342 -820 c97 -43 160 -138 160 -240 0 -111 -47 -192 -141 -244 l-54 -30 -783 -3 c-518 -2 -796 1 -822 8 -59 16 -131 70 -164 122 -38 63 -47 165 -21 235 24 62 79 121 140 149 l50 24 795 0 c778 0 796 -1 840 -21z"/></g></svg>

After

Width:  |  Height:  |  Size: 3.0 KiB

+1
View File
@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 384 512"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M128 192l128 0 0-64c0-35.3-28.7-64-64-64s-64 28.7-64 64l0 64zm-64 0l0-64C64 57.3 121.3 0 192 0S320 57.3 320 128l0 64c35.3 0 64 28.7 64 64l0 192c0 35.3-28.7 64-64 64L64 512c-35.3 0-64-28.7-64-64L0 256c0-35.3 28.7-64 64-64zm256 64l-256 0 0 192 256 0 0-192z"/></svg>

After

Width:  |  Height:  |  Size: 522 B

@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--!Font Awesome Free 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--><path d="M240 88C240 74.7 229.3 64 216 64C202.7 64 192 74.7 192 88L192 128C156.7 128 128 156.7 128 192L88 192C74.7 192 64 202.7 64 216C64 229.3 74.7 240 88 240L128 240L128 296L88 296C74.7 296 64 306.7 64 320C64 333.3 74.7 344 88 344L128 344L128 400L88 400C74.7 400 64 410.7 64 424C64 437.3 74.7 448 88 448L128 448C128 483.3 156.7 512 192 512L192 552C192 565.3 202.7 576 216 576C229.3 576 240 565.3 240 552L240 512L296 512L296 552C296 565.3 306.7 576 320 576C333.3 576 344 565.3 344 552L344 512L400 512L400 552C400 565.3 410.7 576 424 576C437.3 576 448 565.3 448 552L448 512C483.3 512 512 483.3 512 448L552 448C565.3 448 576 437.3 576 424C576 410.7 565.3 400 552 400L512 400L512 344L552 344C565.3 344 576 333.3 576 320C576 306.7 565.3 296 552 296L512 296L512 240L552 240C565.3 240 576 229.3 576 216C576 202.7 565.3 192 552 192L512 192C512 156.7 483.3 128 448 128L448 88C448 74.7 437.3 64 424 64C410.7 64 400 74.7 400 88L400 128L344 128L344 88C344 74.7 333.3 64 320 64C306.7 64 296 74.7 296 88L296 128L240 128L240 88zM224 192L416 192C433.7 192 448 206.3 448 224L448 416C448 433.7 433.7 448 416 448L224 448C206.3 448 192 433.7 192 416L192 224C192 206.3 206.3 192 224 192zM240 240L240 400L400 400L400 240L240 240z"/></svg>

After

Width:  |  Height:  |  Size: 1.4 KiB

+1
View File
@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--!Font Awesome Free 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free Copyright 2026 Fonticons, Inc.--><path d="M181.5 261.1L194.4 267.5C200.3 270.5 206.8 272 213.5 272C237 272 256.1 252.9 256.1 229.4L256.1 208C256.1 172.7 227.4 144 192.1 144L128.1 144C92.8 144 64.1 172.7 64.1 208L64.1 229.4C64.1 252.9 83.2 272 106.7 272C113.3 272 119.8 270.5 125.8 267.5C135.1 262.8 142.2 259.3 147 256.9L135.1 249C130.6 246 128 241 128 235.7L128 232C128 218.7 138.7 208 152 208L168 208C181.3 208 192 218.7 192 232L192 235.7C192 241 189.3 246 184.9 249L173.1 256.9L181.5 261.1zM172.9 310.5L160 304.1L147.1 310.5C134.5 316.8 120.6 320.1 106.6 320.1C103 320.1 99.5 319.9 96 319.5L96 320.1C96 355.4 124.7 384.1 160 384.1L224 384.1C241.7 384.1 256 398.4 256 416.1C256 433.8 241.7 448.1 224 448.1L384 448.1L384 384.1C384 360.4 396.9 339.7 416 328.7C425.4 323.3 436.3 320.1 448 320.1L448 304.1C448 277.6 469.5 256.1 496 256.1C504.8 256.1 512 263.3 512 272.1L512 368.1C512 376.9 519.2 384.1 528 384.1C536.8 384.1 544 376.9 544 368.1L544 268.4C544 220.2 513.2 177.4 467.4 162.1L458.9 159.3C450.9 156.6 446.3 148.2 448.5 140C450.7 131.8 458.8 126.8 467.1 128.4L487 132.4C576 150.1 640 228.2 640 318.9L640 320L640 320C640 443.7 539.7 544 416 544L255.4 544C132 544 32 444 32 320.6L32 280.8C21.9 266.2 16 248.5 16 229.4L16 208L16 206.6C6.7 203.3 0 194.5 0 184C0 170.7 10.7 160 24 160L26.8 160C44.8 122.2 83.3 96 128 96L192 96C236.7 96 275.2 122.2 293.2 160L296 160C309.3 160 320 170.7 320 184C320 194.5 313.3 203.3 304 206.6L304 208L304 229.4C304 230.8 304 232.2 303.9 233.7C315.9 227.5 329.6 224.1 344 224.1L352 224.1C369.7 224.1 384 238.4 384 256.1C384 273.8 369.7 288.1 352 288.1L344 288.1C330.7 288.1 320 298.8 320 312.1L320 320.1L376.4 320.1C361.2 337.1 352 359.5 352 384.1L320 384.1C277.7 384.1 241.8 356.7 229 318.8C223.9 319.7 218.7 320.1 213.4 320.1C199.3 320.1 185.5 316.8 172.9 310.5zM96 192C104.8 192 112 199.2 112 208C112 216.8 104.8 224 96 224C87.2 224 80 216.8 80 208C80 199.2 87.2 192 96 192zM208 208C208 199.2 215.2 192 224 192C232.8 192 240 199.2 240 208C240 216.8 232.8 224 224 224C215.2 224 208 216.8 208 208z"/></svg>

After

Width:  |  Height:  |  Size: 2.2 KiB

@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M460.7 39.3l-2.2-2.1c-4.7-4.6-11.5-6.4-17.9-4.7s-11.4 6.6-13.1 13l-.8 2.9c-3.3 11.8-5.1 23.7-5.5 35.6 24.3 20.6 42.9 47.8 53.3 78.8-8.2-1.9-16.5-2.9-25-2.9-.6 0-1.1 0-1.7 0-18.4-44-56.5-77.4-103.6-89.3l-3.4-.9c-6.2-1.6-12.9-.6-18.5 2.6-10.8 6.2-15.6 19.5-11.2 31.1 14.9 39.5 44.3 71.4 81.4 89.7-3.7 6.6-6.4 14-7.6 21.8L279.7 154.9c-30.9-17.7-65.9-26.9-101.5-26.9-32.3 0-62.2 16.8-78.9 44.4-10.3-12.5-25.8-20.4-43.2-20.4-30.9 0-56 25.1-56 56s25.1 56 56 56c11.3 0 21.8-3.3 30.6-9.1 4.9 17.2 14.5 33.1 28.4 45.9L257.2 431.2C269 442 284.4 448 300.4 448L416 448c17.7 0 32-14.3 32-32s-14.3-32-32-32l-96 0 0-43.5c0-42.9-28.4-80.5-69.6-92.3l-30.8-8.8c-8.5-2.4-13.4-11.3-11-19.8s11.3-13.4 19.8-11l30.8 8.8c55 15.7 92.8 65.9 92.8 123.1l0 15.7 56-32.4 6.4-3.7 101.3 0c33.3 0 60.3-27 60.3-60.3 0-18.1-8.2-35.3-22.2-46.7l-34.6-28.2c-4.6-3.7-9.4-7.1-14.5-10 8.4-49.3-7.8-100-43.9-135.5zm-318.5 382c-14.7 9.8-18.7 29.7-8.9 44.4s29.7 18.7 44.4 8.9l46-30.7-48.6-44.5-32.9 22zM480 240a16 16 0 1 1 32 0 16 16 0 1 1 -32 0z"/></svg>

After

Width:  |  Height:  |  Size: 1.2 KiB

@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M384 249.2c0 21.4-17.4 38.8-38.8 38.8L70.8 288C49.4 288 32 270.6 32 249.2L32 208c0-97.2 78.8-176 176-176s176 78.8 176 176l0 41.2zM480 288c-2 0-4-.1-5.9-.3-16.3 53.3-64.3 92.7-122.1 96l0 56.2c0 22.1-17.9 40-40 40l-48 0c-22.1 0-40-17.9-40-40l0-56-32 0 0 56c0 22.1-17.9 40-40 40l-48 0c-22.1 0-40-17.9-40-40l0-56-32 0c-17.7 0-32-14.3-32-32s14.3-32 32-32l312 0c39.8 0 72-32.2 72-72l0-72c0-35.3 28.7-64 64-64 53 0 96 43 96 96l0 16c0 35.3-28.7 64-64 64l-32 0zm16-64a16 16 0 1 0 0-32 16 16 0 1 0 0 32z"/></svg>

After

Width:  |  Height:  |  Size: 761 B

@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M320 128c0-35.3 28.7-64 64-64s64 28.7 64 64l0 128 64 0 0-128C512 57.3 454.7 0 384 0S256 57.3 256 128l0 64-192 0c-35.3 0-64 28.7-64 64L0 448c0 35.3 28.7 64 64 64l256 0c35.3 0 64-28.7 64-64l0-192c0-35.3-28.7-64-64-64l0-64zM64 256l256 0 0 192-256 0 0-192z"/></svg>

After

Width:  |  Height:  |  Size: 520 B

@@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 640"><!--! Font Awesome Pro 7.3.1 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) Copyright 2026 Fonticons, Inc. --><path fill="currentColor" d="M205 64L434.9 64L439.3 82.4L475.6 234.9C478.5 247 480 259.5 480 272C480 352.2 421 418.7 344 430.2L344 560L432 560L432 608L208 608L208 560L296 560L296 430.2C219 418.6 160 352.2 160 272C160 259.5 161.5 247 164.4 234.9L200.7 82.4L205 64zM243 112L211 246C209 254.5 208 263.2 208 272C208 333.9 258.2 384 320 384C381.8 384 432 333.8 432 272C432 263.3 431 254.5 429 246L397.1 112L371.3 112L384.1 176L320.1 216L352.1 320L256.1 216L328.1 144L306.8 112L243.1 112z"/></svg>

After

Width:  |  Height:  |  Size: 721 B

+91
View File
@@ -0,0 +1,91 @@
//! Build script for the alkane-toolkit binary. On Windows targets it compiles
//! windows/alkane-toolkit.rc (application manifest, icon, version info, and
//! wxMSW's stock resources) and links the result into the GUI executable only.
//! Other targets need nothing here.
use std::env;
use std::path::PathBuf;
use std::process::Command;
fn main() {
println!("cargo:rerun-if-changed=build.rs");
if env::var("CARGO_CFG_TARGET_OS").as_deref() != Ok("windows") {
return;
}
for f in [
"alkane-toolkit.rc",
"alkane-toolkit.exe.manifest",
"alkane-toolkit.ico",
] {
println!("cargo:rerun-if-changed=windows/{f}");
}
println!("cargo:rerun-if-env-changed=WX_RS_WXCONFIG");
if let Err(e) = compile_resources() {
panic!("alkane-gui: Windows resources: {e}");
}
}
fn compile_resources() -> Result<(), String> {
// The resource compiler and wx's resource include path come from the same
// wx-config the wx-rs bridge builds against, so they always match the
// linked wxMSW (and the mingw cross windres when cross-compiling).
let wxconfig = env::var("WX_RS_WXCONFIG").unwrap_or_else(|_| "wx-config".into());
let run = |arg: &str| -> Result<String, String> {
let out = Command::new(&wxconfig)
.arg(arg)
.output()
.map_err(|e| format!("cannot run {wxconfig} {arg}: {e}"))?;
if !out.status.success() {
return Err(format!("{wxconfig} {arg} failed"));
}
String::from_utf8(out.stdout).map_err(|e| e.to_string())
};
let rescomp = run("--rescomp")?;
let mut words = rescomp.split_whitespace();
let windres = words.next().ok_or("wx-config --rescomp printed nothing")?;
let mut args: Vec<String> = words.map(str::to_owned).collect();
// rcdefs.h lives in the build-specific setup directory, which --rescomp
// omits; it is the -I entry of --cxxflags.
for flag in run("--cxxflags")?.split_whitespace() {
if let Some(dir) = flag.strip_prefix("-I") {
args.push("--include-dir".into());
args.push(dir.into());
}
}
let version = env::var("CARGO_PKG_VERSION").unwrap_or_default();
let mut parts = version
.split(['.', '-', '+'])
.map(|p| p.parse::<u16>().unwrap_or(0));
let (major, minor, patch) = (
parts.next().unwrap_or(0),
parts.next().unwrap_or(0),
parts.next().unwrap_or(0),
);
let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").map_err(|e| e.to_string())?);
let out =
PathBuf::from(env::var("OUT_DIR").map_err(|e| e.to_string())?).join("alkane-toolkit-res.o");
let status = Command::new(windres)
.args(&args)
.arg("--include-dir")
.arg(manifest_dir.join("windows"))
.arg(format!("--define=ALKANE_VER_MAJOR={major}"))
.arg(format!("--define=ALKANE_VER_MINOR={minor}"))
.arg(format!("--define=ALKANE_VER_PATCH={patch}"))
.arg(format!("--define=ALKANE_VER_STR=\\\"{version}\\\""))
.arg("--input")
.arg(manifest_dir.join("windows/alkane-toolkit.rc"))
.arg("--output-format=coff")
.arg("--output")
.arg(&out)
.status()
.map_err(|e| format!("cannot run {windres}: {e}"))?;
if !status.success() {
return Err(format!("{windres} failed ({status})"));
}
// Only the GUI binary carries the manifest/icon; miner_probe stays a plain
// console tool. A linked object (not an archive member) is never dropped by
// the linker, which is what keeps the resource section in the .exe.
println!("cargo:rustc-link-arg-bin=alkane-toolkit={}", out.display());
Ok(())
}
Binary file not shown.
+34
View File
@@ -0,0 +1,34 @@
#!/bin/sh
# Regenerate alkane-toolkit.icns (the macOS app icon) from the in-repo
# microchip glyph: the same white chip on a rounded amber tile as the Windows
# icon, at the sizes macOS asks for (16-1024 px). Needs rsvg-convert,
# ImageMagick and python3; the .icns is committed, so a build never runs this.
set -e
cd "$(dirname "$0")"
GLYPH=../assets/icons/microchip-solid-full.svg
TMP=$(mktemp -d)
trap 'rm -rf "$TMP"' 0
sed 's/currentColor/#ffffff/g; s/<svg /<svg fill="#ffffff" /' "$GLYPH" > "$TMP/glyph.svg"
for s in 16 32 64 128 256 512 1024; do
# Apple's grid: the tile fills ~80% of the canvas, centred.
t=$((s * 80 / 100)); m=$(((s - t) / 2)); r=$((t * 22 / 100))
g=$((t * 60 / 100)); o=$(((s - g) / 2))
rsvg-convert -w "$g" -h "$g" "$TMP/glyph.svg" -o "$TMP/g$s.png"
convert -size "${s}x${s}" xc:none -fill '#d9822b' \
-draw "roundrectangle $m,$m $((m + t - 1)),$((m + t - 1)) $r,$r" \
"$TMP/g$s.png" -geometry "+$o+$o" -composite "PNG32:$TMP/i$s.png"
done
python3 - "$TMP" alkane-toolkit.icns <<'PY'
import pathlib, struct, sys
tmp, out = pathlib.Path(sys.argv[1]), sys.argv[2]
# ICNS element types that hold PNG data, by pixel size.
types = [("icp4", 16), ("icp5", 32), ("icp6", 64), ("ic07", 128), ("ic08", 256),
("ic09", 512), ("ic10", 1024), ("ic11", 32), ("ic12", 64), ("ic13", 256),
("ic14", 512)]
body = b""
for kind, size in types:
data = (tmp / f"i{size}.png").read_bytes()
body += kind.encode() + struct.pack(">I", len(data) + 8) + data
pathlib.Path(out).write_bytes(b"icns" + struct.pack(">I", len(body) + 8) + body)
PY
echo "wrote $(pwd)/alkane-toolkit.icns"
+290 -24
View File
@@ -14,18 +14,37 @@
//! rather than add an HTTP+digest crate, so the offline/vendored build is
//! unaffected. `Some(true)` = locked, `Some(false)` = unlocked, `None` =
//! indeterminate (unreachable, or an endpoint/vendor this probe doesn't cover).
//!
//! WhatsMiner has no such digest-gated web endpoint (it returns a 307 redirect
//! for the Antminer paths, so the curl probe always read "indeterminate" and the
//! table fell back to a capability guess that marked older units "locked" even
//! with the default login -- round 12 #8b). Instead we run the WhatsMiner
//! :4028 token handshake: `get_token` (unauthenticated) yields a salt, we derive
//! the AES key from the password, and send a NON-mutating encrypted `summary`.
//! An encrypted reply means the key (hence password) was accepted -> unlocked;
//! a plaintext `enc json load err` means it was rejected -> locked.
use std::io::{Read, Write};
use std::net::{SocketAddr, TcpStream};
use std::process::Command;
use std::time::Duration;
use aes::cipher::{block_padding::ZeroPadding, BlockEncryptMut, KeyInit};
use aes::Aes256;
use base64::engine::general_purpose::STANDARD as BASE64;
use base64::Engine;
use sha2::{Digest, Sha256};
type Aes256EcbEnc = ecb::Encryptor<Aes256>;
/// Classify a miner's access state from an HTTP status code string (curl's
/// `%{http_code}` output). Conservative: anything other than a clear
/// authenticated/unauthorized answer is `None`.
pub fn classify_http_code(code: &str) -> Option<bool> {
match code.trim() {
"200" | "204" => Some(false), // authenticated -> unlocked/writable
"401" | "403" => Some(true), // rejected -> locked/view-only
_ => None, // 000 (no connect), 404, 5xx, ... -> unknown
"200" | "204" => Some(false), // authenticated -> unlocked/writable
"401" | "403" => Some(true), // rejected -> locked/view-only
_ => None, // 000 (no connect), 404, 5xx, ... -> unknown
}
}
@@ -35,30 +54,52 @@ fn endpoint(_firmware: &str) -> &'static str {
"/cgi-bin/get_miner_conf.cgi"
}
/// Probe one miner's access state over its web API with the given credentials.
/// Returns `Ok(Some(true/false))` on a decisive lock/unlock answer, `Ok(None)`
/// if reachable-but-indeterminate or a vendor this probe doesn't cover, or
/// `Err` only on a failure to run curl at all.
pub fn probe_access(ip: &str, firmware: &str, user: &str, pass: &str) -> Result<Option<bool>, String> {
let url = format!("http://{ip}{}", endpoint(firmware));
let userpass = format!("{user}:{pass}");
let mut cmd = Command::new("curl");
/// Probe one miner's access state. `make` is the miner brand ("Whatsminer" /
/// "Antminer"): WhatsMiner uses the :4028 token handshake, everything else the
/// digest-auth web probe. Returns `Ok(Some(true/false))` on a decisive
/// lock/unlock answer, `Ok(None)` if indeterminate, `Err` only on a probe that
/// could not run at all.
pub fn probe_access(ip: &str, make: &str, user: &str, pass: &str) -> Result<Option<bool>, String> {
if make.eq_ignore_ascii_case("whatsminer") {
// Try the caller's saved scan password first (round 18 #12: it was being
// ignored for WhatsMiner, so a miner opened with the operator's real
// password was mis-reported as locked), then the per-firmware override and
// factory defaults. All attempts are non-mutating.
let mut candidates = Vec::new();
if !pass.is_empty() {
candidates.push(pass.to_string());
}
for c in whatsminer_password_candidates() {
if !candidates.contains(&c) {
candidates.push(c);
}
}
return Ok(probe_whatsminer_access(ip, &candidates));
}
let url = format!("http://{ip}{}", endpoint(make));
let mut cmd = alkane_core::platform::quiet_command("curl");
cmd.args([
"-s",
"-o",
"/dev/null",
alkane_core::platform::NULL_DEVICE,
"-w",
"%{http_code}",
"--digest",
"-u",
&userpass,
"--connect-timeout",
"5",
"--max-time",
"9",
"-K",
"-", // read the rest of the config (the credentials) from stdin
&url,
]);
let out = wait_with_timeout(cmd, Duration::from_secs(12))?;
// The user:pass goes through a curl config on stdin, never argv, so it can't
// be read from the process list (round 18 #12).
let config = format!(
"user = \"{}\"\n",
curl_config_quote(&format!("{user}:{pass}"))
);
let out = wait_with_timeout(cmd, Duration::from_secs(12), Some(config.as_bytes()))?;
// curl prints the status code to stdout regardless of exit status (000 on a
// connection failure), so classify the code rather than the exit status.
let code = String::from_utf8_lossy(&out.stdout);
@@ -66,11 +107,26 @@ pub fn probe_access(ip: &str, firmware: &str, user: &str, pass: &str) -> Result<
}
/// Run a command with a wall-clock timeout (curl can hang past --max-time on a
/// black-holed host).
fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process::Output, String> {
use std::io::Read;
cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped());
/// black-holed host). `stdin_data`, when set, is written to the child's stdin and
/// the pipe closed -- used to feed a curl config (with the credentials) instead
/// of putting them on the command line (round 18 #12).
fn wait_with_timeout(
mut cmd: Command,
timeout: Duration,
stdin_data: Option<&[u8]>,
) -> Result<std::process::Output, String> {
use std::io::{Read, Write};
cmd.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped());
if stdin_data.is_some() {
cmd.stdin(std::process::Stdio::piped());
}
let mut child = cmd.spawn().map_err(|e| format!("spawn curl: {e}"))?;
if let Some(data) = stdin_data {
if let Some(mut si) = child.stdin.take() {
let _ = si.write_all(data);
} // dropping `si` closes the pipe so curl stops reading the config
}
let start = std::time::Instant::now();
loop {
match child.try_wait().map_err(|e| e.to_string())? {
@@ -83,11 +139,16 @@ fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process
if let Some(mut e) = child.stderr.take() {
let _ = e.read_to_end(&mut stderr);
}
return Ok(std::process::Output { status, stdout, stderr });
return Ok(std::process::Output {
status,
stdout,
stderr,
});
}
None => {
if start.elapsed() >= timeout {
let _ = child.kill();
let _ = child.wait(); // reap so we never leave a zombie (round 18 #12)
return Err("curl timed out".into());
}
std::thread::sleep(Duration::from_millis(100));
@@ -96,20 +157,225 @@ fn wait_with_timeout(mut cmd: Command, timeout: Duration) -> Result<std::process
}
}
/// Escape a value for a curl `--config` file (double-quoted string).
fn curl_config_quote(s: &str) -> String {
s.replace('\\', "\\\\").replace('"', "\\\"")
}
/// Passwords to try for a WhatsMiner access check: a user-set per-firmware
/// override (round 12 #13) wins; otherwise the two factory defaults ("admin" for
/// V1/V2, "super" for V3). All attempts are non-mutating, so trying both is safe.
fn whatsminer_password_candidates() -> Vec<String> {
if let Some((_, pass)) = crate::credentials::load_firmware_credentials().get("WhatsMiner Stock")
{
if !pass.is_empty() {
return vec![pass.clone()];
}
}
vec!["admin".to_string(), "super".to_string()]
}
/// Fetch a WhatsMiner's active fault codes over the unauthenticated :4028
/// get_error_code command and format them one per line for the log viewer
/// (round 12 #12). Returns None if the miner does not answer.
pub fn whatsminer_get_error_code(ip: &str) -> Option<String> {
let resp = wm_rpc(
ip,
"{\"command\":\"get_error_code\"}",
Duration::from_secs(6),
)
.ok()?;
let v: serde_json::Value = serde_json::from_str(&resp).ok()?;
let codes = v
.get("Msg")
.and_then(|m| m.get("error_code"))
.and_then(|c| c.as_array());
let mut lines = vec![format!("WhatsMiner get_error_code ({ip}):")];
match codes {
Some(arr) if !arr.is_empty() => {
for entry in arr {
if let Some(obj) = entry.as_object() {
for (code, when) in obj {
lines.push(format!(" error {code}: {}", when.as_str().unwrap_or("")));
}
}
}
}
_ => lines.push(" no active error codes".to_string()),
}
Some(lines.join("\n"))
}
/// One WhatsMiner :4028 request/response (the miner closes the socket after it
/// replies). Returns the NUL-trimmed body.
fn wm_rpc(ip: &str, payload: &str, timeout: Duration) -> Result<String, String> {
let addr: SocketAddr = format!("{ip}:4028")
.parse()
.map_err(|e| format!("bad address {ip}: {e}"))?;
let mut stream = TcpStream::connect_timeout(&addr, timeout).map_err(|e| e.to_string())?;
stream.set_read_timeout(Some(timeout)).ok();
stream.set_write_timeout(Some(timeout)).ok();
stream
.write_all(payload.as_bytes())
.map_err(|e| e.to_string())?;
let mut buf = Vec::new();
let mut chunk = [0u8; 4096];
loop {
match stream.read(&mut chunk) {
Ok(0) => break,
Ok(n) => {
buf.extend_from_slice(&chunk[..n]);
if buf.len() > 1 << 20 {
break; // cap a runaway response
}
}
Err(_) => break,
}
}
Ok(String::from_utf8_lossy(&buf)
.trim_matches('\u{0}')
.to_string())
}
/// AES-256-ECB encrypt `data` under SHA256(pwd_md5), base64-encoded -- the exact
/// scheme the WhatsMiner btminer API expects (mirrors the vendored asic-rs
/// whatsminer v2 backend).
fn wm_aes_ecb_enc(pwd_md5: &str, data: &str) -> Option<String> {
let key = Sha256::digest(pwd_md5.as_bytes()); // 32 bytes
let mut buffer = data.as_bytes().to_vec();
while !buffer.len().is_multiple_of(16) {
buffer.push(0);
}
let ct = Aes256EcbEnc::new_from_slice(&key)
.ok()?
.encrypt_padded_mut::<ZeroPadding>(&mut buffer, data.len())
.ok()?;
Some(BASE64.encode(ct))
}
/// Check a WhatsMiner's access via the :4028 token handshake, trying each
/// candidate password. Returns `Some(false)` (unlocked) on the first password
/// the miner accepts, `Some(true)` (locked) if all are rejected, `None` if the
/// miner is unreachable or speaks an unexpected dialect. Non-mutating: only
/// `get_token` and a read-only `summary` are ever sent.
fn probe_whatsminer_access(ip: &str, passwords: &[String]) -> Option<bool> {
let timeout = Duration::from_secs(6);
let mut reachable = false;
// A transient error on one candidate must not abandon the others (round 18 #12):
// skip to the next candidate, but remember it happened so we never report a
// confident "locked" when the answer was really indeterminate.
let mut errored = false;
for pass in passwords {
// 1. get_token (no auth) -> salt / newsalt / time.
let tok_resp = match wm_rpc(ip, "{\"command\":\"get_token\"}", timeout) {
Ok(s) => s,
Err(_) => {
errored = true;
continue;
}
};
let v: serde_json::Value = match serde_json::from_str(&tok_resp) {
Ok(v) => v,
Err(_) => {
errored = true;
continue;
}
};
let (Some(salt), Some(newsalt), Some(time)) = v
.get("Msg")
.map(|msg| {
(
msg.get("salt").and_then(|s| s.as_str()),
msg.get("newsalt").and_then(|s| s.as_str()),
msg.get("time").and_then(|s| s.as_str()),
)
})
.unwrap_or((None, None, None))
else {
errored = true;
continue;
};
reachable = true;
// 2. Derive the md5crypt password hash + write-token from the password.
let crypted = md5crypt::md5crypt(pass.as_bytes(), salt.as_bytes());
let full = String::from_utf8_lossy(&crypted);
let Some(pwd_md5) = full.split('$').nth(3) else {
continue;
};
let sign_crypted =
md5crypt::md5crypt(format!("{pwd_md5}{time}").as_bytes(), newsalt.as_bytes());
let sign_full = String::from_utf8_lossy(&sign_crypted);
let host_sign = sign_full.split('$').nth(3).unwrap_or("");
// 3. Send an encrypted, read-only `summary`. If the AES key (from the
// password) is right the miner replies encrypted; if wrong it returns
// a plaintext "enc json load err".
let cmd = format!("{{\"command\":\"summary\",\"token\":\"{host_sign}\"}}");
let Some(enc) = wm_aes_ecb_enc(pwd_md5, &cmd) else {
continue;
};
let payload = format!("{{\"enc\":1,\"data\":\"{enc}\"}}");
let resp = match wm_rpc(ip, &payload, timeout) {
Ok(s) => s,
Err(_) => {
errored = true;
continue;
}
};
if resp.contains("\"enc\"") {
return Some(false); // accepted -> unlocked/writable
}
// rejected -> try the next candidate password
}
// Only report "locked" when we cleanly reached the miner and every candidate
// was rejected with no transient errors; otherwise the result is indeterminate.
if reachable && !errored {
Some(true)
} else {
None
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn classify_codes() {
assert_eq!(classify_http_code("200"), Some(false), "authenticated -> unlocked");
assert_eq!(
classify_http_code("200"),
Some(false),
"authenticated -> unlocked"
);
assert_eq!(classify_http_code("204"), Some(false));
assert_eq!(classify_http_code("401"), Some(true), "unauthorized -> locked");
assert_eq!(
classify_http_code("401"),
Some(true),
"unauthorized -> locked"
);
assert_eq!(classify_http_code("403"), Some(true));
assert_eq!(classify_http_code("000"), None, "no connection -> unknown");
assert_eq!(classify_http_code("404"), None, "endpoint absent -> unknown");
assert_eq!(
classify_http_code("404"),
None,
"endpoint absent -> unknown"
);
assert_eq!(classify_http_code("500"), None);
assert_eq!(classify_http_code(" 200 "), Some(false), "whitespace tolerated");
assert_eq!(
classify_http_code(" 200 "),
Some(false),
"whitespace tolerated"
);
assert_eq!(classify_http_code(""), None);
}
#[test]
fn whatsminer_aes_ecb_matches_reference() {
// Deterministic vector from the verified btminer scheme: AES-256-ECB over
// SHA256(pwd_md5), zero-padded, base64. Guards the WhatsMiner access
// handshake crypto (round 12 #8b) without needing a live miner.
assert_eq!(
wm_aes_ecb_enc("abc123def456", "{\"command\":\"summary\"}").as_deref(),
Some("jn5Wru/5hhMtU1IgamxLoUd/YTxaLTxEeiCQxu5pO+Q=")
);
}
}

Some files were not shown because too many files have changed in this diff Show More