# Publish a Helm Chart to an OCI Registry

Yes. An agent adds a helm push to GHCR beside your chart-releaser workflow, proves the round trip against a local registry, updates the README and opens a PR.

[Run this on Rush](https://cloud.getrush.ai/run/publish-chart-to-oci/helm/). Opens the console with this prompt ready to send, in a Project that has your repository.

## What the agent does

The agent clones the repository into its own cloud sandbox and reads how the chart is released today. In a repository like helm/examples, `charts/hello-world/Chart.yaml` is `apiVersion: v2`, `version: 0.1.0`, `appVersion: "1.16.0"` and `type: application`; `values.yaml` sets an `nginx` image with an empty `tag` that falls back to `appVersion`, `replicaCount: 1`, a `ClusterIP` service on port `80` and a created service account; the templates are a Deployment with HTTP liveness and readiness probes on `/`, a Service, a ServiceAccount, `NOTES.txt` and `_helpers.tpl`. The `README.md` tells users to `helm repo add examples https://helm.github.io/examples` and `helm install ahoy examples/hello-world`, which is the GitHub Pages index that chart-releaser maintains.

`.github/workflows/release.yaml` runs on every push to `main`: `actions/checkout@v2` with `fetch-depth: 0`, a git identity, `azure/setup-helm@v1`, and `helm/chart-releaser-action@v1.2.0` with `CR_TOKEN` set to `GITHUB_TOKEN`, which packages any chart whose version is new, creates a GitHub release for it and updates the Pages index. `lint-test.yaml` runs on pull requests with `helm/chart-testing-action@v2.0.1`, `ct list-changed`, `ct lint`, and a kind cluster with `ct install` only when a chart changed; it still uses the `::set-output` syntax to pass that result between steps. There is no `helm push`, no `oci://` reference and no `packages: write` permission anywhere.

The agent adds a second job to `release.yaml`, `publish-oci`, that needs the chart-releaser job, with `permissions` of `contents: read` and `packages: write`. It logs in with `helm registry login ghcr.io` using `github.actor` and `GITHUB_TOKEN` on stdin, reads the version from `Chart.yaml`, and before pushing runs `helm show chart oci://ghcr.io/<owner>/charts/hello-world --version <version>` so a version that already exists in the registry is skipped rather than overwritten, since OCI tags are mutable and chart-releaser's own rule is that a published version is final. When the version is new it runs `helm package charts/hello-world` and `helm push hello-world-<version>.tgz oci://ghcr.io/<owner>/charts`. The `README.md` gains the OCI install form, `helm install ahoy oci://ghcr.io/<owner>/charts/hello-world --version 0.1.0`, next to the repository form, which keeps working.

To prove the commands before the workflow runs them, the agent installs Helm in the sandbox, runs `helm lint` and `helm template` on the chart, and, because the sandbox has no Docker, installs it with `sudo apt-get install -y docker.io`, starts `dockerd` and runs the `registry:2` image on `localhost:5000`. It packages the chart, pushes it there with `--plain-http`, pulls it back with `helm pull` and `helm show chart` to confirm the name, version and `appVersion` survive the round trip, and pastes that output into the pull request. The old action majors in both workflows and the deprecated `::set-output` line are listed as a separate cleanup and left alone, so the diff is about publishing.

## Start it with one API call

`POST https://api.phoenix.so/o/{org}/sessions`

```json
{
  "agent": "claude",
  "input": "Add OCI publishing to this Helm chart repository. Read every Chart.yaml and values.yaml under charts/, the README and every workflow under .github/workflows first. Keep the existing chart-releaser release as it is and add a second job to the release workflow that logs in to ghcr.io with the workflow token, skips any chart version that already exists in the registry, and otherwise packages the chart and pushes it with helm push to oci://ghcr.io/<owner>/charts, with packages write permission on that job only. Add the oci:// install form to the README beside the existing helm repo form. In the sandbox, run helm lint and helm template, then install docker.io, start dockerd, run a local registry and push and pull the packaged chart to prove the round trip. Do not bump action versions or change the lint workflow. Open a pull request that quotes the round-trip output.",
  "resources": [
    {
      "url": "https://github.com/your-org/your-app"
    }
  ]
}
```

1. **Get an API key.** In the console, open Settings, then API keys, and create a key for your org. Send it in the Authorization header as a Bearer token.
2. **Send the request.** POST the body in request.json to https://api.phoenix.so/o/{org}/sessions, with your repository as the resources URL. The run starts in its own cloud sandbox.
3. **Read what came back.** Follow the run on its live stream or wait for the run.completed webhook, then read the result and its trajectory.

## What comes back

What comes back is a pull request that adds one job to `.github/workflows/release.yaml` and one paragraph to `README.md`, with the chart, its templates and `lint-test.yaml` unchanged. The description shows the `helm lint` result, the `helm push` and `helm pull` against the local registry with the chart's name, version and `appVersion` read back, and names the registry path the workflow will publish to.

The run's record keeps the Helm install, the lint and template runs, the Docker install, the registry container and the push and pull, so a reviewer can confirm the commands in the workflow are the ones that worked in the sandbox rather than ones written from memory. The existing Pages index and `helm repo add` path keep working alongside the new one.

Before merging, a reviewer checks the GHCR path and owner in the workflow, decides whether the package should be made public in the repository's package settings after the first push, and chooses whether to take the deprecated `::set-output` and the old action majors in the same change or the next.

## Run it on every pull request that changes Chart.yaml

Once charts publish to a registry, the mistake that matters is a version bump that does not package or a chart that does not install. An automation with a `github` trigger on `pull_request.opened` and `pull_request.synchronize` starts one run per pull request; the agent checks out the branch and, when the diff does not touch a `Chart.yaml` or anything under `charts/`, ends with a one-line note. Only work by an owner, member or collaborator fires the trigger; pull requests from forks never do.

When it does, the run lints and packages the changed chart, pushes it to a local registry as the release workflow would, pulls it back, and posts one review that confirms the version is new against the published registry and that the package round-trips, or cites the `Chart.yaml` line that blocks it. It pushes no commits.

## Why run it on Rush?

Publishing to an OCI registry is three Helm commands, and the risk is in the details around them: a token without `packages: write`, a tag that silently overwrites a published version, a README that still points only at the Pages index. The agent writes the job from the commands it actually ran in its own sandbox against a real registry, with the push and pull in the record, so the workflow's first real run is not the first time anyone saw those commands succeed.

An organisation with many chart repositories sends the same request to each and gets one pull request per repository, each wired to that repository's own chart names and existing release job, each with its own round-trip output. The repositories that already push to a registry come back with a short note instead of a duplicate job.

## Frequently asked questions

### Will this replace chart-releaser?

No. The chart-releaser job and the GitHub Pages index stay as they are, and the new job runs after it. Users who added the repository with `helm repo add` keep getting updates; users who prefer `oci://` get the same chart from GHCR.

### What stops the workflow from overwriting a published version?

Before pushing, the job runs `helm show chart` against the registry at the chart's current version and skips the push when it answers. OCI tags can be overwritten, so this guard gives the registry the same rule chart-releaser applies to releases: a version, once published, is final.

### Does the registry need a token of its own?

Not for GHCR in the same organisation. The job logs in with `github.actor` and the workflow's `GITHUB_TOKEN`, which is enough once the job has `packages: write`. A registry elsewhere needs a secret, and the pull request says where the login step would read it.

### Why run a local registry in the sandbox?

Because `helm push` cannot be dry-run. Pushing to a `registry:2` container on `localhost:5000` and pulling the package back is the only way to show the exact commands work before the workflow runs them against GHCR, and the sandbox is discarded afterwards.

## More Helm jobs

- [Review Helm Chart Pull Requests](https://getrush.ai/run/review-chart-changes/helm/)
- [Update the GitHub Actions in a Helm Chart Repository](https://getrush.ai/run/update-github-actions/helm/)
- [Upgrade Helm Chart Dependencies](https://getrush.ai/run/upgrade-chart-dependencies/helm/)

## More jobs like this: Hand off a long task

- [Publish dbt Docs to GitHub Pages](https://getrush.ai/run/publish-dbt-docs/dbt/)
- [Reduce Cold Starts in Cloud Functions for Firebase](https://getrush.ai/run/reduce-cold-starts/firebase-functions/)
- [Reduce Cold Starts for a NestJS API on Serverless Framework](https://getrush.ai/run/reduce-cold-starts/serverless/)

## Keep reading

- [How a Rush run works on your repository, from request to pull request](https://getrush.ai/cloud/)
- [Compare cloud agents, agent sandboxes and AI code review](https://getrush.ai/compare/)
- [Rush pricing: Free, Pro and Max](https://getrush.ai/pricing/)
