Skip to content

0.1.0-alpha.1 - 2026-11-06

Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 06 Nov 09:30
9f89696

Release Notes

Added

  • Planner: the manifest records what an equal-count split of the same flows would have produced by the same estimates (equalCountEstimatedSeconds), so a plan can state its saving over that split (#81).
  • Dashboard: a pipeline with a Fleet plan shows each shard's planned and actual time (first flow start to last flow end) and the slowest shard's saving over an equal-count split (#81).
  • Server: with several instances on one database, a change committed through one instance reaches browsers on the others as a live delta (Postgres NOTIFY/LISTEN), not only after a resync (#34).
  • Agent: host samples carry the load average, CPU cores, swap and Linux pressure stall information (CPU, memory, I/O); screen C charts them and the worker page shows the core count, with "Not reported" for what an agent doesn't send (#42).
  • Fleet Planner (ADR-0013): fleet-planner plan splits a Maestro suite into CI shards. It finds flows the way Maestro does (config.yaml globs, tags, executionOrder), balances shards Longest Processing Time first from Fleet history (or an even split without it), writes an immutable manifest and a GitHub Actions matrix, and publishes the plan. fleet-agent run --plan runs one shard with the plan's workspace config, and refuses an empty shard or a command that would select flows itself.
  • The agent falls back to HTTPS batch transport after repeated blocked WebSocket upgrades, with server-authoritative resume and telemetry acknowledgments.
  • Generated protocol JSON Schemas, golden wire frames and a CI freshness check.
  • A pinned Maestro nightly emulator workflow and a captured absolute-path regression fixture.
  • Agent: cargo xtask bench-overhead measures the agent's overhead (I10) by running the fake-Maestro suite with and without it, reporting the duration delta, the agent's CPU time and its peak memory.
  • Agent: the Maestro version comes from the session log's own version line, and is recorded once per run as maestro.detected (no extra maestro --version process). The server keeps it on the run and in the run's condition fingerprint; a version outside Fleet's profile is warned about on stderr and recorded with profile_supported: false (#73).
  • M5 exit: screen D shows a failed flow's evidence from the usercontent origin: the failure screenshot in the screenshot viewer (tied to the step named in its file name), the Maestro log in the log viewer opened at the failing step of that flow (the step tree moves it; "Jump to the failing step" returns), command timings from commands.json, a link to the Maestro HTML report that opens sandboxed on the usercontent origin, downloads, refused uploads with their reasons, and honest empty states (nothing uploaded, no usercontent origin). The dashboard's CSP allows exactly the configured usercontent origin in img-src and connect-src. fleet-e2e proves acceptance criteria 7, 8 and 9 and invariant I7 in a real browser with the real agent. The step tree now sets aria-level, aria-posinset and aria-setsize (they were being written as attr:aria-level). User guide: "Investigating a failure".
  • M5: retention (issue #45). The leader runs telemetry rollups (one-minute and one-hour, idempotent, late-data aware; unavailable readings stay unavailable), drops expired partitions of raw samples, the journal and steps (raw samples only once rolled up), deletes expired rollups and audit events, expires artifacts by retention class (failure evidence is promoted when its flow finalizes as failed; legal hold keeps an artifact), and deletes blob objects only when no artifact refers to them and after a grace period; leftover temp files of crashed local uploads are swept (BlobStore::sweep_stale_uploads). Migration 0009; [retention] server settings; operator guide section. The metrics endpoints serve ranges over 24 hours from the rollups.
  • M5: screens E and F of the dashboard (History and Compare): GET /api/v1/projects/{project}/history (filters by flow, branch, outcome and time, bounded to 90 days, cursor pages, failure and condition fingerprints, flaky v1 verdicts naming the runs behind them), …/flows/{name}/stats (settled counts, p50/p90 duration of passes, the latest durations, failures grouped by fingerprint) and …/compare?a=&b= (flow-by-flow outcomes with explanations drawn from the sides' evidence only); the /history and /compare pages with URL-synced filters and attempt pickers; fleet-loadgen can set the commit, ref, architecture and failure pattern of a run.
  • M4 exit: the browser acceptance suite (fleet-e2e, m4_exit.rs) proves, in a real browser against the real server, that a developer can follow a full run without CI logs and that acceptance criteria 2, 4, 5, 6 and 14 pass (plus 12 for sign-in): the real fleet-agent wrapping the fake Maestro replays a captured failing run, which is followed from the overview to the failed flow page without a refresh; progress counts toward a Fleet plan's total and is marked uncertain without one; ten simultaneous runs stay correct, and the page stays responsive; signing in works end to end against a wiremock identity provider (PKCE, HttpOnly cookie, group refusal, sign-out). The user guide gains "Watching a run" (screens A–D, the provenance legend, uncertain progress, stale and disconnected).
  • M4: the dashboard: fleet-ui component kit, charts and swimlane timeline, log, screenshot and step views; screens A–D (overview, pipeline detail, runner and device detail, flow investigation) with live updates, resync after a server restart and stale and disconnected states; browser sign-in (OIDC code + PKCE, Postgres sessions, CSRF) and the authorize policy; REST reads for the four screens.
  • M5: failure fingerprints (flow identity + failing step + message with numbers, UUIDs, timestamps, durations, paths, serials and addresses removed, versioned v1:), condition fingerprints (device, Maestro major.minor, OS/arch, host class, CI provider; missing facts read unknown) and flaky v1 (confirmed: pass and fail on one commit and condition; suspected: flip rate ≥ 0.2 over the last 20 default-branch runs; inferred outcomes never count as passes) in fleet-core; migration 0007 and the ingest transaction store both fingerprints when a flow's outcome is final (ADR-0009).
  • M5: fleet-blob: the BlobStore contract (content-addressed per project; streaming put that verifies size and SHA-256, ranged get, head, idempotent delete, list for GC) with a local filesystem backend (atomic writes) and an S3-compatible one (object_store, path-style, custom endpoint; Garage is the reference), one contract suite run against both; fleet-blob::verify: size, SHA-256, magic bytes per artifact class and archive safety for zip and tar.zst (entry count, expansion limits, unsafe paths, links, devices, nested archives); [storage] server settings and the operator guide's storage section. No upload endpoints yet.
  • M3: fleet-loadgen runs simulated agents against a real server (--agents --devices --storm --duplicates), replacing mock-server; fleet-e2e proves the M3 exit criteria (50 agents × 4 devices, reconnect storm, server restart mid-run, fixture replay matching fleet-agent inspect, jobs and same-serial emulators kept apart); the Docker image (deploy/docker/Dockerfile, cargo-chef + distroless) and the Compose reference deployment (Postgres 18, Garage, Caddy); operator guide and protocol reference.
  • M3: POST /api/v1/agent/token exchanges a CI OIDC token (configured issuers only, RS256, JWKS cached and refetched on an unknown kid, aud/exp/nbf/iat checked, each jti once) for a short-lived agent token, matched by trust policies on immutable repository IDs (fleet-core::trust; pull_request_target and dynamic always refused), or exchanges an API key. Verified claims name the pipeline run and job. The agent does the exchange on GitHub Actions (#25), tunnels through HTTP(S)_PROXY with NO_PROXY and trusts FLEET_CA_FILE (#24). fleet-e2e runs the real agent against the real server.
  • M3: the live hub and /api/v1/live (snapshot, then deltas in version order per attempt, resync for slow subscribers, Origin check), REST snapshots with a consistent version (/api/v1/projects, …/attempts, …/attempts/{id}), /api/v1/openapi.json, liveness (online/stale/disconnected/completed) and leader-only sweeps that detach silent runs and abandon expired ones (open flows become unknown from server_inferred, jobs interrupted), and Fleet plans (POST /api/v1/plans, immutable, planned totals before any job starts; #21). Reads need a viewer token until browser SSO (M4). The plan manifest type moved to fleet-protocol::plan.
  • M3: the server ingests agents: /api/v1/agent/ws (fleet.v1+json: welcome with server-authoritative resume, ack after commit, event_rejected, seq_gap, fencing, pings, idle timeout, goaway + close 1012 on shutdown), the HTTPS batch fallback POST /api/v1/agent/batch, telemetry checkpoints with telemetry_ack, API-key auth, /livez and /readyz, and the serve, migrate, check-config, healthcheck and api-key create subcommands with figment configuration (TOML, FLEET_*, *_FILE).
  • M3: fleet-store with migrations 0001–0005 (Postgres 18) and the ingest transaction (epoch fencing, duplicate skip, ownership-checked upserts, claim-lattice outcomes, recorded gaps); fleet-core::outcome (suite and job outcomes); cargo xtask sqlx; CI runs the database tests against a Postgres 18 service.
  • Protocol: flow.ended may name its flow (flow), so a claim about a flow that never started (a skipped executionOrder flow) creates it.
  • M2: the fleet-agent CLI (run, inspect, flush, check, version): supervisor, live observer, spool, WebSocket transport, metrics, adb tracking, planner shards; fleet-loadgen mock-server; cargo-dist release pipeline.
  • M1: cargo xtask fixtures capture | import, 24 Maestro 2.12.1 fixtures, Phase 0 flows, research 08; ADR-0003 accepted.
  • M0 repository bootstrap: Cargo workspace skeleton, cargo xtask (setup, ci, lint, web), CI and CLA workflows,
    licensing and governance files, mdBook skeleton, and a Leptos hello page served by fleet serve.

Changed

  • Suspected flakiness requires five eligible runs. I6 now specifies supported redaction sources and encodings, withholds resolved command fields, and documents binary evidence access controls.
  • Finalization uses a shorter flush budget when the server never answered the WebSocket upgrade during the run.
  • Relicensed from PolyForm Internal Use 1.0.0 to the GNU AGPL v3 (AGPL-3.0-only); a commercial license is available on request (ADR-0012).
  • Renamed the product to Fleet; the agent binary is fleet-agent (ADR-0011).
  • Agent: journal.jsonl is capped at 256 MiB (FLEET_JOURNAL_MAX_BYTES, --journal-max-bytes). Past the cap it stops with one journal.truncated line, the run ends with one warning, and fleet-agent inspect reports the missing events; the server still gets every event (#37).

Fixed

  • Credential-bearing agent requests require TLS for remote hosts, and cleartext loopback traffic bypasses proxies. The sign-in callback preserves authenticated sessions.
  • Ingest checks device and shard ownership, contains invalid NUL characters, rolls back rejected event effects, and rejects events after run.ended within the same batch.
  • Agents reconnect silent sockets and replay spool records after disk-write failures. Live clients resnapshot missing changes, ignore superseded socket disconnects, and release idle ordering state.
  • Flow history uses repository-relative report identities when the workspace is known. Running flows without a device display stale provenance, and history scans have a supporting index.
  • Dashboard: the "Sign in" links were taken over by the client-side router and landed on "Page not found"; they now leave the single-page app (rel="external") so the browser follows the redirect to the identity provider (found by the M4 exit tests).
  • Agent: the outbox kept every unacked event in memory, so a long run with no server (offline mode) or an unreachable one grew without bound (I10). The spool file is now the source of truth, read back into a small send window; when the 64 MiB spool (or the window, with no spool) is exhausted the agent stops storing event bodies and sequences a journal.gap instead (I5), and the spool starts over once everything in it is acked. fleet-agent flush streams the spool instead of loading it.
  • Server: a new agent run opening while another run's batch in the same job was mid-transaction could deadlock in Postgres (attempt and job rows locked in opposite orders); the batch was retried and nothing was lost, but the agent reconnected. open_run no longer locks the attempt row (found by the Compose smoke test).
  • fleet-loadgen: wss:// servers panicked for want of a rustls crypto provider; it now installs ring, as the agent does.
  • Agent: a late-starting observer could read a flow's console result before the log line that starts it and split one flow into two; it now catches up on the log before applying console output (found by the M3 end-to-end tests).
  • Server: a worker's "Last seen" and the overview's 24-hour worker filter only moved when an agent connected, so a long-running worker looked stale; the periodic liveness persist now also refreshes the worker's last_seen_at.
  • Dashboard: history "Load more" could add a page fetched under the previous filter, or offer that filter's cursor until the new first page arrived; answers for an older filter are now dropped.
  • Dashboard: a failed or interrupted flow's Failures badge now updates when its provenance settles (it was keyed without provenance, so the row kept the old badge until reload).
  • Dashboard: Escape hides a tooltip without moving focus (WCAG 1.4.13); a #L123 in the log's address scrolls to and highlights that line on load; a flow's screenshot and log links are retried after 5 s when a refresh fails for a transient reason, instead of staying expired until reload.
  • Agent: nested steps (runFlow, retry, repeat) were paired with the wrong start, so parent steps stayed running and their ends appeared as unnamed steps; each end now closes its own step, and a step whose end arrives after the flow's console result is no longer dropped (#62).
  • Agent: a transient write error to the CI log (a full non-blocking pipe, an interrupted flush) used to stop, or drop output from, Maestro's copy to the log. Output now reaches the log in full and in order: a slow log slows Maestro down (backpressure), and only a closed log stops the copy.
  • Agent: failure screenshots and screen hierarchies are journalled against the step Maestro's commands.json says produced them (artifacts[]), instead of a step guessed from the file name; the file name is only the fallback for output without artifacts[], and a file still waiting for its commands.json at run end keeps that fallback (#76).
  • Dashboard: a failure screenshot links to the step Maestro's artifacts[] names, which the server now stores on the artifact (step in the artifact view, migration 0011); the file name is only the fallback for uploads without a stored step, and screenshots upload once their step is known (#76).
  • Agent: at finalize, a server that was still answering hello when Maestro exited got the 3-second budget of an unreachable one, and uploads could hold back the journal's tail; the journal's tail is now sent first, and a server that answered the upgrade gets the full flush budget (#90).
  • Server: flaky history no longer counts a failure whose message names a lost device (Maestro's DeviceServerDiedException) as flakiness, as ADR-0009 promises; such a run is excluded from the verdict (#72).
  • Server: a flow's failure groups scanned every flow execution (the stats query filtered the project only on failure fingerprints), so they now use the history index; the leader's blob collection also deletes objects that no blobs row records once past the blob grace period (orphans a crash leaves behind), hourly.
  • Release: the shipped third-party license notices leave out dev and build dependencies, so a test-only crate with an unaccepted license no longer fails the release build.

Install fleet-agent 0.1.0-alpha.1

Install prebuilt binaries via shell script

curl --proto '=https' --tlsv1.2 -LsSf https://github.com/moyaver/fleet/releases/download/v0.1.0-alpha.1/fleet-agent-installer.sh | sh

Download fleet-agent 0.1.0-alpha.1

File Platform Checksum
fleet-agent-aarch64-apple-darwin.tar.xz Apple Silicon macOS checksum
fleet-agent-aarch64-unknown-linux-musl.tar.xz ARM64 MUSL Linux checksum
fleet-agent-x86_64-unknown-linux-musl.tar.xz x64 MUSL Linux checksum

Verifying GitHub Artifact Attestations

The artifacts in this release have attestations generated with GitHub Artifact Attestations. These can be verified by using the GitHub CLI:

gh attestation verify <file-path of downloaded artifact> --repo moyaver/fleet

You can also download the attestation from GitHub and verify against that directly:

gh attestation verify <file-path of downloaded artifact> --bundle <file-path of downloaded attestation> --repo moyaver/fleet