All jobs

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 RushOpens 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 with this body:

{
  "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.

The use case this job follows, with its automation and trigger: Upgrade dependencies weekly.

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

More jobs like this: Upgrade dependencies weekly

Keep reading