v3.13.1

* [eas-cli] make large resource class only available for paid users

* update eas.schema.json

* Revert "update eas.schema.json"

This reverts commit 319d998b76a4c6c87d137174d6cf9f90d64b3886.

* apply suggested changes

* update CHANGELOG.md

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -37,7 +37,7 @@ body:
       required: true
     attributes:
       label: Environment
-      description: Run `npx expo-env-info` and `expo doctor`, and paste the output here.
+      description: Run `npx expo-env-info` and `npx expo-doctor`, and paste the output here.
   - type: textarea
     validations:
       required: false

.github/PULL_REQUEST_TEMPLATE

@@ -1,8 +1,5 @@
-<!-- Thanks for contributing to _EAS CLI_! Before you submit your pull request, please make sure to check the following boxes by putting an x in the [ ] (don't: [x ], [ x], do: [x]) -->
-
-# Checklist
-
-- [ ] I've added an entry to [CHANGELOG.md](https://github.com/expo/eas-cli/blob/main/CHANGELOG.md#main) if necessary. You can comment this pull request with `/changelog-entry [breaking-change|new-feature|bug-fix|chore] [message]` and CHANGELOG.md will be updated automatically.
+<!-- If this PR requires a changelog entry, add it by commenting the PR with the command `/changelog-entry [breaking-change|new-feature|bug-fix|chore] [message]`. -->
+<!-- You can skip the changelog check by labeling the PR with "no changelog". -->
 
 # Why
 

.github/internal-actions/notify-slack-on-fail-or-recover/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "printWidth": 100,
+  "singleQuote": true
+}

.github/internal-actions/notify-slack-on-fail-or-recover/action.yml

@@ -0,0 +1,53 @@
+name: notify-slack-on-fail-or-recover
+
+inputs:
+  channel:
+    required: true
+    type: string
+  slack_webhook:
+    required: true
+    type: string
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Get previous workflow run status
+      uses: actions/github-script@v6
+      id: run-status
+      with:
+        script: |
+          const script = require('.github/internal-actions/notify-slack-on-fail-or-recover/main.js');
+          return await script({github, context, core});
+
+    - name: Commit subject
+      shell: bash
+      run: |
+        subject="$(git show --format=%s --quiet | sed 's/"/\\"/g')"
+        echo "${{ fromJSON(steps.run-status.outputs.result).previous }}"
+        echo "SUBJECT=$subject" >> "$GITHUB_ENV"
+
+    - name: Send Slack Success Notification
+      if: fromJSON(steps.run-status.outputs.result).previous == 'failure' && fromJSON(steps.run-status.outputs.result).current == 'success'
+      uses: rtCamp/action-slack-notify@v2
+      env:
+        SLACK_CHANNEL: ${{ inputs.channel }}
+        SLACK_COLOR: good
+        SLACK_ICON: https://github.com/expo-bot.png?size=48
+        SLACK_TITLE: 'Fixed, was failing'
+        SLACK_MESSAGE: ${{ env.SUBJECT }}
+        SLACK_USERNAME: 'EAS CLI CI'
+        SLACK_WEBHOOK: ${{ inputs.slack_webhook }}
+        SLACK_FOOTER: ''
+
+    - name: Send Slack Failure Notification
+      if: fromJSON(steps.run-status.outputs.result).current == 'failure'
+      uses: rtCamp/action-slack-notify@v2
+      env:
+        SLACK_CHANNEL: ${{ inputs.channel }}
+        SLACK_COLOR: danger
+        SLACK_ICON: https://github.com/expo-bot.png?size=48
+        SLACK_TITLE: 'Failed'
+        SLACK_MESSAGE: ${{ env.SUBJECT }}
+        SLACK_USERNAME: 'EAS CLI CI'
+        SLACK_WEBHOOK: ${{ inputs.slack_webhook }}
+        SLACK_FOOTER: ''

.github/internal-actions/notify-slack-on-fail-or-recover/main.js

@@ -0,0 +1,155 @@
+function updateOctokitInstance(github) {
+  updateGithubRestActions(github);
+  addConvenienceMethods(github);
+}
+
+function addConvenienceMethods(github) {
+  Object.assign(github, {
+    // checks if a run is a failure from the perspective of sending Slack
+    // notifications. Works for both runs and run attempts, which should be the
+    // same object shapes.
+    // When a run has not been completed, it fetches the jobs for the workflow
+    // to check if the job is "failing" instead of "failed".
+    async isFailedRun(run) {
+      console.log(`checking run: ${run.id}`);
+      console.log(`status: ${run.status}`);
+      console.log(`conclusion: ${run.conclusion}`);
+      console.log(`run_attempt: ${run.run_attempt}`);
+
+      if (run.status === 'completed') {
+        console.log('completed -- checking conclusion');
+        return run.conclusion === 'failure' || run.conclusion === 'timed_out';
+      }
+
+      const owner = run.repository.owner.login;
+      const repo = run.repository.name;
+      const jobsResp = await github.rest.actions.listJobsForWorkflowRun({
+        owner,
+        repo,
+        run_id: run.id,
+      });
+
+      console.log('checking jobs');
+      const jobs = jobsResp.data;
+      for (const job of jobs.jobs) {
+        if (job.conclusion === 'failure' || job.conclusion === 'timed_out') {
+          console.log('job failed');
+          return true;
+        } else if (job.status === 'completed') {
+          continue;
+        }
+
+        for (const step of job.steps) {
+          if (step.conclusion === 'failure') {
+            console.log('job step failed');
+            return true;
+          }
+        }
+      }
+
+      return false;
+    },
+  });
+}
+
+// github-script's Octokit/REST plugins are out of date, so we have to
+// add our own custom endpoint method
+// see https://octokit.github.io/rest.js/v18#custom-endpoint-methods for
+// documentation
+function updateGithubRestActions(github) {
+  Object.assign(github.rest.actions, {
+    getWorkflowRunAttempt: github.request.defaults({
+      method: 'GET',
+      url: '/repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}',
+      params: {
+        owner: {
+          required: true,
+          type: 'string',
+        },
+        repo: {
+          required: true,
+          type: 'string',
+        },
+        run_id: {
+          required: true,
+          type: 'number',
+        },
+        attempt_number: {
+          required: true,
+          type: 'number',
+        },
+      },
+    }),
+  });
+}
+
+// Returns  { current: 'failure' } | { current: 'success', previous: 'success' | 'failure' } to indicate the failure status
+// of the current and previous runs
+module.exports = async ({ github }) => {
+  const { GITHUB_REPOSITORY, GITHUB_RUN_ID, GITHUB_REF_NAME } = process.env;
+  const [owner, repo] = GITHUB_REPOSITORY.split('/');
+  updateOctokitInstance(github);
+
+  const workflowRunResp = await github.rest.actions.getWorkflowRun({
+    owner,
+    repo,
+    run_id: GITHUB_RUN_ID,
+  });
+
+  const currentRun = workflowRunResp.data;
+  const listWorkflowRunsResp = await github.rest.actions.listWorkflowRuns({
+    owner,
+    repo,
+    workflow_id: currentRun.workflow_id,
+    branch: GITHUB_REF_NAME,
+  });
+  const { workflow_runs } = listWorkflowRunsResp.data;
+
+  if (workflow_runs.length === 1 && workflow_runs[0].run_attempt === 1) {
+    return false;
+  }
+
+  const previousRuns = workflow_runs.filter(
+    (run) => run.status === 'completed' && run.conclusion !== 'cancelled'
+  );
+
+  if (await github.isFailedRun(currentRun)) {
+    return { current: 'failure', previous: null };
+  }
+
+  if (currentRun.run_attempt === 1 && previousRuns.length > 0) {
+    return {
+      current: 'success',
+      previous: (await github.isFailedRun(previousRuns[0])) ? 'failure' : 'success',
+    };
+  }
+
+  for (let i = currentRun.run_attempt - 1; i > 0; i--) {
+    const previousAttemptResp = await github.rest.actions.getWorkflowRunAttempt({
+      owner,
+      repo,
+      run_id: currentRun.id,
+      attempt_number: i,
+    });
+    const previousAttempt = previousAttemptResp.data;
+    if (
+      previousAttempt.conclusion === 'success' ||
+      previousAttempt.conclusion === 'failure' ||
+      previousAttempt.conclusion === 'timed_out'
+    ) {
+      return {
+        current: 'success',
+        previous: (await github.isFailedRun(previousAttempt)) ? 'failure' : 'success',
+      };
+    }
+  }
+
+  if (previousRuns.length > 0) {
+    return {
+      current: 'success',
+      previous: (await github.isFailedRun(previousRuns[0])) ? 'failure' : 'success',
+    };
+  }
+
+  return { current: 'success', previous: 'success' };
+};

.github/internal-actions/notify-slack-on-fail-or-recover/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "notify-slack-on-fail-or-recover",
+  "version": "1.0.0",
+  "description": "A GitHub Action to notify Expo Slack of build failures and recovery.",
+  "main": "main.js",
+  "author": "Expo",
+  "license": "UNLICENSED",
+  "private": true,
+  "devDependencies": {
+    "prettier": "^2.5.1"
+  }
+}

.github/internal-actions/notify-slack-on-fail-or-recover/yarn.lock

@@ -0,0 +1,8 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+[email protected]:
+  version "2.5.1"
+  resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.5.1.tgz#fff75fa9d519c54cf0fce328c1017d94546bc56a"
+  integrity sha512-vBZcPRUR5MZJwoyi3ZoyQlc1rXeEck8KgeC9AwwOn+exuxLxq5toTRDTSaVrXHxelDMHy9zlicw8u66yxoSUFg==

.github/workflows/changelog-bot.yml

@@ -0,0 +1,48 @@
+name: Changelog bot
+
+on:
+  issue_comment:
+    types: [created]
+
+jobs:
+  pr-commented:
+    runs-on: ubuntu-latest
+    if: ${{ github.event.issue.pull_request && github.event.issue.user.login == github.event.comment.user.login && startsWith(github.event.comment.body, '/changelog-entry ') }}
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          token: ${{ secrets.EXPO_BOT_PAT }}
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 18
+      - name: Checkout Pull Request
+        run: hub pr checkout ${{ github.event.issue.number }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Install dependencies
+        working-directory: ./scripts
+        run: yarn install --frozen-lockfile --check-files
+      - name: Add changelog entry
+        working-directory: ./scripts
+        run: |
+          PARAMS=${PR_COMMENT_BODY#/changelog-entry }
+          if [[ ! "$PARAMS" =~ " " ]]; then
+            echo "Invalid /changelog-entry command"
+            exit 1
+          fi
+          CATEGORY=$( cut -d ' ' -f 1 <<< "$PARAMS" | sed -e 's/^[[:space:]]*//' )
+          MESSAGE=$( cut -d ' ' -f 2- <<< "$PARAMS" | sed -e 's/^[[:space:]]*//' )
+          yarn changelog-entry "$CATEGORY" "$MESSAGE"
+        env:
+          GITHUB_PR_AUTHOR: ${{ github.event.issue.user.login }}
+          GITHUB_PR_NUMBER: ${{ github.event.issue.number }}
+          PR_COMMENT_BODY: ${{ github.event.comment.body }}
+      - name: Commit and push
+        run: |
+          # use the last commit author name and email
+          git config --global user.name "$(git --no-pager log --format=format:'%an' -n 1)"
+          git config --global user.email "$(git --no-pager log --format=format:'%ae' -n 1)"
+
+          git add CHANGELOG.md
+          git commit -m "update CHANGELOG.md"
+          git push

.github/workflows/changelog.yml

@@ -1,48 +1,37 @@
-on:
-  issue_comment:
-    types: [created]
+name: CHANGELOG.md PR check
 
-name: Changelog
+on:
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - labeled
+      - unlabeled
 
 jobs:
-  pr-commented:
+  pr-changelog-entry:
+    name: Check CHANGELOG.md updated
     runs-on: ubuntu-latest
-    if: ${{ github.event.issue.pull_request && github.event.issue.user.login == github.event.comment.user.login && startsWith(github.event.comment.body, '/changelog-entry ') }}
     steps:
       - uses: actions/checkout@v2
+      - name: Check if CHANGELOG.md was updated
+        id: changelog-updated
+        uses: tj-actions/changed-files@v35
         with:
-          token: ${{ secrets.EXPO_BOT_PAT }}
-      - uses: actions/setup-node@v2
+          files: CHANGELOG.md
+      - name: Fail if CHANGELOG.md was not updated and the "no changelog" label is absent
+        if: steps.changelog-updated.outputs.any_changed == 'false' && !contains(github.event.pull_request.labels.*.name, 'no changelog')
+        uses: actions/github-script@v6
         with:
-          node-version: 18
-      - name: Checkout Pull Request
-        run: hub pr checkout ${{ github.event.issue.number }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      - name: Install dependencies
-        working-directory: ./scripts
-        run: yarn install --frozen-lockfile --check-files
-      - name: Add changelog entry
-        working-directory: ./scripts
-        run: |
-          PARAMS=${PR_COMMENT_BODY#/changelog-entry }
-          if [[ ! "$PARAMS" =~ " " ]]; then
-            echo "Invalid /changelog-entry command"
-            exit 1
-          fi
-          CATEGORY=$( cut -d ' ' -f 1 <<< "$PARAMS" | sed -e 's/^[[:space:]]*//' )
-          MESSAGE=$( cut -d ' ' -f 2- <<< "$PARAMS" | sed -e 's/^[[:space:]]*//' )
-          yarn changelog-entry "$CATEGORY" "$MESSAGE"
-        env:
-          GITHUB_PR_AUTHOR: ${{ github.event.issue.user.login }}
-          GITHUB_PR_NUMBER: ${{ github.event.issue.number }}
-          PR_COMMENT_BODY: ${{ github.event.comment.body }}
-      - name: Commit and push
-        run: |
-          # use the last commit author name and email
-          git config --global user.name "$(git --no-pager log --format=format:'%an' -n 1)"
-          git config --global user.email "$(git --no-pager log --format=format:'%ae' -n 1)"
-
-          git add CHANGELOG.md
-          git commit -m "update CHANGELOG.md"
-          git push
+          script: |
+            core.setFailed('Please add a changelog entry!')
+      - uses: mshick/[email protected]
+        if: always()
+        with:
+          message-id: changelog-entry-check
+          refresh-message-position: true
+          message: ${{ contains(github.event.pull_request.labels.*.name, 'no changelog') && '⏩ The changelog entry check has been skipped since the "no changelog" label is present.' || '✅ Thank you for adding the changelog entry!' }}
+          message-failure: |
+            ❌ It looks like a changelog entry is missing for this PR. You have two options: you can add it manually, or you can use the changelog bot to do it for you.
+            🤖 To use the bot, simply comment on this PR with the command `/changelog-entry [breaking-change|new-feature|bug-fix|chore] [message]`.
+            ⏩ If this PR doesn't require a changelog entry, such as if it's an internal change that doesn't affect the user experience, you can add the "no changelog" label to the PR.

.github/workflows/release.yml

@@ -161,6 +161,8 @@ jobs:
     needs: publish-to-npm
     steps:
       - uses: actions/checkout@v2
+        with:
+          token: ${{ secrets.EXPO_BOT_PAT }}
       - uses: actions/setup-node@v2
         with:
           node-version: 18
@@ -197,9 +199,9 @@ jobs:
         env:
           SLACK_CHANNEL: eas-cli
           SLACK_COLOR: ${{ job.status }}
-          SLACK_ICON: https://github.com/expo-ci.png?size=48
+          SLACK_ICON: https://github.com/expo-bot.png?size=48
           SLACK_TITLE: 'Released eas-cli@${{ env.EAS_CLI_VERSION }}'
           SLACK_MESSAGE: ${{ env.SLACK_CHANGELOG }}
-          SLACK_USERNAME: 'Expo CI'
+          SLACK_USERNAME: 'EAS CLI CI'
           SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
           SLACK_FOOTER: ''

.github/workflows/test.yml

@@ -1,4 +1,5 @@
 name: Run tests
+
 on:
   push:
     branches: [main]
@@ -25,17 +26,32 @@ jobs:
       - run: yarn typecheck
       - run: yarn test
         if: ${{ !matrix.coverage }}
+        env:
+          NODE_OPTIONS: --max-old-space-size=8192
       - run: yarn test --coverage
         if: ${{ matrix.coverage }}
         env:
           # Oclif seems to cause OOM errors when testing with coverage enabled.
           # Remove this whenever we solved those OOM errors.
-          NODE_OPTIONS: --max-old-space-size=4096
+          NODE_OPTIONS: --max-old-space-size=8192
       - run: yarn lint --max-warnings=0
       - run: yarn install --frozen-lockfile --check-files
         working-directory: ./scripts
-      - run: yarn lint-changelog
       - uses: codecov/codecov-action@v1
         if: ${{ matrix.coverage }}
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
+      - run: yarn lint-changelog
+
+  notify-slack:
+    runs-on: ubuntu-latest
+    needs: test
+    name: Notify Slack
+    if: ${{ github.ref == 'refs/heads/main' && always() }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: Notify Slack
+        uses: ./.github/internal-actions/notify-slack-on-fail-or-recover
+        with:
+          channel: eas-cli
+          slack_webhook: ${{ secrets.SLACK_WEBHOOK }}

CHANGELOG.md

@@ -10,10 +10,202 @@ This is the log of notable changes to EAS CLI and related packages.
 
 ### 🐛 Bug fixes
 
-- Use the new developer-mdn.apple.com subdomain instead of developer.apple.com. ([#1673](https://github.com/expo/eas-cli/pull/1673) by [@brentvatne](https://github.com/brentvatne))
+### 🧹 Chores
+
+- Short format for selecting devices prompt. ([#1840](https://github.com/expo/eas-cli/pull/1840) by [@khamilowicz](https://github.com/khamilowicz))
+- Improve typescript types for user display. ([#1851](https://github.com/expo/eas-cli/pull/1851) by [@wschurman](https://github.com/wschurman))
+- Add error for `large` resource class not available on the free plan to server-side defined errors. ([#1848](https://github.com/expo/eas-cli/pull/1848) by [@szdziedzic](https://github.com/szdziedzic))
+
+## [3.13.0](https://github.com/expo/eas-cli/releases/tag/v3.13.0) - 2023-05-17
+
+### 🎉 New features
+
+- Add clear cache flag to eas update. ([#1839](https://github.com/expo/eas-cli/pull/1839) by [@quinlanj](https://github.com/quinlanj))
+
+### 🐛 Bug fixes
+
+- Fix building iOS projects with framework targets. ([#1835](https://github.com/expo/eas-cli/pull/1835) by [@dsokal](https://github.com/dsokal))
 
 ### 🧹 Chores
 
+- Ignore dirty workingdir when building from GitHub. ([#1842](https://github.com/expo/eas-cli/pull/1842) by [@wkozyra95](https://github.com/wkozyra95))
+- Remove App Specific Password prompt. ([#1843](https://github.com/expo/eas-cli/pull/1843) by [@quinlanj](https://github.com/quinlanj))
+- Validate `CFBundleShortVersionString`. ([#1846](https://github.com/expo/eas-cli/pull/1846) by [@khamilowicz](https://github.com/khamilowicz))
+
+## [3.12.1](https://github.com/expo/eas-cli/releases/tag/v3.12.1) - 2023-05-15
+
+### 🐛 Bug fixes
+
+- Don't submit expired builds. ([#1837](https://github.com/expo/eas-cli/pull/1837) by [@dsokal](https://github.com/dsokal))
+
+### 🧹 Chores
+
+- Change red apple icon to green apple icon on successful build. ([#1828](https://github.com/expo/eas-cli/pull/1828) by [@dchhetri](https://github.com/dchhetri))
+
+## [3.12.0](https://github.com/expo/eas-cli/releases/tag/v3.12.0) - 2023-05-08
+
+### 🎉 New features
+
+- Add `build:version:get` command. ([#1815](https://github.com/expo/eas-cli/pull/1815) by [@wkozyra95](https://github.com/wkozyra95))
+
+### 🧹 Chores
+
+- Upgrade dependencies. ([#1824](https://github.com/expo/eas-cli/pull/1824) by [@dsokal](https://github.com/dsokal))
+
+## [3.11.0](https://github.com/expo/eas-cli/releases/tag/v3.11.0) - 2023-05-05
+
+### 🎉 New features
+
+- Add account list to `eas whoami`/`eas account:view`. ([#1814](https://github.com/expo/eas-cli/pull/1814) by [@wschurman](https://github.com/wschurman))
+- Add `large` resource class for iOS as allowed value in `eas.json`. ([#1817](https://github.com/expo/eas-cli/pull/1817) by [@szdziedzic](https://github.com/szdziedzic))
+
+### 🧹 Chores
+
+- Print request ID on unforeseen GraphQL error for easier tracking and follow up. ([#1813](https://github.com/expo/eas-cli/pull/1813) by [@radoslawkrzemien](https://github.com/radoslawkrzemien))
+
+## [3.10.2](https://github.com/expo/eas-cli/releases/tag/v3.10.2) - 2023-04-25
+
+### 🧹 Chores
+
+- Add info about Xcode 14.3 image to `eas.schema.json`. ([#1808](https://github.com/expo/eas-cli/pull/1808) by [@szdziedzic](https://github.com/szdziedzic))
+- Allow users to select an app to run using the `build:run` command if multiple apps are found in the tarball. ([#1807](https://github.com/expo/eas-cli/pull/1807) by [@szdziedzic](https://github.com/szdziedzic))
+- Don't resolve `default` resource class for iOS in CLI. ([#1734](https://github.com/expo/eas-cli/pull/1734) by [@szdziedzic](https://github.com/szdziedzic))
+
+## [3.10.1](https://github.com/expo/eas-cli/releases/tag/v3.10.1) - 2023-04-25
+
+### 🧹 Chores
+
+- Add `cache.paths` field and deprecate `cache.customPaths`. ([#1794](https://github.com/expo/eas-cli/pull/1794) by [@radoslawkrzemien](https://github.com/radoslawkrzemien))
+
+## [3.10.0](https://github.com/expo/eas-cli/releases/tag/v3.10.0) - 2023-04-21
+
+### 🎉 New features
+
+- Added eas device:rename command. ([#1787](https://github.com/expo/eas-cli/pull/1787) by [@keith-kurak](https://github.com/keith-kurak))
+
+### 🐛 Bug fixes
+
+- Fix `device:delete` not disabling on Apple. ([#1803](https://github.com/expo/eas-cli/pull/1803) by [@keith-kurak](https://github.com/keith-kurak))
+- Fix message truncation for updates. ([#1801](https://github.com/expo/eas-cli/pull/1801) by [@wschurman](https://github.com/wschurman))
+
+### 🧹 Chores
+
+- Throw an error if somebody tries to start iOS build with the `large` resource class selected using the deprecated `--resource-class` flag. ([#1795](https://github.com/expo/eas-cli/pull/1795) by [@szdziedzic](https://github.com/szdziedzic))
+
+## [3.9.3](https://github.com/expo/eas-cli/releases/tag/v3.9.3) - 2023-04-18
+
+### 🐛 Bug fixes
+
+- Fix prompts in `eas update`. ([#1797](https://github.com/expo/eas-cli/pull/1797) by [@wschurman](https://github.com/wschurman))
+
+## [3.9.2](https://github.com/expo/eas-cli/releases/tag/v3.9.2) - 2023-04-13
+
+### 🐛 Bug fixes
+
+- Fixes the rollout percentages when ending a rollout. ([#1781](https://github.com/expo/eas-cli/pull/1781) by [@jonsamp](https://github.com/jonsamp))
+- Print meaningful error message if `extra.eas.projectId` is not a string. ([#1788](https://github.com/expo/eas-cli/pull/1788) by [@dsokal](https://github.com/dsokal))
+
+### 🧹 Chores
+
+- Show output of `expo install expo-updates`. ([#1782](https://github.com/expo/eas-cli/pull/1782) by [@wkozyra95](https://github.com/wkozyra95))
+- Print deprecation warnings for deprecated `eas.json` fields. ([#1768](https://github.com/expo/eas-cli/pull/1768) by [@szdziedzic](https://github.com/szdziedzic))
+
+## [3.9.1](https://github.com/expo/eas-cli/releases/tag/v3.9.1) - 2023-04-10
+
+### 🐛 Bug fixes
+
+- Update apple utilities to work around the maintenance error. ([#1780](https://github.com/expo/eas-cli/pull/1780) by [@byCedric](https://github.com/byCedric))
+
+### 🧹 Chores
+
+- Don't use defaults for the `cache.cacheDefaultPaths` build profile field. ([#1769](https://github.com/expo/eas-cli/pull/1769) by [@szdziedzic](https://github.com/szdziedzic))
+
+## [3.9.0](https://github.com/expo/eas-cli/releases/tag/v3.9.0) - 2023-04-06
+
+### 🎉 New features
+
+- Add support for roll back to embedded updates. ([#1754](https://github.com/expo/eas-cli/pull/1754), [#1755](https://github.com/expo/eas-cli/pull/1755) by [@wschurman](https://github.com/wschurman))
+
+### 🐛 Bug fixes
+
+- Update `expoCommandAsync` to support the new Expo CLI bin path. ([#1772](https://github.com/expo/eas-cli/pull/1772) by [@gabrieldonadel](https://github.com/gabrieldonadel))
+
+### 🧹 Chores
+
+- Use the `eas-cli` npm tag for checking for the local build plugin updates. ([#1759](https://github.com/expo/eas-cli/pull/1759) by [@dsokal](https://github.com/dsokal))
+- Ignore `requireCommit` option in `eas build:internal`. ([#1760](https://github.com/expo/eas-cli/pull/1760) by [@wkozyra95](https://github.com/wkozyra95))
+- Support parsing eas.json from a string. ([#1766](https://github.com/expo/eas-cli/pull/1766) by [@wkozyra95](https://github.com/wkozyra95))
+
+## [3.8.1](https://github.com/expo/eas-cli/releases/tag/v3.8.1) - 2023-03-16
+
+### 🐛 Bug fixes
+
+- Ensure public config is used as update. ([#1745](https://github.com/expo/eas-cli/pull/1745) by [@byCedric](https://github.com/byCedric))
+
+### 🧹 Chores
+
+- Unify how the command errors are displayed. ([#1738](https://github.com/expo/eas-cli/pull/1738) by [@radoslawkrzemien](https://github.com/radoslawkrzemien))
+- Unify the case of base error messages for command failures. ([#1744](https://github.com/expo/eas-cli/pull/1744) by [@radoslawkrzemien](https://github.com/radoslawkrzemien))
+
+## [3.8.0](https://github.com/expo/eas-cli/releases/tag/v3.8.0) - 2023-03-13
+
+### 🎉 New features
+
+- Add new `m-medium` and `m-large` resource classes. ([#1739](https://github.com/expo/eas-cli/pull/1739) by [@szdziedzic](https://github.com/szdziedzic))
+
+## [3.7.2](https://github.com/expo/eas-cli/releases/tag/v3.7.2) - 2023-02-24
+
+### 🐛 Bug fixes
+
+- Implement Apple's proprietary Hashcash algorithm for signing authentication requests. ([#1719](https://github.com/expo/eas-cli/pull/1719) by [@EvanBacon](https://github.com/EvanBacon))
+
+## [3.7.1](https://github.com/expo/eas-cli/releases/tag/v3.7.1) - 2023-02-23
+
+### 🐛 Bug fixes
+
+- Bump `@expo/apple-utils` to fix Apple developer auth. ([03c76c1](https://github.com/expo/eas-cli/commit/03c76c1e0efb9ec55e40b45e33c80b3479f920c3) by [@brentvatne](https://github.com/brentvatne))
+
+## [3.7.0](https://github.com/expo/eas-cli/releases/tag/v3.7.0) - 2023-02-23
+
+### 🎉 New features
+
+- Support variant detection for package\*UniversalApk Gradle Commands. ([#1708](https://github.com/expo/eas-cli/pull/1708) by [@frw](https://github.com/frw))
+
+## [3.6.1](https://github.com/expo/eas-cli/releases/tag/v3.6.1) - 2023-02-20
+
+### 🐛 Bug fixes
+
+- Disable analytics when running behind a proxy. ([#1696](https://github.com/expo/eas-cli/pull/1696) by [@wkozyra95](https://github.com/wkozyra95))
+- Clarify missing owner field error message for Robot users. ([#1702](https://github.com/expo/eas-cli/pull/1702) by [@wschurman](https://github.com/wschurman))
+
+### 🧹 Chores
+
+- Validate the platform for local builds earlier. ([#1698](https://github.com/expo/eas-cli/pull/1698) by [@wkozyra95](https://github.com/wkozyra95))
+- Display build message when picking build in `eas submit`, `eas build:resign`, and `eas build:run` commands. ([#1700](https://github.com/expo/eas-cli/pull/1700) by [@szdziedzic](https://github.com/szdziedzic))
+- Add a link directly to a build phase logs in the EAS CLI build error message. ([#1699](https://github.com/expo/eas-cli/pull/1699) by [@szdziedzic](https://github.com/szdziedzic))
+
+## [3.6.0](https://github.com/expo/eas-cli/releases/tag/v3.6.0) - 2023-02-14
+
+### 🎉 New features
+
+- Use `sdkVersion` as default runtime version policy when running `eas update:configure`. ([#1669](https://github.com/expo/eas-cli/pull/1669) by [@jonsamp](https://github.com/jonsamp))
+- Warn when project ID but no owner specified and mismatch logged in user. ([#1667](https://github.com/expo/eas-cli/pull/1667) by [@wschurman](https://github.com/wschurman))
+- Return the build `message` if one is available. ([#1691](https://github.com/expo/eas-cli/pull/1691) by [@raulriera](https://github.com/raulriera))
+
+### 🐛 Bug fixes
+
+- Fix suggested application identifier to match owning account name. ([#1670](https://github.com/expo/eas-cli/pull/1670) by [@wschurman](https://github.com/wschurman))
+
+### 🧹 Chores
+
+- Add Xcode 14.2 image to the VSCode schema. ([#1693](https://github.com/expo/eas-cli/pull/1693) by [@szdziedzic](https://github.com/szdziedzic))
+
+## [3.5.2](https://github.com/expo/eas-cli/releases/tag/v3.5.2) - 2023-02-05
+
+### 🐛 Bug fixes
+
+- Use the new developer-mdn.apple.com subdomain instead of developer.apple.com. ([#1673](https://github.com/expo/eas-cli/pull/1673) by [@brentvatne](https://github.com/brentvatne))
+
 ## [3.5.1](https://github.com/expo/eas-cli/releases/tag/v3.5.1) - 2023-02-01
 
 ### 🐛 Bug fixes

lerna.json

@@ -1,6 +1,6 @@
 {
   "npmClient": "yarn",
   "useWorkspaces": true,
-  "version": "3.5.2",
+  "version": "3.13.1",
   "$schema": "node_modules/lerna/schemas/lerna-schema.json"
 }

package.json

@@ -14,7 +14,7 @@
     "eas": "packages/eas-cli/bin/run",
     "lint": "eslint .",
     "lint-changelog": "./scripts/bin/run lint-changelog",
-    "release": "./scripts/bin/run release",
+    "release": "lerna run rebuild && ./scripts/bin/run release",
     "test": "jest",
     "clean": "lerna run clean && rm -rf node_modules coverage"
   },

packages/eas-cli/jest/global-setup.ts

@@ -2,4 +2,5 @@ module.exports = async () => {
   process.env.TZ = 'UTC';
   process.env.EAS_NO_VCS = '1';
   process.env.EAS_PROJECT_ROOT = '/app';
+  process.env.FORCE_COLOR = '1';
 };

packages/eas-cli/package.json

@@ -1,20 +1,20 @@
 {
   "name": "eas-cli",
   "description": "EAS command line tool",
-  "version": "3.5.2",
+  "version": "3.13.1",
   "author": "Expo <[email protected]>",
   "bin": {
     "eas": "./bin/run"
   },
   "bugs": "https://github.com/expo/eas-cli/issues",
   "dependencies": {
-    "@expo/apple-utils": "0.0.0-alpha.37",
+    "@expo/apple-utils": "1.2.0",
     "@expo/code-signing-certificates": "0.0.5",
     "@expo/config": "7.0.3",
-    "@expo/config-plugins": "5.0.4",
+    "@expo/config-plugins": "6.0.2",
     "@expo/config-types": "47.0.0",
-    "@expo/eas-build-job": "0.2.103",
-    "@expo/eas-json": "3.5.0",
+    "@expo/eas-build-job": "1.0.13",
+    "@expo/eas-json": "3.13.0",
     "@expo/json-file": "8.2.37",
     "@expo/multipart-body-parser": "1.1.0",
     "@expo/osascript": "2.0.33",
@@ -27,6 +27,7 @@
     "@expo/results": "1.0.0",
     "@expo/rudder-sdk-node": "1.1.1",
     "@expo/spawn-async": "1.7.0",
+    "@expo/steps": "1.0.13",
     "@expo/timeago.js": "1.0.0",
     "@oclif/core": "1.23.2",
     "@oclif/plugin-autocomplete": "1.3.10",
@@ -202,7 +203,8 @@
   "repository": "expo/eas-cli",
   "scripts": {
     "postpack": "rimraf oclif.manifest.json",
-    "prepack": "rimraf build && yarn build && node ./scripts/prepack.js",
+    "prepack": "yarn rebuild && node ./scripts/prepack.js",
+    "rebuild": "rimraf build && yarn build",
     "pretarball-ci": "./scripts/pretarball-ci.sh",
     "build": "tsc --project tsconfig.build.json",
     "watch": "yarn build --watch --preserveWatchOutput",

packages/eas-cli/src/__tests__/commands/__snapshots__/build-version-get-test.ts.snap

@@ -0,0 +1,3 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`BuildVersionGetView reading version when appVersionSource is set to local  1`] = `"This project is not configured for using remote version source. Add {"cli": { "appVersionSource": "remote" }} in eas.json or re-run this command without "--non-interactive" flag."`;

packages/eas-cli/src/__tests__/commands/build-version-get-test.ts

@@ -0,0 +1,161 @@
+import { AppVersionSource, EasJson } from '@expo/eas-json';
+import chalk from 'chalk';
+
+import BuildVersionGetView from '../../commands/build/version/get';
+import { AppVersionQuery } from '../../graphql/queries/AppVersionQuery';
+import Log from '../../log';
+import { enableJsonOutput, printJsonOnlyOutput } from '../../utils/json';
+import { getMockEasJson, mockCommandContext, mockProjectId, mockTestCommand } from './utils';
+
+jest.mock('../../project/applicationIdentifier');
+jest.mock('fs');
+jest.mock('../../log');
+jest.mock('../../utils/json');
+jest.mock('../../graphql/queries/AppVersionQuery');
+
+function withRemoteVersionSource(easJson: EasJson): EasJson {
+  return {
+    ...easJson,
+    cli: {
+      ...easJson.cli,
+      appVersionSource: AppVersionSource.REMOTE,
+    },
+  };
+}
+
+describe(BuildVersionGetView, () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+  test('reading version for platform android', async () => {
+    const ctx = mockCommandContext(BuildVersionGetView, {
+      easJson: withRemoteVersionSource(getMockEasJson()),
+    });
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => ({
+      buildVersion: '100',
+      storeVersion: '1.0.0',
+    }));
+
+    const cmd = mockTestCommand(BuildVersionGetView, ['--platform=android'], ctx);
+    await cmd.run();
+    expect(AppVersionQuery.latestVersionAsync).toHaveBeenCalledWith(
+      ctx.loggedIn.graphqlClient,
+      mockProjectId,
+      'ANDROID',
+      'eas.test.com'
+    );
+    expect(Log.log).toHaveBeenCalledWith(`Android versionCode - ${chalk.bold('100')}`);
+    expect(enableJsonOutput).not.toHaveBeenCalled();
+    expect(printJsonOnlyOutput).not.toHaveBeenCalled();
+  });
+
+  test('reading version for platform android when no remote version is set', async () => {
+    const ctx = mockCommandContext(BuildVersionGetView, {
+      easJson: withRemoteVersionSource(getMockEasJson()),
+    });
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => null);
+
+    const cmd = mockTestCommand(BuildVersionGetView, ['--platform=android'], ctx);
+    await cmd.run();
+    expect(AppVersionQuery.latestVersionAsync).toHaveBeenCalledWith(
+      ctx.loggedIn.graphqlClient,
+      mockProjectId,
+      'ANDROID',
+      'eas.test.com'
+    );
+    expect(Log.log).toHaveBeenCalledWith(`No remote versions are configured for this project.`);
+    expect(enableJsonOutput).not.toHaveBeenCalled();
+    expect(printJsonOnlyOutput).not.toHaveBeenCalled();
+  });
+
+  test('reading version with --json flag for platform android', async () => {
+    const ctx = mockCommandContext(BuildVersionGetView, {
+      easJson: withRemoteVersionSource(getMockEasJson()),
+    });
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => ({
+      buildVersion: '100',
+      storeVersion: '1.0.0',
+    }));
+
+    const cmd = mockTestCommand(
+      BuildVersionGetView,
+      ['--non-interactive', '--json', '--platform=android'],
+      ctx
+    );
+    await cmd.run();
+    expect(AppVersionQuery.latestVersionAsync).toHaveBeenCalledWith(
+      ctx.loggedIn.graphqlClient,
+      mockProjectId,
+      'ANDROID',
+      'eas.test.com'
+    );
+    expect(enableJsonOutput).toHaveBeenCalled();
+    expect(printJsonOnlyOutput).toHaveBeenCalledWith({
+      versionCode: '100',
+    });
+  });
+
+  test('reading version with --json flag for platform ios', async () => {
+    const ctx = mockCommandContext(BuildVersionGetView, {
+      easJson: withRemoteVersionSource(getMockEasJson()),
+    });
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => ({
+      buildVersion: '100',
+      storeVersion: '1.0.0',
+    }));
+
+    const cmd = mockTestCommand(
+      BuildVersionGetView,
+      ['--non-interactive', '--json', '--platform=ios'],
+      ctx
+    );
+    await cmd.run();
+    expect(AppVersionQuery.latestVersionAsync).toHaveBeenCalledWith(
+      ctx.loggedIn.graphqlClient,
+      mockProjectId,
+      'IOS',
+      'eas.test.com'
+    );
+    expect(enableJsonOutput).toHaveBeenCalled();
+    expect(printJsonOnlyOutput).toHaveBeenCalledWith({
+      buildNumber: '100',
+    });
+  });
+
+  test('reading version with --json flag when no remote version is set', async () => {
+    const ctx = mockCommandContext(BuildVersionGetView, {
+      easJson: withRemoteVersionSource(getMockEasJson()),
+    });
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => null);
+
+    const cmd = mockTestCommand(
+      BuildVersionGetView,
+      ['--non-interactive', '--json', '--platform=android'],
+      ctx
+    );
+    await cmd.run();
+    expect(AppVersionQuery.latestVersionAsync).toHaveBeenCalledWith(
+      ctx.loggedIn.graphqlClient,
+      mockProjectId,
+      'ANDROID',
+      'eas.test.com'
+    );
+    expect(enableJsonOutput).toHaveBeenCalled();
+    expect(printJsonOnlyOutput).toHaveBeenCalledWith({});
+  });
+
+  test('reading version when appVersionSource is set to local ', async () => {
+    const ctx = mockCommandContext(BuildVersionGetView, {});
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => ({
+      buildVersion: '100',
+      storeVersion: '1.0.0',
+    }));
+
+    const cmd = mockTestCommand(
+      BuildVersionGetView,
+      ['--non-interactive', '--json', '--platform=android'],
+      ctx
+    );
+    await expect(cmd.run()).rejects.toThrowErrorMatchingSnapshot();
+  });
+});

packages/eas-cli/src/__tests__/commands/build-version-set-test.ts

@@ -0,0 +1,140 @@
+import { AppVersionSource, EasJson } from '@expo/eas-json';
+import fs from 'fs-extra';
+import path from 'path';
+
+import BuildVersionSetView from '../../commands/build/version/set';
+import { AppVersionMutation } from '../../graphql/mutations/AppVersionMutation';
+import { AppQuery } from '../../graphql/queries/AppQuery';
+import { AppVersionQuery } from '../../graphql/queries/AppVersionQuery';
+import Log from '../../log';
+import * as prompts from '../../prompts';
+import {
+  getMockAppFragment,
+  getMockEasJson,
+  mockCommandContext,
+  mockProjectId,
+  mockTestCommand,
+} from './utils';
+
+jest.mock('../../project/applicationIdentifier');
+jest.mock('../../graphql/queries/AppVersionQuery');
+jest.mock('../../graphql/queries/AppQuery');
+jest.mock('../../graphql/mutations/AppVersionMutation');
+jest.mock('fs');
+jest.mock('../../log');
+jest.mock('../../prompts');
+jest.mock('../../utils/json');
+
+function withRemoteVersionSource(easJson: EasJson): EasJson {
+  return {
+    ...easJson,
+    cli: {
+      ...easJson.cli,
+      appVersionSource: AppVersionSource.REMOTE,
+    },
+  };
+}
+
+describe(BuildVersionSetView, () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('setting version for platform android', async () => {
+    const ctx = mockCommandContext(BuildVersionSetView, {
+      easJson: withRemoteVersionSource(getMockEasJson()),
+    });
+    jest.mocked(AppQuery.byIdAsync).mockImplementation(async () => getMockAppFragment());
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => null);
+    jest.mocked(prompts.promptAsync).mockImplementation(async () => ({
+      version: '1000',
+    }));
+
+    const cmd = mockTestCommand(BuildVersionSetView, ['--platform=android'], ctx);
+    await cmd.run();
+    expect(AppVersionQuery.latestVersionAsync).toHaveBeenCalledWith(
+      ctx.loggedIn.graphqlClient,
+      mockProjectId,
+      'ANDROID',
+      'eas.test.com'
+    );
+    expect(AppVersionMutation.createAppVersionAsync).toHaveBeenCalledWith(
+      ctx.loggedIn.graphqlClient,
+      expect.objectContaining({
+        buildVersion: '1000',
+        storeVersion: '1.0.0',
+      })
+    );
+  });
+
+  test('printing current remote version before prompting for a new one', async () => {
+    const ctx = mockCommandContext(BuildVersionSetView, {
+      easJson: withRemoteVersionSource(getMockEasJson()),
+    });
+    jest.mocked(AppQuery.byIdAsync).mockImplementation(async () => getMockAppFragment());
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => ({
+      buildVersion: '100',
+      storeVersion: '1.0.0',
+    }));
+    jest.mocked(prompts.promptAsync).mockImplementation(async () => ({
+      version: '1000',
+    }));
+
+    const cmd = mockTestCommand(BuildVersionSetView, ['--platform=android'], ctx);
+    await cmd.run();
+    expect(Log.log).toHaveBeenCalledWith(expect.stringMatching('configured with versionCode 100'));
+    expect(AppVersionQuery.latestVersionAsync).toHaveBeenCalledWith(
+      ctx.loggedIn.graphqlClient,
+      mockProjectId,
+      'ANDROID',
+      'eas.test.com'
+    );
+  });
+
+  test('printing info that there is no remote version configured', async () => {
+    const ctx = mockCommandContext(BuildVersionSetView, {
+      easJson: withRemoteVersionSource(getMockEasJson()),
+    });
+    jest.mocked(AppQuery.byIdAsync).mockImplementation(async () => getMockAppFragment());
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => null);
+    jest.mocked(prompts.promptAsync).mockImplementation(async () => ({
+      version: '1000',
+    }));
+
+    const cmd = mockTestCommand(BuildVersionSetView, ['--platform=android'], ctx);
+    await cmd.run();
+    expect(Log.log).toHaveBeenCalledWith(
+      expect.stringMatching('does not have any versionCode configured')
+    );
+    expect(AppVersionQuery.latestVersionAsync).toHaveBeenCalledWith(
+      ctx.loggedIn.graphqlClient,
+      mockProjectId,
+      'ANDROID',
+      'eas.test.com'
+    );
+  });
+
+  test('setting version aborts when appVersionSource is set to local and users refuse auto configuration', async () => {
+    const ctx = mockCommandContext(BuildVersionSetView, {});
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => null);
+    jest.mocked(AppQuery.byIdAsync).mockImplementation(async () => getMockAppFragment());
+    jest.mocked(prompts.confirmAsync).mockImplementation(async () => false);
+
+    const cmd = mockTestCommand(BuildVersionSetView, ['--platform=android'], ctx);
+    await expect(cmd.run()).rejects.toThrowError('Aborting...');
+    expect(AppVersionMutation.createAppVersionAsync).not.toHaveBeenCalledWith();
+  });
+
+  test('setting version when appVersionSource is set to local and user allows auto configuration', async () => {
+    const ctx = mockCommandContext(BuildVersionSetView, {});
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => null);
+    jest.mocked(AppQuery.byIdAsync).mockImplementation(async () => getMockAppFragment());
+    jest.mocked(prompts.confirmAsync).mockImplementation(async () => true);
+
+    const cmd = mockTestCommand(BuildVersionSetView, ['--platform=android'], ctx);
+    await cmd.run();
+
+    const easJsonAfterCmd = await fs.readJson(path.join(ctx.projectDir, 'eas.json'));
+    expect(easJsonAfterCmd.cli.appVersionSource).toBe('remote');
+  });
+});

packages/eas-cli/src/__tests__/commands/build-version-sync-test.ts

@@ -0,0 +1,204 @@
+import { Workflow } from '@expo/eas-build-job';
+import { AppVersionSource, EasJson } from '@expo/eas-json';
+import fs from 'fs-extra';
+import path from 'path';
+
+import { updateNativeVersionsAsync as updateAndroidNativeVersionsAsync } from '../../build/android/version';
+import { updateNativeVersionsAsync as updateIosNativeVersionsAsync } from '../../build/ios/version';
+import BuildVersionSyncView from '../../commands/build/version/sync';
+import { Target } from '../../credentials/ios/types';
+import { AppVersionMutation } from '../../graphql/mutations/AppVersionMutation';
+import { AppQuery } from '../../graphql/queries/AppQuery';
+import { AppVersionQuery } from '../../graphql/queries/AppVersionQuery';
+import { getAppBuildGradleAsync } from '../../project/android/gradleUtils';
+import { resolveTargetsAsync } from '../../project/ios/target';
+import { resolveWorkflowAsync } from '../../project/workflow';
+import * as prompts from '../../prompts';
+import {
+  getMockAppFragment,
+  getMockEasJson,
+  mockCommandContext,
+  mockProjectId,
+  mockTestCommand,
+} from './utils';
+
+jest.mock('../../build/android/version');
+jest.mock('../../build/ios/version');
+jest.mock('../../project/applicationIdentifier');
+jest.mock('../../graphql/queries/AppVersionQuery');
+jest.mock('../../graphql/queries/AppQuery');
+jest.mock('../../graphql/mutations/AppVersionMutation');
+jest.mock('../../project/workflow');
+jest.mock('../../project/android/gradleUtils');
+jest.mock('../../project/ios/target');
+jest.mock('../../project/ios/scheme');
+jest.mock('fs');
+jest.mock('../../log');
+jest.mock('../../prompts');
+jest.mock('../../utils/json');
+
+function withRemoteVersionSource(easJson: EasJson): EasJson {
+  return {
+    ...easJson,
+    cli: {
+      ...easJson.cli,
+      appVersionSource: AppVersionSource.REMOTE,
+    },
+  };
+}
+
+describe(BuildVersionSyncView, () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('syncing version for managed project on platform android', async () => {
+    const ctx = mockCommandContext(BuildVersionSyncView, {
+      easJson: withRemoteVersionSource(getMockEasJson()),
+    });
+    jest.mocked(AppQuery.byIdAsync).mockImplementation(async () => getMockAppFragment());
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => ({
+      buildVersion: '1000',
+      storeVersion: '0.0.1',
+    }));
+    jest.mocked(prompts.promptAsync).mockImplementation(async () => ({
+      version: '1000',
+    }));
+    jest.mocked(resolveWorkflowAsync).mockImplementation(async () => Workflow.MANAGED);
+
+    const cmd = mockTestCommand(BuildVersionSyncView, ['--platform=android'], ctx);
+    const syncAndroidAsync = jest.spyOn(cmd, 'syncAndroidAsync' as any);
+
+    await cmd.run();
+    expect(AppVersionQuery.latestVersionAsync).toHaveBeenCalledWith(
+      ctx.loggedIn.graphqlClient,
+      mockProjectId,
+      'ANDROID',
+      'eas.test.com'
+    );
+    expect(syncAndroidAsync).not.toHaveBeenCalled();
+  });
+
+  test('syncing version for bare project on platform android', async () => {
+    const ctx = mockCommandContext(BuildVersionSyncView, {
+      easJson: withRemoteVersionSource(getMockEasJson()),
+    });
+    jest.mocked(AppQuery.byIdAsync).mockImplementation(async () => getMockAppFragment());
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => ({
+      buildVersion: '1000',
+      storeVersion: '0.0.1',
+    }));
+    jest.mocked(prompts.promptAsync).mockImplementation(async () => ({
+      version: '1000',
+    }));
+    jest.mocked(resolveWorkflowAsync).mockImplementation(async () => Workflow.GENERIC);
+    jest.mocked(getAppBuildGradleAsync).mockImplementation(async () => ({
+      android: {},
+    }));
+
+    const cmd = mockTestCommand(BuildVersionSyncView, ['--platform=android'], ctx);
+    const syncAndroidAsync = jest.spyOn(cmd, 'syncAndroidAsync' as any);
+
+    await cmd.run();
+    expect(AppVersionQuery.latestVersionAsync).toHaveBeenCalledWith(
+      ctx.loggedIn.graphqlClient,
+      mockProjectId,
+      'ANDROID',
+      'eas.test.com'
+    );
+    expect(syncAndroidAsync).toHaveBeenCalled();
+    expect(updateAndroidNativeVersionsAsync).toHaveBeenCalledWith({
+      projectDir: ctx.projectDir,
+      versionCode: 1000,
+    });
+  });
+
+  test('syncing version for managed project on platform ios', async () => {
+    const ctx = mockCommandContext(BuildVersionSyncView, {
+      easJson: withRemoteVersionSource(getMockEasJson()),
+    });
+    jest.mocked(AppQuery.byIdAsync).mockImplementation(async () => getMockAppFragment());
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => ({
+      buildVersion: '1000',
+      storeVersion: '0.0.1',
+    }));
+    jest.mocked(prompts.promptAsync).mockImplementation(async () => ({
+      version: '1000',
+    }));
+    jest.mocked(resolveWorkflowAsync).mockImplementation(async () => Workflow.MANAGED);
+
+    const cmd = mockTestCommand(BuildVersionSyncView, ['--platform=ios'], ctx);
+    const syncIosAsync = jest.spyOn(cmd, 'syncIosAsync' as any);
+
+    await cmd.run();
+    expect(AppVersionQuery.latestVersionAsync).toHaveBeenCalledWith(
+      ctx.loggedIn.graphqlClient,
+      mockProjectId,
+      'IOS',
+      'eas.test.com'
+    );
+    expect(syncIosAsync).not.toHaveBeenCalled();
+  });
+
+  test('syncing version for bare project on platform ios', async () => {
+    const ctx = mockCommandContext(BuildVersionSyncView, {
+      easJson: withRemoteVersionSource(getMockEasJson()),
+    });
+    const fakeTarget: Target = {
+      targetName: 'testapp',
+      bundleIdentifier: 'eas.test.com',
+      entitlements: {},
+    };
+    jest.mocked(AppQuery.byIdAsync).mockImplementation(async () => getMockAppFragment());
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => ({
+      buildVersion: '1000',
+      storeVersion: '0.0.1',
+    }));
+    jest.mocked(prompts.promptAsync).mockImplementation(async () => ({
+      version: '1000',
+    }));
+    jest.mocked(resolveWorkflowAsync).mockImplementation(async () => Workflow.GENERIC);
+    jest.mocked(resolveTargetsAsync).mockImplementation(async () => [fakeTarget]);
+
+    const cmd = mockTestCommand(BuildVersionSyncView, ['--platform=ios'], ctx);
+    const syncIosAsync = jest.spyOn(cmd, 'syncIosAsync' as any);
+
+    await cmd.run();
+    expect(AppVersionQuery.latestVersionAsync).toHaveBeenCalledWith(
+      ctx.loggedIn.graphqlClient,
+      mockProjectId,
+      'IOS',
+      'eas.test.com'
+    );
+    expect(syncIosAsync).toHaveBeenCalled();
+    expect(updateIosNativeVersionsAsync).toHaveBeenCalledWith({
+      buildNumber: '1000',
+      projectDir: ctx.projectDir,
+      targets: [fakeTarget],
+    });
+  });
+
+  test('syncing version aborts when appVersionSource is set to local and users refuse auto configuration', async () => {
+    const ctx = mockCommandContext(BuildVersionSyncView, {});
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => null);
+    jest.mocked(AppQuery.byIdAsync).mockImplementation(async () => getMockAppFragment());
+    jest.mocked(prompts.confirmAsync).mockImplementation(async () => false);
+
+    const cmd = mockTestCommand(BuildVersionSyncView, ['--platform=android'], ctx);
+    await expect(cmd.run()).rejects.toThrowError('Aborting...');
+    expect(AppVersionMutation.createAppVersionAsync).not.toHaveBeenCalledWith();
+  });
+
+  test('syncing version when appVersionSource is set to local and user allows auto configuration', async () => {
+    const ctx = mockCommandContext(BuildVersionSyncView, {});
+    jest.mocked(AppVersionQuery.latestVersionAsync).mockImplementation(async () => null);
+    jest.mocked(AppQuery.byIdAsync).mockImplementation(async () => getMockAppFragment());
+    jest.mocked(prompts.confirmAsync).mockImplementation(async () => true);
+
+    const cmd = mockTestCommand(BuildVersionSyncView, ['--platform=android'], ctx);
+    await cmd.run();
+
+    const easJsonAfterCmd = await fs.readJson(path.join(ctx.projectDir, 'eas.json'));
+    expect(easJsonAfterCmd.cli.appVersionSource).toBe('remote');
+  });
+});

packages/eas-cli/src/__tests__/commands/utils.ts

@@ -0,0 +1,140 @@
+import { ExpoConfig } from '@expo/config-types';
+import { EasJson } from '@expo/eas-json';
+import { Command, Config } from '@oclif/core';
+import { vol } from 'memfs';
+import path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+
+import { ContextInput, ContextOutput } from '../../commandUtils/EasCommand';
+import { DynamicConfigContextFn } from '../../commandUtils/context/DynamicProjectConfigContextField';
+import { AppFragment, Role } from '../../graphql/generated';
+
+export function getMockEasJson(): EasJson {
+  return {
+    cli: {},
+    build: {
+      production: {},
+    },
+  };
+}
+
+export const mockProjectId = 'fake-project-id';
+
+export function getMockAppFragment(): AppFragment {
+  return {
+    id: mockProjectId,
+    slug: 'testapp',
+    fullName: '@testuser/testpp',
+    ownerAccount: {
+      id: 'test-account-id',
+      name: 'testuser',
+      users: [
+        {
+          role: Role.Owner,
+          actor: {
+            id: 'test-user-id',
+          },
+        },
+      ],
+    },
+  };
+}
+
+export function getMockExpoConfig(): ExpoConfig {
+  return {
+    name: 'testapp',
+    slug: 'tetsapp',
+    extra: {
+      projectId: mockProjectId,
+    },
+  };
+}
+
+export interface LocalProjectContext {
+  projectDir: string;
+  exp?: ExpoConfig;
+  appId?: string;
+}
+
+export function mockCommandContext<
+  C extends {
+    [name: string]: any;
+  } = object
+>(
+  commandClass: { contextDefinition: ContextInput<C> },
+  overrides: {
+    easJson?: EasJson;
+    exp?: ExpoConfig;
+    projectId?: string;
+    getDynamicProjectConfigAsync?: DynamicConfigContextFn;
+  }
+): ContextOutput<C> {
+  const projectDir = path.join('/test', uuidv4());
+  vol.reset();
+  vol.fromJSON({ 'eas.json': JSON.stringify(overrides.easJson ?? getMockEasJson()) }, projectDir);
+  const contextDefinition = commandClass.contextDefinition;
+
+  const result: any = {};
+  for (const [contextKey] of Object.entries(contextDefinition)) {
+    if (contextKey === 'loggedIn') {
+      result.loggedIn = {};
+    }
+
+    if (contextKey === 'projectDir') {
+      result.projectDir = projectDir;
+    }
+    if (contextKey === 'maybeLoggedIn') {
+      result.maybeLoggedIn = {};
+    }
+    if (contextKey === 'sessionManager') {
+      result.sessionManager = {};
+    }
+    if (contextKey === 'projectConfig') {
+      result.projectConfig = {
+        exp: overrides.exp ?? getMockExpoConfig(),
+        projectId: overrides.projectId ?? mockProjectId,
+        projectDir,
+      };
+    }
+    if (contextKey === 'getDynamicProjectConfigAsync') {
+      result.getDynamicProjectConfigAsync = () => ({
+        exp: overrides.exp ?? getMockExpoConfig(),
+        projectId: overrides.projectId ?? mockProjectId,
+        projectDir,
+      });
+    }
+  }
+  return result;
+}
+
+export function mockTestCommand<T extends Command>(
+  commandConstructor: new (argv: string[], config: Config) => T,
+  argv: string[],
+  ctx: any
+): T {
+  const cmd = new commandConstructor(argv, new Config({ root: __dirname }));
+  (cmd as any).getContextAsync = jest.fn(() => ctx);
+  return cmd;
+}
+
+export class NoErrorThrownError extends Error {}
+
+export const getErrorAsync = async <TError = any>(
+  call: () => unknown
+): Promise<TError | NoErrorThrownError> => {
+  try {
+    await call();
+    throw new NoErrorThrownError();
+  } catch (error: unknown) {
+    return error as TError;
+  }
+};
+
+export const getError = <TError = any>(call: () => unknown): TError | NoErrorThrownError => {
+  try {
+    call();
+    throw new NoErrorThrownError();
+  } catch (error: unknown) {
+    return error as TError;
+  }
+};

packages/eas-cli/src/analytics/AnalyticsManager.ts

@@ -133,7 +133,9 @@ export async function createAnalyticsAsync(): Promise<AnalyticsWithOrchestration
     await UserSettings.setAsync(USER_SETTINGS_KEY_ANALYTICS_ENABLED, false);
   }
 
-  const analyticsEnabled = await UserSettings.getAsync(USER_SETTINGS_KEY_ANALYTICS_ENABLED, true);
+  const analyticsEnabled =
+    !process.env.https_proxy && // disable analytics if running behind proxy
+    (await UserSettings.getAsync(USER_SETTINGS_KEY_ANALYTICS_ENABLED, true));
   if (!analyticsEnabled) {
     return new NoOpAnalytics();
   }

packages/eas-cli/src/build/__tests__/handleBuildRequestError-test.ts

@@ -0,0 +1,510 @@
+import { Platform } from '@expo/eas-build-job';
+import { CombinedError } from '@urql/core';
+import { GraphQLError } from 'graphql/error';
+import { v4 as uuidv4 } from 'uuid';
+
+import { getError } from '../../__tests__/commands/utils';
+import { EasCommandError } from '../../commandUtils/errors';
+import Build from '../../commands/build';
+import Log, { link } from '../../log';
+import { handleBuildRequestError } from '../build';
+import {
+  EasBuildDownForMaintenanceError,
+  EasBuildFreeTierDisabledAndroidError,
+  EasBuildFreeTierDisabledError,
+  EasBuildFreeTierDisabledIOSError,
+  EasBuildResourceClassNotAvailableInFreeTierError,
+  EasBuildTooManyPendingBuildsError,
+  RequestValidationError,
+  TurtleDeprecatedJobFormatError,
+} from '../errors';
+
+beforeEach(() => {
+  jest.resetAllMocks();
+});
+
+const EXPECTED_STRINGIFIED_GRAPHQL_ERROR_JSON = `[
+  {
+    "message": "Error 1"
+  },
+  {
+    "message": "Error 2"
+  },
+  {
+    "message": "Error 3"
+  }
+]`;
+
+const EXPECTED_EAS_BUILD_DOWN_MESSAGE = `EAS Build is down for maintenance. Try again later. Check ${link(
+  'https://status.expo.dev/'
+)} for updates.`;
+
+const EXPECTED_MAX_BUILD_COUNT_MESSAGE_ANDROID = `You have already reached the maximum number of pending Android builds for your account. Try again later.`;
+const EXPECTED_MAX_BUILD_COUNT_MESSAGE_IOS = `You have already reached the maximum number of pending iOS builds for your account. Try again later.`;
+
+const EXPECTED_GENERIC_MESSAGE =
+  'Build request failed. Make sure you are using the latest eas-cli version. If the problem persists, report the issue.';
+
+const mockRequestId = uuidv4();
+const getGraphQLError = (message: string, errorCode: string): GraphQLError => {
+  return new GraphQLError(message, null, null, null, null, null, {
+    errorCode,
+    requestId: mockRequestId,
+  });
+};
+
+const assertReThrownError = (
+  caughtError: CombinedError | Error,
+  expectedType: typeof EasCommandError,
+  expectedMessage: string = 'Error 1'
+): void => {
+  expect(caughtError).toBeInstanceOf(expectedType);
+  expect((caughtError as Error).message).toEqual(expectedMessage);
+};
+
+describe(Build.name, () => {
+  describe('handle build request errors', () => {
+    describe('logs graphQL errors to debug if present', () => {
+      it('does it with Android', async () => {
+        const platform = Platform.ANDROID;
+        const logDebugSpy = jest.spyOn(Log, 'debug');
+        const graphQLErrors = ['Error 1', 'Error 2', 'Error 3'];
+        const error = new CombinedError({ graphQLErrors });
+
+        try {
+          handleBuildRequestError(error, platform);
+        } catch {}
+
+        expect(logDebugSpy).toBeCalledWith(EXPECTED_STRINGIFIED_GRAPHQL_ERROR_JSON);
+      });
+
+      it('does it with iOS', async () => {
+        const platform = Platform.IOS;
+        const logDebugSpy = jest.spyOn(Log, 'debug');
+        const graphQLErrors = ['Error 1', 'Error 2', 'Error 3'];
+        const error = new CombinedError({ graphQLErrors });
+
+        try {
+          handleBuildRequestError(error, platform);
+        } catch {}
+
+        expect(logDebugSpy).toBeCalledWith(EXPECTED_STRINGIFIED_GRAPHQL_ERROR_JSON);
+      });
+    });
+
+    describe('logs nothing to debug if graphQLErrors not present', () => {
+      it('does it with Android', async () => {
+        const platform = Platform.ANDROID;
+        const logDebugSpy = jest.spyOn(Log, 'debug');
+        const error = new Error('Generic error');
+
+        try {
+          handleBuildRequestError(error, platform);
+        } catch {}
+
+        expect(logDebugSpy).toBeCalledWith(undefined);
+      });
+
+      it('does it with iOS', async () => {
+        const platform = Platform.IOS;
+        const logDebugSpy = jest.spyOn(Log, 'debug');
+        const error = new Error('Generic error');
+
+        try {
+          handleBuildRequestError(error, platform);
+        } catch {}
+
+        expect(logDebugSpy).toBeCalledWith(undefined);
+      });
+    });
+
+    describe('error is server-side defined error', () => {
+      describe('for TURTLE_DEPRECATED_JOB_FORMAT', () => {
+        describe('with Android', () => {
+          it('throws correct EasCommandError subclass', async () => {
+            const platform = Platform.ANDROID;
+            const graphQLError = getGraphQLError('Error 1', 'TURTLE_DEPRECATED_JOB_FORMAT');
+            const graphQLErrors = [graphQLError];
+            const error = new CombinedError({ graphQLErrors });
+
+            const handleBuildRequestErrorThrownError = getError<TurtleDeprecatedJobFormatError>(
+              () => {
+                handleBuildRequestError(error, platform);
+              }
+            );
+
+            assertReThrownError(
+              handleBuildRequestErrorThrownError,
+              TurtleDeprecatedJobFormatError,
+              'Error 1'
+            );
+          });
+
+          it('throws correct EasBuildResourceClassNotAvailableInFreeTierError', async () => {
+            const platform = Platform.ANDROID;
+            const graphQLError = getGraphQLError(
+              'Error 1',
+              'EAS_BUILD_RESOURCE_CLASS_NOT_AVAILABLE_IN_FREE_TIER'
+            );
+            const graphQLErrors = [graphQLError];
+            const error = new CombinedError({ graphQLErrors });
+
+            const handleBuildRequestErrorThrownError =
+              getError<EasBuildResourceClassNotAvailableInFreeTierError>(() => {
+                handleBuildRequestError(error, platform);
+              });
+
+            assertReThrownError(
+              handleBuildRequestErrorThrownError,
+              EasBuildResourceClassNotAvailableInFreeTierError,
+              'Error 1'
+            );
+          });
+        });
+        describe('with iOS', () => {
+          it('throws correct EasCommandError subclass', async () => {
+            const platform = Platform.IOS;
+            const graphQLError = getGraphQLError('Error 1', 'TURTLE_DEPRECATED_JOB_FORMAT');
+            const graphQLErrors = [graphQLError];
+            const error = new CombinedError({ graphQLErrors });
+
+            const handleBuildRequestErrorThrownError = getError<TurtleDeprecatedJobFormatError>(
+              () => {
+                handleBuildRequestError(error, platform);
+              }
+            );
+
+            assertReThrownError(
+              handleBuildRequestErrorThrownError,
+              TurtleDeprecatedJobFormatError,
+              'Error 1'
+            );
+          });
+
+          it('throws correct EasBuildResourceClassNotAvailableInFreeTierError', async () => {
+            const platform = Platform.IOS;
+            const graphQLError = getGraphQLError(
+              'Error 1',
+              'EAS_BUILD_RESOURCE_CLASS_NOT_AVAILABLE_IN_FREE_TIER'
+            );
+            const graphQLErrors = [graphQLError];
+            const error = new CombinedError({ graphQLErrors });
+
+            const handleBuildRequestErrorThrownError =
+              getError<EasBuildResourceClassNotAvailableInFreeTierError>(() => {
+                handleBuildRequestError(error, platform);
+              });
+
+            assertReThrownError(
+              handleBuildRequestErrorThrownError,
+              EasBuildResourceClassNotAvailableInFreeTierError,
+              'Error 1'
+            );
+          });
+        });
+      });
+
+      describe('for EAS_BUILD_FREE_TIER_DISABLED', () => {
+        describe('with Android', () => {
+          it('throws correct EasCommandError subclass', async () => {
+            const platform = Platform.ANDROID;
+            const graphQLError = getGraphQLError('Error 1', 'EAS_BUILD_FREE_TIER_DISABLED');
+            const graphQLErrors = [graphQLError];
+            const error = new CombinedError({ graphQLErrors });
+
+            const handleBuildRequestErrorThrownError = getError<EasBuildFreeTierDisabledError>(
+              () => {
+                handleBuildRequestError(error, platform);
+              }
+            );
+
+            assertReThrownError(
+              handleBuildRequestErrorThrownError,
+              EasBuildFreeTierDisabledError,
+              'Error 1'
+            );
+          });
+        });
+        describe('with iOS', () => {
+          it('throws correct EasCommandError subclass', async () => {
+            const platform = Platform.IOS;
+            const graphQLError = getGraphQLError('Error 1', 'EAS_BUILD_FREE_TIER_DISABLED');
+            const graphQLErrors = [graphQLError];
+            const error = new CombinedError({ graphQLErrors });
+
+            const handleBuildRequestErrorThrownError = getError<EasBuildFreeTierDisabledError>(
+              () => {
+                handleBuildRequestError(error, platform);
+              }
+            );
+
+            assertReThrownError(
+              handleBuildRequestErrorThrownError,
+              EasBuildFreeTierDisabledError,
+              'Error 1'
+            );
+          });
+        });
+      });
+      describe('for EAS_BUILD_FREE_TIER_DISABLED_IOS', () => {
+        it('throws correct EasCommandError subclass', async () => {
+          const platform = Platform.IOS;
+          const graphQLError = getGraphQLError('Error 1', 'EAS_BUILD_FREE_TIER_DISABLED_IOS');
+          const graphQLErrors = [graphQLError];
+          const error = new CombinedError({ graphQLErrors });
+
+          try {
+            handleBuildRequestError(error, platform);
+          } catch (caughtError) {
+            assertReThrownError(caughtError as Error, EasBuildFreeTierDisabledIOSError, 'Error 1');
+          }
+        });
+      });
+      describe('for EAS_BUILD_FREE_TIER_DISABLED_ANDROID', () => {
+        it('throws correct EasCommandError subclass', async () => {
+          const platform = Platform.ANDROID;
+          const graphQLError = getGraphQLError('Error 1', 'EAS_BUILD_FREE_TIER_DISABLED_ANDROID');
+          const graphQLErrors = [graphQLError];
+          const error = new CombinedError({ graphQLErrors });
+
+          const handleBuildRequestErrorThrownError = getError<EasBuildFreeTierDisabledAndroidError>(
+            () => {
+              handleBuildRequestError(error, platform);
+            }
+          );
+
+          assertReThrownError(
+            handleBuildRequestErrorThrownError,
+            EasBuildFreeTierDisabledAndroidError,
+            'Error 1'
+          );
+        });
+      });
+
+      describe('for VALIDATION_ERROR', () => {
+        describe('with Android', () => {
+          it('throws correct EasCommandError subclass', async () => {
+            const platform = Platform.ANDROID;
+            const graphQLError = getGraphQLError('Error 1', 'VALIDATION_ERROR');
+            const graphQLErrors = [graphQLError];
+            const error = new CombinedError({ graphQLErrors });
+
+            const handleBuildRequestErrorThrownError = getError<RequestValidationError>(() => {
+              handleBuildRequestError(error, platform);
+            });
+
+            assertReThrownError(
+              handleBuildRequestErrorThrownError,
+              RequestValidationError,
+              'Error 1'
+            );
+          });
+        });
+        describe('with iOS', () => {
+          it('throws correct EasCommandError subclass', async () => {
+            const platform = Platform.IOS;
+            const graphQLError = getGraphQLError('Error 1', 'VALIDATION_ERROR');
+            const graphQLErrors = [graphQLError];
+            const error = new CombinedError({ graphQLErrors });
+
+            const handleBuildRequestErrorThrownError = getError<RequestValidationError>(() => {
+              handleBuildRequestError(error, platform);
+            });
+
+            assertReThrownError(
+              handleBuildRequestErrorThrownError,
+              RequestValidationError,
+              'Error 1'
+            );
+          });
+        });
+      });
+    });
+
+    describe('error is other expected graphQL-related error', () => {
+      describe('for EAS_BUILD_DOWN_FOR_MAINTENANCE', () => {
+        describe('with Android', () => {
+          it('throws correct EasCommandError subclass', async () => {
+            const platform = Platform.ANDROID;
+            const graphQLError = getGraphQLError('Error 1', 'EAS_BUILD_DOWN_FOR_MAINTENANCE');
+            const graphQLErrors = [graphQLError];
+            const error = new CombinedError({ graphQLErrors });
+
+            const handleBuildRequestErrorThrownError = getError<EasBuildDownForMaintenanceError>(
+              () => {
+                handleBuildRequestError(error, platform);
+              }
+            );
+
+            assertReThrownError(
+              handleBuildRequestErrorThrownError,
+              EasBuildDownForMaintenanceError,
+              EXPECTED_EAS_BUILD_DOWN_MESSAGE
+            );
+          });
+        });
+        describe('with iOS', () => {
+          it('throws correct EasCommandError subclass', async () => {
+            const platform = Platform.IOS;
+            const graphQLError = getGraphQLError('Error 1', 'EAS_BUILD_DOWN_FOR_MAINTENANCE');
+            const graphQLErrors = [graphQLError];
+            const error = new CombinedError({ graphQLErrors });
+
+            const handleBuildRequestErrorThrownError = getError<EasBuildDownForMaintenanceError>(
+              () => {
+                handleBuildRequestError(error, platform);
+              }
+            );
+
+            assertReThrownError(
+              handleBuildRequestErrorThrownError,
+              EasBuildDownForMaintenanceError,
+              EXPECTED_EAS_BUILD_DOWN_MESSAGE
+            );
+          });
+        });
+      });
+
+      describe('for EAS_BUILD_TOO_MANY_PENDING_BUILDS', () => {
+        describe('with Android', () => {
+          it('throws correct EasCommandError subclass', async () => {
+            const platform = Platform.ANDROID;
+            const graphQLError = getGraphQLError('Error 1', 'EAS_BUILD_TOO_MANY_PENDING_BUILDS');
+            const graphQLErrors = [graphQLError];
+            const error = new CombinedError({ graphQLErrors });
+
+            const handleBuildRequestErrorThrownError = getError<EasBuildTooManyPendingBuildsError>(
+              () => {
+                handleBuildRequestError(error, platform);
+              }
+            );
+
+            assertReThrownError(
+              handleBuildRequestErrorThrownError,
+              EasBuildTooManyPendingBuildsError,
+              EXPECTED_MAX_BUILD_COUNT_MESSAGE_ANDROID
+            );
+          });
+        });
+        describe('with iOS', () => {
+          it('throws correct EasCommandError subclass', async () => {
+            const platform = Platform.IOS;
+            const graphQLError = getGraphQLError('Error 1', 'EAS_BUILD_TOO_MANY_PENDING_BUILDS');
+            const graphQLErrors = [graphQLError];
+            const error = new CombinedError({ graphQLErrors });
+
+            const handleBuildRequestErrorThrownError = getError<EasBuildTooManyPendingBuildsError>(
+              () => {
+                handleBuildRequestError(error, platform);
+              }
+            );
+
+            assertReThrownError(
+              handleBuildRequestErrorThrownError,
+              EasBuildTooManyPendingBuildsError,
+              EXPECTED_MAX_BUILD_COUNT_MESSAGE_IOS
+            );
+          });
+        });
+      });
+    });
+
+    describe('error is unexpected graphQL-related error', () => {
+      describe('with Android', () => {
+        it('throws base Error class with custom message', async () => {
+          const platform = Platform.ANDROID;
+          const graphQLError = getGraphQLError('Error 1', 'UNKNOWN_GRAPHQL_ERROR');
+          const graphQLErrors = [graphQLError];
+          const error = new CombinedError({ graphQLErrors });
+          const expectedMessage = EXPECTED_GENERIC_MESSAGE + `\nRequest ID: ${mockRequestId}`;
+
+          const handleBuildRequestErrorThrownError = getError<Error>(() => {
+            handleBuildRequestError(error, platform);
+          });
+
+          assertReThrownError(handleBuildRequestErrorThrownError, Error, expectedMessage);
+        });
+        describe('without request ID', () => {
+          it('throws base Error class with custom message without request ID line', async () => {
+            const platform = Platform.ANDROID;
+            const graphQLError = getGraphQLError('Error 1', 'UNKNOWN_GRAPHQL_ERROR');
+            delete graphQLError.extensions.requestId;
+            const graphQLErrors = [graphQLError];
+            const error = new CombinedError({ graphQLErrors });
+
+            const handleBuildRequestErrorThrownError = getError<Error>(() => {
+              handleBuildRequestError(error, platform);
+            });
+
+            assertReThrownError(
+              handleBuildRequestErrorThrownError,
+              Error,
+              EXPECTED_GENERIC_MESSAGE
+            );
+          });
+        });
+      });
+      describe('with iOS', () => {
+        it('throws base Error class with custom message', async () => {
+          const platform = Platform.IOS;
+          const graphQLError = getGraphQLError('Error 1', 'UNKNOWN_GRAPHQL_ERROR');
+          const graphQLErrors = [graphQLError];
+          const error = new CombinedError({ graphQLErrors });
+          const expectedMessage = EXPECTED_GENERIC_MESSAGE + `\nRequest ID: ${mockRequestId}`;
+
+          const handleBuildRequestErrorThrownError = getError<Error>(() => {
+            handleBuildRequestError(error, platform);
+          });
+
+          assertReThrownError(handleBuildRequestErrorThrownError, Error, expectedMessage);
+        });
+        describe('without request ID', () => {
+          it('throws base Error class with custom message without request ID line', async () => {
+            const platform = Platform.IOS;
+            const graphQLError = getGraphQLError('Error 1', 'UNKNOWN_GRAPHQL_ERROR');
+            delete graphQLError.extensions.requestId;
+            const graphQLErrors = [graphQLError];
+            const error = new CombinedError({ graphQLErrors });
+
+            const handleBuildRequestErrorThrownError = getError<Error>(() => {
+              handleBuildRequestError(error, platform);
+            });
+
+            assertReThrownError(
+              handleBuildRequestErrorThrownError,
+              Error,
+              EXPECTED_GENERIC_MESSAGE
+            );
+          });
+        });
+      });
+    });
+
+    describe('error is unexpected non-graphQL-related error', () => {
+      describe('with Android', () => {
+        it('throws base Error class with propagated message', async () => {
+          const platform = Platform.ANDROID;
+          const error = new Error('Non-graphQL-related error');
+
+          const handleBuildRequestErrorThrownError = getError<Error>(() => {
+            handleBuildRequestError(error, platform);
+          });
+
+          expect(handleBuildRequestErrorThrownError).toStrictEqual(error);
+        });
+      });
+      describe('with iOS', () => {
+        it('throws base Error class with propagated message', async () => {
+          const platform = Platform.IOS;
+          const error = new Error('Non-graphQL-related error');
+
+          const handleBuildRequestErrorThrownError = getError<Error>(() => {
+            handleBuildRequestError(error, platform);
+          });
+
+          expect(handleBuildRequestErrorThrownError).toStrictEqual(error);
+        });
+      });
+    });
+  });
+});

packages/eas-cli/src/build/android/build.ts

@@ -62,7 +62,7 @@ This means that it will most likely produce an AAB and you will not be able to i
   const gradleContext = await resolveGradleBuildContextAsync(ctx.projectDir, buildProfile);
 
   if (ctx.workflow === Workflow.MANAGED) {
-    await ensureApplicationIdIsDefinedForManagedProjectAsync(ctx.projectDir, ctx.exp, ctx.user);
+    await ensureApplicationIdIsDefinedForManagedProjectAsync(ctx);
   }
 
   const applicationId = await getApplicationIdAsync(ctx.projectDir, ctx.exp, gradleContext);
@@ -124,7 +124,8 @@ export async function prepareAndroidBuildAsync(
 }
 
 function shouldProvideCredentials(ctx: BuildContext<Platform.ANDROID>): boolean {
-  return !ctx.buildProfile.withoutCredentials;
+  const isCustomBuild = ctx.buildProfile.config !== undefined;
+  return !ctx.buildProfile.withoutCredentials && !isCustomBuild;
 }
 
 async function ensureAndroidCredentialsAsync(

packages/eas-cli/src/build/android/graphql.ts

@@ -1,7 +1,12 @@
 import { Android } from '@expo/eas-build-job';
 
 import { AndroidBuildType, AndroidJobInput } from '../../graphql/generated';
-import { transformBuildTrigger, transformProjectArchive, transformWorkflow } from '../graphql';
+import {
+  transformBuildMode,
+  transformBuildTrigger,
+  transformProjectArchive,
+  transformWorkflow,
+} from '../graphql';
 
 export function transformJob(job: Android.Job): AndroidJobInput {
   return {
@@ -22,6 +27,8 @@ export function transformJob(job: Android.Job): AndroidJobInput {
     buildType: job.buildType && transformBuildType(job.buildType),
     developmentClient: job.developmentClient,
     experimental: job.experimental,
+    mode: transformBuildMode(job.mode),
+    customBuildConfig: job.customBuildConfig,
   };
 }
 

packages/eas-cli/src/build/android/prepareJob.ts

@@ -12,6 +12,7 @@ import path from 'path';
 import slash from 'slash';
 
 import { AndroidCredentials } from '../../credentials/android/AndroidCredentialsProvider';
+import { getCustomBuildConfigPath } from '../../project/customBuildConfig';
 import { getUsername } from '../../project/projectUtils';
 import { getVcsClient } from '../../vcs';
 import { BuildContext } from '../context';
@@ -23,8 +24,7 @@ interface JobData {
 
 const cacheDefaults = {
   disabled: false,
-  customPaths: [],
-  cacheDefaultPaths: true,
+  paths: [],
 };
 
 export async function prepareJobAsync(
@@ -49,11 +49,15 @@ export async function prepareJobAsync(
       }
     : {};
 
-  let buildType = ctx.buildProfile.buildType;
-  if (!buildType && !buildProfile.gradleCommand && ctx.buildProfile.distribution === 'internal') {
+  let buildType = buildProfile.buildType;
+  if (!buildType && !buildProfile.gradleCommand && buildProfile.distribution === 'internal') {
     buildType = Android.BuildType.APK;
   }
 
+  const maybeCustomBuildConfigPath = buildProfile.config
+    ? getCustomBuildConfigPath(buildProfile.config)
+    : undefined;
+
   const job: Android.Job = {
     type: ctx.workflow,
     platform: Platform.ANDROID,
@@ -75,8 +79,8 @@ export async function prepareJobAsync(
     secrets: {
       ...buildCredentials,
     },
-    releaseChannel: ctx.buildProfile.releaseChannel,
-    updates: { channel: ctx.buildProfile.channel },
+    releaseChannel: buildProfile.releaseChannel,
+    updates: { channel: buildProfile.channel },
     developmentClient: buildProfile.developmentClient,
     gradleCommand: buildProfile.gradleCommand,
     applicationArchivePath: buildProfile.applicationArchivePath ?? buildProfile.artifactPath,
@@ -89,10 +93,15 @@ export async function prepareJobAsync(
       },
     }),
     experimental: {
-      prebuildCommand: ctx.buildProfile.prebuildCommand,
+      prebuildCommand: buildProfile.prebuildCommand,
     },
-    mode: BuildMode.BUILD,
+    mode: buildProfile.config ? BuildMode.CUSTOM : BuildMode.BUILD,
     triggeredBy: BuildTrigger.EAS_CLI,
+    ...(maybeCustomBuildConfigPath && {
+      customBuildConfig: {
+        path: maybeCustomBuildConfigPath,
+      },
+    }),
   };
 
   return sanitizeJob(job);

packages/eas-cli/src/build/build.ts

@@ -10,6 +10,7 @@ import { BuildEvent } from '../analytics/AnalyticsManager';
 import { withAnalyticsAsync } from '../analytics/common';
 import { getExpoWebsiteBaseUrl } from '../api';
 import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { EasCommandError } from '../commandUtils/errors';
 import {
   AppPlatform,
   BuildFragment,
@@ -36,6 +37,16 @@ import { createProgressTracker } from '../utils/progress';
 import { sleepAsync } from '../utils/promise';
 import { getVcsClient } from '../vcs';
 import { BuildContext } from './context';
+import {
+  EasBuildDownForMaintenanceError,
+  EasBuildFreeTierDisabledAndroidError,
+  EasBuildFreeTierDisabledError,
+  EasBuildFreeTierDisabledIOSError,
+  EasBuildResourceClassNotAvailableInFreeTierError,
+  EasBuildTooManyPendingBuildsError,
+  RequestValidationError,
+  TurtleDeprecatedJobFormatError,
+} from './errors';
 import { transformMetadata } from './graphql';
 import { LocalBuildMode, runLocalBuildAsync } from './local';
 import { collectMetadataAsync } from './metadata';
@@ -70,9 +81,14 @@ interface Builder<TPlatform extends Platform, Credentials, TJob extends Job> {
 
 export type BuildRequestSender = () => Promise<BuildFragment | undefined>;
 
-function resolveBuildParamsInput<T extends Platform>(ctx: BuildContext<T>): BuildParamsInput {
+function resolveBuildParamsInput<T extends Platform>(
+  ctx: BuildContext<T>,
+  metadata: Metadata
+): BuildParamsInput {
   return {
     resourceClass: ctx.resourceClass,
+    sdkVersion: metadata.sdkVersion,
+    reactNativeVersion: metadata.reactNativeVersion,
   };
 }
 
@@ -132,7 +148,7 @@ export async function prepareBuildRequestForPlatformAsync<
   assert(projectArchive);
 
   const metadata = await collectMetadataAsync(ctx);
-  const buildParams = resolveBuildParamsInput(ctx);
+  const buildParams = resolveBuildParamsInput(ctx, metadata);
   const job = await builder.prepareJobAsync(ctx, {
     projectArchive,
     credentials: credentialsResult?.credentials,
@@ -161,39 +177,40 @@ export async function prepareBuildRequestForPlatformAsync<
   };
 }
 
-const SERVER_SIDE_DEFINED_ERRORS = [
-  'TURTLE_DEPRECATED_JOB_FORMAT',
-  'EAS_BUILD_FREE_TIER_DISABLED',
-  'EAS_BUILD_FREE_TIER_DISABLED_IOS',
-  'EAS_BUILD_FREE_TIER_DISABLED_ANDROID',
-  'VALIDATION_ERROR',
-];
+const SERVER_SIDE_DEFINED_ERRORS: Record<string, typeof EasCommandError> = {
+  TURTLE_DEPRECATED_JOB_FORMAT: TurtleDeprecatedJobFormatError,
+  EAS_BUILD_FREE_TIER_DISABLED: EasBuildFreeTierDisabledError,
+  EAS_BUILD_FREE_TIER_DISABLED_IOS: EasBuildFreeTierDisabledIOSError,
+  EAS_BUILD_FREE_TIER_DISABLED_ANDROID: EasBuildFreeTierDisabledAndroidError,
+  EAS_BUILD_RESOURCE_CLASS_NOT_AVAILABLE_IN_FREE_TIER:
+    EasBuildResourceClassNotAvailableInFreeTierError,
+  VALIDATION_ERROR: RequestValidationError,
+};
 
-function handleBuildRequestError(error: any, platform: Platform): never {
+export function handleBuildRequestError(error: any, platform: Platform): never {
   Log.debug(JSON.stringify(error.graphQLErrors, null, 2));
 
-  if (SERVER_SIDE_DEFINED_ERRORS.includes(error?.graphQLErrors?.[0]?.extensions?.errorCode)) {
-    Log.error(error?.graphQLErrors?.[0]?.message);
-    throw new Error('Build request failed.');
-  } else if (
-    error?.graphQLErrors?.[0]?.extensions?.errorCode === 'EAS_BUILD_DOWN_FOR_MAINTENANCE'
-  ) {
-    Log.error(
+  const graphQLErrorCode: string = error?.graphQLErrors?.[0]?.extensions?.errorCode;
+  if (graphQLErrorCode in SERVER_SIDE_DEFINED_ERRORS) {
+    const ErrorClass: typeof EasCommandError = SERVER_SIDE_DEFINED_ERRORS[graphQLErrorCode];
+    throw new ErrorClass(error?.graphQLErrors?.[0]?.message);
+  } else if (graphQLErrorCode === 'EAS_BUILD_DOWN_FOR_MAINTENANCE') {
+    throw new EasBuildDownForMaintenanceError(
       `EAS Build is down for maintenance. Try again later. Check ${link(
         'https://status.expo.dev/'
       )} for updates.`
     );
-    throw new Error('Build request failed.');
-  } else if (
-    error?.graphQLErrors?.[0]?.extensions?.errorCode === 'EAS_BUILD_TOO_MANY_PENDING_BUILDS'
-  ) {
-    Log.error(
+  } else if (graphQLErrorCode === 'EAS_BUILD_TOO_MANY_PENDING_BUILDS') {
+    throw new EasBuildTooManyPendingBuildsError(
       `You have already reached the maximum number of pending ${requestedPlatformDisplayNames[platform]} builds for your account. Try again later.`
     );
-    throw new Error('Build request failed.');
   } else if (error?.graphQLErrors) {
-    Log.error(
-      'Build request failed. Make sure you are using the latest eas-cli version. If the problem persists, report the issue.'
+    const requestIdLine = error?.graphQLErrors?.[0]?.extensions?.requestId
+      ? `\nRequest ID: ${error.graphQLErrors[0].extensions.requestId}`
+      : '';
+    throw new Error(
+      'Build request failed. Make sure you are using the latest eas-cli version. If the problem persists, report the issue.' +
+        requestIdLine
     );
   }
   throw error;
@@ -607,7 +624,7 @@ function formatAccountSubscriptionsUrl(accountName: string): string {
 }
 
 async function updateIosBuildProfilesToUseM1WorkersAsync(projectDir: string): Promise<void> {
-  const easJsonAccessor = new EasJsonAccessor(projectDir);
+  const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
   await easJsonAccessor.readRawJsonAsync();
 
   const profileNames = await EasJsonUtils.getBuildProfileNamesAsync(easJsonAccessor);
@@ -615,7 +632,7 @@ async function updateIosBuildProfilesToUseM1WorkersAsync(projectDir: string): Pr
     for (const profileName of profileNames) {
       easJsonRawObject.build[profileName].ios = {
         ...easJsonRawObject.build[profileName].ios,
-        resourceClass: ResourceClass.M1_MEDIUM,
+        resourceClass: ResourceClass.M_MEDIUM,
       };
     }
     return easJsonRawObject;

packages/eas-cli/src/build/configure.ts

@@ -1,5 +1,5 @@
 import { Platform, Workflow } from '@expo/eas-build-job';
-import { EasJson, EasJsonAccessor, ResourceClass } from '@expo/eas-json';
+import { EasJson, EasJsonAccessor } from '@expo/eas-json';
 import chalk from 'chalk';
 import fs from 'fs-extra';
 
@@ -53,21 +53,11 @@ const EAS_JSON_MANAGED_DEFAULT: EasJson = {
     development: {
       developmentClient: true,
       distribution: 'internal',
-      ios: {
-        resourceClass: ResourceClass.M1_MEDIUM,
-      },
     },
     preview: {
       distribution: 'internal',
-      ios: {
-        resourceClass: ResourceClass.M1_MEDIUM,
-      },
-    },
-    production: {
-      ios: {
-        resourceClass: ResourceClass.M1_MEDIUM,
-      },
     },
+    production: {},
   },
   submit: {
     production: {},
@@ -86,20 +76,12 @@ const EAS_JSON_BARE_DEFAULT: EasJson = {
       },
       ios: {
         buildConfiguration: 'Debug',
-        resourceClass: ResourceClass.M1_MEDIUM,
       },
     },
     preview: {
       distribution: 'internal',
-      ios: {
-        resourceClass: ResourceClass.M1_MEDIUM,
-      },
-    },
-    production: {
-      ios: {
-        resourceClass: ResourceClass.M1_MEDIUM,
-      },
     },
+    production: {},
   },
   submit: {
     production: {},

packages/eas-cli/src/build/context.ts

@@ -8,6 +8,7 @@ import { CredentialsContext } from '../credentials/context';
 import { Target } from '../credentials/ios/types';
 import { BuildResourceClass } from '../graphql/generated';
 import { GradleBuildContext } from '../project/android/gradle';
+import { CustomBuildConfigMetadata } from '../project/customBuildConfig';
 import { XcodeBuildContext } from '../project/ios/scheme';
 import { Actor } from '../user/User';
 import { LocalBuildOptions } from './local';
@@ -51,6 +52,7 @@ export interface BuildContext<T extends Platform> {
   graphqlClient: ExpoGraphqlClient;
   analytics: Analytics;
   workflow: Workflow;
+  customBuildConfigMetadata?: CustomBuildConfigMetadata;
   android: T extends Platform.ANDROID ? AndroidBuildContext : undefined;
   ios: T extends Platform.IOS ? IosBuildContext : undefined;
 }

packages/eas-cli/src/build/createContext.ts

@@ -9,6 +9,7 @@ import { Analytics, AnalyticsEventProperties, BuildEvent } from '../analytics/An
 import { DynamicConfigContextFn } from '../commandUtils/context/DynamicProjectConfigContextField';
 import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import { CredentialsContext } from '../credentials/context';
+import { CustomBuildConfigMetadata } from '../project/customBuildConfig';
 import { getOwnerAccountForProjectIdAsync } from '../project/projectUtils';
 import { resolveWorkflowAsync } from '../project/workflow';
 import { Actor } from '../user/User';
@@ -34,6 +35,7 @@ export async function createBuildContextAsync<T extends Platform>({
   graphqlClient,
   analytics,
   getDynamicProjectConfigAsync,
+  customBuildConfigMetadata,
 }: {
   buildProfileName: string;
   buildProfile: BuildProfile<T>;
@@ -50,6 +52,7 @@ export async function createBuildContextAsync<T extends Platform>({
   graphqlClient: ExpoGraphqlClient;
   analytics: Analytics;
   getDynamicProjectConfigAsync: DynamicConfigContextFn;
+  customBuildConfigMetadata?: CustomBuildConfigMetadata;
 }): Promise<BuildContext<T>> {
   const { exp, projectId } = await getDynamicProjectConfigAsync({ env: buildProfile.env });
   const projectName = exp.slug;
@@ -90,8 +93,6 @@ export async function createBuildContextAsync<T extends Platform>({
   const resourceClass = await resolveBuildResourceClassAsync(
     buildProfile,
     platform,
-    projectDir,
-    exp,
     resourceClassFlag
   );
 
@@ -118,6 +119,7 @@ export async function createBuildContextAsync<T extends Platform>({
     workflow,
     message,
     runFromCI,
+    customBuildConfigMetadata,
   };
   if (platform === Platform.ANDROID) {
     const common = commonContext as CommonContext<Platform.ANDROID>;

packages/eas-cli/src/build/errors.ts

@@ -0,0 +1,17 @@
+import { EasCommandError } from '../commandUtils/errors';
+
+export class TurtleDeprecatedJobFormatError extends EasCommandError {}
+
+export class EasBuildFreeTierDisabledError extends EasCommandError {}
+
+export class EasBuildFreeTierDisabledIOSError extends EasCommandError {}
+
+export class EasBuildFreeTierDisabledAndroidError extends EasCommandError {}
+
+export class EasBuildResourceClassNotAvailableInFreeTierError extends EasCommandError {}
+
+export class RequestValidationError extends EasCommandError {}
+
+export class EasBuildDownForMaintenanceError extends EasCommandError {}
+
+export class EasBuildTooManyPendingBuildsError extends EasCommandError {}

packages/eas-cli/src/build/graphql.ts

@@ -91,11 +91,16 @@ export function transformIosEnterpriseProvisioning(
   }
 }
 
-export function transformBuildMode(buildMode: Metadata['buildMode']): BuildMode {
+// TODO: check what in metadata
+export function transformBuildMode(buildMode: string): BuildMode {
   if (buildMode === 'build') {
     return BuildMode.Build;
-  } else {
+  } else if (buildMode === 'resign') {
     return BuildMode.Resign;
+  } else if (buildMode === 'custom') {
+    return BuildMode.Custom;
+  } else {
+    throw new Error(`Unsupported build mode: ${buildMode}`);
   }
 }
 

packages/eas-cli/src/build/ios/__tests__/version-test.ts

@@ -77,7 +77,7 @@ describe(bumpVersionAsync, () => {
     );
     await bumpVersionAsync({
       bumpStrategy: BumpStrategy.BUILD_NUMBER,
-      projectDir: '/repo',
+      projectDir: '/app',
       exp: fakeExp,
       targets: [
         {
@@ -88,9 +88,9 @@ describe(bumpVersionAsync, () => {
       ],
     });
 
-    const appJSON = await fs.readJSON('/repo/app.json');
+    const appJSON = await fs.readJSON('/app/app.json');
     const infoPlist = (await readPlistAsync(
-      '/repo/ios/myproject/Info.plist'
+      '/app/ios/myproject/Info.plist'
     )) as IOSConfig.InfoPlist;
     expect(fakeExp.version).toBe('1.0.0');
     expect(fakeExp.ios?.buildNumber).toBe('2');
@@ -113,7 +113,7 @@ describe(bumpVersionAsync, () => {
     );
     await bumpVersionAsync({
       bumpStrategy: BumpStrategy.BUILD_NUMBER,
-      projectDir: '/repo',
+      projectDir: '/app',
       exp: fakeExp,
       targets: [
         {
@@ -124,9 +124,9 @@ describe(bumpVersionAsync, () => {
       ],
     });
 
-    const appJSON = await fs.readJSON('/repo/app.json');
+    const appJSON = await fs.readJSON('/app/app.json');
     const infoPlist = (await readPlistAsync(
-      '/repo/ios/myproject/Info2.plist'
+      '/app/ios/myproject/Info2.plist'
     )) as IOSConfig.InfoPlist;
     expect(fakeExp.version).toBe('1.0.0');
     expect(fakeExp.ios?.buildNumber).toBe('2');
@@ -148,7 +148,7 @@ describe(bumpVersionAsync, () => {
     );
     await bumpVersionAsync({
       bumpStrategy: BumpStrategy.APP_VERSION,
-      projectDir: '/repo',
+      projectDir: '/app',
       exp: fakeExp,
       targets: [
         {
@@ -159,9 +159,9 @@ describe(bumpVersionAsync, () => {
       ],
     });
 
-    const appJSON = await fs.readJSON('/repo/app.json');
+    const appJSON = await fs.readJSON('/app/app.json');
     const infoPlist = (await readPlistAsync(
-      '/repo/ios/myproject/Info.plist'
+      '/app/ios/myproject/Info.plist'
     )) as IOSConfig.InfoPlist;
     expect(fakeExp.version).toBe('1.0.1');
     expect(fakeExp.ios?.buildNumber).toBe('1');
@@ -183,7 +183,7 @@ describe(bumpVersionAsync, () => {
     );
     await bumpVersionAsync({
       bumpStrategy: BumpStrategy.NOOP,
-      projectDir: '/repo',
+      projectDir: '/app',
       exp: fakeExp,
       targets: [
         {
@@ -194,9 +194,9 @@ describe(bumpVersionAsync, () => {
       ],
     });
 
-    const appJSON = await fs.readJSON('/repo/app.json');
+    const appJSON = await fs.readJSON('/app/app.json');
     const infoPlist = (await readPlistAsync(
-      '/repo/ios/myproject/Info.plist'
+      '/app/ios/myproject/Info.plist'
     )) as IOSConfig.InfoPlist;
     expect(fakeExp.version).toBe('1.0.0');
     expect(fakeExp.ios?.buildNumber).toBe('1');
@@ -214,11 +214,11 @@ describe(bumpVersionInAppJsonAsync, () => {
 
     await bumpVersionInAppJsonAsync({
       bumpStrategy: BumpStrategy.BUILD_NUMBER,
-      projectDir: '/repo',
+      projectDir: '/app',
       exp: fakeExp,
     });
 
-    const appJSON = await fs.readJSON('/repo/app.json');
+    const appJSON = await fs.readJSON('/app/app.json');
     expect(fakeExp.version).toBe('1.0.0');
     expect(fakeExp.ios?.buildNumber).toBe('2');
     expect(appJSON.expo.version).toBe('1.0.0');
@@ -230,11 +230,11 @@ describe(bumpVersionInAppJsonAsync, () => {
 
     await bumpVersionInAppJsonAsync({
       bumpStrategy: BumpStrategy.APP_VERSION,
-      projectDir: '/repo',
+      projectDir: '/app',
       exp: fakeExp,
     });
 
-    const appJSON = await fs.readJSON('/repo/app.json');
+    const appJSON = await fs.readJSON('/app/app.json');
     expect(fakeExp.version).toBe('1.0.1');
     expect(fakeExp.ios?.buildNumber).toBe('1');
     expect(appJSON.expo.version).toBe('1.0.1');
@@ -246,11 +246,11 @@ describe(bumpVersionInAppJsonAsync, () => {
 
     await bumpVersionInAppJsonAsync({
       bumpStrategy: BumpStrategy.NOOP,
-      projectDir: '/repo',
+      projectDir: '/app',
       exp: fakeExp,
     });
 
-    const appJSON = await fs.readJSON('/repo/app.json');
+    const appJSON = await fs.readJSON('/app/app.json');
     expect(fakeExp.version).toBe('1.0.0');
     expect(fakeExp.ios?.buildNumber).toBe('1');
     expect(appJSON.expo.version).toBe('1.0.0');
@@ -262,7 +262,7 @@ describe(readBuildNumberAsync, () => {
   describe('bare project', () => {
     it('reads the build number from native code', async () => {
       const exp = initBareWorkflowProject();
-      const buildNumber = await readBuildNumberAsync('/repo', exp, {});
+      const buildNumber = await readBuildNumberAsync('/app', exp, {});
       expect(buildNumber).toBe('1');
     });
   });
@@ -270,7 +270,7 @@ describe(readBuildNumberAsync, () => {
   describe('managed project', () => {
     it('reads the build number from expo config', async () => {
       const exp = initManagedProject();
-      const buildNumber = await readBuildNumberAsync('/repo', exp, {});
+      const buildNumber = await readBuildNumberAsync('/app', exp, {});
       expect(buildNumber).toBe('1');
     });
   });
@@ -280,24 +280,38 @@ describe(readShortVersionAsync, () => {
   describe('bare project', () => {
     it('reads the short version from native code', async () => {
       const exp = initBareWorkflowProject();
-      const appVersion = await readShortVersionAsync('/repo', exp, {});
+      const appVersion = await readShortVersionAsync('/app', exp, {});
       expect(appVersion).toBe('1.0.0');
     });
     it('evaluates interpolated build number', async () => {
       const exp = initBareWorkflowProject({
         appVersion: '$(CURRENT_PROJECT_VERSION)',
       });
-      const buildNumber = await readShortVersionAsync('/repo', exp, {
+      const buildNumber = await readShortVersionAsync('/app', exp, {
         CURRENT_PROJECT_VERSION: '1.0.0',
       });
       expect(buildNumber).toBe('1.0.0');
     });
+
+    it('fails when build number is invalid', async () => {
+      const exp = initBareWorkflowProject({
+        appVersion: '$(CURRENT_PROJECT_VERSION)',
+      });
+
+      await expect(
+        readShortVersionAsync('/app', exp, {
+          CURRENT_PROJECT_VERSION: '0.0.7.1.028',
+        })
+      ).rejects.toThrowError(
+        'CFBundleShortVersionString (version field in app.json/app.config.js) must be a period-separated list of three non-negative integers. Current value: 0.0.7.1.028'
+      );
+    });
   });
 
   describe('managed project', () => {
     it('reads the version from app config', async () => {
       const exp = initBareWorkflowProject();
-      const appVersion = await readShortVersionAsync('/repo', exp, {});
+      const appVersion = await readShortVersionAsync('/app', exp, {});
       expect(appVersion).toBe('1.0.0');
     });
   });
@@ -309,66 +323,75 @@ describe(getInfoPlistPath, () => {
       {
         './ios/testapp/Info.plist': '',
       },
-      '/repo'
+      '/app'
     );
-    const plistPath = getInfoPlistPath('/repo', {});
-    expect(plistPath).toBe('/repo/ios/testapp/Info.plist');
+    const plistPath = getInfoPlistPath('/app', {});
+    expect(plistPath).toBe('/app/ios/testapp/Info.plist');
   });
   it('returns INFOPLIST_FILE if specified', () => {
     vol.fromJSON(
       {
         './ios/testapp/Info.plist': '',
       },
-      '/repo'
+      '/app'
     );
-    const plistPath = getInfoPlistPath('/repo', { INFOPLIST_FILE: './qwert/NotInfo.plist' });
-    expect(plistPath).toBe('/repo/ios/qwert/NotInfo.plist');
+    const plistPath = getInfoPlistPath('/app', { INFOPLIST_FILE: './qwert/NotInfo.plist' });
+    expect(plistPath).toBe('/app/ios/qwert/NotInfo.plist');
   });
   it('evaluates SRCROOT in Info.plist', () => {
     vol.fromJSON(
       {
         './ios/testapp/Info.plist': '',
       },
-      '/repo'
+      '/app'
     );
-    const plistPath = getInfoPlistPath('/repo', {
+    const plistPath = getInfoPlistPath('/app', {
       INFOPLIST_FILE: '$(SRCROOT)/qwert/NotInfo.plist',
     });
-    expect(plistPath).toBe('/repo/ios/qwert/NotInfo.plist');
+    expect(plistPath).toBe('/app/ios/qwert/NotInfo.plist');
   });
   it('evaluates BuildSettings in Info.plist', () => {
     vol.fromJSON(
       {
         './ios/testapp/Info.plist': '',
       },
-      '/repo'
+      '/app'
     );
-    const plistPath = getInfoPlistPath('/repo', {
+    const plistPath = getInfoPlistPath('/app', {
       INFOPLIST_FILE: '$(SRCROOT)/qwert/$(TARGET_NAME).plist',
       TARGET_NAME: 'NotInfo',
     });
-    expect(plistPath).toBe('/repo/ios/qwert/NotInfo.plist');
+    expect(plistPath).toBe('/app/ios/qwert/NotInfo.plist');
   });
 });
 
 function initBareWorkflowProject({
   appVersion = '1.0.0',
   buildNumber = '1',
+  expoConfig = {},
   infoPlistName = 'Info.plist',
-}: { appVersion?: string; buildNumber?: string; infoPlistName?: string } = {}): ExpoConfig {
+}: {
+  appVersion?: string;
+  buildNumber?: string;
+  infoPlistName?: string;
+  expoConfig?: { version?: string; ios?: object };
+} = {}): ExpoConfig {
   const fakeExp: ExpoConfig = {
     name: 'myproject',
     slug: 'myproject',
     version: '1.0.0',
     ios: {
       buildNumber: '1',
+      ...expoConfig.ios,
     },
+    ...expoConfig,
   };
   vol.fromJSON(
     {
       './app.json': JSON.stringify({
         expo: fakeExp,
       }),
+      './ios/myproject.xcodeproj/project.pbxproj': '',
       [`./ios/myproject/${infoPlistName}`]: `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -380,7 +403,7 @@ function initBareWorkflowProject({
 </dict>
 </plist>`,
     },
-    '/repo'
+    '/app'
   );
 
   return fakeExp;
@@ -402,7 +425,7 @@ function initManagedProject(): ExpoConfig {
         expo: fakeExp,
       }),
     },
-    '/repo'
+    '/app'
   );
 
   return fakeExp;

packages/eas-cli/src/build/ios/build.ts

@@ -27,7 +27,7 @@ export async function createIosContextAsync(
   const { buildProfile } = ctx;
 
   if (ctx.workflow === Workflow.MANAGED) {
-    await ensureBundleIdentifierIsDefinedForManagedProjectAsync(ctx.projectDir, ctx.exp, ctx.user);
+    await ensureBundleIdentifierIsDefinedForManagedProjectAsync(ctx);
   }
 
   checkNodeEnvVariable(ctx);

packages/eas-cli/src/build/ios/credentials.ts

@@ -55,5 +55,6 @@ export async function ensureIosCredentialsForBuildResignAsync(
 }
 
 function shouldProvideCredentials(buildCtx: BuildContext<Platform.IOS>): boolean {
-  return !buildCtx.buildProfile.simulator;
+  const isCustomBuild = buildCtx.buildProfile.config !== undefined;
+  return !buildCtx.buildProfile.simulator && !isCustomBuild;
 }

packages/eas-cli/src/build/ios/graphql.ts

@@ -2,7 +2,12 @@ import { Ios } from '@expo/eas-build-job';
 import nullthrows from 'nullthrows';
 
 import { IosJobInput, IosJobSecretsInput } from '../../graphql/generated';
-import { transformBuildTrigger, transformProjectArchive, transformWorkflow } from '../graphql';
+import {
+  transformBuildMode,
+  transformBuildTrigger,
+  transformProjectArchive,
+  transformWorkflow,
+} from '../graphql';
 
 export function transformJob(job: Ios.Job): IosJobInput {
   return {
@@ -12,7 +17,7 @@ export function transformJob(job: Ios.Job): IosJobInput {
     projectRootDirectory: nullthrows(job.projectRootDirectory),
     releaseChannel: job.releaseChannel,
     updates: job.updates,
-    secrets: transformIosSecrets(job.secrets),
+    secrets: job.secrets ? transformIosSecrets(job.secrets) : undefined,
     builderEnvironment: job.builderEnvironment,
     cache: job.cache,
     version: job.version?.buildNumber ? { buildNumber: job.version.buildNumber } : undefined,
@@ -24,6 +29,8 @@ export function transformJob(job: Ios.Job): IosJobInput {
     developmentClient: job.developmentClient,
     simulator: job.simulator,
     experimental: job.experimental,
+    mode: transformBuildMode(job.mode),
+    customBuildConfig: job.customBuildConfig,
   };
 }
 

packages/eas-cli/src/build/ios/prepareJob.ts

@@ -7,12 +7,14 @@ import {
   Platform,
   sanitizeJob,
 } from '@expo/eas-build-job';
+import { BuildProfile } from '@expo/eas-json';
 import nullthrows from 'nullthrows';
 import path from 'path';
 import slash from 'slash';
 
 import { IosCredentials, TargetCredentials } from '../../credentials/ios/types';
 import { IosJobSecretsInput } from '../../graphql/generated';
+import { getCustomBuildConfigPath } from '../../project/customBuildConfig';
 import { getUsername } from '../../project/projectUtils';
 import { getVcsClient } from '../../vcs';
 import { BuildContext } from '../context';
@@ -25,18 +27,18 @@ interface JobData {
 
 const cacheDefaults = {
   disabled: false,
-  customPaths: [],
-  cacheDefaultPaths: true,
+  paths: [],
 };
 
 export async function prepareJobAsync(
   ctx: BuildContext<Platform.IOS>,
   jobData: JobData
 ): Promise<Job> {
+  const username = getUsername(ctx.exp, ctx.user);
+  const buildProfile: BuildProfile<Platform.IOS> = ctx.buildProfile;
   const projectRootDirectory =
     slash(path.relative(await getVcsClient().getRootPathAsync(), ctx.projectDir)) || '.';
-  const username = getUsername(ctx.exp, ctx.user);
-  const buildCredentials: Ios.Job['secrets']['buildCredentials'] = {};
+  const buildCredentials: Ios.BuildSecrets['buildCredentials'] = {};
   if (jobData.credentials) {
     const targetNames = Object.keys(jobData.credentials);
     for (const targetName of targetNames) {
@@ -44,38 +46,41 @@ export async function prepareJobAsync(
     }
   }
 
+  const maybeCustomBuildConfigPath = buildProfile.config
+    ? getCustomBuildConfigPath(buildProfile.config)
+    : undefined;
+
   const job: Ios.Job = {
     type: ctx.workflow,
     platform: Platform.IOS,
     projectArchive: jobData.projectArchive,
     projectRootDirectory,
     builderEnvironment: {
-      image: ctx.buildProfile.image,
-      node: ctx.buildProfile.node,
-      yarn: ctx.buildProfile.yarn,
-      bundler: ctx.buildProfile.bundler,
-      cocoapods: ctx.buildProfile.cocoapods,
-      fastlane: ctx.buildProfile.fastlane,
-      expoCli: ctx.buildProfile.expoCli,
-      env: ctx.buildProfile.env,
+      image: buildProfile.image,
+      node: buildProfile.node,
+      yarn: buildProfile.yarn,
+      bundler: buildProfile.bundler,
+      cocoapods: buildProfile.cocoapods,
+      fastlane: buildProfile.fastlane,
+      expoCli: buildProfile.expoCli,
+      env: buildProfile.env,
     },
     cache: {
       ...cacheDefaults,
-      ...ctx.buildProfile.cache,
+      ...buildProfile.cache,
       clear: ctx.clearCache,
     },
     secrets: {
       buildCredentials,
     },
-    releaseChannel: ctx.buildProfile.releaseChannel,
-    updates: { channel: ctx.buildProfile.channel },
-    developmentClient: ctx.buildProfile.developmentClient,
-    simulator: ctx.buildProfile.simulator,
+    releaseChannel: buildProfile.releaseChannel,
+    updates: { channel: buildProfile.channel },
+    developmentClient: buildProfile.developmentClient,
+    simulator: buildProfile.simulator,
     scheme: jobData.buildScheme,
-    buildConfiguration: ctx.buildProfile.buildConfiguration,
-    applicationArchivePath:
-      ctx.buildProfile.applicationArchivePath ?? ctx.buildProfile.artifactPath,
-    buildArtifactPaths: ctx.buildProfile.buildArtifactPaths,
+    buildConfiguration: buildProfile.buildConfiguration,
+    applicationArchivePath: buildProfile.applicationArchivePath ?? buildProfile.artifactPath,
+    buildArtifactPaths: buildProfile.buildArtifactPaths,
     username,
     ...(ctx.ios.buildNumberOverride && {
       version: {
@@ -83,10 +88,15 @@ export async function prepareJobAsync(
       },
     }),
     experimental: {
-      prebuildCommand: ctx.buildProfile.prebuildCommand,
+      prebuildCommand: buildProfile.prebuildCommand,
     },
-    mode: BuildMode.BUILD,
+    mode: buildProfile.config ? BuildMode.CUSTOM : BuildMode.BUILD,
     triggeredBy: BuildTrigger.EAS_CLI,
+    ...(maybeCustomBuildConfigPath && {
+      customBuildConfig: {
+        path: maybeCustomBuildConfigPath,
+      },
+    }),
   };
   return sanitizeJob(job);
 }

packages/eas-cli/src/build/ios/version.ts

@@ -22,6 +22,8 @@ import { readPlistAsync, writePlistAsync } from '../../utils/plist';
 import { updateAppJsonConfigAsync } from '../utils/appJson';
 import { bumpAppVersionAsync, ensureStaticConfigExists } from '../utils/version';
 
+const SHORT_VERSION_REGEX = /^\d+.\d+.\d+$/;
+
 export enum BumpStrategy {
   APP_VERSION,
   BUILD_NUMBER,
@@ -97,6 +99,14 @@ export async function bumpVersionInAppJsonAsync({
   }
 }
 
+function validateShortVersion(shortVersion: string | undefined): void {
+  if (shortVersion && !SHORT_VERSION_REGEX.test(shortVersion)) {
+    throw new Error(
+      `CFBundleShortVersionString (version field in app.json/app.config.js) must be a period-separated list of three non-negative integers. Current value: ${shortVersion}`
+    );
+  }
+}
+
 export async function readShortVersionAsync(
   projectDir: string,
   exp: ExpoConfig,
@@ -105,11 +115,15 @@ export async function readShortVersionAsync(
   const workflow = await resolveWorkflowAsync(projectDir, Platform.IOS);
   if (workflow === Workflow.GENERIC) {
     const infoPlist = await readInfoPlistAsync(projectDir, buildSettings);
-    return (
+
+    const shortVersion =
       infoPlist.CFBundleShortVersionString &&
-      evaluateTemplateString(infoPlist.CFBundleShortVersionString, buildSettings)
-    );
+      evaluateTemplateString(infoPlist.CFBundleShortVersionString, buildSettings);
+
+    validateShortVersion(shortVersion);
+    return shortVersion;
   } else {
+    validateShortVersion(exp.version);
     return exp.version;
   }
 }

packages/eas-cli/src/build/metadata.ts

@@ -1,5 +1,5 @@
 import { Updates } from '@expo/config-plugins';
-import { Metadata, Platform, sanitizeMetadata } from '@expo/eas-build-job';
+import { BuildMode, Metadata, Platform, sanitizeMetadata } from '@expo/eas-build-job';
 import { IosEnterpriseProvisioning } from '@expo/eas-json';
 import fs from 'fs-extra';
 import resolveFrom from 'resolve-from';
@@ -19,6 +19,7 @@ import { getVcsClient } from '../vcs';
 import { maybeResolveVersionsAsync as maybeResolveAndroidVersionsAsync } from './android/version';
 import { BuildContext } from './context';
 import { maybeResolveVersionsAsync as maybeResolveIosVersionsAsync } from './ios/version';
+import { LocalBuildMode } from './local';
 
 export async function collectMetadataAsync<T extends Platform>(
   ctx: BuildContext<T>
@@ -47,7 +48,10 @@ export async function collectMetadataAsync<T extends Platform>(
     gitCommitMessage: truncateGitCommitMessage(
       (await vcsClient.getLastCommitMessageAsync()) ?? undefined
     ),
-    isGitWorkingTreeDirty: await vcsClient.hasUncommittedChangesAsync(),
+    isGitWorkingTreeDirty:
+      ctx.localBuildOptions.localBuildMode === LocalBuildMode.INTERNAL
+        ? false
+        : await vcsClient.hasUncommittedChangesAsync(),
     username: getUsername(ctx.exp, ctx.user),
     message: ctx.message,
     ...(ctx.platform === Platform.IOS && {
@@ -57,6 +61,8 @@ export async function collectMetadataAsync<T extends Platform>(
     }),
     runWithNoWaitFlag: ctx.noWait,
     runFromCI: ctx.runFromCI,
+    buildMode: ctx.buildProfile.config ? BuildMode.CUSTOM : BuildMode.BUILD,
+    customWorkflowName: ctx.customBuildConfigMetadata?.workflowName,
   };
   return sanitizeMetadata(metadata);
 }

packages/eas-cli/src/build/queries.ts

@@ -99,10 +99,6 @@ export async function listAndSelectBuildOnAppAsync(
   }
 }
 
-function formatBuildChoiceValue(value: string | undefined | null): string {
-  return value ? chalk.bold(value) : 'Unknown';
-}
-
 function createBuildToPartialChoiceMaker(
   selectPromptDisabledFunction?: (build: BuildFragment) => boolean
 ) {
@@ -119,19 +115,34 @@ function createBuildToPartialChoiceMaker(
         ? `${build.gitCommitHash.slice(0, 7)} "${chalk.bold(
             splitCommitMessage[0] + (splitCommitMessage.length > 1 ? '…' : '')
           )}"`
-        : 'Unknown';
+        : null;
+
+    const descriptionItems: { name: string; value: string | null }[] = [
+      { name: 'Version', value: build.appVersion ? chalk.bold(build.appVersion) : null },
+      { name: 'Commit', value: formattedCommitData },
+      {
+        name: 'Message',
+        value: build.message
+          ? chalk.bold(
+              build.message.length > 200 ? `${build.message.slice(0, 200)}...` : build.message
+            )
+          : null,
+      },
+      {
+        name: build.platform === AppPlatform.Ios ? 'Build number' : 'Version code',
+        value: build.appBuildVersion ? chalk.bold(build.appBuildVersion) : null,
+      },
+    ];
+
+    const filteredDescriptionArray: string[] = descriptionItems
+      .filter(item => item.value)
+      .map(item => `${chalk.bold(item.name)}: ${item.value}`);
 
     return {
       title: `${chalk.bold(`ID:`)} ${build.id} (${chalk.bold(
         `${fromNow(new Date(build.completedAt))} ago`
       )})`,
-      description: [
-        `\t${chalk.bold(`Version:`)} ${formatBuildChoiceValue(build.appVersion)}`,
-        `\t${chalk.bold(
-          build.platform === AppPlatform.Ios ? 'Build number:' : 'Version code:'
-        )} ${formatBuildChoiceValue(build.appBuildVersion)}`,
-        `\t${chalk.bold(`Commit:`)} ${formattedCommitData}`,
-      ].join('\n'),
+      description: filteredDescriptionArray.length > 0 ? filteredDescriptionArray.join('\n') : '',
       disabled: selectPromptDisabledFunction?.(build),
     };
   };

packages/eas-cli/src/build/runBuildAndSubmit.ts

@@ -31,6 +31,10 @@ import {
   appPlatformEmojis,
   toPlatforms,
 } from '../platform';
+import {
+  CustomBuildConfigMetadata,
+  validateCustomBuildConfigAsync,
+} from '../project/customBuildConfig';
 import { checkExpoSdkIsSupportedAsync } from '../project/expoSdk';
 import { validateMetroConfigForManagedWorkflowAsync } from '../project/metroConfig';
 import { validateAppVersionRuntimePolicySupportAsync } from '../project/projectUtils';
@@ -98,7 +102,7 @@ export async function runBuildAndSubmitAsync(
     projectDir,
     nonInteractive: flags.nonInteractive,
   });
-  const easJsonAccessor = new EasJsonAccessor(projectDir);
+  const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
   const easJsonCliConfig: EasJson['cli'] =
     (await EasJsonUtils.getCliConfigAsync(easJsonAccessor)) ?? {};
 
@@ -116,8 +120,14 @@ export async function runBuildAndSubmitAsync(
     buildProfiles,
   });
 
+  const customBuildConfigMetadataByPlatform: { [p in AppPlatform]?: CustomBuildConfigMetadata } =
+    {};
   for (const buildProfile of buildProfiles) {
     validateBuildProfileVersionSettings(buildProfile, easJsonCliConfig);
+    const maybeMetadata = await validateCustomBuildConfigAsync(projectDir, buildProfile.profile);
+    if (maybeMetadata) {
+      customBuildConfigMetadataByPlatform[toAppPlatform(buildProfile.platform)] = maybeMetadata;
+    }
   }
 
   const startedBuilds: {
@@ -127,6 +137,7 @@ export async function runBuildAndSubmitAsync(
   const buildCtxByPlatform: { [p in AppPlatform]?: BuildContext<Platform> } = {};
 
   for (const buildProfile of buildProfiles) {
+    const platform = toAppPlatform(buildProfile.platform);
     const { build: maybeBuild, buildCtx } = await prepareAndStartBuildAsync({
       projectDir,
       flags,
@@ -137,11 +148,12 @@ export async function runBuildAndSubmitAsync(
       graphqlClient,
       analytics,
       getDynamicProjectConfigAsync,
+      customBuildConfigMetadata: customBuildConfigMetadataByPlatform[platform],
     });
     if (maybeBuild) {
       startedBuilds.push({ build: maybeBuild, buildProfile });
     }
-    buildCtxByPlatform[toAppPlatform(buildProfile.platform)] = buildCtx;
+    buildCtxByPlatform[platform] = buildCtx;
   }
 
   if (flags.localBuildOptions.localBuildMode) {
@@ -244,6 +256,7 @@ async function prepareAndStartBuildAsync({
   graphqlClient,
   analytics,
   getDynamicProjectConfigAsync,
+  customBuildConfigMetadata,
 }: {
   projectDir: string;
   flags: BuildFlags;
@@ -254,6 +267,7 @@ async function prepareAndStartBuildAsync({
   graphqlClient: ExpoGraphqlClient;
   analytics: Analytics;
   getDynamicProjectConfigAsync: DynamicConfigContextFn;
+  customBuildConfigMetadata?: CustomBuildConfigMetadata;
 }): Promise<{ build: BuildFragment | undefined; buildCtx: BuildContext<Platform> }> {
   const buildCtx = await createBuildContextAsync({
     buildProfileName: buildProfile.profileName,
@@ -271,6 +285,7 @@ async function prepareAndStartBuildAsync({
     graphqlClient,
     analytics,
     getDynamicProjectConfigAsync,
+    customBuildConfigMetadata,
   });
 
   if (moreBuilds) {

packages/eas-cli/src/build/utils/formatBuild.ts

@@ -38,6 +38,10 @@ export function formatGraphQLBuild(build: BuildFragment): string {
         }
       },
     },
+    {
+      label: 'Message',
+      value: build.message,
+    },
     {
       label: 'Distribution',
       value: build.distribution?.toLowerCase(),

packages/eas-cli/src/build/utils/printBuildInfo.ts

@@ -15,6 +15,32 @@ import Log, { learnMore, link } from '../../log';
 import { appPlatformDisplayNames, appPlatformEmojis } from '../../platform';
 import { getBuildLogsUrl, getInternalDistributionInstallUrl } from './url';
 
+function terminalLinkFallback(url: string, text: string): string {
+  return `${text} (${url})`;
+}
+
+const errorCodeToErrorMessageOverride: Record<string, (build: BuildFragment) => string> = {
+  EAS_BUILD_UNKNOWN_FASTLANE_ERROR: build =>
+    `The ${link(getBuildLogsUrl(build, 'run-fastlane'), {
+      text: '"Run fastlane"',
+      fallback: terminalLinkFallback(getBuildLogsUrl(build, 'run-fastlane'), '"Run fastlane"'),
+    })} step failed with an unknown error. Refer to the ${link(
+      getBuildLogsUrl(build, 'xcode-logs'),
+      {
+        text: '"Xcode logs"',
+        fallback: terminalLinkFallback(getBuildLogsUrl(build, 'xcode-logs'), '"Xcode logs"'),
+      }
+    )} phase for additional, more detailed logs`,
+  EAS_BUILD_UNKNOWN_GRADLE_ERROR: build =>
+    `Gradle build failed with unknown error. See logs for the ${link(
+      getBuildLogsUrl(build, 'run-gradlew'),
+      {
+        text: '"Run gradlew"',
+        fallback: terminalLinkFallback(getBuildLogsUrl(build, 'run-gradlew'), '"Run gradlew"'),
+      }
+    )} phase for more information.`,
+};
+
 export function printLogsUrls(builds: BuildFragment[]): void {
   if (builds.length === 1) {
     Log.log(`Build details: ${link(getBuildLogsUrl(builds[0]))}`);
@@ -31,7 +57,6 @@ export function printLogsUrls(builds: BuildFragment[]): void {
 }
 
 export function printBuildResults(builds: (BuildFragment | null)[]): void {
-  Log.newLine();
   if (builds.length === 1) {
     const [build] = builds;
     assert(build, 'Build should be defined');
@@ -42,8 +67,8 @@ export function printBuildResults(builds: (BuildFragment | null)[]): void {
 }
 
 function printBuildResult(build: BuildFragment): void {
-  Log.addNewLineIfNone();
   if (build.status === BuildStatus.Errored) {
+    Log.addNewLineIfNone();
     const userError = build.error;
     Log.error(
       `${appPlatformEmojis[build.platform]} ${
@@ -51,11 +76,12 @@ function printBuildResult(build: BuildFragment): void {
       } build failed${userError ? ':' : ''}`
     );
     if (userError) {
-      printUserError(userError);
+      printUserError(userError, build);
     }
     return;
   }
   if (build.status === BuildStatus.Canceled) {
+    Log.addNewLineIfNone();
     Log.error(
       `${appPlatformEmojis[build.platform]} ${
         appPlatformDisplayNames[build.platform]
@@ -65,6 +91,7 @@ function printBuildResult(build: BuildFragment): void {
   }
 
   if (build.distribution === DistributionType.Internal) {
+    Log.addNewLineIfNone();
     const logsUrl = getBuildLogsUrl(build);
     // It's tricky to install the .apk file directly on Android so let's fallback
     // to the build details page and let people press the button to download there
@@ -82,9 +109,14 @@ function printBuildResult(build: BuildFragment): void {
   } else {
     // TODO: it looks like buildUrl could possibly be undefined, based on the code below.
     // we should account for this case better if it is possible
-    const url = build.artifacts?.buildUrl ?? '';
-    Log.log(`${appPlatformEmojis[build.platform]} ${appPlatformDisplayNames[build.platform]} app:`);
-    Log.log(`${link(url)}`);
+    const url = build.artifacts?.buildUrl;
+    if (url) {
+      Log.addNewLineIfNone();
+      Log.log(
+        `${appPlatformEmojis[build.platform]} ${appPlatformDisplayNames[build.platform]} app:`
+      );
+      Log.log(link(url));
+    }
   }
 }
 
@@ -105,9 +137,22 @@ export function printDeprecationWarnings(deprecationInfo?: EasBuildDeprecationIn
   }
 }
 
-export function printUserError(error: BuildError): void {
-  Log.error(error.message);
-  if (error.docsUrl) {
-    Log.error(learnMore(error.docsUrl, { dim: false }));
+export function printUserError(error: BuildError, build: BuildFragment): void {
+  const maybeErrorMessageOverride = maybeGetErrorMessageOverride(error, build);
+  if (maybeErrorMessageOverride) {
+    Log.error(maybeErrorMessageOverride);
+  } else {
+    Log.error(error.message);
+    if (error.docsUrl) {
+      Log.error(learnMore(error.docsUrl, { dim: false }));
+    }
   }
 }
+
+function maybeGetErrorMessageOverride(error: BuildError, build: BuildFragment): string | null {
+  if (!(error.errorCode in errorCodeToErrorMessageOverride)) {
+    return null;
+  }
+
+  return errorCodeToErrorMessageOverride[error.errorCode](build);
+}

packages/eas-cli/src/build/utils/resourceClass.ts

@@ -1,31 +1,34 @@
-import { ExpoConfig } from '@expo/config-types';
 import { Platform } from '@expo/eas-build-job';
 import { BuildProfile, ResourceClass } from '@expo/eas-json';
 import chalk from 'chalk';
-import semver from 'semver';
 
 import { BuildResourceClass } from '../../graphql/generated';
-import Log from '../../log';
-import { getReactNativeVersionAsync } from '../metadata';
+import Log, { link } from '../../log';
+
+type AndroidResourceClass = Exclude<
+  ResourceClass,
+  | ResourceClass.M1_EXPERIMENTAL
+  | ResourceClass.M1_MEDIUM
+  | ResourceClass.M1_LARGE
+  | ResourceClass.INTEL_MEDIUM
+  | ResourceClass.M_MEDIUM
+  | ResourceClass.M_LARGE
+>;
 
 const iosResourceClassToBuildResourceClassMapping: Record<ResourceClass, BuildResourceClass> = {
   [ResourceClass.DEFAULT]: BuildResourceClass.IosDefault,
   [ResourceClass.LARGE]: BuildResourceClass.IosLarge,
-  [ResourceClass.M1_EXPERIMENTAL]: BuildResourceClass.IosM1Large,
-  [ResourceClass.M1_MEDIUM]: BuildResourceClass.IosM1Medium,
-  [ResourceClass.M1_LARGE]: BuildResourceClass.IosM1Large,
+  [ResourceClass.M1_EXPERIMENTAL]: BuildResourceClass.IosMMedium,
+  [ResourceClass.M1_MEDIUM]: BuildResourceClass.IosMMedium,
+  [ResourceClass.M1_LARGE]: BuildResourceClass.IosMLarge,
   [ResourceClass.INTEL_MEDIUM]: BuildResourceClass.IosIntelMedium,
   [ResourceClass.MEDIUM]: BuildResourceClass.IosMedium,
+  [ResourceClass.M_MEDIUM]: BuildResourceClass.IosMMedium,
+  [ResourceClass.M_LARGE]: BuildResourceClass.IosMLarge,
 };
 
 const androidResourceClassToBuildResourceClassMapping: Record<
-  Exclude<
-    ResourceClass,
-    | ResourceClass.M1_EXPERIMENTAL
-    | ResourceClass.M1_MEDIUM
-    | ResourceClass.M1_LARGE
-    | ResourceClass.INTEL_MEDIUM
-  >,
+  AndroidResourceClass,
   BuildResourceClass
 > = {
   [ResourceClass.DEFAULT]: BuildResourceClass.AndroidDefault,
@@ -36,22 +39,20 @@ const androidResourceClassToBuildResourceClassMapping: Record<
 export async function resolveBuildResourceClassAsync<T extends Platform>(
   profile: BuildProfile<T>,
   platform: Platform,
-  projectDir: string,
-  exp: ExpoConfig,
   resourceClassFlag?: ResourceClass
 ): Promise<BuildResourceClass> {
   const profileResourceClass = profile.resourceClass;
 
   if (profileResourceClass && resourceClassFlag && resourceClassFlag !== profileResourceClass) {
     Log.warn(
-      `Build profile specifies the "${profileResourceClass}" resource class but you passed "${resourceClassFlag}" to --resource-class.\nUsing the  "${resourceClassFlag}" as the override.`
+      `Build profile specifies the "${profileResourceClass}" resource class but you passed "${resourceClassFlag}" to --resource-class.\nUsing "${resourceClassFlag}" as the override.`
     );
   }
 
   const selectedResourceClass = resourceClassFlag ?? profileResourceClass;
 
   return platform === Platform.IOS
-    ? await resolveIosResourceClassAsync(exp, projectDir, resourceClassFlag ?? profileResourceClass)
+    ? resolveIosResourceClass(resourceClassFlag, profileResourceClass)
     : resolveAndroidResourceClass(selectedResourceClass);
 }
 
@@ -70,44 +71,38 @@ function resolveAndroidResourceClass(selectedResourceClass?: ResourceClass): Bui
 
   const resourceClass = selectedResourceClass ?? ResourceClass.DEFAULT;
 
-  return androidResourceClassToBuildResourceClassMapping[
-    resourceClass as Exclude<
-      ResourceClass,
-      | ResourceClass.M1_EXPERIMENTAL
-      | ResourceClass.M1_MEDIUM
-      | ResourceClass.M1_LARGE
-      | ResourceClass.INTEL_MEDIUM
-    >
-  ];
+  return androidResourceClassToBuildResourceClassMapping[resourceClass as AndroidResourceClass];
 }
 
-async function resolveIosResourceClassAsync(
-  exp: ExpoConfig,
-  projectDir: string,
-  selectedResourceClass?: ResourceClass
-): Promise<BuildResourceClass> {
-  const resourceClass =
-    selectedResourceClass ?? (await resolveIosDefaultRequestedResourceClassAsync(exp, projectDir));
+function resolveIosResourceClass(
+  resourceClassFlag?: ResourceClass,
+  profileResourceClass?: ResourceClass
+): BuildResourceClass {
+  const resourceClass = resourceClassFlag ?? profileResourceClass ?? ResourceClass.DEFAULT;
 
-  if (resourceClass === ResourceClass.M1_EXPERIMENTAL) {
-    Log.warn(`Resource class ${chalk.bold('m1-experimental')} is deprecated.`);
+  if (resourceClassFlag === ResourceClass.LARGE) {
+    throw new Error(
+      `Experimental "large" resource class for Intel iOS workers is no longer available. Remove the specified resource class to use the default, or learn more about all available resource classes: ${link(
+        'https://docs.expo.dev/build-reference/eas-json/'
+      )}`
+    );
+  }
+
+  if ([ResourceClass.M1_EXPERIMENTAL, ResourceClass.M1_MEDIUM].includes(resourceClass)) {
+    Log.warn(
+      `Resource class ${chalk.bold(resourceClass)} is deprecated. Use ${chalk.bold(
+        'm-medium'
+      )} instead.`
+    );
+  }
+
+  if ([ResourceClass.M_LARGE, ResourceClass.M1_LARGE].includes(resourceClass)) {
+    Log.warn(
+      `Resource class ${chalk.bold(resourceClass)} is deprecated. Use ${chalk.bold(
+        'large'
+      )} instead.`
+    );
   }
 
   return iosResourceClassToBuildResourceClassMapping[resourceClass];
 }
-
-async function resolveIosDefaultRequestedResourceClassAsync(
-  exp: ExpoConfig,
-  projectDir: string
-): Promise<ResourceClass> {
-  const { sdkVersion } = exp;
-  const reactNativeVersion = await getReactNativeVersionAsync(projectDir);
-  if (
-    (sdkVersion && semver.satisfies(sdkVersion, '>=48')) ||
-    (reactNativeVersion && semver.satisfies(reactNativeVersion, '>=0.71.0'))
-  ) {
-    return ResourceClass.M1_MEDIUM;
-  } else {
-    return ResourceClass.DEFAULT;
-  }
-}

packages/eas-cli/src/build/utils/url.ts

@@ -10,12 +10,14 @@ export function getProjectDashboardUrl(accountName: string, projectName: string)
   ).toString();
 }
 
-export function getBuildLogsUrl(build: BuildFragment): string {
+export function getBuildLogsUrl(build: BuildFragment, hash?: string): string {
   const { project } = build;
   const url =
     project.__typename !== 'App'
       ? `/builds/${build.id}`
-      : `/accounts/${project.ownerAccount.name}/projects/${project.slug}/builds/${build.id}`;
+      : `/accounts/${project.ownerAccount.name}/projects/${project.slug}/builds/${build.id}${
+          hash ? `#${hash}` : ''
+        }`;
 
   return new URL(url, getExpoWebsiteBaseUrl()).toString();
 }

packages/eas-cli/src/commandUtils/EasCommand.ts

@@ -1,4 +1,5 @@
 import { Command } from '@oclif/core';
+import { CombinedError } from '@urql/core';
 import nullthrows from 'nullthrows';
 
 import {
@@ -6,6 +7,7 @@ import {
   CommandEvent,
   createAnalyticsAsync,
 } from '../analytics/AnalyticsManager';
+import Log from '../log';
 import SessionManager from '../user/SessionManager';
 import AnalyticsContextField from './context/AnalyticsContextField';
 import ContextField from './context/ContextField';
@@ -16,8 +18,9 @@ import { OptionalProjectConfigContextField } from './context/OptionalProjectConf
 import ProjectConfigContextField from './context/ProjectConfigContextField';
 import ProjectDirContextField from './context/ProjectDirContextField';
 import SessionManagementContextField from './context/SessionManagementContextField';
+import { EasCommandError } from './errors';
 
-type ContextInput<
+export type ContextInput<
   T extends {
     [name: string]: any;
   } = object
@@ -25,7 +28,7 @@ type ContextInput<
   [P in keyof T]: ContextField<T[P]>;
 };
 
-type ContextOutput<
+export type ContextOutput<
   T extends {
     [name: string]: any;
   } = object
@@ -33,6 +36,8 @@ type ContextOutput<
   [P in keyof T]: T[P];
 };
 
+const BASE_GRAPHQL_ERROR_MESSAGE: string = 'GraphQL request failed.';
+
 export default abstract class EasCommand extends Command {
   protected static readonly ContextOptions = {
     /**
@@ -103,6 +108,18 @@ export default abstract class EasCommand extends Command {
    */
   static contextDefinition: ContextInput = {};
 
+  /**
+   * The user session manager. Responsible for coordinating all user session related state.
+   * If needed in a subclass, use the SessionManager ContextOption.
+   */
+  private sessionManagerInternal?: SessionManager;
+
+  /**
+   * The analytics manager. Used for logging analytics.
+   * It is set up here to ensure a consistent setup.
+   */
+  private analyticsInternal?: AnalyticsWithOrchestration;
+
   /**
    * Execute the context in the contextDefinition to satisfy command prerequisites.
    */
@@ -132,20 +149,10 @@ export default abstract class EasCommand extends Command {
     return Object.fromEntries(contextValuePairs);
   }
 
-  /**
-   * The user session manager. Responsible for coordinating all user session related state.
-   * If needed in a subclass, use the SessionManager ContextOption.
-   */
-  private sessionManagerInternal?: SessionManager;
   private get sessionManager(): SessionManager {
     return nullthrows(this.sessionManagerInternal);
   }
 
-  /**
-   * The analytics manager. Used for logging analytics.
-   * It is set up here to ensure a consistent set up.
-   */
-  private analyticsInternal?: AnalyticsWithOrchestration;
   private get analytics(): AnalyticsWithOrchestration {
     return nullthrows(this.analyticsInternal);
   }
@@ -175,4 +182,22 @@ export default abstract class EasCommand extends Command {
     await this.analytics.flushAsync();
     return super.finally(err);
   }
+
+  protected override catch(err: Error): Promise<any> {
+    let baseMessage = `${this.id} command failed.`;
+    if (err instanceof EasCommandError) {
+      Log.error(err.message);
+    } else if (err instanceof CombinedError && err?.graphQLErrors) {
+      let cleanMessage = err.message.replace('[GraphQL] ', '');
+      cleanMessage += err?.graphQLErrors?.[0]?.extensions?.requestId
+        ? `\nRequest ID: ${err.graphQLErrors[0].extensions.requestId}`
+        : '';
+      Log.error(cleanMessage);
+      baseMessage = BASE_GRAPHQL_ERROR_MESSAGE;
+    } else {
+      Log.error(err.message);
+    }
+    Log.debug(err);
+    throw new Error(baseMessage);
+  }
 }

packages/eas-cli/src/commandUtils/__tests__/EasCommand-test.ts

@@ -1,4 +1,9 @@
+import { CombinedError } from '@urql/core';
+import { GraphQLError } from 'graphql/error';
+import { v4 as uuidv4 } from 'uuid';
+
 import { AnalyticsWithOrchestration, createAnalyticsAsync } from '../../analytics/AnalyticsManager';
+import Log from '../../log';
 import SessionManager from '../../user/SessionManager';
 import EasCommand from '../EasCommand';
 
@@ -11,8 +16,10 @@ jest.mock('../../analytics/AnalyticsManager', () => {
     createAnalyticsAsync: jest.fn(),
   };
 });
+jest.mock('../../log');
 
 let originalProcessArgv: string[];
+const mockRequestId = uuidv4();
 
 beforeAll(() => {
   originalProcessArgv = process.argv;
@@ -40,7 +47,7 @@ const createTestEasCommand = (): typeof EasCommand => {
     async runAsync(): Promise<void> {}
   }
 
-  TestEasCommand.id = 'TestEasCommand'; // normally oclif will assign ids, but b/c this is located outside the commands folder it will not
+  TestEasCommand.id = 'testEasCommand'; // normally oclif will assign ids, but b/c this is located outside the commands folder it will not
   return TestEasCommand;
 };
 
@@ -96,5 +103,103 @@ describe(EasCommand.name, () => {
 
       expect(analytics.flushAsync).toHaveBeenCalled();
     });
+
+    describe('catch', () => {
+      it('logs the message', async () => {
+        const TestEasCommand = createTestEasCommand();
+        const logErrorSpy = jest.spyOn(Log, 'error');
+        const logDebugSpy = jest.spyOn(Log, 'debug');
+        const runAsyncMock = jest.spyOn(TestEasCommand.prototype as any, 'runAsync');
+        const error = new Error('Unexpected, internal error message');
+        runAsyncMock.mockImplementation(() => {
+          throw error;
+        });
+        try {
+          await TestEasCommand.run();
+        } catch {}
+
+        expect(logErrorSpy).toBeCalledWith('Unexpected, internal error message');
+        expect(logDebugSpy).toBeCalledWith(error);
+      });
+
+      it('logs the cleaned message if needed', async () => {
+        const TestEasCommand = createTestEasCommand();
+        const logErrorSpy = jest.spyOn(Log, 'error');
+        const logDebugSpy = jest.spyOn(Log, 'debug');
+        const runAsyncMock = jest.spyOn(TestEasCommand.prototype as any, 'runAsync');
+        const graphQLErrors = ['Unexpected GraphQL error message'];
+        const error = new CombinedError({ graphQLErrors });
+        runAsyncMock.mockImplementation(() => {
+          throw error;
+        });
+        try {
+          await TestEasCommand.run();
+        } catch {}
+
+        expect(logErrorSpy).toBeCalledWith('Unexpected GraphQL error message');
+        expect(logDebugSpy).toBeCalledWith(error);
+      });
+
+      it('logs the cleaned message with request ID if present', async () => {
+        const TestEasCommand = createTestEasCommand();
+        const logErrorSpy = jest.spyOn(Log, 'error');
+        const logDebugSpy = jest.spyOn(Log, 'debug');
+        const runAsyncMock = jest.spyOn(TestEasCommand.prototype as any, 'runAsync');
+        const graphQLError = new GraphQLError(
+          'Unexpected GraphQL error message',
+          null,
+          null,
+          null,
+          null,
+          null,
+          {
+            errorCode: 'UNKNOWN_GRAPHQL_ERROR',
+            requestId: mockRequestId,
+          }
+        );
+        const graphQLErrors = [graphQLError];
+        const error = new CombinedError({ graphQLErrors });
+        runAsyncMock.mockImplementation(() => {
+          throw error;
+        });
+        try {
+          await TestEasCommand.run();
+        } catch {}
+
+        expect(logErrorSpy).toBeCalledWith(
+          `Unexpected GraphQL error message\nRequest ID: ${mockRequestId}`
+        );
+        expect(logDebugSpy).toBeCalledWith(error);
+      });
+
+      it('re-throws the error with default base message', async () => {
+        const TestEasCommand = createTestEasCommand();
+        const runAsyncMock = jest.spyOn(TestEasCommand.prototype as any, 'runAsync');
+        runAsyncMock.mockImplementation(() => {
+          throw new Error('Error message');
+        });
+        try {
+          await TestEasCommand.run();
+        } catch (caughtError) {
+          expect(caughtError).toBeInstanceOf(Error);
+          expect((caughtError as Error).message).toEqual('testEasCommand command failed.');
+        }
+      });
+
+      it('re-throws the error with a different default base message in case of graphQLError', async () => {
+        const TestEasCommand = createTestEasCommand();
+        const runAsyncMock = jest.spyOn(TestEasCommand.prototype as any, 'runAsync');
+        runAsyncMock.mockImplementation(() => {
+          const graphQLErrors = ['Unexpected GraphQL error message'];
+          throw new CombinedError({ graphQLErrors });
+        });
+        try {
+          await TestEasCommand.run();
+        } catch (caughtError) {
+          expect(caughtError).toBeInstanceOf(Error);
+          expect((caughtError as Error).message).toEqual('GraphQL request failed.');
+        }
+      });
+    });
   });
 });

packages/eas-cli/src/commandUtils/context/DynamicProjectConfigContextField.ts

@@ -16,8 +16,8 @@ export class DynamicProjectConfigContextField extends ContextField<DynamicConfig
     nonInteractive,
     sessionManager,
   }: ContextOptions): Promise<DynamicConfigContextFn> {
+    const projectDir = await findProjectDirAndVerifyProjectSetupAsync();
     return async (options?: ExpoConfigOptions) => {
-      const projectDir = await findProjectDirAndVerifyProjectSetupAsync();
       const expBefore = getExpoConfig(projectDir, options);
       const projectId = await getProjectIdAsync(sessionManager, expBefore, {
         nonInteractive,

packages/eas-cli/src/commandUtils/context/contextUtils/__tests__/getProjectIdAsync-test.ts

@@ -15,7 +15,6 @@ jest.mock('fs');
 
 jest.mock('../../../../graphql/queries/AppQuery');
 jest.mock('../../contextUtils/findProjectDirAndVerifyProjectSetupAsync');
-jest.mock('../../../../user/User');
 jest.mock('../../../../ora', () => ({
   ora: () => ({
     start: () => ({ succeed: () => {}, fail: () => {} }),
@@ -107,7 +106,79 @@ describe(getProjectIdAsync, () => {
         { nonInteractive: false }
       )
     ).rejects.toThrow(
-      `Project config: Project identified by "extra.eas.projectId" (notnotbrent) is not owned by owner specified in the "owner" field (wat). ${learnMore(
+      `Project config: Owner of project identified by "extra.eas.projectId" (notnotbrent) does not match owner specified in the "owner" field (wat). ${learnMore(
+        'https://expo.fyi/eas-project-id'
+      )}`
+    );
+  });
+
+  it('throws when the owner is not specified and is different than logged in user', async () => {
+    jest.mocked(getConfig).mockReturnValue({
+      exp: { name: 'test', slug: 'test', extra: { eas: { projectId: '1234' } } },
+    } as any);
+    jest.mocked(AppQuery.byIdAsync).mockResolvedValue({
+      id: '1234',
+      fullName: '@totallybrent/test',
+      slug: 'test',
+      ownerAccount: { name: 'totallybrent' } as any,
+    });
+
+    await expect(
+      getProjectIdAsync(
+        sessionManager,
+        { name: 'test', slug: 'test', extra: { eas: { projectId: '1234' } } },
+        { nonInteractive: false }
+      )
+    ).rejects.toThrow(
+      `Project config: Owner of project identified by "extra.eas.projectId" (totallybrent) does not match the logged in user (notnotbrent) and the "owner" field is not specified. To ensure all libraries work correctly, "owner": "totallybrent" should be added to the project config, which can be done automatically by re-running "eas init". ${learnMore(
+        'https://expo.fyi/eas-project-id'
+      )}`
+    );
+  });
+
+  it('throws when the owner is not specified and is different than logged in user which is a robot', async () => {
+    const sessionManagerMock = mock<SessionManager>();
+    when(sessionManagerMock.ensureLoggedInAsync(anything())).thenResolve({
+      actor: {
+        __typename: 'Robot',
+        id: 'robot_id',
+        accounts: [
+          {
+            id: 'account_id_1',
+            name: 'notnotbrent',
+            users: [{ role: Role.Admin, actor: { id: 'robot_id' } }],
+          },
+          {
+            id: 'account_id_2',
+            name: 'dominik',
+            users: [{ role: Role.ViewOnly, actor: { id: 'robot_id' } }],
+          },
+        ],
+        isExpoAdmin: false,
+        featureGates: {},
+      },
+      authenticationInfo: { accessToken: 'fake', sessionSecret: null },
+    });
+    const sessionManagerRobot = instance(sessionManagerMock);
+
+    jest.mocked(getConfig).mockReturnValue({
+      exp: { name: 'test', slug: 'test', extra: { eas: { projectId: '1234' } } },
+    } as any);
+    jest.mocked(AppQuery.byIdAsync).mockResolvedValue({
+      id: '1234',
+      fullName: '@totallybrent/test',
+      slug: 'test',
+      ownerAccount: { name: 'totallybrent' } as any,
+    });
+
+    await expect(
+      getProjectIdAsync(
+        sessionManagerRobot,
+        { name: 'test', slug: 'test', extra: { eas: { projectId: '1234' } } },
+        { nonInteractive: false }
+      )
+    ).rejects.toThrow(
+      `Project config: Owner of project identified by "extra.eas.projectId" (totallybrent) must be specified in "owner" field when using a robot access token. To ensure all libraries work correctly, "owner": "totallybrent" should be added to the project config, which can be done automatically by re-running "eas init". ${learnMore(
         'https://expo.fyi/eas-project-id'
       )}`
     );
@@ -181,4 +252,26 @@ describe(getProjectIdAsync, () => {
       getProjectIdAsync(sessionManager, { name: 'test', slug: 'test' }, { nonInteractive: false })
     ).rejects.toThrow();
   });
+
+  it('throws if extra.eas.projectId is not a string', async () => {
+    jest.mocked(getConfig).mockReturnValue({
+      exp: { name: 'test', slug: 'test', extra: { eas: { projectId: 1234 } } },
+    } as any);
+    jest.mocked(AppQuery.byIdAsync).mockResolvedValue({
+      id: '1234',
+      fullName: '@notnotbrent/test',
+      slug: 'test',
+      ownerAccount: { name: 'notnotbrent' } as any,
+    });
+
+    await expect(
+      getProjectIdAsync(
+        sessionManager,
+        { name: 'test', slug: 'wat', extra: { eas: { projectId: 1234 } } },
+        { nonInteractive: false }
+      )
+    ).rejects.toThrow(
+      `Project config: "extra.eas.projectId" must be a string, found number. If you're not sure how to set it up on your own, remove the property entirely and it will be automatically configured on the next EAS CLI run.`
+    );
+  });
 });

packages/eas-cli/src/commandUtils/context/contextUtils/findProjectDirAndVerifyProjectSetupAsync.ts

@@ -12,7 +12,7 @@ import { getVcsClient, setVcsClient } from '../../../vcs';
 import GitClient from '../../../vcs/clients/git';
 
 async function applyCliConfigAsync(projectDir: string): Promise<void> {
-  const easJsonAccessor = new EasJsonAccessor(projectDir);
+  const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
   const config = await EasJsonUtils.getCliConfigAsync(easJsonAccessor);
   if (config?.version && !semver.satisfies(easCliVersion, config.version)) {
     throw new Error(

packages/eas-cli/src/commandUtils/context/contextUtils/getProjectIdAsync.ts

@@ -10,7 +10,7 @@ import { getExpoConfig } from '../../../project/expoConfig';
 import { fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync } from '../../../project/fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync';
 import { toAppPrivacy } from '../../../project/projectUtils';
 import SessionManager from '../../../user/SessionManager';
-import { Actor } from '../../../user/User';
+import { Actor, getActorUsername } from '../../../user/User';
 import { createGraphqlClient } from './createGraphqlClient';
 import { findProjectRootAsync } from './findProjectDirAndVerifyProjectSetupAsync';
 
@@ -89,18 +89,50 @@ export async function getProjectIdAsync(
 
   const localProjectId = exp.extra?.eas?.projectId;
   if (localProjectId) {
+    if (typeof localProjectId !== 'string') {
+      throw new Error(
+        `Project config: "extra.eas.projectId" must be a string, found ${typeof localProjectId}. If you're not sure how to set it up on your own, remove the property entirely and it will be automatically configured on the next EAS CLI run.`
+      );
+    }
+
     // check that the local project ID matches account and slug
     const appForProjectId = await AppQuery.byIdAsync(graphqlClient, localProjectId);
     if (exp.owner && exp.owner !== appForProjectId.ownerAccount.name) {
       throw new Error(
-        `Project config: Project identified by "extra.eas.projectId" (${
+        `Project config: Owner of project identified by "extra.eas.projectId" (${
           appForProjectId.ownerAccount.name
-        }) is not owned by owner specified in the "owner" field (${exp.owner}). ${learnMore(
+        }) does not match owner specified in the "owner" field (${exp.owner}). ${learnMore(
           'https://expo.fyi/eas-project-id'
         )}`
       );
     }
 
+    const actorUsername = getActorUsername(actor);
+    if (!exp.owner && appForProjectId.ownerAccount.name !== actorUsername) {
+      if (actorUsername) {
+        throw new Error(
+          `Project config: Owner of project identified by "extra.eas.projectId" (${
+            appForProjectId.ownerAccount.name
+          }) does not match the logged in user (${actorUsername}) and the "owner" field is not specified. To ensure all libraries work correctly, "owner": "${
+            appForProjectId.ownerAccount.name
+          }" should be added to the project config, which can be done automatically by re-running "eas init". ${learnMore(
+            'https://expo.fyi/eas-project-id'
+          )}`
+        );
+      } else {
+        // robot caller
+        throw new Error(
+          `Project config: Owner of project identified by "extra.eas.projectId" (${
+            appForProjectId.ownerAccount.name
+          }) must be specified in "owner" field when using a robot access token. To ensure all libraries work correctly, "owner": "${
+            appForProjectId.ownerAccount.name
+          }" should be added to the project config, which can be done automatically by re-running "eas init". ${learnMore(
+            'https://expo.fyi/eas-project-id'
+          )}`
+        );
+      }
+    }
+
     if (exp.slug && exp.slug !== appForProjectId.slug) {
       throw new Error(
         `Project config: Slug for project identified by "extra.eas.projectId" (${

packages/eas-cli/src/commandUtils/errors.ts

@@ -0,0 +1,7 @@
+export class EasCommandError extends Error {
+  // constructor is not useless, since the constructor for Error allows for optional `message`
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+  constructor(message: string) {
+    super(message);
+  }
+}

packages/eas-cli/src/commands/account/view.ts

@@ -1,8 +1,10 @@
 import chalk from 'chalk';
+import nullthrows from 'nullthrows';
 
 import EasCommand from '../../commandUtils/EasCommand';
+import { Role } from '../../graphql/generated';
 import Log from '../../log';
-import { getActorDisplayName } from '../../user/User';
+import { Actor, getActorDisplayName } from '../../user/User';
 
 export default class AccountView extends EasCommand {
   static override description = 'show the username you are logged in as';
@@ -18,9 +20,48 @@ export default class AccountView extends EasCommand {
     } = await this.getContextAsync(AccountView, { nonInteractive: true });
     if (actor) {
       Log.log(chalk.green(getActorDisplayName(actor)));
+
+      // personal account is included, only show if more accounts that personal account
+      // but do show personal account in list if there are more
+      const accountExcludingPersonalAccount = actor.accounts.filter(
+        account => !('username' in actor) || account.name !== actor.username
+      );
+      if (accountExcludingPersonalAccount.length > 0) {
+        Log.newLine();
+        Log.log('Accounts:');
+        actor.accounts.forEach(account => {
+          const roleOnAccount = AccountView.getRoleOnAccount(actor, account);
+          Log.log(`• ${account.name} (Role: ${AccountView.getLabelForRole(roleOnAccount)})`);
+        });
+      }
     } else {
       Log.warn('Not logged in');
       process.exit(1);
     }
   }
+
+  private static getRoleOnAccount(actor: Actor, account: Actor['accounts'][0]): Role {
+    if ('username' in actor && account.name === actor.username) {
+      return Role.Owner;
+    }
+
+    return nullthrows(account.users.find(user => user.actor.id === actor.id)?.role);
+  }
+
+  private static getLabelForRole(role: Role): string {
+    switch (role) {
+      case Role.Owner:
+        return 'Owner';
+      case Role.Admin:
+        return 'Admin';
+      case Role.Developer:
+        return 'Developer';
+      case Role.ViewOnly:
+        return 'Viewer';
+      case Role.Custom:
+      case Role.HasAdmin:
+      case Role.NotAdmin:
+        return 'Custom';
+    }
+  }
 }

packages/eas-cli/src/commands/build/index.ts

@@ -227,6 +227,13 @@ export default class Build extends EasCommand {
         });
       } else if (process.platform !== 'darwin' && requestedPlatform === RequestedPlatform.Ios) {
         Errors.error('Unsupported platform, macOS is required to build apps for iOS', { exit: 1 });
+      } else if (
+        !['linux', 'darwin'].includes(process.platform) &&
+        requestedPlatform === RequestedPlatform.Android
+      ) {
+        Errors.error('Unsupported platform, macOS or Linux is required to build apps for Android', {
+          exit: 1,
+        });
       }
     }
 
@@ -244,7 +251,7 @@ export async function handleDeprecatedEasJsonAsync(
   if (!(await fs.pathExists(EasJsonAccessor.formatEasJsonPath(projectDir)))) {
     return;
   }
-  const easJsonAccessor = new EasJsonAccessor(projectDir);
+  const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
   const profileNames = await EasJsonUtils.getBuildProfileNamesAsync(easJsonAccessor);
   const platformAndProfileNames: [Platform, string][] = profileNames.flatMap(profileName => [
     [Platform.ANDROID, profileName],

packages/eas-cli/src/commands/build/internal.ts

@@ -6,6 +6,8 @@ import { runBuildAndSubmitAsync } from '../../build/runBuildAndSubmit';
 import EasCommand from '../../commandUtils/EasCommand';
 import { RequestedPlatform } from '../../platform';
 import { enableJsonOutput } from '../../utils/json';
+import { setVcsClient } from '../../vcs';
+import GitNoCommitClient from '../../vcs/clients/gitNoCommit';
 
 /**
  * This command will be run on the EAS Build workers, when building
@@ -51,6 +53,8 @@ export default class BuildInternal extends EasCommand {
       nonInteractive: true,
     });
 
+    setVcsClient(new GitNoCommitClient());
+
     await handleDeprecatedEasJsonAsync(projectDir, flags.nonInteractive);
 
     await runBuildAndSubmitAsync(

packages/eas-cli/src/commands/build/resign.ts

@@ -121,7 +121,7 @@ export default class BuildResign extends EasCommand {
     await handleDeprecatedEasJsonAsync(projectDir, flags.nonInteractive);
 
     await maybeWarnAboutEasOutagesAsync(graphqlClient, [StatuspageServiceName.EasBuild]);
-    const easJsonAccessor = new EasJsonAccessor(projectDir);
+    const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
     const easJsonCliConfig: EasJson['cli'] =
       (await EasJsonUtils.getCliConfigAsync(easJsonAccessor)) ?? {};
 

packages/eas-cli/src/commands/build/version/get.ts

@@ -0,0 +1,120 @@
+import { Platform } from '@expo/eas-build-job';
+import { EasJsonAccessor } from '@expo/eas-json';
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+
+import EasCommand from '../../../commandUtils/EasCommand';
+import { EasNonInteractiveAndJsonFlags } from '../../../commandUtils/flags';
+import { AppVersionQuery } from '../../../graphql/queries/AppVersionQuery';
+import { toAppPlatform } from '../../../graphql/types/AppPlatform';
+import Log from '../../../log';
+import { selectRequestedPlatformAsync, toPlatforms } from '../../../platform';
+import { getApplicationIdentifierAsync } from '../../../project/applicationIdentifier';
+import {
+  ensureVersionSourceIsRemoteAsync,
+  validateAppConfigForRemoteVersionSource,
+} from '../../../project/remoteVersionSource';
+import { enableJsonOutput, printJsonOnlyOutput } from '../../../utils/json';
+import { getProfilesAsync } from '../../../utils/profiles';
+
+export default class BuildVersionGetView extends EasCommand {
+  public static override description = 'get the latest version from EAS servers';
+
+  public static override flags = {
+    platform: Flags.enum({
+      char: 'p',
+      options: ['android', 'ios', 'all'],
+    }),
+    profile: Flags.string({
+      char: 'e',
+      description:
+        'Name of the build profile from eas.json. Defaults to "production" if defined in eas.json.',
+      helpValue: 'PROFILE_NAME',
+    }),
+    ...EasNonInteractiveAndJsonFlags,
+  };
+
+  static override contextDefinition = {
+    ...this.ContextOptions.LoggedIn,
+    ...this.ContextOptions.DynamicProjectConfig,
+    ...this.ContextOptions.ProjectDir,
+  };
+
+  public async runAsync(): Promise<void> {
+    const { flags } = await this.parse(BuildVersionGetView);
+    if (flags.json) {
+      enableJsonOutput();
+    }
+    const {
+      loggedIn: { graphqlClient },
+      getDynamicProjectConfigAsync,
+      projectDir,
+    } = await this.getContextAsync(BuildVersionGetView, {
+      nonInteractive: true,
+    });
+
+    if (!flags.platform && flags['non-interactive']) {
+      throw new Error('"--platform" flag is required in non-interactive mode.');
+    }
+    const requestedPlatform = await selectRequestedPlatformAsync(flags.platform);
+    const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
+    await ensureVersionSourceIsRemoteAsync(easJsonAccessor, {
+      nonInteractive: flags['non-interactive'],
+    });
+
+    const platforms = toPlatforms(requestedPlatform);
+    const buildProfiles = await getProfilesAsync({
+      type: 'build',
+      easJsonAccessor,
+      platforms,
+      profileName: flags.profile ?? undefined,
+    });
+    const results: { [key in Platform]?: string } = {};
+    for (const { profile, platform } of buildProfiles) {
+      const { exp, projectId } = await getDynamicProjectConfigAsync({
+        env: profile.env,
+      });
+
+      validateAppConfigForRemoteVersionSource(exp, platform);
+
+      const applicationIdentifier = await getApplicationIdentifierAsync({
+        graphqlClient,
+        projectDir,
+        projectId,
+        exp,
+        buildProfile: profile,
+        platform,
+      });
+      const remoteVersions = await AppVersionQuery.latestVersionAsync(
+        graphqlClient,
+        projectId,
+        toAppPlatform(platform),
+        applicationIdentifier
+      );
+      if (remoteVersions?.buildVersion) {
+        results[platform] = remoteVersions?.buildVersion;
+      }
+    }
+    if (flags.json) {
+      const jsonResults: { versionCode?: string; buildNumber?: string } = {};
+      if (results.android) {
+        jsonResults.versionCode = results.android;
+      }
+      if (results.ios) {
+        jsonResults.buildNumber = results.ios;
+      }
+      printJsonOnlyOutput(jsonResults);
+    } else {
+      if (Object.keys(results).length === 0) {
+        Log.log('No remote versions are configured for this project.');
+        return;
+      }
+      if (results.android) {
+        Log.log(`Android versionCode - ${chalk.bold(results.android)}`);
+      }
+      if (results.ios) {
+        Log.log(`iOS buildNumber - ${chalk.bold(results.ios)}`);
+      }
+    }
+  }
+}

packages/eas-cli/src/commands/build/version/set.ts

@@ -22,7 +22,7 @@ import {
 import { promptAsync } from '../../../prompts';
 
 export default class BuildVersionSetView extends EasCommand {
-  static override description = 'Update version of an app.';
+  static override description = 'update version of an app';
 
   static override flags = {
     platform: Flags.enum({
@@ -46,7 +46,7 @@ export default class BuildVersionSetView extends EasCommand {
   public async runAsync(): Promise<void> {
     const { flags } = await this.parse(BuildVersionSetView);
     const {
-      loggedIn: { actor, graphqlClient },
+      loggedIn: { graphqlClient },
       getDynamicProjectConfigAsync,
       projectDir,
     } = await this.getContextAsync(BuildVersionSetView, {
@@ -54,8 +54,8 @@ export default class BuildVersionSetView extends EasCommand {
     });
 
     const platform = await selectPlatformAsync(flags.platform);
-    const easJsonAccessor = new EasJsonAccessor(projectDir);
-    await ensureVersionSourceIsRemoteAsync(easJsonAccessor);
+    const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
+    await ensureVersionSourceIsRemoteAsync(easJsonAccessor, { nonInteractive: false });
     const profile = await EasJsonUtils.getBuildProfileAsync(
       easJsonAccessor,
       platform,
@@ -67,13 +67,14 @@ export default class BuildVersionSetView extends EasCommand {
 
     validateAppConfigForRemoteVersionSource(exp, platform);
 
-    const applicationIdentifier = await getApplicationIdentifierAsync(
+    const applicationIdentifier = await getApplicationIdentifierAsync({
+      graphqlClient,
       projectDir,
+      projectId,
       exp,
-      profile,
+      buildProfile: profile,
       platform,
-      actor
-    );
+    });
     const remoteVersions = await AppVersionQuery.latestVersionAsync(
       graphqlClient,
       projectId,

packages/eas-cli/src/commands/build/version/sync.ts

@@ -39,7 +39,7 @@ interface SyncContext<T extends Platform> {
 
 export default class BuildVersionSyncView extends EasCommand {
   public static override description =
-    'Update a version in native code with a value stored on EAS servers';
+    'update a version in native code with a value stored on EAS servers';
 
   public static override flags = {
     platform: Flags.enum({
@@ -63,7 +63,7 @@ export default class BuildVersionSyncView extends EasCommand {
   public async runAsync(): Promise<void> {
     const { flags } = await this.parse(BuildVersionSyncView);
     const {
-      loggedIn: { actor, graphqlClient },
+      loggedIn: { graphqlClient },
       getDynamicProjectConfigAsync,
       projectDir,
     } = await this.getContextAsync(BuildVersionSyncView, {
@@ -71,8 +71,8 @@ export default class BuildVersionSyncView extends EasCommand {
     });
 
     const requestedPlatform = await selectRequestedPlatformAsync(flags.platform);
-    const easJsonAccessor = new EasJsonAccessor(projectDir);
-    await ensureVersionSourceIsRemoteAsync(easJsonAccessor);
+    const easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
+    await ensureVersionSourceIsRemoteAsync(easJsonAccessor, { nonInteractive: false });
 
     const platforms = toPlatforms(requestedPlatform);
     const buildProfiles = await getProfilesAsync({
@@ -89,13 +89,14 @@ export default class BuildVersionSyncView extends EasCommand {
       validateAppConfigForRemoteVersionSource(exp, profileInfo.platform);
       const platformDisplayName = appPlatformDisplayNames[toAppPlatform(profileInfo.platform)];
 
-      const applicationIdentifier = await getApplicationIdentifierAsync(
+      const applicationIdentifier = await getApplicationIdentifierAsync({
+        graphqlClient,
         projectDir,
+        projectId,
         exp,
-        profileInfo.profile,
-        profileInfo.platform,
-        actor
-      );
+        buildProfile: profileInfo.profile,
+        platform: profileInfo.platform,
+      });
       const remoteVersions = await AppVersionQuery.latestVersionAsync(
         graphqlClient,
         projectId,

packages/eas-cli/src/commands/channel/rollout.ts

@@ -1,6 +1,8 @@
 import { Flags } from '@oclif/core';
 import chalk from 'chalk';
 
+import { selectBranchOnAppAsync } from '../../branch/queries';
+import { selectChannelOnAppAsync } from '../../channel/queries';
 import { BranchMapping, getBranchMapping } from '../../channel/utils';
 import EasCommand from '../../commandUtils/EasCommand';
 import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
@@ -132,13 +134,11 @@ async function startRolloutAsync(
     );
   }
 
-  const logMessage = `️Started a rollout of branch ${chalk.bold(
+  const logMessage = `Started a rollout of branch ${chalk.bold(branchName)} on channel ${chalk.bold(
+    channelName!
+  )}! ${chalk.bold(percent)}% of users will be directed to branch ${chalk.bold(
     branchName
-  )} onto channel ${chalk.bold(channelName!)}! ${chalk.bold(
-    percent
-  )}% of users will be directed to branch ${chalk.bold(branchName)}, ${chalk.bold(
-    100 - percent
-  )}% to branch ${chalk.bold(oldBranch.name)}.`;
+  )}, ${chalk.bold(100 - percent)}% to branch ${chalk.bold(oldBranch.name)}.`;
 
   return { newChannelInfo, logMessage };
 }
@@ -190,7 +190,7 @@ async function editRolloutAsync(
     branchMapping: JSON.stringify(newBranchMapping),
   });
 
-  const logMessage = `️Rollout of branch ${chalk.bold(newBranch.name)} onto channel ${chalk.bold(
+  const logMessage = `Rollout of branch ${chalk.bold(newBranch.name)} on channel ${chalk.bold(
     channelName!
   )} updated from ${chalk.bold(currentPercent)}% to ${chalk.bold(percent)}%. ${chalk.bold(
     percent
@@ -256,11 +256,11 @@ async function endRolloutAsync(
       'Ending the rollout will send all traffic to a single branch. Which one should that be?',
       [
         {
-          title: `${newBranch.name} ${chalk.grey(`- current percent: ${100 - currentPercent}%`)}`,
+          title: `${newBranch.name} ${chalk.grey(`- current percent: ${currentPercent}%`)}`,
           value: true,
         },
         {
-          title: `${oldBranch.name} ${chalk.grey(`- current percent: ${currentPercent}%`)}`,
+          title: `${oldBranch.name} ${chalk.grey(`- current percent: ${100 - currentPercent}%`)}`,
           value: false,
         },
       ]
@@ -284,7 +284,7 @@ async function endRolloutAsync(
     channelId: channel.id,
     branchMapping: JSON.stringify(newBranchMapping),
   });
-  const logMessage = `️Rollout on channel ${chalk.bold(
+  const logMessage = `Rollout on channel ${chalk.bold(
     channelName
   )} ended. All traffic is now sent to branch ${chalk.bold(
     endOnNewBranch ? newBranch.name : oldBranch.name
@@ -294,14 +294,12 @@ async function endRolloutAsync(
 }
 
 export default class ChannelRollout extends EasCommand {
-  static override hidden = true;
-  static override description = 'Rollout a new branch out to a channel incrementally.';
+  static override description = 'Roll a new branch out on a channel incrementally.';
 
   static override args = [
     {
       name: 'channel',
-      required: true,
-      description: 'rollout that the channel is on',
+      description: 'channel on which the rollout should be done',
     },
   ];
 
@@ -311,7 +309,7 @@ export default class ChannelRollout extends EasCommand {
       required: false,
     }),
     percent: Flags.integer({
-      description: 'percent of traffic to redirect to the new branch',
+      description: 'percent of users to send to the new branch',
       required: false,
     }),
     end: Flags.boolean({
@@ -328,7 +326,7 @@ export default class ChannelRollout extends EasCommand {
 
   async runAsync(): Promise<void> {
     const {
-      args: { channel: channelName },
+      args: { channel: channelNameArg },
       flags: {
         json: jsonFlag,
         end: endFlag,
@@ -349,9 +347,23 @@ export default class ChannelRollout extends EasCommand {
 
     const projectDisplayName = await getDisplayNameForProjectIdAsync(graphqlClient, projectId);
 
+    let channelName: string = channelNameArg;
+    if (!channelName) {
+      const { name } = await selectChannelOnAppAsync(graphqlClient, {
+        projectId,
+        selectionPromptTitle: 'Select a channel on which to perform a rollout',
+        paginatedQueryOptions: {
+          json: jsonFlag,
+          nonInteractive,
+          offset: 0,
+        },
+      });
+      channelName = name;
+    }
+
     const channel = await ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
       appId: projectId,
-      channelName: channelName!,
+      channelName,
     });
     if (!channel) {
       throw new Error(
@@ -396,7 +408,15 @@ export default class ChannelRollout extends EasCommand {
     if (!isRollout) {
       rolloutMutationResult = await startRolloutAsync(graphqlClient, {
         channelName,
-        branchName: branchName ?? (await promptForBranchNameAsync(channelName, nonInteractive)),
+        branchName:
+          branchName ??
+          (await promptForBranchNameAsync({
+            graphqlClient,
+            projectId,
+            channelName,
+            nonInteractive,
+            json: jsonFlag,
+          })),
         percent,
         nonInteractive,
         projectId,
@@ -433,18 +453,36 @@ export default class ChannelRollout extends EasCommand {
   }
 }
 
-async function promptForBranchNameAsync(
-  channelName: string,
-  nonInteractive: boolean
-): Promise<string> {
+async function promptForBranchNameAsync({
+  graphqlClient,
+  projectId,
+  channelName,
+  nonInteractive,
+  json,
+}: {
+  graphqlClient: ExpoGraphqlClient;
+  projectId: string;
+  channelName: string;
+  nonInteractive: boolean;
+  json: boolean;
+}): Promise<string> {
   if (nonInteractive) {
     throw new Error('Must supply branch flag in non-interactive mode');
   }
-  const { name } = await promptAsync({
-    type: 'text',
-    name: 'name',
-    message: `Select a branch to rollout onto ${channelName}`,
-    validate: value => (value ? true : 'A branch must be specified.'),
+
+  const { name: branchName } = await selectBranchOnAppAsync(graphqlClient, {
+    projectId,
+    promptTitle: `Which branch would you like roll out on ${channelName}?`,
+    displayTextForListItem: updateBranch => ({
+      title: updateBranch.name,
+    }),
+    // discard limit and offset because this query is not their intended target
+    paginatedQueryOptions: {
+      json,
+      nonInteractive,
+      offset: 0,
+    },
   });
-  return name;
+
+  return branchName;
 }

packages/eas-cli/src/commands/config.ts

@@ -45,7 +45,7 @@ export default class Config extends EasCommand {
       nonInteractive: false,
     });
 
-    const accessor = new EasJsonAccessor(projectDir);
+    const accessor = EasJsonAccessor.fromProjectPath(projectDir);
     const profileName =
       maybeProfile ??
       (await selectAsync(

packages/eas-cli/src/commands/device/delete.ts

@@ -112,11 +112,17 @@ export default class DeviceDelete extends EasCommand {
     const removeAppleSpinner = ora('Disabling device on Apple').start();
     try {
       const appleValidatedDevices = await Device.getAsync(context);
-      const appleValidatedDevice = appleValidatedDevices.find(d => d.id === device.id);
+      const appleValidatedDevice = appleValidatedDevices.find(
+        d => d.attributes.udid === device.identifier
+      );
       if (appleValidatedDevice) {
         await appleValidatedDevice.updateAsync({ status: DeviceStatus.DISABLED });
+        removeAppleSpinner.succeed('Disabled device on Apple');
+      } else {
+        removeAppleSpinner.warn(
+          'Device not found on Apple Developer Portal. Expo-registered devices will not appear there until they are chosen for an internal distribution build.'
+        );
       }
-      removeAppleSpinner.succeed('Disabled device on Apple');
     } catch (err) {
       removeAppleSpinner.fail();
       throw err;

packages/eas-cli/src/commands/device/rename.ts

@@ -0,0 +1,168 @@
+import { Device } from '@expo/apple-utils';
+import { Flags } from '@oclif/core';
+import assert from 'assert';
+
+import EasCommand from '../../commandUtils/EasCommand';
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
+import { PaginatedQueryOptions, getPaginatedQueryOptions } from '../../commandUtils/pagination';
+import { AppleDeviceMutation } from '../../credentials/ios/api/graphql/mutations/AppleDeviceMutation';
+import {
+  AppleDeviceQuery,
+  AppleDeviceQueryResult,
+} from '../../credentials/ios/api/graphql/queries/AppleDeviceQuery';
+import { authenticateAsync, getRequestContext } from '../../credentials/ios/appstore/authenticate';
+import {
+  selectAppleDeviceOnAppleTeamAsync,
+  selectAppleTeamOnAccountAsync,
+} from '../../devices/queries';
+import formatDevice from '../../devices/utils/formatDevice';
+import { AppleDevice, AppleTeamFragment, Maybe } from '../../graphql/generated';
+import Log from '../../log';
+import { ora } from '../../ora';
+import { getOwnerAccountForProjectIdAsync } from '../../project/projectUtils';
+import { promptAsync } from '../../prompts';
+import { enableJsonOutput, printJsonOnlyOutput } from '../../utils/json';
+
+export default class DeviceRename extends EasCommand {
+  static override description = 'rename a registered device';
+
+  static override flags = {
+    'apple-team-id': Flags.string({ description: 'The Apple team ID on which to find the device' }),
+    udid: Flags.string({ description: 'The Apple device ID to rename' }),
+    name: Flags.string({ description: 'The new name for the device' }),
+    ...EasNonInteractiveAndJsonFlags,
+  };
+
+  static override contextDefinition = {
+    ...this.ContextOptions.ProjectConfig,
+    ...this.ContextOptions.LoggedIn,
+  };
+
+  async runAsync(): Promise<void> {
+    const { flags } = await this.parse(DeviceRename);
+    const paginatedQueryOptions = getPaginatedQueryOptions(flags);
+    let { 'apple-team-id': appleTeamIdentifier, udid, name } = flags;
+    const {
+      projectConfig: { projectId },
+      loggedIn: { graphqlClient },
+    } = await this.getContextAsync(DeviceRename, {
+      nonInteractive: paginatedQueryOptions.nonInteractive,
+    });
+    const account = await getOwnerAccountForProjectIdAsync(graphqlClient, projectId);
+    let appleTeamName;
+
+    if (paginatedQueryOptions.json) {
+      enableJsonOutput();
+    }
+
+    let appleTeam: AppleTeamFragment;
+
+    if (!appleTeamIdentifier) {
+      appleTeam = await selectAppleTeamOnAccountAsync(graphqlClient, {
+        accountName: account.name,
+        selectionPromptTitle: `What Apple team would you like to list devices for?`,
+        paginatedQueryOptions,
+      });
+      appleTeamIdentifier = appleTeam.appleTeamIdentifier;
+      appleTeamName = appleTeam.appleTeamName;
+    }
+
+    assert(appleTeamIdentifier, 'No team identifier is specified');
+
+    const chosenDevice = udid
+      ? await AppleDeviceQuery.getByDeviceIdentifierAsync(graphqlClient, account.name, udid)
+      : await selectAppleDeviceOnAppleTeamAsync(graphqlClient, {
+          accountName: account.name,
+          appleTeamIdentifier,
+          selectionPromptTitle: `Which device would you like to rename?`,
+          paginatedQueryOptions,
+        });
+
+    const newDeviceName = name ? name : await this.promptForNewDeviceNameAsync(chosenDevice.name);
+
+    this.logChosenDevice(chosenDevice, appleTeamName, appleTeamIdentifier, paginatedQueryOptions);
+
+    await this.renameDeviceOnExpoAsync(graphqlClient, chosenDevice, newDeviceName!);
+
+    await this.renameDeviceOnAppleAsync(chosenDevice, appleTeamIdentifier, newDeviceName!);
+  }
+
+  async promptForNewDeviceNameAsync(
+    initial: Maybe<string> | undefined
+  ): Promise<string | undefined> {
+    const { name } = await promptAsync({
+      type: 'text',
+      name: 'name',
+      message: 'New device name:',
+      initial: initial ?? undefined,
+    });
+    return name;
+  }
+
+  async renameDeviceOnExpoAsync(
+    graphqlClient: ExpoGraphqlClient,
+    chosenDevice: AppleDevice | AppleDeviceQueryResult,
+    newDeviceName: string
+  ): Promise<void> {
+    const removalSpinner = ora(`Renaming Apple device on Expo`).start();
+    try {
+      await AppleDeviceMutation.updateAppleDeviceAsync(graphqlClient, chosenDevice.id, {
+        name: newDeviceName,
+      });
+      removalSpinner.succeed('Renamed Apple device on Expo');
+    } catch (err) {
+      removalSpinner.fail();
+      throw err;
+    }
+  }
+
+  async renameDeviceOnAppleAsync(
+    device: AppleDevice | AppleDeviceQueryResult,
+    appleTeamIdentifier: string,
+    newDeviceName: string
+  ): Promise<void> {
+    const ctx = await authenticateAsync({ teamId: appleTeamIdentifier });
+    const context = getRequestContext(ctx);
+
+    Log.addNewLineIfNone();
+    const removeAppleSpinner = ora('Renaming device on Apple').start();
+    try {
+      const appleValidatedDevices = await Device.getAsync(context);
+      const appleValidatedDevice = appleValidatedDevices.find(
+        d => d.attributes.udid === device.identifier
+      );
+      if (appleValidatedDevice) {
+        await appleValidatedDevice.updateAsync({ name: newDeviceName });
+        removeAppleSpinner.succeed('Renamed device on Apple');
+      } else {
+        removeAppleSpinner.warn(
+          'Device not found on Apple Developer Portal. Expo-registered devices will not appear there until they are chosen for an internal distribution build.'
+        );
+      }
+    } catch (err) {
+      removeAppleSpinner.fail();
+      throw err;
+    }
+  }
+
+  logChosenDevice(
+    device: AppleDevice | AppleDeviceQueryResult,
+    appleTeamName: Maybe<string> | undefined,
+    appleTeamIdentifier: string,
+    { json }: PaginatedQueryOptions
+  ): void {
+    if (json) {
+      printJsonOnlyOutput(device);
+    } else {
+      Log.addNewLineIfNone();
+      Log.log(
+        formatDevice(device, {
+          appleTeamName,
+          appleTeamIdentifier: appleTeamIdentifier!,
+        })
+      );
+      Log.newLine();
+    }
+  }
+}

packages/eas-cli/src/commands/metadata/lint.ts

@@ -44,7 +44,7 @@ export default class MetadataLint extends EasCommand {
 
     const submitProfiles = await getProfilesAsync({
       type: 'submit',
-      easJsonAccessor: new EasJsonAccessor(projectDir),
+      easJsonAccessor: EasJsonAccessor.fromProjectPath(projectDir),
       platforms: [Platform.IOS],
       profileName: flags.profile,
     });

packages/eas-cli/src/commands/metadata/pull.ts

@@ -46,7 +46,7 @@ export default class MetadataPull extends EasCommand {
 
     const submitProfiles = await getProfilesAsync({
       type: 'submit',
-      easJsonAccessor: new EasJsonAccessor(projectDir),
+      easJsonAccessor: EasJsonAccessor.fromProjectPath(projectDir),
       platforms: [Platform.IOS],
       profileName: flags.profile,
     });

packages/eas-cli/src/commands/metadata/push.ts

@@ -44,7 +44,7 @@ export default class MetadataPush extends EasCommand {
 
     const submitProfiles = await getProfilesAsync({
       type: 'submit',
-      easJsonAccessor: new EasJsonAccessor(projectDir),
+      easJsonAccessor: EasJsonAccessor.fromProjectPath(projectDir),
       platforms: [Platform.IOS],
       profileName: flags.profile,
     });

packages/eas-cli/src/commands/project/__tests__/init.test.ts

@@ -344,12 +344,38 @@ describe(ProjectInit.name, () => {
     describe('when it is already configured', () => {
       beforeEach(() => {
         mockTestProject({ configuredProjectId: '1234', configuredOwner: jester.accounts[0].name });
+
+        jest.mocked(AppQuery.byIdAsync).mockResolvedValue({
+          id: '1234',
+          slug: 'testing-123',
+          fullName: '@jester/testing-123',
+          ownerAccount: jester.accounts[0],
+        });
       });
 
       it('does not configure', async () => {
         await new ProjectInit([], commandOptions).run();
         expect(saveProjectIdToAppConfigAsync).not.toHaveBeenCalled();
       });
+
+      it('checks owner and slug consistency', async () => {
+        jest.mocked(AppQuery.byIdAsync).mockResolvedValue({
+          id: '1234',
+          slug: 'testing-124',
+          fullName: '@jester2/testing-124',
+          ownerAccount: jester2.accounts[0],
+        });
+
+        jest.mocked(confirmAsync).mockResolvedValue(true);
+        jest.mocked(modifyConfigAsync).mockResolvedValue({ type: 'success', config: {} as any });
+
+        await new ProjectInit([], commandOptions).run();
+
+        expect(confirmAsync).toHaveBeenCalled();
+        expect(modifyConfigAsync).toHaveBeenCalledTimes(2);
+        expect(modifyConfigAsync).toHaveBeenCalledWith('/test-project', { owner: 'jester2' });
+        expect(modifyConfigAsync).toHaveBeenCalledWith('/test-project', { slug: 'testing-124' });
+      });
     });
 
     describe('when it is not yet configured', () => {
@@ -365,6 +391,14 @@ describe(ProjectInit.name, () => {
 
           it('prompts for confirmation to link', async () => {
             jest.mocked(confirmAsync).mockResolvedValue(true);
+
+            jest.mocked(AppQuery.byIdAsync).mockResolvedValue({
+              id: '1234',
+              slug: 'testing-123',
+              fullName: '@jester/testing-123',
+              ownerAccount: jester.accounts[0],
+            });
+
             await new ProjectInit([], commandOptions).run();
             expect(saveProjectIdToAppConfigAsync).toHaveBeenCalledWith('/test-project', '123456');
             expect(confirmAsync).toHaveBeenCalledTimes(1);
@@ -384,6 +418,14 @@ describe(ProjectInit.name, () => {
           it('asks to create it', async () => {
             jest.mocked(confirmAsync).mockResolvedValue(true);
             jest.mocked(AppMutation.createAppAsync).mockResolvedValue('0129');
+
+            jest.mocked(AppQuery.byIdAsync).mockResolvedValue({
+              id: '0129',
+              slug: 'testing-123',
+              fullName: '@jester/testing-123',
+              ownerAccount: jester.accounts[0],
+            });
+
             await new ProjectInit([], commandOptions).run();
             expect(saveProjectIdToAppConfigAsync).toHaveBeenCalledWith('/test-project', '0129');
             expect(confirmAsync).toHaveBeenCalledTimes(1);

packages/eas-cli/src/commands/project/init.ts

@@ -194,7 +194,6 @@ export default class ProjectInit extends EasCommand {
   }
 
   private static async initializeWithExplicitIDAsync(
-    graphqlClient: ExpoGraphqlClient,
     projectId: string,
     projectDir: string,
     { force, nonInteractive }: InitializeMethodOptions
@@ -203,17 +202,13 @@ export default class ProjectInit extends EasCommand {
       force,
       nonInteractive,
     });
-    await this.ensureOwnerSlugConsistencyAsync(graphqlClient, projectId, projectDir, {
-      force,
-      nonInteractive,
-    });
   }
 
   private static async initializeWithInteractiveSelectionAsync(
     graphqlClient: ExpoGraphqlClient,
     actor: Actor,
     projectDir: string
-  ): Promise<void> {
+  ): Promise<string> {
     const exp = getExpoConfig(projectDir);
     const existingProjectId = exp.extra?.eas?.projectId;
 
@@ -223,7 +218,7 @@ export default class ProjectInit extends EasCommand {
           existingProjectId
         )}). To re-configure, remove the "extra.eas.projectId" field from your app config.`
       );
-      return;
+      return existingProjectId;
     }
 
     const allAccounts = actor.accounts;
@@ -287,7 +282,7 @@ export default class ProjectInit extends EasCommand {
       }
 
       await ProjectInit.saveProjectIdAndLogSuccessAsync(projectDir, existingProjectIdOnServer);
-      return;
+      return existingProjectIdOnServer;
     }
 
     if (!accountNamesWhereUserHasSufficientPermissionsToCreateApp.has(accountName)) {
@@ -323,24 +318,36 @@ export default class ProjectInit extends EasCommand {
     }
 
     await ProjectInit.saveProjectIdAndLogSuccessAsync(projectDir, createdProjectId);
+    return createdProjectId;
   }
 
   async runAsync(): Promise<void> {
     const {
-      flags: { id, force, 'non-interactive': nonInteractive },
+      flags: { id: idArgument, force, 'non-interactive': nonInteractive },
     } = await this.parse(ProjectInit);
     const {
       loggedIn: { actor, graphqlClient },
       projectDir,
     } = await this.getContextAsync(ProjectInit, { nonInteractive });
 
-    if (id) {
-      await ProjectInit.initializeWithExplicitIDAsync(graphqlClient, id, projectDir, {
+    let idForConsistency: string;
+    if (idArgument) {
+      await ProjectInit.initializeWithExplicitIDAsync(idArgument, projectDir, {
         force,
         nonInteractive,
       });
+      idForConsistency = idArgument;
     } else {
-      await ProjectInit.initializeWithInteractiveSelectionAsync(graphqlClient, actor, projectDir);
+      idForConsistency = await ProjectInit.initializeWithInteractiveSelectionAsync(
+        graphqlClient,
+        actor,
+        projectDir
+      );
     }
+
+    await ProjectInit.ensureOwnerSlugConsistencyAsync(graphqlClient, idForConsistency, projectDir, {
+      force,
+      nonInteractive,
+    });
   }
 }

packages/eas-cli/src/commands/submit.ts

@@ -115,7 +115,7 @@ export default class Submit extends EasCommand {
     const platforms = toPlatforms(flagsWithPlatform.requestedPlatform);
     const submissionProfiles = await getProfilesAsync({
       type: 'submit',
-      easJsonAccessor: new EasJsonAccessor(projectDir),
+      easJsonAccessor: EasJsonAccessor.fromProjectPath(projectDir),
       platforms,
       profileName: flagsWithPlatform.profile,
     });

packages/eas-cli/src/commands/update/__tests__/index.test.ts

@@ -1,6 +1,14 @@
-import { AppJSONConfig, PackageJSONConfig, Platform, getConfig } from '@expo/config';
+import {
+  AppJSONConfig,
+  ExpoConfig,
+  GetConfigOptions,
+  PackageJSONConfig,
+  Platform,
+  getConfig,
+} from '@expo/config';
 import { Updates } from '@expo/config-plugins';
 import { vol } from 'memfs';
+import nullthrows from 'nullthrows';
 import path from 'path';
 import { instance, mock } from 'ts-mockito';
 
@@ -29,6 +37,7 @@ const updateStub: UpdateFragment = {
   platform: 'ios',
   gitCommitHash: 'commit',
   manifestFragment: JSON.stringify({ fake: 'manifest' }),
+  isRollBackToEmbedded: false,
   manifestPermalink: 'https://expo.dev/fake/manifest/link',
   codeSigningInfo: null,
   createdAt: '2022-01-01T12:00:00Z',
@@ -46,7 +55,7 @@ jest.mock('../../../graphql/queries/AppQuery');
 jest.mock('../../../graphql/queries/UpdateQuery');
 jest.mock('../../../ora', () => ({
   ora: () => ({
-    start: () => ({ succeed: () => {}, fail: () => {} }),
+    start: () => ({ succeed: () => {}, fail: () => {}, stop: () => {} }),
   }),
 }));
 jest.mock('../../../project/publish', () => ({
@@ -58,7 +67,10 @@ jest.mock('../../../project/publish', () => ({
 }));
 
 describe(UpdatePublish.name, () => {
-  afterEach(() => vol.reset());
+  afterEach(() => {
+    vol.reset();
+    jest.mocked(PublishMutation.publishUpdateGroupAsync).mockClear();
+  });
 
   // Deprecated and split to a new command: update:republish
   it('errors with --republish', async () => {
@@ -80,7 +92,7 @@ describe(UpdatePublish.name, () => {
     mockTestProject();
 
     await expect(new UpdatePublish(flags, commandOptions).run()).rejects.toThrow(
-      'Cannot specify both --channel and --branch. Specify either --channel, --branch, or --auto'
+      'Cannot specify both --channel and --branch. Specify either --channel, --branch, or --auto.'
     );
   });
 
@@ -136,14 +148,59 @@ describe(UpdatePublish.name, () => {
 
     expect(PublishMutation.publishUpdateGroupAsync).toHaveBeenCalled();
   });
+
+  it('creates a new update with the public expo config', async () => {
+    const flags = ['--non-interactive', '--branch=branch123', '--message=abc'];
+
+    // Add configuration to the project that should not be included in the update
+    const { appJson } = mockTestProject({
+      expoConfig: {
+        hooks: {
+          postPublish: [
+            {
+              file: 'custom-hook.js',
+              config: { some: 'config' },
+            },
+          ],
+        },
+      },
+    });
+
+    const { platforms, runtimeVersion } = mockTestExport({ platforms: ['ios'] });
+
+    // Mock an existing branch, so we don't create a new one
+    jest.mocked(ensureBranchExistsAsync).mockResolvedValue({
+      branchId: 'branch123',
+      createdBranch: false,
+    });
+
+    jest
+      .mocked(PublishMutation.publishUpdateGroupAsync)
+      .mockResolvedValue(platforms.map(platform => ({ ...updateStub, platform, runtimeVersion })));
+
+    await new UpdatePublish(flags, commandOptions).run();
+
+    // Pull the publish data from the mocked publish function
+    const publishData = jest.mocked(PublishMutation.publishUpdateGroupAsync).mock.calls[0][1][0];
+    // Pull the Expo config from the publish data
+    const expoConfig = nullthrows(publishData.updateInfoGroup).ios!.extra.expoClient;
+
+    // Ensure the basic properties are present
+    expect(expoConfig).toHaveProperty('name', appJson.expo.name);
+    expect(expoConfig).toHaveProperty('slug', appJson.expo.slug);
+    // Ensure non-public config is not present
+    expect(expoConfig).not.toHaveProperty('hooks');
+  });
 });
 
 /** Create a new in-memory project, copied from src/commands/update/__tests__/republish.test.ts */
 function mockTestProject({
   configuredProjectId = '1234',
+  expoConfig = {},
 }: {
   configuredProjectId?: string;
-} = {}): { projectId: string } {
+  expoConfig?: Partial<ExpoConfig>;
+} = {}): { projectId: string; appJson: AppJSONConfig } {
   const packageJSON: PackageJSONConfig = {
     name: 'testing123',
     version: '0.1.0',
@@ -163,6 +220,7 @@ function mockTestProject({
           projectId: configuredProjectId,
         },
       },
+      ...expoConfig,
     },
   };
 
@@ -180,11 +238,27 @@ function mockTestProject({
   jest.mocked(getConfig).mockReturnValue(mockManifest as any);
   jest
     .spyOn(DynamicProjectConfigContextField.prototype, 'getValueAsync')
-    .mockResolvedValue(async () => ({
-      exp: mockManifest.exp,
-      projectDir: projectRoot,
-      projectId: configuredProjectId,
-    }));
+    .mockResolvedValue(async (options?: GetConfigOptions) => {
+      let exp = { ...mockManifest.exp };
+
+      // Fake a limited public config
+      if (options?.isPublicConfig) {
+        exp = {
+          name: mockManifest.exp.name,
+          version: mockManifest.exp.version,
+          slug: mockManifest.exp.slug,
+          sdkVersion: mockManifest.exp.sdkVersion,
+          owner: mockManifest.exp.owner,
+          extra: mockManifest.exp.extra,
+        };
+      }
+
+      return {
+        exp,
+        projectDir: projectRoot,
+        projectId: configuredProjectId,
+      };
+    });
 
   jest.spyOn(LoggedInContextField.prototype, 'getValueAsync').mockResolvedValue({
     actor: jester,
@@ -199,7 +273,7 @@ function mockTestProject({
     ownerAccount: jester.accounts[0],
   });
 
-  return { projectId: configuredProjectId };
+  return { projectId: configuredProjectId, appJson: appJSON };
 }
 
 /** Create a new in-memory export of the project */
@@ -246,6 +320,8 @@ function mockTestExport({
     uniqueAssetCount: platforms.length,
     uniqueUploadedAssetCount: platforms.length,
     assetLimitPerUpdateGroup: 9001,
+    launchAssetCount: 2,
+    uniqueUploadedAssetPaths: [],
   });
 
   jest.mocked(Updates.getRuntimeVersion).mockReturnValue(runtimeVersion);

packages/eas-cli/src/commands/update/__tests__/republish.test.ts

@@ -27,6 +27,7 @@ const updateStub: UpdateFragment = {
   platform: 'ios',
   gitCommitHash: 'commit',
   manifestFragment: JSON.stringify({ fake: 'manifest' }),
+  isRollBackToEmbedded: false,
   manifestPermalink: 'https://expo.dev/fake/manifest/link',
   codeSigningInfo: null,
   createdAt: '2022-01-01T12:00:00Z',

packages/eas-cli/src/commands/update/__tests__/roll-back-to-embedded.test.ts

@@ -0,0 +1,257 @@
+import {
+  AppJSONConfig,
+  ExpoConfig,
+  GetConfigOptions,
+  PackageJSONConfig,
+  getConfig,
+} from '@expo/config';
+import { Updates } from '@expo/config-plugins';
+import { vol } from 'memfs';
+import nullthrows from 'nullthrows';
+import path from 'path';
+import { instance, mock } from 'ts-mockito';
+
+import { ensureBranchExistsAsync } from '../../../branch/queries';
+import { DynamicProjectConfigContextField } from '../../../commandUtils/context/DynamicProjectConfigContextField';
+import LoggedInContextField from '../../../commandUtils/context/LoggedInContextField';
+import { ExpoGraphqlClient } from '../../../commandUtils/context/contextUtils/createGraphqlClient';
+import FeatureGateEnvOverrides from '../../../commandUtils/gating/FeatureGateEnvOverrides';
+import FeatureGating from '../../../commandUtils/gating/FeatureGating';
+import { jester } from '../../../credentials/__tests__/fixtures-constants';
+import { UpdateFragment } from '../../../graphql/generated';
+import { PublishMutation } from '../../../graphql/mutations/PublishMutation';
+import { AppQuery } from '../../../graphql/queries/AppQuery';
+import { getBranchNameFromChannelNameAsync } from '../../../update/getBranchNameFromChannelNameAsync';
+import UpdateRollBackToEmbedded from '../roll-back-to-embedded';
+
+const projectRoot = '/test-project';
+const commandOptions = { root: projectRoot } as any;
+const updateStub: UpdateFragment = {
+  id: 'update-1234',
+  group: 'group-1234',
+  branch: { id: 'branch-1234', name: 'main' },
+  message: 'test message',
+  runtimeVersion: 'exposdk:47.0.0',
+  platform: 'ios',
+  gitCommitHash: 'commit',
+  manifestFragment: JSON.stringify({ fake: 'manifest' }),
+  isRollBackToEmbedded: false,
+  manifestPermalink: 'https://expo.dev/fake/manifest/link',
+  codeSigningInfo: null,
+  createdAt: '2022-01-01T12:00:00Z',
+};
+
+jest.mock('fs');
+jest.mock('@expo/config');
+jest.mock('@expo/config-plugins');
+jest.mock('../../../branch/queries');
+jest.mock('../../../commandUtils/context/contextUtils/getProjectIdAsync');
+jest.mock('../../../update/configure');
+jest.mock('../../../update/getBranchNameFromChannelNameAsync');
+jest.mock('../../../graphql/mutations/PublishMutation');
+jest.mock('../../../graphql/queries/AppQuery');
+jest.mock('../../../graphql/queries/UpdateQuery');
+jest.mock('../../../ora', () => ({
+  ora: () => ({
+    start: () => ({ succeed: () => {}, fail: () => {}, stop: () => {} }),
+  }),
+}));
+jest.mock('../../../project/publish', () => ({
+  ...jest.requireActual('../../../project/publish'),
+  buildBundlesAsync: jest.fn(),
+  collectAssetsAsync: jest.fn(),
+  resolveInputDirectoryAsync: jest.fn((inputDir = 'dist') => path.join(projectRoot, inputDir)),
+  uploadAssetsAsync: jest.fn(),
+}));
+
+describe(UpdateRollBackToEmbedded.name, () => {
+  afterEach(() => vol.reset());
+
+  it('errors with both --channel and --branch', async () => {
+    const flags = ['--channel=channel123', '--branch=branch123'];
+
+    mockTestProject();
+
+    await expect(new UpdateRollBackToEmbedded(flags, commandOptions).run()).rejects.toThrow(
+      'Cannot specify both --channel and --branch. Specify either --channel, --branch, or --auto.'
+    );
+  });
+
+  it('creates a roll back to embedded with --non-interactive, --branch, and --message', async () => {
+    const flags = ['--non-interactive', '--branch=branch123', '--message=abc'];
+
+    mockTestProject();
+    const platforms = ['android', 'ios'];
+    const runtimeVersion = 'exposdk:47.0.0';
+    jest.mocked(Updates.getRuntimeVersion).mockReturnValue(runtimeVersion);
+
+    jest.mocked(ensureBranchExistsAsync).mockResolvedValue({
+      branchId: 'branch123',
+      createdBranch: false,
+    });
+
+    jest
+      .mocked(PublishMutation.publishUpdateGroupAsync)
+      .mockResolvedValue(platforms.map(platform => ({ ...updateStub, platform, runtimeVersion })));
+
+    await new UpdateRollBackToEmbedded(flags, commandOptions).run();
+
+    expect(PublishMutation.publishUpdateGroupAsync).toHaveBeenCalled();
+  });
+
+  it('creates a roll back to embedded with --non-interactive, --channel, and --message', async () => {
+    const flags = ['--non-interactive', '--channel=channel123', '--message=abc'];
+
+    const { projectId } = mockTestProject();
+    const platforms = ['android', 'ios'];
+    const runtimeVersion = 'exposdk:47.0.0';
+    jest.mocked(Updates.getRuntimeVersion).mockReturnValue(runtimeVersion);
+
+    jest.mocked(getBranchNameFromChannelNameAsync).mockResolvedValue('branchFromChannel');
+    jest.mocked(ensureBranchExistsAsync).mockResolvedValue({
+      branchId: 'branch123',
+      createdBranch: false,
+    });
+
+    jest.mocked(PublishMutation.publishUpdateGroupAsync).mockResolvedValue(
+      platforms.map(platform => ({
+        ...updateStub,
+        runtimeVersion,
+        platform,
+      }))
+    );
+
+    await new UpdateRollBackToEmbedded(flags, commandOptions).run();
+
+    expect(ensureBranchExistsAsync).toHaveBeenCalledWith(
+      expect.any(Object), // graphql client
+      {
+        appId: projectId,
+        branchName: 'branchFromChannel',
+      }
+    );
+
+    expect(PublishMutation.publishUpdateGroupAsync).toHaveBeenCalled();
+  });
+
+  it('creates a roll back to embedded with the public expo config', async () => {
+    const flags = ['--non-interactive', '--branch=branch123', '--message=abc'];
+
+    // Add configuration to the project that should not be included in the update
+    mockTestProject({
+      expoConfig: {
+        hooks: {
+          postPublish: [
+            {
+              file: 'custom-hook.js',
+              config: { some: 'config' },
+            },
+          ],
+        },
+      },
+    });
+
+    const platforms = ['ios'];
+    const runtimeVersion = 'exposdk:47.0.0';
+    jest.mocked(Updates.getRuntimeVersion).mockReturnValue(runtimeVersion);
+
+    // Mock an existing branch, so we don't create a new one
+    jest.mocked(ensureBranchExistsAsync).mockResolvedValue({
+      branchId: 'branch123',
+      createdBranch: false,
+    });
+
+    jest
+      .mocked(PublishMutation.publishUpdateGroupAsync)
+      .mockResolvedValue(platforms.map(platform => ({ ...updateStub, platform, runtimeVersion })));
+
+    await new UpdateRollBackToEmbedded(flags, commandOptions).run();
+
+    // Pull the publish data from the mocked publish function
+    const publishData = jest.mocked(PublishMutation.publishUpdateGroupAsync).mock.calls[0][1][0];
+    expect(nullthrows(publishData.rollBackToEmbeddedInfoGroup).ios).toBe(true);
+  });
+});
+
+/** Create a new in-memory project, based on src/commands/project/__tests__/init.test.ts */
+function mockTestProject({
+  configuredProjectId = '1234',
+  expoConfig = {},
+}: {
+  configuredProjectId?: string;
+  expoConfig?: Partial<ExpoConfig>;
+} = {}): { projectId: string; appJson: AppJSONConfig } {
+  const packageJSON: PackageJSONConfig = {
+    name: 'testing123',
+    version: '0.1.0',
+    description: 'fake description',
+    main: 'index.js',
+  };
+
+  const appJSON: AppJSONConfig = {
+    expo: {
+      name: 'testing 123',
+      version: '0.1.0',
+      slug: 'testing-123',
+      sdkVersion: '33.0.0',
+      owner: jester.accounts[0].name,
+      extra: {
+        eas: {
+          projectId: configuredProjectId,
+        },
+      },
+      ...expoConfig,
+    },
+  };
+
+  vol.fromJSON(
+    {
+      'package.json': JSON.stringify(packageJSON),
+      'app.json': JSON.stringify(appJSON),
+    },
+    projectRoot
+  );
+
+  const mockManifest = { exp: appJSON.expo };
+  const graphqlClient = instance(mock<ExpoGraphqlClient>({}));
+
+  jest.mocked(getConfig).mockReturnValue(mockManifest as any);
+  jest
+    .spyOn(DynamicProjectConfigContextField.prototype, 'getValueAsync')
+    .mockResolvedValue(async (options?: GetConfigOptions) => {
+      let exp = { ...mockManifest.exp };
+
+      // Fake a limited public config
+      if (options?.isPublicConfig) {
+        exp = {
+          name: mockManifest.exp.name,
+          version: mockManifest.exp.version,
+          slug: mockManifest.exp.slug,
+          sdkVersion: mockManifest.exp.sdkVersion,
+          owner: mockManifest.exp.owner,
+          extra: mockManifest.exp.extra,
+        };
+      }
+
+      return {
+        exp,
+        projectDir: projectRoot,
+        projectId: configuredProjectId,
+      };
+    });
+
+  jest.spyOn(LoggedInContextField.prototype, 'getValueAsync').mockResolvedValue({
+    actor: jester,
+    featureGating: new FeatureGating({}, new FeatureGateEnvOverrides()),
+    graphqlClient,
+  });
+
+  jest.mocked(AppQuery.byIdAsync).mockResolvedValue({
+    id: '1234',
+    slug: 'testing-123',
+    fullName: '@jester/testing-123',
+    ownerAccount: jester.accounts[0],
+  });
+
+  return { projectId: configuredProjectId, appJson: appJSON };
+}

packages/eas-cli/src/commands/update/index.ts

@@ -1,13 +1,9 @@
-import { ExpoConfig, Platform as PublishPlatform } from '@expo/config';
-import { Updates } from '@expo/config-plugins';
-import { Platform, Workflow } from '@expo/eas-build-job';
+import { Platform as PublishPlatform } from '@expo/config';
 import { Errors, Flags } from '@oclif/core';
-import assert from 'assert';
 import chalk from 'chalk';
 import nullthrows from 'nullthrows';
 
-import { ensureBranchExistsAsync, selectBranchOnAppAsync } from '../../branch/queries';
-import { getDefaultBranchNameAsync } from '../../branch/utils';
+import { ensureBranchExistsAsync } from '../../branch/queries';
 import { getUpdateGroupUrl } from '../../build/utils/url';
 import { ensureChannelExistsAsync } from '../../channel/queries';
 import EasCommand from '../../commandUtils/EasCommand';
@@ -23,32 +19,31 @@ import {
 import { PublishMutation } from '../../graphql/mutations/PublishMutation';
 import Log, { learnMore, link } from '../../log';
 import { ora } from '../../ora';
-import { RequestedPlatform, requestedPlatformDisplayNames } from '../../platform';
+import { RequestedPlatform } from '../../platform';
 import { getOwnerAccountForProjectIdAsync } from '../../project/projectUtils';
 import {
   ExpoCLIExportPlatformFlag,
   buildBundlesAsync,
   buildUnsortedUpdateInfoGroupAsync,
   collectAssetsAsync,
+  defaultPublishPlatforms,
   filterExportedPlatformsByFlag,
+  getBranchNameForCommandAsync,
+  getRequestedPlatform,
+  getRuntimeToPlatformMappingFromRuntimeVersions,
+  getRuntimeVersionObjectAsync,
+  getUpdateMessageForCommandAsync,
   isUploadedAssetCountAboveWarningThreshold,
   resolveInputDirectoryAsync,
   uploadAssetsAsync,
 } from '../../project/publish';
-import { resolveWorkflowAsync } from '../../project/workflow';
-import { promptAsync } from '../../prompts';
 import { ensureEASUpdateIsConfiguredAsync } from '../../update/configure';
-import { getBranchNameFromChannelNameAsync } from '../../update/getBranchNameFromChannelNameAsync';
-import {
-  formatUpdateMessage,
-  getUpdateGroupJsonInfo,
-  truncateString as truncateUpdateMessage,
-} from '../../update/utils';
+import { getUpdateGroupJsonInfo } from '../../update/utils';
 import {
   checkManifestBodyAgainstUpdateInfoGroup,
   getCodeSigningInfoAsync,
   getManifestBodyAsync,
-  signManifestBody,
+  signBody,
 } from '../../utils/code-signing';
 import uniqBy from '../../utils/expodash/uniqBy';
 import formatFields from '../../utils/formatFields';
@@ -56,8 +51,6 @@ import { enableJsonOutput, printJsonOnlyOutput } from '../../utils/json';
 import { maybeWarnAboutEasOutagesAsync } from '../../utils/statuspageService';
 import { getVcsClient } from '../../vcs';
 
-export const defaultPublishPlatforms: Partial<PublishPlatform>[] = ['android', 'ios'];
-
 type RawUpdateFlags = {
   auto: boolean;
   branch?: string;
@@ -66,6 +59,7 @@ type RawUpdateFlags = {
   platform: string;
   'input-dir': string;
   'skip-bundler': boolean;
+  'clear-cache': boolean;
   'private-key-path'?: string;
   'non-interactive': boolean;
   json: boolean;
@@ -83,26 +77,12 @@ type UpdateFlags = {
   updateMessage?: string;
   inputDir: string;
   skipBundler: boolean;
+  clearCache: boolean;
   privateKeyPath?: string;
   json: boolean;
   nonInteractive: boolean;
 };
 
-function getRequestedPlatform(platform: ExpoCLIExportPlatformFlag): RequestedPlatform | null {
-  switch (platform) {
-    case 'android':
-      return RequestedPlatform.Android;
-    case 'ios':
-      return RequestedPlatform.Ios;
-    case 'web':
-      return null;
-    case 'all':
-      return RequestedPlatform.All;
-    default:
-      throw new Error(`Unsupported platform: ${platform}`);
-  }
-}
-
 export default class UpdatePublish extends EasCommand {
   static override description = 'publish an update group';
 
@@ -136,6 +116,10 @@ export default class UpdatePublish extends EasCommand {
       description: `Skip running Expo CLI to bundle the app before publishing`,
       default: false,
     }),
+    'clear-cache': Flags.boolean({
+      description: `Clear the bundler cache before publishing`,
+      default: false,
+    }),
     platform: Flags.enum({
       char: 'p',
       options: [
@@ -166,18 +150,19 @@ export default class UpdatePublish extends EasCommand {
   async runAsync(): Promise<void> {
     const { flags: rawFlags } = await this.parse(UpdatePublish);
     const paginatedQueryOptions = getPaginatedQueryOptions(rawFlags);
-    let {
+    const {
       auto: autoFlag,
       platform: platformFlag,
-      channelName,
-      updateMessage,
+      channelName: channelNameArg,
+      updateMessage: updateMessageArg,
       inputDir,
       skipBundler,
+      clearCache,
       privateKeyPath,
       json: jsonFlag,
       nonInteractive,
+      branchName: branchNameArg,
     } = this.sanitizeFlags(rawFlags);
-    let branchName = this.sanitizeFlags(rawFlags).branchName;
 
     const {
       getDynamicProjectConfigAsync,
@@ -198,10 +183,6 @@ export default class UpdatePublish extends EasCommand {
       isPublicConfig: true,
     });
 
-    const { exp: expPrivate } = await getDynamicProjectConfigAsync({
-      isPublicConfig: false,
-    });
-
     await maybeWarnAboutEasOutagesAsync(graphqlClient, [StatuspageServiceName.EasUpdate]);
 
     await ensureEASUpdateIsConfiguredAsync(graphqlClient, {
@@ -211,81 +192,34 @@ export default class UpdatePublish extends EasCommand {
       projectId,
     });
 
-    const { exp } = await getDynamicProjectConfigAsync({});
+    const { exp } = await getDynamicProjectConfigAsync({ isPublicConfig: true });
+    const { exp: expPrivate } = await getDynamicProjectConfigAsync({
+      isPublicConfig: false,
+    });
     const codeSigningInfo = await getCodeSigningInfoAsync(expPrivate, privateKeyPath);
 
-    let realizedPlatforms: PublishPlatform[] = [];
+    const branchName = await getBranchNameForCommandAsync({
+      graphqlClient,
+      projectId,
+      channelNameArg,
+      branchNameArg,
+      autoFlag,
+      nonInteractive,
+      paginatedQueryOptions,
+    });
 
-    if (channelName && branchName) {
-      throw new Error(
-        'Cannot specify both --channel and --branch. Specify either --channel, --branch, or --auto'
-      );
-    }
-
-    if (channelName) {
-      branchName = await getBranchNameFromChannelNameAsync(graphqlClient, projectId, channelName);
-    }
-
-    if (!branchName) {
-      if (autoFlag) {
-        branchName = await getDefaultBranchNameAsync();
-      } else if (nonInteractive) {
-        throw new Error('Must supply --channel, --branch or --auto when in non-interactive mode');
-      } else {
-        try {
-          const branch = await selectBranchOnAppAsync(graphqlClient, {
-            projectId,
-            promptTitle: `Which branch would you like to publish on?`,
-            displayTextForListItem: updateBranch => ({
-              title: `${updateBranch.name} ${chalk.grey(
-                `- current update: ${formatUpdateMessage(updateBranch.updates[0])}`
-              )}`,
-            }),
-            paginatedQueryOptions,
-          });
-          branchName = branch.name;
-        } catch {
-          // unable to select a branch (network error or no branches for project)
-          ({ name: branchName } = await promptAsync({
-            type: 'text',
-            name: 'name',
-            message: 'No branches found. Provide a branch name:',
-            initial: await getDefaultBranchNameAsync(),
-            validate: value => (value ? true : 'Branch name may not be empty.'),
-          }));
-        }
-
-        assert(branchName, 'Branch name must be specified.');
-      }
-    }
-
-    if (!updateMessage && autoFlag) {
-      updateMessage = (await getVcsClient().getLastCommitMessageAsync())?.trim();
-    }
-
-    if (!updateMessage) {
-      if (nonInteractive) {
-        throw new Error('Must supply --message or use --auto when in non-interactive mode');
-      }
-
-      const validationMessage = 'publish message may not be empty.';
-      if (jsonFlag) {
-        throw new Error(validationMessage);
-      }
-      ({ updateMessage } = await promptAsync({
-        type: 'text',
-        name: 'updateMessage',
-        message: `Provide an update message.`,
-        initial: (await getVcsClient().getLastCommitMessageAsync())?.trim(),
-        validate: (value: any) => (value ? true : validationMessage),
-      }));
-    }
+    const updateMessage = await getUpdateMessageForCommandAsync({
+      updateMessageArg,
+      autoFlag,
+      nonInteractive,
+      jsonFlag,
+    });
 
     // build bundle and upload assets for a new publish
     if (!skipBundler) {
       const bundleSpinner = ora().start('Exporting...');
       try {
-        await buildBundlesAsync({ projectDir, inputDir, exp, platformFlag });
+        await buildBundlesAsync({ projectDir, inputDir, exp, platformFlag, clearCache });
         bundleSpinner.succeed('Exported bundle(s)');
       } catch (e) {
         bundleSpinner.fail('Export failed');
@@ -300,6 +234,7 @@ export default class UpdatePublish extends EasCommand {
     let unsortedUpdateInfoGroups: UpdateInfoGroup = {};
     let uploadedAssetCount = 0;
     let assetLimitPerUpdateGroup = 0;
+    let realizedPlatforms: PublishPlatform[] = [];
 
     try {
       const collectedAssets = await collectAssetsAsync(distRoot);
@@ -318,31 +253,42 @@ export default class UpdatePublish extends EasCommand {
       uploadedAssetCount = uploadResults.uniqueUploadedAssetCount;
       assetLimitPerUpdateGroup = uploadResults.assetLimitPerUpdateGroup;
       unsortedUpdateInfoGroups = await buildUnsortedUpdateInfoGroupAsync(assets, exp);
-      const uploadAssetSuccessMessage = uploadedAssetCount
-        ? `Uploaded ${uploadedAssetCount} ${uploadedAssetCount === 1 ? 'platform' : 'platforms'}`
-        : `Uploaded: No changes detected`;
-      assetSpinner.succeed(uploadAssetSuccessMessage);
+
+      // NOTE(cedric): we assume that bundles are always uploaded, and always are part of
+      // `uploadedAssetCount`, perferably we don't assume. For that, we need to refactor the
+      // `uploadAssetsAsync` and be able to determine asset type from the uploaded assets.
+      const uploadedBundleCount = uploadResults.launchAssetCount;
+      const uploadedNormalAssetCount = Math.max(0, uploadedAssetCount - uploadedBundleCount);
+      const reusedNormalAssetCount = uploadResults.uniqueAssetCount - uploadedNormalAssetCount;
+
+      assetSpinner.stop();
+      Log.withTick(
+        `Uploaded ${uploadedBundleCount} app ${uploadedBundleCount === 1 ? 'bundle' : 'bundles'}`
+      );
+      if (uploadedNormalAssetCount === 0) {
+        Log.withTick(`Uploading assets skipped - no new assets found`);
+      } else {
+        let message = `Uploaded ${uploadedNormalAssetCount} ${
+          uploadedNormalAssetCount === 1 ? 'asset' : 'assets'
+        }`;
+        if (reusedNormalAssetCount > 0) {
+          message += ` (reused ${reusedNormalAssetCount} ${
+            reusedNormalAssetCount === 1 ? 'asset' : 'assets'
+          })`;
+        }
+        Log.withTick(message);
+      }
+      for (const uploadedAssetPath of uploadResults.uniqueUploadedAssetPaths) {
+        Log.debug(chalk.dim(`- ${uploadedAssetPath}`));
+      }
     } catch (e) {
       assetSpinner.fail('Failed to upload');
       throw e;
     }
 
-    const truncatedMessage = truncateUpdateMessage(updateMessage!, 1024);
-    if (truncatedMessage !== updateMessage) {
-      Log.warn('Update message exceeds the allowed 1024 character limit. Truncating message...');
-    }
-
     const runtimeVersions = await getRuntimeVersionObjectAsync(exp, realizedPlatforms, projectDir);
-
-    const runtimeToPlatformMapping: { runtimeVersion: string; platforms: string[] }[] = [];
-    for (const runtime of runtimeVersions) {
-      const platforms = runtimeVersions
-        .filter(({ runtimeVersion }) => runtimeVersion === runtime.runtimeVersion)
-        .map(({ platform }) => platform);
-      if (!runtimeToPlatformMapping.find(item => item.runtimeVersion === runtime.runtimeVersion)) {
-        runtimeToPlatformMapping.push({ runtimeVersion: runtime.runtimeVersion, platforms });
-      }
-    }
+    const runtimeToPlatformMapping =
+      getRuntimeToPlatformMappingFromRuntimeVersions(runtimeVersions);
 
     const { branchId, createdBranch } = await ensureBranchExistsAsync(graphqlClient, {
       appId: projectId,
@@ -377,7 +323,7 @@ export default class UpdatePublish extends EasCommand {
           branchId,
           updateInfoGroup: localUpdateInfoGroup,
           runtimeVersion,
-          message: truncatedMessage,
+          message: updateMessage,
           gitCommitHash,
           isGitWorkingTreeDirty,
           awaitingCodeSigningInfo: !!codeSigningInfo,
@@ -394,7 +340,10 @@ export default class UpdatePublish extends EasCommand {
 
         const updatesTemp = [...newUpdates];
         const updateGroupsAndTheirUpdates = updateGroups.map(updateGroup => {
-          const newUpdates = updatesTemp.splice(0, Object.keys(updateGroup.updateInfoGroup).length);
+          const newUpdates = updatesTemp.splice(
+            0,
+            Object.keys(nullthrows(updateGroup.updateInfoGroup)).length
+          );
           return {
             updateGroup,
             newUpdates,
@@ -414,11 +363,13 @@ export default class UpdatePublish extends EasCommand {
                 checkManifestBodyAgainstUpdateInfoGroup(
                   manifestBody,
                   nullthrows(
-                    updateGroup.updateInfoGroup[newUpdate.platform as keyof UpdateInfoGroup]
+                    nullthrows(updateGroup.updateInfoGroup)[
+                      newUpdate.platform as keyof UpdateInfoGroup
+                    ]
                   )
                 );
 
-                const manifestSignature = signManifestBody(manifestBody, codeSigningInfo);
+                const manifestSignature = signBody(manifestBody, codeSigningInfo);
 
                 await PublishMutation.setCodeSigningInfoAsync(graphqlClient, newUpdate.id, {
                   alg: codeSigningInfo.codeSigningMetadata.alg,
@@ -480,7 +431,7 @@ export default class UpdatePublish extends EasCommand {
               ? [{ label: 'Android update ID', value: newAndroidUpdate.id }]
               : []),
             ...(newIosUpdate ? [{ label: 'iOS update ID', value: newIosUpdate.id }] : []),
-            { label: 'Message', value: truncatedMessage },
+            { label: 'Message', value: updateMessage },
             ...(gitCommitHash
               ? [
                   {
@@ -544,6 +495,7 @@ export default class UpdatePublish extends EasCommand {
       updateMessage,
       inputDir: flags['input-dir'],
       skipBundler: flags['skip-bundler'],
+      clearCache: flags['clear-cache'],
       platform: flags.platform as RequestedPlatform,
       privateKeyPath: flags['private-key-path'],
       nonInteractive,
@@ -551,41 +503,3 @@ export default class UpdatePublish extends EasCommand {
     };
   }
 }
-
-/** Get runtime versions grouped by platform. Runtime version is always `null` on web where the platform is always backwards compatible. */
-async function getRuntimeVersionObjectAsync(
-  exp: ExpoConfig,
-  platforms: PublishPlatform[],
-  projectDir: string
-): Promise<{ platform: string; runtimeVersion: string }[]> {
-  for (const platform of platforms) {
-    if (platform === 'web') {
-      continue;
-    }
-    const isPolicy = typeof (exp[platform]?.runtimeVersion ?? exp.runtimeVersion) === 'object';
-    if (isPolicy) {
-      const isManaged =
-        (await resolveWorkflowAsync(projectDir, platform as Platform)) === Workflow.MANAGED;
-      if (!isManaged) {
-        throw new Error(
-          'Runtime version policies are only supported in the managed workflow. In the bare workflow, runtime version needs to be set manually.'
-        );
-      }
-    }
-  }
-
-  return [...new Set(platforms)].map(platform => {
-    if (platform === 'web') {
-      return { platform: 'web', runtimeVersion: 'UNVERSIONED' };
-    }
-    return {
-      platform,
-      runtimeVersion: nullthrows(
-        Updates.getRuntimeVersion(exp, platform),
-        `Unable to determine runtime version for ${
-          requestedPlatformDisplayNames[platform]
-        }. ${learnMore('https://docs.expo.dev/eas-update/runtime-versions/')}`
-      ),
-    };
-  });
-}

packages/eas-cli/src/commands/update/republish.ts

@@ -56,7 +56,7 @@ type UpdateToRepublish = {
 >;
 
 export default class UpdateRepublish extends EasCommand {
-  static override description = 'rollback to an existing update';
+  static override description = 'roll back to an existing update';
 
   static override flags = {
     channel: Flags.string({

packages/eas-cli/src/commands/update/roll-back-to-embedded.ts

@@ -0,0 +1,389 @@
+import { Platform as PublishPlatform } from '@expo/config';
+import { Errors, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import nullthrows from 'nullthrows';
+
+import { ensureBranchExistsAsync } from '../../branch/queries';
+import { getUpdateGroupUrl } from '../../build/utils/url';
+import { ensureChannelExistsAsync } from '../../channel/queries';
+import EasCommand from '../../commandUtils/EasCommand';
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { EasNonInteractiveAndJsonFlags } from '../../commandUtils/flags';
+import { getPaginatedQueryOptions } from '../../commandUtils/pagination';
+import fetch from '../../fetch';
+import {
+  PublishUpdateGroupInput,
+  StatuspageServiceName,
+  UpdatePublishMutation,
+} from '../../graphql/generated';
+import { PublishMutation } from '../../graphql/mutations/PublishMutation';
+import Log, { link } from '../../log';
+import { ora } from '../../ora';
+import { RequestedPlatform } from '../../platform';
+import { getOwnerAccountForProjectIdAsync } from '../../project/projectUtils';
+import {
+  ExpoCLIExportPlatformFlag,
+  defaultPublishPlatforms,
+  getBranchNameForCommandAsync,
+  getRequestedPlatform,
+  getRuntimeToPlatformMappingFromRuntimeVersions,
+  getRuntimeVersionObjectAsync,
+  getUpdateMessageForCommandAsync,
+} from '../../project/publish';
+import { ensureEASUpdateIsConfiguredAsync } from '../../update/configure';
+import { getUpdateGroupJsonInfo } from '../../update/utils';
+import {
+  CodeSigningInfo,
+  checkDirectiveBodyAgainstUpdateInfoGroup,
+  getCodeSigningInfoAsync,
+  getDirectiveBodyAsync,
+  signBody,
+} from '../../utils/code-signing';
+import uniqBy from '../../utils/expodash/uniqBy';
+import formatFields from '../../utils/formatFields';
+import { enableJsonOutput, printJsonOnlyOutput } from '../../utils/json';
+import { maybeWarnAboutEasOutagesAsync } from '../../utils/statuspageService';
+import { getVcsClient } from '../../vcs';
+
+type RawUpdateFlags = {
+  auto: boolean;
+  branch?: string;
+  channel?: string;
+  message?: string;
+  platform: string;
+  'private-key-path'?: string;
+  'non-interactive': boolean;
+  json: boolean;
+};
+
+type UpdateFlags = {
+  auto: boolean;
+  platform: ExpoCLIExportPlatformFlag;
+  branchName?: string;
+  channelName?: string;
+  updateMessage?: string;
+  privateKeyPath?: string;
+  json: boolean;
+  nonInteractive: boolean;
+};
+
+export default class UpdateRollBackToEmbedded extends EasCommand {
+  static override hidden = true; // until we launch
+  static override description = 'roll back to the embedded update';
+
+  static override flags = {
+    branch: Flags.string({
+      description: 'Branch to publish the rollback to embedded update group on',
+      required: false,
+    }),
+    channel: Flags.string({
+      description: 'Channel that the published rollback to embedded update should affect',
+      required: false,
+    }),
+    message: Flags.string({
+      description: 'A short message describing the rollback to embedded update',
+      required: false,
+    }),
+    platform: Flags.enum({
+      char: 'p',
+      options: [...defaultPublishPlatforms, 'all'],
+      default: 'all',
+      required: false,
+    }),
+    auto: Flags.boolean({
+      description:
+        'Use the current git branch and commit message for the EAS branch and update message',
+      default: false,
+    }),
+    'private-key-path': Flags.string({
+      description: `File containing the PEM-encoded private key corresponding to the certificate in expo-updates' configuration. Defaults to a file named "private-key.pem" in the certificate's directory.`,
+      required: false,
+    }),
+    ...EasNonInteractiveAndJsonFlags,
+  };
+
+  static override contextDefinition = {
+    ...this.ContextOptions.DynamicProjectConfig,
+    ...this.ContextOptions.LoggedIn,
+  };
+
+  async runAsync(): Promise<void> {
+    const { flags: rawFlags } = await this.parse(UpdateRollBackToEmbedded);
+    const paginatedQueryOptions = getPaginatedQueryOptions(rawFlags);
+    const {
+      auto: autoFlag,
+      platform: platformFlag,
+      channelName: channelNameArg,
+      updateMessage: updateMessageArg,
+      privateKeyPath,
+      json: jsonFlag,
+      nonInteractive,
+      branchName: branchNameArg,
+    } = this.sanitizeFlags(rawFlags);
+
+    const {
+      getDynamicProjectConfigAsync,
+      loggedIn: { graphqlClient },
+    } = await this.getContextAsync(UpdateRollBackToEmbedded, {
+      nonInteractive,
+    });
+
+    if (jsonFlag) {
+      enableJsonOutput();
+    }
+
+    const {
+      exp: expPossiblyWithoutEasUpdateConfigured,
+      projectId,
+      projectDir,
+    } = await getDynamicProjectConfigAsync({
+      isPublicConfig: true,
+    });
+
+    await maybeWarnAboutEasOutagesAsync(graphqlClient, [StatuspageServiceName.EasUpdate]);
+
+    await ensureEASUpdateIsConfiguredAsync(graphqlClient, {
+      exp: expPossiblyWithoutEasUpdateConfigured,
+      platform: getRequestedPlatform(platformFlag),
+      projectDir,
+      projectId,
+    });
+
+    const { exp } = await getDynamicProjectConfigAsync({ isPublicConfig: true });
+    const { exp: expPrivate } = await getDynamicProjectConfigAsync({
+      isPublicConfig: false,
+    });
+    const codeSigningInfo = await getCodeSigningInfoAsync(expPrivate, privateKeyPath);
+
+    const branchName = await getBranchNameForCommandAsync({
+      graphqlClient,
+      projectId,
+      channelNameArg,
+      branchNameArg,
+      autoFlag,
+      nonInteractive,
+      paginatedQueryOptions,
+    });
+
+    const updateMessage = await getUpdateMessageForCommandAsync({
+      updateMessageArg,
+      autoFlag,
+      nonInteractive,
+      jsonFlag,
+    });
+
+    const realizedPlatforms: PublishPlatform[] =
+      platformFlag === 'all' ? defaultPublishPlatforms : [platformFlag];
+
+    const { branchId, createdBranch } = await ensureBranchExistsAsync(graphqlClient, {
+      appId: projectId,
+      branchName,
+    });
+    if (createdBranch) {
+      await ensureChannelExistsAsync(graphqlClient, {
+        appId: projectId,
+        branchId,
+        channelName: branchName,
+      });
+    }
+
+    Log.withTick(`Channel: ${chalk.bold(branchName)} pointed at branch: ${chalk.bold(branchName)}`);
+
+    const vcsClient = getVcsClient();
+
+    const gitCommitHash = await vcsClient.getCommitHashAsync();
+    const isGitWorkingTreeDirty = await vcsClient.hasUncommittedChangesAsync();
+
+    const runtimeVersions = await getRuntimeVersionObjectAsync(exp, realizedPlatforms, projectDir);
+
+    let newUpdates: UpdatePublishMutation['updateBranch']['publishUpdateGroups'];
+    const publishSpinner = ora('Publishing...').start();
+    try {
+      newUpdates = await this.publishRollbacksAsync({
+        graphqlClient,
+        isGitWorkingTreeDirty,
+        gitCommitHash,
+        updateMessage,
+        branchId,
+        codeSigningInfo,
+        runtimeVersions,
+        realizedPlatforms,
+      });
+      publishSpinner.succeed('Published!');
+    } catch (e) {
+      publishSpinner.fail('Failed to publish updates');
+      throw e;
+    }
+
+    if (jsonFlag) {
+      printJsonOnlyOutput(getUpdateGroupJsonInfo(newUpdates));
+    } else {
+      if (new Set(newUpdates.map(update => update.group)).size > 1) {
+        Log.addNewLineIfNone();
+        Log.log(
+          '👉 Since multiple runtime versions are defined, multiple update groups have been published.'
+        );
+      }
+
+      Log.addNewLineIfNone();
+
+      for (const runtime of uniqBy(runtimeVersions, version => version.runtimeVersion)) {
+        const newUpdatesForRuntimeVersion = newUpdates.filter(
+          update => update.runtimeVersion === runtime.runtimeVersion
+        );
+        if (newUpdatesForRuntimeVersion.length === 0) {
+          throw new Error(
+            `Publish response is missing updates with runtime ${runtime.runtimeVersion}.`
+          );
+        }
+        const platforms = newUpdatesForRuntimeVersion.map(update => update.platform);
+        const newAndroidUpdate = newUpdatesForRuntimeVersion.find(
+          update => update.platform === 'android'
+        );
+        const newIosUpdate = newUpdatesForRuntimeVersion.find(update => update.platform === 'ios');
+        const updateGroupId = newUpdatesForRuntimeVersion[0].group;
+
+        const projectName = exp.slug;
+        const accountName = (await getOwnerAccountForProjectIdAsync(graphqlClient, projectId)).name;
+        const updateGroupUrl = getUpdateGroupUrl(accountName, projectName, updateGroupId);
+        const updateGroupLink = link(updateGroupUrl, { dim: false });
+
+        Log.log(
+          formatFields([
+            { label: 'Branch', value: branchName },
+            { label: 'Runtime version', value: runtime.runtimeVersion },
+            { label: 'Platform', value: platforms.join(', ') },
+            { label: 'Update group ID', value: updateGroupId },
+            ...(newAndroidUpdate
+              ? [{ label: 'Android update ID', value: newAndroidUpdate.id }]
+              : []),
+            ...(newIosUpdate ? [{ label: 'iOS update ID', value: newIosUpdate.id }] : []),
+            { label: 'Message', value: updateMessage },
+            ...(gitCommitHash
+              ? [
+                  {
+                    label: 'Commit',
+                    value: `${gitCommitHash}${isGitWorkingTreeDirty ? '*' : ''}`,
+                  },
+                ]
+              : []),
+            { label: 'Website link', value: updateGroupLink },
+          ])
+        );
+        Log.addNewLineIfNone();
+      }
+    }
+  }
+
+  private async publishRollbacksAsync({
+    graphqlClient,
+    isGitWorkingTreeDirty,
+    gitCommitHash,
+    updateMessage,
+    branchId,
+    codeSigningInfo,
+    runtimeVersions,
+    realizedPlatforms,
+  }: {
+    graphqlClient: ExpoGraphqlClient;
+    isGitWorkingTreeDirty: boolean | undefined;
+    gitCommitHash: string | undefined;
+    updateMessage: string;
+    branchId: string;
+    codeSigningInfo: CodeSigningInfo | undefined;
+    runtimeVersions: { platform: string; runtimeVersion: string }[];
+    realizedPlatforms: PublishPlatform[];
+  }): Promise<UpdatePublishMutation['updateBranch']['publishUpdateGroups']> {
+    const runtimeToPlatformMapping =
+      getRuntimeToPlatformMappingFromRuntimeVersions(runtimeVersions);
+    const rollbackInfoGroups = Object.fromEntries(
+      realizedPlatforms.map(platform => [platform, true])
+    );
+
+    // Sort the updates into different groups based on their platform specific runtime versions
+    const updateGroups: PublishUpdateGroupInput[] = runtimeToPlatformMapping.map(
+      ({ runtimeVersion, platforms }) => {
+        const localRollbackInfoGroup = Object.fromEntries(
+          platforms.map(platform => [platform, rollbackInfoGroups[platform]])
+        );
+
+        return {
+          branchId,
+          rollBackToEmbeddedInfoGroup: localRollbackInfoGroup,
+          runtimeVersion,
+          message: updateMessage,
+          gitCommitHash,
+          isGitWorkingTreeDirty,
+          awaitingCodeSigningInfo: !!codeSigningInfo,
+        };
+      }
+    );
+
+    const newUpdates = await PublishMutation.publishUpdateGroupAsync(graphqlClient, updateGroups);
+
+    if (codeSigningInfo) {
+      Log.log('🔒 Signing roll back');
+
+      const updatesTemp = [...newUpdates];
+      const updateGroupsAndTheirUpdates = updateGroups.map(updateGroup => {
+        const newUpdates = updatesTemp.splice(
+          0,
+          Object.keys(nullthrows(updateGroup.rollBackToEmbeddedInfoGroup)).length
+        );
+        return {
+          updateGroup,
+          newUpdates,
+        };
+      });
+
+      await Promise.all(
+        updateGroupsAndTheirUpdates.map(async ({ newUpdates }) => {
+          await Promise.all(
+            newUpdates.map(async newUpdate => {
+              const response = await fetch(newUpdate.manifestPermalink, {
+                method: 'GET',
+                headers: { accept: 'multipart/mixed' },
+              });
+              const directiveBody = nullthrows(await getDirectiveBodyAsync(response));
+
+              checkDirectiveBodyAgainstUpdateInfoGroup(directiveBody);
+
+              const directiveSignature = signBody(directiveBody, codeSigningInfo);
+
+              await PublishMutation.setCodeSigningInfoAsync(graphqlClient, newUpdate.id, {
+                alg: codeSigningInfo.codeSigningMetadata.alg,
+                keyid: codeSigningInfo.codeSigningMetadata.keyid,
+                sig: directiveSignature,
+              });
+            })
+          );
+        })
+      );
+    }
+
+    return newUpdates;
+  }
+
+  private sanitizeFlags(flags: RawUpdateFlags): UpdateFlags {
+    const nonInteractive = flags['non-interactive'] ?? false;
+
+    const { auto, branch: branchName, channel: channelName, message: updateMessage } = flags;
+    if (nonInteractive && !auto && !(updateMessage && (branchName || channelName))) {
+      Errors.error(
+        '--branch and --message, or --channel and --message are required when updating in non-interactive mode unless --auto is specified',
+        { exit: 1 }
+      );
+    }
+
+    return {
+      auto,
+      branchName,
+      channelName,
+      updateMessage,
+      platform: flags.platform as RequestedPlatform,
+      privateKeyPath: flags['private-key-path'],
+      nonInteractive,
+      json: flags.json ?? false,
+    };
+  }
+}

packages/eas-cli/src/credentials/ios/IosCredentialsProvider.ts

@@ -128,7 +128,7 @@ export default class IosCredentialsProvider {
   private async disablePushNotificationsSetupInEasJsonAsync(
     ctx: CredentialsContext
   ): Promise<void> {
-    const easJsonAccessor = new EasJsonAccessor(ctx.projectDir);
+    const easJsonAccessor = EasJsonAccessor.fromProjectPath(ctx.projectDir);
     await easJsonAccessor.readRawJsonAsync();
     easJsonAccessor.patch(easJsonRawObject => {
       easJsonRawObject.cli = {

packages/eas-cli/src/credentials/ios/actions/DeviceUtils.ts

@@ -13,6 +13,7 @@ export async function chooseDevicesAsync(
   const { devices } = await promptAsync({
     type: 'multiselect',
     name: 'devices',
+    selectionFormat: '<num> devices selected',
     message: 'Select devices for the ad hoc build:',
     hint: '- Space to select. Return to submit',
     choices: allDevices.map(device => ({

packages/eas-cli/src/credentials/ios/actions/SetUpAscApiKey.ts

@@ -31,10 +31,10 @@ export enum SetupAscApiKeyChoice {
 export class SetUpAscApiKey {
   public choices: { title: string; value: string }[] = [
     {
-      title: '[Choose an existing ASC API Key]',
+      title: '[Choose an existing key]',
       value: SetupAscApiKeyChoice.USE_EXISTING,
     },
-    { title: '[Add a new ASC API Key]', value: SetupAscApiKeyChoice.GENERATE },
+    { title: '[Add a new key]', value: SetupAscApiKeyChoice.GENERATE },
   ];
 
   constructor(private app: AppLookupParams, private purpose: AppStoreApiKeyPurpose) {}
@@ -126,7 +126,7 @@ export class SetUpAscApiKey {
       const result = await promptAsync({
         type: 'select',
         name: 'choice',
-        message: 'Select what to use for your project:',
+        message: 'Select the App Store Connect Api Key to use for your project:',
         choices,
       });
       choice = result.choice;

packages/eas-cli/src/credentials/ios/actions/SetUpSubmissionCredentials.ts

@@ -1,70 +0,0 @@
-import chalk from 'chalk';
-import nullthrows from 'nullthrows';
-import wrapAnsi from 'wrap-ansi';
-
-import { CommonIosAppCredentialsFragment } from '../../../graphql/generated';
-import Log, { learnMore } from '../../../log';
-import { promptAsync } from '../../../prompts';
-import { CredentialsContext } from '../../context';
-import { UnsupportedCredentialsChoiceError } from '../../errors';
-import { AppLookupParams } from '../api/graphql/types/AppLookupParams';
-import { AppStoreApiKeyPurpose } from './AscApiKeyUtils';
-import { SetUpAscApiKey } from './SetUpAscApiKey';
-
-export const PROMPT_FOR_APP_SPECIFIC_PASSWORD = 'PROMPT_FOR_APP_SPECIFIC_PASSWORD';
-
-export class SetUpSubmissionCredentials {
-  private setupAscApiKeyAction;
-
-  constructor(app: AppLookupParams) {
-    this.setupAscApiKeyAction = new SetUpAscApiKey(app, AppStoreApiKeyPurpose.SUBMISSION_SERVICE);
-    // Add this unrelated choice to ASC API Key setup for legacy purposes -- we will deprecate it soon
-    this.setupAscApiKeyAction.choices = this.setupAscApiKeyAction.choices.concat({
-      title: '[Enter an App Specific Password]',
-      value: PROMPT_FOR_APP_SPECIFIC_PASSWORD,
-    });
-  }
-
-  public async runAsync(
-    ctx: CredentialsContext
-  ): Promise<CommonIosAppCredentialsFragment | string> {
-    try {
-      const iosAppCredentials = await this.setupAscApiKeyAction.runAsync(ctx);
-      const { keyIdentifier, name } = nullthrows(
-        iosAppCredentials.appStoreConnectApiKeyForSubmissions,
-        'ASC API Key must be defined for EAS Submit'
-      );
-      Log.log(`Using API Key ID: ${keyIdentifier}${name ? ` (${name})` : ''}`);
-      return iosAppCredentials;
-    } catch (e) {
-      if (e instanceof UnsupportedCredentialsChoiceError) {
-        if (e.choice === PROMPT_FOR_APP_SPECIFIC_PASSWORD) {
-          return await this.promptForAppSpecificPasswordAsync();
-        }
-      }
-      throw e;
-    }
-  }
-
-  async promptForAppSpecificPasswordAsync(): Promise<string> {
-    Log.addNewLineIfNone();
-    Log.log(`Enter your Apple app-specific password.`);
-    Log.log(learnMore('https://expo.fyi/apple-app-specific-password'));
-    Log.warn(
-      wrapAnsi(
-        `This option will be deprecated soon. You will still be able to provide your password with the ${chalk.bold(
-          'EXPO_APPLE_APP_SPECIFIC_PASSWORD'
-        )} environment variable.`,
-        process.stdout.columns || 80
-      )
-    );
-
-    const { appSpecificPassword } = await promptAsync({
-      name: 'appSpecificPassword',
-      message: 'Your Apple app-specific password:',
-      type: 'password',
-      validate: (val: string) => val !== '' || 'Apple app-specific password cannot be empty!',
-    });
-    return appSpecificPassword;
-  }
-}

packages/eas-cli/src/credentials/ios/actions/__tests__/SetUpSubmissionCredentials-test.ts

@@ -1,70 +0,0 @@
-import { AppQuery } from '../../../../graphql/queries/AppQuery';
-import { findApplicationTarget } from '../../../../project/ios/target';
-import { confirmAsync, promptAsync } from '../../../../prompts';
-import { testAppQueryByIdResponse } from '../../../__tests__/fixtures-constants';
-import { createCtxMock } from '../../../__tests__/fixtures-context';
-import {
-  getNewIosApiMock,
-  testCommonIosAppCredentialsFragment,
-  testTargets,
-} from '../../../__tests__/fixtures-ios';
-import { getAppLookupParamsFromContextAsync } from '../BuildCredentialsUtils';
-import { SetUpAscApiKey } from '../SetUpAscApiKey';
-import {
-  PROMPT_FOR_APP_SPECIFIC_PASSWORD,
-  SetUpSubmissionCredentials,
-} from '../SetUpSubmissionCredentials';
-
-jest.mock('../../../../prompts');
-jest.mocked(confirmAsync).mockImplementation(async () => true);
-jest.mock('../../../../graphql/queries/AppQuery');
-
-describe(SetUpSubmissionCredentials, () => {
-  beforeEach(() => {
-    jest.mocked(AppQuery.byIdAsync).mockResolvedValue(testAppQueryByIdResponse);
-  });
-  it('allows user to enter an App Specific Password', async () => {
-    jest
-      .mocked(promptAsync)
-      .mockImplementationOnce(async () => ({
-        choice: PROMPT_FOR_APP_SPECIFIC_PASSWORD,
-      }))
-      .mockImplementationOnce(async () => ({
-        appSpecificPassword: 'super secret',
-      }));
-    const ctx = createCtxMock({
-      nonInteractive: false,
-      ios: {
-        ...getNewIosApiMock(),
-      },
-    });
-    const appLookupParams = await getAppLookupParamsFromContextAsync(
-      ctx,
-      findApplicationTarget(testTargets)
-    );
-    const setupAscApiKeyAction = new SetUpSubmissionCredentials(appLookupParams);
-    const asp = await setupAscApiKeyAction.runAsync(ctx);
-
-    // prompt to choose ASP, then prompt to input ASP
-    expect(jest.mocked(promptAsync).mock.calls.length).toBe(2);
-    expect(asp).toBe('super secret');
-  });
-  it('returns an ASC API key', async () => {
-    try {
-      jest
-        .spyOn(SetUpAscApiKey.prototype, 'runAsync')
-        .mockImplementation(async _ctx => testCommonIosAppCredentialsFragment);
-      const ctx = createCtxMock();
-      const appLookupParams = await getAppLookupParamsFromContextAsync(
-        ctx,
-        findApplicationTarget(testTargets)
-      );
-      const setupAscApiKeyAction = new SetUpSubmissionCredentials(appLookupParams);
-      const asc = await setupAscApiKeyAction.runAsync(ctx);
-
-      expect(asc).toEqual(testCommonIosAppCredentialsFragment);
-    } finally {
-      jest.restoreAllMocks();
-    }
-  });
-});

packages/eas-cli/src/credentials/ios/api/graphql/mutations/AppleDeviceMutation.ts

@@ -6,8 +6,10 @@ import { withErrorHandlingAsync } from '../../../../../graphql/client';
 import {
   AppleDeviceFragment,
   AppleDeviceInput,
+  AppleDeviceUpdateInput,
   CreateAppleDeviceMutation,
   DeleteAppleDeviceResult,
+  UpdateAppleDeviceMutation,
 } from '../../../../../graphql/generated';
 import { AppleDeviceFragmentNode } from '../../../../../graphql/types/credentials/AppleDevice';
 
@@ -67,4 +69,35 @@ export const AppleDeviceMutation = {
     );
     return data.id;
   },
+  async updateAppleDeviceAsync(
+    graphqlClient: ExpoGraphqlClient,
+    id: string,
+    appleDeviceUpdateInput: AppleDeviceUpdateInput
+  ): Promise<AppleDeviceFragment> {
+    const data = await withErrorHandlingAsync(
+      graphqlClient
+        .mutation<UpdateAppleDeviceMutation>(
+          gql`
+            mutation UpdateAppleDeviceMutation(
+              $id: ID!
+              $appleDeviceUpdateInput: AppleDeviceUpdateInput!
+            ) {
+              appleDevice {
+                updateAppleDevice(id: $id, appleDeviceUpdateInput: $appleDeviceUpdateInput) {
+                  id
+                  ...AppleDeviceFragment
+                }
+              }
+            }
+            ${print(AppleDeviceFragmentNode)}
+          `,
+          {
+            id,
+            appleDeviceUpdateInput,
+          }
+        )
+        .toPromise()
+    );
+    return data.appleDevice.updateAppleDevice;
+  },
 };

packages/eas-cli/src/credentials/manager/SelectBuildProfileFromEasJson.ts

@@ -8,7 +8,7 @@ export class SelectBuildProfileFromEasJson<T extends Platform> {
   private easJsonAccessor: EasJsonAccessor;
 
   constructor(projectDir: string, private platform: T) {
-    this.easJsonAccessor = new EasJsonAccessor(projectDir);
+    this.easJsonAccessor = EasJsonAccessor.fromProjectPath(projectDir);
   }
 
   async runAsync(): Promise<BuildProfile<T>> {

packages/eas-cli/src/devices/actions/create/inputMethod.ts

@@ -81,7 +81,9 @@ async function collectDeviceDataAsync(
   Log.newLine();
   Log.log(
     `We are going to register the following device in our database.
-This will ${chalk.bold('not')} register the device on the Apple Developer Portal yet.`
+This device will ${chalk.bold(
+      'not'
+    )} be registered on the Apple Developer Portal until it is chosen for an internal distribution build.`
   );
   Log.newLine();
   Log.log(formatNewDevice({ ...deviceData, identifier: deviceData.udid }, appleTeam));

packages/eas-cli/src/easMultiselect.ts

@@ -0,0 +1,53 @@
+import { Choice, PromptObject } from 'prompts';
+import { MultiselectPrompt } from 'prompts/lib/elements';
+
+const noop = (): void => {};
+
+export type Question<T extends string = string> = PromptObject<T> & {
+  selectionFormat?: string;
+};
+
+/**
+ * Customized multiselect prompt.
+ *
+ * Additional parameters:
+ *
+ * @param selectionFormat
+ *   String indicating number of selected options. Should contain `<num>` substring.
+ *
+ *   Example:
+ *     'Selected <num> devices'
+ *
+ *   Short format is used when more than one option is selected.
+ *
+ **/
+
+export default class EasMultiselect extends MultiselectPrompt {
+  constructor(opts: Question) {
+    super(opts);
+    this.selectionFormat = opts.selectionFormat;
+  }
+  override renderDoneOrInstructions(): string {
+    if (this.done && this.selectionFormat && this.value) {
+      const selectedOptionsCount = this.value.filter(e => e.selected).length;
+
+      if (selectedOptionsCount > 1) {
+        return this.selectionFormat.replace('<num>', selectedOptionsCount.toString());
+      }
+    }
+    return super.renderDoneOrInstructions();
+  }
+}
+
+export const easMultiselect = (args: Question): Promise<Choice[]> => {
+  const toSelected = (items: Choice[]): Choice[] =>
+    items.filter(item => item.selected).map(item => item.value);
+
+  return new Promise((res, rej) => {
+    const p = new EasMultiselect(args);
+    const onAbort = toSelected || noop;
+    const onSubmit = toSelected || noop;
+    p.on('submit', x => res(onSubmit(x)));
+    p.on('abort', x => rej(onAbort(x)));
+  });
+};

packages/eas-cli/src/graphql/types/Build.ts

@@ -52,8 +52,10 @@ export const BuildFragmentNode = gql`
     priority
     createdAt
     updatedAt
+    message
     completedAt
     resourceClass
+    expirationDate
   }
 `;
 

packages/eas-cli/src/graphql/types/Update.ts

@@ -9,12 +9,13 @@ export const UpdateFragmentNode = gql`
     runtimeVersion
     platform
     manifestFragment
+    isRollBackToEmbedded
     manifestPermalink
     gitCommitHash
     actor {
       __typename
       id
-      ... on User {
+      ... on UserActor {
         username
       }
       ... on Robot {

packages/eas-cli/src/log.ts

@@ -90,11 +90,12 @@ export default class Log {
  */
 export function link(
   url: string,
-  { text = url, dim = true }: { text?: string; dim?: boolean } = {}
+  { text = url, fallback, dim = true }: { text?: string; dim?: boolean; fallback?: string } = {}
 ): string {
   // Links can be disabled via env variables https://github.com/jamestalmage/supports-hyperlinks/blob/master/index.js
   const output = terminalLink(text, url, {
-    fallback: () => (text === url ? chalk.underline(url) : `${text}: ${chalk.underline(url)}`),
+    fallback: () =>
+      fallback ?? (text === url ? chalk.underline(url) : `${text}: ${chalk.underline(url)}`),
   });
   return dim ? chalk.dim(output) : output;
 }

packages/eas-cli/src/ora.ts

@@ -1,3 +1,4 @@
+import { boolish } from 'getenv';
 // eslint-disable-next-line
 import oraReal, { Options, Ora } from 'ora';
 
@@ -14,6 +15,8 @@ const warnReal = console.warn;
 // eslint-disable-next-line no-console
 const errorReal = console.error;
 
+const isCi = boolish('CI', false);
+
 /**
  * A custom ora spinner that sends the stream to stdout in CI, or non-TTY, instead of stderr (the default).
  *
@@ -22,7 +25,7 @@ const errorReal = console.error;
  */
 export function ora(options?: Options | string): Ora {
   const inputOptions = typeof options === 'string' ? { text: options } : options ?? {};
-  const disabled = Log.isDebug || !process.stdin.isTTY;
+  const disabled = Log.isDebug || !process.stdin.isTTY || isCi;
   const spinner = oraReal({
     // Ensure our non-interactive mode emulates CI mode.
     isEnabled: !disabled,

packages/eas-cli/src/platform.ts

@@ -9,7 +9,7 @@ export const appPlatformDisplayNames: Record<AppPlatform, string> = {
 };
 
 export const appPlatformEmojis = {
-  [AppPlatform.Ios]: '🍎',
+  [AppPlatform.Ios]: '🍏',
   [AppPlatform.Android]: '🤖',
 };
 

packages/eas-cli/src/project/__mocks__/applicationIdentifier.ts

@@ -0,0 +1,17 @@
+import { ExpoConfig } from '@expo/config';
+import { BuildProfile, Platform } from '@expo/eas-json';
+
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+
+async function defaultGetApplicationIdentifierAsync(_opts: {
+  graphqlClient: ExpoGraphqlClient;
+  projectDir: string;
+  projectId: string;
+  exp: ExpoConfig;
+  buildProfile: BuildProfile;
+  platform: Platform;
+}): Promise<string> {
+  return 'eas.test.com';
+}
+
+export const getApplicationIdentifierAsync = jest.fn(defaultGetApplicationIdentifierAsync);

packages/eas-cli/src/project/__tests__/publish-test.ts

@@ -5,7 +5,6 @@ import { instance, mock } from 'ts-mockito';
 import { v4 as uuidv4 } from 'uuid';
 
 import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
-import { defaultPublishPlatforms } from '../../commands/update';
 import { AssetMetadataStatus } from '../../graphql/generated';
 import { PublishMutation } from '../../graphql/mutations/PublishMutation';
 import { PublishQuery } from '../../graphql/queries/PublishQuery';
@@ -14,9 +13,12 @@ import {
   buildUnsortedUpdateInfoGroupAsync,
   collectAssetsAsync,
   convertAssetToUpdateInfoGroupFormatAsync,
+  defaultPublishPlatforms,
   filterExportedPlatformsByFlag,
   filterOutAssetsThatAlreadyExistAsync,
+  getAssetHashFromPath,
   getBase64URLEncoding,
+  getOriginalPathFromAssetMap,
   getStorageKey,
   getStorageKeyForAssetAsync,
   guessContentTypeFromExtension,
@@ -279,9 +281,55 @@ describe(resolveInputDirectoryAsync, () => {
   });
 });
 
+describe(getAssetHashFromPath, () => {
+  it('returns asset hash from path', () => {
+    expect(getAssetHashFromPath('assets/5b2a819c71d035ca45d223e4c47ed4f9')).toBe(
+      '5b2a819c71d035ca45d223e4c47ed4f9'
+    );
+  });
+  it('returns null for incorrect path', () => {
+    expect(getAssetHashFromPath('assets/this/is/not/a/hash.jpg')).toBeNull();
+  });
+});
+
+describe(getOriginalPathFromAssetMap, () => {
+  // Partial assetmap.json, with only fields we need
+  const fakeAssetMap = {
+    '5b2a819c71d035ca45d223e4c47ed4f9': {
+      httpServerLocation: '/assets/src/assets',
+      name: 'asset-420',
+      type: 'jpg',
+    },
+  };
+  it('returns null path when asset map is null', () => {
+    expect(
+      getOriginalPathFromAssetMap(null, {
+        path: 'assets/5b2a819c71d035ca45d223e4c47ed4f9',
+        ext: 'jpg',
+      })
+    ).toBeNull();
+  });
+  it('returns null when asset is not found in asset map', () => {
+    expect(
+      getOriginalPathFromAssetMap(fakeAssetMap, {
+        path: 'assets/fb64d3b2fb71b3d739ad5c13a93e12c5',
+        ext: 'jpg',
+      })
+    ).toBeNull();
+  });
+  it('returns reconstructed original path from existing asset in asset map', () => {
+    expect(
+      getOriginalPathFromAssetMap(fakeAssetMap, {
+        path: 'assets/5b2a819c71d035ca45d223e4c47ed4f9',
+        ext: 'jpg',
+      })
+    ).toBe('/src/assets/asset-420.jpg');
+  });
+});
+
 describe(collectAssetsAsync, () => {
   it('builds an update info group', async () => {
-    const fakeHash = 'md5-hash-of-jpg';
+    const fakeHash = 'hdahukw8adhawi8fawhfa8';
     const bundles = {
       android: 'android-bundle-code',
       ios: 'ios-bundle-code',
@@ -294,6 +342,7 @@ describe(collectAssetsAsync, () => {
         fileExtension: '.jpg',
         contentType: 'image/jpeg',
         path: `${inputDir}/assets/${fakeHash}`,
+        originalPath: `assets/wat.jpg`,
       },
     ];
 
@@ -326,6 +375,24 @@ describe(collectAssetsAsync, () => {
         },
       })
     );
+    await fs.writeFile(
+      path.resolve(inputDir, 'assetmap.json'),
+      JSON.stringify({
+        [fakeHash]: {
+          __packager_asset: true,
+          fileSystemLocation: '/Users/blah/temp/assets',
+          httpServerLocation: 'assets/assets',
+          width: 2339,
+          height: 1560,
+          scales: [1],
+          files: ['/Users/blah/temp/assets/wat.jpg'],
+          hash: fakeHash,
+          name: 'wat',
+          type: 'jpg',
+          fileHashes: [fakeHash],
+        },
+      })
+    );
 
     expect(await collectAssetsAsync(inputDir)).toEqual({
       android: {
@@ -410,6 +477,7 @@ describe(uploadAssetsAsync, () => {
   const androidBundlePath = uuidv4();
   const iosBundlePath = uuidv4();
   const dummyFilePath = uuidv4();
+  const dummyOriginalFilePath = uuidv4();
   const userDefinedPath = uuidv4();
   const testProjectId = uuidv4();
   const expectedAssetLimit = 1400;
@@ -427,7 +495,15 @@ describe(uploadAssetsAsync, () => {
         contentType: 'application/javascript',
         path: androidBundlePath,
       },
-      assets: [userDefinedAsset, { type: 'jpg', contentType: 'image/jpeg', path: dummyFilePath }],
+      assets: [
+        userDefinedAsset,
+        {
+          type: 'jpg',
+          contentType: 'image/jpeg',
+          path: dummyFilePath,
+          originalPath: dummyOriginalFilePath,
+        },
+      ],
     },
     ios: {
       launchAsset: {
@@ -435,7 +511,15 @@ describe(uploadAssetsAsync, () => {
         contentType: 'application/javascript',
         path: androidBundlePath,
       },
-      assets: [userDefinedAsset, { type: 'jpg', contentType: 'image/jpeg', path: dummyFilePath }],
+      assets: [
+        userDefinedAsset,
+        {
+          type: 'jpg',
+          contentType: 'image/jpeg',
+          path: dummyFilePath,
+          originalPath: dummyOriginalFilePath,
+        },
+      ],
     },
   };
 
@@ -490,8 +574,10 @@ describe(uploadAssetsAsync, () => {
       uploadAssetsAsync(graphqlClient, assetsForUpdateInfoGroup, testProjectId)
     ).resolves.toEqual({
       assetCount: 6,
+      launchAssetCount: 2,
       uniqueAssetCount: 3,
       uniqueUploadedAssetCount: 0,
+      uniqueUploadedAssetPaths: [],
       assetLimitPerUpdateGroup: expectedAssetLimit,
     });
   });
@@ -526,8 +612,10 @@ describe(uploadAssetsAsync, () => {
       uploadAssetsAsync(graphqlClient, assetsForUpdateInfoGroup, testProjectId)
     ).resolves.toEqual({
       assetCount: 6,
+      launchAssetCount: 2,
       uniqueAssetCount: 3,
       uniqueUploadedAssetCount: 2,
+      uniqueUploadedAssetPaths: [],
       assetLimitPerUpdateGroup: expectedAssetLimit,
     });
   });

packages/eas-cli/src/project/android/__tests__/applicationId-test.ts

@@ -1,8 +1,11 @@
 import fs from 'fs-extra';
 import { vol } from 'memfs';
 import os from 'os';
+import { instance, mock } from 'ts-mockito';
 
-import { jester as mockJester } from '../../../credentials/__tests__/fixtures-constants';
+import { ExpoGraphqlClient } from '../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { jester, jester as mockJester } from '../../../credentials/__tests__/fixtures-constants';
+import { AppQuery } from '../../../graphql/queries/AppQuery';
 import { promptAsync } from '../../../prompts';
 import {
   ensureApplicationIdIsDefinedForManagedProjectAsync,
@@ -11,6 +14,7 @@ import {
 
 jest.mock('fs');
 jest.mock('../../../prompts');
+jest.mock('../../../graphql/queries/AppQuery');
 jest.mock('../../../user/actions', () => ({ ensureLoggedInAsync: jest.fn(() => mockJester) }));
 
 beforeEach(async () => {
@@ -103,6 +107,8 @@ describe(getApplicationIdAsync, () => {
 describe(ensureApplicationIdIsDefinedForManagedProjectAsync, () => {
   describe('managed project + android.package missing in app config', () => {
     it('throws an error if using app.config.js', async () => {
+      const graphqlClient = instance(mock<ExpoGraphqlClient>());
+
       vol.fromJSON(
         {
           'app.config.js': 'module.exports = { blah: {} };',
@@ -110,10 +116,23 @@ describe(ensureApplicationIdIsDefinedForManagedProjectAsync, () => {
         '/app'
       );
       await expect(
-        ensureApplicationIdIsDefinedForManagedProjectAsync('/app', {} as any, mockJester)
+        ensureApplicationIdIsDefinedForManagedProjectAsync({
+          graphqlClient,
+          projectDir: '/app',
+          projectId: '',
+          exp: {} as any,
+        })
       ).rejects.toThrowError(/we can't update this file programmatically/);
     });
     it('prompts for the Android package if using app.json', async () => {
+      const graphqlClient = instance(mock<ExpoGraphqlClient>());
+      jest.mocked(AppQuery.byIdAsync).mockResolvedValue({
+        id: '1234',
+        slug: 'testing-123',
+        fullName: '@jester/testing-123',
+        ownerAccount: jester.accounts[0],
+      });
+
       vol.fromJSON(
         {
           'app.json': '{ "expo": {} }',
@@ -126,11 +145,26 @@ describe(ensureApplicationIdIsDefinedForManagedProjectAsync, () => {
       }));
 
       await expect(
-        ensureApplicationIdIsDefinedForManagedProjectAsync('/app', {} as any, mockJester)
+        ensureApplicationIdIsDefinedForManagedProjectAsync({
+          graphqlClient,
+          projectDir: '/app',
+          projectId: '',
+          exp: {} as any,
+        })
       ).resolves.toBe('com.expo.notdominik');
       expect(promptAsync).toHaveBeenCalled();
     });
+
     it('puts the Android package in app.json', async () => {
+      const graphqlClient = instance(mock<ExpoGraphqlClient>());
+
+      jest.mocked(AppQuery.byIdAsync).mockResolvedValue({
+        id: '1234',
+        slug: 'testing-123',
+        fullName: '@jester/testing-123',
+        ownerAccount: jester.accounts[0],
+      });
+
       vol.fromJSON(
         {
           'app.json': '{ "expo": {} }',
@@ -143,7 +177,12 @@ describe(ensureApplicationIdIsDefinedForManagedProjectAsync, () => {
       }));
 
       await expect(
-        ensureApplicationIdIsDefinedForManagedProjectAsync('/app', {} as any, mockJester)
+        ensureApplicationIdIsDefinedForManagedProjectAsync({
+          graphqlClient,
+          projectDir: '/app',
+          projectId: '',
+          exp: {} as any,
+        })
       ).resolves.toBe('com.expo.notdominik');
       const appJson = JSON.parse(await fs.readFile('/app/app.json', 'utf-8'));
       expect(appJson).toMatchObject({

packages/eas-cli/src/project/android/applicationId.ts

@@ -7,22 +7,31 @@ import fs from 'fs-extra';
 import nullthrows from 'nullthrows';
 
 import { readAppJson } from '../../build/utils/appJson';
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
 import env from '../../env';
 import Log, { learnMore } from '../../log';
-import { getProjectConfigDescription, getUsername } from '../../project/projectUtils';
+import {
+  getOwnerAccountForProjectIdAsync,
+  getProjectConfigDescription,
+} from '../../project/projectUtils';
 import { promptAsync } from '../../prompts';
-import { Actor } from '../../user/User';
 import { resolveWorkflowAsync } from '../workflow';
 import { GradleBuildContext } from './gradle';
 import * as gradleUtils from './gradleUtils';
 
 export const INVALID_APPLICATION_ID_MESSAGE = `Invalid format of Android applicationId. Only alphanumeric characters, '.' and '_' are allowed, and each '.' must be followed by a letter.`;
 
-export async function ensureApplicationIdIsDefinedForManagedProjectAsync(
-  projectDir: string,
-  exp: ExpoConfig,
-  actor: Actor
-): Promise<string> {
+export async function ensureApplicationIdIsDefinedForManagedProjectAsync({
+  graphqlClient,
+  projectDir,
+  projectId,
+  exp,
+}: {
+  graphqlClient: ExpoGraphqlClient;
+  projectDir: string;
+  projectId: string;
+  exp: ExpoConfig;
+}): Promise<string> {
   const workflow = await resolveWorkflowAsync(projectDir, Platform.ANDROID);
   assert(workflow === Workflow.MANAGED, 'This function should be called only for managed projects');
 
@@ -31,7 +40,7 @@ export async function ensureApplicationIdIsDefinedForManagedProjectAsync(
       moduleName: gradleUtils.DEFAULT_MODULE_NAME,
     });
   } catch {
-    return await configureApplicationIdAsync(projectDir, exp, actor);
+    return await configureApplicationIdAsync({ graphqlClient, projectDir, projectId, exp });
   }
 }
 
@@ -110,11 +119,17 @@ export async function getApplicationIdAsync(
   }
 }
 
-async function configureApplicationIdAsync(
-  projectDir: string,
-  exp: ExpoConfig,
-  actor: Actor
-): Promise<string> {
+async function configureApplicationIdAsync({
+  graphqlClient,
+  projectDir,
+  projectId,
+  exp,
+}: {
+  graphqlClient: ExpoGraphqlClient;
+  projectDir: string;
+  projectId: string;
+  exp: ExpoConfig;
+}): Promise<string> {
   const paths = getConfigFilePaths(projectDir);
   // we can't automatically update app.config.js
   if (paths.dynamicConfigPath) {
@@ -132,7 +147,11 @@ async function configureApplicationIdAsync(
     )}`
   );
 
-  const suggestedAndroidApplicationId = await getSuggestedApplicationIdAsync(exp, actor);
+  const suggestedAndroidApplicationId = await getSuggestedApplicationIdAsync(
+    graphqlClient,
+    exp,
+    projectId
+  );
   const { packageName } = await promptAsync({
     name: 'packageName',
     type: 'text',
@@ -174,8 +193,9 @@ export function warnIfAndroidPackageDefinedInAppConfigForBareWorkflowProject(
 }
 
 async function getSuggestedApplicationIdAsync(
+  graphqlClient: ExpoGraphqlClient,
   exp: ExpoConfig,
-  actor: Actor
+  projectId: string
 ): Promise<string | undefined> {
   // Attempt to use the ios bundle id first since it's convenient to have them aligned.
   const maybeBundleId = IOSConfig.BundleIdentifier.getBundleIdentifier(exp);
@@ -183,9 +203,9 @@ async function getSuggestedApplicationIdAsync(
     return maybeBundleId;
   } else {
     // the only callsite is heavily interactive
-    const username = getUsername(exp, actor);
+    const account = await getOwnerAccountForProjectIdAsync(graphqlClient, projectId);
     // It's common to use dashes in your node project name, strip them from the suggested package name.
-    const possibleId = `com.${username}.${exp.slug}`.split('-').join('');
+    const possibleId = `com.${account.name}.${exp.slug}`.split('-').join('');
     if (isApplicationIdValid(possibleId)) {
       return possibleId;
     }

packages/eas-cli/src/project/android/gradleUtils.ts

@@ -74,7 +74,7 @@ export function parseGradleCommand(cmd: string, buildGradle: AppBuildGradle): Gr
   const [moduleName, taskName] =
     splitCmd.length > 1 ? [splitCmd[0], splitCmd[1]] : [undefined, splitCmd[0]];
 
-  const matchResult = taskName.match(/(build|bundle|assemble)(.*)(Release|Debug)/);
+  const matchResult = taskName.match(/(build|bundle|assemble|package)(.*)(Release|Debug)/);
   if (!matchResult) {
     throw new Error(`Failed to parse gradle command: ${cmd}`);
   }

packages/eas-cli/src/project/applicationIdentifier.ts

@@ -2,7 +2,7 @@ import { ExpoConfig } from '@expo/config';
 import { Platform, Workflow } from '@expo/eas-build-job';
 import { BuildProfile } from '@expo/eas-json';
 
-import { Actor } from '../user/User';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
 import {
   ensureApplicationIdIsDefinedForManagedProjectAsync,
   getApplicationIdAsync,
@@ -16,19 +16,32 @@ import { resolveXcodeBuildContextAsync } from './ios/scheme';
 import { findApplicationTarget, resolveTargetsAsync } from './ios/target';
 import { resolveWorkflowAsync } from './workflow';
 
-export async function getApplicationIdentifierAsync(
-  projectDir: string,
-  exp: ExpoConfig,
-  buildProfile: BuildProfile,
-  platform: Platform,
-  actor: Actor
-): Promise<string> {
+export async function getApplicationIdentifierAsync({
+  graphqlClient,
+  projectDir,
+  projectId,
+  exp,
+  buildProfile,
+  platform,
+}: {
+  graphqlClient: ExpoGraphqlClient;
+  projectDir: string;
+  projectId: string;
+  exp: ExpoConfig;
+  buildProfile: BuildProfile;
+  platform: Platform;
+}): Promise<string> {
   if (platform === Platform.ANDROID) {
     const profile = buildProfile as BuildProfile<Platform.ANDROID>;
     const workflow = await resolveWorkflowAsync(projectDir, Platform.ANDROID);
 
     if (workflow === Workflow.MANAGED) {
-      return await ensureApplicationIdIsDefinedForManagedProjectAsync(projectDir, exp, actor);
+      return await ensureApplicationIdIsDefinedForManagedProjectAsync({
+        graphqlClient,
+        projectDir,
+        projectId,
+        exp,
+      });
     }
 
     const gradleContext = await resolveGradleBuildContextAsync(projectDir, profile);
@@ -37,7 +50,12 @@ export async function getApplicationIdentifierAsync(
     const workflow = await resolveWorkflowAsync(projectDir, Platform.IOS);
     const profile = buildProfile as BuildProfile<Platform.IOS>;
     if (workflow === Workflow.MANAGED) {
-      return await ensureBundleIdentifierIsDefinedForManagedProjectAsync(projectDir, exp, actor);
+      return await ensureBundleIdentifierIsDefinedForManagedProjectAsync({
+        graphqlClient,
+        projectDir,
+        projectId,
+        exp,
+      });
     }
 
     const xcodeBuildContext = await resolveXcodeBuildContextAsync(

packages/eas-cli/src/project/customBuildConfig.ts

@@ -0,0 +1,56 @@
+import { Platform } from '@expo/eas-build-job';
+import { BuildProfile } from '@expo/eas-json';
+import { errors, readAndValidateBuildConfigAsync } from '@expo/steps';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+
+export interface CustomBuildConfigMetadata {
+  workflowName?: string;
+}
+
+export async function validateCustomBuildConfigAsync(
+  projectDir: string,
+  profile: BuildProfile<Platform>
+): Promise<CustomBuildConfigMetadata | undefined> {
+  if (!profile.config) {
+    return undefined;
+  }
+
+  const relativeConfigPath = getCustomBuildConfigPath(profile.config);
+  const configPath = path.join(projectDir, relativeConfigPath);
+  if (!(await fs.pathExists(configPath))) {
+    throw new Error(
+      `Custom build configuration file ${chalk.bold(relativeConfigPath)} does not exist.`
+    );
+  }
+
+  try {
+    const config = await readAndValidateBuildConfigAsync(configPath, {
+      skipNamespacedFunctionsCheck: true,
+    });
+    return {
+      workflowName: config.build.name,
+    };
+  } catch (err) {
+    if (err instanceof errors.BuildConfigYAMLError) {
+      throw new Error(
+        `Custom build configuration file ${chalk.bold(
+          relativeConfigPath
+        )} contains invalid YAML.\n\n${err.message}`
+      );
+    } else if (err instanceof errors.BuildConfigError) {
+      throw new Error(
+        `Custom build configuration file ${chalk.bold(
+          relativeConfigPath
+        )} contains invalid configuration. Please check the docs!\n${err.message}`
+      );
+    } else {
+      throw err;
+    }
+  }
+}
+
+export function getCustomBuildConfigPath(configFilename: string): string {
+  return path.join('.eas/build', configFilename);
+}

packages/eas-cli/src/project/ios/__tests__/bundleIdentifier-test.ts

@@ -2,8 +2,11 @@ import fs from 'fs-extra';
 import { vol } from 'memfs';
 import os from 'os';
 import path from 'path';
+import { instance, mock } from 'ts-mockito';
 
-import { jester as mockJester } from '../../../credentials/__tests__/fixtures-constants';
+import { ExpoGraphqlClient } from '../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { jester, jester as mockJester } from '../../../credentials/__tests__/fixtures-constants';
+import { AppQuery } from '../../../graphql/queries/AppQuery';
 import { promptAsync } from '../../../prompts';
 import {
   ensureBundleIdentifierIsDefinedForManagedProjectAsync,
@@ -13,6 +16,7 @@ import {
 
 jest.mock('fs');
 jest.mock('../../../prompts');
+jest.mock('../../../graphql/queries/AppQuery');
 jest.mock('../../../user/actions', () => ({ ensureLoggedInAsync: jest.fn(() => mockJester) }));
 
 beforeEach(async () => {
@@ -86,6 +90,7 @@ describe(getBundleIdentifierAsync, () => {
 describe(ensureBundleIdentifierIsDefinedForManagedProjectAsync, () => {
   describe('managed project + ios.bundleIdentifier missing in app config', () => {
     it('throws an error if using app.config.js', async () => {
+      const graphqlClient = instance(mock<ExpoGraphqlClient>());
       vol.fromJSON(
         {
           'app.config.js': 'module.exports = { blah: {} };',
@@ -93,10 +98,23 @@ describe(ensureBundleIdentifierIsDefinedForManagedProjectAsync, () => {
         '/app'
       );
       await expect(
-        ensureBundleIdentifierIsDefinedForManagedProjectAsync('/app', {} as any, mockJester)
+        ensureBundleIdentifierIsDefinedForManagedProjectAsync({
+          graphqlClient,
+          projectDir: '/app',
+          projectId: '1234',
+          exp: {} as any,
+        })
       ).rejects.toThrowError(/we can't update this file programmatically/);
     });
     it('prompts for the bundle identifier if using app.json', async () => {
+      const graphqlClient = instance(mock<ExpoGraphqlClient>());
+      jest.mocked(AppQuery.byIdAsync).mockResolvedValue({
+        id: '1234',
+        slug: 'testing-123',
+        fullName: '@jester/testing-123',
+        ownerAccount: jester.accounts[0],
+      });
+
       vol.fromJSON(
         {
           'app.json': '{ "expo": {} }',
@@ -109,11 +127,24 @@ describe(ensureBundleIdentifierIsDefinedForManagedProjectAsync, () => {
       }));
 
       await expect(
-        ensureBundleIdentifierIsDefinedForManagedProjectAsync('/app', {} as any, mockJester)
+        ensureBundleIdentifierIsDefinedForManagedProjectAsync({
+          graphqlClient,
+          projectDir: '/app',
+          projectId: '1234',
+          exp: {} as any,
+        })
       ).resolves.toBe('com.expo.notdominik');
       expect(promptAsync).toHaveBeenCalled();
     });
     it('puts the bundle identifier in app.json', async () => {
+      const graphqlClient = instance(mock<ExpoGraphqlClient>());
+      jest.mocked(AppQuery.byIdAsync).mockResolvedValue({
+        id: '1234',
+        slug: 'testing-123',
+        fullName: '@jester/testing-123',
+        ownerAccount: jester.accounts[0],
+      });
+
       vol.fromJSON(
         {
           'app.json': '{ "expo": {} }',
@@ -126,7 +157,12 @@ describe(ensureBundleIdentifierIsDefinedForManagedProjectAsync, () => {
       }));
 
       await expect(
-        ensureBundleIdentifierIsDefinedForManagedProjectAsync('/app', {} as any, mockJester)
+        ensureBundleIdentifierIsDefinedForManagedProjectAsync({
+          graphqlClient,
+          projectDir: '/app',
+          projectId: '1234',
+          exp: {} as any,
+        })
       ).resolves.toBe('com.expo.notdominik');
       const appJson = JSON.parse(await fs.readFile('/app/app.json', 'utf-8'));
       expect(appJson).toMatchObject({