Skip to content

feat(computers): a release publishes chromium composed, and a compose of the same inputs pulls it (M8.60) - #705

Open
earakely-scale wants to merge 2 commits into
mainfrom
edgararakelyan/fd-5908-m860-publish-chromium-with-each
Open

earakely-scale wants to merge 2 commits into
mainfrom
edgararakelyan/fd-5908-m860-publish-chromium-with-each

Conversation

@earakely-scale

@earakely-scale earakely-scale commented Nov 16, 2026 •

Copy link
Copy Markdown
Collaborator

What and why

M8.60 (FD-5908), PR 1 of 2: each release publishes chromium composed, and a compose of the same inputs pulls it.

Today anyone who uses chromium composes it: Docker, a package resolve from Ubuntu's archive, PyPI and download URLs, minutes per arch, and emulation for the other arch. A release now composes it once per arch, probes it, and publishes it; an install of that release pulls it by digest instead of resolving and building. PR 2 (scaleapi) promotes it to the hub as the env chromium.

Design note: M8.60: Publish chromium with each release, outcome and decisions 1a (amended: boot from ghcr), 2a, 3a, 4a, Nov 15.

What changes

  • The release (publish-pypi.yml, .github/scripts/release_computers.py):
    • computer-build composes chromium from the release's own wheels on an amd64 and an arm64 runner, once the protocol is on PyPI and the base computers are published. It probes each at full and hands its local registry's storage on. It holds no token that pushes.
    • computer-publish (infra_build.py publish-computers, standard library and docker only) joins the two images as one index in ghcr.io/scaleapi/agentenv-computers, from that storage, keeping their digests, so each is the image its probe booted. It records each arch's key, image by digest and the lock it was composed from.
    • infra-record puts that record in the wheel's published_images.json as computers; verify-record checks the index and its images against the registry; the release notes list the index.
    • A new image every release, since chromium's venv pins the protocol the release ships.
    • These two jobs never hold a release back: a failure ships the release without chromium, with a warning, and an install composes it as before.
  • The composer (composer.py, published_images.py):
    • A compose takes the release's lock for its inputs rather than resolving one, computes the key a build under it takes, and finds that key in the record. It records the released image by digest (reused, published) and probes it as any reuse is probed. Nothing is resolved or built.
    • The computer is written over the index the release published. An arch composed here beside a released one, or an index the registry won't give, gets an index joined in the run's own store, the released image copied there first.
    • Anything that changes the key composes as before: a changed chromium, a source checkout (which stages the protocol's source), another base, or an image the registry won't give.
  • Docs: computers/README.md, browsers/README.md, AGENTS.md.

Decided while building, for your review

The design note lists 8, in its last section. The ones worth a look:

  1. The hub's chromium helper and the store rule for alias ids (decision 3) move out of this PR, into a small framework PR that ships with PR 2.
  2. The release's computer jobs never hold a release back.
  3. Each arch is published only as a platform of one index, recorded by digest, with no per-arch tag.
  4. The compose job hands the push job its registry's storage, so the job that pushes runs no agent-env code and pushes exactly what was probed.
  5. agentenv-computers is a new GHCR package: private until an org admin makes it public. Until then installs compose as before, and the release warns.

How it was tested

  • Unit:

    • The composer (test_computer_env.py, on a fake Docker and registry): a compose of what the release published pulls it with nothing resolved or built and its computer over the released index; a record of another key, or an image the registry won't give, composes as before; an arch released beside one composed here, and an index the registry won't give, join an index in the store.
    • The record (published_images_test.py): its locks, images and index found, a record that isn't one refused, a registry named by its port.
    • The release scripts: publish-computers joins each app's platform manifests (an attestation set aside) into one index and records it, refuses anything a compose didn't write and pushes nothing, and refuses an index that doesn't name exactly its images; verify-record checks each composed computer; write --computers records them.
    • 429 passed on each VM, amd64 and arm64.
  • End to end, on agent-environments-admin VMs, amd64 (c8i.4xlarge, KVM) and arm64 (m7g.4xlarge), the release as the workflow runs it:

    • computer-build: the framework built as a wheel and pinned as the release pins it, installed with protocol 0.1.555 from PyPI, chromium composed natively and probed ready on each arch (129 files resolved, about 3 minutes each).
    • computer-publish: the two registries' storage merged, and infra_build.py publish-computers run as is, a second local registry standing in for ghcr: one index of the two images, their digests kept. verify-record passed on the record.
    • An install of a wheel carrying that record, in fresh stores and an empty registry, running a task that deploys chromium alone: on each arch both arches were taken from the release, nothing resolved or built, its own arch probed ready in about 25 s, and the deploy ran.
    • This found that the record refused a registry named by its port; fixed in 51a11aa.
  • Chaos, on amd64, each a fresh install with --no-emulate:

    Case What happened
    The released registry down Warned that the image can't be pulled, then resolved, built and probed it ready (1.5 min)
    The record holding amd64 alone amd64 taken from the release and ready; arm64 skipped
    An index the registry doesn't serve Both images from the release; warned and joined an index in the store
    Another build's keys Composed as before, nothing marked published
  • Integration, browser_computer_test.py, a new test: chromium composed again in fresh stores with a record of the module's own compose (the local registry standing in for ghcr) takes every arch's image from it, resolves and builds nothing, and the browser it deploys boots that image. The whole module passed on amd64 (31 passed, 1 skipped); the new test and gate 3 passed on arm64.

  • Not run before merge: the jobs on GitHub's runners and the push to ghcr, which only a release tag runs.

After merge

  • The first release runs the two new jobs for real; I'll watch it.
  • An org admin makes the agentenv-computers package public once it exists.
  • PR 2 in scaleapi, with the framework PR for the hub's chromium env.

🤖 Generated with Claude Code

RetriggerView in GreptileConfidence Score: 5/5

The PR appears safe to merge; no actionable issue was established.

Summary

Releases compose and probe Chromium on both supported architectures, publish one index, and record its images and package locks in the wheel.

  • Each release publishes probed Chromium images for both supported architectures.
  • Matching Chromium composes pull the release image instead of building it again.

Intentional rollout limits: earakely-scale states that computer-job failures ship without Chromium, the new GHCR package remains private until an admin makes it public, and the hub helper is deferred.

Diagram

%%{init: {'theme': 'neutral'}}%%
flowchart TD
  A[Release wheels] --> B[Compose and probe amd64]
  A --> C[Compose and probe arm64]
  B --> D[Publish one image index]
  C --> D
  D --> E[Record images and locks in release wheel]
  E --> F[Install computes build key]
  F --> G{Released image matches and can be read?}
  G -->|Yes| H[Reuse image by digest and probe]
  G -->|No| I[Resolve, build, and probe]
Loading

Reviews (1) · Last reviewed commit: "fix(computers): a release record may nam..." · Reviewed by Greptile

earakely-scale and others added 2 commits November 15, 2026 20:22
… of the same inputs pulls it (M8.60)

Each release composes chromium from its own wheels on an amd64 and an arm64 runner, probes it, and joins the two images
by their digests as one index in ghcr.io/scaleapi/agentenv-computers; the wheel records each arch's key, image and the
lock it was composed from. A compose with that wheel takes the release's lock rather than resolving one, finds its key
in the record, and records the released image by digest, pulled rather than built; anything that changes the key
composes as before. The release's computer jobs never hold a release back.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@earakely-scale
earakely-scale marked this pull request as ready for review November 16, 2026 05:16
@earakely-scale
earakely-scale requested a review from a team as a code owner November 16, 2026 05:16

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant