# Add an EAS Build Workflow on GitHub Actions to an Expo App

Yes. An agent adds a GitHub Actions workflow that starts EAS Build for your Expo app, preview on pull requests and production on tags, from your eas.json profiles.

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

## 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`

```json
{
  "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"
    }
  ]
}
```

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

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

- [Set Up GitHub Actions CI for an Expo App](https://getrush.ai/run/add-github-actions-ci/expo/)
- [Add i18n to an Expo App](https://getrush.ai/run/add-i18n/expo/)
- [Add Over-the-Air Updates to an Expo App](https://getrush.ai/run/add-ota-updates/expo/)

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

- [Add an Edge Function to a Supabase Project](https://getrush.ai/run/add-edge-function/supabase/)
- [Add a CodeMirror Editor Extension to an Obsidian Plugin](https://getrush.ai/run/add-editor-extension/obsidian-plugin/)
- [Add Autocomplete Suggestions to an Obsidian Plugin](https://getrush.ai/run/add-editor-suggest/obsidian-plugin/)

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