Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
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.mdindex 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 cratediff --git a/.github/scripts/merge_release_please_manifests.py b/.github/scripts/merge_release_please_manifests.pyindex 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.pynew file mode 100644index 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.pyindex 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.cjsnew file mode 100644index 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.pyindex 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.pynew file mode 100644index 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.pyindex 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.pyindex 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.ymlindex 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.jsonfi++ # 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.mddiff --git a/.github/workflows/ci-release-reminder.yml b/.github/workflows/ci-release-reminder.ymlindex 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 servicesdeclare -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.ymlindex 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.cjsNODE_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 backfillrun: python3 .github/scripts/release_backfill.py validatediff --git a/.github/workflows/release-bump-version.yml b/.github/workflows/release-bump-version.ymlindex 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: truetype: choiceoptions:- - 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: packagerun: |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_OUTPUTecho "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_OUTPUTecho "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 tokenid: app-tokenuses: actions/create-github-app-token@v1diff --git a/.github/workflows/release-github-reusable.yml b/.github/workflows/release-github-reusable.ymlindex 7c01e5e3b8..51e9af1eec 100644--- a/.github/workflows/release-github-reusable.yml+++ b/.github/workflows/release-github-reusable.yml@@ -60,8 +60,44 @@ jobs:fetch-depth: 0ref: ${{ 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_notesid: release-notesenv:GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}@@ -127,20 +163,8 @@ jobs:echo "$NOTES" >> $GITHUB_OUTPUTecho "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-bodyenv:# 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 # v2with:tag_name: ${{ inputs.tag_name }}diff --git a/.github/workflows/release-notes.yml b/.github/workflows/release-notes.ymlnew file mode 100644index 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.mddiff --git a/.github/workflows/release-on-merge.yml b/.github/workflows/release-on-merge.ymlindex 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 servicesdeclare -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.ymlindex 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+ - cuabotbump: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 historydiff --git a/.github/workflows/release-unreleased-digest.yml b/.github/workflows/release-unreleased-digest.ymlindex 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 → directorydeclare -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.jsonindex 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.mdindex 7372bfe74b..9b07e07b88 100644--- a/CONTRIBUTING.md+++ b/CONTRIBUTING.md@@ -132,7 +132,9 @@ only a retry for an existing published stable Release Please-managed Sandboxrelease. Legacy tags without a Sandbox release-manifest entry cannot be retriedthrough 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 Authorshipdiff --git a/Development.md b/Development.mdindex 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 Filesdiff --git a/Makefile b/Makefileindex 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-versionshelp: ## 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.cfgdeleted file mode 100644index 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.cfgdeleted file mode 100644index 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.cfgdeleted file mode 100644index 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.cfgdeleted file mode 100644index 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.cfgdeleted file mode 100644index 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.cfgdeleted file mode 100644index 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.cfgdeleted file mode 100644index 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.cfgdeleted file mode 100644index 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.cfgdeleted file mode 100644index 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.cfgdeleted file mode 100644index 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.jsonindex 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"+ }+ ]}}}