What the agent does
The agent reads the EAS configuration before it writes any YAML, because the workflow should drive the profiles the app already has rather than define new ones. In an app generated from the infinitered/ignite boilerplate, eas.json pins the CLI with "version": ">= 3.15.1" and declares five build profiles: development and development:device for dev clients, preview with distribution: internal, an iOS simulator build and an Android apk, preview:device for installable iOS builds, and an empty production, plus a submit.production entry. package.json already wraps eas build in eight scripts such as build:ios:preview and build:android:prod, every one with --local, so today builds happen on a developer's machine and nowhere else. The repository has no .github directory.
It then reads what a runner needs to reproduce the developer's setup: engines.node of >=20.0.0, pnpm as the package manager in the README's pnpm run instructions, expo 55.0.5 with react-native 0.83.2, app.json with the slug, the com.helloworld bundle identifier and Android package, and app.config.ts, which imports tsx/cjs so the dynamic config can be TypeScript; the runner must install dependencies before eas reads the config, or that import fails. There is no expo-updates in the dependencies and no channel on any profile, so the workflow has nothing to do with EAS Update and the agent does not add it.
The new .github/workflows/eas-build.yml sets up pnpm and Node 20 with the pnpm store cached, installs with pnpm install --frozen-lockfile, and uses expo/expo-github-action with eas-version: latest and token: ${{ secrets.EXPO_TOKEN }} to sign in. On pull_request it runs eas build --profile preview --platform all --non-interactive --no-wait, so the job returns as soon as the builds are queued and the EAS dashboard holds the result; on a v* tag it runs the production profile and waits, so a failed production build fails the workflow. A concurrency group per ref cancels a queued preview when a newer commit arrives, and paths-ignore skips docs-only changes. The agent cannot create the EXPO_TOKEN secret, so the workflow checks for it in a first step and fails with a one-line message naming the setting rather than failing inside eas with a sign-in error.
In its sandbox the agent validates the workflow with actionlint, runs pnpm install and npx eas-cli --version to confirm the CLI resolves on the pinned Node, and runs pnpm compile and pnpm lint:check so the branch it opens is otherwise green. It does not run a build: an EAS build needs the project's Expo account, and a local build of the Android or iOS profile needs an SDK the sandbox does not carry, so the pull request says so and treats the first workflow run on the branch as the proof.
Start it with one API call
POST https://api.phoenix.so/o/{org}/sessions with this body:
{
"agent": "claude",
"input": "Add a GitHub Actions workflow that runs EAS Build for this Expo app. Read eas.json, package.json, app.json, app.config.ts and the README first and use the existing build profiles: preview for pull requests, queued without waiting, and production for version tags, waiting for the result. Use the package manager and Node version the repository expects, sign in with an EXPO_TOKEN secret through expo/expo-github-action, fail early with a clear message when the secret is missing, cancel superseded preview builds, and skip documentation-only changes. Validate the workflow with actionlint, run the type check and lint, and open a pull request that explains which secret to add and where.",
"resources": [
{
"url": "https://github.com/your-org/your-app"
}
]
}- 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.
- 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.
- 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 on its own branch adding .github/workflows/eas-build.yml and a short section in the README on the EXPO_TOKEN secret and the two triggers. eas.json, app.json and package.json are unchanged, so the --local scripts developers use keep working and the profiles the workflow names are the ones they already know.
The description walks through the workflow step by step, names the profile each event uses and why the preview job does not wait, quotes the actionlint, type check and lint output from the sandbox, and lists what it could not verify: the build itself, which needs the account token. It tells the reviewer to add the robot token under the repository's Actions secrets before the first pull request lands.
Before merging, a reviewer adds the secret, re-runs the workflow on the pull request to see the preview builds appear on the EAS dashboard, and decides whether --no-wait suits the team or whether the preview job should block the pull request until the builds finish.
Run it on every new Expo app
Each new app repository gets this request once, with its URL in resources, from the script that creates the repository or by hand from the terminal. Send a request_id, a UUID, in the body so a retried start returns the run it already began rather than opening a second pull request.
With a webhook_url on the key, Rush POSTs run.completed when the turn ends with the result up to 16 KiB, and GET /o/{org}/sessions/{id} names the pull request. A follow-up through POST /o/{org}/sessions/{id}/messages, for example to add an eas submit step on tags, wakes the parked sandbox with the repository and the workflow still there.
The use case this job follows, with its automation and trigger: Hand off a long task.
Why run it on Rush?
The workflow is short, but getting it right means reading how the app builds today: which profiles exist, that the dynamic config needs dependencies installed before the CLI can read it, and that the sandbox cannot stand in for the Expo account. The agent reads those files and writes a workflow that uses what is there, and is honest in the pull request about the one thing only the first run can prove.
On Rush the install, the type check, the lint and the workflow lint run in the agent's own sandbox, and the transcript keeps their output beside the diff, so the reviewer's only remaining job is the secret. A team with several Expo apps can start one run per repository and review one pull request each, instead of adapting one workflow by hand.
Frequently asked questions
Why does the preview job not wait for the build?
An EAS build can take many minutes and the result lives on the EAS dashboard either way. With --no-wait the job returns once the builds are queued, so the pull request's checks finish quickly and the runner is not billed for waiting. The production job on tags waits, so a broken release build fails the workflow.
Where does EXPO_TOKEN come from?
From a robot user or an access token created on expo.dev for the project's account, stored as a repository secret under Actions. The agent cannot create it; the workflow's first step checks the secret is set and stops with a message naming it when it is not.
Will it add EAS Update or submit to the stores?
No. The app has no expo-updates dependency and no channels, so the workflow only builds. Submitting is one more step with eas submit and the submit.production profile that already exists in eas.json; ask for it in a follow-up if the team wants tags to go to TestFlight and Play.
Does the workflow change the local build scripts?
No. The eight build:* scripts with --local stay as they are for developers with Xcode or an Android SDK. The workflow calls eas build directly with the same profile names, so both paths read the same eas.json.
More Expo jobs
More jobs like this: Hand off a long task
- Add an Edge Function to a Supabase Project (Supabase)
- Add a CodeMirror Editor Extension to an Obsidian Plugin (Obsidian plugin)
- Add Autocomplete Suggestions to an Obsidian Plugin (Obsidian plugin)