Skip to content

armgit / cua

Public Imported from GitHub
0

Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.

ci(release): give Spaces, the SDK and the Python/npm packages the Cua Driver/Lume changelog and contributor credits (#5127)

dduponte138b1d9cfa2
diff --git a/.github/releases/README.md b/.github/releases/README.md
index 0e0ddf6890..6038534a03 100644
--- a/.github/releases/README.md
+++ b/.github/releases/README.md
@@ -6,6 +6,96 @@ tag namespaces, build-time version sites, builder workflow, and change paths.
It intentionally does not describe signing, packaging, or registry publishing;
those remain owned by each component workflow.
+## Release Please components and their release notes
+
+Every package below gets a Release Please release PR, a generated
+`CHANGELOG.md`, an immutable `<component>-v<version>` tag, and a GitHub
+release whose body credits contributors. Release Please only prepares the PR,
+changelog, tag and draft release; each package's own CD workflow (started by
+the tag push) still builds and publishes.
+
+The release body is the same one Cua Driver and Lume use:
+`release_attribution.py collect` builds a pull-request-first manifest of the
+tag range (authors, coauthors, and reporters of closed issues, resolved to
+GitHub handles), and `render` writes Summary, Features/Fixes with per-change
+thanks, a Contributors section that @-mentions every external contributor, and
+the full-changelog link. GitHub draws the release's contributor avatars from
+those @-mentions. Cua Driver and Lume render it inside their CD release job.
+For every other component, `release-notes.yml` renders it when the stable tag
+is pushed and replaces only the release body (draft or published), using
+`release_notes.py`, which reads the package's path, exclusions and changelog
+from `release-please-config.json`. On a release PR, `CI: Release metadata`
+runs the same render first, so a changelog or attribution problem fails there
+rather than at release time. If the job fails after tagging, the release keeps
+Release Please's changelog; fix the cause and re-run **Release: Changelog and
+contributor notes** with the tag.
+
+| Package | Release Please path | Tag | Builds and publishes |
+|---|---|---|---|
+| Cua Driver (Rust, Python, npm) | `libs/cua-driver` | `cua-driver-rs-v*` | `cd-rust-cua-driver.yml` (renders its own notes) |
+| Cua Perception | `libs/cua-driver/rust/crates/cua-perception` | `cua-perception-v*` | `cd-cua-perception.yml` |
+| Lume | `libs/lume` | `lume-v*` | `cd-swift-lume.yml` (renders its own notes) |
+| Cua Spaces (macOS, Electron, Tauri) | `apps/cua-spaces-macos` | `cua-spaces-v*` | `cd-cua-spaces.yml` |
+| cua SDK and `cua` CLI | `libs/cua` | `cua-sdk-v*` | `cd-cua-sdk.yml` |
+| cua-spacesd | `libs/cua-spacesd` | `cua-spacesd-v*` | `cd-cua-spacesd.yml` |
+| cua-sandbox (PyPI) | `libs/python/cua-sandbox` | `sandbox-v*` | publish the draft; `cd-py-sandbox.yml` |
+| cua-agent (PyPI) | `libs/python/agent` | `agent-v*` | `cd-py-agent.yml` |
+| cua-core (PyPI) | `libs/python/core` | `core-v*` | `cd-py-core.yml` |
+| cua-bench (PyPI) | `libs/cua-bench` | `bench-v*` | `cd-py-bench.yml` |
+| cua-bench-ui (PyPI) | `libs/python/bench-ui` | `bench-ui-v*` | `cd-py-bench-ui.yml` |
+| cua-som (PyPI) | `libs/python/som` | `som-v*` | `cd-py-som.yml` |
+| cua-sandbox-apps (PyPI) | `libs/python/cua-sandbox-apps` | `sandbox-apps-v*` | `cd-py-sandbox-apps.yml` |
+| cua-train (PyPI) | `libs/python/cua-train` | `train-v*` | `cd-py-train.yml` |
+| @trycua/core (npm) | `libs/typescript/core` | `npm-core-v*` | `cd-ts-core.yml` |
+| @trycua/playground (npm) | `libs/typescript/playground` | `npm-playground-v*` | `cd-ts-playground.yml` |
+| cuabot (npm) | `libs/cuabot` | `cuabot-v*` | `cd-ts-cuabot.yml` |
+
+The PyPI and npm packages above moved off the legacy bump2version workflow with
+their tag formats and versions unchanged. Their CD workflows publish through
+`release-github-reusable.yml`, which now uploads to and publishes the Release
+Please draft for the tag instead of creating a second release (and still
+creates one for a tag without a draft). Release Please bumps
+`pyproject.toml`/`package.json` and the `uv.lock` entries that record the
+package; `validate_release_versions.py --product packages` keeps them equal to
+the manifest.
+
+The first Release Please release after each package's last legacy tag (listed
+in `release_notes.py` as `LEGACY_BASELINE_TAGS`) can have a short changelog:
+Release Please searches only the newest 500 merges and drops the file list of
+the 5,276-file launch merge (#4397). Its GitHub release notes still list every
+change, because they come from git; the changelog-citation check resumes with
+the next release. Check that release PR's version against the notes: for
+cua-sandbox-apps, #4397 is a `feat`, so prepare it with
+**Release: Prepare component releases** (component `sandbox-apps`, bump
+`minor`) for 0.2.0 rather than the 0.1.3 Release Please proposes.
+
+To release one of them: merge pull requests with conventional titles
+(`fix(core): ...`, `feat(agent): ...`); Release Please opens or updates
+`chore(main): release <component> <version>`. Review the version and changelog
+and merge it. The tag push starts the CD workflow and `release-notes.yml`. To
+force a bump, run **Release: Prepare component releases** with the component
+and bump type. Cua Sandbox's draft is published by hand, which starts its PyPI
+workflow; the others publish themselves.
+
+Not on Release Please: the Docker images (`docker-*-v*`, still on
+**Legacy packages: Bump Version**, with no GitHub release pages), `@trycua/fleet`
+and `cua-fleet` (Fleets is shut down), the OS images (`linux-image-v*`,
+`omarchy-image-v*` and the image pipelines' own date versions), and the
+`cua-install-latest`/`cua-spaces-latest` rolling feeds.
+
+### Cua Spaces betas
+
+Betas are cut by pushing a `cua-spaces-vX.Y.Z-beta.N` tag by hand on the
+commit to test. `cd-cua-spaces.yml` creates a draft prerelease for it, builds,
+signs and publishes it as a `beta` Sparkle item with its own notes. Release
+Please ignores prerelease tags: it looks for the previous stable
+`cua-spaces-v*` release, so betas never move the manifest version, never
+appear in the release PR, and `release-notes.yml` skips them. When the soak
+ends, merging the open `chore(main): release cua-spaces X.Y.Z` PR tags the
+stable release from main, and its notes cover everything since the previous
+stable release. Release Please 17.3.0 has no `additional-paths` option, so the
+`cua-spaces` changelog counts commits under `apps/cua-spaces-macos` only.
+
## cua-perception releases
`cua-perception` has an independent version and changelog beside its Rust crate
diff --git a/.github/scripts/merge_release_please_manifests.py b/.github/scripts/merge_release_please_manifests.py
index 6f5f55c407..e9dc629efc 100644
--- a/.github/scripts/merge_release_please_manifests.py
+++ b/.github/scripts/merge_release_please_manifests.py
@@ -17,6 +17,16 @@ COMPONENT_PATHS = {
"cua-spacesd": "libs/cua-spacesd",
"cua-sdk": "libs/cua",
"cua-spaces": "apps/cua-spaces-macos",
+ "agent": "libs/python/agent",
+ "core": "libs/python/core",
+ "bench": "libs/cua-bench",
+ "bench-ui": "libs/python/bench-ui",
+ "som": "libs/python/som",
+ "sandbox-apps": "libs/python/cua-sandbox-apps",
+ "train": "libs/python/cua-train",
+ "npm-core": "libs/typescript/core",
+ "npm-playground": "libs/typescript/playground",
+ "cuabot": "libs/cuabot",
}
diff --git a/.github/scripts/release_notes.py b/.github/scripts/release_notes.py
new file mode 100644
index 0000000000..288a4c3b4a
--- /dev/null
+++ b/.github/scripts/release_notes.py
@@ -0,0 +1,334 @@
+#!/usr/bin/env python3
+"""Give a Release Please component's GitHub release the Cua Driver/Lume notes.
+
+Cua Driver and Lume render their release body in their own CD release job:
+`release_attribution.py collect` builds a PR-first manifest of the tag range,
+and `render` turns it into the body with Summary, Features/Fixes, a
+Contributors section that @-mentions every external contributor (GitHub draws
+the release's contributor avatars from those mentions), and the full changelog
+link. Every other Release Please component gets the same body from
+`.github/workflows/release-notes.yml` through this script:
+
+ release_notes.py plan --tag cua-sdk-v0.4.2
+ release_notes.py render --tag cua-sdk-v0.4.2 --sha <sha> --repository trycua/cua --out-dir out
+ release_notes.py apply --tag cua-sdk-v0.4.2 --repository trycua/cua --body out/release-body.md
+
+`publish-draft` lets a legacy CD workflow publish the Release Please draft it
+built assets for, instead of creating a second release for the same tag.
+
+The component, its paths, exclusions and changelog all come from
+`release-please-config.json`, so the notes cover exactly the commits Release
+Please put in the changelog. Prerelease tags (a Spaces beta) are not managed
+here: they keep the notes their CD workflow writes.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+import re
+import sys
+import time
+from typing import Any, Mapping, Sequence
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import release_attribution # noqa: E402
+from github_release import GitHubApi, ReleaseError, releases_by_tag, upload_assets # noqa: E402
+
+
+STABLE_VERSION_RE = re.compile(r"^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$")
+# These render and publish their body inside their own CD release job.
+SELF_RENDERED = {"cua-driver-rs", "lume", "cua-perception"}
+DISPLAY_NAMES = {
+ "cua-spaces": "Cua Spaces",
+ "cua-sdk": "cua SDK",
+ "cua-spacesd": "cua-spacesd",
+ "sandbox": "Cua Sandbox",
+ "agent": "Cua Agent",
+ "core": "Cua Core",
+ "bench": "Cua Bench",
+ "bench-ui": "Cua Bench UI",
+ "som": "Cua SOM",
+ "sandbox-apps": "Cua Sandbox Apps",
+ "train": "Cua Train",
+ "npm-core": "@trycua/core",
+ "npm-playground": "@trycua/playground",
+ "cuabot": "CuaBot",
+}
+# component -> (registry, package); the footer names the exact published version.
+INSTALL = {
+ "cua-sdk": (("pypi", "cua"), ("npm", "@trycua/cua")),
+ "sandbox": (("pypi", "cua-sandbox"),),
+ "agent": (("pypi", "cua-agent"),),
+ "core": (("pypi", "cua-core"),),
+ "bench": (("pypi", "cua-bench"),),
+ "bench-ui": (("pypi", "cua-bench-ui"),),
+ "som": (("pypi", "cua-som"),),
+ "sandbox-apps": (("pypi", "cua-sandbox-apps"),),
+ "train": (("pypi", "cua-train"),),
+ "npm-core": (("npm", "@trycua/core"),),
+ "npm-playground": (("npm", "@trycua/playground"),),
+ "cuabot": (("npm", "cuabot"),),
+}
+
+
+# The last bump2version tag of each package that moved to Release Please. The
+# first Release Please changelog after one of them can miss changes: Release
+# Please only searches the newest 500 merges and loses the file list of a
+# commit over GitHub's 3,000-file limit (the launch merge #4397). For that one
+# release the notes come from git alone, so they still list every change; the
+# check that the changelog cites each pull request starts with the next one.
+LEGACY_BASELINE_TAGS = frozenset({
+ "agent-v0.9.0",
+ "core-v0.3.2",
+ "bench-v0.3.0",
+ "bench-ui-v0.7.1",
+ "som-v0.1.4",
+ "sandbox-apps-v0.1.2",
+ "train-v0.1.2",
+ "npm-core-v0.1.6",
+ "npm-playground-v0.3.0",
+ "cuabot-v1.0.16",
+})
+
+
+def load_config(repo_root: Path) -> Mapping[str, Any]:
+ return json.loads((repo_root / "release-please-config.json").read_text())
+
+
+def resolve_tag(config: Mapping[str, Any], tag: str) -> dict[str, Any] | None:
+ """The Release Please package a stable component tag belongs to, if any."""
+ if config.get("include-component-in-tag") is not True or config.get("tag-separator") != "-":
+ raise ReleaseError("release-please-config.json must tag as <component>-v<version>")
+ matches = []
+ for path, package in config["packages"].items():
+ component = str(package["component"])
+ prefix = f"{component}-v"
+ if not tag.startswith(prefix):
+ continue
+ version = tag[len(prefix):]
+ if STABLE_VERSION_RE.fullmatch(version):
+ matches.append((path, package, component, prefix, version))
+ if not matches:
+ return None
+ if len(matches) > 1:
+ raise ReleaseError(f"tag {tag} matches several components: {[m[2] for m in matches]}")
+ path, package, component, prefix, version = matches[0]
+ # Release Please gives each changed file to the most specific package path,
+ # so a package nested under this one owns its own commits.
+ nested = [other for other in config["packages"] if other != path and other.startswith(f"{path}/")]
+ return {
+ "component": component,
+ "display_name": DISPLAY_NAMES.get(component, component),
+ "version": version,
+ "tag": tag,
+ "tag_prefix": prefix,
+ # The pinned release-please 17.3.0 has no `additional-paths` support
+ # (the key is ignored), so the changelog covers the package path only.
+ "paths": [path],
+ "exclude_paths": [*package.get("exclude-paths", []), *nested],
+ "changelog": f"{path}/{package.get('changelog-path', 'CHANGELOG.md')}",
+ "self_rendered": component in SELF_RENDERED,
+ }
+
+
+def install_footer(component: str, version: str) -> str:
+ lines = []
+ for registry, name in INSTALL.get(component, ()):
+ if registry == "pypi":
+ lines.append(f'pip install "{name}=={version}"')
+ else:
+ lines.append(f"npm install {name}@{version}")
+ if not lines:
+ return ""
+ return "## Install\n\n```bash\n" + "\n".join(lines) + "\n```\n"
+
+
+def render(
+ *,
+ repo_root: Path,
+ repository: str,
+ tag: str,
+ sha: str,
+ out_dir: Path,
+ ref: str | None,
+ github: release_attribution.GitHubClient | None = None,
+) -> Path:
+ plan = resolve_tag(load_config(repo_root), tag)
+ if plan is None or plan["self_rendered"]:
+ raise ReleaseError(f"{tag} is not a stable tag of a component this script renders")
+ attribution = json.loads((repo_root / ".github/release-attribution-config.json").read_text())
+ previous = release_attribution.find_previous_tag(repo_root, tag, plan["tag_prefix"])
+ client = github or release_attribution.GitHubClient(
+ os.environ.get("GH_TOKEN", ""), os.environ.get("GITHUB_API_URL", "https://api.github.com")
+ )
+ cites_every_change = release_attribution.changelog_references_change
+ if previous in LEGACY_BASELINE_TAGS:
+ print(f"{previous} is a legacy baseline: not requiring the changelog to cite every change")
+ release_attribution.changelog_references_change = lambda *_args: True
+ try:
+ manifest = _build(plan, repo_root, repository, tag, previous, sha, attribution, client, ref)
+ finally:
+ release_attribution.changelog_references_change = cites_every_change
+ body = release_attribution.render_body(manifest, install_footer(plan["component"], plan["version"]))
+ if len(body.encode()) > 125_000:
+ raise ReleaseError("rendered GitHub release body exceeds 125,000 bytes")
+ out_dir.mkdir(parents=True, exist_ok=True)
+ release_attribution.write_json(out_dir / "release-manifest.json", manifest)
+ body_path = out_dir / "release-body.md"
+ body_path.write_text(body)
+ print(f"rendered {tag}: {len(manifest['changes'])} changes, "
+ f"{sum(1 for c in manifest['contributors'] if c.get('external'))} external contributors")
+ return body_path
+
+
+def _build(plan, repo_root, repository, tag, previous, sha, attribution, client, ref):
+ return release_attribution.build_manifest(
+ repo_root=repo_root,
+ repository=repository,
+ product=plan["component"],
+ display_name=plan["display_name"],
+ version=plan["version"],
+ tag=tag,
+ previous_tag=previous,
+ expected_sha=sha,
+ paths=plan["paths"],
+ changelog_path=(repo_root / plan["changelog"]).resolve(),
+ attribution_config=attribution,
+ github=client,
+ release_ref=ref,
+ exclude_paths=plan["exclude_paths"],
+ )
+
+
+def wait_for_release(api: Any, repository: str, tag: str, attempts: int, delay: float) -> dict[str, Any]:
+ """Release Please creates the draft and its tag together; allow a short lag."""
+ for attempt in range(1, attempts + 1):
+ matches = releases_by_tag(api, repository, tag)
+ if len(matches) > 1:
+ raise ReleaseError(f"expected one GitHub release for {tag}, found {[m.get('id') for m in matches]}")
+ if matches:
+ return matches[0]
+ if attempt < attempts:
+ time.sleep(delay)
+ raise ReleaseError(f"no GitHub release exists for {tag}")
+
+
+def apply(api: Any, repository: str, tag: str, body: str, *, attempts: int = 20, delay: float = 15) -> bool:
+ """Replace only the release body; draft, prerelease and assets stay as they are."""
+ release = wait_for_release(api, repository, tag, attempts, delay)
+ if str(release.get("body") or "") == body:
+ print(f"{tag} already has the rendered notes")
+ return False
+ api.patch(f"repos/{repository}/releases/{release['id']}", {"body": body})
+ print(f"updated the notes of {tag} ({'draft' if release.get('draft') else 'published'})")
+ return True
+
+
+def publish_draft(
+ api: Any,
+ repository: str,
+ tag: str,
+ *,
+ asset_dir: Path | None,
+ prerelease: bool,
+ name: str | None = None,
+) -> bool:
+ """Publish the Release Please draft for `tag`; False when there is none.
+
+ Keeps the draft's body (Release Please's changelog, or the rendered notes)
+ and never makes a monorepo component the repository-wide Latest release.
+ """
+ matches = releases_by_tag(api, repository, tag)
+ if not matches:
+ return False
+ if len(matches) > 1:
+ raise ReleaseError(f"expected one GitHub release for {tag}, found {[m.get('id') for m in matches]}")
+ release = matches[0]
+ if asset_dir is not None and asset_dir.is_dir() and any(p.is_file() for p in asset_dir.iterdir()):
+ upload_assets(api, repository, release, asset_dir)
+ if release.get("draft"):
+ fields: dict[str, Any] = {"draft": False, "prerelease": prerelease, "make_latest": "false"}
+ if name:
+ fields["name"] = name
+ api.patch(f"repos/{repository}/releases/{release['id']}", fields)
+ print(f"published the Release Please draft for {tag}")
+ else:
+ print(f"{tag} is already published")
+ return True
+
+
+def write_output(name: str, value: str) -> None:
+ output = os.environ.get("GITHUB_OUTPUT")
+ if output:
+ with open(output, "a") as handle:
+ handle.write(f"{name}={value}\n")
+ print(f"{name}={value}")
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+ parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+ parser.add_argument("--repo-root", type=Path, default=Path.cwd())
+ sub = parser.add_subparsers(dest="command", required=True)
+ plan_cmd = sub.add_parser("plan")
+ plan_cmd.add_argument("--tag", required=True)
+ render_cmd = sub.add_parser("render")
+ render_cmd.add_argument("--tag", required=True)
+ render_cmd.add_argument("--sha", required=True)
+ render_cmd.add_argument("--repository", required=True)
+ render_cmd.add_argument("--out-dir", type=Path, required=True)
+ render_cmd.add_argument("--ref", help="git ref to read before the tag exists (a release PR head)")
+ apply_cmd = sub.add_parser("apply")
+ apply_cmd.add_argument("--tag", required=True)
+ apply_cmd.add_argument("--repository", required=True)
+ apply_cmd.add_argument("--body", type=Path, required=True)
+ publish_cmd = sub.add_parser("publish-draft")
+ publish_cmd.add_argument("--tag", required=True)
+ publish_cmd.add_argument("--repository", required=True)
+ publish_cmd.add_argument("--asset-dir", type=Path)
+ publish_cmd.add_argument("--prerelease", action="store_true")
+ publish_cmd.add_argument("--name", help="release title (the legacy CD workflow's release_name)")
+ args = parser.parse_args(argv)
+ repo_root = args.repo_root.resolve()
+ try:
+ if args.command == "plan":
+ plan = resolve_tag(load_config(repo_root), args.tag)
+ managed = plan is not None and not plan["self_rendered"]
+ write_output("render", "true" if managed else "false")
+ if managed:
+ write_output("component", plan["component"])
+ write_output("version", plan["version"])
+ elif args.command == "render":
+ render(
+ repo_root=repo_root,
+ repository=args.repository,
+ tag=args.tag,
+ sha=args.sha,
+ out_dir=args.out_dir,
+ ref=args.ref,
+ )
+ elif args.command == "apply":
+ api = GitHubApi(os.environ.get("GH_TOKEN", ""), os.environ.get("GITHUB_API_URL", "https://api.github.com"))
+ apply(api, args.repository, args.tag, args.body.read_text())
+ else:
+ api = GitHubApi(os.environ.get("GH_TOKEN", ""), os.environ.get("GITHUB_API_URL", "https://api.github.com"))
+ adopted = publish_draft(
+ api,
+ args.repository,
+ args.tag,
+ asset_dir=args.asset_dir,
+ prerelease=args.prerelease,
+ name=args.name,
+ )
+ write_output("adopted", "true" if adopted else "false")
+ except (ReleaseError, release_attribution.ReleaseError) as error:
+ print(f"release notes error: {error}", file=sys.stderr)
+ return 1
+ return 0
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/.github/scripts/resolve_release_please_request.py b/.github/scripts/resolve_release_please_request.py
index 1de79677c3..d29532391e 100644
--- a/.github/scripts/resolve_release_please_request.py
+++ b/.github/scripts/resolve_release_please_request.py
@@ -18,6 +18,16 @@ COMPONENT_PATHS = {
"cua-spacesd": "libs/cua-spacesd",
"cua-sdk": "libs/cua",
"cua-spaces": "apps/cua-spaces-macos",
+ "agent": "libs/python/agent",
+ "core": "libs/python/core",
+ "bench": "libs/cua-bench",
+ "bench-ui": "libs/python/bench-ui",
+ "som": "libs/python/som",
+ "sandbox-apps": "libs/python/cua-sandbox-apps",
+ "train": "libs/python/cua-train",
+ "npm-core": "libs/typescript/core",
+ "npm-playground": "libs/typescript/playground",
+ "cuabot": "libs/cuabot",
}
SEMVER = re.compile(r"^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$")
BUMP_TYPES = {"automatic", "patch", "minor", "major"}
diff --git a/.github/scripts/tests/release_please_enrolled_preview.cjs b/.github/scripts/tests/release_please_enrolled_preview.cjs
new file mode 100644
index 0000000000..f2972cfa4b
--- /dev/null
+++ b/.github/scripts/tests/release_please_enrolled_preview.cjs
@@ -0,0 +1,137 @@
+// Offline: exercise the pinned Release Please engine for the PyPI and npm
+// packages that moved from the legacy bump2version workflow (CUA-1531).
+// For each package: a fix bumps the patch, a feat the minor, a docs commit
+// releases nothing, the tag keeps its legacy format, and only that package's
+// version files (plus the lockfiles that record it) change.
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { buildStrategy } = require('release-please/build/src/factory');
+const { parseConventionalCommits } = require('release-please/build/src/commit');
+const { TagName } = require('release-please/build/src/util/tag-name');
+const { CommitSplit } = require('release-please/build/src/util/commit-split');
+
+const root = path.resolve(__dirname, '../../..');
+const config = JSON.parse(fs.readFileSync(path.join(root, 'release-please-config.json')));
+const manifest = JSON.parse(fs.readFileSync(path.join(root, '.release-please-manifest.json')));
+
+// path -> [legacy tag prefix, a source file inside it, files the release PR must update]
+const PACKAGES = {
+ 'libs/python/agent': ['agent-v', 'cua_agent/__init__.py',
+ ['libs/python/agent/CHANGELOG.md', 'libs/python/agent/pyproject.toml', 'uv.lock', 'libs/cua-bench/uv.lock']],
+ 'libs/python/core': ['core-v', 'cua_core/__init__.py',
+ ['libs/python/core/CHANGELOG.md', 'libs/python/core/pyproject.toml', 'uv.lock', 'libs/cua-bench/uv.lock']],
+ 'libs/cua-bench': ['bench-v', 'cua_bench/__init__.py',
+ ['libs/cua-bench/CHANGELOG.md', 'libs/cua-bench/pyproject.toml', 'libs/cua-bench/uv.lock']],
+ 'libs/python/bench-ui': ['bench-ui-v', 'bench_ui/__init__.py',
+ ['libs/python/bench-ui/CHANGELOG.md', 'libs/python/bench-ui/pyproject.toml', 'uv.lock']],
+ 'libs/python/som': ['som-v', 'som/__init__.py',
+ ['libs/python/som/CHANGELOG.md', 'libs/python/som/pyproject.toml', 'uv.lock']],
+ 'libs/python/cua-sandbox-apps': ['sandbox-apps-v', 'cua_sandbox_apps/__init__.py',
+ ['libs/python/cua-sandbox-apps/CHANGELOG.md', 'libs/python/cua-sandbox-apps/pyproject.toml',
+ 'libs/python/cua-sandbox-apps/uv.lock']],
+ 'libs/python/cua-train': ['train-v', 'src/cua_train/__init__.py',
+ ['libs/python/cua-train/CHANGELOG.md', 'libs/python/cua-train/pyproject.toml']],
+ 'libs/typescript/core': ['npm-core-v', 'src/index.ts',
+ ['libs/typescript/core/CHANGELOG.md', 'libs/typescript/core/package.json']],
+ 'libs/typescript/playground': ['npm-playground-v', 'src/index.ts',
+ ['libs/typescript/playground/CHANGELOG.md', 'libs/typescript/playground/package.json']],
+ 'libs/cuabot': ['cuabot-v', 'src/index.ts',
+ ['libs/cuabot/CHANGELOG.md', 'libs/cuabot/package.json']],
+};
+
+function optionsFor(packagePath) {
+ const merged = { ...config, ...config.packages[packagePath] };
+ delete merged.packages;
+ return Object.fromEntries(Object.entries(merged)
+ .map(([key, value]) => [key.replace(/-([a-z])/g, (_, c) => c.toUpperCase()), value]));
+}
+
+function read(file) {
+ const full = path.join(root, file);
+ return fs.existsSync(full) ? fs.readFileSync(full, 'utf8') : '';
+}
+
+function versionOf(packagePath) {
+ const pyproject = read(`${packagePath}/pyproject.toml`);
+ if (pyproject) return pyproject.match(/^version = "([^"]+)"$/m)[1];
+ return JSON.parse(read(`${packagePath}/package.json`)).version;
+}
+
+async function preview(packagePath, message, expectedVersion) {
+ const [prefix, sourceFile, expectedFiles] = PACKAGES[packagePath];
+ const strategy = await buildStrategy({
+ ...optionsFor(packagePath),
+ path: packagePath,
+ targetBranch: 'main',
+ github: {
+ repository: { owner: 'example', repo: 'repo', defaultBranch: 'main' },
+ // The node and python strategies read package metadata through the client.
+ getFileContentsOnBranch: async file => ({ parsedContent: read(file) }),
+ },
+ });
+ const current = manifest[packagePath];
+ const release = await strategy.buildReleasePullRequest(parseConventionalCommits([
+ { sha: 'a'.repeat(40), message, files: [`${packagePath}/${sourceFile}`] },
+ ]), { tag: TagName.parse(`${prefix}${current}`), sha: 'b'.repeat(40), notes: '' });
+ if (expectedVersion === null) {
+ assert.equal(release, undefined, `${packagePath}: ${message} must not release`);
+ return null;
+ }
+ assert.equal(release.version.toString(), expectedVersion, packagePath);
+ const component = config.packages[packagePath].component;
+ assert.equal(`${component}-v`, prefix, `${packagePath} keeps its legacy tag prefix`);
+ assert.match(release.headRefName, new RegExp(`components--${component}$`));
+ const updates = {};
+ for (const update of release.updates) {
+ const before = read(update.path);
+ if (!before && !update.createIfMissing) continue; // optional updaters for absent files
+ updates[update.path] = update.updater.updateContent(before);
+ }
+ const changed = Object.keys(updates).filter(file => updates[file] !== read(file)).sort();
+ assert.deepEqual(changed, [...expectedFiles].sort(), `${packagePath} release PR files`);
+ for (const file of changed.filter(f => !f.endsWith('CHANGELOG.md'))) {
+ assert.ok(updates[file].includes(expectedVersion), `${file} carries ${expectedVersion}`);
+ // Only the package's own version moves: no other line changes.
+ const before = read(file).split('\n');
+ const after = updates[file].split('\n');
+ const diff = after.filter((line, i) => line !== before[i]);
+ assert.ok(diff.length >= 1 && diff.length <= 2, `${file} changes ${diff.length} lines`);
+ }
+ assert.ok(updates[`${packagePath}/CHANGELOG.md`].includes(`${prefix}${expectedVersion}`));
+ return { path: packagePath, message, tag: `${prefix}${expectedVersion}`, files: changed };
+}
+
+function bumped(version, kind) {
+ const [major, minor, patch] = version.split('.').map(Number);
+ if (kind === 'patch') return `${major}.${minor}.${patch + 1}`;
+ if (kind === 'minor' || major === 0) return `${major}.${minor + 1}.0`;
+ return `${major + 1}.0.0`;
+}
+
+async function main() {
+ // A commit in a sibling directory that shares a name prefix must not leak.
+ const split = new CommitSplit({ packagePaths: Object.keys(config.packages) });
+ const leaked = split.split([
+ { sha: 'c'.repeat(40), message: 'fix: x', files: ['libs/cua-bench-rl/a.py'] },
+ { sha: 'd'.repeat(40), message: 'fix: y', files: ['libs/python/cua-sandbox/z.py'] },
+ ]);
+ assert.equal(leaked['libs/cua-bench'], undefined, 'libs/cua-bench-rl must not bump cua-bench');
+ assert.equal(leaked['libs/python/cua-sandbox-apps'], undefined,
+ 'libs/python/cua-sandbox must not bump sandbox-apps');
+
+ for (const packagePath of Object.keys(PACKAGES)) {
+ assert.ok(config.packages[packagePath], `${packagePath} is enrolled`);
+ const current = manifest[packagePath];
+ assert.equal(current, versionOf(packagePath), `${packagePath} manifest matches its source`);
+ const results = [
+ await preview(packagePath, 'fix: correct a behavior', bumped(current, 'patch')),
+ await preview(packagePath, 'feat: add a capability', bumped(current, 'minor')),
+ await preview(packagePath, 'feat!: change a contract', bumped(current, 'major')),
+ await preview(packagePath, 'docs: clarify setup', null),
+ ];
+ for (const result of results.filter(Boolean)) console.log(JSON.stringify(result));
+ }
+}
+
+main().catch(error => { console.error(error); process.exitCode = 1; });
diff --git a/.github/scripts/tests/test_cua_sandbox_release_wiring.py b/.github/scripts/tests/test_cua_sandbox_release_wiring.py
index d136c13098..2010f94dd0 100644
--- a/.github/scripts/tests/test_cua_sandbox_release_wiring.py
+++ b/.github/scripts/tests/test_cua_sandbox_release_wiring.py
@@ -44,7 +44,7 @@ class TestCuaSandboxReleaseWiring(unittest.TestCase):
self.assertNotIn(" - pypi/sandbox\n", workflow)
self.assertNotIn('"pypi/sandbox")', workflow)
self.assertNotIn("id: sandbox_version", workflow)
- self.assertIn(" - pypi/sandbox-apps\n", workflow)
+ self.assertNotIn(" - pypi/sandbox-apps\n", workflow)
auto_release = (REPO_ROOT / ".github/workflows/release-on-merge.yml").read_text()
self.assertNotIn('["libs/python/cua-sandbox/"]', auto_release)
diff --git a/.github/scripts/tests/test_release_notes.py b/.github/scripts/tests/test_release_notes.py
new file mode 100644
index 0000000000..fba736944e
--- /dev/null
+++ b/.github/scripts/tests/test_release_notes.py
@@ -0,0 +1,221 @@
+"""Release Please components get Cua Driver/Lume release notes (CUA-1531)."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import re
+
+import pytest
+
+import release_notes
+import resolve_release_please_request
+import validate_release_versions
+from github_release import ReleaseError
+
+
+ROOT = Path(__file__).resolve().parents[3]
+CONFIG = json.loads((ROOT / "release-please-config.json").read_text())
+MANIFEST = json.loads((ROOT / ".release-please-manifest.json").read_text())
+WORKFLOWS = ROOT / ".github/workflows"
+ENROLLED = {
+ "libs/python/agent": "agent",
+ "libs/python/core": "core",
+ "libs/cua-bench": "bench",
+ "libs/python/bench-ui": "bench-ui",
+ "libs/python/som": "som",
+ "libs/python/cua-sandbox-apps": "sandbox-apps",
+ "libs/python/cua-train": "train",
+ "libs/typescript/core": "npm-core",
+ "libs/typescript/playground": "npm-playground",
+ "libs/cuabot": "cuabot",
+}
+
+
+def components() -> dict[str, str]:
+ return {package["component"]: path for path, package in CONFIG["packages"].items()}
+
+
+ ("tag", "component", "paths", "excludes"),
+ [
+ ("cua-sdk-v0.4.2", "cua-sdk", ["libs/cua"], ["libs/cua/proto/MEDIA.md", "libs/cua/README.md"]),
+ # additional-paths is not a release-please 17.3.0 option: the changelog
+ # covers the package path only, so the notes do too.
+ ("cua-spaces-v0.8.0", "cua-spaces", ["apps/cua-spaces-macos"], []),
+ ("cua-spacesd-v0.5.4", "cua-spacesd", ["libs/cua-spacesd"], None),
+ ("sandbox-v0.9.1", "sandbox", ["libs/python/cua-sandbox"], []),
+ ("sandbox-apps-v0.1.3", "sandbox-apps", ["libs/python/cua-sandbox-apps"], []),
+ ("bench-v0.3.1", "bench", ["libs/cua-bench"], []),
+ ("bench-ui-v0.7.2", "bench-ui", ["libs/python/bench-ui"], []),
+ ("core-v0.3.3", "core", ["libs/python/core"], []),
+ ("npm-core-v0.1.7", "npm-core", ["libs/typescript/core"], []),
+ ("cuabot-v1.0.17", "cuabot", ["libs/cuabot"], None),
+ ],
+)
+def test_stable_tags_resolve_to_exactly_their_release_please_package(tag, component, paths, excludes):
+ plan = release_notes.resolve_tag(CONFIG, tag)
+ assert plan["component"] == component
+ assert plan["paths"] == paths
+ assert not plan["self_rendered"]
+ assert plan["changelog"] == f"{paths[0]}/CHANGELOG.md"
+ if excludes is not None:
+ assert plan["exclude_paths"] == excludes
+
+
+def test_nested_release_please_packages_are_excluded_from_their_parent():
+ plan = release_notes.resolve_tag(CONFIG, "cua-driver-rs-v0.35.3")
+ assert "libs/cua-driver/rust/crates/cua-perception" in plan["exclude_paths"]
+ assert plan["self_rendered"]
+
+
+ "tag",
+ [
+ "cua-spaces-v0.8.0-beta.6", # betas keep the notes their CD workflow writes
+ "docker-cuabot-v1.0.7", # Docker images stay on the legacy bump
+ "nightly-lume-v0.6.2-nightly.20261009.1",
+ "fleet-v0.1.18",
+ "cua-spaces-latest",
+ ],
+)
+def test_prerelease_and_unmanaged_tags_are_not_rendered(tag):
+ assert release_notes.resolve_tag(CONFIG, tag) is None
+
+
+def test_every_component_has_one_owner_for_its_release_notes():
+ triggers = re.findall(r'^ - "([^"]+)-v\*"$', (WORKFLOWS / "release-notes.yml").read_text(), re.M)
+ for component in components():
+ if component in release_notes.SELF_RENDERED:
+ assert component not in triggers
+ else:
+ assert component in release_notes.DISPLAY_NAMES
+ assert component in triggers, f"release-notes.yml does not run for {component} tags"
+ assert set(triggers) <= set(components())
+
+
+def test_enrolled_packages_keep_their_legacy_tag_and_current_version():
+ for path, component in ENROLLED.items():
+ package = CONFIG["packages"][path]
+ assert package["component"] == component
+ assert package["release-type"] == "simple"
+ assert package["bump-minor-pre-major"] is True
+ pyproject = ROOT / path / "pyproject.toml"
+ if pyproject.exists():
+ current = re.search(r'^version = "([^"]+)"$', pyproject.read_text(), re.M).group(1)
+ else:
+ current = json.loads((ROOT / path / "package.json").read_text())["version"]
+ assert MANIFEST[path] == current
+ assert not (ROOT / path / ".bumpversion.cfg").exists()
+
+
+def test_legacy_bump_workflows_no_longer_release_enrolled_packages():
+ services = ["pypi/agent", "pypi/bench", "pypi/bench-ui", "pypi/core", "pypi/sandbox-apps",
+ "pypi/som", "pypi/train", "npm/core", "npm/playground", "npm/cuabot"]
+ for workflow in ("release-bump-version.yml", "release-on-merge.yml",
+ "ci-release-reminder.yml", "release-unreleased-digest.yml"):
+ text = (WORKFLOWS / workflow).read_text()
+ for service in services:
+ assert f'"{service}"' not in text and f"- {service}\n" not in text, (workflow, service)
+ # Docker images (libs/cuabot's container among them) stay on the legacy bump.
+ assert " - docker/cuabot\n" in (WORKFLOWS / "release-bump-version.yml").read_text()
+ assert (ROOT / "libs/cuabot/.bumpversion.docker.cfg").exists()
+
+
+def test_targeted_release_requests_cover_every_component():
+ assert resolve_release_please_request.COMPONENT_PATHS == components()
+ workflow = (WORKFLOWS / "release-please.yml").read_text()
+ for component in components():
+ assert f" - {component}\n" in workflow
+
+
+def test_install_footer_names_the_released_version():
+ footer = release_notes.install_footer("cua-sdk", "0.4.2")
+ assert 'pip install "cua==0.4.2"' in footer
+ assert "npm install @trycua/[email protected]" in footer
+ assert release_notes.install_footer("cua-spaces", "0.8.0") == ""
+
+
+class FakeApi:
+ def __init__(self, releases):
+ self.releases = releases
+ self.patches = []
+
+ def get(self, path):
+ assert "/releases?per_page=100" in path
+ return self.releases
+
+ def patch(self, path, body):
+ self.patches.append((path, body))
+ return {}
+
+
+def test_apply_replaces_only_the_body_of_a_draft():
+ api = FakeApi([{"id": 7, "tag_name": "cua-sdk-v0.4.2", "draft": True, "body": "rp"}])
+ assert release_notes.apply(api, "trycua/cua", "cua-sdk-v0.4.2", "rendered", attempts=1, delay=0)
+ assert api.patches == [("repos/trycua/cua/releases/7", {"body": "rendered"})]
+
+
+def test_apply_is_idempotent_and_refuses_a_missing_or_duplicated_release():
+ same = FakeApi([{"id": 7, "tag_name": "core-v0.3.3", "draft": False, "body": "rendered"}])
+ assert not release_notes.apply(same, "trycua/cua", "core-v0.3.3", "rendered", attempts=1, delay=0)
+ assert same.patches == []
+ with pytest.raises(ReleaseError, match="no GitHub release"):
+ release_notes.apply(FakeApi([]), "trycua/cua", "core-v0.3.3", "x", attempts=2, delay=0)
+ twice = FakeApi([{"id": 1, "tag_name": "core-v0.3.3"}, {"id": 2, "tag_name": "core-v0.3.3"}])
+ with pytest.raises(ReleaseError, match="expected one"):
+ release_notes.apply(twice, "trycua/cua", "core-v0.3.3", "x", attempts=1, delay=0)
+
+
+def test_publish_draft_keeps_the_body_and_never_takes_latest():
+ api = FakeApi([{"id": 9, "tag_name": "agent-v0.9.1", "draft": True, "body": "changelog"}])
+ assert release_notes.publish_draft(
+ api, "trycua/cua", "agent-v0.9.1", asset_dir=None, prerelease=False, name="cua-agent v0.9.1"
+ )
+ assert api.patches == [(
+ "repos/trycua/cua/releases/9",
+ {"draft": False, "prerelease": False, "make_latest": "false", "name": "cua-agent v0.9.1"},
+ )]
+ published = FakeApi([{"id": 9, "tag_name": "agent-v0.9.1", "draft": False}])
+ assert release_notes.publish_draft(published, "trycua/cua", "agent-v0.9.1", asset_dir=None, prerelease=False)
+ assert published.patches == []
+ # No draft: the legacy workflow creates the release as before.
+ assert not release_notes.publish_draft(FakeApi([]), "trycua/cua", "agent-v0.9.1", asset_dir=None, prerelease=False)
+
+
+def test_version_check_catches_a_package_file_that_drifted(tmp_path):
+ (tmp_path / "libs/python/core").mkdir(parents=True)
+ (tmp_path / "libs/python/core/pyproject.toml").write_text('[project]\nname = "cua-core"\nversion = "0.3.3"\n')
+ (tmp_path / "uv.lock").write_text('[[package]]\nname = "cua-core"\nversion = "0.3.2"\n')
+ package = CONFIG["packages"]["libs/python/core"]
+ values = {
+ extra["path"]: validate_release_versions.extra_file_version(tmp_path, "libs/python/core", extra)
+ for extra in package["extra-files"]
+ if not extra["path"].startswith("/libs/")
+ }
+ assert values == {"pyproject.toml": "0.3.3", "/uv.lock": "0.3.2"}
+ with pytest.raises(validate_release_versions.VersionError, match="mismatched"):
+ validate_release_versions.require_equal("core", "0.3.3", values)
+
+
+def test_legacy_baselines_are_exactly_the_enrolled_packages_last_legacy_tags():
+ expected = {f"{component}-v{MANIFEST[path]}" for path, component in ENROLLED.items()}
+ assert release_notes.LEGACY_BASELINE_TAGS == expected
+
+
+def test_only_a_legacy_baseline_relaxes_the_changelog_citation_check(monkeypatch, tmp_path):
+ seen = {}
+
+ def fake_build(plan, repo_root, repository, tag, previous, sha, attribution, client, ref):
+ seen[previous] = release_notes.release_attribution.changelog_references_change("", 1, [])
+ return {"changes": [], "contributors": [], "displayName": "x", "version": plan["version"],
+ "repository": repository, "tag": tag, "previousTag": previous, "compareUrl": "u"}
+
+ original = release_notes.release_attribution.changelog_references_change
+ monkeypatch.setattr(release_notes, "_build", fake_build)
+ for previous in ("sandbox-apps-v0.1.2", "sandbox-apps-v0.1.3"):
+ monkeypatch.setattr(release_notes.release_attribution, "find_previous_tag", lambda *_a, p=previous: p)
+ release_notes.render(repo_root=ROOT, repository="trycua/cua", tag="sandbox-apps-v0.1.4",
+ sha="a" * 40, out_dir=tmp_path, ref=None, github=object())
+ assert release_notes.release_attribution.changelog_references_change is original
+ assert seen == {"sandbox-apps-v0.1.2": True, "sandbox-apps-v0.1.3": False}
diff --git a/.github/scripts/tests/test_validate_release_versions.py b/.github/scripts/tests/test_validate_release_versions.py
index f8973c576c..14d6f1c030 100644
--- a/.github/scripts/tests/test_validate_release_versions.py
+++ b/.github/scripts/tests/test_validate_release_versions.py
@@ -22,6 +22,24 @@ def copy_release_sources(destination: Path) -> None:
(destination / config).parent.mkdir(parents=True, exist_ok=True)
shutil.copy(REPO_ROOT / config, destination / config)
shutil.copy(REPO_ROOT / ".release-please-manifest.json", destination)
+ shutil.copy(REPO_ROOT / "release-please-config.json", destination)
+ for relative in (
+ "uv.lock",
+ "libs/cua-bench/uv.lock",
+ "libs/cua-bench/pyproject.toml",
+ "libs/python/agent/pyproject.toml",
+ "libs/python/core/pyproject.toml",
+ "libs/python/bench-ui/pyproject.toml",
+ "libs/python/som/pyproject.toml",
+ "libs/python/cua-sandbox-apps/pyproject.toml",
+ "libs/python/cua-sandbox-apps/uv.lock",
+ "libs/python/cua-train/pyproject.toml",
+ "libs/typescript/core/package.json",
+ "libs/typescript/playground/package.json",
+ "libs/cuabot/package.json",
+ ):
+ (destination / relative).parent.mkdir(parents=True, exist_ok=True)
+ shutil.copy(REPO_ROOT / relative, destination / relative)
for filename in ("VERSION", "pyproject.toml", "uv.lock", "cua_sandbox/__init__.py"):
relative = Path("libs/python/cua-sandbox") / filename
(destination / relative).parent.mkdir(parents=True, exist_ok=True)
diff --git a/.github/scripts/validate_release_versions.py b/.github/scripts/validate_release_versions.py
index 46aa3e0907..4594b3be89 100644
--- a/.github/scripts/validate_release_versions.py
+++ b/.github/scripts/validate_release_versions.py
@@ -286,6 +286,65 @@ def spaces_app_versions(root: Path) -> tuple[str, dict[str, str]]:
}
+# Packages whose Release Please entry is the whole version contract: the
+# manifest version must equal every extra file Release Please bumps.
+CONFIG_ONLY_PACKAGES = (
+ "libs/python/agent",
+ "libs/python/core",
+ "libs/cua-bench",
+ "libs/python/bench-ui",
+ "libs/python/som",
+ "libs/python/cua-sandbox-apps",
+ "libs/python/cua-train",
+ "libs/typescript/core",
+ "libs/typescript/playground",
+ "libs/cuabot",
+)
+LOCK_ENTRY = re.compile(r"^\$\.package\[\?\(@\.name\.value=='([^']+)'\)\]\.version$")
+
+
+def extra_file_version(root: Path, package_path: str, extra: dict) -> str:
+ path = extra["path"]
+ file = root / path.lstrip("/") if path.startswith("/") else root / package_path / path
+ jsonpath = extra["jsonpath"]
+ if extra["type"] == "json":
+ data = json.loads(file.read_text())
+ elif extra["type"] == "toml":
+ data = tomllib.loads(file.read_text())
+ else:
+ raise VersionError(f"{package_path}: unsupported extra-file type {extra['type']}")
+ lock = LOCK_ENTRY.match(jsonpath)
+ if lock:
+ entries = [e for e in data.get("package", []) if e.get("name") == lock.group(1)]
+ if len(entries) != 1:
+ raise VersionError(f"{file.relative_to(root)} must lock {lock.group(1)} exactly once")
+ return str(entries[0]["version"])
+ node = data
+ for key in jsonpath.removeprefix("$.").split("."):
+ node = node[key]
+ return str(node)
+
+
+def config_only_package_versions(root: Path) -> dict[str, tuple[str, dict[str, str]]]:
+ config = json.loads((root / "release-please-config.json").read_text())
+ manifest = json.loads((root / ".release-please-manifest.json").read_text())
+ results = {}
+ for package_path in CONFIG_ONLY_PACKAGES:
+ package = config["packages"].get(package_path)
+ if package is None:
+ raise VersionError(f"{package_path} is not a Release Please package")
+ expected = str(manifest[package_path])
+ stable_version_tuple(expected)
+ values = {
+ f"{extra['path']}:{extra['jsonpath']}": extra_file_version(root, package_path, extra)
+ for extra in package.get("extra-files", [])
+ }
+ if not values:
+ raise VersionError(f"{package_path} has no version file for Release Please to bump")
+ results[package_path] = (expected, values)
+ return results
+
+
def validate(root: Path, product: str) -> None:
manifest = json.loads((root / ".release-please-manifest.json").read_text())
if product in {"all", "driver"}:
@@ -337,6 +396,9 @@ def validate(root: Path, product: str) -> None:
expected, values = sdk_versions(root)
values[".release-please-manifest.json"] = str(manifest["libs/cua"])
require_equal("cua SDK", expected, values)
+ if product in {"all", "packages"}:
+ for package_path, (expected, values) in config_only_package_versions(root).items():
+ require_equal(package_path, expected, values)
if product in {"all", "spaces"}:
expected, values = spaces_app_versions(root)
values[".release-please-manifest.json"] = str(manifest["apps/cua-spaces-macos"])
@@ -348,7 +410,9 @@ def main(argv: Sequence[str] | None = None) -> int:
parser.add_argument("--repo-root", type=Path, default=Path.cwd())
parser.add_argument(
"--product",
- choices=("all", "driver", "perception", "lume", "sandbox", "spacesd", "sdk", "spaces"),
+ choices=(
+ "all", "driver", "perception", "lume", "sandbox", "spacesd", "sdk", "spaces", "packages"
+ ),
default="all",
)
args = parser.parse_args(argv)
diff --git a/.github/workflows/ci-release-metadata.yml b/.github/workflows/ci-release-metadata.yml
index d74a8ff6bb..3a56d9d964 100644
--- a/.github/workflows/ci-release-metadata.yml
+++ b/.github/workflows/ci-release-metadata.yml
@@ -193,3 +193,35 @@ jobs:
--changelog libs/python/cua-sandbox/CHANGELOG.md \
--output /tmp/sandbox-release-manifest.json
fi
+
+ # The components release-notes.yml renders get the same preflight: a
+ # release PR whose changelog or contributor attribution would not render
+ # fails here, before its tag exists.
+ - name: Preflight release notes for other Release Please components
+ if: >-
+ github.event.pull_request.head.repo.full_name == github.repository &&
+ startsWith(github.event.pull_request.head.ref, 'release-please--branches--')
+ env:
+ GH_TOKEN: ${{ github.token }}
+ HEAD_REF: ${{ github.event.pull_request.head.ref }}
+ HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+ run: |
+ set -euo pipefail
+ COMPONENT="${HEAD_REF##*--components--}"
+ PACKAGE_PATH=$(jq -r --arg c "$COMPONENT" \
+ '.packages | to_entries[] | select(.value.component == $c) | .key' release-please-config.json)
+ if [[ -z "$PACKAGE_PATH" ]]; then
+ echo "No Release Please package for component $COMPONENT"
+ exit 0
+ fi
+ VERSION=$(jq -r --arg p "$PACKAGE_PATH" '.[$p]' .release-please-manifest.json)
+ TAG="$COMPONENT-v$VERSION"
+ PLAN=$(python3 .github/scripts/release_notes.py plan --tag "$TAG")
+ if ! grep -qx 'render=true' <<<"$PLAN"; then
+ echo "$TAG is rendered by its own CD workflow"
+ exit 0
+ fi
+ python3 .github/scripts/release_notes.py render \
+ --tag "$TAG" --ref "$HEAD_SHA" --sha "$HEAD_SHA" \
+ --repository "${{ github.repository }}" --out-dir /tmp/release-notes-preflight
+ cat /tmp/release-notes-preflight/release-body.md
diff --git a/.github/workflows/ci-release-reminder.yml b/.github/workflows/ci-release-reminder.yml
index 2a3453b270..c96f17c191 100644
--- a/.github/workflows/ci-release-reminder.yml
+++ b/.github/workflows/ci-release-reminder.yml
@@ -32,14 +32,6 @@ jobs:
# Map paths to publishable services
declare -A PATH_TO_SERVICE=(
- ["libs/python/agent/"]="pypi/agent"
- ["libs/python/core/"]="pypi/core"
- ["libs/python/som/"]="pypi/som"
- ["libs/python/bench-ui/"]="pypi/bench-ui"
- ["libs/cua-bench/"]="pypi/bench"
- ["libs/typescript/core/"]="npm/core"
- ["libs/typescript/playground/"]="npm/playground"
- ["libs/cuabot/"]="npm/cuabot"
["libs/xfce-cua/"]="docker/xfce-cua"
["libs/xfce/"]="docker/xfce"
["libs/kasm/"]="docker/kasm"
diff --git a/.github/workflows/ci-test-scripts.yml b/.github/workflows/ci-test-scripts.yml
index ad4e360428..8b6bff7ca0 100644
--- a/.github/workflows/ci-test-scripts.yml
+++ b/.github/workflows/ci-test-scripts.yml
@@ -189,6 +189,8 @@ jobs:
node .github/scripts/tests/release_please_perception_preview.cjs
NODE_PATH="$RUNNER_TEMP/sandbox-release-preview/node_modules" \
node .github/scripts/tests/release_please_spaces_preview.cjs
+ NODE_PATH="$RUNNER_TEMP/sandbox-release-preview/node_modules" \
+ node .github/scripts/tests/release_please_enrolled_preview.cjs
- name: Validate historical release backfill
run: python3 .github/scripts/release_backfill.py validate
diff --git a/.github/workflows/release-bump-version.yml b/.github/workflows/release-bump-version.yml
index d048c4c3e4..abd6bf2048 100644
--- a/.github/workflows/release-bump-version.yml
+++ b/.github/workflows/release-bump-version.yml
@@ -4,21 +4,11 @@ on:
workflow_dispatch:
inputs:
service:
- description: "Legacy package (Cua Driver, Lume, and Sandbox use Release Please)"
+ description: "Legacy package (Cua Driver, Lume, and Sandbox use Release Please, as do Spaces, the SDK and the Python and npm packages)"
required: true
type: choice
options:
- - pypi/agent
- - pypi/bench
- - pypi/bench-ui
- - pypi/core
- - pypi/sandbox-apps
- - pypi/som
- - pypi/train
- - npm/core
- npm/fleet
- - npm/playground
- - npm/cuabot
- docker/cuabot
- docker/kasm
- docker/xfce-cua
@@ -73,50 +63,10 @@ jobs:
id: package
run: |
case "${{ inputs.service }}" in
- "pypi/agent")
- echo "directory=libs/python/agent" >> $GITHUB_OUTPUT
- echo "type=python" >> $GITHUB_OUTPUT
- ;;
- "pypi/bench")
- echo "directory=libs/cua-bench" >> $GITHUB_OUTPUT
- echo "type=python" >> $GITHUB_OUTPUT
- ;;
- "pypi/bench-ui")
- echo "directory=libs/python/bench-ui" >> $GITHUB_OUTPUT
- echo "type=python" >> $GITHUB_OUTPUT
- ;;
- "pypi/core")
- echo "directory=libs/python/core" >> $GITHUB_OUTPUT
- echo "type=python" >> $GITHUB_OUTPUT
- ;;
- "pypi/sandbox-apps")
- echo "directory=libs/python/cua-sandbox-apps" >> $GITHUB_OUTPUT
- echo "type=python" >> $GITHUB_OUTPUT
- ;;
- "pypi/som")
- echo "directory=libs/python/som" >> $GITHUB_OUTPUT
- echo "type=python" >> $GITHUB_OUTPUT
- ;;
- "pypi/train")
- echo "directory=libs/python/cua-train" >> $GITHUB_OUTPUT
- echo "type=python" >> $GITHUB_OUTPUT
- ;;
- "npm/core")
- echo "directory=libs/typescript/core" >> $GITHUB_OUTPUT
- echo "type=npm" >> $GITHUB_OUTPUT
- ;;
"npm/fleet")
echo "directory=libs/typescript/fleet" >> $GITHUB_OUTPUT
echo "type=npm" >> $GITHUB_OUTPUT
;;
- "npm/playground")
- echo "directory=libs/typescript/playground" >> $GITHUB_OUTPUT
- echo "type=npm" >> $GITHUB_OUTPUT
- ;;
- "npm/cuabot")
- echo "directory=libs/cuabot" >> $GITHUB_OUTPUT
- echo "type=npm" >> $GITHUB_OUTPUT
- ;;
"docker/cuabot")
echo "directory=libs/cuabot" >> $GITHUB_OUTPUT
echo "type=docker" >> $GITHUB_OUTPUT
@@ -212,93 +162,6 @@ jobs:
echo "Tags to push: $ALL_TAGS"
echo "tags=$ALL_TAGS" >> $GITHUB_OUTPUT
- - name: Capture bumped agent version
- if: ${{ inputs.service == 'pypi/agent' }}
- id: agent_version
- run: |
- cd libs/python/agent
- VERSION=$(python -c "import tomllib; from pathlib import Path; data = tomllib.loads(Path('pyproject.toml').read_text()); print(data['project']['version'])")
- echo "Agent version: $VERSION"
- echo "version=$VERSION" >> "$GITHUB_OUTPUT"
-
- - name: Capture bumped bench version
- if: ${{ inputs.service == 'pypi/bench' }}
- id: bench_version
- run: |
- cd libs/cua-bench
- VERSION=$(python -c "import tomllib; from pathlib import Path; data = tomllib.loads(Path('pyproject.toml').read_text()); print(data['project']['version'])")
- echo "Bench version: $VERSION"
- echo "version=$VERSION" >> "$GITHUB_OUTPUT"
-
- - name: Capture bumped bench-ui version
- if: ${{ inputs.service == 'pypi/bench-ui' }}
- id: bench_ui_version
- run: |
- cd libs/python/bench-ui
- VERSION=$(python -c "import tomllib; from pathlib import Path; data = tomllib.loads(Path('pyproject.toml').read_text()); print(data['project']['version'])")
- echo "Bench-ui version: $VERSION"
- echo "version=$VERSION" >> "$GITHUB_OUTPUT"
-
- - name: Capture bumped core version
- if: ${{ inputs.service == 'pypi/core' }}
- id: core_version
- run: |
- cd libs/python/core
- VERSION=$(python -c "import tomllib; from pathlib import Path; data = tomllib.loads(Path('pyproject.toml').read_text()); print(data['project']['version'])")
- echo "Core version: $VERSION"
- echo "version=$VERSION" >> "$GITHUB_OUTPUT"
-
- - name: Capture bumped sandbox-apps version
- if: ${{ inputs.service == 'pypi/sandbox-apps' }}
- id: sandbox_apps_version
- run: |
- cd libs/python/cua-sandbox-apps
- VERSION=$(python -c "import tomllib; from pathlib import Path; data = tomllib.loads(Path('pyproject.toml').read_text()); print(data['project']['version'])")
- echo "Sandbox-apps version: $VERSION"
- echo "version=$VERSION" >> "$GITHUB_OUTPUT"
-
- - name: Capture bumped som version
- if: ${{ inputs.service == 'pypi/som' }}
- id: som_version
- run: |
- cd libs/python/som
- VERSION=$(python -c "import tomllib; from pathlib import Path; data = tomllib.loads(Path('pyproject.toml').read_text()); print(data['project']['version'])")
- echo "SOM version: $VERSION"
- echo "version=$VERSION" >> "$GITHUB_OUTPUT"
-
- - name: Capture bumped train version
- if: ${{ inputs.service == 'pypi/train' }}
- id: train_version
- run: |
- cd libs/python/cua-train
- VERSION=$(python -c "import tomllib; from pathlib import Path; data = tomllib.loads(Path('pyproject.toml').read_text()); print(data['project']['version'])")
- echo "Train version: $VERSION"
- echo "version=$VERSION" >> "$GITHUB_OUTPUT"
-
- - name: Capture bumped npm/core version
- if: ${{ inputs.service == 'npm/core' }}
- id: npm_core_version
- run: |
- VERSION=$(grep -oP '"version": "\K[^"]+' libs/typescript/core/package.json)
- echo "npm/core version: $VERSION"
- echo "version=$VERSION" >> "$GITHUB_OUTPUT"
-
- - name: Capture bumped npm/playground version
- if: ${{ inputs.service == 'npm/playground' }}
- id: npm_playground_version
- run: |
- VERSION=$(grep -oP '"version": "\K[^"]+' libs/typescript/playground/package.json)
- echo "npm/playground version: $VERSION"
- echo "version=$VERSION" >> "$GITHUB_OUTPUT"
-
- - name: Capture bumped cuabot version
- if: ${{ inputs.service == 'npm/cuabot' }}
- id: cuabot_version
- run: |
- VERSION=$(grep -oP '"version": "\K[^"]+' libs/cuabot/package.json)
- echo "cuabot version: $VERSION"
- echo "version=$VERSION" >> "$GITHUB_OUTPUT"
-
- name: Generate GitHub App token
id: app-token
uses: actions/create-github-app-token@v1
diff --git a/.github/workflows/release-github-reusable.yml b/.github/workflows/release-github-reusable.yml
index 7c01e5e3b8..51e9af1eec 100644
--- a/.github/workflows/release-github-reusable.yml
+++ b/.github/workflows/release-github-reusable.yml
@@ -60,8 +60,44 @@ jobs:
fetch-depth: 0
ref: ${{ inputs.source_sha || github.sha }}
+ - name: Download artifacts
+ if: inputs.attach_artifacts
+ uses: actions/download-artifact@v4
+ with:
+ path: release-assets
+ merge-multiple: true
+
+ - name: List downloaded artifacts
+ if: inputs.attach_artifacts
+ run: |
+ echo "Downloaded artifacts:"
+ ls -lah release-assets/
+
+ # A package on Release Please already has a draft release for its tag,
+ # holding the generated changelog (release-notes.yml adds the contributor
+ # credits). Upload to it and publish it instead of creating a second
+ # release for the same tag.
+ - name: Publish the Release Please draft for this tag
+ id: draft
+ env:
+ GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+ TAG: ${{ inputs.tag_name }}
+ NAME: ${{ inputs.release_name }}
+ ATTACH: ${{ inputs.attach_artifacts }}
+ PRERELEASE: ${{ inputs.prerelease }}
+ run: |
+ set -euo pipefail
+ if [ ! -f .github/scripts/release_notes.py ]; then
+ echo "adopted=false" >> "$GITHUB_OUTPUT"
+ exit 0
+ fi
+ ARGS=(publish-draft --tag "$TAG" --repository "$GITHUB_REPOSITORY" --name "$NAME")
+ [ "$ATTACH" = true ] && ARGS+=(--asset-dir release-assets)
+ [ "$PRERELEASE" = true ] && ARGS+=(--prerelease)
+ python3 .github/scripts/release_notes.py "${ARGS[@]}"
+
- name: Generate path-filtered release notes
- if: inputs.module_path != '' && inputs.generate_notes
+ if: steps.draft.outputs.adopted != 'true' && inputs.module_path != '' && inputs.generate_notes
id: release-notes
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -127,20 +163,8 @@ jobs:
echo "$NOTES" >> $GITHUB_OUTPUT
echo "EOF" >> $GITHUB_OUTPUT
- - name: Download artifacts
- if: inputs.attach_artifacts
- uses: actions/download-artifact@v4
- with:
- path: release-assets
- merge-multiple: true
-
- - name: List downloaded artifacts
- if: inputs.attach_artifacts
- run: |
- echo "Downloaded artifacts:"
- ls -lah release-assets/
-
- name: Prepare release body
+ if: steps.draft.outputs.adopted != 'true'
id: prepare-body
env:
# Use env vars to avoid shell interpretation of backticks in commit messages
@@ -172,6 +196,7 @@ jobs:
echo "EOF" >> $GITHUB_OUTPUT
- name: Create Release
+ if: steps.draft.outputs.adopted != 'true'
uses: softprops/action-gh-release@3bb12739c298aeb8a4eeaf626c5b8d85266b0e65 # v2
with:
tag_name: ${{ inputs.tag_name }}
diff --git a/.github/workflows/release-notes.yml b/.github/workflows/release-notes.yml
new file mode 100644
index 0000000000..1a347d36ed
--- /dev/null
+++ b/.github/workflows/release-notes.yml
@@ -0,0 +1,93 @@
+name: "Release: Changelog and contributor notes"
+
+# Cua Driver and Lume render their GitHub release body in their own CD release
+# job (release_attribution.py collect + render): a PR-first changelog and a
+# Contributors section whose @-mentions give the release GitHub's contributor
+# avatars. This gives every other Release Please component the same body when
+# Release Please pushes its stable tag. The component's own CD workflow still
+# builds, uploads and publishes; this job only replaces the release body, so it
+# works on a draft or an already published release. Prerelease tags (a Cua
+# Spaces beta) keep the notes their CD workflow writes.
+#
+# A failure here leaves Release Please's own changelog on the release; re-run
+# the job after fixing the attribution (for example an unresolved coauthor).
+
+on:
+ push:
+ tags:
+ - "cua-spaces-v*"
+ - "cua-sdk-v*"
+ - "cua-spacesd-v*"
+ - "sandbox-v*"
+ - "agent-v*"
+ - "core-v*"
+ - "bench-v*"
+ - "bench-ui-v*"
+ - "som-v*"
+ - "sandbox-apps-v*"
+ - "train-v*"
+ - "npm-core-v*"
+ - "npm-playground-v*"
+ - "cuabot-v*"
+ workflow_dispatch:
+ inputs:
+ tag:
+ description: "Stable Release Please tag whose notes to re-render (e.g. cua-sdk-v0.4.2)"
+ required: true
+ type: string
+
+permissions:
+ contents: write
+ issues: read
+ pull-requests: read
+
+concurrency:
+ group: release-notes-${{ github.event.inputs.tag || github.ref_name }}
+ cancel-in-progress: false
+
+jobs:
+ notes:
+ runs-on: ubuntu-latest
+ env:
+ TAG: ${{ github.event.inputs.tag || github.ref_name }}
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ fetch-depth: 0
+ ref: ${{ github.event.inputs.tag && format('refs/tags/{0}', github.event.inputs.tag) || github.ref }}
+ persist-credentials: false
+
+ - name: Is this a stable tag of a component rendered here?
+ id: plan
+ run: python3 .github/scripts/release_notes.py plan --tag "$TAG"
+
+ - name: Collect PR-first release attribution and render the body
+ if: steps.plan.outputs.render == 'true'
+ env:
+ GH_TOKEN: ${{ github.token }}
+ run: |
+ set -euo pipefail
+ python3 .github/scripts/release_notes.py render \
+ --tag "$TAG" \
+ --sha "$(git rev-parse "refs/tags/$TAG^{commit}")" \
+ --repository "${{ github.repository }}" \
+ --out-dir release-metadata
+
+ - name: Preserve release evidence
+ if: steps.plan.outputs.render == 'true'
+ uses: actions/upload-artifact@v4
+ with:
+ name: release-notes-${{ env.TAG }}
+ path: release-metadata/
+ if-no-files-found: error
+ retention-days: 90
+
+ - name: Replace the release body
+ if: steps.plan.outputs.render == 'true'
+ env:
+ GH_TOKEN: ${{ github.token }}
+ run: |
+ python3 .github/scripts/release_notes.py apply \
+ --tag "$TAG" \
+ --repository "${{ github.repository }}" \
+ --body release-metadata/release-body.md
diff --git a/.github/workflows/release-on-merge.yml b/.github/workflows/release-on-merge.yml
index 4eb19ad709..5a659bd176 100644
--- a/.github/workflows/release-on-merge.yml
+++ b/.github/workflows/release-on-merge.yml
@@ -86,15 +86,7 @@ jobs:
# Map paths to publishable services
declare -A PATH_TO_SERVICE=(
- ["libs/python/agent/"]="pypi/agent"
- ["libs/python/core/"]="pypi/core"
- ["libs/python/som/"]="pypi/som"
- ["libs/python/bench-ui/"]="pypi/bench-ui"
- ["libs/cua-bench/"]="pypi/bench"
- ["libs/typescript/core/"]="npm/core"
["libs/typescript/fleet/"]="npm/fleet"
- ["libs/typescript/playground/"]="npm/playground"
- ["libs/cuabot/"]="npm/cuabot"
["libs/xfce-cua/"]="docker/xfce-cua"
["libs/xfce/"]="docker/xfce"
["libs/kasm/"]="docker/kasm"
diff --git a/.github/workflows/release-please.yml b/.github/workflows/release-please.yml
index 35551e68cf..ca61e35153 100644
--- a/.github/workflows/release-please.yml
+++ b/.github/workflows/release-please.yml
@@ -20,6 +20,16 @@ on:
- cua-spacesd
- cua-sdk
- cua-spaces
+ - agent
+ - core
+ - bench
+ - bench-ui
+ - som
+ - sandbox-apps
+ - train
+ - npm-core
+ - npm-playground
+ - cuabot
bump:
description: "Version bump for the selected component"
required: true
@@ -63,7 +73,7 @@ jobs:
inputs.component == 'automatic' &&
inputs.bump != 'automatic'
run: |
- echo "::error::Select cua-perception, cua-driver-rs, lume, sandbox, cua-spacesd, cua-sdk or cua-spaces when forcing a bump type."
+ echo "::error::Select a component (not automatic) when forcing a bump type."
exit 1
- name: Reject manifest tags outside main history
diff --git a/.github/workflows/release-unreleased-digest.yml b/.github/workflows/release-unreleased-digest.yml
index 45eff0618e..ae6120fca6 100644
--- a/.github/workflows/release-unreleased-digest.yml
+++ b/.github/workflows/release-unreleased-digest.yml
@@ -23,14 +23,6 @@ jobs:
run: |
# Service → tag prefix → directory
declare -A SERVICE_TAG_DIR
- SERVICE_TAG_DIR["pypi/agent"]="agent-v|libs/python/agent/"
- SERVICE_TAG_DIR["pypi/core"]="core-v|libs/python/core/"
- SERVICE_TAG_DIR["pypi/som"]="som-v|libs/python/som/"
- SERVICE_TAG_DIR["pypi/bench"]="bench-v|libs/cua-bench/"
- SERVICE_TAG_DIR["pypi/bench-ui"]="bench-ui-v|libs/python/bench-ui/"
- SERVICE_TAG_DIR["npm/core"]="npm-core-v|libs/typescript/core/"
- SERVICE_TAG_DIR["npm/playground"]="npm-playground-v|libs/typescript/playground/"
- SERVICE_TAG_DIR["npm/cuabot"]="cuabot-v|libs/cuabot/"
SERVICE_TAG_DIR["docker/xfce-cua"]="docker-xfce-cua-v|libs/xfce-cua/"
SERVICE_TAG_DIR["docker/xfce"]="docker-xfce-v|libs/xfce/"
SERVICE_TAG_DIR["docker/kasm"]="docker-kasm-v|libs/kasm/"
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index 4f77af7a2a..289d436b89 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -5,5 +5,15 @@
"libs/python/cua-sandbox": "0.9.0",
"libs/cua": "0.4.1",
"libs/cua-spacesd": "0.5.3",
- "apps/cua-spaces-macos": "0.8.0"
+ "apps/cua-spaces-macos": "0.8.0",
+ "libs/python/agent": "0.9.0",
+ "libs/python/core": "0.3.2",
+ "libs/cua-bench": "0.3.0",
+ "libs/python/bench-ui": "0.7.1",
+ "libs/python/som": "0.1.4",
+ "libs/python/cua-sandbox-apps": "0.1.2",
+ "libs/python/cua-train": "0.1.2",
+ "libs/typescript/core": "0.1.6",
+ "libs/typescript/playground": "0.3.0",
+ "libs/cuabot": "1.0.16"
}
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7372bfe74b..9b07e07b88 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -132,7 +132,9 @@ only a retry for an existing published stable Release Please-managed Sandbox
release. Legacy tags without a Sandbox release-manifest entry cannot be retried
through this workflow. The legacy
`pypi/sandbox` bump workflow and `release:pypi/sandbox` auto-release label no
-longer manage this package. Sandbox Apps remains on its separate legacy path.
+longer manage this package. Sandbox Apps and the other Python and npm packages
+also release through Release Please now; see
+[`.github/releases/README.md`](.github/releases/README.md).
## Preserve Contributor Authorship
diff --git a/Development.md b/Development.md
index 264e4a5d10..26f39e1324 100644
--- a/Development.md
+++ b/Development.md
@@ -138,20 +138,20 @@ instead of entering the public docs navigation.
## Releases
-Release Please manages the components listed in
-[`.github/releases/components.json`](.github/releases/components.json) (Cua
-Driver, Cua Perception, Lume, and the cua SDK) plus cua-sandbox
-(`sandbox-v*` tags). Their pull request titles decide the release; see
-[`CONTRIBUTING.md`](CONTRIBUTING.md#agent-assisted-contributions).
+Release Please manages Cua Driver, Cua Perception, Lume, Cua Spaces, the cua
+SDK, cua-spacesd, cua-sandbox and the Python and npm packages; the table in
+[`.github/releases/README.md`](.github/releases/README.md) lists each one's
+path, tag and publishing workflow. Their pull request titles decide the
+release; see [`CONTRIBUTING.md`](CONTRIBUTING.md#agent-assisted-contributions).
-Other packages are released through the
+The Docker images are still released through the
[Legacy packages: Bump Version](https://github.com/trycua/cua/actions/workflows/release-bump-version.yml)
-workflow. Its `service` input is the current target list. Each package's
-`.bumpversion.cfg`, Cargo manifest, or package manifest owns its version and
-tag format, and tag-triggered CD workflows publish.
+workflow. Its `service` input is the current target list. Each image's
+`.bumpversion.cfg` owns its version and tag format, and tag-triggered CD
+workflows publish.
-The root `Makefile` provides local version inspection and dry-run helpers. It
-does not publish production releases.
+The root `Makefile` prints the Release Please versions (`make show-versions`).
+It does not publish releases.
## Generated and Local Files
diff --git a/Makefile b/Makefile
index 7720b54b24..a4fc7b71ce 100644
--- a/Makefile
+++ b/Makefile
@@ -1,36 +1,19 @@
-# Python Package Release Makefile
-# Version bumps are managed via GitHub Actions workflows (see Development.md)
-# This Makefile provides utility targets for checking versions and dry-run testing
+# Release utilities
+# Python and npm packages release through Release Please (see
+# .github/releases/README.md); this Makefile only shows current versions.
-.PHONY: help
+.PHONY: help show-versions
help: ## Show this help message
- @echo "Python Package Release Utilities"
+ @echo "Release utilities"
@echo ""
@echo "Usage: make <target>"
@echo ""
@echo "Available targets:"
@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf " %-25s %s\n", $$1, $$2}'
@echo ""
- @echo "⚠️ For production version bumps, use GitHub Actions:"
- @echo " https://github.com/trycua/cua/actions/workflows/release-bump-version.yml"
-
-# Dry run targets (test without making changes)
-dry-run-patch-%: ## Dry run for patch version bump (e.g., make dry-run-patch-core)
- @echo "Dry run: Bumping $* patch version..."
- cd libs/python/$* && bump2version --dry-run --verbose patch
-
-dry-run-minor-%: ## Dry run for minor version bump (e.g., make dry-run-minor-core)
- @echo "Dry run: Bumping $* minor version..."
- cd libs/python/$* && bump2version --dry-run --verbose minor
-
-dry-run-major-%: ## Dry run for major version bump (e.g., make dry-run-major-core)
- @echo "Dry run: Bumping $* major version..."
- cd libs/python/$* && bump2version --dry-run --verbose major
+ @echo "Release Please opens a release PR per package from conventional commit titles."
# Show current versions
-show-versions: ## Show current versions of all packages
- @echo "Current Python package versions:"
- @echo " cua-core: $$(grep 'current_version' libs/python/core/.bumpversion.cfg | cut -d' ' -f3)"
- @echo " cua-som: $$(grep 'current_version' libs/python/som/.bumpversion.cfg | cut -d' ' -f3)"
- @echo " cua-agent: $$(grep 'current_version' libs/python/agent/.bumpversion.cfg | cut -d' ' -f3)"
+show-versions: ## Show the released version of every Release Please package
+ @python3 -c "import json; [print(f' {p:45} {v}') for p, v in json.load(open('.release-please-manifest.json')).items()]"
diff --git a/libs/cua-bench/.bumpversion.cfg b/libs/cua-bench/.bumpversion.cfg
deleted file mode 100644
index 4f119d862f..0000000000
--- a/libs/cua-bench/.bumpversion.cfg
+++ /dev/null
@@ -1,10 +0,0 @@
-[bumpversion]
-current_version = 0.3.0
-commit = True
-tag = True
-tag_name = bench-v{new_version}
-message = chore: bump cua-bench version to {new_version}
-
-[bumpversion:file:pyproject.toml]
-search = version = "{current_version}"
-replace = version = "{new_version}"
diff --git a/libs/cuabot/.bumpversion.cfg b/libs/cuabot/.bumpversion.cfg
deleted file mode 100644
index 4eb15609a2..0000000000
--- a/libs/cuabot/.bumpversion.cfg
+++ /dev/null
@@ -1,10 +0,0 @@
-[bumpversion]
-current_version = 1.0.16
-commit = True
-tag = True
-tag_name = cuabot-v{new_version}
-message = Bump cuabot to v{new_version}
-
-[bumpversion:file:package.json]
-search = "version": "{current_version}"
-replace = "version": "{new_version}"
diff --git a/libs/python/agent/.bumpversion.cfg b/libs/python/agent/.bumpversion.cfg
deleted file mode 100644
index 4fbf4f29d7..0000000000
--- a/libs/python/agent/.bumpversion.cfg
+++ /dev/null
@@ -1,10 +0,0 @@
-[bumpversion]
-current_version = 0.9.0
-commit = True
-tag = True
-tag_name = agent-v{new_version}
-message = Bump cua-agent to v{new_version}
-
-[bumpversion:file:pyproject.toml]
-search = version = "{current_version}"
-replace = version = "{new_version}"
diff --git a/libs/python/bench-ui/.bumpversion.cfg b/libs/python/bench-ui/.bumpversion.cfg
deleted file mode 100644
index c3a4db7c0f..0000000000
--- a/libs/python/bench-ui/.bumpversion.cfg
+++ /dev/null
@@ -1,10 +0,0 @@
-[bumpversion]
-current_version = 0.7.1
-commit = True
-tag = True
-tag_name = bench-ui-v{new_version}
-message = chore: bump cua-bench-ui version to {new_version}
-
-[bumpversion:file:pyproject.toml]
-search = version = "{current_version}"
-replace = version = "{new_version}"
diff --git a/libs/python/core/.bumpversion.cfg b/libs/python/core/.bumpversion.cfg
deleted file mode 100644
index 465837486e..0000000000
--- a/libs/python/core/.bumpversion.cfg
+++ /dev/null
@@ -1,10 +0,0 @@
-[bumpversion]
-current_version = 0.3.2
-commit = True
-tag = True
-tag_name = core-v{new_version}
-message = Bump cua-core to v{new_version}
-
-[bumpversion:file:pyproject.toml]
-search = version = "{current_version}"
-replace = version = "{new_version}"
diff --git a/libs/python/cua-sandbox-apps/.bumpversion.cfg b/libs/python/cua-sandbox-apps/.bumpversion.cfg
deleted file mode 100644
index 4d59506ec0..0000000000
--- a/libs/python/cua-sandbox-apps/.bumpversion.cfg
+++ /dev/null
@@ -1,10 +0,0 @@
-[bumpversion]
-current_version = 0.1.2
-commit = True
-tag = True
-tag_name = sandbox-apps-v{new_version}
-message = Bump cua-sandbox-apps to v{new_version}
-
-[bumpversion:file:pyproject.toml]
-search = version = "{current_version}"
-replace = version = "{new_version}"
diff --git a/libs/python/cua-train/.bumpversion.cfg b/libs/python/cua-train/.bumpversion.cfg
deleted file mode 100644
index 35f6ea62a7..0000000000
--- a/libs/python/cua-train/.bumpversion.cfg
+++ /dev/null
@@ -1,10 +0,0 @@
-[bumpversion]
-current_version = 0.1.2
-commit = True
-tag = True
-tag_name = train-v{new_version}
-message = Bump cua-train to v{new_version}
-
-[bumpversion:file:pyproject.toml]
-search = version = "{current_version}"
-replace = version = "{new_version}"
diff --git a/libs/python/som/.bumpversion.cfg b/libs/python/som/.bumpversion.cfg
deleted file mode 100644
index 78cf865984..0000000000
--- a/libs/python/som/.bumpversion.cfg
+++ /dev/null
@@ -1,10 +0,0 @@
-[bumpversion]
-current_version = 0.1.4
-commit = True
-tag = True
-tag_name = som-v{new_version}
-message = Bump cua-som to v{new_version}
-
-[bumpversion:file:pyproject.toml]
-search = version = "{current_version}"
-replace = version = "{new_version}"
diff --git a/libs/typescript/core/.bumpversion.cfg b/libs/typescript/core/.bumpversion.cfg
deleted file mode 100644
index 7ad9099d5e..0000000000
--- a/libs/typescript/core/.bumpversion.cfg
+++ /dev/null
@@ -1,10 +0,0 @@
-[bumpversion]
-current_version = 0.1.6
-commit = True
-tag = True
-tag_name = npm-core-v{new_version}
-message = Bump @trycua/core to v{new_version}
-
-[bumpversion:file:package.json]
-search = "version": "{current_version}"
-replace = "version": "{new_version}"
diff --git a/libs/typescript/playground/.bumpversion.cfg b/libs/typescript/playground/.bumpversion.cfg
deleted file mode 100644
index b00ac9d125..0000000000
--- a/libs/typescript/playground/.bumpversion.cfg
+++ /dev/null
@@ -1,10 +0,0 @@
-[bumpversion]
-current_version = 0.3.0
-commit = True
-tag = True
-tag_name = npm-playground-v{new_version}
-message = Bump @trycua/playground to v{new_version}
-
-[bumpversion:file:package.json]
-search = "version": "{current_version}"
-replace = "version": "{new_version}"
diff --git a/release-please-config.json b/release-please-config.json
index 706b13e504..fd698aaecc 100644
--- a/release-please-config.json
+++ b/release-please-config.json
@@ -446,6 +446,191 @@
"jsonpath": "$.package[?(@.name.value=='cua-spaces-app')].version"
}
]
+ },
+ "libs/python/agent": {
+ "release-type": "simple",
+ "component": "agent",
+ "package-name": "cua-agent",
+ "bump-minor-pre-major": true,
+ "changelog-path": "CHANGELOG.md",
+ "extra-files": [
+ {
+ "type": "toml",
+ "path": "pyproject.toml",
+ "jsonpath": "$.project.version"
+ },
+ {
+ "type": "toml",
+ "path": "/uv.lock",
+ "jsonpath": "$.package[?(@.name.value=='cua-agent')].version"
+ },
+ {
+ "type": "toml",
+ "path": "/libs/cua-bench/uv.lock",
+ "jsonpath": "$.package[?(@.name.value=='cua-agent')].version"
+ }
+ ]
+ },
+ "libs/python/core": {
+ "release-type": "simple",
+ "component": "core",
+ "package-name": "cua-core",
+ "bump-minor-pre-major": true,
+ "changelog-path": "CHANGELOG.md",
+ "extra-files": [
+ {
+ "type": "toml",
+ "path": "pyproject.toml",
+ "jsonpath": "$.project.version"
+ },
+ {
+ "type": "toml",
+ "path": "/uv.lock",
+ "jsonpath": "$.package[?(@.name.value=='cua-core')].version"
+ },
+ {
+ "type": "toml",
+ "path": "/libs/cua-bench/uv.lock",
+ "jsonpath": "$.package[?(@.name.value=='cua-core')].version"
+ }
+ ]
+ },
+ "libs/cua-bench": {
+ "release-type": "simple",
+ "component": "bench",
+ "package-name": "cua-bench",
+ "bump-minor-pre-major": true,
+ "changelog-path": "CHANGELOG.md",
+ "extra-files": [
+ {
+ "type": "toml",
+ "path": "pyproject.toml",
+ "jsonpath": "$.project.version"
+ },
+ {
+ "type": "toml",
+ "path": "uv.lock",
+ "jsonpath": "$.package[?(@.name.value=='cua-bench')].version"
+ }
+ ]
+ },
+ "libs/python/bench-ui": {
+ "release-type": "simple",
+ "component": "bench-ui",
+ "package-name": "cua-bench-ui",
+ "bump-minor-pre-major": true,
+ "changelog-path": "CHANGELOG.md",
+ "extra-files": [
+ {
+ "type": "toml",
+ "path": "pyproject.toml",
+ "jsonpath": "$.project.version"
+ },
+ {
+ "type": "toml",
+ "path": "/uv.lock",
+ "jsonpath": "$.package[?(@.name.value=='cua-bench-ui')].version"
+ }
+ ]
+ },
+ "libs/python/som": {
+ "release-type": "simple",
+ "component": "som",
+ "package-name": "cua-som",
+ "bump-minor-pre-major": true,
+ "changelog-path": "CHANGELOG.md",
+ "extra-files": [
+ {
+ "type": "toml",
+ "path": "pyproject.toml",
+ "jsonpath": "$.project.version"
+ },
+ {
+ "type": "toml",
+ "path": "/uv.lock",
+ "jsonpath": "$.package[?(@.name.value=='cua-som')].version"
+ }
+ ]
+ },
+ "libs/python/cua-sandbox-apps": {
+ "release-type": "simple",
+ "component": "sandbox-apps",
+ "package-name": "cua-sandbox-apps",
+ "bump-minor-pre-major": true,
+ "changelog-path": "CHANGELOG.md",
+ "extra-files": [
+ {
+ "type": "toml",
+ "path": "pyproject.toml",
+ "jsonpath": "$.project.version"
+ },
+ {
+ "type": "toml",
+ "path": "uv.lock",
+ "jsonpath": "$.package[?(@.name.value=='cua-sandbox-apps')].version"
+ }
+ ]
+ },
+ "libs/python/cua-train": {
+ "release-type": "simple",
+ "component": "train",
+ "package-name": "cua-train",
+ "bump-minor-pre-major": true,
+ "changelog-path": "CHANGELOG.md",
+ "extra-files": [
+ {
+ "type": "toml",
+ "path": "pyproject.toml",
+ "jsonpath": "$.project.version"
+ }
+ ]
+ },
+ "libs/typescript/core": {
+ "release-type": "simple",
+ "component": "npm-core",
+ "package-name": "@trycua/core",
+ "bump-minor-pre-major": true,
+ "changelog-path": "CHANGELOG.md",
+ "extra-files": [
+ {
+ "type": "json",
+ "path": "package.json",
+ "jsonpath": "$.version"
+ }
+ ]
+ },
+ "libs/typescript/playground": {
+ "release-type": "simple",
+ "component": "npm-playground",
+ "package-name": "@trycua/playground",
+ "bump-minor-pre-major": true,
+ "changelog-path": "CHANGELOG.md",
+ "extra-files": [
+ {
+ "type": "json",
+ "path": "package.json",
+ "jsonpath": "$.version"
+ }
+ ]
+ },
+ "libs/cuabot": {
+ "release-type": "simple",
+ "component": "cuabot",
+ "package-name": "cuabot",
+ "bump-minor-pre-major": true,
+ "changelog-path": "CHANGELOG.md",
+ "exclude-paths": [
+ "libs/cuabot/Dockerfile",
+ "libs/cuabot/VERSION",
+ "libs/cuabot/.bumpversion.docker.cfg"
+ ],
+ "extra-files": [
+ {
+ "type": "json",
+ "path": "package.json",
+ "jsonpath": "$.version"
+ }
+ ]
}
}
}