# Upgrade an Ember.js App to the Latest Release

Yes. An agent runs ember-cli-update against your app's recorded blueprint, bumps ember-source and ember-cli together, runs lint and the test suite, and opens a PR.

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

## What the agent does

An Ember upgrade has two halves: the framework packages, and the project files the app blueprint generated and has since revised. The agent reads where the app stands on both. In an app laid out like ember-learn/super-rentals, `package.json` pins `ember-source` and `ember-cli` to `~7.3.0`, and `config/ember-cli-update.json` records that the project came from `@ember/app-blueprint` 7.3.1 with the options `--pnpm` and `--ci-provider=github`. The build is Vite with Embroider (`vite.config.mjs` loads `classicEmberSupport()` and `ember()` from `@embroider/vite`), components are `.gjs` files, `engines.node` is `>= 20.19.0`, and `.github/workflows/ci.yml` runs `pnpm lint` and `pnpm test` on Node 22 with pnpm 10. The agent asks the npm registry for the newest `ember-source`, `ember-cli` and `@ember/app-blueprint` and states the target versions before it changes anything.

It clears the ground first. `config/environment.js` sets `RAISE_ON_DEPRECATION: true`, and `app/deprecation-workflow.js` silences two ids, `ember-data:deprecate-legacy-imports` and `warp-drive.deprecate-tracking-package`, under a comment that says to fix them later. The agent builds and runs the suite on the current versions with `pnpm test`, which is `vite build --mode development && testem ci --port 0`, and collects every deprecation the run prints. A deprecation whose removal version is at or below the target is fixed on the old version, where the app still works, and committed on its own. The two silenced ids belong to the data layer and stay silenced, because this job leaves the five `@warp-drive/*` packages at `~5.8.2`.

Then it runs `npx ember-cli-update --to` the target version. The tool reads the recorded blueprint and options, computes the difference between the blueprint at 7.3.1 and at the target, and applies it as a patch. Clean hunks land directly; where the app has edited a generated file, the tool leaves conflict markers and the agent resolves each one by keeping the app's change and taking the blueprint's. The files that conflict are the ones an app edits after generation. In this repository `app/app.js` gained a `setBuildURLConfig` call with the `api` namespace, `app/deprecation-workflow.js` gained its two silence handlers, and `package.json` carries the app's own dependencies, `maplibre-gl` among them. It sets the `ember-source` and `ember-cli` ranges to the same new minor, updates the version in `config/ember-cli-update.json`, and reinstalls with pnpm.

Verification is the two commands CI runs. `pnpm lint` fans out to Stylelint, Prettier, `ember-template-lint` and ESLint through `concurrently`, and `pnpm test` builds the app and launches Chrome through Testem. `testem.cjs` adds `--no-sandbox` only when `CI` is set, so the agent exports `CI=true` and installs Chrome if the sandbox has none. A test that fails after the upgrade is traced to its cause: the agent reads the release notes for the versions in between and fixes the app code, and it does not loosen an assertion. One more thing goes into the pull request as a note. The workflow installs with `pnpm install --frozen-lockfile`, and the repository tracks no `pnpm-lock.yaml`; the agent does not start tracking one on its own, and says what it saw.

## Start it with one API call

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

```json
{
  "agent": "claude",
  "input": "Upgrade this Ember app to the latest stable release of ember-source and ember-cli. Read package.json, config/ember-cli-update.json, config/environment.js, app/deprecation-workflow.js, ember-cli-build.mjs, vite.config.mjs, babel.config.mjs, eslint.config.mjs, testem.cjs, app/app.js and .github/workflows/ci.yml first, and look up the newest ember-source, ember-cli and @ember/app-blueprint versions on the npm registry. State the current and target versions. Install with pnpm, export CI=true, install Chrome if it is missing, and run pnpm lint and pnpm test on the current versions; record the result and every deprecation printed. Fix deprecations that the target version removes while still on the current version, in their own commit, and leave the two ids silenced in app/deprecation-workflow.js alone. Run npx ember-cli-update to the target version, resolve every conflict by keeping the app's own changes alongside the blueprint's, and bump ember-source and ember-cli to the same minor. Do not change the @warp-drive packages or any other major version. Run pnpm lint and pnpm test again and fix failures in application code without weakening tests. If the upgrade cannot pass, stop and report the failing step. Open a pull request that lists the versions before and after, each blueprint file changed and why, the deprecations fixed, and both test outputs.",
  "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

The pull request contains one commit of deprecation fixes made on the old version, if any were needed, and one for the upgrade itself: the new `ember-source` and `ember-cli` ranges, the version in `config/ember-cli-update.json`, and whatever blueprint files changed between the two releases. Its description gives the versions before and after, a line per blueprint file saying what the blueprint changed and how any conflict was resolved, the deprecation ids that were fixed with the files they touched, and the output of `pnpm lint` and `pnpm test` from before and after the change.

A reviewer reads the conflict resolutions first, because those are judgment calls: that the `setBuildURLConfig` call in `app/app.js` survived next to whatever the new blueprint changed there, that the WarpDrive `setConfig` block in `ember-cli-build.mjs` is intact, and that `eslint.config.mjs` still loads the WarpDrive rules. They compare the two test outputs to confirm the same tests ran, and they check the notes at the end, where the agent lists what it left alone: the data packages, the silenced deprecations, the missing lockfile, and anything in the README that no longer matches the scripts.

When the upgrade cannot be made to pass, no pull request claims otherwise. The run ends with a report of the step that failed and the error, and its sandbox parks with the work so far, where a follow-up message can pick it up.

## Run it on every first of the month

Ember ships minor releases on a regular cadence, and an app that takes each one has a small diff every time. Create an automation on the Project with this prompt and a `schedule` trigger whose `cron` is `0 9 1 * *` in your `timezone`. Each fire starts one run; when the app is already on the newest release, the run reports that and opens nothing.

For a team that would rather react than poll, a small handler on your own server can watch the npm registry for a new `ember-source` version and call a `webhook` trigger with `Authorization: Bearer` and the trigger's secret. The body it posts becomes the event text after the prompt, so the new version number reaches the agent as data.

## Why run it on Rush?

The upgrade is mechanical until it is not, and the part that is not shows up only when the tests run in a browser. A Rush run has its own sandbox with Node, pnpm, a build and Chrome under Testem, so the agent runs the suite before and after and the two outputs can be compared line by line. Every command, including the `ember-cli-update` run and its conflict list, stays in the run's transcript.

It also separates the attempt from anyone's working tree. A failed upgrade costs nothing but the run: no half-applied blueprint patch on a laptop, no `node_modules` to rebuild. When several apps share the same Ember version, each gets its own run at once and its own pull request, and the conflicts in each are resolved against that app's own edits.

## Frequently asked questions

### Does it jump straight to the newest version or go one release at a time?

For an app one or two minors behind, it goes straight to the target. Across a major version it stops at the last release of the old major first, clears every deprecation there, and only then crosses over, because Ember removes in a major what it deprecated before it. The request's rule against other major bumps keeps that crossing a deliberate, separate run.

### What if my app has no config/ember-cli-update.json?

Then the tool has no recorded blueprint to diff from. The agent reads the `ember-cli` version in `package.json`, passes the blueprint and starting version to `ember-cli-update` explicitly, and commits the generated config file so the next upgrade starts from a recorded state.

### Will it upgrade Ember Data or WarpDrive at the same time?

No. The data packages move on their own schedule and carry their own deprecations, which is why super-rentals keeps five `@warp-drive/*` packages on one tilde range and sets `compatWith` in `ember-cli-build.mjs`. Mixing the two upgrades makes a failing test hard to attribute, so that is a separate request.

## More Ember.js jobs

- [Convert an Ember App From JavaScript to TypeScript](https://getrush.ai/run/convert-javascript-to-typescript/ember/)
- [Fix Deprecations in an Ember App](https://getrush.ai/run/fix-deprecated-apis/ember/)

## More jobs like this: Upgrade dependencies weekly

- [Upgrade the Expo SDK in a React Native App](https://getrush.ai/run/upgrade-expo-sdk/react-native/)
- [Upgrade an Express 4 App to Express 5 in Node.js](https://getrush.ai/run/upgrade-express-5/nodejs/)
- [Upgrade firebase-functions and firebase-admin](https://getrush.ai/run/upgrade-firebase-functions/firebase-functions/)
- [Upgrade Laravel 11 to Laravel 13](https://getrush.ai/run/upgrade-framework-major/laravel/)

## 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/)
