Skip to content

0.1.0-alpha.4 - 2026-11-09

Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 09 Nov 14:54

Release Notes

Breaking

  • Protocol, schema and configuration use runner-neutral names (ADR-0014, #153): the event runner.detected { runner, version, profile_supported } replaces maestro.detected; the artifact class runner_log replaces maestro_log; the agent-run and telemetry fields are runner_exit_code, runner_exit_signal, runner_version, runner_profile_supported, runner_cpu_pct, runner_rss_bytes, runner_cpu_avg and runner_rss_max; the exit class is runner_error; the metric scope is runner; the failure-fingerprint dimension is runner; the configuration key is artifacts.max_bytes.runner_log. The migrations carry these names from the start.
  • There is no compatibility before v1.0.0. The alpha releases cannot be upgraded: start with a fresh database, and upgrade the agents and the server together, since an alpha agent cannot talk to this server.
  • cargo xtask upgrade-rehearsal replays release tags from v1.0.0 on. With none yet it reports that there is nothing to rehearse and succeeds.

Added

  • Agent: Maestro's own takeScreenshot images and startRecording videos can be uploaded, under the new classes user_screenshot (PNG) and user_recording (MP4). Off by default: fleet-agent run --upload-user-media or FLEET_UPLOAD_USER_MEDIA=1 turns it on, and then only a failed flow's files are uploaded, each linked to the step that made it. Their pixels are not redacted, so the switch is the operator's decision (#133).

  • Server: migration 0033 adds the two classes to the artifact allowlist and to the per-project policy, and the retention class user_media (14 days by default), seeded for every project. Each class has its own size cap (artifacts.max_bytes.user_screenshot, 20 MiB; artifacts.max_bytes.user_recording, 100 MiB), its own content type (image/png, video/mp4) and the usercontent serving rules: a recording is served inline, with ranges, and every read of either is audited (#133).

  • Dashboard: screen D shows a failed flow's own screenshots and recordings under the step that made them: an image inline, a recording in the browser's player, both from the usercontent origin. The dashboard's policy allows that origin in media-src (#133).

  • Docs: the security page's T22 row covers the opt-in and its controls; the runner, operator and user guides describe the switch, the classes, their caps and their retention (#133).

  • Dashboard: screen E lists the flow catalog, every flow the project knows, including flows that have never run (shown as "Never run", never as a pass). The agent sends the workspace's flows with their header tags in hello.catalog, and a stored plan names its flows; migration 0031 stores the tags on flow_definitions (#85).

  • Dashboard: screen E filters on tag, device model, OS version, runner, device, CI provider, commit, failure fingerprint and suite, as well as flow, branch, outcome and window. Every filter is in the address, so a saved view is a link (#85, with #41).

  • Dashboard: screen E shows a project trend over the filtered trusted runs: passed, failed and flaky counts per UTC day, and the median and 95th-percentile duration per day and over the window (#85, with #41).

  • Protocol: hello carries catalog (the workspace's flows, bounded at 500, with truncated) and each device sample in telemetry carries model and os_version; both are optional, and PROTOCOL_VERSION stays 1 (#85).

  • Server: GET /api/v1/projects/{project}/flows (the flow catalog) and GET /api/v1/projects/{project}/history/trend (the trend); the history takes the new filters (#85).

  • Server: one browser live socket carries several subscriptions. A subscribe may name its subscription with an id, and unsubscribe stops one; every frame names its subscription as sub. Each subscription is authorized on its own, and a refused one is answered alone while the socket stays open. A socket holds at most 32 subscriptions. A single subscribe without an id works as before. The protocol adds the unsubscribe request and the unsubscribed and samples frames, and the schemas are regenerated (#40).

  • Server: a committed telemetry checkpoint tells its project's subscribers that its runners' samples changed (samples frame), on every instance (#40).

  • Dashboard: one live socket serves the whole app. A page subscribes when it opens and unsubscribes when it closes, and a reconnect subscribes every page again, so moving between pages does not open another socket (#40).

  • Dashboard: the runner and device pages update live as new samples arrive and as their runs move on, without a reload. While a page is not receiving updates (reconnecting, or paused), its runner's liveness, its host sample, and its device's state and newest sample read Stale (#40).

  • Dashboard: a failed flow's page (screen D) and its row in the history (screen E) show the Maestro command that reruns that flow, selectable and copyable. The command is the run's own, with the flow's path last; env values and unrecognised flags are never shown, and the page names what was left out (#82).

  • Dashboard: an attempt's failed flows download as a plan manifest, from the flow page, the history rows of failed flows and the pipeline page. One shard per run with a failed flow; fleet-agent run --plan reruns exactly those flows. An attempt with no failed flow answers 404, and one whose failed flow has no path answers 409 (#82).

  • Server: GET /api/v1/projects/{project}/attempts/{attempt}/failed-flows serves that manifest as an attachment. The screen D and history rows carry reproduction (command, left_out, unavailable) (#82).

  • Agent: run.started carries reproduction, the words of the run's maestro test command with its env values as [REDACTED] and its unknown flags named only, built from the redacted argv. Migration 0029 stores them on agent_runs (#82).

  • Dashboard: Screen G, administration, read only (#139). A global administrator sees Administration in the navigation and reads /admin: projects, publisher trust policies, API keys (metadata only), role mappings, retention classes and windows, the artifact policy and the metric collection policy (both from the running configuration), agent versions against the protocol, ingestion health (refused events, reported losses and the lag of open runs), and /admin/audit, the audit history, newest first and 50 at a time. Everyone else is refused: the page's links are hidden and GET /api/v1/admin/… answers 403 (401 anonymously). The routes are in the authorization matrix. fleet_core::policy gains ViewAdministration, a global administrator's action; the audit history keeps ViewAudit. The operator guide's Administration section says where each area comes from. Forms to change these areas follow.

  • Dashboard: Screen G's changes (#139). A global administrator creates a project and renames it; creates an API key (its secret is shown once, on the page the form answers with), expires it or revokes it; gives a person a role on a project or on every project, and removes it; maps an identity-provider group to a role, changes it and removes it; and adds, edits, revokes and removes publisher trust policies. Each change is one transaction with its audit event (who, what, and the values before and after), and a refused change writes nothing. The forms post with the session's CSRF token, and a request from another site is refused. The same changes are on /api/v1/admin/… as JSON. Migration 0030 adds a source column to group_mappings and publisher_trust_policies (config or dashboard), lets a removed trust policy's tokens end with it, and indexes the audit history by time.

  • Dashboard: a configured trust policy or group mapping is locked on the page, and the start-up sync refuses a configured row that a page row already holds, naming it (#139).

  • Dashboard: Screen G's forms for retention, artifact policy and metric collection, per project (#139). A global administrator sets each retention class's window (0 keeps for ever; it applies to artifacts that become available afterwards), accepts or turns off each artifact class and its largest file, sets the daily bytes and files, and sets the calm and under-pressure sampling intervals (1 to 300 seconds). A blank field keeps the configured value, and an artifact override or daily quota can only be lower than the configured cap. Migration 0032 stores the overrides; the JSON routes are PUT /api/v1/admin/retention/{project}/{class}, …/artifact-classes/{project}/{class}, …/artifact-quota/{project} and …/metric-policy/{project}.

  • Dashboard: every change on these forms is audited in the transaction that makes it, with who made it and the values before and after. A refused change writes no event (#139).

  • Dashboard: a project created by the configuration (projects[]) is locked from renaming on the page: its row says from config, and the API refuses a rename with a reason that names the configuration. A project created on the page can still be renamed (#139).

  • Protocol: welcome.limits carries optional sample_interval_ms and pressure_sample_interval_ms: the project's own interval, else the server's ingest.sample_interval_ms and ingest.pressure_sample_interval_ms, else the agent's 5 s and 15 s. Both are omitted when unset, so PROTOCOL_VERSION stays 1 (#139).

  • Dashboard: a failure's First seen date shows beside its triage state on the flow page and in the history (#84).

  • Dashboard: every live page (overview, pipeline, flow, runner and device) has one polite status region that reads run events out in batches, at most once every five seconds: a run starting or ending, a flow failing or being interrupted, a pipeline's verdict changing. Log lines and counts are never read out (#149).

  • Agent: each emulator's qemu-system-* process is matched to its serial by its console port, and its CPU and resident memory are sent with the device's samples (emu_cpu_pct, emu_rss_bytes, #39).

  • Agent: device samples carry the AVD name and the API level, and the resumed activity of a device on which a flow failed (#39). The server stores them in device_samples (migration 0019).

  • Dashboard: an Active emulators tile on the overview counts emulators seen in the last two minutes that adb reports online (#123).

  • Agent: while the host is under pressure (PSI CPU some avg10 at least 40, PSI memory at least 20, or host CPU at least 95 %, CPU alone on macOS), host and process metrics are sampled every 15 s instead of 5 s and the devices' guest CPU and memory reads are skipped. The agent leaves that state after three calm samples (#39).

  • Dashboard: a flow whose app crashed shows "App crashed: in " above Maestro's failure, with a link to the device logcat excerpt (or a note that none was uploaded); the flow's result and failure message stay Maestro's (#152).

  • Server: API keys expire after api.api_key_ttl_days (90 by default) unless fleet api-key create --expires-in-days says otherwise. api.api_key_ttl_days must be above 0.

  • Dashboard: a flow whose device was lost during it is labelled "Failed · infrastructure (device lost)" above Maestro's failure, on the flow page and in history, with the evidence that made the call (the failure's DeviceServerDiedException and the agent's commands_not_final warning) and the provenance of the failure. The label needs both halves of that evidence; the flow stays failed. The REST flow and history entries carry infrastructure with evidence, warning, source and finality. fleet-agent inspect applies the same rule (#145). The cut-short warning is kept on the flow when the server ingests it (flow_executions.cut_short, migration 0028, backfilled from the journal), so the label outlives the journal's 14-day retention and stays on history for as long as the history does.

  • Server: GET /api/v1/flows/{id}/page redirects a signed-in reader to the flow's screen D (/flows/{id}?project=<slug>), for a flow known only by its ID. A browser (Accept: text/html) without a session is sent to browser sign-in and comes back to the flow; an API client keeps the 401. A reader without a role on the flow's project gets the answer for a missing flow (#71).

  • Agent: the job summary links each flow that did not pass to its screen D, when FLEET_SERVER is set (#71).

  • Examples: the composite action's install input (default true) runs the fleet-agent already on PATH with false, and its summary-file output names the job summary file (#71).

  • CI: the action-smoke job runs the composite action on the repository's own agent over a fake Maestro that replays the suite fixture, with a quoted argument, and checks the job summary and Maestro's exit status (#71).

  • CI: the claim lattice's property tests run at PROPTEST_CASES=20000 on every push and pull request (#46).

  • Agent and dashboard: every device sample carries the shard the device was assigned to (the planner's shard for a plan run), and every reading the agent did not take carries a reason (not_an_emulator, no_emulator_process, no_avd_name, probe_failed, throttled, no_baseline, no_adb_list, not_sampled). The protocol adds DeviceSample.shard and DeviceSample.unavailable, optional and serde-defaulted, and the schemas are regenerated. The server stores them in device_samples (migration 0024) and serves the newest sample on GET …/devices/{device} as latest (its shard and every reading with its reason). The device page has a Newest sample card that shows each unknown reading's reason, marked Missing (#39).

  • Agent, server and dashboard: every host and process reading the agent did not take carries a reason (no_system_info, no_psi, no_process, probe_failed, no_baseline), as device readings do. The protocol adds Sample.unavailable, optional and serde-defaulted, and the schemas are regenerated. Migration 0026 stores the reasons in host_samples.unavailable. The runner's latest host reading in the overview says why it is unknown, and the runner page has a Newest host sample card that lists every host reading with its value or its reason, marked Missing (#39).

  • Failure triage: a maintainer marks a failure fingerprint Known (with the issue that tracks it) or Resolved, or clears it. The state shows on history rows, on the failure groups of a flow's stats and on the flow page's failure band. Every fingerprint records when it was first seen, and every change is audited (PUT and DELETE /api/v1/projects/{project}/failures/{fingerprint}/triage; migration 0020, #84).

  • Agent: an offline run (no FLEET_SERVER, such as a fork pull request) writes fleet-bundle.tar.zst to its run directory: its journal and the artifacts it would have uploaded, each redacted as a live upload is. The run's output and exit status are unchanged (#83).

  • Agent: fleet-agent publish <bundle or Maestro output directory> sends a finished run to the server as a new, imported run. Live console output is recorded as debug-log evidence, not as live (#83).

  • Agent: a Maestro HTML report is uploaded as an html_report artifact when the run wrote it: the file --output names for --format html or html-detailed, or Maestro's default report.html in the working directory without --output (redacted like a log; not uploaded above 16 MiB; a report left by an earlier run is ignored with a report_stale warning). An upload that fails never changes the run's result (#43).

  • Dashboard and REST: a published run is labelled Published wherever runs and flows are shown, and the REST API carries origin (live or published) on agent runs, flows and history entries. The server stores it in agent_runs.origin (migration 0021).

  • Agent: a published Maestro output directory without meta.json keeps the times its files record (the maestro.log records and the flows' commands.json), not the 1970 replay epoch.

  • Server: a published run is filed under the day it started (run_day), not the day it was published. A run older than the journal retention is refused with the reason.

  • Agent and server: artifacts can be uploaded straight to S3 with a presigned PUT (issue #43, PLAN §7.6, ADR-0007). The agent asks with direct: true; the server answers presigned with a staging URL signed for the file's SHA-256, and reads the staged bytes once, at complete, and verifies them as before. A store that cannot presign, or a direct upload that fails, is relayed as before. New server setting storage.s3.public_endpoint (the host agents reach). Protocol: additive UploadRequest::direct and UploadGrant::Presigned; schemas regenerated. Repeated completions return the recorded outcome and never re-read staged bytes.

  • Server: the usercontent origin answers HTTP Range requests for artifacts: a single byte range is 206 Partial Content with Content-Range, an unsatisfiable one is 416, and every answer carries Accept-Ranges: bytes (#43).

  • Agent: a single-flow run with no --format settles its steps from its final commands.json. Maestro's default console names no flow, so the flow is the one file the command names, when the command runs exactly that file alone (one device, one shard, no -c); the steps are read from Maestro's command lines in that console (#148).

  • Agent: a final commands.json whose flow the log never started is warned on its agent run (commands_flow_unnamed) instead of being ignored. The server keeps the warning on the run (file_warnings, migration 0025), and the job's entry on the pipeline page says so; no flow is created for it (#148).

  • Docs: the operator guide's Upgrades section covers backups before an upgrade, forward-only migrations and their checksums, agent and server protocol versions, rollback by restore, and how to rehearse an upgrade.

  • Tooling: cargo xtask upgrade-rehearsal exports each release tag's migrations from git, seeds rows under each release's schema, migrates to the current tree and checks that the rows and the current read paths survive (crates/fleet-store/tests/upgrade.rs). CI runs it on every push and pull request.

  • Server: fleet-server api-key list --project <slug> shows each key's ID and state. api-key revoke --id <id> and api-key expire --id <id> --in-days <d> end keys made before the 90-day default, and revoking or expiring a key also stops every agent token minted from it (research 06 T3, #140).

Changed

  • Server: the start-up sync replaces only the publisher trust policies and group mappings that came from the configuration. Rows added on the dashboard are kept (#139). Revoking a trust policy, here or by configuration, now ends the agent tokens minted from it at once, as revoking a key does.
  • Dashboard: the Active emulators tile sits beside the runners on the overview, not in the readout strip (#123).
  • Dashboard: a pipeline whose flow failed reads Failed while its jobs are still running; the verdict follows its flows (#149).
  • Dashboard: the status words follow one vocabulary. Completed replaces Finished, Closed and a job's closed lifecycle without an outcome; Interrupted replaces Cancelled; Running covers starting, finalizing and reporting; Not started replaces No jobs yet (#149).
  • Dashboard: a settled result carries no provenance badge of its own. Rows mark only Provisional, Inferred, Missing and Stale values; each page or section states Verified or Observed once (#149).
  • Dashboard: on a phone the top bar shows the brand mark and the live indicator. The pages, the project and the account are behind the ⋯ button (#149).
  • Dashboard: the sign-in prompt and error notices are hairline-ruled rather than bordered boxes, and so is the log viewer (#149).
  • Server: an upload is refused when the project's last 24 hours of declared uploads would pass 20 GiB or 20,000 files (artifacts.max_project_bytes_per_day, artifacts.max_project_files_per_day; refusal project_quota_exceeded). WebSocket and batch frames are capped at 256 KiB, down from 1 MiB (ingest.max_frame_bytes); agents fill frames by bytes under that cap, and an agent event over 192 KiB is stored as a gap (research 06 T12, #140).
  • Server: a browser session ends after login.session_idle_minutes (60 by default) without a request, as well as at its absolute lifetime. A request renews it; an open live socket does not. Migration 0027 adds sessions.last_seen_at (research 06 T21, #140).
  • Server: a discovery document's jwks_uri must name the issuer's host, or a host listed in the issuer's jwks_hosts (or login.jwks_hosts). Any other host is refused and never fetched (research 06 T14, #140).
  • Server: a screenshot, JUnit or HTML report read through a signed link writes an artifact.fetched audit row, and a read whose row cannot be written is refused (research 06 T7, #140).
  • Agent: the recorded command line redacts the value of every flag not on the safe list, and -e/--env values become KEY=[REDACTED] (research 06 T5, #140).
  • Agent: every line the agent prints itself (notices, warnings, the job summary, inspect, publish and check output) has its leading :: removed, so a runner does not read app or device text as a workflow command. Maestro's own output is unchanged (I1; research 06 T13, #140).
  • Agent action: verify-attestation defaults to true. The action requires the release's build attestation to verify, takes the archive's expected SHA-256 from that attestation, and no longer trusts sha256.sum from the same release. The example workflow grants attestations: read (research 06 T18, #140).
  • Deployment: Garage's RPC secret is a Docker secret (GARAGE_RPC_SECRET_FILE), and Fleet reads the S3 key pair from Docker secrets (FLEET_STORAGE__S3__*_FILE), not .env. Postgres is pinned to postgres:18.6. Garage's default key pair stays in its container's environment, from secrets/garage.env, because Garage 2.5 has no file option for it (research 06 T20, #140).
  • Runner guide: a "Hardening a runner" section for the steps the repository can document (research 06 T18, T19, #140). The immutable-releases setting and ephemeral runners for fleet-mac are the owner's to set.

Fixed

  • Agent: a run takes a Maestro directory only on evidence that it is its own, the directory its own process holds its session log open in. A run whose process could not be asked (it had exited, or the system could not tell) no longer takes another run's lone directory, which two runs in one tree could trade under load (#148). A directory dated a few milliseconds before the run's start, as a coarse birth clock can date it, is still considered.

  • Server: sibling runs of one CI job that end at the same moment close the job. Each run's end now locks the job before deriving its state, so neither reads the other as still open (a race #141's write path exposed).

  • Server: a batch the database cannot start in time (the pool's 5 s acquire timeout) is refused with a non-fatal overloaded error that names the batch's first seq, instead of a fatal internal error that closed the agent's socket. The socket stays open and nothing of the batch is stored. The refusals are logged at warn, at most once every 10 seconds. Every other store error is still fatal (research 14, F1).

  • Agent: a busy server is waited out (200 ms to 5 s, jittered, reset by the next ack) and the batch resent on the same connection from the refusal's expected_seq. The run does not fail over it.

  • Loadgen: the same wait and resend, and the results JSON counts the refusals as busy.

  • Dashboard: a flow the log started whose run ended with no verdict for it is Unknown with the Missing provenance, not Running. The run's end re-resolves its started flows, and an ended agent run counts as the end of its evidence, as a closed suite does (fleet-core resolve, flow_provenance).

  • Agent: fleet-agent inspect and publish read a flow's bundles where the layout model says Maestro writes them: --test-output-dir, --debug-output apart from the session log, and a workspace config's testOutputDir. The captured paths-debug-and-test-output-apart, paths-debug-and-test-output-same, paths-test-output-dir and paths-config-* runs now settle their flows as a live run does, and a command that runs Maestro from a shell script (exec maestro …) is read as its command.

  • Server: on shutdown an agent socket waits up to one second for the agent's close frame after goaway and close 1012, so the socket is not reset while the agent's frames are unread and the agent still reads goaway.

  • Agent: an emulator is recognised by its program's qemu-system-* name as well as by its process name, so a process whose name differs from the program it runs still maps to its serial.

  • Agent: a live run follows Maestro's files for two more layouts, which the captured fixtures now cover: a workspace config's testOutputDir (read from --config, or from a config.yaml in a directory the command names, and overridden by --test-output-dir), and --flatten-debug-output with --test-output-dir or with --debug-output and --test-output-dir. --flatten-debug-output alone writes into Maestro's user.home, which the agent now reads as the JVM does (-Duser.home in JAVA_OPTS or MAESTRO_OPTS, else the account's home), not from $HOME (#148).

  • Agent: a command that already has --flatten-debug-output is never given a second one. Maestro rejects a repeated flag with exit 2 (captured: paths-flatten-repeated), so the run failed before it started.

  • Agent: two Maestro runs in one tree no longer trade their steps. A run's directory is the one its own process holds its session log open in, not the oldest one created since it started. With no process to ask, a single candidate is taken and several are not (#148).

  • Agent: the watcher reads a shared flattened directory (the home directory without --debug-output) only for folders created since the run started, and on a backoff of at most once a second while nothing new appears, so it no longer reads every entry of the home directory on each 50 ms poll (#148).

  • Dashboard: a step the log opened and never ended, which the flow's final commands.json does not list either, is Missing rather than Provisional. Every other step is settled from the file as before (#148).

  • Dashboard: a step row still read from the live log is marked Stale once its run goes quiet, the same rule as the flow's own badge, and its open steps are marked Inferred and read Unknown when the server abandons the run (#148).

  • Agent: a live run settles its steps from commands.json wherever the command's own flags put Maestro's files: --debug-output, --test-output-dir, --flatten-debug-output in any combination, or none of them with --fleet-rewrite=off. The watcher used to follow only the agent's flattened directory, so those runs left their steps Provisional until a replay (#148).

  • Dashboard: a flow's step rows stay Provisional after the flow is Verified. Once the flow ends, its final commands.json settles the steps the log reported: each command is paired with the step at the same depth and of the same command kind, and a paired row takes the file's result and timing and is Verified. Unpaired steps stay Provisional, and the Steps section says when steps could not be matched or when the log and the file disagree on a status (the file's status is shown). A settled step row carries no badge of its own, since its section states Verified once; a row shows its own badge only when it is Provisional, Inferred, Missing or Stale (#149). A cut-short, empty, aborted or unrecognised commands.json settles nothing. step.ended carries the file's start and duration as an optional timing (protocol additive change; schema regenerated). Migration 0023 keeps the alignment warnings on the flow (#148).

  • Examples: the composite action splits its command input as a shell does for quotes and backslashes (maestro test "my flows/" passes one argument). It used to split on every whitespace, so a quoted argument broke (#71).

  • Agent: a serial that a later shard selects again is a new device session. Its samples follow that session and shard, its API level is read again and its CPU baseline starts over; the probes used to keep the first session's API level and CPU baseline and to attribute samples to the first shard that selected the serial (#39).

  • Server: fleet api-key create --project <slug> on a configured project keeps the project's name; it used to rename the project to its slug until the next serve start.

  • Agent: fleet-agent publish with no credential (no FLEET_TOKEN, no CI OIDC variables) fails before it reads or sends anything, and names the variables to set; it used to report the run as refused by the server.

  • Agent: fleet-agent publish of a run the server refuses (older than the journal retention) exits at once with the reason. It used to wait out the upload budget (FLEET_UPLOAD_TIMEOUT, 120 s by default) first.

  • Server: pull request runs (trust pr) and untrusted runs are kept out of flow stats, the duration summary and chart, failure groups and flakiness verdicts. They stay in the history and on their own run pages.

  • Agent: a run with no credential (no FLEET_TOKEN, or an empty one, and no OIDC request) runs offline. It no longer attempts an unauthenticated connection, which sent the run's CI facts to the server.

  • Server: the OIDC key-set client no longer follows redirects, so a redirected discovery document is refused.

  • Server: token-shaped text in step, flow, report and app-crash events is redacted on ingest, before it is journaled or stored.

  • Server: the dashboard CSP forbids <object> and <base>, and open browser sockets close when their sign-in ends (api.session_recheck_ms, 30 s by default). Signed artifact links last at most 300 s. CI OIDC tokens without a jti are refused.

  • Blob: an SVG with an XML prolog is refused as a JUnit report.

  • Maestro: escape strings (OSC, DCS and others) are removed with their payload, so an OSC 8 link or OSC 52 clipboard write never reaches a log line.

  • Xtask lint: raw HTML injection (inner_html) is refused in Rust sources.

  • Dashboard: no page scrolls sideways at 1440 px or 390 px. Long flow names, run ids and URLs wrap, wide tables scroll inside their own box, and the phone's navigation shrinks instead of pushing the account off the screen (#149).

Install fleet-agent 0.1.0-alpha.4

Install prebuilt binaries via shell script

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

Download fleet-agent 0.1.0-alpha.4

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