v0.11.0

fix building APKs for Android managed projects (#349 )
* fix building APKs for Android managed projects * update CHANGELOG
2026-11-15 03:38:08 -10:00 · 2021-04-20 15:08:57 +02:00 · 2021-04-20 14:39:58 +02:00 · 2021-04-20 10:39:37 +02:00 · 2021-04-19 12:39:20 +02:00 · 2021-04-19 12:29:37 +02:00
178 changed files with 11007 additions and 4115 deletions
@@ -22,7 +22,7 @@ jobs:
        with:
          node-version: ${{ matrix.node }}
      - run: yarn install --frozen-lockfile --check-files
-      - run: yarn lerna run build
+      - run: yarn typecheck
      - run: yarn test
        if: ${{ !matrix.coverage }}
      - run: yarn test --coverage
@@ -6,6 +6,96 @@ This is the log of notable changes to EAS CLI and related packages.

 ### 🛠 Breaking changes

+- `"credentialsSource": "auto"` is now deprecated. The option will use `"remote"` as the default value. ([#345](https://github.com/expo/eas-cli/pull/345) by [@dsokal](https://github.com/dsokal))
+
+### 🎉 New features
+
+- Add validation when setting up ad-hoc provisioning profile in non-interactive mode. ([#338](https://github.com/expo/eas-cli/pull/338) by [@dsokal](https://github.com/dsokal))
+- Allow for registering devices when running an ad-hoc build for the first time. ([#340](https://github.com/expo/eas-cli/pull/340) by [@dsokal](https://github.com/dsokal))
+
+### 🐛 Bug fixes
+
+- Fix the bug where all Android managed builds produced AAB archives. The `buildType` property from `eas.json` is not ignored now. ([#349](https://github.com/expo/eas-cli/pull/349) by [@dsokal](https://github.com/dsokal))
+
+### 🧹 Chores
+
+## [0.10.0](https://github.com/expo/eas-cli/releases/tag/v0.10.0) - 2021-04-16
+
+### 🛠 Breaking changes
+
+- `secrets:<COMMAND>` is renamed to `secret:<COMMAND>` ([#315](https://github.com/expo/eas-cli/pull/315) by [@fiberjw](https://github.com/fiberjw))
+- `secret:delete` now accepts `id` through a flag rather than an argument ([#315](https://github.com/expo/eas-cli/pull/315) by [@fiberjw](https://github.com/fiberjw))
+
+### 🎉 New features
+
+- Use special Expo SDK runtime version for managed projects ([#336](https://github.com/expo/eas-cli/pull/336)) by [@wschurman](https://github.com/wschurman))
+
+### 🐛 Bug fixes
+
+- Fix the behavior where the provisioning profile was invalidated after syncing bundle id capabilities. ([#334](https://github.com/expo/eas-cli/pull/334) by [@dsokal](https://github.com/dsokal))
+
+### 🧹 Chores
+
+- Change build credentials summary format. ([#321](https://github.com/expo/eas-cli/pull/321) by [@dsokal](https://github.com/dsokal))
+
+## [0.9.1](https://github.com/expo/eas-cli/releases/tag/v0.9.1) - 2021-04-09
+
+### 🐛 Bug fixes
+
+- Fix provisioning profile validation to actually check status. ([#318](https://github.com/expo/eas-cli/pull/318) by [@quinlanj](https://github.com/quinlanj))
+
+### 🧹 Chores
+
+- Replace Credentials REST API calls with GraphQL counterparts, also improved DX. ([#293](https://github.com/expo/eas-cli/pull/293), [#299](https://github.com/expo/eas-cli/pull/299), [#301](https://github.com/expo/eas-cli/pull/301), [#317](https://github.com/expo/eas-cli/pull/317) by [@quinlanj](https://github.com/quinlanj))
+
+## [0.9.0](https://github.com/expo/eas-cli/releases/tag/v0.9.0) - 2021-04-09
+
+### 🎉 New features
+
+- Retry graphQL call on network or transient server errors. ([#320](https://github.com/expo/eas-cli/pull/320) by [@jkhales](https://github.com/jkhales))
+- Display more friendly error messages when `eas submit` fails. ([#311](https://github.com/expo/eas-cli/pull/297) by [@barthap](https://github.com/barthap))
+- Add support for managing webhooks (new commands: `webhook:create`, `webhook:view`, `webhook:list`, `webhook:update`, and `webhook:delete`). ([#314](https://github.com/expo/eas-cli/pull/314) by [@dsokal](https://github.com/dsokal))
+- Support for local builds [experimental]. ([#305](https://github.com/expo/eas-cli/pull/305) by [@wkozyra95](https://github.com/wkozyra95))
+
+### 🐛 Bug fixes
+
+- Fix the issue where the first iOS build fails for a project without `ios.bundleIdentifier` set in `app.json`. ([#319](https://github.com/expo/eas-cli/pull/319) by [@dsokal](https://github.com/dsokal))
+- Bump @expo/config-plugins to fix `eas build:configure` on Windows. ([d0f3e](https://github.com/expo/eas-cli/commit/d0f3e387e7f31dbce4c3b93b8d083c7d20d9e30d) by [@brentvatne](https://github.com/brentvatne))
+- Replace REST API calls with GraphQL counterparts. ([#333](https://github.com/expo/eas-cli/pull/333) by [@barthap](https://github.com/barthap))
+
+## [0.8.1](https://github.com/expo/eas-cli/releases/tag/v0.8.1) - 2021-04-06
+
+### 🐛 Bug fixes
+
+- Fix the issue where the build status never got updated when running `eas build`. ([#310](https://github.com/expo/eas-cli/pull/310) by [@dsokal](https://github.com/dsokal))
+
+## [0.8.0](https://github.com/expo/eas-cli/releases/tag/v0.8.0) - 2021-04-06
+
+### 🛠 Breaking changes
+
+- Change the way of disabling cache - add `cache.disabled` field. ([#295](https://github.com/expo/eas-cli/pull/295) by [@dsokal](https://github.com/dsokal))
+- `secrets:create` now uses flags rather than positional arguments ([#300](https://github.com/expo/eas-cli/pull/300) by [@fiberjw](https://github.com/fiberjw))
+- `secrets:create`'s `target` arg is now called `scope` ([#300](https://github.com/expo/eas-cli/pull/300) by [@fiberjw](https://github.com/fiberjw))
+- `secrets:list`'s `target` property is now called `scope` ([#300](https://github.com/expo/eas-cli/pull/300) by [@fiberjw](https://github.com/fiberjw))
+- `secrets:delete`'s `ID` arg is now optional ([#309](https://github.com/expo/eas-cli/pull/309) by [@fiberjw](https://github.com/fiberjw))
+- `secrets:delete`'s now allows users to choose secrets from a list ([#309](https://github.com/expo/eas-cli/pull/309) by [@fiberjw](https://github.com/fiberjw))
+
+### 🎉 New features
+
+- `build:view` and `build:list` now showing the distribution type (store / internal) and release channel. ([#284](https://github.com/expo/eas-cli/pull/284) by [@vthibault](https://github.com/vthibault))
+- Add analytics to EAS Build. ([#162](https://github.com/expo/eas-cli/pull/162) by [@wkozyra95](https://github.com/wkozyra95))
+- Improve tar archive support in EAS Submit. ([#297](https://github.com/expo/eas-cli/pull/297) by [@barthap](https://github.com/barthap))
+
+### 🐛 Bug fixes
+
+- Fix environment secret creation prompt. ([#298](https://github.com/expo/eas-cli/pull/298) by [@fiberjw](https://github.com/fiberjw))
+
+### 🧹 Chores
+
+- Replace REST API calls with GraphQL counterparts. ([#286](https://github.com/expo/eas-cli/pull/286), [#288](https://github.com/expo/eas-cli/pull/288), [#303](https://github.com/expo/eas-cli/pull/303), [#306](https://github.com/expo/eas-cli/pull/306), [#307](https://github.com/expo/eas-cli/pull/307) by [@dsokal](https://github.com/dsokal))
+
+## [0.7.0](https://github.com/expo/eas-cli/releases/tag/v0.7.0) - 2021-03-22
+
 ### 🎉 New features

 - Print common error messages when builds fail. ([#272](https://github.com/expo/eas-cli/pull/272) by [@dsokal](https://github.com/dsokal))
@@ -19,8 +109,6 @@ This is the log of notable changes to EAS CLI and related packages.
 - Verify whether "name" field in app.json contains any alphanumeric characters. ([#280](https://github.com/expo/eas-cli/pull/280) by [@wkozyra95](https://github.com/wkozyra95))
 - Detect dependency cycles in eas.json build profiles. ([#283](https://github.com/expo/eas-cli/pull/283) by [@wkozyra95](https://github.com/wkozyra95))

-### 🧹 Chores
-
 ## [0.6.0](https://github.com/expo/eas-cli/releases/tag/v0.6.0) - 2021-03-09

 ### 🛠 Breaking changes
@@ -1,9 +1,10 @@
 ## Releasing a new version

-1. Add release notes to `CHANGELOG.md`.
-1. Run `yarn release` in the repository root folder. This will create a new tag
-   like `v1.0.0`.
-1. Wait until the `release` GitHub workflow has finished.
-1. Once the release ready to go, you can go to
-   https://github.com/expo/eas-cli/releases and mark it as not draft.
+1. Run `yarn release` in the repository root folder. This will create a new tag like `v1.0.0`.
+1. **Wait until the `release` GitHub workflow has finished.**
+1. Once the release is ready to go, you can go to https://github.com/expo/eas-cli/releases and mark it as not draft.
+   - Remember to copy the changelog entries from `CHANGELOG.md`.
 1. Run `yarn lerna publish from-git` in the repository root folder. This will publish the packages to npm.
+1. Update `CHANGELOG.md`.
+   - Add the new section with the release version in the title.
+   - Leave the `main` section empty (without any changelog entries).
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020-present 650 Industries, Inc. (aka Expo)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
@@ -1,5 +1,5 @@
 {
  "npmClient": "yarn",
  "useWorkspaces": true,
-  "version": "0.7.0"
+  "version": "0.11.0"
 }
@@ -6,6 +6,9 @@
  "scripts": {
    "build": "lerna run build",
    "build:tarballs:linux": "yarn build && yarn workspace eas-cli oclif-dev pack --targets linux-x64",
+    "typecheck": "lerna run typecheck",
+    "start": "lerna run watch --parallel",
+    "watch": "yarn start",
    "eas": "packages/eas-cli/bin/run",
    "lint": "eslint . --ext .ts",
    "release": "lerna version",
@@ -36,6 +36,7 @@ eas --help COMMAND
 * [`eas account:login`](#eas-accountlogin)
 * [`eas account:logout`](#eas-accountlogout)
 * [`eas account:view`](#eas-accountview)
+* [`eas analytics [STATUS]`](#eas-analytics-status)
 * [`eas build`](#eas-build)
 * [`eas build:cancel [BUILD_ID]`](#eas-buildcancel-build_id)
 * [`eas build:configure`](#eas-buildconfigure)
@@ -46,8 +47,15 @@ eas --help COMMAND
 * [`eas device:list`](#eas-devicelist)
 * [`eas device:view [UDID]`](#eas-deviceview-udid)
 * [`eas help [COMMAND]`](#eas-help-command)
-* [`eas secrets:list`](#eas-secretslist)
+* [`eas secret:create`](#eas-secretcreate)
+* [`eas secret:delete`](#eas-secretdelete)
+* [`eas secret:list`](#eas-secretlist)
 * [`eas submit --platform=(android|ios)`](#eas-submit---platformandroidios)
+* [`eas webhook:create`](#eas-webhookcreate)
+* [`eas webhook:delete [ID]`](#eas-webhookdelete-id)
+* [`eas webhook:list`](#eas-webhooklist)
+* [`eas webhook:update`](#eas-webhookupdate)
+* [`eas webhook:view ID`](#eas-webhookview-id)

 ## `eas account:login`

@@ -61,7 +69,7 @@ ALIASES
  $ eas login
 ```

-_See code: [build/commands/account/login.ts](https://github.com/expo/eas-cli/blob/v0.7.0/build/commands/account/login.ts)_
+_See code: [build/commands/account/login.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/account/login.ts)_

 ## `eas account:logout`

@@ -75,7 +83,7 @@ ALIASES
  $ eas logout
 ```

-_See code: [build/commands/account/logout.ts](https://github.com/expo/eas-cli/blob/v0.7.0/build/commands/account/logout.ts)_
+_See code: [build/commands/account/logout.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/account/logout.ts)_

 ## `eas account:view`

@@ -89,7 +97,18 @@ ALIASES
  $ eas whoami
 ```

-_See code: [build/commands/account/view.ts](https://github.com/expo/eas-cli/blob/v0.7.0/build/commands/account/view.ts)_
+_See code: [build/commands/account/view.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/account/view.ts)_
+
+## `eas analytics [STATUS]`
+
+View or change analytics settings
+
+```
+USAGE
+  $ eas analytics [STATUS]
+```
+
+_See code: [build/commands/analytics.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/analytics.ts)_

 ## `eas build`

@@ -101,6 +120,7 @@ USAGE

 OPTIONS
  -p, --platform=(android|ios|all)
+  --local                           Run build locally [experimental]
  --non-interactive                 Run command in --non-interactive mode
  --profile=profile                 [default: release] Name of the build profile from eas.json
  --skip-credentials-check          Skip validation of build credentials
@@ -108,7 +128,7 @@ OPTIONS
  --[no-]wait                       Wait for build(s) to complete
 ```

-_See code: [build/commands/build/index.ts](https://github.com/expo/eas-cli/blob/v0.7.0/build/commands/build/index.ts)_
+_See code: [build/commands/build/index.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/build/index.ts)_

 ## `eas build:cancel [BUILD_ID]`

@@ -119,7 +139,7 @@ USAGE
  $ eas build:cancel [BUILD_ID]
 ```

-_See code: [build/commands/build/cancel.ts](https://github.com/expo/eas-cli/blob/v0.7.0/build/commands/build/cancel.ts)_
+_See code: [build/commands/build/cancel.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/build/cancel.ts)_

 ## `eas build:configure`

@@ -134,7 +154,7 @@ OPTIONS
  --allow-experimental              Enable experimental configuration steps.
 ```

-_See code: [build/commands/build/configure.ts](https://github.com/expo/eas-cli/blob/v0.7.0/build/commands/build/configure.ts)_
+_See code: [build/commands/build/configure.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/build/configure.ts)_

 ## `eas build:list`

@@ -150,7 +170,7 @@ OPTIONS
  --status=(in-queue|in-progress|errored|finished|canceled)
 ```

-_See code: [build/commands/build/list.ts](https://github.com/expo/eas-cli/blob/v0.7.0/build/commands/build/list.ts)_
+_See code: [build/commands/build/list.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/build/list.ts)_

 ## `eas build:view [BUILD_ID]`

@@ -161,7 +181,7 @@ USAGE
  $ eas build:view [BUILD_ID]
 ```

-_See code: [build/commands/build/view.ts](https://github.com/expo/eas-cli/blob/v0.7.0/build/commands/build/view.ts)_
+_See code: [build/commands/build/view.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/build/view.ts)_

 ## `eas credentials`

@@ -172,7 +192,7 @@ USAGE
  $ eas credentials
 ```

-_See code: [build/commands/credentials.ts](https://github.com/expo/eas-cli/blob/v0.7.0/build/commands/credentials.ts)_
+_See code: [build/commands/credentials.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/credentials.ts)_

 ## `eas device:create`

@@ -183,7 +203,7 @@ USAGE
  $ eas device:create
 ```

-_See code: [build/commands/device/create.ts](https://github.com/expo/eas-cli/blob/v0.7.0/build/commands/device/create.ts)_
+_See code: [build/commands/device/create.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/device/create.ts)_

 ## `eas device:list`

@@ -197,7 +217,7 @@ OPTIONS
  --apple-team-id=apple-team-id
 ```

-_See code: [build/commands/device/list.ts](https://github.com/expo/eas-cli/blob/v0.7.0/build/commands/device/list.ts)_
+_See code: [build/commands/device/list.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/device/list.ts)_

 ## `eas device:view [UDID]`

@@ -208,7 +228,7 @@ USAGE
  $ eas device:view [UDID]
 ```

-_See code: [build/commands/device/view.ts](https://github.com/expo/eas-cli/blob/v0.7.0/build/commands/device/view.ts)_
+_See code: [build/commands/device/view.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/device/view.ts)_

 ## `eas help [COMMAND]`

@@ -227,16 +247,49 @@ OPTIONS

 _See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v3.2.0/src/commands/help.ts)_

-## `eas secrets:list`
+## `eas secret:create`
+
+Create an environment secret on the current project or owner account.
+
+```
+USAGE
+  $ eas secret:create
+
+OPTIONS
+  --name=name                Name of the secret
+  --scope=(account|project)  [default: project] Scope for the secret
+  --value=value              Value of the secret
+```
+
+_See code: [build/commands/secret/create.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/secret/create.ts)_
+
+## `eas secret:delete`
+
+Delete an environment secret by ID.
+
+```
+USAGE
+  $ eas secret:delete
+
+OPTIONS
+  --id=id  ID of the secret to delete
+
+DESCRIPTION
+  Unsure where to find the secret's ID? Run eas secrets:list
+```
+
+_See code: [build/commands/secret/delete.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/secret/delete.ts)_
+
+## `eas secret:list`

 Lists environment secrets available for your current app

 ```
 USAGE
-  $ eas secrets:list
+  $ eas secret:list
 ```

-_See code: [build/commands/secrets/list.ts](https://github.com/expo/eas-cli/blob/v0.7.0/build/commands/secrets/list.ts)_
+_See code: [build/commands/secret/list.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/secret/list.ts)_

 ## `eas submit --platform=(android|ios)`

@@ -262,7 +315,8 @@ OPTIONS

  iOS specific options=asc-app-id                                    App Store Connect unique application Apple ID
                                                                     number. Providing this param results in skipping
-                                                                     app creation step. Learn more.
+                                                                     app creation step. Learn more:
+                                                                     https://expo.fyi/asc-app-id

  iOS specific options=bundle-identifier                             Your iOS Bundle Identifier (default:
                                                                     expo.ios.bundleIdentifier from app config)
@@ -315,5 +369,86 @@ EXAMPLES
         and provide its App ID
 ```

-_See code: [build/commands/submit.ts](https://github.com/expo/eas-cli/blob/v0.7.0/build/commands/submit.ts)_
+_See code: [build/commands/submit.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/submit.ts)_
+
+## `eas webhook:create`
+
+Create a webhook on the current project.
+
+```
+USAGE
+  $ eas webhook:create
+
+OPTIONS
+  --event=(BUILD)  [default: BUILD] Event type that triggers the webhook
+
+  --secret=secret  Secret used to create a hash signature of the request payload, provided in the 'Expo-Signature'
+                   header.
+
+  --url=url        Webhook URL
+```
+
+_See code: [build/commands/webhook/create.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/webhook/create.ts)_
+
+## `eas webhook:delete [ID]`
+
+Delete a webhook on the current project.
+
+```
+USAGE
+  $ eas webhook:delete [ID]
+
+ARGUMENTS
+  ID  ID of the webhook to delete
+```
+
+_See code: [build/commands/webhook/delete.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/webhook/delete.ts)_
+
+## `eas webhook:list`
+
+List webhooks on the current project.
+
+```
+USAGE
+  $ eas webhook:list
+
+OPTIONS
+  --event=(BUILD)  Event type that triggers the webhook
+```
+
+_See code: [build/commands/webhook/list.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/webhook/list.ts)_
+
+## `eas webhook:update`
+
+Create a webhook on the current project.
+
+```
+USAGE
+  $ eas webhook:update
+
+OPTIONS
+  --event=(BUILD)  [default: BUILD] Event type that triggers the webhook
+  --id=id          (required) Webhook ID
+
+  --secret=secret  Secret used to create a hash signature of the request payload, provided in the 'Expo-Signature'
+                   header.
+
+  --url=url        Webhook URL
+```
+
+_See code: [build/commands/webhook/update.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/webhook/update.ts)_
+
+## `eas webhook:view ID`
+
+View a webhook on the current project.
+
+```
+USAGE
+  $ eas webhook:view ID
+
+ARGUMENTS
+  ID  ID of the webhook to view
+```
+
+_See code: [build/commands/webhook/view.ts](https://github.com/expo/eas-cli/blob/v0.11.0/build/commands/webhook/view.ts)_
 <!-- commandsstop -->
@@ -1,29 +1,33 @@
 {
  "name": "eas-cli",
  "description": "EAS command line tool",
-  "version": "0.7.0",
+  "version": "0.11.0",
  "author": "Expo <[email protected]>",
  "bin": {
    "eas": "./bin/run"
  },
  "bugs": "https://github.com/expo/eas-cli/issues",
  "dependencies": {
+    "@amplitude/identify": "^1.5.0",
+    "@amplitude/node": "^1.5.0",
    "@expo/apple-utils": "0.0.0-alpha.17",
    "@expo/config": "~3.3.19",
-    "@expo/config-plugins": "1.0.21-alpha.0",
-    "@expo/eas-build-job": "0.2.21",
-    "@expo/eas-json": "^0.7.0",
+    "@expo/config-plugins": "1.0.24",
+    "@expo/eas-build-job": "0.2.22",
+    "@expo/eas-json": "^0.11.0",
    "@expo/json-file": "^8.2.24",
    "@expo/plist": "^0.0.11",
    "@expo/plugin-warn-if-update-available": "^1.7.0",
    "@expo/results": "^1.0.0",
+    "@expo/sdk-runtime-versions": "^1.0.0",
    "@expo/spawn-async": "^1.5.0",
    "@hapi/joi": "^17.1.1",
    "@oclif/command": "^1",
    "@oclif/config": "^1",
    "@oclif/errors": "^1.3.3",
    "@oclif/plugin-help": "^3",
-    "@urql/core": "^1.13.0",
+    "@urql/core": "^2.0.0",
+    "@urql/exchange-retry": "^0.2.0",
    "chalk": "^4.1.0",
    "cli-table3": "^0.6.0",
    "dateformat": "^3.0.3",
@@ -39,7 +43,6 @@
    "indent-string": "^4.0.0",
    "keychain": "^1.3.0",
    "lodash": "^4.17.20",
-    "md5-file": "^5.0.0",
    "mime": "^2.4.7",
    "minimatch": "^3.0.4",
    "node-fetch": "^2.6.1",
@@ -161,7 +164,9 @@
  "scripts": {
    "postpack": "rm -f oclif.manifest.json",
    "prepack": "rm -rf build && yarn build && yarn oclif-dev manifest && yarn oclif-dev readme",
-    "build": "tsc",
+    "build": "tsc --project tsconfig.build.json",
+    "watch": "yarn build --watch --preserveWatchOutput",
+    "typecheck": "tsc",
    "test": "jest",
    "version": "yarn oclif-dev readme && git add README.md",
    "generate-graphql-code": "graphql-codegen --config graphql-codegen.yml"
@@ -21,7 +21,7 @@ describe('apiClient', () => {
        ],
      });

-    let error: Error;
+    let error: Error | null = null;
    try {
      await apiClient.post('test');
    } catch (e) {
@@ -41,7 +41,7 @@ describe('apiClient', () => {
  it('does not convert non-APIv2 error to ApiV2Error', async () => {
    nock(getExpoApiBaseUrl()).post('/--/api/v2/test').reply(500, 'Something went wrong');

-    let error: Error;
+    let error: Error | null = null;
    try {
      await apiClient.post('test');
    } catch (e) {
@@ -0,0 +1,101 @@
+import { Identify } from '@amplitude/identify';
+import * as Amplitude from '@amplitude/node';
+import os from 'os';
+import { v4 as uuidv4 } from 'uuid';
+
+import UserSettings from './user/UserSettings';
+
+/**
+ * We use require() to exclude package.json from TypeScript's analysis since it lives outside
+ * the src directory and would change the directory structure of the emitted files
+ * under the build directory
+ */
+const packageJSON = require('../package.json');
+
+const PLATFORM_TO_ANALYTICS_PLATFORM: { [platform: string]: string } = {
+  darwin: 'Mac',
+  win32: 'Windows',
+  linux: 'Linux',
+};
+
+let client: Amplitude.NodeClient | null = null;
+let userIdentifyCalled = false;
+let identifyData: {
+  userId: string;
+  deviceId: string;
+  identify: Identify;
+} | null = null;
+
+export async function initAsync(): Promise<void> {
+  if (process.env.DISABLE_EAS_ANALYTICS) {
+    await UserSettings.setAsync('amplitudeEnabled', false);
+  }
+  const amplitudeEnabled = await UserSettings.getAsync('amplitudeEnabled', true);
+  if (amplitudeEnabled) {
+    const apiKey =
+      process.env.EXPO_STAGING || process.env.EXPO_LOCAL
+        ? 'cdebbc678931403439486c4750781544'
+        : '4ac443afd5073c0df6169291db1d3495';
+    client = Amplitude.init(apiKey);
+  }
+}
+
+export async function setUserDataAsync(
+  userId: string,
+  properties: Record<string, any>
+): Promise<void> {
+  const identify = new Identify();
+  Object.entries(properties).forEach(([property, value]) => {
+    identify.set(property, value);
+  });
+  const savedDeviceId = await UserSettings.getAsync('amplitudeDeviceId', null);
+  const deviceId = savedDeviceId ?? uuidv4();
+  if (!savedDeviceId) {
+    await UserSettings.setAsync('amplitudeDeviceId', deviceId);
+  }
+  identifyData = {
+    userId,
+    deviceId,
+    identify,
+  };
+
+  ensureUserIdentified();
+}
+
+export async function flushAsync(): Promise<void> {
+  if (client) {
+    await client.flush();
+  }
+}
+
+export function logEvent(name: string, properties: Record<string, any> = {}) {
+  if (client) {
+    ensureUserIdentified();
+    const { userId, deviceId } = identifyData ?? {};
+    client.logEvent({
+      event_type: name,
+      event_properties: properties,
+      ...(userId && { user_id: userId }),
+      ...(deviceId && { device_id: deviceId }),
+      ...getContext(),
+    });
+  }
+}
+
+function ensureUserIdentified() {
+  if (client && !userIdentifyCalled && identifyData) {
+    client.identify(identifyData.userId, identifyData.deviceId, identifyData.identify);
+    userIdentifyCalled = true;
+  }
+}
+
+function getContext() {
+  const platform = PLATFORM_TO_ANALYTICS_PLATFORM[os.platform()] || os.platform();
+  return {
+    os_name: platform,
+    os_version: os.release(),
+    device_brand: platform,
+    device_model: platform,
+    app_version: packageJSON?.version,
+  };
+}
@@ -1,294 +0,0 @@
-import { Workflow } from '@expo/eas-build-job';
-import { CredentialsSource } from '@expo/eas-json';
-import prompts from 'prompts';
-
-import { asMock } from '../../__tests__/utils';
-import { CredentialsProvider } from '../../credentials/CredentialsProvider';
-import { ensureCredentialsAsync } from '../credentials';
-
-jest.mock('prompts');
-
-function createMockCredentialsProvider({
-  hasRemote,
-  hasLocal,
-  isLocalSynced,
-}: any): CredentialsProvider {
-  return {
-    platform: 'android',
-    hasRemoteAsync: jest.fn().mockImplementation(() => hasRemote || false),
-    hasLocalAsync: jest.fn().mockImplementation(() => hasLocal || false),
-    isLocalSyncedAsync: jest.fn().mockImplementation(() => isLocalSynced || false),
-  } as CredentialsProvider;
-}
-
-const originalConsoleLog = console.log;
-const originalConsoleWarn = console.warn;
-beforeAll(() => {
-  console.log = jest.fn();
-  console.warn = jest.fn();
-});
-afterAll(() => {
-  console.log = originalConsoleLog;
-  console.warn = originalConsoleWarn;
-});
-
-beforeEach(() => {
-  asMock(prompts).mockReset();
-  asMock(prompts).mockImplementation(() => {
-    throw new Error(`unhandled prompts call - this shouldn't happen - fix tests!`);
-  });
-});
-
-describe(ensureCredentialsAsync, () => {
-  describe('for generic builds', () => {
-    it("should use credentials.json if it's the only available credentials", async () => {
-      const provider = createMockCredentialsProvider({
-        hasRemote: false,
-        hasLocal: true,
-      });
-      const src = await ensureCredentialsAsync(
-        provider,
-        Workflow.GENERIC,
-        CredentialsSource.AUTO,
-        false
-      );
-      expect(src).toBe('local');
-    });
-    it("should use credentials from server if it's the only available credentials", async () => {
-      const provider = createMockCredentialsProvider({
-        hasRemote: true,
-        hasLocal: false,
-      });
-      const src = await ensureCredentialsAsync(
-        provider,
-        Workflow.GENERIC,
-        CredentialsSource.AUTO,
-        false
-      );
-      expect(src).toBe('remote');
-    });
-    it('should use credentials.json if credentials are the same in credentials.json and on server', async () => {
-      const provider = createMockCredentialsProvider({
-        hasRemote: true,
-        hasLocal: true,
-        isLocalSynced: true,
-      });
-      const src = await ensureCredentialsAsync(
-        provider,
-        Workflow.GENERIC,
-        CredentialsSource.AUTO,
-        false
-      );
-      expect(prompts).toHaveBeenCalledTimes(0);
-      expect(src).toBe('local');
-    });
-    it('should ask which credentials to use when local and remote crednitals have different values', async () => {
-      const provider = createMockCredentialsProvider({
-        hasRemote: true,
-        hasLocal: true,
-        isLocalSynced: false,
-      });
-      asMock(prompts).mockImplementationOnce(() => {
-        return { select: 'local' };
-      });
-      const src = await ensureCredentialsAsync(
-        provider,
-        Workflow.GENERIC,
-        CredentialsSource.AUTO,
-        false
-      );
-      expect(prompts).toHaveBeenCalledTimes(1);
-      expect(src).toBe('local');
-    });
-    it('should ask when local and remote are not the same (select remote)', async () => {
-      const provider = createMockCredentialsProvider({
-        hasRemote: true,
-        hasLocal: true,
-        isLocalSynced: false,
-      });
-      asMock(prompts).mockImplementationOnce(() => {
-        return { select: 'remote' };
-      });
-      const src = await ensureCredentialsAsync(
-        provider,
-        Workflow.GENERIC,
-        CredentialsSource.AUTO,
-        false
-      );
-      expect(prompts).toHaveBeenCalledTimes(1);
-      expect(src).toBe('remote');
-    });
-    it('should should throw an error when local and remote are not the same (in non interactive mode)', async () => {
-      const provider = createMockCredentialsProvider({
-        hasRemote: true,
-        hasLocal: true,
-        isLocalSynced: false,
-      });
-
-      try {
-        await ensureCredentialsAsync(provider, Workflow.GENERIC, CredentialsSource.AUTO, true);
-        throw new Error('ensureCredentialsAsync should throw an Error');
-      } catch (e) {
-        expect(e.message).toMatch(
-          'Contents of your local credentials.json for Android are not the same as credentials on EAS servers'
-        );
-      }
-
-      expect(prompts).toHaveBeenCalledTimes(0);
-    });
-    it('should ask when no credentials are present and return remote if confirm=true', async () => {
-      const provider = createMockCredentialsProvider({
-        hasRemote: false,
-        hasLocal: false,
-        isLocalSynced: false,
-      });
-      asMock(prompts).mockImplementationOnce(() => {
-        return { value: true }; //confirm
-      });
-      const src = await ensureCredentialsAsync(
-        provider,
-        Workflow.GENERIC,
-        CredentialsSource.AUTO,
-        false
-      );
-      expect(prompts).toHaveBeenCalledTimes(1);
-      expect(src).toBe('remote');
-    });
-    it('should ask when no credentials are present and abort if confimr=false', async () => {
-      const provider = createMockCredentialsProvider({
-        hasRemote: false,
-        hasLocal: false,
-        isLocalSynced: false,
-      });
-      asMock(prompts).mockImplementationOnce(() => {
-        return { value: false }; //confirm
-      });
-
-      try {
-        await ensureCredentialsAsync(provider, Workflow.GENERIC, CredentialsSource.AUTO, false);
-        throw new Error('ensureCredentialsAsync should throw an Error');
-      } catch (e) {
-        expect(e.message).toMatch(
-          'Aborting build process, credentials are not configured for Android'
-        );
-      }
-
-      expect(prompts).toHaveBeenCalledTimes(1);
-    });
-    it('should throw an error when no credentials are present in non interactive mode', async () => {
-      const provider = createMockCredentialsProvider({
-        hasRemote: false,
-        hasLocal: false,
-        isLocalSynced: false,
-      });
-      asMock(prompts).mockImplementation(() => {
-        return { value: true }; // confirm
-      });
-
-      try {
-        await ensureCredentialsAsync(provider, Workflow.GENERIC, CredentialsSource.AUTO, true);
-        throw new Error('ensureCredentialsAsync should throw an Error');
-      } catch (e) {
-        expect(e.message).toMatch('Credentials for this app are not configured');
-      }
-
-      expect(prompts).toHaveBeenCalledTimes(0);
-    });
-  });
-
-  describe('for managed builds', () => {
-    it("should use credentials.json if it's the only available credentials", async () => {
-      const provider = createMockCredentialsProvider({
-        hasRemote: false,
-        hasLocal: true,
-      });
-      const src = await ensureCredentialsAsync(
-        provider,
-        Workflow.MANAGED,
-        CredentialsSource.AUTO,
-        false
-      );
-      expect(src).toBe('local');
-    });
-    it("should use credentials from server if it's the only available credentials", async () => {
-      const provider = createMockCredentialsProvider({
-        hasRemote: true,
-        hasLocal: false,
-      });
-      const src = await ensureCredentialsAsync(
-        provider,
-        Workflow.MANAGED,
-        CredentialsSource.AUTO,
-        false
-      );
-      expect(src).toBe('remote');
-    });
-    it('should use credentials.json if credentials are the same in credentials.json and on server', async () => {
-      const provider = createMockCredentialsProvider({
-        hasRemote: true,
-        hasLocal: true,
-        isLocalSynced: true,
-      });
-      const src = await ensureCredentialsAsync(
-        provider,
-        Workflow.MANAGED,
-        CredentialsSource.AUTO,
-        false
-      );
-      expect(prompts).toHaveBeenCalledTimes(0);
-      expect(src).toBe('local');
-    });
-
-    it('should use credentials.json even if credentials on server are different', async () => {
-      const provider = createMockCredentialsProvider({
-        hasRemote: true,
-        hasLocal: true,
-        isLocalSynced: false,
-      });
-      const src = await ensureCredentialsAsync(
-        provider,
-        Workflow.MANAGED,
-        CredentialsSource.AUTO,
-        false
-      );
-      expect(prompts).toHaveBeenCalledTimes(0);
-      expect(src).toBe('local');
-    });
-  });
-
-  describe('generic builds with credentialsSource set to local', () => {
-    it('should use credentials.json without asking even if credentials on server are different', async () => {
-      const provider = createMockCredentialsProvider({
-        hasRemote: true,
-        hasLocal: true,
-        isLocalSynced: false,
-      });
-      const src = await ensureCredentialsAsync(
-        provider,
-        Workflow.GENERIC,
-        CredentialsSource.LOCAL,
-        false
-      );
-      expect(prompts).toHaveBeenCalledTimes(0);
-      expect(src).toBe('local');
-    });
-  });
-
-  describe('generic builds with credentialsSource set to remote', () => {
-    it('should use credentials from server even if credentials.json exists and have different values', async () => {
-      const provider = createMockCredentialsProvider({
-        hasRemote: true,
-        hasLocal: true,
-        isLocalSynced: false,
-      });
-      const src = await ensureCredentialsAsync(
-        provider,
-        Workflow.GENERIC,
-        CredentialsSource.REMOTE,
-        false
-      );
-      expect(prompts).toHaveBeenCalledTimes(0);
-      expect(src).toBe('remote');
-    });
-  });
-});
@@ -1,4 +1,4 @@
-import { Workflow } from '@expo/eas-build-job';
+import { Android, Metadata, Workflow } from '@expo/eas-build-job';
 import { EasConfig } from '@expo/eas-json';
 import chalk from 'chalk';
 import fs from 'fs-extra';
@@ -8,20 +8,23 @@ import AndroidCredentialsProvider, {
  AndroidCredentials,
 } from '../../credentials/android/AndroidCredentialsProvider';
 import { createCredentialsContextAsync } from '../../credentials/context';
+import { BuildMutation, BuildResult } from '../../graphql/mutations/BuildMutation';
 import Log from '../../log';
 import { toggleConfirmAsync } from '../../prompts';
 import { CredentialsResult, prepareBuildRequestForPlatformAsync } from '../build';
 import { BuildContext, CommandContext, createBuildContext } from '../context';
-import { ensureCredentialsAsync } from '../credentials';
+import { transformMetadata } from '../graphql';
 import { Platform } from '../types';
+import { logCredentialsSource } from '../utils/credentials';
 import { ensureApplicationIdIsValidAsync } from './applicationId';
 import { validateAndSyncProjectConfigurationAsync } from './configure';
+import { transformGenericJob, transformManagedJob } from './graphql';
 import { prepareJobAsync } from './prepareJob';

 export async function prepareAndroidBuildAsync(
  commandCtx: CommandContext,
  easConfig: EasConfig
-): Promise<() => Promise<string>> {
+): Promise<() => Promise<string | undefined>> {
  const buildCtx = createBuildContext<Platform.ANDROID>({
    commandCtx,
    platform: Platform.ANDROID,
@@ -72,6 +75,28 @@ This means that it will most likely produce an AAB and you will not be able to i
      }
    },
    prepareJobAsync,
+    sendBuildRequestAsync: async (
+      appId: string,
+      job: Android.Job,
+      metadata: Metadata
+    ): Promise<BuildResult> => {
+      const graphqlMetadata = transformMetadata(metadata);
+      if (job.type === Workflow.GENERIC) {
+        const graphqlJob = transformGenericJob(job);
+        return await BuildMutation.createAndroidGenericBuildAsync({
+          appId,
+          job: graphqlJob,
+          metadata: graphqlMetadata,
+        });
+      } else {
+        const graphqlJob = transformManagedJob(job);
+        return await BuildMutation.createAndroidManagedBuildAsync({
+          appId,
+          job: graphqlJob,
+          metadata: graphqlMetadata,
+        });
+      }
+    },
  });
 }

@@ -100,12 +125,8 @@ async function ensureAndroidCredentialsAsync(
      skipCredentialsCheck: ctx.commandCtx.skipCredentialsCheck,
    }
  );
-  const credentialsSource = await ensureCredentialsAsync(
-    provider,
-    ctx.buildProfile.workflow,
-    ctx.buildProfile.credentialsSource,
-    ctx.commandCtx.nonInteractive
-  );
+  const { credentialsSource } = ctx.buildProfile;
+  logCredentialsSource(credentialsSource, Platform.ANDROID);
  return {
    credentials: await provider.getCredentialsAsync(credentialsSource),
    source: credentialsSource,
@@ -0,0 +1,44 @@
+import { Android } from '@expo/eas-build-job';
+
+import {
+  AndroidGenericJobInput,
+  AndroidManagedBuildType,
+  AndroidManagedJobInput,
+} from '../../graphql/generated';
+import { transformProjectArchive } from '../graphql';
+
+export function transformGenericJob(job: Android.GenericJob): AndroidGenericJobInput {
+  return {
+    projectArchive: transformProjectArchive(job.projectArchive),
+    projectRootDirectory: job.projectRootDirectory,
+    releaseChannel: job.releaseChannel,
+    secrets: job.secrets,
+    builderEnvironment: job.builderEnvironment,
+    cache: job.cache,
+    gradleCommand: job.gradleCommand,
+    artifactPath: job.artifactPath,
+  };
+}
+
+export function transformManagedJob(job: Android.ManagedJob): AndroidManagedJobInput {
+  return {
+    projectArchive: transformProjectArchive(job.projectArchive),
+    projectRootDirectory: job.projectRootDirectory,
+    releaseChannel: job.releaseChannel,
+    secrets: job.secrets,
+    builderEnvironment: job.builderEnvironment,
+    cache: job.cache,
+    username: job.username,
+    buildType: transformBuildType(job.buildType),
+  };
+}
+
+function transformBuildType(buildType: Android.ManagedBuildType): AndroidManagedBuildType {
+  if (buildType === Android.ManagedBuildType.APK) {
+    return AndroidManagedBuildType.Apk;
+  } else if (buildType === Android.ManagedBuildType.APP_BUNDLE) {
+    return AndroidManagedBuildType.AppBundle;
+  } else {
+    return AndroidManagedBuildType.DevelopmentClient;
+  }
+}
@@ -1,24 +1,16 @@
-import {
-  Android,
-  ArchiveSource,
-  ArchiveSourceType,
-  Cache,
-  Job,
-  Workflow,
-  sanitizeJob,
-} from '@expo/eas-build-job';
+import { Android, ArchiveSource, Cache, Job, Workflow, sanitizeJob } from '@expo/eas-build-job';
 import { AndroidGenericBuildProfile, AndroidManagedBuildProfile } from '@expo/eas-json';
 import path from 'path';

 import { AndroidCredentials } from '../../credentials/android/AndroidCredentialsProvider';
-import { readSecretEnvsAsync } from '../../credentials/credentialsJson/read';
+import { readEnvironmentSecretsAsync } from '../../credentials/credentialsJson/read';
 import { getProjectAccountNameAsync } from '../../project/projectUtils';
 import { gitRootDirectoryAsync } from '../../utils/git';
 import { BuildContext } from '../context';
 import { Platform } from '../types';

 interface JobData {
-  archiveBucketKey: string;
+  projectArchive: ArchiveSource;
  credentials?: AndroidCredentials;
 }

@@ -41,12 +33,12 @@ interface CommonJobProperties {
  platform: Platform.ANDROID;
  projectArchive: ArchiveSource;
  builderEnvironment: Android.BuilderEnvironment;
-  cache: Cache | null;
+  cache: Cache;
  secrets: {
    buildCredentials?: {
      keystore: Android.Keystore;
    };
-    secretEnvs?: Record<string, string>;
+    environmentSecrets?: Record<string, string>;
  };
 }

@@ -54,7 +46,7 @@ async function prepareJobCommonAsync(
  ctx: BuildContext<Platform.ANDROID>,
  jobData: JobData
 ): Promise<Partial<CommonJobProperties>> {
-  const secretEnvs = await readSecretEnvsAsync(ctx.commandCtx.projectDir);
+  const environmentSecrets = await readEnvironmentSecretsAsync(ctx.commandCtx.projectDir);
  const credentials = jobData.credentials;
  const buildCredentials = credentials
    ? {
@@ -71,10 +63,7 @@ async function prepareJobCommonAsync(

  return {
    platform: Platform.ANDROID,
-    projectArchive: {
-      type: ArchiveSourceType.S3,
-      bucketKey: jobData.archiveBucketKey,
-    },
+    projectArchive: jobData.projectArchive,
    builderEnvironment: {
      image: ctx.buildProfile.image,
      node: ctx.buildProfile.node,
@@ -84,7 +73,7 @@ async function prepareJobCommonAsync(
    },
    cache: ctx.buildProfile.cache,
    secrets: {
-      ...(secretEnvs ? { secretEnvs } : {}),
+      ...(environmentSecrets ? { environmentSecrets } : {}),
      ...buildCredentials,
    },
  };
@@ -1,18 +1,20 @@
-import { Job } from '@expo/eas-build-job';
+import { ArchiveSource, ArchiveSourceType, Job, Metadata } from '@expo/eas-build-job';
 import { CredentialsSource } from '@expo/eas-json';
 import fs from 'fs-extra';

-import { apiClient } from '../api';
+import { UploadSessionType } from '../graphql/generated';
+import { BuildResult } from '../graphql/mutations/BuildMutation';
 import Log from '../log';
 import { promptAsync } from '../prompts';
-import { UploadType, uploadAsync } from '../uploads';
+import { uploadAsync } from '../uploads';
 import { formatBytes } from '../utils/files';
 import { createProgressTracker } from '../utils/progress';
-import { platformDisplayNames } from './constants';
+import { requestedPlatformDisplayNames } from './constants';
 import { BuildContext } from './context';
+import { runLocalBuildAsync } from './local';
 import { collectMetadata } from './metadata';
-import { AnalyticsEvent, Platform, TrackingContext } from './types';
-import Analytics from './utils/analytics';
+import { Platform, TrackingContext } from './types';
+import Analytics, { Event } from './utils/analytics';
 import { printDeprecationWarnings } from './utils/printBuildInfo';
 import {
  commitChangedFilesAsync,
@@ -27,7 +29,7 @@ export interface CredentialsResult<Credentials> {
  credentials: Credentials;
 }

-interface Builder<TPlatform extends Platform, Credentials, ProjectConfiguration> {
+interface Builder<TPlatform extends Platform, Credentials, ProjectConfiguration, TJob extends Job> {
  ctx: BuildContext<TPlatform>;
  projectConfiguration: ProjectConfiguration;

@@ -38,30 +40,34 @@ interface Builder<TPlatform extends Platform, Credentials, ProjectConfiguration>
  prepareJobAsync(
    ctx: BuildContext<TPlatform>,
    jobData: {
-      archiveBucketKey: string;
      credentials?: Credentials;
      projectConfiguration?: ProjectConfiguration;
+      projectArchive: ArchiveSource;
    }
  ): Promise<Job>;
+  sendBuildRequestAsync(appId: string, job: TJob, metadata: Metadata): Promise<BuildResult>;
 }

 export async function prepareBuildRequestForPlatformAsync<
  TPlatform extends Platform,
  Credentials,
-  ProjectConfiguration
->(builder: Builder<TPlatform, Credentials, ProjectConfiguration>): Promise<() => Promise<string>> {
+  ProjectConfiguration,
+  TJob extends Job
+>(
+  builder: Builder<TPlatform, Credentials, ProjectConfiguration, TJob>
+): Promise<() => Promise<string | undefined>> {
  const credentialsResult = await withAnalyticsAsync(
    async () => await builder.ensureCredentialsAsync(builder.ctx),
    {
-      successEvent: AnalyticsEvent.GATHER_CREDENTIALS_SUCCESS,
-      failureEvent: AnalyticsEvent.GATHER_CREDENTIALS_FAIL,
+      successEvent: Event.GATHER_CREDENTIALS_SUCCESS,
+      failureEvent: Event.GATHER_CREDENTIALS_FAIL,
      trackingCtx: builder.ctx.trackingCtx,
    }
  );
  if (!builder.ctx.commandCtx.skipProjectConfiguration) {
    await withAnalyticsAsync(async () => await builder.ensureProjectConfiguredAsync(builder.ctx), {
-      successEvent: AnalyticsEvent.CONFIGURE_PROJECT_SUCCESS,
-      failureEvent: AnalyticsEvent.CONFIGURE_PROJECT_FAIL,
+      successEvent: Event.CONFIGURE_PROJECT_SUCCESS,
+      failureEvent: Event.CONFIGURE_PROJECT_FAIL,
      trackingCtx: builder.ctx.trackingCtx,
    });
  }
@@ -69,55 +75,47 @@ export async function prepareBuildRequestForPlatformAsync<
  if (!(await isGitStatusCleanAsync())) {
    Log.addNewLineIfNone();
    await reviewAndCommitChangesAsync(
-      `[EAS Build] Run EAS Build for ${platformDisplayNames[builder.ctx.platform as Platform]}`,
+      `[EAS Build] Run EAS Build for ${
+        requestedPlatformDisplayNames[builder.ctx.platform as Platform]
+      }`,
      {
        nonInteractive: builder.ctx.commandCtx.nonInteractive,
      }
    );
  }

-  const archiveBucketKey = await uploadProjectAsync(builder.ctx);
+  const projectArchive = builder.ctx.commandCtx.local
+    ? ({
+        type: ArchiveSourceType.PATH,
+        path: (await makeProjectTarballAsync()).path,
+      } as const)
+    : ({
+        type: ArchiveSourceType.S3,
+        bucketKey: await uploadProjectAsync(builder.ctx),
+      } as const);

  const metadata = await collectMetadata(builder.ctx, {
    credentialsSource: credentialsResult?.source,
  });
  const job = await builder.prepareJobAsync(builder.ctx, {
-    archiveBucketKey,
+    projectArchive,
    credentials: credentialsResult?.credentials,
    projectConfiguration: builder.projectConfiguration,
  });

  return async () => {
-    try {
-      return await withAnalyticsAsync(
-        async () => {
-          if (Log.isDebug) {
-            Log.log(`Starting ${platformDisplayNames[job.platform]} build`);
-          }
-          const {
-            data: { buildId, deprecationInfo },
-          } = await apiClient
-            .post(`projects/${builder.ctx.commandCtx.projectId}/builds`, {
-              json: {
-                job,
-                metadata,
-              },
-            })
-            .json();
-          printDeprecationWarnings(deprecationInfo);
-          return buildId;
-        },
-        {
-          successEvent: AnalyticsEvent.BUILD_REQUEST_SUCCESS,
-          failureEvent: AnalyticsEvent.BUILD_REQUEST_FAIL,
-          trackingCtx: builder.ctx.trackingCtx,
+    if (builder.ctx.commandCtx.local) {
+      await runLocalBuildAsync(job);
+      return undefined;
+    } else {
+      try {
+        return sendBuildRequestAsync(builder, job, metadata);
+      } catch (error) {
+        if (error?.expoApiV2ErrorCode === 'TURTLE_DEPRECATED_JOB_FORMAT') {
+          Log.error('EAS Build API has changed, please upgrade to the latest eas-cli');
        }
-      );
-    } catch (error) {
-      if (error?.expoApiV2ErrorCode === 'TURTLE_DEPRECATED_JOB_FORMAT') {
-        Log.error('EAS Build API has changed, please upgrade to the latest eas-cli');
+        throw error;
      }
-      throw error;
    }
  };
 }
@@ -133,7 +131,7 @@ async function uploadProjectAsync<TPlatform extends Platform>(
        projectTarballPath = projectTarball.path;

        const { bucketKey } = await uploadAsync(
-          UploadType.TURTLE_PROJECT_SOURCES,
+          UploadSessionType.EasBuildProjectSources,
          projectTarball.path,
          createProgressTracker({
            total: projectTarball.size,
@@ -147,8 +145,8 @@ async function uploadProjectAsync<TPlatform extends Platform>(
        return bucketKey;
      },
      {
-        successEvent: AnalyticsEvent.PROJECT_UPLOAD_SUCCESS,
-        failureEvent: AnalyticsEvent.PROJECT_UPLOAD_FAIL,
+        successEvent: Event.PROJECT_UPLOAD_SUCCESS,
+        failureEvent: Event.PROJECT_UPLOAD_FAIL,
        trackingCtx: ctx.trackingCtx,
      }
    );
@@ -159,11 +157,45 @@ async function uploadProjectAsync<TPlatform extends Platform>(
  }
 }

+async function sendBuildRequestAsync<
+  TPlatform extends Platform,
+  Credentials,
+  ProjectConfiguration,
+  TJob extends Job
+>(
+  builder: Builder<TPlatform, Credentials, ProjectConfiguration, TJob>,
+  job: TJob,
+  metadata: Metadata
+): Promise<string> {
+  const { ctx } = builder;
+  return await withAnalyticsAsync(
+    async () => {
+      if (Log.isDebug) {
+        Log.log(`Starting ${requestedPlatformDisplayNames[job.platform]} build`);
+      }
+
+      const { build, deprecationInfo } = await builder.sendBuildRequestAsync(
+        ctx.commandCtx.projectId,
+        job,
+        metadata
+      );
+
+      printDeprecationWarnings(deprecationInfo);
+      return build.id;
+    },
+    {
+      successEvent: Event.BUILD_REQUEST_SUCCESS,
+      failureEvent: Event.BUILD_REQUEST_FAIL,
+      trackingCtx: ctx.trackingCtx,
+    }
+  );
+}
+
 async function withAnalyticsAsync<Result>(
  fn: () => Promise<Result>,
  analytics: {
-    successEvent: AnalyticsEvent;
-    failureEvent: AnalyticsEvent;
+    successEvent: Event;
+    failureEvent: Event;
    trackingCtx: TrackingContext;
  }
 ): Promise<Result> {
@@ -21,7 +21,7 @@ import {

 const configureCommitMessage = {
  [RequestedPlatform.Android]: 'Configure EAS Build for Android',
-  [RequestedPlatform.iOS]: 'Configure EAS Build for iOS',
+  [RequestedPlatform.Ios]: 'Configure EAS Build for iOS',
  [RequestedPlatform.All]: 'Configure EAS Build',
 };

@@ -44,7 +44,7 @@ export async function configureAsync(options: {
    shouldConfigureAndroid: [RequestedPlatform.All, RequestedPlatform.Android].includes(
      options.platform
    ),
-    shouldConfigureIos: [RequestedPlatform.All, RequestedPlatform.iOS].includes(options.platform),
+    shouldConfigureIos: [RequestedPlatform.All, RequestedPlatform.Ios].includes(options.platform),
    hasAndroidNativeProject: await fs.pathExists(path.join(options.projectDir, 'android')),
    hasIosNativeProject: await fs.pathExists(path.join(options.projectDir, 'ios')),
  };
@@ -1,12 +1,18 @@
-import { Platform, RequestedPlatform } from './types';
+import { AppPlatform } from '../graphql/generated';
+import { RequestedPlatform } from './types';

-export const platformDisplayNames = {
-  [RequestedPlatform.iOS]: 'iOS',
+export const requestedPlatformDisplayNames: Record<RequestedPlatform, string> = {
+  [RequestedPlatform.Ios]: 'iOS',
  [RequestedPlatform.Android]: 'Android',
  [RequestedPlatform.All]: 'Android and iOS',
 };

-export const platformEmojis = {
-  [Platform.IOS]: '🍎',
-  [Platform.ANDROID]: '🤖',
+export const appPlatformDisplayNames: Record<AppPlatform, string> = {
+  [AppPlatform.Android]: 'Android',
+  [AppPlatform.Ios]: 'iOS',
+};
+
+export const appPlatformEmojis = {
+  [AppPlatform.Ios]: '🍎',
+  [AppPlatform.Android]: '🤖',
 };
@@ -1,10 +1,13 @@
 import { ExpoConfig } from '@expo/config';
-import { AndroidBuildProfile, EasConfig, iOSBuildProfile } from '@expo/eas-json';
+import { AndroidBuildProfile, EasConfig, IosBuildProfile } from '@expo/eas-json';
+import { v4 as uuidv4 } from 'uuid';

 import { getProjectAccountName } from '../project/projectUtils';
+import { findAccountByName } from '../user/Account';
 import { Actor } from '../user/User';
 import { ensureLoggedInAsync } from '../user/actions';
 import { Platform, RequestedPlatform, TrackingContext } from './types';
+import Analytics, { Event } from './utils/analytics';

 export interface CommandContext {
  requestedPlatform: RequestedPlatform;
@@ -15,8 +18,8 @@ export interface CommandContext {
  accountName: string;
  projectName: string;
  exp: ExpoConfig;
-  trackingCtx: TrackingContext;
  nonInteractive: boolean;
+  local: boolean;
  skipCredentialsCheck: boolean;
  skipProjectConfiguration: boolean;
  waitForBuildEnd: boolean;
@@ -28,8 +31,8 @@ export async function createCommandContextAsync({
  exp,
  projectDir,
  projectId,
-  trackingCtx,
  nonInteractive = false,
+  local,
  skipCredentialsCheck = false,
  skipProjectConfiguration = false,
  waitForBuildEnd,
@@ -39,8 +42,8 @@ export async function createCommandContextAsync({
  exp: ExpoConfig;
  projectId: string;
  projectDir: string;
-  trackingCtx: TrackingContext;
  nonInteractive: boolean;
+  local: boolean;
  skipCredentialsCheck: boolean;
  skipProjectConfiguration: boolean;
  waitForBuildEnd: boolean;
@@ -58,8 +61,8 @@ export async function createCommandContextAsync({
    accountName,
    projectName,
    exp,
-    trackingCtx,
    nonInteractive,
+    local,
    skipCredentialsCheck,
    skipProjectConfiguration,
    waitForBuildEnd,
@@ -80,7 +83,7 @@ export interface ConfigureContext {

 type PlatformBuildProfile<T extends Platform> = T extends Platform.ANDROID
  ? AndroidBuildProfile
-  : iOSBuildProfile;
+  : IosBuildProfile;

 export interface BuildContext<T extends Platform> {
  commandCtx: CommandContext;
@@ -102,13 +105,20 @@ export function createBuildContext<T extends Platform>({
  if (!buildProfile) {
    throw new Error(`${platform} build profile does not exist`);
  }
-  const builderTrackingCtx = {
-    ...commandCtx.trackingCtx,
+
+  const accountId = findAccountByName(commandCtx.user.accounts, commandCtx.accountName)?.id;
+  const trackingCtx = {
+    tracking_id: uuidv4(),
    platform,
+    ...(accountId && { account_id: accountId }),
+    account_name: commandCtx.accountName,
+    project_id: commandCtx.projectId,
+    project_type: buildProfile.workflow,
  };
+  Analytics.logEvent(Event.BUILD_COMMAND, trackingCtx);
  return {
    commandCtx,
-    trackingCtx: builderTrackingCtx,
+    trackingCtx,
    platform,
    buildProfile,
  };
@@ -1,14 +1,16 @@
 import { EasJsonReader } from '@expo/eas-json';
 import chalk from 'chalk';
+import nullthrows from 'nullthrows';
 import ora from 'ora';

-import { apiClient } from '../api';
+import { BuildFragment, BuildStatus } from '../graphql/generated';
+import { BuildQuery } from '../graphql/queries/BuildQuery';
 import Log from '../log';
 import { sleep } from '../utils/promise';
 import { prepareAndroidBuildAsync } from './android/build';
 import { CommandContext } from './context';
 import { prepareIosBuildAsync } from './ios/build';
-import { Build, BuildStatus, Platform, RequestedPlatform } from './types';
+import { Platform, RequestedPlatform } from './types';
 import { printBuildResults, printLogsUrls } from './utils/printBuildInfo';
 import { ensureGitRepoExistsAsync, ensureGitStatusIsCleanAsync } from './utils/repository';

@@ -17,15 +19,15 @@ export async function buildAsync(commandCtx: CommandContext): Promise<void> {
  await ensureGitStatusIsCleanAsync(commandCtx.nonInteractive);

  const scheduledBuilds = await startBuildsAsync(commandCtx);
+  if (commandCtx.local) {
+    return;
+  }
  Log.newLine();
  printLogsUrls(commandCtx.accountName, scheduledBuilds);
  Log.newLine();

  if (commandCtx.waitForBuildEnd) {
-    const builds = await waitForBuildEndAsync(
-      commandCtx,
-      scheduledBuilds.map(i => i.buildId)
-    );
+    const builds = await waitForBuildEndAsync(scheduledBuilds.map(i => i.buildId));
    printBuildResults(commandCtx.accountName, builds);
    exitWithNonZeroCodeIfSomeBuildsFailed(builds);
  }
@@ -37,7 +39,7 @@ async function startBuildsAsync(
  const shouldBuildAndroid = [RequestedPlatform.Android, RequestedPlatform.All].includes(
    commandCtx.requestedPlatform
  );
-  const shouldBuildiOS = [RequestedPlatform.iOS, RequestedPlatform.All].includes(
+  const shouldBuildIos = [RequestedPlatform.Ios, RequestedPlatform.All].includes(
    commandCtx.requestedPlatform
  );
  const easConfig = await new EasJsonReader(
@@ -47,63 +49,61 @@ async function startBuildsAsync(

  const builds: {
    platform: Platform;
-    sendBuildRequestAsync: () => Promise<string>;
+    sendBuildRequestAsync: () => Promise<string | undefined>;
  }[] = [];
  if (shouldBuildAndroid) {
    const sendBuildRequestAsync = await prepareAndroidBuildAsync(commandCtx, easConfig);
    builds.push({ platform: Platform.ANDROID, sendBuildRequestAsync });
  }
-  if (shouldBuildiOS) {
+  if (shouldBuildIos) {
    const sendBuildRequestAsync = await prepareIosBuildAsync(commandCtx, easConfig);
    builds.push({ platform: Platform.IOS, sendBuildRequestAsync });
  }
-  return Promise.all(
-    builds.map(async ({ platform, sendBuildRequestAsync }) => ({
-      platform,
-      buildId: await sendBuildRequestAsync(),
-    }))
-  );
+  return (
+    await Promise.all(
+      builds.map(async ({ platform, sendBuildRequestAsync }) => ({
+        platform,
+        buildId: await sendBuildRequestAsync(),
+      }))
+    )
+  ).filter((build): build is { platform: Platform; buildId: string } => !!build.buildId);
 }

 async function waitForBuildEndAsync(
-  commandCtx: CommandContext,
  buildIds: string[],
  { timeoutSec = 1800, intervalSec = 30 } = {}
-): Promise<(Build | null)[]> {
+): Promise<(BuildFragment | null)[]> {
  Log.log('Waiting for build to complete. You can press Ctrl+C to exit.');
  const spinner = ora().start();
  let time = new Date().getTime();
  const endTime = time + timeoutSec * 1000;
  while (time <= endTime) {
-    const builds: (Build | null)[] = await Promise.all(
+    const builds: (BuildFragment | null)[] = await Promise.all(
      buildIds.map(async buildId => {
        try {
-          const { data } = await apiClient
-            .get(`projects/${commandCtx.projectId}/builds/${buildId}`)
-            .json();
-          return data;
+          return await BuildQuery.byIdAsync(buildId, { useCache: false });
        } catch (err) {
          return null;
        }
      })
    );
    if (builds.length === 1) {
-      const build = builds[0] as Build;
+      const build = nullthrows(builds[0]);
      switch (build.status) {
-        case BuildStatus.FINISHED:
+        case BuildStatus.Finished:
          spinner.succeed('Build finished');
          return builds;
-        case BuildStatus.IN_QUEUE:
+        case BuildStatus.InQueue:
          spinner.text = 'Build queued...';
          break;
-        case BuildStatus.CANCELED:
+        case BuildStatus.Canceled:
          spinner.text = 'Build canceled';
          spinner.stopAndPersist();
          return builds;
-        case BuildStatus.IN_PROGRESS:
+        case BuildStatus.InProgress:
          spinner.text = 'Build in progress...';
          break;
-        case BuildStatus.ERRORED:
+        case BuildStatus.Errored:
          spinner.fail('Build failed');
          if (build.error) {
            return builds;
@@ -115,13 +115,13 @@ async function waitForBuildEndAsync(
          throw new Error(`Unknown status: ${builds} - aborting!`);
      }
    } else {
-      if (builds.filter(build => build?.status === BuildStatus.FINISHED).length === builds.length) {
+      if (builds.filter(build => build?.status === BuildStatus.Finished).length === builds.length) {
        spinner.succeed('All builds have finished');
        return builds;
      } else if (
        builds.filter(build =>
          build?.status
-            ? [BuildStatus.FINISHED, BuildStatus.ERRORED, BuildStatus.CANCELED].includes(
+            ? [BuildStatus.Finished, BuildStatus.Errored, BuildStatus.Canceled].includes(
                build.status
              )
            : false
@@ -130,11 +130,11 @@ async function waitForBuildEndAsync(
        spinner.fail('Some of the builds were canceled or failed.');
        return builds;
      } else {
-        const inQueue = builds.filter(build => build?.status === BuildStatus.IN_QUEUE).length;
-        const inProgress = builds.filter(build => build?.status === BuildStatus.IN_PROGRESS).length;
-        const errored = builds.filter(build => build?.status === BuildStatus.ERRORED).length;
-        const finished = builds.filter(build => build?.status === BuildStatus.FINISHED).length;
-        const canceled = builds.filter(build => build?.status === BuildStatus.CANCELED).length;
+        const inQueue = builds.filter(build => build?.status === BuildStatus.InQueue).length;
+        const inProgress = builds.filter(build => build?.status === BuildStatus.InProgress).length;
+        const errored = builds.filter(build => build?.status === BuildStatus.Errored).length;
+        const finished = builds.filter(build => build?.status === BuildStatus.Finished).length;
+        const canceled = builds.filter(build => build?.status === BuildStatus.Canceled).length;
        const unknownState = builds.length - inQueue - inProgress - errored - finished;
        spinner.text = [
          inQueue && `Builds in queue: ${inQueue}`,
@@ -157,8 +157,10 @@ async function waitForBuildEndAsync(
  );
 }

-function exitWithNonZeroCodeIfSomeBuildsFailed(maybeBuilds: (Build | null)[]): void {
-  const failedBuilds = (maybeBuilds.filter(i => i) as Build[]).filter(i => i.status === 'errored');
+function exitWithNonZeroCodeIfSomeBuildsFailed(maybeBuilds: (BuildFragment | null)[]): void {
+  const failedBuilds = (maybeBuilds.filter(i => i) as BuildFragment[]).filter(
+    i => i.status === BuildStatus.Errored
+  );
  if (failedBuilds.length > 0) {
    process.exit(1);
  }
@@ -1,104 +0,0 @@
-import { Platform, Workflow } from '@expo/eas-build-job';
-import { CredentialsSource } from '@expo/eas-json';
-import chalk from 'chalk';
-
-import { CredentialsProvider } from '../credentials/CredentialsProvider';
-import Log from '../log';
-import { confirmAsync, promptAsync } from '../prompts';
-import { platformDisplayNames } from './constants';
-
-function logCredentials(target: 'local' | 'remote', platform: Platform) {
-  let message = `Using ${target} ${platformDisplayNames[platform]} credentials`;
-  if (target === 'local') message += ` ${chalk.dim('(credentials.json)')}`;
-  if (target === 'remote') message += ` ${chalk.dim('(Expo server)')}`;
-  Log.succeed(message);
-}
-
-async function ensureCredentialsAutoAsync(
-  provider: CredentialsProvider,
-  workflow: Workflow,
-  nonInteractive: boolean
-): Promise<CredentialsSource.LOCAL | CredentialsSource.REMOTE> {
-  const platform = platformDisplayNames[provider.platform];
-  switch (workflow) {
-    case Workflow.MANAGED:
-      if (await provider.hasLocalAsync()) {
-        return CredentialsSource.LOCAL;
-      } else {
-        return CredentialsSource.REMOTE;
-      }
-    case Workflow.GENERIC: {
-      const hasLocal = await provider.hasLocalAsync();
-      const hasRemote = await provider.hasRemoteAsync();
-      if (hasRemote && hasLocal) {
-        if (!(await provider.isLocalSyncedAsync())) {
-          if (nonInteractive) {
-            throw new Error(
-              `Contents of your local credentials.json for ${platform} are not the same as credentials on EAS servers. To use the desired credentials, set the "builds.${platform}.{profile}.credentialsSource" field in the credentials.json file to one of the following: "local", "remote".`
-            );
-          } else {
-            Log.log(
-              `Contents of your local credentials.json for ${platform} are not the same as credentials on EAS servers`
-            );
-          }
-
-          const { select } = await promptAsync({
-            type: 'select',
-            name: 'select',
-            message: 'Which credentials do you want to use for this build?',
-            choices: [
-              { title: 'Local credentials.json', value: CredentialsSource.LOCAL },
-              { title: 'Credentials stored on EAS servers.', value: CredentialsSource.REMOTE },
-            ],
-          });
-          return select;
-        } else {
-          return CredentialsSource.LOCAL;
-        }
-      } else if (hasLocal) {
-        logCredentials('local', provider.platform);
-        return CredentialsSource.LOCAL;
-      } else if (hasRemote) {
-        logCredentials('remote', provider.platform);
-        return CredentialsSource.REMOTE;
-      } else {
-        if (nonInteractive) {
-          throw new Error(
-            `Credentials for this app are not configured and there is no entry in credentials.json for ${platform}. Either configure credentials.json, or launch the build without "--non-interactive" flag to get a prompt to generate credentials automatically.`
-          );
-        } else if (Log.isDebug) {
-          Log.warn(
-            `Credentials for this app are not configured and there is no entry in credentials.json for ${platform}`
-          );
-        }
-
-        const confirm = await confirmAsync({
-          message: `${platform} credentials not found, generate now?`,
-        });
-        if (confirm) {
-          return CredentialsSource.REMOTE;
-        } else {
-          throw new Error(`Aborting build process, credentials are not configured for ${platform}`);
-        }
-      }
-    }
-  }
-}
-
-export async function ensureCredentialsAsync(
-  provider: CredentialsProvider,
-  workflow: Workflow,
-  src: CredentialsSource,
-  nonInteractive: boolean
-): Promise<CredentialsSource.LOCAL | CredentialsSource.REMOTE> {
-  switch (src) {
-    case CredentialsSource.LOCAL:
-      logCredentials('local', provider.platform);
-      return CredentialsSource.LOCAL;
-    case CredentialsSource.REMOTE:
-      logCredentials('remote', provider.platform);
-      return CredentialsSource.REMOTE;
-    case CredentialsSource.AUTO:
-      return await ensureCredentialsAutoAsync(provider, workflow, nonInteractive);
-  }
-}
@@ -0,0 +1,72 @@
+import { ArchiveSource, ArchiveSourceType, Metadata, Workflow } from '@expo/eas-build-job';
+
+import {
+  BuildCredentialsSource,
+  BuildMetadataInput,
+  BuildWorkflow,
+  DistributionType,
+  ProjectArchiveSourceInput,
+  ProjectArchiveSourceType,
+} from '../graphql/generated';
+
+export function transformProjectArchive(archiveSource: ArchiveSource): ProjectArchiveSourceInput {
+  if (archiveSource.type === ArchiveSourceType.S3) {
+    return {
+      type: ProjectArchiveSourceType.S3,
+      bucketKey: archiveSource.bucketKey,
+    };
+  } else if (archiveSource.type === ArchiveSourceType.URL) {
+    return {
+      type: ProjectArchiveSourceType.Url,
+      url: archiveSource.url,
+    };
+  } else {
+    throw new Error(`Unsupported project archive source type: '${archiveSource.type}'`);
+  }
+}
+
+export function transformMetadata(metadata: Metadata): BuildMetadataInput {
+  return {
+    appIdentifier: metadata.appIdentifier,
+    appName: metadata.appName,
+    appVersion: metadata.appVersion,
+    buildProfile: metadata.buildProfile,
+    cliVersion: metadata.cliVersion,
+    credentialsSource:
+      metadata.credentialsSource && transformCredentialsSource(metadata.credentialsSource),
+    distribution: metadata.distribution && transformDistribution(metadata.distribution),
+    gitCommitHash: metadata.gitCommitHash,
+    releaseChannel: metadata.releaseChannel,
+    sdkVersion: metadata.sdkVersion,
+    trackingContext: metadata.trackingContext,
+    workflow: metadata.workflow && transformWorkflow(metadata.workflow),
+  };
+}
+
+function transformCredentialsSource(
+  credentialsSource: Metadata['credentialsSource']
+): BuildCredentialsSource {
+  if (credentialsSource === 'local') {
+    return BuildCredentialsSource.Local;
+  } else {
+    return BuildCredentialsSource.Remote;
+  }
+}
+
+function transformDistribution(distribution: Metadata['distribution']): DistributionType {
+  if (distribution === 'internal') {
+    return DistributionType.Internal;
+  } else if (distribution === 'simulator') {
+    return DistributionType.Simulator;
+  } else {
+    return DistributionType.Store;
+  }
+}
+
+function transformWorkflow(workflow: Metadata['workflow']): BuildWorkflow {
+  if (workflow === Workflow.GENERIC) {
+    return BuildWorkflow.Generic;
+  } else {
+    return BuildWorkflow.Managed;
+  }
+}
@@ -1,4 +1,5 @@
 import { ExpoConfig } from '@expo/config';
+import { IOSConfig } from '@expo/config-plugins';
 import fs from 'fs-extra';
 import { vol } from 'memfs';
 import os from 'os';
@@ -38,9 +39,11 @@ describe(bumpVersionAsync, () => {
    });

    const appJSON = await fs.readJSON('/repo/app.json');
-    const infoPlist = await readPlistAsync('/repo/ios/myproject/Info.plist');
+    const infoPlist = (await readPlistAsync(
+      '/repo/ios/myproject/Info.plist'
+    )) as IOSConfig.InfoPlist;
    expect(fakeExp.version).toBe('1.0.0');
-    expect(fakeExp.ios.buildNumber).toBe('2');
+    expect(fakeExp.ios?.buildNumber).toBe('2');
    expect(appJSON.expo.version).toBe('1.0.0');
    expect(appJSON.expo.ios.buildNumber).toBe('2');
    expect(infoPlist['CFBundleShortVersionString']).toBe('1.0.0');
@@ -57,9 +60,11 @@ describe(bumpVersionAsync, () => {
    });

    const appJSON = await fs.readJSON('/repo/app.json');
-    const infoPlist = await readPlistAsync('/repo/ios/myproject/Info.plist');
+    const infoPlist = (await readPlistAsync(
+      '/repo/ios/myproject/Info.plist'
+    )) as IOSConfig.InfoPlist;
    expect(fakeExp.version).toBe('1.0.1');
-    expect(fakeExp.ios.buildNumber).toBe('1');
+    expect(fakeExp.ios?.buildNumber).toBe('1');
    expect(appJSON.expo.version).toBe('1.0.1');
    expect(appJSON.expo.ios.buildNumber).toBe('1');
    expect(infoPlist['CFBundleShortVersionString']).toBe('1.0.1');
@@ -76,9 +81,11 @@ describe(bumpVersionAsync, () => {
    });

    const appJSON = await fs.readJSON('/repo/app.json');
-    const infoPlist = await readPlistAsync('/repo/ios/myproject/Info.plist');
+    const infoPlist = (await readPlistAsync(
+      '/repo/ios/myproject/Info.plist'
+    )) as IOSConfig.InfoPlist;
    expect(fakeExp.version).toBe('1.0.0');
-    expect(fakeExp.ios.buildNumber).toBe('1');
+    expect(fakeExp.ios?.buildNumber).toBe('1');
    expect(appJSON.expo.version).toBe('1.0.0');
    expect(appJSON.expo.ios.buildNumber).toBe('1');
    expect(infoPlist['CFBundleShortVersionString']).toBe('1.0.0');
@@ -99,7 +106,7 @@ describe(bumpVersionInAppJsonAsync, () => {

    const appJSON = await fs.readJSON('/repo/app.json');
    expect(fakeExp.version).toBe('1.0.0');
-    expect(fakeExp.ios.buildNumber).toBe('2');
+    expect(fakeExp.ios?.buildNumber).toBe('2');
    expect(appJSON.expo.version).toBe('1.0.0');
    expect(appJSON.expo.ios.buildNumber).toBe('2');
  });
@@ -115,7 +122,7 @@ describe(bumpVersionInAppJsonAsync, () => {

    const appJSON = await fs.readJSON('/repo/app.json');
    expect(fakeExp.version).toBe('1.0.1');
-    expect(fakeExp.ios.buildNumber).toBe('1');
+    expect(fakeExp.ios?.buildNumber).toBe('1');
    expect(appJSON.expo.version).toBe('1.0.1');
    expect(appJSON.expo.ios.buildNumber).toBe('1');
  });
@@ -131,7 +138,7 @@ describe(bumpVersionInAppJsonAsync, () => {

    const appJSON = await fs.readJSON('/repo/app.json');
    expect(fakeExp.version).toBe('1.0.0');
-    expect(fakeExp.ios.buildNumber).toBe('1');
+    expect(fakeExp.ios?.buildNumber).toBe('1');
    expect(appJSON.expo.version).toBe('1.0.0');
    expect(appJSON.expo.ios.buildNumber).toBe('1');
  });
@@ -1,25 +1,28 @@
 import { IOSConfig } from '@expo/config-plugins';
-import { Workflow } from '@expo/eas-build-job';
+import { Ios, Metadata, Workflow } from '@expo/eas-build-job';
 import { EasConfig } from '@expo/eas-json';
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import sortBy from 'lodash/sortBy';
 import path from 'path';

+import { BuildMutation, BuildResult } from '../../graphql/mutations/BuildMutation';
 import Log from '../../log';
 import { promptAsync } from '../../prompts';
 import { prepareBuildRequestForPlatformAsync } from '../build';
 import { BuildContext, CommandContext, createBuildContext } from '../context';
+import { transformMetadata } from '../graphql';
 import { Platform } from '../types';
 import { ensureBundleIdentifierIsValidAsync } from './bundleIdentifer';
 import { validateAndSyncProjectConfigurationAsync } from './configure';
 import { ensureIosCredentialsAsync } from './credentials';
+import { transformGenericJob, transformManagedJob } from './graphql';
 import { prepareJobAsync, sanitizedTargetName } from './prepareJob';

 export async function prepareIosBuildAsync(
  commandCtx: CommandContext,
  easConfig: EasConfig
-): Promise<() => Promise<string>> {
+): Promise<() => Promise<string | undefined>> {
  const buildCtx = createBuildContext<Platform.IOS>({
    commandCtx,
    platform: Platform.IOS,
@@ -72,6 +75,28 @@ export async function prepareIosBuildAsync(
      });
    },
    prepareJobAsync,
+    sendBuildRequestAsync: async (
+      appId: string,
+      job: Ios.Job,
+      metadata: Metadata
+    ): Promise<BuildResult> => {
+      const graphqlMetadata = transformMetadata(metadata);
+      if (job.type === Workflow.GENERIC) {
+        const graphqlJob = transformGenericJob(job);
+        return await BuildMutation.createIosGenericBuildAsync({
+          appId,
+          job: graphqlJob,
+          metadata: graphqlMetadata,
+        });
+      } else {
+        const graphqlJob = transformManagedJob(job);
+        return await BuildMutation.createIosManagedBuildAsync({
+          appId,
+          job: graphqlJob,
+          metadata: graphqlMetadata,
+        });
+      }
+    },
  });
 }

@@ -3,9 +3,9 @@ import { IOSConfig } from '@expo/config-plugins';
 import { Workflow } from '@expo/eas-build-job';
 import {
  EasJsonReader,
+  IosBuildProfile,
+  IosGenericBuildProfile,
  VersionAutoIncrement,
-  iOSBuildProfile,
-  iOSGenericBuildProfile,
 } from '@expo/eas-json';

 import Log from '../../log';
@@ -44,13 +44,13 @@ export async function validateAndSyncProjectConfigurationAsync({
 }: {
  projectDir: string;
  exp: ExpoConfig;
-  buildProfile: iOSBuildProfile;
+  buildProfile: IosBuildProfile;
 }): Promise<void> {
  const { workflow, autoIncrement } = buildProfile;
  const versionBumpStrategy = resolveVersionBumpStrategy(autoIncrement);

  if (workflow === Workflow.GENERIC) {
-    const genericBuildProfile = buildProfile as iOSGenericBuildProfile;
+    const genericBuildProfile = buildProfile as IosGenericBuildProfile;
    if (!genericBuildProfile.disableIosBundleIdentifierValidation) {
      const bundleIdentifierFromPbxproj = IOSConfig.BundleIdentifier.getBundleIdentifierFromPbxproj(
        projectDir
@@ -1,16 +1,17 @@
 import { Workflow } from '@expo/eas-build-job';
-import { CredentialsSource, iOSDistributionType } from '@expo/eas-json';
+import { CredentialsSource, IosDistributionType, IosEnterpriseProvisioning } from '@expo/eas-json';
 import assert from 'assert';

 import { createCredentialsContextAsync } from '../../credentials/context';
 import IosCredentialsProvider, {
  IosCredentials,
 } from '../../credentials/ios/IosCredentialsProvider';
+import { getAppLookupParamsFromContext } from '../../credentials/ios/actions/new/BuildCredentialsUtils';
 import { AppLookupParams } from '../../credentials/ios/credentials';
 import { CredentialsResult } from '../build';
 import { BuildContext } from '../context';
-import { ensureCredentialsAsync } from '../credentials';
 import { Platform } from '../types';
+import { logCredentialsSource } from '../utils/credentials';

 export async function ensureIosCredentialsAsync(
  ctx: BuildContext<Platform.IOS>
@@ -28,6 +29,7 @@ export async function ensureIosCredentialsAsync(
    workflow: ctx.buildProfile.workflow,
    credentialsSource: ctx.buildProfile.credentialsSource,
    distribution: ctx.buildProfile.distribution ?? 'store',
+    enterpriseProvisioning: ctx.buildProfile.enterpriseProvisioning,
    nonInteractive: ctx.commandCtx.nonInteractive,
    skipCredentialsCheck: ctx.commandCtx.skipCredentialsCheck,
  });
@@ -37,7 +39,8 @@ interface ResolveCredentialsParams {
  app: AppLookupParams;
  workflow: Workflow;
  credentialsSource: CredentialsSource;
-  distribution: iOSDistributionType;
+  distribution: IosDistributionType;
+  enterpriseProvisioning?: IosEnterpriseProvisioning;
  nonInteractive: boolean;
  skipCredentialsCheck: boolean;
 }
@@ -46,22 +49,18 @@ export async function resolveIosCredentialsAsync(
  projectDir: string,
  params: ResolveCredentialsParams
 ): Promise<CredentialsResult<IosCredentials>> {
-  const provider = new IosCredentialsProvider(
-    await createCredentialsContextAsync(projectDir, {
-      nonInteractive: params.nonInteractive,
-    }),
-    {
-      app: params.app,
-      distribution: params.distribution,
-      skipCredentialsCheck: params.skipCredentialsCheck,
-    }
-  );
-  const credentialsSource = await ensureCredentialsAsync(
-    provider,
-    params.workflow,
-    params.credentialsSource,
-    params.nonInteractive
-  );
+  const ctx = await createCredentialsContextAsync(projectDir, {
+    nonInteractive: params.nonInteractive,
+  });
+  const app = getAppLookupParamsFromContext(ctx);
+  const provider = new IosCredentialsProvider(ctx, {
+    app,
+    distribution: params.distribution,
+    enterpriseProvisioning: params.enterpriseProvisioning,
+    skipCredentialsCheck: params.skipCredentialsCheck,
+  });
+  const { credentialsSource } = params;
+  logCredentialsSource(credentialsSource, Platform.IOS);
  return {
    credentials: await provider.getCredentialsAsync(credentialsSource),
    source: credentialsSource,
@@ -0,0 +1,93 @@
+import { Env, Ios } from '@expo/eas-build-job';
+import nullthrows from 'nullthrows';
+
+import {
+  DistributionType,
+  IosGenericJobInput,
+  IosJobSecretsInput,
+  IosManagedBuildType,
+  IosManagedJobInput,
+  IosSchemeBuildConfiguration,
+} from '../../graphql/generated';
+import { transformProjectArchive } from '../graphql';
+
+export function transformGenericJob(job: Ios.GenericJob): IosGenericJobInput {
+  return {
+    projectArchive: transformProjectArchive(job.projectArchive),
+    projectRootDirectory: job.projectRootDirectory,
+    releaseChannel: job.releaseChannel,
+    distribution: job.distribution && transformDistributionType(job.distribution),
+    secrets: transformIosSecrets(job.secrets),
+    builderEnvironment: job.builderEnvironment,
+    cache: job.cache,
+    scheme: job.scheme,
+    schemeBuildConfiguration:
+      job.schemeBuildConfiguration &&
+      transformSchemeBuildConfiguration(job.schemeBuildConfiguration),
+    artifactPath: job.artifactPath,
+  };
+}
+
+export function transformManagedJob(job: Ios.ManagedJob): IosManagedJobInput {
+  return {
+    projectArchive: transformProjectArchive(job.projectArchive),
+    projectRootDirectory: job.projectRootDirectory,
+    releaseChannel: job.releaseChannel,
+    distribution: job.distribution && transformDistributionType(job.distribution),
+    secrets: transformIosSecrets(job.secrets),
+    builderEnvironment: job.builderEnvironment,
+    cache: job.cache,
+    buildType: job.buildType && transformBuildType(job.buildType),
+    username: job.username,
+  };
+}
+
+function transformDistributionType(distributionType: Ios.DistributionType): DistributionType {
+  if (distributionType === 'store') {
+    return DistributionType.Store;
+  } else if (distributionType === 'internal') {
+    return DistributionType.Internal;
+  } else {
+    return DistributionType.Simulator;
+  }
+}
+
+function transformIosSecrets(secrets: {
+  buildCredentials?: Ios.BuildCredentials;
+  env?: Env;
+}): IosJobSecretsInput {
+  const buildCredentials: IosJobSecretsInput['buildCredentials'] = [];
+
+  for (const targetName of Object.keys(secrets.buildCredentials ?? {})) {
+    buildCredentials.push({
+      targetName,
+      provisioningProfileBase64: nullthrows(secrets.buildCredentials?.[targetName])
+        .provisioningProfileBase64,
+      distributionCertificate: nullthrows(secrets.buildCredentials?.[targetName])
+        .distributionCertificate,
+    });
+  }
+
+  return {
+    buildCredentials,
+    environmentSecrets: secrets.env,
+  };
+}
+
+function transformSchemeBuildConfiguration(
+  schemeBuildConfiguration: Ios.SchemeBuildConfiguration
+): IosSchemeBuildConfiguration {
+  if (schemeBuildConfiguration === Ios.SchemeBuildConfiguration.DEBUG) {
+    return IosSchemeBuildConfiguration.Debug;
+  } else {
+    return IosSchemeBuildConfiguration.Release;
+  }
+}
+
+function transformBuildType(buildType: Ios.ManagedBuildType): IosManagedBuildType {
+  if (buildType === Ios.ManagedBuildType.DEVELOPMENT_CLIENT) {
+    return IosManagedBuildType.DevelopmentClient;
+  } else {
+    return IosManagedBuildType.Release;
+  }
+}
@@ -1,13 +1,5 @@
-import {
-  ArchiveSource,
-  ArchiveSourceType,
-  Cache,
-  Ios,
-  Job,
-  Workflow,
-  sanitizeJob,
-} from '@expo/eas-build-job';
-import { iOSGenericBuildProfile, iOSManagedBuildProfile } from '@expo/eas-json';
+import { ArchiveSource, Cache, Ios, Job, Workflow, sanitizeJob } from '@expo/eas-build-job';
+import { IosGenericBuildProfile, IosManagedBuildProfile } from '@expo/eas-json';
 import assert from 'assert';
 import path from 'path';

@@ -15,7 +7,7 @@ import {
  IosCredentials,
  IosTargetCredentials,
  isCredentialsMap,
-  readSecretEnvsAsync,
+  readEnvironmentSecretsAsync,
 } from '../../credentials/credentialsJson/read';
 import { getProjectAccountNameAsync } from '../../project/projectUtils';
 import { gitRootDirectoryAsync } from '../../utils/git';
@@ -23,7 +15,7 @@ import { BuildContext } from '../context';
 import { Platform } from '../types';

 interface JobData {
-  archiveBucketKey: string;
+  projectArchive: ArchiveSource;
  credentials?: IosCredentials;
  projectConfiguration: {
    iosBuildScheme?: string;
@@ -52,22 +44,22 @@ interface CommonJobProperties {
  builderEnvironment: Ios.BuilderEnvironment;
  releaseChannel?: string;
  distribution?: Ios.DistributionType;
-  cache: Cache | null;
+  cache: Cache;
  secrets: {
    buildCredentials: Ios.BuildCredentials;
-    secretEnvs?: Record<string, string>;
+    environmentSecrets?: Record<string, string>;
  };
 }

 async function prepareJobCommonAsync(
  ctx: BuildContext<Platform.IOS>,
  {
-    archiveBucketKey,
    credentials,
    targetName,
-  }: { archiveBucketKey: string; credentials?: IosCredentials; targetName?: string }
+    projectArchive,
+  }: { credentials?: IosCredentials; targetName?: string; projectArchive: ArchiveSource }
 ): Promise<Partial<CommonJobProperties>> {
-  const secretEnvs = await readSecretEnvsAsync(ctx.commandCtx.projectDir);
+  const environmentSecrets = await readEnvironmentSecretsAsync(ctx.commandCtx.projectDir);

  let buildCredentials: CommonJobProperties['secrets']['buildCredentials'] = {};
  if (credentials && isCredentialsMap(credentials)) {
@@ -87,10 +79,7 @@ async function prepareJobCommonAsync(

  return {
    platform: Platform.IOS,
-    projectArchive: {
-      type: ArchiveSourceType.S3,
-      bucketKey: archiveBucketKey,
-    },
+    projectArchive,
    distribution: ctx.buildProfile.distribution,
    builderEnvironment: {
      image: ctx.buildProfile.image,
@@ -103,7 +92,7 @@ async function prepareJobCommonAsync(
    },
    cache: ctx.buildProfile.cache,
    secrets: {
-      ...(secretEnvs ? { secretEnvs } : {}),
+      ...(environmentSecrets ? { environmentSecrets } : {}),
      buildCredentials,
    },
  };
@@ -122,15 +111,15 @@ function prepareTargetCredentials(targetCredentials: IosTargetCredentials): Ios.
 async function prepareGenericJobAsync(
  ctx: BuildContext<Platform.IOS>,
  jobData: JobData,
-  buildProfile: iOSGenericBuildProfile
+  buildProfile: IosGenericBuildProfile
 ): Promise<Partial<Ios.GenericJob>> {
  const projectRootDirectory =
    path.relative(await gitRootDirectoryAsync(), ctx.commandCtx.projectDir) || '.';
  return {
    ...(await prepareJobCommonAsync(ctx, {
-      archiveBucketKey: jobData.archiveBucketKey,
      credentials: jobData.credentials,
      targetName: jobData.projectConfiguration.iosApplicationTarget,
+      projectArchive: jobData.projectArchive,
    })),
    type: Workflow.GENERIC,
    scheme: jobData.projectConfiguration.iosBuildScheme,
@@ -147,16 +136,16 @@ async function prepareGenericJobAsync(
 async function prepareManagedJobAsync(
  ctx: BuildContext<Platform.IOS>,
  jobData: JobData,
-  buildProfile: iOSManagedBuildProfile
+  buildProfile: IosManagedBuildProfile
 ): Promise<Partial<Ios.ManagedJob>> {
  const projectRootDirectory =
    path.relative(await gitRootDirectoryAsync(), ctx.commandCtx.projectDir) || '.';
  const accountName = await getProjectAccountNameAsync(ctx.commandCtx.exp);
  return {
    ...(await prepareJobCommonAsync(ctx, {
-      archiveBucketKey: jobData.archiveBucketKey,
      credentials: jobData.credentials,
      targetName: jobData.projectConfiguration.iosApplicationTarget,
+      projectArchive: jobData.projectArchive,
    })),
    type: Workflow.MANAGED,
    buildType: buildProfile.buildType,
@@ -0,0 +1,45 @@
+import { Job } from '@expo/eas-build-job';
+import spawnAsync from '@expo/spawn-async';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+
+import Log from '../log';
+
+const PLUGIN_PACKAGE_NAME = 'eas-cli-local-build-plugin';
+
+export async function runLocalBuildAsync(job: Job): Promise<void> {
+  const execNameOrPath =
+    process.env.EAS_LOCAL_BUILD_PLUGIN_PATH ??
+    (await findWithNodeResolution()) ??
+    PLUGIN_PACKAGE_NAME;
+  try {
+    const arg = Buffer.from(JSON.stringify({ job })).toString('base64');
+    await spawnAsync(execNameOrPath, [arg], {
+      stdio: 'inherit',
+    });
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      Log.warn(`Could not resolve executable ${execNameOrPath}.`);
+      Log.warn(
+        `Install ${PLUGIN_PACKAGE_NAME} package from npm e.g. ${chalk.bold(
+          `npm install -g ${PLUGIN_PACKAGE_NAME}`
+        )} and make sure it's in PATH.`
+      );
+      throw err;
+    }
+  }
+}
+
+async function findWithNodeResolution(): Promise<string | undefined> {
+  try {
+    const resolvedPath = path.resolve(
+      path.dirname(require.resolve(PLUGIN_PACKAGE_NAME)),
+      '../bin/run'
+    );
+    if (await fs.pathExists(resolvedPath)) {
+      return resolvedPath;
+    }
+  } catch {}
+  return undefined;
+}
@@ -1,14 +1,11 @@
-import { Metadata, Platform, errors } from '@expo/eas-build-job';
-import { AndroidBuildProfile, iOSBuildProfile } from '@expo/eas-json';
+export { Platform } from '@expo/eas-build-job';

 export enum RequestedPlatform {
  Android = 'android',
-  iOS = 'ios',
+  Ios = 'ios',
  All = 'all',
 }

-export { Platform };
-
 export enum BuildStatus {
  IN_QUEUE = 'in-queue',
  IN_PROGRESS = 'in-progress',
@@ -18,43 +15,3 @@ export enum BuildStatus {
 }

 export type TrackingContext = Record<string, string | number>;
-
-export interface Build {
-  id: string;
-  status: BuildStatus;
-  platform: Platform;
-  createdAt: string;
-  updatedAt: string;
-  artifacts?: BuildArtifacts;
-  metadata?: Partial<Metadata>;
-  error?: errors.ExternalUserError;
-}
-
-interface BuildArtifacts {
-  buildUrl?: string;
-  logsUrl: string;
-}
-
-export type PlatformBuildProfile<T extends Platform> = T extends Platform.ANDROID
-  ? AndroidBuildProfile
-  : iOSBuildProfile;
-
-export enum AnalyticsEvent {
-  BUILD_COMMAND = 'builds cli build command',
-  PROJECT_UPLOAD_SUCCESS = 'builds cli project upload success',
-  PROJECT_UPLOAD_FAIL = 'builds cli project upload fail',
-  GATHER_CREDENTIALS_SUCCESS = 'builds cli gather credentials success',
-  GATHER_CREDENTIALS_FAIL = 'builds cli gather credentials fail',
-  CONFIGURE_PROJECT_SUCCESS = 'builds cli configure project success',
-  CONFIGURE_PROJECT_FAIL = 'builds cli configure project fail',
-  BUILD_REQUEST_SUCCESS = 'build cli build request success',
-  BUILD_REQUEST_FAIL = 'builds cli build request fail',
-
-  BUILD_STATUS_COMMAND = 'builds cli build status',
-
-  CREDENTIALS_SYNC_COMMAND = 'builds cli credentials sync command',
-  CREDENTIALS_SYNC_UPDATE_LOCAL_SUCCESS = 'builds cli credentials sync update local success',
-  CREDENTIALS_SYNC_UPDATE_LOCAL_FAIL = 'builds cli credentials sync update local fail',
-  CREDENTIALS_SYNC_UPDATE_REMOTE_SUCCESS = 'builds cli credentials sync update remote success',
-  CREDENTIALS_SYNC_UPDATE_REMOTE_FAIL = 'builds cli credentials sync update remote fail',
-}
@@ -1,3 +1,27 @@
+import { logEvent } from '../../analytics';
+
+export enum Event {
+  BUILD_COMMAND = 'build cli build command',
+  PROJECT_UPLOAD_SUCCESS = 'build cli project upload success',
+  PROJECT_UPLOAD_FAIL = 'build cli project upload fail',
+  GATHER_CREDENTIALS_SUCCESS = 'build cli gather credentials success',
+  GATHER_CREDENTIALS_FAIL = 'build cli gather credentials fail',
+  CONFIGURE_PROJECT_SUCCESS = 'build cli configure project success',
+  CONFIGURE_PROJECT_FAIL = 'build cli configure project fail',
+  BUILD_REQUEST_SUCCESS = 'build cli build request success',
+  BUILD_REQUEST_FAIL = 'build cli build request fail',
+
+  BUILD_STATUS_COMMAND = 'build cli build status',
+
+  CREDENTIALS_SYNC_COMMAND = 'build cli credentials sync command',
+  CREDENTIALS_SYNC_UPDATE_LOCAL_SUCCESS = 'build cli credentials sync update local success',
+  CREDENTIALS_SYNC_UPDATE_LOCAL_FAIL = 'build cli credentials sync update local fail',
+  CREDENTIALS_SYNC_UPDATE_REMOTE_SUCCESS = 'build cli credentials sync update remote success',
+  CREDENTIALS_SYNC_UPDATE_REMOTE_FAIL = 'build cli credentials sync update remote fail',
+}
+
 export default {
-  logEvent: (a: any, b: any) => {},
+  logEvent(name: Event, properties: Record<string, any>) {
+    logEvent(name, properties);
+  },
 };
@@ -0,0 +1,15 @@
+import { Platform } from '@expo/eas-build-job';
+import { CredentialsSource } from '@expo/eas-json';
+import chalk from 'chalk';
+
+import Log from '../../log';
+import { requestedPlatformDisplayNames } from '../constants';
+
+export function logCredentialsSource(credentialsSource: CredentialsSource, platform: Platform) {
+  let message = `Using ${credentialsSource} ${requestedPlatformDisplayNames[platform]} credentials`;
+  if (credentialsSource === CredentialsSource.LOCAL)
+    message += ` ${chalk.dim('(credentials.json)')}`;
+  else if (credentialsSource === CredentialsSource.REMOTE)
+    message += ` ${chalk.dim('(Expo server)')}`;
+  Log.succeed(message);
+}
@@ -1,57 +1,66 @@
 import chalk from 'chalk';

+import { BuildFragment, BuildStatus as GraphQLBuildStatus } from '../../graphql/generated';
 import formatFields from '../../utils/formatFields';
-import { platformDisplayNames } from '../constants';
-import { Build, BuildStatus } from '../types';
+import { appPlatformDisplayNames } from '../constants';
 import { getBuildLogsUrl } from './url';

-interface Options {
-  accountName: string;
-}
-
-export default function formatBuild(build: Build, { accountName }: Options) {
+export function formatGraphQLBuild(build: BuildFragment) {
+  const actor = getActorName(build);
+  const account = build.project.__typename === 'App' ? build.project.ownerAccount.name : 'unknown';
  const fields: { label: string; value: string }[] = [
    { label: 'ID', value: build.id },
    {
      label: 'Platform',
-      value: platformDisplayNames[build.platform],
+      value: appPlatformDisplayNames[build.platform],
    },
    {
      label: 'Status',
      get value() {
        switch (build.status) {
-          case BuildStatus.IN_QUEUE:
+          case GraphQLBuildStatus.InQueue:
            return chalk.blue('in queue');
-          case BuildStatus.IN_PROGRESS:
+          case GraphQLBuildStatus.InProgress:
            return chalk.blue('in progress');
-          case BuildStatus.CANCELED:
+          case GraphQLBuildStatus.Canceled:
            return chalk.gray('canceled');
-          case BuildStatus.FINISHED:
+          case GraphQLBuildStatus.Finished:
            return chalk.green('finished');
-          case BuildStatus.ERRORED:
+          case GraphQLBuildStatus.Errored:
            return chalk.red('errored');
          default:
            return 'unknown';
        }
      },
    },
+    {
+      label: 'Distribution',
+      value: build.distribution?.toLowerCase() ?? chalk.gray('unknown'),
+    },
+    {
+      label: 'Release Channel',
+      value: build.releaseChannel ?? chalk.gray('unknown'),
+    },
    {
      label: 'Logs',
-      value: getBuildLogsUrl({ buildId: build.id, account: accountName }),
+      value: getBuildLogsUrl({ buildId: build.id, account }),
    },
    {
      label: 'Artifact',
      get value() {
-        if (build.status === BuildStatus.IN_QUEUE || build.status === BuildStatus.IN_PROGRESS) {
+        if (
+          build.status === GraphQLBuildStatus.InQueue ||
+          build.status === GraphQLBuildStatus.InProgress
+        ) {
        }
        switch (build.status) {
-          case BuildStatus.IN_QUEUE:
-          case BuildStatus.IN_PROGRESS:
+          case GraphQLBuildStatus.InQueue:
+          case GraphQLBuildStatus.InProgress:
            return '<in progress>';
-          case BuildStatus.CANCELED:
-          case BuildStatus.ERRORED:
+          case GraphQLBuildStatus.Canceled:
+          case GraphQLBuildStatus.Errored:
            return '---------';
-          case BuildStatus.FINISHED: {
+          case GraphQLBuildStatus.Finished: {
            const url = build.artifacts?.buildUrl;
            return url ? url : chalk.red('not found');
          }
@@ -64,13 +73,23 @@ export default function formatBuild(build: Build, { accountName }: Options) {
    {
      label: 'Finished at',
      value:
-        build.status === BuildStatus.IN_QUEUE || build.status === BuildStatus.IN_PROGRESS
+        build.status === GraphQLBuildStatus.InQueue ||
+        build.status === GraphQLBuildStatus.InProgress
          ? '<in progress>'
          : new Date(build.updatedAt).toLocaleString(),
    },
-    // TODO: we can do it once we migrate to GraphQL
-    // { label: 'Started by', get: build => 'TODO' },
+    { label: 'Started by', value: actor ?? 'unknown' },
  ];

  return formatFields(fields);
 }
+
+const getActorName = (build: BuildFragment): string => {
+  if (!build.initiatingActor) {
+    return 'unknown';
+  } else if (build.initiatingActor.__typename === 'User') {
+    return build.initiatingActor.username;
+  } else {
+    return build.initiatingActor.firstName ?? 'unknown';
+  }
+};
@@ -1,17 +1,22 @@
-import { errors } from '@expo/eas-build-job';
 import assert from 'assert';
 import chalk from 'chalk';

+import {
+  BuildError,
+  BuildFragment,
+  BuildStatus,
+  DistributionType,
+  EasBuildDeprecationInfo,
+  EasBuildDeprecationInfoType,
+} from '../../graphql/generated';
 import Log, { learnMore } from '../../log';
-import { platformDisplayNames, platformEmojis } from '../constants';
-import { Build } from '../types';
+import {
+  appPlatformDisplayNames,
+  appPlatformEmojis,
+  requestedPlatformDisplayNames,
+} from '../constants';
 import { getBuildLogsUrl } from './url';

-export interface DeprecationInfo {
-  type: 'user-facing' | 'internal';
-  message: string;
-}
-
 export function printLogsUrls(
  accountName: string,
  builds: { platform: 'android' | 'ios'; buildId: string }[]
@@ -29,51 +34,57 @@ export function printLogsUrls(
        buildId,
        account: accountName,
      });
-      Log.log(`${platformDisplayNames[platform]} build details: ${chalk.underline(logsUrl)}`);
+      Log.log(
+        `${requestedPlatformDisplayNames[platform]} build details: ${chalk.underline(logsUrl)}`
+      );
    });
  }
 }

-export function printBuildResults(accountName: string, builds: (Build | null)[]): void {
+export function printBuildResults(accountName: string, builds: (BuildFragment | null)[]): void {
  Log.newLine();
  if (builds.length === 1) {
    const [build] = builds;
    assert(build, 'Build should be defined');
    printBuildResult(accountName, build);
  } else {
-    (builds.filter(i => i) as Build[]).forEach(build => printBuildResult(accountName, build));
+    (builds.filter(i => i) as BuildFragment[]).forEach(build =>
+      printBuildResult(accountName, build)
+    );
  }
 }

-function printBuildResult(accountName: string, build: Build): void {
+function printBuildResult(accountName: string, build: BuildFragment): void {
  Log.addNewLineIfNone();
-  if (build.status === 'errored') {
+  if (build.status === BuildStatus.Errored) {
    const userError = build.error;
    Log.error(
-      `${platformEmojis[build.platform]} ${platformDisplayNames[build.platform]} build failed${
-        userError ? ':' : ''
-      }`
+      `${appPlatformEmojis[build.platform]} ${
+        appPlatformDisplayNames[build.platform]
+      } build failed${userError ? ':' : ''}`
    );
    if (userError) {
      printUserError(userError);
    }
    return;
  }
-  if (build.status === 'canceled') {
+  if (build.status === BuildStatus.Canceled) {
    Log.error(
-      `${platformEmojis[build.platform]} ${platformDisplayNames[build.platform]} build was canceled`
+      `${appPlatformEmojis[build.platform]} ${
+        appPlatformDisplayNames[build.platform]
+      } build was canceled`
    );
    return;
  }

-  if (build.metadata?.distribution === 'internal') {
+  if (build.distribution === DistributionType.Internal) {
    const logsUrl = getBuildLogsUrl({
      buildId: build.id,
      account: accountName,
    });
    Log.log(
-      `${platformEmojis[build.platform]} Open this link on your ${
-        platformDisplayNames[build.platform]
+      `${appPlatformEmojis[build.platform]} Open this link on your ${
+        appPlatformDisplayNames[build.platform]
      } devices to install the app:`
    );
    Log.log(`${chalk.underline(logsUrl)}`);
@@ -81,20 +92,20 @@ function printBuildResult(accountName: string, build: Build): void {
    // 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(`${platformEmojis[build.platform]} ${platformDisplayNames[build.platform]} app:`);
+    Log.log(`${appPlatformEmojis[build.platform]} ${appPlatformDisplayNames[build.platform]} app:`);
    Log.log(`${chalk.underline(url)}`);
  }
 }

-export function printDeprecationWarnings(deprecationInfo?: DeprecationInfo): void {
+export function printDeprecationWarnings(deprecationInfo?: EasBuildDeprecationInfo | null): void {
  if (!deprecationInfo) {
    return;
  }
-  if (deprecationInfo.type === 'internal') {
+  if (deprecationInfo.type === EasBuildDeprecationInfoType.Internal) {
    Log.warn('This command is using API that soon will be deprecated, please update eas-cli.');
    Log.warn("Changes won't affect your project config.");
    Log.warn(deprecationInfo.message);
-  } else if (deprecationInfo.type === 'user-facing') {
+  } else if (deprecationInfo.type === EasBuildDeprecationInfoType.UserFacing) {
    Log.warn('This command is using API that soon will be deprecated, please update eas-cli.');
    Log.warn(
      'There might be some changes necessary to your project config, latest eas-cli will provide more specific error messages.'
@@ -106,7 +117,7 @@ export function printDeprecationWarnings(deprecationInfo?: DeprecationInfo): voi
  }
 }

-export function printUserError(error: errors.ExternalUserError): void {
+export function printUserError(error: BuildError): void {
  Log.error(error.message);
  if (error.docsUrl) {
    Log.error(learnMore(error.docsUrl, { dim: false }));
@@ -2,8 +2,7 @@ import { Command } from '@oclif/command';
 import chalk from 'chalk';

 import Log from '../../log';
-import { getUserAsync } from '../../user/User';
-import { getActorDisplayName } from '../../user/actions';
+import { getActorDisplayName, getUserAsync } from '../../user/User';

 export default class AccountView extends Command {
  static description = 'show the username you are logged in as';
@@ -0,0 +1,25 @@
+import { Command } from '@oclif/command';
+
+import Log from '../log';
+import UserSettings from '../user/UserSettings';
+
+export default class AnalyticsView extends Command {
+  static description = 'View or change analytics settings';
+
+  static args = [{ name: 'STATUS', options: ['on', 'off'] }];
+
+  async run() {
+    const { STATUS: status } = this.parse(AnalyticsView).args;
+    if (status) {
+      await UserSettings.setAsync('amplitudeEnabled', status === 'on');
+      Log.withTick(`${status === 'on' ? 'Enabling' : 'Disabling'} analytics.`);
+    } else {
+      const amplitudeEnabled = await UserSettings.getAsync('amplitudeEnabled', null);
+      Log.log(
+        `Analytics are ${
+          amplitudeEnabled === false ? 'disabled' : 'enabled'
+        } on this eas-cli installation.`
+      );
+    }
+  }
+}
@@ -44,7 +44,7 @@ async function getBranchInfoAsync({
      )
      .toPromise()
  );
-  const branchId = data.app?.byId.updateBranchByName.id;
+  const branchId = data.app?.byId.updateBranchByName?.id;
  if (!branchId) {
    throw new Error(`Could not find branch ${name} on ${appId}`);
  }
@@ -103,7 +103,7 @@ export default class BranchDelete extends Command {
    if (!projectDir) {
      throw new Error('Please run this command inside a project directory.');
    }
-    const { exp } = await getConfig(projectDir, { skipSDKVersionRequirement: true });
+    const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
    const accountName = getProjectAccountName(exp, await ensureLoggedInAsync());
    const projectId = await ensureProjectExistsAsync({
      accountName,
@@ -129,7 +129,7 @@ export default class BranchDelete extends Command {
      Log.addNewLineIfNone();
      Log.warn(
        `You are about to permamently delete branch: "${name}" and all of the updates published on it.` +
-          `\nThis action is irreversable.`
+          `\nThis action is irreversible.`
      );
      Log.newLine();
      const confirmed = await toggleConfirmAsync({ message: 'Are you sure you wish to proceed?' });
@@ -1,5 +1,6 @@
 import { getConfig } from '@expo/config';
 import { Command, flags } from '@oclif/command';
+import chalk from 'chalk';
 import CliTable from 'cli-table3';
 import gql from 'graphql-tag';
 import { format } from 'timeago.js';
@@ -15,9 +16,15 @@ import {
 } from '../../graphql/generated';
 import Log from '../../log';
 import { findProjectRootAsync, getProjectFullNameAsync } from '../../project/projectUtils';
-import { getActorDisplayName } from '../../user/actions';
+import { getActorDisplayName } from '../../user/User';

+export type FormatUpdateParameter = Pick<Update, 'id' | 'createdAt' | 'message'> & {
+  actor?: Maybe<Pick<User, 'username' | 'id'> | Pick<Robot, 'firstName' | 'id'>>;
+};
+
+export const UPDATE_COLUMNS = ['update description', 'update runtime version', 'update group ID'];
 const BRANCHES_LIMIT = 10_000;
+
 export async function listBranchesAsync({ fullName }: { fullName: string }) {
  const data = await withErrorHandlingAsync(
    graphqlClient
@@ -43,8 +50,10 @@ export async function listBranchesAsync({ fullName }: { fullName: string }) {
                        firstName
                      }
                    }
-                    updatedAt
+                    createdAt
                    message
+                    runtimeVersion
+                    group
                  }
                }
              }
@@ -87,8 +96,19 @@ export default class BranchList extends Command {
    if (flags.json) {
      Log.log(JSON.stringify(branches, null, 2));
    } else {
-      const table = new CliTable({ head: ['Branch', 'Latest update'] });
-      table.push(...branches.map(branch => [branch.name, formatUpdate(branch.updates[0])]));
+      const table = new CliTable({
+        head: ['branch', ...UPDATE_COLUMNS],
+        wordWrap: true,
+      });
+      table.push(
+        ...branches.map(branch => [
+          branch.name,
+          formatUpdate(branch.updates[0]),
+          branch.updates[0]?.runtimeVersion ?? 'N/A',
+          branch.updates[0]?.group ?? 'N/A',
+        ])
+      );
+      Log.log(chalk.bold('Branches with their most recent update group:'));
      Log.log(table.toString());
      if (branches.length >= BRANCHES_LIMIT) {
        Log.warn(`Showing first ${BRANCHES_LIMIT} branches, some results might be omitted.`);
@@ -97,16 +117,12 @@ export default class BranchList extends Command {
  }
 }

-export function formatUpdate(
-  update: Pick<Update, 'id' | 'updatedAt' | 'message'> & {
-    actor?: Maybe<Pick<User, 'username' | 'id'> | Pick<Robot, 'firstName' | 'id'>>;
-  }
-): string {
+export function formatUpdate(update: FormatUpdateParameter): string {
  if (!update) {
    return 'N/A';
  }
  const message = update.message ? `"${update.message}" ` : '';
-  return `${message}(${format(update.updatedAt, 'en_US')} by ${getActorDisplayName(
+  return `${message}(${format(update.createdAt, 'en_US')} by ${getActorDisplayName(
    update.actor as any
  )})`;
 }
@@ -1,4 +1,5 @@
-import { getConfig } from '@expo/config';
+import { getConfig, getDefaultTarget } from '@expo/config';
+import { getRuntimeVersionForSDKVersion } from '@expo/sdk-runtime-versions';
 import { Command, flags } from '@oclif/command';
 import assert from 'assert';
 import chalk from 'chalk';
@@ -64,10 +65,15 @@ export default class BranchPublish extends Command {
  static hidden = true;
  static description = 'Publish an update group to a branch.';

+  static args = [
+    {
+      name: 'name',
+      required: true,
+      description: 'Name of the branch to publish on',
+    },
+  ];
+
  static flags = {
-    branch: flags.string({
-      description: 'name of the branch to publish on.',
-    }),
    message: flags.string({
      description: 'Short message describing the updates.',
      required: false,
@@ -97,9 +103,9 @@ export default class BranchPublish extends Command {

  async run() {
    let {
+      args: { name },
      flags: {
        json: jsonFlag,
-        branch: name,
        message,
        republish,
        group,
@@ -117,7 +123,17 @@ export default class BranchPublish extends Command {

    const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
    const accountName = await getProjectAccountNameAsync(exp);
-    const { slug, runtimeVersion } = exp;
+    let { slug, runtimeVersion, sdkVersion } = exp;
+
+    // When a SDK version is supplied instead of a runtime version and we're in the managed workflow
+    // construct the runtimeVersion with special meaning indicating that the runtime is an
+    // Expo SDK preset runtime that can be launched in Expo Go.
+    const isManagedProject = getDefaultTarget(projectDir) === 'managed';
+    if (!runtimeVersion && sdkVersion && isManagedProject) {
+      Log.withTick('Generating runtime version from sdk version');
+      runtimeVersion = getRuntimeVersionForSDKVersion(sdkVersion);
+    }
+
    if (!runtimeVersion) {
      throw new Error(
        "Couldn't find 'runtimeVersion'. Please specify it under the 'expo' key in 'app.json'"
@@ -75,8 +75,9 @@ export default class BranchRename extends Command {
    if (!projectDir) {
      throw new Error('Please run this command inside a project directory.');
    }
-    const { exp } = await getConfig(projectDir, { skipSDKVersionRequirement: true });
+    const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
    const accountName = getProjectAccountName(exp, await ensureLoggedInAsync());
+
    const projectId = await ensureProjectExistsAsync({
      accountName,
      projectName: exp.slug,
@@ -19,6 +19,7 @@ import Log from '../../log';
 import { ensureProjectExistsAsync } from '../../project/ensureProjectExists';
 import { findProjectRootAsync, getProjectAccountNameAsync } from '../../project/projectUtils';
 import { promptAsync } from '../../prompts';
+import { UPDATE_COLUMNS, formatUpdate } from './list';

 const PAGE_LIMIT = 10_000;

@@ -59,7 +60,7 @@ export async function viewUpdateBranchAsync({
                    actor {
                      id
                      ... on User {
-                        firstName
+                        username
                      }
                      ... on Robot {
                        firstName
@@ -152,17 +153,12 @@ export default class BranchView extends Command {
    }

    const groupTable = new Table({
-      head: ['createdAt', 'message', 'group', 'actor'],
+      head: UPDATE_COLUMNS,
      wordWrap: true,
    });

    for (const update of updates) {
-      groupTable.push([
-        new Date(update.createdAt).toLocaleString(),
-        update.message,
-        update.group,
-        update.actor?.firstName,
-      ]);
+      groupTable.push([formatUpdate(update), update.runtimeVersion, update.group]);
    }

    Log.withTick(
@@ -4,11 +4,9 @@ import chalk from 'chalk';
 import gql from 'graphql-tag';
 import ora from 'ora';

-import { platformEmojis } from '../../build/constants';
-import { Platform } from '../../build/types';
+import { appPlatformEmojis } from '../../build/constants';
 import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
 import {
-  AppPlatform,
  Build,
  BuildStatus,
  CancelBuildMutation,
@@ -44,15 +42,10 @@ async function cancelBuildAsync(buildId: string): Promise<Pick<Build, 'id' | 'st
  return data.build!.cancel;
 }

-const appPlatformMap = {
-  [AppPlatform.Android]: Platform.ANDROID,
-  [AppPlatform.Ios]: Platform.IOS,
-};
-
 function formatUnfinishedBuild(
  build: Pick<Build, 'id' | 'platform' | 'status' | 'createdAt'>
 ): string {
-  const platform = platformEmojis[appPlatformMap[build.platform]];
+  const platform = appPlatformEmojis[build.platform];
  const startTime = new Date(build.createdAt).toLocaleString();
  const status = chalk.blue(build.status === BuildStatus.InQueue ? 'in-queue' : 'in-progress');
  return `${platform} Started at: ${startTime}, Status: ${status}, Id: ${build.id}`;
@@ -87,7 +87,7 @@ async function promptForPlatformAsync(): Promise<RequestedPlatform> {
      },
      {
        title: 'iOS',
-        value: RequestedPlatform.iOS,
+        value: RequestedPlatform.Ios,
      },
      {
        title: 'Android',
@@ -1,17 +1,19 @@
-import { getConfig } from '@expo/config';
+import { ExpoConfig, getConfig } from '@expo/config';
 import { Command, flags } from '@oclif/command';
 import chalk from 'chalk';
 import fs from 'fs-extra';
+import nullthrows from 'nullthrows';
 import path from 'path';
-import { v4 as uuidv4 } from 'uuid';

-import { apiClient } from '../../api';
+import {
+  flushAsync as flushAnalyticsAsync,
+  initAsync as initAnalyticsAsync,
+} from '../../analytics';
 import { configureAsync } from '../../build/configure';
 import { createCommandContextAsync } from '../../build/context';
 import { buildAsync } from '../../build/create';
-import { AnalyticsEvent, Build as BuildType, RequestedPlatform } from '../../build/types';
-import Analytics from '../../build/utils/analytics';
-import formatBuild from '../../build/utils/formatBuild';
+import { RequestedPlatform } from '../../build/types';
+import { formatGraphQLBuild } from '../../build/utils/formatBuild';
 import { isGitStatusCleanAsync } from '../../build/utils/repository';
 import { AppPlatform } from '../../graphql/generated';
 import { BuildQuery } from '../../graphql/queries/BuildQuery';
@@ -50,6 +52,10 @@ export default class Build extends Command {
      default: false,
      description: 'Run command in --non-interactive mode',
    }),
+    local: flags.boolean({
+      default: false,
+      description: 'Run build locally [experimental]',
+    }),
    wait: flags.boolean({
      default: true,
      allowNo: true,
@@ -59,57 +65,61 @@ export default class Build extends Command {

  async run(): Promise<void> {
    const { flags } = this.parse(Build);
-    const user = await ensureLoggedInAsync();
+    await initAnalyticsAsync(); // TODO: run in oclif hook for every command
+    try {
+      const user = await ensureLoggedInAsync();

-    const nonInteractive = flags['non-interactive'];
-    if (!flags.platform && nonInteractive) {
-      throw new Error('--platform is required when building in non-interactive mode');
+      const nonInteractive = flags['non-interactive'];
+      if (!flags.platform && nonInteractive) {
+        throw new Error('--platform is required when building in non-interactive mode');
+      }
+      const platform =
+        (flags.platform as RequestedPlatform | undefined) ?? (await promptForPlatformAsync());
+
+      const projectDir = (await findProjectRootAsync()) ?? process.cwd();
+      let { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
+      const projectId = await getProjectIdAsync(exp);
+
+      if (!flags.local && !(await isEasEnabledForProjectAsync(projectId))) {
+        warnEasUnavailable();
+        process.exitCode = 1;
+        return;
+      }
+
+      if (flags.local && !verifyOptionsForLocalBuilds(platform)) {
+        process.exitCode = 1;
+        return;
+      }
+
+      const accountName = await getProjectAccountNameAsync(exp);
+      const accountHasPendingBuilds = await ensureNoPendingBuildsExistAsync({
+        accountName,
+        platform,
+        projectId,
+        user,
+      });
+      if (accountHasPendingBuilds) {
+        return;
+      }
+
+      exp = (await ensureProjectConfiguredAsync(projectDir)) ?? exp;
+
+      const commandCtx = await createCommandContextAsync({
+        requestedPlatform: platform,
+        profile: flags.profile,
+        exp,
+        projectDir,
+        projectId,
+        nonInteractive,
+        skipCredentialsCheck: flags['skip-credentials-check'],
+        local: flags.local,
+        skipProjectConfiguration: flags['skip-project-configuration'],
+        waitForBuildEnd: flags.wait,
+      });
+      await buildAsync(commandCtx);
+    } finally {
+      await flushAnalyticsAsync(); // TODO: run in oclif hook for every command
    }
-    const platform =
-      (flags.platform as RequestedPlatform | undefined) ?? (await promptForPlatformAsync());
-
-    const projectDir = (await findProjectRootAsync()) ?? process.cwd();
-    const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
-    const projectId = await getProjectIdAsync(exp);
-
-    if (!(await isEasEnabledForProjectAsync(projectId))) {
-      warnEasUnavailable();
-      process.exitCode = 1;
-      return;
-    }
-
-    const accountName = await getProjectAccountNameAsync(exp);
-    const accountHasPendingBuilds = await ensureNoPendingBuildsExistAsync({
-      accountName,
-      platform,
-      projectId,
-      user,
-    });
-    if (accountHasPendingBuilds) {
-      return;
-    }
-
-    await ensureProjectConfiguredAsync(projectDir);
-
-    const trackingCtx = {
-      tracking_id: uuidv4(),
-      requested_platform: flags.platform,
-    };
-    Analytics.logEvent(AnalyticsEvent.BUILD_COMMAND, trackingCtx);
-
-    const commandCtx = await createCommandContextAsync({
-      requestedPlatform: platform,
-      profile: flags.profile,
-      exp,
-      projectDir,
-      projectId,
-      trackingCtx,
-      nonInteractive,
-      skipCredentialsCheck: flags['skip-credentials-check'],
-      skipProjectConfiguration: flags['skip-project-configuration'],
-      waitForBuildEnd: flags.wait,
-    });
-    await buildAsync(commandCtx);
  }
 }

@@ -142,17 +152,12 @@ async function ensureNoPendingBuildsExistAsync({
    Log.newLine();
    const results = await Promise.all(
      pendingBuilds.map(pendingBuild => {
-        return apiClient.get<{ data: BuildType }>(
-          `projects/${projectId}/builds/${pendingBuild?.id}`,
-          {
-            responseType: 'json',
-          }
-        );
+        return BuildQuery.byIdAsync(nullthrows(pendingBuild).id);
      })
    );

    for (const result of results) {
-      Log.log(formatBuild(result.body.data, { accountName }));
+      Log.log(formatGraphQLBuild(result));
    }

    process.exitCode = 1;
@@ -161,6 +166,18 @@ async function ensureNoPendingBuildsExistAsync({
  return false;
 }

+function verifyOptionsForLocalBuilds(platform: RequestedPlatform): boolean {
+  if (platform === RequestedPlatform.All) {
+    Log.error('Builds for multiple platforms are not supported with flag --local');
+    return false;
+  } else if (process.platform !== 'darwin' && platform === RequestedPlatform.Ios) {
+    Log.error('Unsupported platform, macOS is required to build apps for iOS');
+    return false;
+  } else {
+    return true;
+  }
+}
+
 function toAppPlatforms(requestedPlatform: RequestedPlatform): AppPlatform[] {
  if (requestedPlatform === RequestedPlatform.All) {
    return [AppPlatform.Android, AppPlatform.Ios];
@@ -183,7 +200,7 @@ async function promptForPlatformAsync(): Promise<RequestedPlatform> {
      },
      {
        title: 'iOS',
-        value: RequestedPlatform.iOS,
+        value: RequestedPlatform.Ios,
      },
      {
        title: 'Android',
@@ -194,9 +211,9 @@ async function promptForPlatformAsync(): Promise<RequestedPlatform> {
  return platform;
 }

-async function ensureProjectConfiguredAsync(projectDir: string): Promise<void> {
+async function ensureProjectConfiguredAsync(projectDir: string): Promise<ExpoConfig | null> {
  if (await fs.pathExists(path.join(projectDir, 'eas.json'))) {
-    return;
+    return null;
  }
  const confirm = await confirmAsync({
    message: 'This app is not set up for building with EAS. Set it up now?',
@@ -212,6 +229,8 @@ async function ensureProjectConfiguredAsync(projectDir: string): Promise<void> {
        'Build process requires clean git working tree, please commit all your changes and run `eas build` again'
      );
    }
+    const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
+    return exp;
  } else {
    throw new Error(
      `Aborting, please run ${chalk.bold('eas build:configure')} or create eas.json (${learnMore(
@@ -3,13 +3,13 @@ import { Command, flags } from '@oclif/command';
 import chalk from 'chalk';
 import ora from 'ora';

-import { apiClient } from '../../api';
-import { Build } from '../../build/types';
-import formatBuild from '../../build/utils/formatBuild';
+import { BuildStatus, RequestedPlatform } from '../../build/types';
+import { formatGraphQLBuild } from '../../build/utils/formatBuild';
+import { AppPlatform, BuildStatus as GraphQLBuildStatus } from '../../graphql/generated';
+import { BuildQuery } from '../../graphql/queries/BuildQuery';
 import Log from '../../log';
 import {
  findProjectRootAsync,
-  getProjectAccountNameAsync,
  getProjectFullNameAsync,
  getProjectIdAsync,
 } from '../../project/projectUtils';
@@ -18,35 +18,45 @@ export default class BuildList extends Command {
  static description = 'list all builds for your project';

  static flags = {
-    platform: flags.enum({ options: ['all', 'android', 'ios'] }),
-    status: flags.enum({ options: ['in-queue', 'in-progress', 'errored', 'finished', 'canceled'] }),
+    platform: flags.enum({
+      options: [RequestedPlatform.All, RequestedPlatform.Android, RequestedPlatform.Ios],
+    }),
+    status: flags.enum({
+      options: [
+        BuildStatus.IN_QUEUE,
+        BuildStatus.IN_PROGRESS,
+        BuildStatus.ERRORED,
+        BuildStatus.FINISHED,
+        BuildStatus.CANCELED,
+      ],
+    }),
    limit: flags.integer(),
  };

  async run() {
-    const { platform, status, limit = 10 } = this.parse(BuildList).flags;
+    const { platform: requestedPlatform, status: buildStatus, limit = 10 } = this.parse(
+      BuildList
+    ).flags;
+
+    const platform = toAppPlatform(requestedPlatform);
+    const graphqlBuildStatus = toGraphQLBuildStatus(buildStatus);

    const projectDir = (await findProjectRootAsync()) ?? process.cwd();
    const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
    const projectId = await getProjectIdAsync(exp);
-    const accountName = await getProjectAccountNameAsync(exp);
    const projectName = await getProjectFullNameAsync(exp);

    const spinner = ora().start('Fetching the build list for the project…');

    try {
-      const response = await apiClient.get<{ data: { builds: Build[] } }>(
-        `projects/${projectId}/builds`,
-        {
-          searchParams: { platform, status, limit },
-          responseType: 'json',
-        }
-      );
-
-      const { builds } = response.body.data;
+      const builds = await BuildQuery.allForAppAsync(projectId, {
+        limit,
+        platform,
+        status: graphqlBuildStatus,
+      });

      if (builds.length) {
-        if (platform || status) {
+        if (platform || graphqlBuildStatus) {
          spinner.succeed(
            `Showing ${builds.length} matching builds for the project ${projectName}`
          );
@@ -55,7 +65,7 @@ export default class BuildList extends Command {
        }

        const list = builds
-          .map(build => formatBuild(build, { accountName }))
+          .map(build => formatGraphQLBuild(build))
          .join(`\n\n${chalk.dim('———')}\n\n`);

        Log.log(`\n${list}`);
@@ -68,3 +78,29 @@ export default class BuildList extends Command {
    }
  }
 }
+
+const toAppPlatform = (requestedPlatform?: RequestedPlatform): AppPlatform | undefined => {
+  if (!requestedPlatform || requestedPlatform === RequestedPlatform.All) {
+    return undefined;
+  } else if (requestedPlatform === RequestedPlatform.Android) {
+    return AppPlatform.Android;
+  } else {
+    return AppPlatform.Ios;
+  }
+};
+
+const toGraphQLBuildStatus = (buildStatus: BuildStatus): GraphQLBuildStatus | undefined => {
+  if (!buildStatus) {
+    return undefined;
+  } else if (buildStatus === BuildStatus.IN_QUEUE) {
+    return GraphQLBuildStatus.InQueue;
+  } else if (buildStatus === BuildStatus.IN_PROGRESS) {
+    return GraphQLBuildStatus.InProgress;
+  } else if (buildStatus === BuildStatus.ERRORED) {
+    return GraphQLBuildStatus.Errored;
+  } else if (buildStatus === BuildStatus.FINISHED) {
+    return GraphQLBuildStatus.Finished;
+  } else {
+    return GraphQLBuildStatus.Canceled;
+  }
+};
@@ -1,15 +1,13 @@
 import { getConfig } from '@expo/config';
 import { Command } from '@oclif/command';
-import { HTTPError } from 'got';
 import ora from 'ora';

-import { apiClient } from '../../api';
-import { Build } from '../../build/types';
-import formatBuild from '../../build/utils/formatBuild';
+import { formatGraphQLBuild } from '../../build/utils/formatBuild';
+import { BuildFragment } from '../../graphql/generated';
+import { BuildQuery } from '../../graphql/queries/BuildQuery';
 import Log from '../../log';
 import {
  findProjectRootAsync,
-  getProjectAccountNameAsync,
  getProjectFullNameAsync,
  getProjectIdAsync,
 } from '../../project/projectUtils';
@@ -25,33 +23,22 @@ export default class BuildView extends Command {
    const projectDir = (await findProjectRootAsync()) ?? process.cwd();
    const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
    const projectId = await getProjectIdAsync(exp);
-    const accountName = await getProjectAccountNameAsync(exp);
    const projectName = await getProjectFullNameAsync(exp);

    const spinner = ora().start('Fetching the build…');

    try {
-      let build: Build;
+      let build: BuildFragment;

-      if (buildId == null) {
-        const response = await apiClient.get<{ data: { builds: Build[] } }>(
-          `projects/${projectId}/builds`,
-          {
-            searchParams: { limit: 1 },
-            responseType: 'json',
-          }
-        );
-
-        build = response.body.data.builds[0];
+      if (buildId) {
+        build = await BuildQuery.byIdAsync(buildId);
      } else {
-        const response = await apiClient.get<{ data: Build }>(
-          `projects/${projectId}/builds/${buildId}`,
-          {
-            responseType: 'json',
-          }
-        );
-
-        build = response.body.data;
+        const builds = await BuildQuery.allForAppAsync(projectId, { limit: 1 });
+        if (builds.length === 0) {
+          spinner.fail(`Couldn't find any builds for the project ${projectName}`);
+          return;
+        }
+        build = builds[0];
      }

      if (buildId) {
@@ -60,29 +47,17 @@ export default class BuildView extends Command {
        spinner.succeed(`Showing the last build for the project ${projectName}`);
      }

-      Log.log(`\n${formatBuild(build, { accountName })}`);
-    } catch (e) {
-      const error = e as HTTPError;
-
-      if (error.response.statusCode === 400) {
-        if (buildId) {
-          spinner.fail(
-            `Couldn't find a build for the project ${projectName} matching the id ${buildId}`
-          );
-        } else {
-          spinner.fail(`Couldn't find any builds for the project ${projectName}`);
-        }
+      Log.log(`\n${formatGraphQLBuild(build)}`);
+    } catch (err) {
+      if (buildId) {
+        spinner.fail(`Something went wrong and we couldn't fetch the build with id ${buildId}`);
      } else {
-        if (buildId) {
-          spinner.fail(`Something went wrong and we couldn't fetch the build with id ${buildId}`);
-        } else {
-          spinner.fail(
-            `Something went wrong and we couldn't fetch the last build for the project ${projectName}`
-          );
-        }
+        spinner.fail(
+          `Something went wrong and we couldn't fetch the last build for the project ${projectName}`
+        );
      }

-      throw error;
+      throw err;
    }
  }
 }
@@ -60,7 +60,7 @@ async function getChannelByNameForAppAsync({
  return updateChannelByNameResult;
 }

-async function updateChannelBranchMappingAsync({
+export async function updateChannelBranchMappingAsync({
  channelId,
  branchMapping,
 }: UpdateChannelBranchMappingMutationVariables): Promise<{
@@ -147,7 +147,11 @@ export default class ChannelEdit extends Command {
    }

    const existingChannel = await getChannelByNameForAppAsync({ appId: projectId, channelName });
-    // todo: refactor when multiple branches per channel are available
+    if (existingChannel.updateBranches.length > 1) {
+      throw new Error(
+        'There is a rollout in progress. Please manage it with "channel:rollout" instead.'
+      );
+    }
    const existingBranch = existingChannel.updateBranches[0];

    Log.addNewLineIfNone();
@@ -170,7 +174,6 @@ export default class ChannelEdit extends Command {
    }

    const branch = await getBranchByNameAsync({ appId: projectId, name: branchName! });
-
    const channel = await updateChannelBranchMappingAsync({
      channelId: existingChannel.id,
      // todo: move branch mapping logic to utility
@@ -1,7 +1,6 @@
 import { getConfig } from '@expo/config';
 import { Command, flags } from '@oclif/command';
 import chalk from 'chalk';
-import Table from 'cli-table3';
 import gql from 'graphql-tag';

 import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
@@ -12,6 +11,7 @@ import {
 import Log from '../../log';
 import { ensureProjectExistsAsync } from '../../project/ensureProjectExists';
 import { findProjectRootAsync, getProjectAccountNameAsync } from '../../project/projectUtils';
+import { logChannelDetails } from './view';

 const CHANNEL_LIMIT = 10_000;

@@ -31,18 +31,20 @@ async function getAllUpdateChannelForAppAsync({
                updateChannels(offset: $offset, limit: $limit) {
                  id
                  name
-                  updateBranches(offset: 0, limit: 1) {
+                  branchMapping
+                  updateBranches(offset: 0, limit: $limit) {
                    id
                    name
                    updates(offset: 0, limit: 1) {
                      id
                      group
                      message
+                      runtimeVersion
                      createdAt
                      actor {
                        id
                        ... on User {
-                          firstName
+                          username
                        }
                        ... on Robot {
                          firstName
@@ -102,27 +104,10 @@ export default class ChannelList extends Command {
      return;
    }

-    const table = new Table({
-      head: ['channel', 'branch', 'update', 'message', 'created-at', 'actor'],
-      wordWrap: true,
-    });
-
+    Log.log(); // spacing
    for (const channel of channels) {
-      // TODO (cedric): refactor when multiple branches per channel are available
-      const branch = channel.updateBranches[0];
-      const update = branch.updates[0];
-
-      table.push([
-        channel.name,
-        branch.name,
-        update?.group,
-        update?.message,
-        update?.createdAt && new Date(update.createdAt).toLocaleString(),
-        update?.actor?.firstName,
-      ]);
+      Log.log(`Details of channel ${chalk.bold(chalk.cyan(channel.name))}:`);
+      logChannelDetails(channel);
    }
-
-    Log.log(chalk`{bold Channels for this app:}`);
-    Log.log(table.toString());
  }
 }
@@ -0,0 +1,433 @@
+import { getConfig } from '@expo/config';
+import { Command, flags } from '@oclif/command';
+import chalk from 'chalk';
+
+import { GetChannelByNameForAppQuery, UpdateBranch } from '../../graphql/generated';
+import Log from '../../log';
+import { ensureProjectExistsAsync } from '../../project/ensureProjectExists';
+import {
+  findProjectRootAsync,
+  getBranchByNameAsync,
+  getProjectAccountNameAsync,
+} from '../../project/projectUtils';
+import { promptAsync, selectAsync } from '../../prompts';
+import { updateChannelBranchMappingAsync } from './edit';
+import { BranchMapping, getBranchMapping, getUpdateChannelByNameForAppAsync } from './view';
+
+async function promptForRolloutPercentAsync({
+  promptMessage,
+}: {
+  promptMessage: string;
+}): Promise<number> {
+  const { name: rolloutPercent } = await promptAsync({
+    type: 'text',
+    name: 'name',
+    format: value => {
+      return parseInt(value, 10);
+    },
+    message: promptMessage,
+    initial: 0,
+    validate: (rolloutPercent: string): true | string => {
+      const floatValue = parseFloat(rolloutPercent);
+      return Number.isInteger(floatValue) && floatValue >= 0 && floatValue <= 100
+        ? true
+        : 'The rollout percentage must be an integer between 0 and 100 inclusive.';
+    },
+  });
+  return rolloutPercent;
+}
+
+function getRolloutInfo(
+  getUpdateChannelByNameForAppResult: GetChannelByNameForAppQuery
+): {
+  newBranch: Pick<UpdateBranch, 'name' | 'id'>;
+  oldBranch: Pick<UpdateBranch, 'name' | 'id'>;
+  currentPercent: number;
+} {
+  const { branchMapping } = getBranchMapping(
+    getUpdateChannelByNameForAppResult.app?.byId.updateChannelByName?.branchMapping
+  );
+  const [newBranchId, oldBranchId] = branchMapping.data.map(d => d.branchId);
+  const newBranch = getUpdateChannelByNameForAppResult.app?.byId.updateChannelByName?.updateBranches.filter(
+    branch => branch.id === newBranchId
+  )[0];
+  const oldBranch = getUpdateChannelByNameForAppResult.app?.byId.updateChannelByName?.updateBranches.filter(
+    branch => branch.id === oldBranchId
+  )[0];
+
+  if (!newBranch || !oldBranch) {
+    throw new Error(
+      `Branch mapping rollout is missing a branch for channel "${getUpdateChannelByNameForAppResult.app?.byId.updateChannelByName?.name}".`
+    );
+  }
+
+  const currentPercent = 100 * branchMapping.data[0].branchMappingLogic.operand;
+  return { newBranch, oldBranch, currentPercent };
+}
+
+async function startRolloutAsync({
+  channelName,
+  branchName,
+  percent,
+  jsonFlag,
+  projectId,
+  fullName,
+  currentBranchMapping,
+  getUpdateChannelByNameForAppResult,
+}: {
+  channelName?: string;
+  branchName?: string;
+  percent?: number;
+  jsonFlag: boolean;
+  projectId: string;
+  fullName: string;
+  currentBranchMapping: BranchMapping;
+  getUpdateChannelByNameForAppResult: GetChannelByNameForAppQuery;
+}): Promise<{
+  newChannelInfo: {
+    id: string;
+    name: string;
+    branchMapping: string;
+  };
+  logMessage: string;
+}> {
+  if (!branchName) {
+    const validationMessage = 'A branch must be specified.';
+    if (jsonFlag) {
+      throw new Error(validationMessage);
+    }
+    ({ name: branchName } = await promptAsync({
+      type: 'text',
+      name: 'name',
+      message: `Select a branch to rollout onto ${channelName}`,
+      validate: value => (value ? true : validationMessage),
+    }));
+  }
+  const branch = await getBranchByNameAsync({ appId: projectId, name: branchName! });
+  const oldBranchId = currentBranchMapping.data[0].branchId;
+  if (branch.id === oldBranchId) {
+    throw new Error(
+      `channel "${channelName}" is already pointing at branch "${branchName}". Rollouts must be done with distinct branches.`
+    );
+  }
+
+  if (percent == null) {
+    if (jsonFlag) {
+      throw new Error(
+        'You must specify a percent with the --percent flag when initiating a rollout with the --json flag.'
+      );
+    }
+    const promptMessage = `What percent of users should be directed to the branch "${branchName}"?`;
+    percent = await promptForRolloutPercentAsync({ promptMessage });
+  }
+
+  const newBranchMapping = {
+    version: 0,
+    data: [
+      {
+        branchId: branch.id,
+        branchMappingLogic: {
+          operand: percent / 100,
+          clientKey: 'rolloutToken',
+          branchMappingOperator: 'hash_lt',
+        },
+      },
+      currentBranchMapping.data[0],
+    ],
+  };
+  const newChannelInfo = await updateChannelBranchMappingAsync({
+    channelId: getUpdateChannelByNameForAppResult.app?.byId.updateChannelByName?.id!,
+    branchMapping: JSON.stringify(newBranchMapping),
+  });
+
+  const oldBranch = getUpdateChannelByNameForAppResult.app?.byId.updateChannelByName?.updateBranches.filter(
+    branch => branch.id === oldBranchId
+  )[0];
+  if (!oldBranch) {
+    throw new Error(
+      `Branch mapping is missing its only branch for channel "${channelName}" on app "${fullName}"`
+    );
+  }
+
+  const logMessage = `️Started a rollout of 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)}.`;
+
+  return { newChannelInfo, logMessage };
+}
+
+async function editRolloutAsync({
+  channelName,
+  percent,
+  jsonFlag,
+  currentBranchMapping,
+  getUpdateChannelByNameForAppResult,
+}: {
+  channelName?: string;
+  percent?: number;
+  jsonFlag: boolean;
+  currentBranchMapping: BranchMapping;
+  getUpdateChannelByNameForAppResult: GetChannelByNameForAppQuery;
+}): Promise<{
+  newChannelInfo: {
+    id: string;
+    name: string;
+    branchMapping: string;
+  };
+  logMessage: string;
+}> {
+  const { newBranch, oldBranch, currentPercent } = getRolloutInfo(
+    getUpdateChannelByNameForAppResult
+  );
+
+  if (percent == null) {
+    if (jsonFlag) {
+      throw new Error(
+        'A rollout is already in progress. If you wish to modify it you must use specify the new rollout percentage with the --percent flag.'
+      );
+    }
+    const promptMessage = `Currently ${currentPercent}% of all users are routed to branch ${
+      newBranch.name
+    } and ${100 - currentPercent}% of all users are routed to branch ${
+      oldBranch.name
+    }. What percent of users should be directed to the branch ${newBranch.name}?`;
+    percent = await promptForRolloutPercentAsync({ promptMessage });
+  }
+
+  const newBranchMapping = { ...currentBranchMapping };
+  newBranchMapping.data[0].branchMappingLogic.operand = percent / 100;
+
+  const newChannelInfo = await updateChannelBranchMappingAsync({
+    channelId: getUpdateChannelByNameForAppResult.app?.byId.updateChannelByName?.id!,
+    branchMapping: JSON.stringify(newBranchMapping),
+  });
+
+  const logMessage = `️Rollout of branch ${chalk.bold(newBranch.name)} onto channel ${chalk.bold(
+    channelName!
+  )} updated from ${chalk.bold(currentPercent)}% to ${chalk.bold(percent)}%. ${chalk.bold(
+    percent
+  )}% of users will be directed to branch ${chalk.bold(newBranch.name)}, ${chalk.bold(
+    100 - percent
+  )}% to branch ${chalk.bold(oldBranch.name)}.`;
+
+  return { newChannelInfo, logMessage };
+}
+
+async function endRolloutAsync({
+  channelName,
+  branchName,
+  jsonFlag,
+  projectId,
+  getUpdateChannelByNameForAppResult,
+}: {
+  channelName?: string;
+  branchName?: string;
+  jsonFlag: boolean;
+  projectId: string;
+  getUpdateChannelByNameForAppResult: GetChannelByNameForAppQuery;
+}): Promise<{
+  newChannelInfo: {
+    id: string;
+    name: string;
+    branchMapping: string;
+  };
+  logMessage: string;
+}> {
+  // end rollout
+  const { newBranch, oldBranch, currentPercent } = getRolloutInfo(
+    getUpdateChannelByNameForAppResult
+  );
+
+  let endOnNewBranch;
+  if (branchName) {
+    const branch = await getBranchByNameAsync({ appId: projectId, name: branchName! });
+    switch (branch.id) {
+      case newBranch.id:
+        endOnNewBranch = true;
+        break;
+      case oldBranch.id:
+        endOnNewBranch = false;
+        break;
+      default:
+        throw new Error(
+          `The branch "${branchName}" specified by --branch must be one of the branches involved in the rollout: "${newBranch.name}" or "${oldBranch.name}".`
+        );
+    }
+  } else {
+    if (jsonFlag) {
+      throw new Error(
+        'Branch name must be specified with the --branch flag when both the --end and --json flag are true.'
+      );
+    }
+    endOnNewBranch = await selectAsync<boolean>(
+      '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}%`)}`,
+          value: true,
+        },
+        {
+          title: `${oldBranch.name} ${chalk.grey(`- current percent: ${currentPercent}%`)}`,
+          value: false,
+        },
+      ]
+    );
+  }
+  if (endOnNewBranch == null) {
+    throw new Error('Branch to end on is undefined.');
+  }
+
+  const newBranchMapping = {
+    version: 0,
+    data: [
+      {
+        branchId: endOnNewBranch ? newBranch.id : oldBranch.id,
+        branchMappingLogic: 'true',
+      },
+    ],
+  };
+
+  const newChannelInfo = await updateChannelBranchMappingAsync({
+    channelId: getUpdateChannelByNameForAppResult.app?.byId.updateChannelByName?.id!,
+    branchMapping: JSON.stringify(newBranchMapping),
+  });
+  const logMessage = `️Rollout on channel ${chalk.bold(
+    channelName
+  )} ended. All traffic is now sent to branch ${chalk.bold(
+    endOnNewBranch ? newBranch.name : oldBranch.name
+  )}`;
+
+  return { newChannelInfo, logMessage };
+}
+
+export default class ChannelRollout extends Command {
+  static hidden = true;
+  static description = 'Rollout a new branch out to a channel incrementally.';
+
+  static args = [
+    {
+      name: 'channel',
+      required: true,
+      description: 'rollout that the channel is on',
+    },
+  ];
+
+  static flags = {
+    branch: flags.string({
+      description: 'branch to rollout',
+      required: false,
+    }),
+    percent: flags.integer({
+      description: 'percent of traffic to redirect to the new branch',
+      required: false,
+    }),
+    end: flags.boolean({
+      description: 'end the rollout',
+      default: false,
+    }),
+    json: flags.boolean({
+      description: 'print output as a JSON object with the new channel ID, name and branch mapping',
+      default: false,
+    }),
+  };
+
+  async run() {
+    const {
+      args: { channel: channelName },
+      flags: { json: jsonFlag, end: endFlag },
+    } = this.parse(ChannelRollout);
+    const {
+      flags: { branch: branchName, percent },
+    } = this.parse(ChannelRollout);
+
+    const projectDir = await findProjectRootAsync(process.cwd());
+    if (!projectDir) {
+      throw new Error('Please run this command inside a project directory.');
+    }
+    const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
+    const accountName = await getProjectAccountNameAsync(exp);
+    const { slug } = exp;
+    const projectId = await ensureProjectExistsAsync({
+      accountName,
+      projectName: slug,
+    });
+
+    const getUpdateChannelByNameForAppResult = await getUpdateChannelByNameForAppAsync({
+      appId: projectId,
+      channelName: channelName!,
+    });
+    const { branchMapping: currentBranchMapping, isRollout } = getBranchMapping(
+      getUpdateChannelByNameForAppResult.app?.byId.updateChannelByName?.branchMapping
+    );
+
+    if (currentBranchMapping.data.length === 0) {
+      throw new Error('The channel is not pointing at any branches.');
+    }
+    if (currentBranchMapping.data.length > 2) {
+      throw new Error('"channel:rollout" cannot handle branch mappings with more than 2 branches.');
+    }
+    // This combination doesn't make sense. Throw an error explaining the options.
+    if (isRollout && branchName && !endFlag) {
+      throw new Error(
+        `There is a rollout in progress. You can only either edit the rollout percent or 'end' it.`
+      );
+    }
+
+    /**
+     * This if/else block has three branches:
+     *  1. The branch mapping is not a rollout, i.e. it is pointing to a single branch.
+     *  2. The branch mapping is a rollout.
+     *    a. increase/decrease the rollout percentage.
+     *    b. end the rollout.
+     */
+    let rolloutMutationResult: {
+      newChannelInfo: {
+        id: string;
+        name: string;
+        branchMapping: string;
+      };
+      logMessage: string;
+    };
+    if (!isRollout) {
+      rolloutMutationResult = await startRolloutAsync({
+        channelName,
+        branchName,
+        percent,
+        jsonFlag,
+        projectId,
+        fullName: `@${accountName}/${slug}`,
+        currentBranchMapping,
+        getUpdateChannelByNameForAppResult,
+      });
+    } else if (endFlag) {
+      rolloutMutationResult = await endRolloutAsync({
+        channelName,
+        branchName,
+        jsonFlag,
+        projectId,
+        getUpdateChannelByNameForAppResult,
+      });
+    } else {
+      rolloutMutationResult = await editRolloutAsync({
+        channelName,
+        percent,
+        jsonFlag,
+        currentBranchMapping,
+        getUpdateChannelByNameForAppResult,
+      });
+    }
+    if (!rolloutMutationResult) {
+      throw new Error('rollout result is empty');
+    }
+    const { newChannelInfo, logMessage } = rolloutMutationResult;
+    if (jsonFlag) {
+      Log.log(JSON.stringify(newChannelInfo));
+      return;
+    }
+    Log.withTick(logMessage);
+  }
+}
@@ -2,6 +2,7 @@ import { getConfig } from '@expo/config';
 import { Command, flags } from '@oclif/command';
 import chalk from 'chalk';
 import Table from 'cli-table3';
+import { assert } from 'console';
 import gql from 'graphql-tag';

 import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
@@ -13,8 +14,75 @@ import Log from '../../log';
 import { ensureProjectExistsAsync } from '../../project/ensureProjectExists';
 import { findProjectRootAsync, getProjectAccountNameAsync } from '../../project/projectUtils';
 import { promptAsync } from '../../prompts';
+import { FormatUpdateParameter, UPDATE_COLUMNS, formatUpdate } from '../branch/list';

-async function getUpdateChannelByNameForAppAsync({
+export type BranchMapping = {
+  version: number;
+  data: {
+    branchId: string;
+    branchMappingLogic: {
+      operand: number;
+      clientKey: string;
+      branchMappingOperator: string;
+    } & string;
+  }[];
+};
+
+/**
+ * Get the branch mapping and determine whether it is a rollout.
+ * Ensure that the branch mapping is properly formatted.
+ */
+export function getBranchMapping(
+  branchMappingString?: string
+): { branchMapping: BranchMapping; isRollout: boolean; rolloutPercent?: number } {
+  if (!branchMappingString) {
+    throw new Error('Missing branch mapping.');
+  }
+  let branchMapping: BranchMapping;
+  try {
+    branchMapping = JSON.parse(branchMappingString);
+  } catch (e) {
+    throw new Error(`Could not parse branchMapping string into a JSON: "${branchMappingString}"`);
+  }
+  assert(branchMapping, 'Branch Mapping must be defined.');
+
+  if (branchMapping.version !== 0) {
+    throw new Error('Branch mapping must be version 0.');
+  }
+
+  const isRollout = branchMapping.data.length === 2;
+  const rolloutPercent = branchMapping.data[0].branchMappingLogic.operand;
+
+  switch (branchMapping.data.length) {
+    case 0:
+      break;
+    case 1:
+      if (branchMapping.data[0].branchMappingLogic !== 'true') {
+        throw new Error('Branch mapping logic for a single branch must be "true"');
+      }
+      break;
+    case 2:
+      if (branchMapping.data[0].branchMappingLogic.clientKey !== 'rolloutToken') {
+        throw new Error('Client key of initial branch mapping must be "rolloutToken"');
+      }
+      if (branchMapping.data[0].branchMappingLogic.branchMappingOperator !== 'hash_lt') {
+        throw new Error('Branch mapping operator of initial branch mapping must be "hash_lt"');
+      }
+      if (rolloutPercent == null) {
+        throw new Error('Branch mapping is missing a "rolloutPercent"');
+      }
+      if (branchMapping.data[1].branchMappingLogic !== 'true') {
+        throw new Error('Branch mapping logic for a the second branch of a rollout must be "true"');
+      }
+      break;
+    default:
+      throw new Error('Branch mapping data must have length less than or equal to 2.');
+  }
+
+  return { branchMapping, isRollout, rolloutPercent };
+}
+
+export async function getUpdateChannelByNameForAppAsync({
  appId,
  channelName,
 }: GetChannelByNameForAppQueryVariables): Promise<GetChannelByNameForAppQuery> {
@@ -30,18 +98,20 @@ async function getUpdateChannelByNameForAppAsync({
                  id
                  name
                  createdAt
-                  updateBranches(offset: 0, limit: 1) {
+                  branchMapping
+                  updateBranches(offset: 0, limit: 1000) {
                    id
                    name
                    updates(offset: 0, limit: 1) {
                      id
                      group
                      message
+                      runtimeVersion
                      createdAt
                      actor {
                        id
                        ... on User {
-                          firstName
+                          username
                        }
                        ... on Robot {
                          firstName
@@ -60,6 +130,49 @@ async function getUpdateChannelByNameForAppAsync({
  );
 }

+export function logChannelDetails(channel: {
+  branchMapping: string;
+  updateBranches: {
+    updates: (FormatUpdateParameter & { runtimeVersion?: string; group?: string })[];
+    name: string;
+    id: string;
+  }[];
+}): void {
+  const { branchMapping, isRollout, rolloutPercent } = getBranchMapping(channel.branchMapping);
+
+  const table = new Table({
+    head: ['branch', ...(isRollout ? ['rollout percent'] : []), ...UPDATE_COLUMNS],
+    wordWrap: true,
+  });
+
+  for (const index in branchMapping.data) {
+    if (parseInt(index, 10) > 1) {
+      throw new Error('Branch Mapping data must have length less than or equal to 2.');
+    }
+
+    const { branchId } = branchMapping.data[index];
+    const branch = channel.updateBranches.filter(branch => branch.id === branchId)[0];
+    if (!branch) {
+      throw new Error('Branch mapping is pointing at a missing branch.');
+    }
+    const update = branch.updates[0];
+    table.push([
+      branch.name,
+      ...(isRollout
+        ? [
+            parseInt(index, 10) === 0
+              ? `${rolloutPercent! * 100}%`
+              : `${(1 - rolloutPercent!) * 100}%`,
+          ]
+        : []),
+      formatUpdate(update),
+      update?.runtimeVersion ?? 'N/A',
+      update?.group ?? 'N/A,',
+    ]);
+  }
+  Log.log(table.toString());
+}
+
 export default class ChannelView extends Command {
  static hidden = true;
  static description = 'View a channel on the current project.';
@@ -124,28 +237,12 @@ export default class ChannelView extends Command {
      return;
    }

-    const table = new Table({
-      head: ['branch', 'update', 'message', 'created-at', 'actor'],
-      wordWrap: true,
-    });
-
-    for (const branch of channel.updateBranches) {
-      // TODO (cedric): refactor when multiple branches per channel are available
-      const update = branch.updates[0];
-
-      table.push([
-        branch.name,
-        update?.group,
-        update?.message,
-        update?.createdAt && new Date(update.createdAt).toLocaleString(),
-        update?.actor?.firstName,
-      ]);
-    }
-
    Log.withTick(
      chalk`Channel: {bold ${channel.name}} on project {bold ${accountName}/${slug}}. Channel ID: {bold ${channel.id}}`
    );
-    Log.log(chalk`{bold Recent update groups published on this branch:}`);
-    Log.log(table.toString());
+    Log.log(
+      chalk`{bold Branches, pointed at by this channel, and their most recent update group:}`
+    );
+    logChannelDetails(channel);
  }
 }
@@ -1,5 +1,5 @@
 import { getConfig } from '@expo/config';
-import { Command } from '@oclif/command';
+import { Command, flags } from '@oclif/command';
 import chalk from 'chalk';

 import { EnvironmentSecretMutation } from '../../graphql/mutations/EnvironmentSecretMutation';
@@ -12,39 +12,34 @@ import {
 import { findProjectRootAsync, getProjectAccountNameAsync } from '../../project/projectUtils';
 import { promptAsync } from '../../prompts';
 import { findAccountByName } from '../../user/Account';
-import { ensureLoggedInAsync, getActorDisplayName } from '../../user/actions';
+import { getActorDisplayName } from '../../user/User';
+import { ensureLoggedInAsync } from '../../user/actions';

-export enum EnvironmentSecretTargetLocation {
+export enum EnvironmentSecretScope {
  ACCOUNT = 'account',
  PROJECT = 'project',
 }
 export default class EnvironmentSecretCreate extends Command {
-  static hidden = true;
  static description = 'Create an environment secret on the current project or owner account.';

-  static args = [
-    {
-      name: 'target',
-      required: false,
-      description: 'Target location for the secret',
-      options: [EnvironmentSecretTargetLocation.ACCOUNT, EnvironmentSecretTargetLocation.PROJECT],
-    },
-    {
-      name: 'name',
-      required: false,
+  static flags = {
+    scope: flags.enum({
+      description: 'Scope for the secret',
+      options: [EnvironmentSecretScope.ACCOUNT, EnvironmentSecretScope.PROJECT],
+      default: EnvironmentSecretScope.PROJECT,
+    }),
+    name: flags.string({
      description: 'Name of the secret',
-    },
-    {
-      name: 'value',
-      required: false,
+    }),
+    value: flags.string({
      description: 'Value of the secret',
-    },
-  ];
+    }),
+  };

  async run() {
-    const user = await ensureLoggedInAsync();
+    const actor = await ensureLoggedInAsync();
    let {
-      args: { name, value: secretValue, target },
+      flags: { name, value: secretValue, scope },
    } = this.parse(EnvironmentSecretCreate);

    const projectDir = (await findProjectRootAsync()) ?? process.cwd();
@@ -63,16 +58,16 @@ export default class EnvironmentSecretCreate extends Command {
      return;
    }

-    if (!target) {
-      const validationMessage = 'Secret target may not be empty.';
+    if (!scope) {
+      const validationMessage = 'Secret scope may not be empty.';

-      ({ target } = await promptAsync({
+      ({ scope } = await promptAsync({
        type: 'select',
-        name: 'target',
+        name: 'scope',
        message: 'Where should this secret be used:',
        choices: [
-          { title: 'Account-wide', value: EnvironmentSecretTargetLocation.ACCOUNT },
-          { title: 'Project-specific', value: EnvironmentSecretTargetLocation.PROJECT },
+          { title: 'Account-wide', value: EnvironmentSecretScope.ACCOUNT },
+          { title: 'Project-specific', value: EnvironmentSecretScope.PROJECT },
        ],
        validate: value => (value ? true : validationMessage),
      }));
@@ -88,13 +83,17 @@ export default class EnvironmentSecretCreate extends Command {
            return 'Secret name may not be empty.';
          }

-          if (value.match(/^\w+$/)) {
+          // this validation regex here is just to shorten the feedback loop
+          // the source of truth is in www's EnvironmentSecretValidator class
+          if (!value.match(/^\w+$/)) {
            return 'Names may contain only letters, numbers, and underscores.';
          }

          return true;
        },
      }));
+
+      if (!name) throw new Error('Secret name may not be empty.');
    }

    if (!secretValue) {
@@ -106,9 +105,11 @@ export default class EnvironmentSecretCreate extends Command {
        message: 'Secret value:',
        validate: value => (value ? true : validationMessage),
      }));
+
+      if (!secretValue) throw new Error(validationMessage);
    }

-    if (target === EnvironmentSecretTargetLocation.PROJECT) {
+    if (scope === EnvironmentSecretScope.PROJECT) {
      const secret = await EnvironmentSecretMutation.createForApp(
        { name, value: secretValue },
        projectId
@@ -124,11 +125,11 @@ export default class EnvironmentSecretCreate extends Command {
          `@${accountName}/${slug}`
        )}.`
      );
-    } else if (target === EnvironmentSecretTargetLocation.ACCOUNT) {
-      const ownerAccount = findAccountByName(user.accounts, accountName);
+    } else if (scope === EnvironmentSecretScope.ACCOUNT) {
+      const ownerAccount = findAccountByName(actor.accounts, accountName);
      if (!ownerAccount) {
        Log.warn(
-          `Your account (${getActorDisplayName(user)}) doesn't have access to the ${chalk.bold(
+          `Your account (${getActorDisplayName(actor)}) doesn't have access to the ${chalk.bold(
            accountName
          )} account`
        );
@@ -0,0 +1,100 @@
+import { getConfig } from '@expo/config';
+import { Command, flags } from '@oclif/command';
+import chalk from 'chalk';
+
+import { EnvironmentSecretMutation } from '../../graphql/mutations/EnvironmentSecretMutation';
+import {
+  EnvironmentSecretWithScope,
+  EnvironmentSecretsQuery,
+} from '../../graphql/queries/EnvironmentSecretsQuery';
+import Log from '../../log';
+import {
+  isEasEnabledForProjectAsync,
+  warnEasUnavailable,
+} from '../../project/isEasEnabledForProject';
+import {
+  findProjectRootAsync,
+  getProjectAccountNameAsync,
+  getProjectFullNameAsync,
+  getProjectIdAsync,
+} from '../../project/projectUtils';
+import { promptAsync, toggleConfirmAsync } from '../../prompts';
+import { ensureLoggedInAsync } from '../../user/actions';
+import { EnvironmentSecretScope } from './create';
+
+export default class EnvironmentSecretDelete extends Command {
+  static description = `Delete an environment secret by ID.
+Unsure where to find the secret's ID? Run ${chalk.bold('eas secrets:list')}`;
+
+  static flags = {
+    id: flags.string({
+      description: 'ID of the secret to delete',
+    }),
+  };
+
+  async run() {
+    await ensureLoggedInAsync();
+
+    const projectDir = (await findProjectRootAsync()) ?? process.cwd();
+    const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
+    const projectId = await getProjectIdAsync(exp);
+    const projectFullName = await getProjectFullNameAsync(exp);
+    const projectAccountName = await getProjectAccountNameAsync(exp);
+
+    if (!(await isEasEnabledForProjectAsync(projectId))) {
+      warnEasUnavailable();
+      process.exitCode = 1;
+      return;
+    }
+
+    let {
+      flags: { id },
+    } = this.parse(EnvironmentSecretDelete);
+    let secret: EnvironmentSecretWithScope | undefined;
+
+    if (!id) {
+      const validationMessage = 'You must select which secret to delete.';
+
+      const secrets = await EnvironmentSecretsQuery.allAsync(projectAccountName, projectFullName);
+
+      ({ secret } = await promptAsync({
+        type: 'autocomplete',
+        name: 'secret',
+        message: 'Pick the secret to be deleted:',
+        choices: secrets.map(secret => ({
+          title: `${secret.name} (${secret.scope})`,
+          value: secret,
+        })),
+      }));
+
+      id = secret?.id;
+
+      if (!id) throw new Error(validationMessage);
+    }
+
+    Log.addNewLineIfNone();
+    Log.warn(
+      `You are about to permamently delete secret${
+        secret?.name ? ` "${secret?.name}"` : ''
+      } with id: "${id}".\nThis action is irreversible.`
+    );
+    Log.newLine();
+    const confirmed = await toggleConfirmAsync({
+      message: `Are you sure you wish to proceed?${
+        secret?.scope === EnvironmentSecretScope.ACCOUNT
+          ? ' This secret is applied across your whole account and may affect multiple apps.'
+          : ''
+      }`,
+    });
+    if (!confirmed) {
+      Log.error(
+        `Canceled deletion of secret${secret?.name ? ` "${secret?.name}"` : ''} with id: "${id}".`
+      );
+      process.exit(1);
+    }
+
+    await EnvironmentSecretMutation.delete(id);
+
+    Log.withTick(`️Deleted secret${secret?.name ? ` "${secret?.name}"` : ''} with id "${id}".`);
+  }
+}
@@ -4,7 +4,6 @@ import chalk from 'chalk';
 import Table from 'cli-table3';
 import dateFormat from 'dateformat';

-import { EnvironmentSecretFragment } from '../../graphql/generated';
 import { EnvironmentSecretsQuery } from '../../graphql/queries/EnvironmentSecretsQuery';
 import Log from '../../log';
 import {
@@ -18,11 +17,9 @@ import {
  getProjectIdAsync,
 } from '../../project/projectUtils';
 import { ensureLoggedInAsync } from '../../user/actions';
-import { EnvironmentSecretTargetLocation } from './create';

-export default class EnvironmentSecretsList extends Command {
+export default class EnvironmentSecretList extends Command {
  static description = 'Lists environment secrets available for your current app';
-  static usage = 'secrets:list';

  async run(): Promise<void> {
    await ensureLoggedInAsync();
@@ -43,24 +40,16 @@ export default class EnvironmentSecretsList extends Command {
      throw new Error("Please run this command inside your project's directory");
    }

-    const [accountSecrets, appSecrets] = await Promise.all([
-      EnvironmentSecretsQuery.byAcccountNameAsync(projectAccountName),
-      EnvironmentSecretsQuery.byAppFullNameAsync(projectFullName),
-    ]);
-
-    const secrets = [
-      ...appSecrets.map(s => ({ ...s, target: EnvironmentSecretTargetLocation.PROJECT })),
-      ...accountSecrets.map(s => ({ ...s, target: EnvironmentSecretTargetLocation.ACCOUNT })),
-    ] as (EnvironmentSecretFragment & { target: EnvironmentSecretTargetLocation })[];
+    const secrets = await EnvironmentSecretsQuery.allAsync(projectAccountName, projectFullName);

    const table = new Table({
-      head: ['Name', 'Target', 'Updated at', 'ID'],
+      head: ['Name', 'Scope', 'ID', 'Updated at'],
      wordWrap: true,
    });

    for (const secret of secrets) {
-      const { name, createdAt: updatedAt, target, id } = secret;
-      table.push([name, target, dateFormat(updatedAt, 'mmm dd HH:MM:ss'), id]);
+      const { name, createdAt: updatedAt, scope, id } = secret;
+      table.push([name, scope, id, dateFormat(updatedAt, 'mmm dd HH:MM:ss')]);
    }

    Log.log(chalk`{bold Secrets for this account and project:}`);
@@ -1,61 +0,0 @@
-import { getConfig } from '@expo/config';
-import { Command } from '@oclif/command';
-
-import { EnvironmentSecretMutation } from '../../graphql/mutations/EnvironmentSecretMutation';
-import Log from '../../log';
-import {
-  isEasEnabledForProjectAsync,
-  warnEasUnavailable,
-} from '../../project/isEasEnabledForProject';
-import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
-import { toggleConfirmAsync } from '../../prompts';
-import { ensureLoggedInAsync } from '../../user/actions';
-
-export default class EnvironmentSecretDelete extends Command {
-  static hidden = true;
-  static description = `
-Delete an environment secret by ID.
-Unsure where to find the secret's ID? Run ${'`eas secrets:list`'}
-  `;
-
-  static args = [
-    {
-      name: 'id',
-      required: true,
-      description: `ID of the secret to delete`,
-    },
-  ];
-
-  async run() {
-    await ensureLoggedInAsync();
-
-    const projectDir = (await findProjectRootAsync()) ?? process.cwd();
-    const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
-    const projectId = await getProjectIdAsync(exp);
-
-    if (!(await isEasEnabledForProjectAsync(projectId))) {
-      warnEasUnavailable();
-      process.exitCode = 1;
-      return;
-    }
-
-    const {
-      args: { id },
-    } = this.parse(EnvironmentSecretDelete);
-
-    Log.addNewLineIfNone();
-    Log.warn(
-      `You are about to permamently delete secret with id: "${id}".\nThis action is irreversable.`
-    );
-    Log.newLine();
-    const confirmed = await toggleConfirmAsync({ message: 'Are you sure you wish to proceed?' });
-    if (!confirmed) {
-      Log.error(`Canceled deletion of secret with id: "${id}".`);
-      process.exit(1);
-    }
-
-    await EnvironmentSecretMutation.delete(id);
-
-    Log.withTick(`️Deleted secret with id "${id}".`);
-  }
-}
@@ -1,17 +1,14 @@
 import { getConfig } from '@expo/config';
 import { Command, flags } from '@oclif/command';

+import { AppPlatform } from '../graphql/generated';
 import { learnMore } from '../log';
 import { isEasEnabledForProjectAsync, warnEasUnavailable } from '../project/isEasEnabledForProject';
 import { findProjectRootAsync, getProjectIdAsync } from '../project/projectUtils';
 import { promptAsync } from '../prompts';
 import AndroidSubmitCommand from '../submissions/android/AndroidSubmitCommand';
 import IosSubmitCommand from '../submissions/ios/IosSubmitCommand';
-import {
-  AndroidSubmitCommandFlags,
-  IosSubmitCommandFlags,
-  SubmissionPlatform,
-} from '../submissions/types';
+import { AndroidSubmitCommandFlags, IosSubmitCommandFlags } from '../submissions/types';
 import { ensureLoggedInAsync } from '../user/actions';

 const COMMON_FLAGS = '';
@@ -159,14 +156,15 @@ export default class BuildSubmit extends Command {
        'company-name': companyName,

        // common
-        platform: platformFromParams,
        ...flags
      },
    } = this.parse(BuildSubmit);

    await ensureLoggedInAsync();

-    const platform = platformFromParams ?? (await promptForPlatformAsync());
+    const platform =
+      (flags.platform?.toUpperCase() as AppPlatform | undefined) ??
+      (await promptForPlatformAsync());

    const projectDir = (await findProjectRootAsync()) ?? process.cwd();
    const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
@@ -183,7 +181,7 @@ export default class BuildSubmit extends Command {
      throw new Error("Please run this command inside your project's directory");
    }

-    if (platform === SubmissionPlatform.Android) {
+    if (platform === AppPlatform.Android) {
      const options: AndroidSubmitCommandFlags = {
        androidPackage,
        releaseStatus,
@@ -193,7 +191,7 @@ export default class BuildSubmit extends Command {
      const ctx = AndroidSubmitCommand.createContext(projectDir, projectId, options);
      const command = new AndroidSubmitCommand(ctx);
      await command.runAsync();
-    } else if (platform === SubmissionPlatform.iOS) {
+    } else if (platform === AppPlatform.Ios) {
      const options: IosSubmitCommandFlags = {
        appleId,
        ascAppId,
@@ -213,7 +211,7 @@ export default class BuildSubmit extends Command {
  }
 }

-async function promptForPlatformAsync(): Promise<SubmissionPlatform> {
+async function promptForPlatformAsync(): Promise<AppPlatform> {
  const { platform } = await promptAsync({
    type: 'select',
    message: 'Submit to platform',
@@ -221,11 +219,11 @@ async function promptForPlatformAsync(): Promise<SubmissionPlatform> {
    choices: [
      {
        title: 'iOS',
-        value: SubmissionPlatform.iOS,
+        value: AppPlatform.Ios,
      },
      {
        title: 'Android',
-        value: SubmissionPlatform.Android,
+        value: AppPlatform.Android,
      },
    ],
  });
@@ -0,0 +1,88 @@
+import { Command, flags } from '@oclif/command';
+import chalk from 'chalk';
+import gql from 'graphql-tag';
+
+import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
+import {
+  DeleteUpdateGroupMutation,
+  UpdateMutationDeleteUpdateGroupArgs,
+} from '../../graphql/generated';
+import Log from '../../log';
+import { confirmAsync } from '../../prompts';
+
+async function deleteUpdateGroupAsync({
+  group,
+}: {
+  group: string;
+}): Promise<DeleteUpdateGroupMutation> {
+  return await withErrorHandlingAsync(
+    graphqlClient
+      .mutation<DeleteUpdateGroupMutation, UpdateMutationDeleteUpdateGroupArgs>(
+        gql`
+          mutation DeleteUpdateGroup($group: ID!) {
+            update {
+              deleteUpdateGroup(group: $group) {
+                group
+              }
+            }
+          }
+        `,
+        { group }
+      )
+      .toPromise()
+  );
+}
+
+export default class UpdateDelete extends Command {
+  static hidden = true;
+  static description = 'Delete all the updates in an update Group.';
+
+  static args = [
+    {
+      name: 'groupId',
+      required: true,
+      description: 'The ID of an update group to delete.',
+    },
+  ];
+
+  static flags = {
+    json: flags.boolean({
+      description: `Return a json with the group ID of the deleted updates.`,
+      default: false,
+    }),
+  };
+
+  async run() {
+    const {
+      args: { groupId: group },
+      flags: { json: jsonFlag },
+    } = this.parse(UpdateDelete);
+
+    if (!jsonFlag) {
+      const shouldAbort = await confirmAsync({
+        message:
+          `🚨${chalk.red('CAUTION')}🚨\n\n` +
+          `${chalk.yellow(`This will delete all of the updates in group "${group}".`)} ${chalk.red(
+            'This is a permanent operation.'
+          )}\n\n` +
+          `If you want to revert to a previous publish, you should use 'branch:publish --republish' targeted at the last working update group instead.\n\n` +
+          `An update group should only be deleted in an emergency like an accidental publish of a secret. In this case user 'branch:publish --republish' to revert to the last working update group first and then proceed with the deletion. Deleting an update group when it is the latest publish can lead to inconsistent cacheing behavior by clients.\n\n` +
+          `Would you like to abort?`,
+      });
+
+      if (shouldAbort) {
+        Log.log('Aborted.');
+        return;
+      }
+    }
+
+    await deleteUpdateGroupAsync({ group });
+
+    if (jsonFlag) {
+      Log.log(JSON.stringify({ group }));
+      return;
+    }
+
+    Log.withTick(`Deleted update group ${group}`);
+  }
+}
@@ -1,10 +0,0 @@
-import { Command } from '@oclif/command';
-
-export default class UpdateShow extends Command {
-  static hidden = true;
-  static description = 'details about a particular revision';
-
-  async run() {
-    throw new Error('Not implemented');
-  }
-}
@@ -0,0 +1,99 @@
+import { Command, flags } from '@oclif/command';
+import Table from 'cli-table3';
+import gql from 'graphql-tag';
+
+import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
+import { UpdatesByGroupQuery, UpdatesByGroupQueryVariables } from '../../graphql/generated';
+import Log from '../../log';
+import { UPDATE_COLUMNS, formatUpdate } from '../branch/list';
+
+export async function viewUpdateAsync({
+  groupId,
+}: {
+  groupId: string;
+}): Promise<UpdatesByGroupQuery> {
+  const data = await withErrorHandlingAsync(
+    graphqlClient
+      .query<UpdatesByGroupQuery, UpdatesByGroupQueryVariables>(
+        gql`
+          query UpdatesByGroup($groupId: ID!) {
+            updatesByGroup(group: $groupId) {
+              id
+              group
+              runtimeVersion
+              platform
+              message
+              actor {
+                id
+                ... on User {
+                  username
+                }
+                ... on Robot {
+                  firstName
+                }
+              }
+              createdAt
+            }
+          }
+        `,
+        {
+          groupId,
+        }
+      )
+      .toPromise()
+  );
+  if (data.updatesByGroup.length === 0) {
+    throw new Error(`Could not find any updates with group ID: "${groupId}"`);
+  }
+  return data;
+}
+export default class UpdateView extends Command {
+  static hidden = true;
+  static description = 'Update group details.';
+
+  static args = [
+    {
+      name: 'groupId',
+      required: true,
+      description: 'The ID of an update group.',
+    },
+  ];
+
+  static flags = {
+    json: flags.boolean({
+      description: `Return a json with the updates belonging to the group.`,
+      default: false,
+    }),
+  };
+
+  async run() {
+    const {
+      args: { groupId },
+      flags: { json: jsonFlag },
+    } = this.parse(UpdateView);
+
+    const { updatesByGroup } = await viewUpdateAsync({ groupId });
+
+    if (jsonFlag) {
+      Log.log(JSON.stringify(updatesByGroup));
+      return;
+    }
+
+    const groupTable = new Table({
+      head: [...UPDATE_COLUMNS, 'platforms'],
+      wordWrap: true,
+    });
+
+    // The relevant info of the updates are same except for their platform
+    const platforms = updatesByGroup.map(update => update.platform);
+    const representativeUpdate = updatesByGroup[0];
+    groupTable.push([
+      formatUpdate(representativeUpdate),
+      representativeUpdate.runtimeVersion,
+      representativeUpdate.group,
+      platforms.join(','),
+    ]);
+
+    Log.log(groupTable.toString());
+  }
+}
@@ -0,0 +1,50 @@
+import { getConfig } from '@expo/config';
+import { Command, flags } from '@oclif/command';
+import ora from 'ora';
+
+import { WebhookType } from '../../graphql/generated';
+import { WebhookMutation } from '../../graphql/mutations/WebhookMutation';
+import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
+import { ensureLoggedInAsync } from '../../user/actions';
+import { prepareInputParamsAsync } from '../../webhooks/input';
+
+export default class WebhookCreate extends Command {
+  static description = 'Create a webhook on the current project.';
+
+  static flags = {
+    event: flags.enum({
+      description: 'Event type that triggers the webhook',
+      options: [WebhookType.Build],
+      default: WebhookType.Build,
+    }),
+    url: flags.string({
+      description: 'Webhook URL',
+    }),
+    secret: flags.string({
+      description:
+        "Secret used to create a hash signature of the request payload, provided in the 'Expo-Signature' header.",
+    }),
+  };
+
+  async run() {
+    await ensureLoggedInAsync();
+    const { flags } = this.parse(WebhookCreate);
+    const webhookInputParams = await prepareInputParamsAsync(flags);
+
+    const projectDir = await findProjectRootAsync(process.cwd());
+    if (!projectDir) {
+      throw new Error('Please run this command inside a project directory.');
+    }
+    const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
+    const projectId = await getProjectIdAsync(exp);
+
+    const spinner = ora('Creating a webhook').start();
+    try {
+      await WebhookMutation.createWebhookAsync(projectId, webhookInputParams);
+      spinner.succeed('Successfully created a webhook');
+    } catch (err) {
+      spinner.fail('Failed to create a webhook');
+      throw err;
+    }
+  }
+}
@@ -0,0 +1,102 @@
+import { getConfig } from '@expo/config';
+import { Command } from '@oclif/command';
+import assert from 'assert';
+import chalk from 'chalk';
+import nullthrows from 'nullthrows';
+import ora from 'ora';
+
+import { WebhookFragment } from '../../graphql/generated';
+import { WebhookMutation } from '../../graphql/mutations/WebhookMutation';
+import { WebhookQuery } from '../../graphql/queries/WebhookQuery';
+import Log from '../../log';
+import { findProjectRootAsync, getProjectIdAsync } from '../../project/projectUtils';
+import { promptAsync, toggleConfirmAsync } from '../../prompts';
+import { ensureLoggedInAsync } from '../../user/actions';
+import { formatWebhook } from '../../webhooks/formatWebhook';
+
+export default class WebhookDelete extends Command {
+  static description = 'Delete a webhook on the current project.';
+
+  static args = [
+    {
+      name: 'ID',
+      required: false,
+      description: 'ID of the webhook to delete',
+    },
+  ];
+
+  async run() {
+    await ensureLoggedInAsync();
+    let {
+      args: { ID: webhookId },
+    } = this.parse(WebhookDelete);
+
+    const projectDir = await findProjectRootAsync(process.cwd());
+    if (!projectDir) {
+      throw new Error('Please run this command inside a project directory.');
+    }
+    const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
+    const projectId = await getProjectIdAsync(exp);
+
+    let webhook: WebhookFragment | undefined =
+      webhookId && (await WebhookQuery.byIdAsync(webhookId));
+    if (!webhookId) {
+      const webhooks = await fetchWebhooksByAppIdAsync(projectId);
+      if (webhooks.length === 0) {
+        process.exit(1);
+      }
+      ({ webhook } = await promptAsync({
+        type: 'autocomplete',
+        name: 'webhook',
+        message: 'Pick the webhook to be deleted:',
+        choices: webhooks.map(i => ({
+          title: `${chalk.bold(i.url)} (Event: ${i.event}, ID: ${i.id})`,
+          value: i,
+        })),
+      }));
+      webhookId = nullthrows(webhook).id;
+    }
+
+    assert(webhook, 'Webhook must be defined here');
+
+    Log.addNewLineIfNone();
+    Log.log(formatWebhook(webhook));
+    Log.newLine();
+    Log.warn(`You are about to permamently delete this webhook.\nThis action is irreversible.`);
+    Log.newLine();
+    const confirmed = await toggleConfirmAsync({
+      message: 'Are you sure you wish to proceed?',
+    });
+
+    if (!confirmed) {
+      Log.error(`Canceled deletion of the webhook`);
+      process.exit(1);
+    }
+
+    const spinner = ora('Deleting the webhook').start();
+    try {
+      await WebhookMutation.deleteWebhookAsync(webhookId);
+      spinner.succeed('Successfully deleted the webhook');
+    } catch (err) {
+      spinner.fail('Failed to delete the webhook');
+      throw err;
+    }
+  }
+}
+
+async function fetchWebhooksByAppIdAsync(appId: string): Promise<WebhookFragment[]> {
+  const spinner = ora('Fetching webhooks').start();
+  try {
+    const webhooks = await WebhookQuery.byAppIdAsync(appId);
+    if (webhooks.length === 0) {
+      spinner.fail('There are no webhooks on the project');
+      return [];
+    } else {
+      spinner.succeed(`Successfully fetched ${webhooks.length} webhooks`);
+      return webhooks;
+    }
+  } catch (err) {
+    spinner.fail("Something went wrong and we couldn't fetch the webhook list");
+    throw err;
+  }
+}
@@ -0,0 +1,60 @@
+import { getConfig } from '@expo/config';
+import { Command, flags } from '@oclif/command';
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { WebhookType } from '../../graphql/generated';
+import { WebhookQuery } from '../../graphql/queries/WebhookQuery';
+import Log from '../../log';
+import {
+  findProjectRootAsync,
+  getProjectFullNameAsync,
+  getProjectIdAsync,
+} from '../../project/projectUtils';
+import { ensureLoggedInAsync } from '../../user/actions';
+import { formatWebhook } from '../../webhooks/formatWebhook';
+
+export default class WebhookList extends Command {
+  static description = 'List webhooks on the current project.';
+
+  static flags = {
+    event: flags.enum({
+      description: 'Event type that triggers the webhook',
+      options: [WebhookType.Build],
+    }),
+  };
+
+  async run() {
+    await ensureLoggedInAsync();
+    const {
+      flags: { event },
+    } = this.parse(WebhookList);
+
+    const projectDir = await findProjectRootAsync(process.cwd());
+    if (!projectDir) {
+      throw new Error('Please run this command inside a project directory.');
+    }
+    const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
+    const projectId = await getProjectIdAsync(exp);
+    const projectFullName = await getProjectFullNameAsync(exp);
+
+    const spinner = ora(`Fetching the list of webhook on project ${projectFullName}`).start();
+    try {
+      const webhooks = await WebhookQuery.byAppIdAsync(projectId, event && { event });
+      if (webhooks.length === 0) {
+        spinner.fail(`There are no webhooks on project ${projectFullName}`);
+      } else {
+        spinner.succeed(`Found ${webhooks.length} webhooks on project ${projectFullName}`);
+        const list = webhooks
+          .map(webhook => formatWebhook(webhook))
+          .join(`\n\n${chalk.dim('———')}\n\n`);
+        Log.log(`\n${list}`);
+      }
+    } catch (err) {
+      spinner.fail(
+        `Something went wrong and we couldn't fetch the webhook list for the project ${projectFullName}`
+      );
+      throw err;
+    }
+  }
+}
@@ -0,0 +1,54 @@
+import { Command, flags } from '@oclif/command';
+import pick from 'lodash/pick';
+import ora from 'ora';
+
+import { WebhookType } from '../../graphql/generated';
+import { WebhookMutation } from '../../graphql/mutations/WebhookMutation';
+import { WebhookQuery } from '../../graphql/queries/WebhookQuery';
+import { ensureLoggedInAsync } from '../../user/actions';
+import { prepareInputParamsAsync } from '../../webhooks/input';
+
+export default class WebhookUpdate extends Command {
+  static description = 'Create a webhook on the current project.';
+
+  static flags = {
+    id: flags.string({
+      description: 'Webhook ID',
+      required: true,
+    }),
+    event: flags.enum({
+      description: 'Event type that triggers the webhook',
+      options: [WebhookType.Build],
+      default: WebhookType.Build,
+    }),
+    url: flags.string({
+      description: 'Webhook URL',
+    }),
+    secret: flags.string({
+      description:
+        "Secret used to create a hash signature of the request payload, provided in the 'Expo-Signature' header.",
+    }),
+  };
+
+  async run() {
+    await ensureLoggedInAsync();
+    const { flags } = this.parse(WebhookUpdate);
+
+    const webhookId = flags.id;
+
+    const webhook = await WebhookQuery.byIdAsync(webhookId);
+    const webhookInputParams = await prepareInputParamsAsync(
+      pick(flags, ['event', 'url', 'secret']),
+      webhook
+    );
+
+    const spinner = ora('Updating a webhook').start();
+    try {
+      await WebhookMutation.updateWebhookAsync(webhookId, webhookInputParams);
+      spinner.succeed('Successfully updated a webhook');
+    } catch (err) {
+      spinner.fail('Failed to update a webhook');
+      throw err;
+    }
+  }
+}
@@ -0,0 +1,36 @@
+import { Command } from '@oclif/command';
+import ora from 'ora';
+
+import { WebhookQuery } from '../../graphql/queries/WebhookQuery';
+import Log from '../../log';
+import { ensureLoggedInAsync } from '../../user/actions';
+import { formatWebhook } from '../../webhooks/formatWebhook';
+
+export default class WebhookView extends Command {
+  static description = 'View a webhook on the current project.';
+
+  static args = [
+    {
+      name: 'ID',
+      required: true,
+      description: 'ID of the webhook to view',
+    },
+  ];
+
+  async run() {
+    await ensureLoggedInAsync();
+    const {
+      args: { ID: webhookId },
+    } = this.parse(WebhookView);
+
+    const spinner = ora(`Fetching the webhook details for ID ${webhookId}`).start();
+    try {
+      const webhook = await WebhookQuery.byIdAsync(webhookId);
+      spinner.succeed(`Found the webhook details`);
+      Log.log(`\n${formatWebhook(webhook)}`);
+    } catch (err) {
+      spinner.fail(`Couldn't find the webhook with ID ${webhookId}`);
+      throw err;
+    }
+  }
+}
@@ -1,8 +0,0 @@
-import { Platform } from '@expo/eas-build-job';
-
-export interface CredentialsProvider {
-  platform: Platform;
-  hasRemoteAsync(): Promise<boolean>;
-  hasLocalAsync(): Promise<boolean>;
-  isLocalSyncedAsync(): Promise<boolean>;
-}
@@ -1,3 +1,11 @@
+import { AuthCtx } from '../ios/appstore/authenticate';
+
+export const testAuthCtx: AuthCtx = {
+  appleId: 'test-apple-id',
+  appleIdPassword: 'test-apple-password',
+  team: { id: 'test-team-id', name: 'test-team-name', inHouse: false },
+};
+
 export function getAppstoreMock() {
  return {
    ensureAuthenticatedAsync: jest.fn(),
@@ -5,6 +5,7 @@ export const jester: Actor = {
  id: 'jester-id',
  username: 'jester',
  accounts: [{ id: 'jester-account-id', name: 'jester' }],
+  isExpoAdmin: false,
 };

 export const jester2: Actor = {
@@ -12,6 +13,7 @@ export const jester2: Actor = {
  id: 'jester2-id',
  username: 'jester2',
  accounts: [{ id: 'jester2-account-id', name: 'jester2' }],
+  isExpoAdmin: false,
 };

 export const testUsername = jester.username;
@@ -37,5 +37,5 @@ export function createManagerMock(mockOverride: Record<string, any> = {}): Crede
      }),
    },
    mockOverride
-  );
+  ) as any;
 }
@@ -2,8 +2,12 @@ import {
  AppFragment,
  AppleAppIdentifierFragment,
  AppleDistributionCertificateFragment,
+  AppleProvisioningProfileFragment,
  AppleTeamFragment,
+  IosAppBuildCredentialsFragment,
+  IosDistributionType,
 } from '../../graphql/generated';
+import { IosAppCredentialsWithBuildCredentialsQueryResult } from '../ios/api/graphql/queries/IosAppCredentialsQuery';
 import {
  DistributionCertificate,
  DistributionCertificateStoreInfo,
@@ -56,6 +60,17 @@ export const testAppFragment: AppFragment = {
  slug: 'testapp',
 };

+export const testProvisioningProfileFragment: AppleProvisioningProfileFragment = {
+  id: 'test-prov-prof-id-1',
+  expiration: new Date(),
+  developerPortalIdentifier: 'test-developer-identifier',
+  provisioningProfile: 'test-provisioning-profile',
+  updatedAt: new Date(),
+  status: 'Active',
+  appleTeam: { ...testAppleTeamFragment },
+  appleDevices: [],
+};
+
 export const testDistCertFragmentNoDependencies: AppleDistributionCertificateFragment = {
  id: 'test-dist-cert-id-1',
  certificateP12: 'Y2VydHAxMg==',
@@ -95,6 +110,18 @@ export const testDistCertFragmentOneDependency: AppleDistributionCertificateFrag
  ],
 };

+export const testIosAppBuildCredentialsFragment: IosAppBuildCredentialsFragment = {
+  id: 'test-ios-app-build-credentials-id',
+  iosDistributionType: IosDistributionType.AppStore,
+  distributionCertificate: testDistCertFragmentNoDependencies,
+  provisioningProfile: testProvisioningProfileFragment,
+};
+
+export const testIosAppCredentialsWithBuildCredentialsQueryResult: IosAppCredentialsWithBuildCredentialsQueryResult = {
+  id: 'test-app-credential-id',
+  iosAppBuildCredentialsArray: [testIosAppBuildCredentialsFragment],
+};
+
 export const testDistCert: DistributionCertificate = {
  certP12: 'Y2VydHAxMg==',
  certPassword: 'test-password',
@@ -106,7 +106,7 @@ export function getNewIosApiMockWithoutCredentials() {
    createOrUpdateIosAppBuildCredentialsAsync: jest.fn(),
    getIosAppCredentialsWithBuildCredentialsAsync: jest.fn(),
    createOrGetExistingIosAppCredentialsWithBuildCredentialsAsync: jest.fn(),
-    createOrGetExistingAppleTeamAsync: jest.fn(),
+    createOrGetExistingAppleTeamAsync: () => testAppleTeam,
    createOrGetExistingAppleAppIdentifierAsync: jest.fn(),
    getDevicesForAppleTeamAsync: jest.fn(),
    createProvisioningProfileAsync: jest.fn(),
@@ -1,9 +1,7 @@
 import { Platform } from '@expo/eas-build-job';
 import { CredentialsSource } from '@expo/eas-json';

-import Log from '../../log';
 import { CredentialsManager } from '../CredentialsManager';
-import { CredentialsProvider } from '../CredentialsProvider';
 import { Context } from '../context';
 import * as credentialsJsonReader from '../credentialsJson/read';
 import { SetupBuildCredentials } from './actions/SetupBuildCredentials';
@@ -23,7 +21,7 @@ interface Options {
  skipCredentialsCheck?: boolean;
 }

-export default class AndroidCredentialsProvider implements CredentialsProvider {
+export default class AndroidCredentialsProvider {
  public readonly platform = Platform.ANDROID;

  constructor(private ctx: Context, private options: Options) {}
@@ -33,45 +31,6 @@ export default class AndroidCredentialsProvider implements CredentialsProvider {
    return `@${accountName}/${projectName}`;
  }

-  public async hasRemoteAsync(): Promise<boolean> {
-    const keystore = await this.ctx.android.fetchKeystoreAsync(this.projectFullName);
-    return !!keystore;
-  }
-
-  public async hasLocalAsync(): Promise<boolean> {
-    if (!(await credentialsJsonReader.fileExistsAsync(this.ctx.projectDir))) {
-      return false;
-    }
-    try {
-      const rawCredentialsJson = await credentialsJsonReader.readRawAsync(this.ctx.projectDir);
-      return !!rawCredentialsJson?.android;
-    } catch (err) {
-      Log.error(err); // malformed json
-      return false;
-    }
-  }
-
-  public async isLocalSyncedAsync(): Promise<boolean> {
-    try {
-      const [remote, local] = await Promise.all([
-        this.ctx.android.fetchKeystoreAsync(this.projectFullName),
-        credentialsJsonReader.readAndroidCredentialsAsync(this.ctx.projectDir),
-      ]);
-      const r = remote;
-      const l = local?.keystore;
-      return !!(
-        r &&
-        l &&
-        r.keystore === l.keystore &&
-        r.keystorePassword === l.keystorePassword &&
-        r.keyAlias === l.keyAlias &&
-        r.keyPassword === l.keyPassword
-      );
-    } catch (_) {
-      return false;
-    }
-  }
-
  public async getCredentialsAsync(
    src: CredentialsSource.LOCAL | CredentialsSource.REMOTE
  ): Promise<AndroidCredentials> {
@@ -81,7 +40,6 @@ export default class AndroidCredentialsProvider implements CredentialsProvider {
      case CredentialsSource.REMOTE:
        return await this.getRemoteAsync();
    }
-    throw new Error('Unknown');
  }

  private async getRemoteAsync(): Promise<AndroidCredentials> {
@@ -5,10 +5,10 @@ import pick from 'lodash/pick';
 import Log from '../log';
 import { getProjectAccountName } from '../project/projectUtils';
 import { confirmAsync } from '../prompts';
-import { Actor } from '../user/User';
-import { ensureLoggedInAsync, getActorDisplayName } from '../user/actions';
+import { Actor, getActorDisplayName } from '../user/User';
+import { ensureLoggedInAsync } from '../user/actions';
 import AndroidApi from './android/api/Client';
-import iOSApi from './ios/api/Client';
+import IosApi from './ios/api/Client';
 import * as IosGraphqlClient from './ios/api/GraphqlClient';
 import AppStoreApi from './ios/appstore/AppStoreApi';

@@ -27,7 +27,7 @@ export interface Context {
  readonly user: Actor;
  readonly nonInteractive: boolean;
  readonly android: AndroidApi;
-  readonly ios: iOSApi;
+  readonly ios: IosApi;
  readonly newIos: typeof IosGraphqlClient;
  readonly appStore: AppStoreApi;
  readonly hasProjectContext: boolean;
@@ -56,7 +56,7 @@ export async function createCredentialsContextAsync(

 class CredentialsContext implements Context {
  public readonly android = new AndroidApi();
-  public readonly ios = new iOSApi();
+  public readonly ios = new IosApi();
  public readonly newIos = IosGraphqlClient;
  public readonly appStore: AppStoreApi;
  public readonly nonInteractive: boolean;
@@ -227,8 +227,8 @@ describe('credentialsJson', () => {
    });
  });

-  describe('readSecretEnvsAsync', () => {
-    it('should read secretEnvs field correctly', async () => {
+  describe('readEnvironmentSecretsAsync', () => {
+    it('should read environmentSecrets field correctly', async () => {
      vol.fromJSON({
        './credentials.json': JSON.stringify({
          ios: {
@@ -245,7 +245,7 @@ describe('credentialsJson', () => {
        './pprofile': 'somebinarycontent',
        './cert.p12': 'somebinarycontent2',
      });
-      const result = await credentialsJsonReader.readSecretEnvsAsync('.');
+      const result = await credentialsJsonReader.readEnvironmentSecretsAsync('.');
      expect(result).toEqual({
        NPM_TOKEN: 'VALUE',
      });
@@ -136,7 +136,7 @@ async function readCredentialsForTargetAsync(
  };
 }

-export async function readSecretEnvsAsync(
+export async function readEnvironmentSecretsAsync(
  projectDir: string
 ): Promise<Record<string, string> | undefined> {
  if (!(await fileExistsAsync(projectDir))) {
@@ -1,99 +1,34 @@
 import { Platform } from '@expo/eas-build-job';
-import { CredentialsSource, iOSDistributionType } from '@expo/eas-json';
+import { CredentialsSource, IosDistributionType, IosEnterpriseProvisioning } from '@expo/eas-json';

-import { AppleTeamFragment, IosDistributionType } from '../../graphql/generated';
+import { IosAppBuildCredentialsFragment } from '../../graphql/generated';
 import Log from '../../log';
-import { findAccountByName } from '../../user/Account';
 import { CredentialsManager } from '../CredentialsManager';
-import { CredentialsProvider } from '../CredentialsProvider';
 import { Context } from '../context';
 import * as credentialsJsonReader from '../credentialsJson/read';
 import type { IosCredentials } from '../credentialsJson/read';
 import { SetupBuildCredentials } from './actions/SetupBuildCredentials';
-import { resolveAppleTeamIfAuthenticatedAsync } from './actions/new/AppleTeamUtils';
-import { AppleTeamMissingError, MissingCredentialsNonInteractiveError } from './errors';
+import {
+  getBuildCredentialsAsync,
+  resolveDistributionType,
+} from './actions/new/BuildCredentialsUtils';
+import { AppLookupParams } from './api/GraphqlClient';
 import { isAdHocProfile } from './utils/provisioningProfile';

-export { IosCredentials };
-
-interface PartialIosCredentials {
-  provisioningProfile?: string;
-  distributionCertificate?: {
-    certP12?: string;
-    certPassword?: string;
-  };
-}
+export type { IosCredentials };

 interface Options {
  app: AppLookupParams;
-  distribution: iOSDistributionType;
+  distribution: IosDistributionType;
+  enterpriseProvisioning?: IosEnterpriseProvisioning;
  skipCredentialsCheck?: boolean;
 }

-interface AppLookupParams {
-  projectName: string;
-  accountName: string;
-  bundleIdentifier: string;
-}
-
-export default class IosCredentialsProvider implements CredentialsProvider {
+export default class IosCredentialsProvider {
  public readonly platform = Platform.IOS;

  constructor(private ctx: Context, private options: Options) {}

-  public async hasRemoteAsync(): Promise<boolean> {
-    // TODO: this is temporary
-    // remove this check when we implement syncing local credentials for internal distribution
-    if (this.options.distribution === 'internal' && (await this.hasLocalAsync())) {
-      return false;
-    }
-    const { distributionCertificate, provisioningProfile } = await this.fetchRemoteAsync();
-    return !!(
-      distributionCertificate?.certP12 ||
-      distributionCertificate?.certPassword ||
-      provisioningProfile
-    );
-  }
-
-  public async hasLocalAsync(): Promise<boolean> {
-    if (!(await credentialsJsonReader.fileExistsAsync(this.ctx.projectDir))) {
-      return false;
-    }
-    try {
-      const rawCredentialsJson = await credentialsJsonReader.readRawAsync(this.ctx.projectDir);
-      return !!rawCredentialsJson?.ios;
-    } catch (err) {
-      Log.error(err); // malformed json
-      return false;
-    }
-  }
-
-  public async isLocalSyncedAsync(): Promise<boolean> {
-    try {
-      const [remote, local] = await Promise.all([this.fetchRemoteAsync(), this.getLocalAsync()]);
-      const r = remote;
-      const l = local;
-
-      // TODO
-      // For now, when credentials.json contains credentials for multi-target project
-      // assume they are synced with the Expo servers.
-      // Change this behavior when we figure out how to store multi-target project credentials in the db.
-      if (credentialsJsonReader.isCredentialsMap(l)) {
-        return true;
-      }
-
-      return !!(
-        r &&
-        l &&
-        r.provisioningProfile === l.provisioningProfile &&
-        r.distributionCertificate?.certP12 === l.distributionCertificate.certP12 &&
-        r.distributionCertificate?.certPassword === l.distributionCertificate.certPassword
-      );
-    } catch (_) {
-      return false;
-    }
-  }
-
  public async getCredentialsAsync(
    src: CredentialsSource.LOCAL | CredentialsSource.REMOTE
  ): Promise<IosCredentials> {
@@ -122,13 +57,13 @@ export default class IosCredentialsProvider implements CredentialsProvider {
    if (this.options.distribution === 'internal' && !isAdHoc) {
      throw new Error(
        `You must use an adhoc provisioning profile${
-          targetName && ` (target '${targetName})'`
+          targetName ? ` (target '${targetName})'` : ''
        } for internal distribution`
      );
    } else if (this.options.distribution !== 'internal' && isAdHoc) {
      throw new Error(
        `You can't use an adhoc provisioning profile${
-          targetName && ` (target '${targetName}')`
+          targetName ? ` (target '${targetName}')` : ''
        } for app store distribution`
      );
    }
@@ -139,12 +74,19 @@ export default class IosCredentialsProvider implements CredentialsProvider {
      Log.log('Skipping credentials check');
    } else {
      await new CredentialsManager(this.ctx).runActionAsync(
-        new SetupBuildCredentials(this.options.app, this.options.distribution)
+        new SetupBuildCredentials({
+          app: this.options.app,
+          distribution: this.options.distribution,
+          enterpriseProvisioning: this.options.enterpriseProvisioning,
+        })
      );
    }

-    const { distributionCertificate, provisioningProfile } = await this.fetchRemoteAsync();
-    if (!distributionCertificate?.certP12 || !distributionCertificate?.certPassword) {
+    const buildCredentials = await this.fetchRemoteAsync();
+    if (
+      !buildCredentials?.distributionCertificate?.certificateP12 ||
+      !buildCredentials.distributionCertificate?.certificatePassword
+    ) {
      if (this.options.skipCredentialsCheck) {
        throw new Error(
          'Distribution certificate is missing and credentials check was skipped. Run without --skip-credentials-check to set it up.'
@@ -153,7 +95,7 @@ export default class IosCredentialsProvider implements CredentialsProvider {
        throw new Error('Distribution certificate is missing');
      }
    }
-    if (!provisioningProfile) {
+    if (!buildCredentials.provisioningProfile?.provisioningProfile) {
      if (this.options.skipCredentialsCheck) {
        throw new Error(
          'Provisioning profile is missing and credentials check was skipped. Run without --skip-credentials-check to set it up.'
@@ -163,70 +105,19 @@ export default class IosCredentialsProvider implements CredentialsProvider {
      }
    }
    return {
-      provisioningProfile,
+      provisioningProfile: buildCredentials.provisioningProfile.provisioningProfile,
      distributionCertificate: {
-        certP12: distributionCertificate.certP12,
-        certPassword: distributionCertificate.certPassword,
+        certP12: buildCredentials.distributionCertificate.certificateP12,
+        certPassword: buildCredentials.distributionCertificate.certificatePassword,
      },
    };
  }

-  private async fetchRemoteAsync(): Promise<PartialIosCredentials> {
-    if (this.options.distribution === 'internal') {
-      const { app } = this.options;
-      const account = findAccountByName(this.ctx.user.accounts, app.accountName);
-      if (!account) {
-        throw new Error(`You do not have access to the ${app.accountName} account`);
-      }
-
-      const appLookupParams = {
-        account,
-        bundleIdentifier: this.options.app.bundleIdentifier,
-        projectName: this.options.app.projectName,
-      };
-
-      let appleTeam: AppleTeamFragment | null = null;
-      if (!this.ctx.nonInteractive) {
-        await this.ctx.appStore.ensureAuthenticatedAsync();
-        appleTeam = await resolveAppleTeamIfAuthenticatedAsync(this.ctx, appLookupParams);
-      }
-
-      try {
-        const [distCert, provisioningProfile] = await Promise.all([
-          this.ctx.newIos.getDistributionCertificateForAppAsync(
-            appLookupParams,
-            IosDistributionType.AdHoc,
-            { appleTeam }
-          ),
-          this.ctx.newIos.getProvisioningProfileAsync(appLookupParams, IosDistributionType.AdHoc, {
-            appleTeam,
-          }),
-        ]);
-        return {
-          provisioningProfile: provisioningProfile?.provisioningProfile ?? undefined,
-          distributionCertificate: {
-            certP12: distCert?.certificateP12 ?? undefined,
-            certPassword: distCert?.certificatePassword ?? undefined,
-          },
-        };
-      } catch (err) {
-        if (err instanceof AppleTeamMissingError && this.ctx.nonInteractive) {
-          throw new MissingCredentialsNonInteractiveError();
-        }
-        throw err;
-      }
-    } else {
-      const [distCert, provisioningProfile] = await Promise.all([
-        this.ctx.ios.getDistributionCertificateAsync(this.options.app),
-        this.ctx.ios.getProvisioningProfileAsync(this.options.app),
-      ]);
-      return {
-        provisioningProfile: provisioningProfile?.provisioningProfile,
-        distributionCertificate: {
-          certP12: distCert?.certP12,
-          certPassword: distCert?.certPassword,
-        },
-      };
-    }
+  private async fetchRemoteAsync(): Promise<IosAppBuildCredentialsFragment | null> {
+    const distributionType = resolveDistributionType(
+      this.options.distribution,
+      this.options.enterpriseProvisioning
+    );
+    return await getBuildCredentialsAsync(this.ctx, this.options.app, distributionType);
  }
 }
@@ -0,0 +1,95 @@
+import { CredentialsSource } from '@expo/eas-json';
+import { vol } from 'memfs';
+
+import { getAppstoreMock } from '../../__tests__/fixtures-appstore';
+import { createCtxMock } from '../../__tests__/fixtures-context';
+import { testIosAppCredentialsWithBuildCredentialsQueryResult } from '../../__tests__/fixtures-ios';
+import { getNewIosApiMockWithoutCredentials } from '../../__tests__/fixtures-new-ios';
+import IosCredentialsProvider from '../IosCredentialsProvider';
+import { getAppLookupParamsFromContext } from '../actions/new/BuildCredentialsUtils';
+
+jest.mock('fs');
+
+const originalConsoleLog = console.log;
+beforeAll(() => {
+  console.log = jest.fn();
+});
+afterAll(() => {
+  console.log = originalConsoleLog;
+});
+
+beforeEach(() => {
+  vol.reset();
+});
+
+describe(IosCredentialsProvider, () => {
+  describe('#getCredentialsAsync', () => {
+    describe('remote credentials', () => {
+      it('throws an error is credentials do not exist', async () => {
+        const ctx = createCtxMock({
+          nonInteractive: false,
+          appStore: getAppstoreMock(),
+          projectDir: '/app',
+          newIos: {
+            ...getNewIosApiMockWithoutCredentials(),
+            getIosAppCredentialsWithBuildCredentialsAsync: jest.fn(() => null),
+          },
+        });
+        const appLookupParams = getAppLookupParamsFromContext(ctx);
+        const provider = new IosCredentialsProvider(ctx, {
+          app: {
+            account: {
+              id: `id-${appLookupParams.account.name}`,
+              name: appLookupParams.account.name,
+            },
+            bundleIdentifier: appLookupParams.bundleIdentifier,
+            projectName: appLookupParams.projectName,
+          },
+          distribution: 'store',
+          skipCredentialsCheck: true,
+        });
+
+        await expect(provider.getCredentialsAsync(CredentialsSource.REMOTE)).rejects.toThrowError();
+      });
+
+      it('returns credentials if they exist', async () => {
+        const ctx = createCtxMock({
+          nonInteractive: false,
+          appStore: getAppstoreMock(),
+          projectDir: '/app',
+          newIos: {
+            ...getNewIosApiMockWithoutCredentials(),
+            getIosAppCredentialsWithBuildCredentialsAsync: jest.fn(
+              () => testIosAppCredentialsWithBuildCredentialsQueryResult
+            ),
+          },
+        });
+        const appLookupParams = getAppLookupParamsFromContext(ctx);
+        const provider = new IosCredentialsProvider(ctx, {
+          app: {
+            account: {
+              id: `id-${appLookupParams.account.name}`,
+              name: appLookupParams.account.name,
+            },
+            bundleIdentifier: appLookupParams.bundleIdentifier,
+            projectName: appLookupParams.projectName,
+          },
+          distribution: 'store',
+          skipCredentialsCheck: true,
+        });
+
+        const buildCredentials =
+          testIosAppCredentialsWithBuildCredentialsQueryResult.iosAppBuildCredentialsArray[0];
+        await expect(provider.getCredentialsAsync(CredentialsSource.REMOTE)).resolves.toMatchObject(
+          {
+            distributionCertificate: {
+              certP12: buildCredentials.distributionCertificate?.certificateP12,
+              certPassword: buildCredentials.distributionCertificate?.certificatePassword,
+            },
+            provisioningProfile: buildCredentials.provisioningProfile?.provisioningProfile,
+          }
+        );
+      });
+    });
+  });
+});
@@ -31,11 +31,7 @@ export class CreateDistributionCertificate implements Action {
  }

  public async runAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
-    const distCert = await provideOrGenerateDistributionCertificateAsync(
-      manager,
-      ctx,
-      this.accountName
-    );
+    const distCert = await provideOrGenerateDistributionCertificateAsync(ctx, this.accountName);
    this._distCredentials = await ctx.ios.createDistributionCertificateAsync(
      this.accountName,
      distCert
@@ -1,45 +0,0 @@
-import assert from 'assert';
-
-import Log from '../../../log';
-import { Action, CredentialsManager } from '../../CredentialsManager';
-import { Context } from '../../context';
-import { askForUserProvidedAsync } from '../../utils/promptForCredentials';
-import { ProvisioningProfile } from '../appstore/Credentials.types';
-import { AppLookupParams, provisioningProfileSchema } from '../credentials';
-import { displayIosAppCredentials } from '../utils/printCredentials';
-import { generateProvisioningProfileAsync } from './ProvisioningProfileUtils';
-
-export class CreateProvisioningProfileStandaloneManager implements Action {
-  constructor(private app: AppLookupParams) {}
-
-  async runAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
-    await manager.runActionAsync(new CreateProvisioningProfile(this.app));
-
-    const appCredentials = await ctx.ios.getAppCredentialsAsync(this.app);
-    displayIosAppCredentials(appCredentials);
-    Log.newLine();
-  }
-}
-
-export class CreateProvisioningProfile implements Action {
-  constructor(private app: AppLookupParams) {}
-
-  async runAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
-    const provisioningProfile = await this.provideOrGenerateAsync(ctx);
-    await ctx.ios.updateProvisioningProfileAsync(this.app, provisioningProfile);
-
-    Log.succeed('Created provisioning profile');
-  }
-
-  private async provideOrGenerateAsync(ctx: Context): Promise<ProvisioningProfile> {
-    const userProvided = await askForUserProvidedAsync(provisioningProfileSchema);
-    if (userProvided) {
-      // userProvided profiles don't come with ProvisioningProfileId's (only accessible from Apple Portal API)
-      Log.warn('Provisioning profile: Unable to validate specified profile.');
-      return userProvided;
-    }
-    const distCert = await ctx.ios.getDistributionCertificateAsync(this.app);
-    assert(distCert, 'missing distribution certificate');
-    return await generateProvisioningProfileAsync(ctx, this.app.bundleIdentifier, distCert);
-  }
-}
@@ -2,7 +2,6 @@ import chalk from 'chalk';

 import Log, { learnMore } from '../../../log';
 import { promptAsync } from '../../../prompts';
-import { CredentialsManager } from '../../CredentialsManager';
 import { Context } from '../../context';
 import { askForUserProvidedAsync } from '../../utils/promptForCredentials';
 import { AppleTooManyCertsError } from '../appstore/AppStoreApi';
@@ -31,7 +30,6 @@ Please remember that Apple Distribution Certificates are not application specifi
 `;

 export async function provideOrGenerateDistributionCertificateAsync(
-  manager: CredentialsManager,
  ctx: Context,
  accountName: string
 ): Promise<DistributionCertificate> {
@@ -50,11 +48,11 @@ export async function provideOrGenerateDistributionCertificateAsync(
        }
        return isValid
          ? userProvided
-          : await provideOrGenerateDistributionCertificateAsync(manager, ctx, accountName);
+          : await provideOrGenerateDistributionCertificateAsync(ctx, accountName);
      }
    }
  }
-  return await generateDistributionCertificateAsync(manager, ctx, accountName);
+  return await generateDistributionCertificateAsync(ctx, accountName);
 }

 async function promptForDistCertAsync(ctx: Context): Promise<DistributionCertificate | null> {
@@ -78,7 +76,6 @@ async function promptForDistCertAsync(ctx: Context): Promise<DistributionCertifi
 }

 async function generateDistributionCertificateAsync(
-  manager: CredentialsManager,
  ctx: Context,
  accountName: string
 ): Promise<DistributionCertificate> {
@@ -125,7 +122,7 @@ async function generateDistributionCertificateAsync(
      throw e;
    }
  }
-  return await generateDistributionCertificateAsync(manager, ctx, accountName);
+  return await generateDistributionCertificateAsync(ctx, accountName);
 }

 interface SelectOptions {
@@ -145,7 +142,7 @@ export async function selectDistributionCertificateAsync(
  let validDistCredentials: IosDistCredentials[] | null = null;
  if (ctx.appStore.authCtx) {
    const certInfoFromApple = await ctx.appStore.listDistributionCertificatesAsync();
-    validDistCredentials = await filterRevokedDistributionCerts(distCredentials, certInfoFromApple);
+    validDistCredentials = filterRevokedDistributionCerts(distCredentials, certInfoFromApple);
  }
  distCredentials =
    options.filterInvalid && validDistCredentials ? validDistCredentials : distCredentials;
@@ -1,109 +1,80 @@
-import { iOSDistributionType } from '@expo/eas-json';
-import assert from 'assert';
+import { IosDistributionType, IosEnterpriseProvisioning } from '@expo/eas-json';
 import chalk from 'chalk';

-import { AppleDevice, IosAppBuildCredentialsFragment } from '../../../graphql/generated';
+import {
+  IosDistributionType as GraphQLIosDistributionType,
+  IosAppBuildCredentialsFragment,
+} from '../../../graphql/generated';
 import Log from '../../../log';
 import { promptAsync } from '../../../prompts';
-import { findAccountByName } from '../../../user/Account';
 import { Action, CredentialsManager } from '../../CredentialsManager';
 import { Context } from '../../context';
 import { isCredentialsMap, readIosCredentialsAsync } from '../../credentialsJson/read';
-import { AppLookupParams, IosAppCredentials, IosDistCredentials } from '../credentials';
-import { displayProjectCredentials } from '../utils/printCredentials';
+import { AppLookupParams as GraphQLAppLookupParams } from '../api/GraphqlClient';
+import { AppLookupParams, IosAppCredentials } from '../credentials';
+import { displayProjectCredentials as legacyDisplayProjectCredentials } from '../utils/printCredentials';
+import { displayProjectCredentials } from '../utils/printCredentialsBeta';
 import { readAppleTeam } from '../utils/provisioningProfile';
-import { SetupProvisioningProfile } from './SetupProvisioningProfile';
 import { SetupAdhocProvisioningProfile } from './new/SetupAdhocProvisioningProfile';
+import { SetupInternalProvisioningProfile } from './new/SetupInternalProvisioningProfile';
+import { SetupProvisioningProfile } from './new/SetupProvisioningProfile';

-type AppCredentialsAndDistCert = {
-  appCredentials: IosAppCredentials;
-  distCert: IosDistCredentials | null;
-};
+interface Options {
+  app: GraphQLAppLookupParams;
+  distribution: IosDistributionType;
+  enterpriseProvisioning?: IosEnterpriseProvisioning;
+  skipCredentialsCheck?: boolean;
+}

 export class SetupBuildCredentials implements Action {
-  constructor(private app: AppLookupParams, private distribution: iOSDistributionType) {}
+  constructor(private options: Options) {}

  async runAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
+    const { app } = this.options;
+
    await ctx.bestEffortAppStoreAuthenticateAsync();

    if (ctx.appStore.authCtx) {
-      await ctx.appStore.ensureBundleIdExistsAsync(this.app, { enablePushNotifications: true });
+      await ctx.appStore.ensureBundleIdExistsAsync(
+        {
+          accountName: app.account.name,
+          bundleIdentifier: app.bundleIdentifier,
+          projectName: app.projectName,
+        },
+        { enablePushNotifications: true }
+      );
    }
-
-    let iosAppBuildCredentials: IosAppBuildCredentialsFragment | null = null;
    try {
-      if (this.distribution === 'internal') {
-        const account = findAccountByName(ctx.user.accounts, this.app.accountName);
-        if (!account) {
-          throw new Error(`You do not have access to the ${this.app.accountName} account`);
-        }
-        const action = new SetupAdhocProvisioningProfile({
-          account,
-          projectName: this.app.projectName,
-          bundleIdentifier: this.app.bundleIdentifier,
-        });
-        await manager.runActionAsync(action);
-        iosAppBuildCredentials = action.iosAppBuildCredentials;
-      } else {
-        await manager.runActionAsync(new SetupProvisioningProfile(this.app));
-      }
+      const buildCredentials = await this.setupBuildCredentials(ctx);
+
+      const appInfo = `@${app.account.name}/${app.projectName} (${app.bundleIdentifier})`;
+      displayProjectCredentials(app, buildCredentials);
+      Log.newLine();
+      Log.log(chalk.green(`All credentials are ready to build ${appInfo}`));
+      Log.newLine();
    } catch (error) {
      Log.error('Failed to setup credentials.');
      throw error;
    }
-
-    const { appCredentials, distCert } = await this.unifyCredentialsFormatAsync(
-      ctx,
-      iosAppBuildCredentials
-    );
-    const appInfo = `@${this.app.accountName}/${this.app.projectName} (${this.app.bundleIdentifier})`;
-    displayProjectCredentials(this.app, appCredentials, /* pushKey */ null, distCert);
-    Log.newLine();
-    Log.log(chalk.green(`All credentials are ready to build ${appInfo}`));
-    Log.newLine();
  }

-  async unifyCredentialsFormatAsync(
-    ctx: Context,
-    iosAppBuildCredentials: IosAppBuildCredentialsFragment | null
-  ): Promise<AppCredentialsAndDistCert> {
-    if (!iosAppBuildCredentials) {
-      const [appCredentials, distCert] = await Promise.all([
-        ctx.ios.getAppCredentialsAsync(this.app),
-        ctx.ios.getDistributionCertificateAsync(this.app),
-      ]);
-      return {
-        appCredentials,
-        distCert,
-      };
+  async setupBuildCredentials(ctx: Context): Promise<IosAppBuildCredentialsFragment> {
+    const { app, distribution, enterpriseProvisioning } = this.options;
+    if (distribution === 'internal') {
+      if (enterpriseProvisioning === 'adhoc') {
+        return await new SetupAdhocProvisioningProfile(app).runAsync(ctx);
+      } else if (enterpriseProvisioning === 'universal') {
+        return await new SetupProvisioningProfile(
+          app,
+          GraphQLIosDistributionType.Enterprise
+        ).runAsync(ctx);
+      } else {
+        return await new SetupInternalProvisioningProfile(app).runAsync(ctx);
+      }
    } else {
-      const { distributionCertificate, provisioningProfile } = iosAppBuildCredentials;
-      assert(distributionCertificate && provisioningProfile);
-      return {
-        appCredentials: {
-          experienceName: `${this.app.accountName}/${this.app.projectName}`,
-          bundleIdentifier: this.app.bundleIdentifier,
-          credentials: {
-            provisioningProfile: provisioningProfile.provisioningProfile ?? undefined,
-            provisioningProfileId: provisioningProfile.developerPortalIdentifier ?? undefined,
-            teamId: provisioningProfile.appleTeam?.appleTeamIdentifier || '',
-            teamName: provisioningProfile.appleTeam?.appleTeamName ?? undefined,
-            devices: provisioningProfile.appleDevices?.filter(device => device) as
-              | AppleDevice[]
-              | undefined,
-          },
-        },
-        distCert: {
-          // the id doesn't really matter, it's only for displaying credentials
-          id: null as any,
-          type: 'dist-cert',
-          certId: distributionCertificate.developerPortalIdentifier ?? undefined,
-          certP12: distributionCertificate.certificateP12 ?? '',
-          certPassword: distributionCertificate.certificatePassword ?? '',
-          teamId: distributionCertificate.appleTeam?.appleTeamIdentifier || '',
-          teamName: distributionCertificate.appleTeam?.appleTeamName ?? undefined,
-        },
-      };
+      return await new SetupProvisioningProfile(app, GraphQLIosDistributionType.AppStore).runAsync(
+        ctx
+      );
    }
  }
 }
@@ -187,7 +158,7 @@ export class SetupBuildCredentialsFromCredentialsJson implements Action {
      await ctx.ios.useDistributionCertificateAsync(this.app, createdDistCert.id);
    }

-    displayProjectCredentials(
+    legacyDisplayProjectCredentials(
      this.app,
      await ctx.ios.getAppCredentialsAsync(this.app),
      undefined,
@@ -1,109 +0,0 @@
-import Log from '../../../log';
-import { confirmAsync, promptAsync } from '../../../prompts';
-import { Action, CredentialsManager } from '../../CredentialsManager';
-import { Context } from '../../context';
-import { AppLookupParams } from '../credentials';
-import { validateDistributionCertificateAsync } from '../validators/validateDistributionCertificate';
-import { CreateDistributionCertificate } from './CreateDistributionCertificate';
-import {
-  formatDistributionCertificate,
-  getValidDistCertsAsync,
-} from './DistributionCertificateUtils';
-import {
-  UseExistingDistributionCertificate,
-  UseSpecificDistributionCertificate,
-} from './UseDistributionCertificate';
-
-export class SetupDistributionCertificateForApp implements Action {
-  constructor(private app: AppLookupParams) {}
-
-  public async runAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
-    if (await this.isCurrentCertificateValidAsync(ctx)) {
-      return;
-    }
-
-    if (ctx.nonInteractive) {
-      throw new Error(
-        'Distribution Certificate is not configured correctly. Please run this command again in interactive mode.'
-      );
-    }
-
-    const existingCertificates = await getValidDistCertsAsync(ctx, this.app.accountName);
-
-    if (existingCertificates.length === 0) {
-      await this.createNewCertificateAsync(manager, ctx);
-      return;
-    }
-
-    // autoselect credentials if we find valid certs
-    const autoselectedCertificate = existingCertificates[0];
-
-    const credentials = await ctx.ios.getAllCredentialsAsync(this.app.accountName);
-    const usedByApps = credentials.appCredentials.filter(
-      cred => cred.distCredentialsId === autoselectedCertificate.id
-    );
-    const confirm = await confirmAsync({
-      message: `${formatDistributionCertificate(
-        autoselectedCertificate,
-        usedByApps,
-        ctx.appStore.authCtx ? 'VALID' : 'UNKNOWN'
-      )} \n  Would you like to use this certificate?`,
-    });
-    if (!confirm) {
-      await this.createOrReuseAsync(manager, ctx);
-      return;
-    }
-
-    Log.log(`Using Distribution Certificate: ${autoselectedCertificate.certId || '-----'}`);
-    await manager.runActionAsync(
-      new UseSpecificDistributionCertificate(this.app, autoselectedCertificate.id)
-    );
-  }
-
-  private async isCurrentCertificateValidAsync(ctx: Context): Promise<boolean> {
-    const currentCertificate = await ctx.ios.getDistributionCertificateAsync(this.app);
-    if (!currentCertificate) {
-      return false;
-    }
-    if (ctx.appStore.authCtx) {
-      const isValid = await validateDistributionCertificateAsync(ctx, currentCertificate);
-      if (!isValid) {
-        Log.warn("Current Distribution Certificate is no longer valid on Apple's server");
-      }
-      return isValid;
-    }
-    return true;
-  }
-
-  private async createNewCertificateAsync(
-    manager: CredentialsManager,
-    ctx: Context
-  ): Promise<void> {
-    const action = new CreateDistributionCertificate(this.app.accountName);
-    await manager.runActionAsync(action);
-    await manager.runActionAsync(
-      new UseSpecificDistributionCertificate(this.app, action.distCredentials.id)
-    );
-  }
-
-  private async createOrReuseAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
-    const { action } = await promptAsync({
-      type: 'select',
-      name: 'action',
-      message: 'Select an iOS Distribution Certificate to use for code signing:',
-      choices: [
-        {
-          title: '[Choose existing certificate] (Recommended)',
-          value: 'CHOOSE_EXISTING',
-        },
-        { title: '[Add a new certificate]', value: 'GENERATE' },
-      ],
-    });
-
-    if (action === 'GENERATE') {
-      await this.createNewCertificateAsync(manager, ctx);
-    } else if (action === 'CHOOSE_EXISTING') {
-      await manager.runActionAsync(new UseExistingDistributionCertificate(this.app));
-    }
-  }
-}
@@ -1,152 +0,0 @@
-import assert from 'assert';
-import pick from 'lodash/pick';
-
-import Log from '../../../log';
-import { confirmAsync, promptAsync } from '../../../prompts';
-import { Action, CredentialsManager } from '../../CredentialsManager';
-import { Context } from '../../context';
-import { ProvisioningProfileStoreInfo } from '../appstore/Credentials.types';
-import { AppLookupParams, IosDistCredentials } from '../credentials';
-import {
-  validateProvisioningProfileAsync,
-  validateProvisioningProfileWithoutApple,
-} from '../validators/validateProvisioningProfile';
-import {
-  ConfigureProvisioningProfile,
-  UseExistingProvisioningProfile,
-} from './ConfigureProvisioningProfile';
-import { CreateProvisioningProfile } from './CreateProvisioningProfile';
-import { formatProvisioningProfileFromApple } from './ProvisioningProfileUtils';
-import { SetupDistributionCertificateForApp } from './SetupDistributionCertificate';
-
-export class SetupProvisioningProfile implements Action {
-  constructor(private app: AppLookupParams) {}
-
-  async runAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
-    await manager.runActionAsync(new SetupDistributionCertificateForApp(this.app));
-    if (await this.isCurrentProfileValidAsync(ctx)) {
-      return;
-    }
-
-    if (ctx.nonInteractive) {
-      throw new Error(
-        'Provisioning profile is not configured correctly. Please run this command again in interactive mode.'
-      );
-    }
-
-    if (!ctx.appStore.authCtx) {
-      await manager.runActionAsync(new CreateProvisioningProfile(this.app));
-      return;
-    }
-
-    const existingProfiles = await ctx.appStore.listProvisioningProfilesAsync(
-      this.app.bundleIdentifier
-    );
-
-    if (existingProfiles.length === 0) {
-      await manager.runActionAsync(new CreateProvisioningProfile(this.app));
-      return;
-    }
-
-    const distCert = await ctx.ios.getDistributionCertificateAsync(this.app);
-    assert(distCert, 'missing distribution certificate');
-
-    const autoselectedProfile = this.choosePreferred(existingProfiles, distCert);
-    // autoselect credentials if we find valid certs
-
-    if (!ctx.nonInteractive) {
-      const confirm = await confirmAsync({
-        message: `${formatProvisioningProfileFromApple(
-          autoselectedProfile
-        )} \n  Would you like to use this profile?`,
-      });
-      if (!confirm) {
-        await this.createOrReuseAsync(manager, ctx);
-        return;
-      }
-    } else {
-      Log.log(`Using provisioning profile: ${autoselectedProfile.provisioningProfileId}`);
-    }
-
-    await ctx.ios.updateProvisioningProfileAsync(
-      this.app,
-      pick(autoselectedProfile, [
-        'provisioningProfile',
-        'provisioningProfileId',
-        'teamId',
-        'teamName',
-      ])
-    );
-    await manager.runActionAsync(new ConfigureProvisioningProfile(this.app));
-  }
-
-  private async isCurrentProfileValidAsync(ctx: Context): Promise<boolean> {
-    const currentProfile = await ctx.ios.getProvisioningProfileAsync(this.app);
-    const currentCertificate = await ctx.ios.getDistributionCertificateAsync(this.app);
-    if (!currentProfile || !currentCertificate) {
-      return false;
-    }
-    if (!ctx.appStore.authCtx || !currentProfile.provisioningProfileId) {
-      if (!currentProfile.provisioningProfileId) {
-        Log.warn(
-          "The provisioning profile we have on file cannot be validated on Apple's servers."
-        );
-      }
-      const validationResult = validateProvisioningProfileWithoutApple(
-        currentProfile,
-        currentCertificate,
-        this.app.bundleIdentifier
-      );
-      if (!validationResult.ok) {
-        Log.warn(validationResult.error);
-        return false;
-      }
-      return true;
-    }
-    const validationResult = await validateProvisioningProfileAsync(
-      ctx,
-      currentProfile,
-      currentCertificate,
-      this.app.bundleIdentifier
-    );
-    if (!validationResult.ok) {
-      Log.warn(validationResult.error);
-      return false;
-    }
-    return true;
-  }
-
-  private choosePreferred(
-    profiles: ProvisioningProfileStoreInfo[],
-    distCert: IosDistCredentials
-  ): ProvisioningProfileStoreInfo {
-    // prefer the profile that already has the same dist cert associated with it
-    const profileWithSameCert = profiles.find(profile =>
-      profile.certificates.some(cert => cert.id === distCert.certId)
-    );
-
-    // if not, just get an arbitrary profile
-    return profileWithSameCert || profiles[0];
-  }
-
-  private async createOrReuseAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
-    const { action } = await promptAsync({
-      type: 'select',
-      name: 'action',
-      message: 'Select a provisioning profile:',
-      choices: [
-        {
-          title: '[Choose existing provisioning profile] (Recommended)',
-          value: 'CHOOSE_EXISTING',
-        },
-        { title: '[Add a new provisioning profile]', value: 'GENERATE' },
-      ],
-    });
-
-    if (action === 'GENERATE') {
-      await manager.runActionAsync(new CreateProvisioningProfile(this.app));
-    } else if (action === 'CHOOSE_EXISTING') {
-      await manager.runActionAsync(new UseExistingProvisioningProfile(this.app));
-    }
-  }
-}
@@ -62,11 +62,7 @@ export class UpdateSpecificDistributionCertificate implements Action {
      cred => cred.distCredentialsId === this.userCredentialsId
    );

-    const newDistCert = await provideOrGenerateDistributionCertificateAsync(
-      manager,
-      ctx,
-      this.accountName
-    );
+    const newDistCert = await provideOrGenerateDistributionCertificateAsync(ctx, this.accountName);
    await ctx.ios.updateDistributionCertificateAsync(
      this.userCredentialsId,
      this.accountName,
@@ -0,0 +1,113 @@
+import { IosDistributionType, IosEnterpriseProvisioning } from '@expo/eas-json';
+import nullthrows from 'nullthrows';
+
+import {
+  AppleDistributionCertificateFragment,
+  AppleProvisioningProfileFragment,
+  AppleTeamFragment,
+  IosDistributionType as GraphQLIosDistributionType,
+  IosAppBuildCredentialsFragment,
+} from '../../../../graphql/generated';
+import {
+  getProjectAccountName,
+  getProjectConfigDescription,
+} from '../../../../project/projectUtils';
+import { findAccountByName } from '../../../../user/Account';
+import { Context } from '../../../context';
+import { AppLookupParams } from '../../api/GraphqlClient';
+import { resolveAppleTeamIfAuthenticatedAsync } from './AppleTeamUtils';
+
+export async function getBuildCredentialsAsync(
+  ctx: Context,
+  app: AppLookupParams,
+  iosDistributionType: GraphQLIosDistributionType
+): Promise<IosAppBuildCredentialsFragment | null> {
+  const appCredentials = await ctx.newIos.getIosAppCredentialsWithBuildCredentialsAsync(app, {
+    iosDistributionType,
+  });
+  if (!appCredentials || appCredentials.iosAppBuildCredentialsArray.length === 0) {
+    return null;
+  }
+  const [buildCredentials] = appCredentials.iosAppBuildCredentialsArray;
+  return buildCredentials;
+}
+
+export async function getProvisioningProfileAsync(
+  ctx: Context,
+  app: AppLookupParams,
+  iosDistributionType: GraphQLIosDistributionType
+): Promise<AppleProvisioningProfileFragment | null> {
+  const buildCredentials = await getBuildCredentialsAsync(ctx, app, iosDistributionType);
+  return buildCredentials?.provisioningProfile ?? null;
+}
+
+export async function getDistributionCertificateAsync(
+  ctx: Context,
+  app: AppLookupParams,
+  iosDistributionType: GraphQLIosDistributionType
+): Promise<AppleDistributionCertificateFragment | null> {
+  const buildCredentials = await getBuildCredentialsAsync(ctx, app, iosDistributionType);
+  return buildCredentials?.distributionCertificate ?? null;
+}
+
+export async function assignBuildCredentialsAsync(
+  ctx: Context,
+  app: AppLookupParams,
+  iosDistributionType: GraphQLIosDistributionType,
+  distCert: AppleDistributionCertificateFragment,
+  provisioningProfile: AppleProvisioningProfileFragment,
+  appleTeam?: AppleTeamFragment
+): Promise<IosAppBuildCredentialsFragment> {
+  const resolvedAppleTeam = nullthrows(
+    appleTeam ?? (await resolveAppleTeamIfAuthenticatedAsync(ctx, app))
+  );
+  const appleAppIdentifier = await ctx.newIos.createOrGetExistingAppleAppIdentifierAsync(
+    app,
+    resolvedAppleTeam
+  );
+  return await ctx.newIos.createOrUpdateIosAppBuildCredentialsAsync(app, {
+    appleTeam: resolvedAppleTeam,
+    appleAppIdentifierId: appleAppIdentifier.id,
+    appleDistributionCertificateId: distCert.id,
+    appleProvisioningProfileId: provisioningProfile.id,
+    iosDistributionType,
+  });
+}
+
+export function getAppLookupParamsFromContext(ctx: Context): AppLookupParams {
+  ctx.ensureProjectContext();
+  const projectName = ctx.exp.slug;
+  const accountName = getProjectAccountName(ctx.exp, ctx.user);
+  const account = findAccountByName(ctx.user.accounts, accountName);
+  if (!account) {
+    throw new Error(`You do not have access to account: ${accountName}`);
+  }
+
+  const bundleIdentifier = ctx.exp.ios?.bundleIdentifier;
+  if (!bundleIdentifier) {
+    throw new Error(
+      `ios.bundleIdentifier needs to be defined in your ${getProjectConfigDescription(
+        ctx.projectDir
+      )} file`
+    );
+  }
+
+  return { account, projectName, bundleIdentifier };
+}
+
+export function resolveDistributionType(
+  distribution: IosDistributionType,
+  enterpriseProvisioning?: IosEnterpriseProvisioning
+): GraphQLIosDistributionType {
+  if (distribution === 'internal') {
+    if (enterpriseProvisioning === 'adhoc') {
+      return GraphQLIosDistributionType.AdHoc;
+    } else if (enterpriseProvisioning === 'universal') {
+      return GraphQLIosDistributionType.Enterprise;
+    } else {
+      return GraphQLIosDistributionType.AdHoc;
+    }
+  } else {
+    return GraphQLIosDistributionType.AppStore;
+  }
+}
@@ -0,0 +1,113 @@
+import assert from 'assert';
+import chalk from 'chalk';
+import ora from 'ora';
+
+import {
+  AppleDistributionCertificateFragment,
+  AppleProvisioningProfileFragment,
+} from '../../../../graphql/generated';
+import Log from '../../../../log';
+import { Context } from '../../../context';
+import { AppLookupParams } from '../../api/GraphqlClient';
+import { AppleProvisioningProfileMutationResult } from '../../api/graphql/mutations/AppleProvisioningProfileMutation';
+import { ProvisioningProfileStoreInfo } from '../../appstore/Credentials.types';
+import { AuthCtx } from '../../appstore/authenticate';
+import { MissingCredentialsNonInteractiveError } from '../../errors';
+
+export class ConfigureProvisioningProfile {
+  constructor(
+    private app: AppLookupParams,
+    private distributionCertificate: AppleDistributionCertificateFragment,
+    private originalProvisioningProfile: AppleProvisioningProfileFragment
+  ) {}
+
+  public async runAsync(ctx: Context): Promise<AppleProvisioningProfileMutationResult | null> {
+    if (ctx.nonInteractive) {
+      throw new MissingCredentialsNonInteractiveError(
+        'Configuring Provisioning Profiles is only supported in interactive mode.'
+      );
+    }
+    const { developerPortalIdentifier, provisioningProfile } = this.originalProvisioningProfile;
+    if (!developerPortalIdentifier && !provisioningProfile) {
+      Log.warn("The provisioning profile we have on file cannot be configured on Apple's servers.");
+      return null;
+    }
+
+    if (!ctx.appStore.authCtx) {
+      Log.warn(
+        "Without access to your Apple account we can't configure provisioning profiles for you."
+      );
+      Log.warn('Make sure to recreate the profile if you selected a new distribution certificate.');
+      return null;
+    }
+
+    const profilesFromApple = await ctx.appStore.listProvisioningProfilesAsync(
+      this.app.bundleIdentifier
+    );
+    const [matchingProfile] = profilesFromApple.filter(appleInfo =>
+      developerPortalIdentifier
+        ? appleInfo.provisioningProfileId === developerPortalIdentifier
+        : appleInfo.provisioningProfile === provisioningProfile
+    );
+    if (!matchingProfile) {
+      Log.warn(
+        `Profile ${
+          developerPortalIdentifier ? `${developerPortalIdentifier} ` : ''
+        }not found on Apple Developer Portal.`
+      );
+      return null;
+    }
+
+    return await this.configureAndUpdateAsync(ctx, ctx.appStore.authCtx, this.app, matchingProfile);
+  }
+
+  private async configureAndUpdateAsync(
+    ctx: Context,
+    authCtx: AuthCtx,
+    app: AppLookupParams,
+    profileFromApple: ProvisioningProfileStoreInfo
+  ): Promise<AppleProvisioningProfileMutationResult> {
+    const {
+      developerPortalIdentifier,
+      certificateP12,
+      certificatePassword,
+      serialNumber,
+    } = this.distributionCertificate;
+    assert(
+      certificateP12 && certificatePassword,
+      'Distribution Certificate P12 and Password is required'
+    );
+    // configure profile on Apple's Server to use our distCert
+    const updatedProfile = await ctx.appStore.useExistingProvisioningProfileAsync(
+      app.bundleIdentifier,
+      profileFromApple,
+      {
+        certId: developerPortalIdentifier ?? undefined,
+        certP12: certificateP12,
+        certPassword: certificatePassword,
+        distCertSerialNumber: serialNumber,
+        teamId: authCtx.appleId,
+      }
+    );
+
+    const bundleIdTag = `(${app.bundleIdentifier})`;
+    const slugTag = `@${app.account.name}/${app.projectName}`;
+    const projectTag = `${chalk.bold(slugTag)} ${chalk.dim(bundleIdTag)}`;
+
+    const spinner = ora(`Updating Expo profile for ${projectTag}`).start();
+    try {
+      const configuredProvisioningProfile = await ctx.newIos.updateProvisioningProfileAsync(
+        this.originalProvisioningProfile.id,
+        {
+          appleProvisioningProfile: updatedProfile.provisioningProfile,
+          developerPortalIdentifier: updatedProfile.provisioningProfileId,
+        }
+      );
+      spinner.succeed(`Updated Expo profile for ${projectTag}`);
+      return configuredProvisioningProfile;
+    } catch (error) {
+      spinner.fail();
+      throw error;
+    }
+  }
+}
@@ -1,35 +1,19 @@
-import assert from 'assert';
-
 import Log from '../../../../log';
-import { Action, CredentialsManager } from '../../../CredentialsManager';
 import { Context } from '../../../context';
 import { AppLookupParams } from '../../api/GraphqlClient';
 import { AppleDistributionCertificateMutationResult } from '../../api/graphql/mutations/AppleDistributionCertificateMutation';
 import { provideOrGenerateDistributionCertificateAsync } from '../DistributionCertificateUtils';

-export class CreateDistributionCertificate implements Action {
-  private _distributionCertificate?: AppleDistributionCertificateMutationResult;
-
+export class CreateDistributionCertificate {
  constructor(private app: AppLookupParams) {}

-  public get distributionCertificate(): AppleDistributionCertificateMutationResult {
-    assert(
-      this._distributionCertificate,
-      'distributionCertificate can be accessed only after calling .runAsync()'
-    );
-    return this._distributionCertificate;
-  }
-
-  public async runAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
+  public async runAsync(ctx: Context): Promise<AppleDistributionCertificateMutationResult> {
    const distCert = await provideOrGenerateDistributionCertificateAsync(
-      manager,
      ctx,
      this.app.account.name
    );
-    this._distributionCertificate = await ctx.newIos.createDistributionCertificateAsync(
-      this.app,
-      distCert
-    );
+    const result = await ctx.newIos.createDistributionCertificateAsync(this.app, distCert);
    Log.succeed('Created distribution certificate');
+    return result;
  }
 }
@@ -0,0 +1,74 @@
+import assert from 'assert';
+import nullthrows from 'nullthrows';
+
+import { AppleDistributionCertificateFragment } from '../../../../graphql/generated';
+import Log from '../../../../log';
+import { Context } from '../../../context';
+import { askForUserProvidedAsync } from '../../../utils/promptForCredentials';
+import { AppLookupParams } from '../../api/GraphqlClient';
+import { AppleProvisioningProfileMutationResult } from '../../api/graphql/mutations/AppleProvisioningProfileMutation';
+import { ProvisioningProfile } from '../../appstore/Credentials.types';
+import { AuthCtx } from '../../appstore/authenticate';
+import { provisioningProfileSchema } from '../../credentials';
+import { MissingCredentialsNonInteractiveError } from '../../errors';
+import { generateProvisioningProfileAsync } from '../ProvisioningProfileUtils';
+import { resolveAppleTeamIfAuthenticatedAsync } from './AppleTeamUtils';
+
+export class CreateProvisioningProfile {
+  constructor(
+    private app: AppLookupParams,
+    private distributionCertificate: AppleDistributionCertificateFragment
+  ) {}
+
+  async runAsync(ctx: Context): Promise<AppleProvisioningProfileMutationResult> {
+    if (ctx.nonInteractive) {
+      throw new MissingCredentialsNonInteractiveError(
+        'Creating Provisioning Profiles is only supported in interactive mode.'
+      );
+    }
+    const appleAuthCtx = await ctx.appStore.ensureAuthenticatedAsync();
+    const provisioningProfile = await this.provideOrGenerateAsync(ctx, appleAuthCtx);
+    const appleTeam = nullthrows(await resolveAppleTeamIfAuthenticatedAsync(ctx, this.app));
+    const appleAppIdentifier = await ctx.newIos.createOrGetExistingAppleAppIdentifierAsync(
+      this.app,
+      appleTeam
+    );
+    const provisioningProfileMutationResult = await ctx.newIos.createProvisioningProfileAsync(
+      this.app,
+      appleAppIdentifier,
+      {
+        appleProvisioningProfile: provisioningProfile.provisioningProfile,
+        developerPortalIdentifier: provisioningProfile.provisioningProfileId,
+      }
+    );
+    Log.succeed('Created provisioning profile');
+    return provisioningProfileMutationResult;
+  }
+
+  private async provideOrGenerateAsync(
+    ctx: Context,
+    appleAuthCtx: AuthCtx
+  ): Promise<ProvisioningProfile> {
+    const userProvided = await askForUserProvidedAsync(provisioningProfileSchema);
+    if (userProvided) {
+      // userProvided profiles don't come with ProvisioningProfileId's (only accessible from Apple Portal API)
+      Log.warn('Provisioning profile: Unable to validate specified profile.');
+      return userProvided;
+    }
+    assert(
+      this.distributionCertificate.certificateP12,
+      'Distribution Certificate must have p12 certificate'
+    );
+    assert(
+      this.distributionCertificate.certificatePassword,
+      'Distribution Certificate must have certificate password'
+    );
+    return await generateProvisioningProfileAsync(ctx, this.app.bundleIdentifier, {
+      certId: this.distributionCertificate.developerPortalIdentifier ?? undefined,
+      certP12: this.distributionCertificate.certificateP12,
+      certPassword: this.distributionCertificate.certificatePassword,
+      distCertSerialNumber: this.distributionCertificate.serialNumber,
+      teamId: this.distributionCertificate.appleTeam?.appleTeamIdentifier ?? appleAuthCtx.appleId,
+    });
+  }
+}
@@ -1,14 +1,13 @@
-import { AppleDevice } from '../../../../graphql/generated';
+import { AppleDevice, AppleDeviceFragment } from '../../../../graphql/generated';
 import { APPLE_DEVICE_CLASS_LABELS } from '../../../../graphql/types/credentials/AppleDevice';
 import { promptAsync } from '../../.././../prompts';
-import { AppleDeviceFragmentWithAppleTeam } from '../../api/graphql/queries/AppleDeviceQuery';

 export async function chooseDevices(
-  allDevices: AppleDeviceFragmentWithAppleTeam[],
+  allDevices: AppleDeviceFragment[],
  preselectedDeviceIdentifiers: string[] = []
 ): Promise<AppleDevice[]> {
  const preselectedDeviceIdentifierSet = new Set(preselectedDeviceIdentifiers);
-  const isSelected = (device: AppleDeviceFragmentWithAppleTeam) =>
+  const isSelected = (device: AppleDeviceFragment) =>
    preselectedDeviceIdentifierSet.size === 0 ||
    preselectedDeviceIdentifierSet.has(device.identifier);
  const { devices } = await promptAsync({
@@ -27,12 +26,12 @@ export async function chooseDevices(
  return devices;
 }

-function formatDeviceLabel(device: AppleDeviceFragmentWithAppleTeam): string {
+export function formatDeviceLabel(device: AppleDeviceFragment): string {
  const deviceDetails = formatDeviceDetails(device);
  return `${device.name ?? device.identifier}${deviceDetails !== '' ? ` ${deviceDetails}` : ''}`;
 }

-function formatDeviceDetails(device: AppleDeviceFragmentWithAppleTeam): string {
+function formatDeviceDetails(device: AppleDeviceFragment): string {
  let details = '';
  if (device.deviceClass) {
    details += APPLE_DEVICE_CLASS_LABELS[device.deviceClass];
@@ -1,45 +0,0 @@
-import isEqual from 'lodash/isEqual';
-
-import { AppleDistributionCertificateFragment } from '../../../../graphql/generated';
-import Log from '../../../../log';
-import { AppleDeviceFragmentWithAppleTeam } from '../../api/graphql/queries/AppleDeviceQuery';
-import { ProvisioningProfileStoreInfo } from '../../appstore/Credentials.types';
-
-export function isDevPortalAdhocProfileValid(
-  profileFromDevPortal: ProvisioningProfileStoreInfo | null,
-  distCert: AppleDistributionCertificateFragment,
-  expectedDevices: AppleDeviceFragmentWithAppleTeam[]
-): boolean {
-  if (!profileFromDevPortal) {
-    return false;
-  }
-
-  if (profileFromDevPortal.status === 'Invalid' || profileFromDevPortal.certificates.length === 0) {
-    Log.log('Provisioning Profile is invalid');
-    return false;
-  }
-
-  const currentDistCertId = profileFromDevPortal.certificates[0].id;
-  if (
-    distCert.developerPortalIdentifier &&
-    distCert.developerPortalIdentifier !== currentDistCertId
-  ) {
-    Log.log(
-      `Provisioning Profile was generated for Distribution Certificate with ID "${currentDistCertId}", expected ID "${distCert.developerPortalIdentifier}"`
-    );
-    return false;
-  }
-
-  const profileDeviceUdids = (profileFromDevPortal.devices ?? []).map(({ udid }) => udid);
-  const expectedDeviceUdids = expectedDevices.map(({ identifier }) => identifier);
-  if (!doUDIDsMatch(profileDeviceUdids, expectedDeviceUdids)) {
-    Log.log('Provisioning Profile was generated for another set of devices');
-    return false;
-  }
-
-  return true;
-}
-
-export function doUDIDsMatch(udidsA: string[], udidsB: string[]): boolean {
-  return isEqual(new Set(udidsA), new Set(udidsB));
-}
@@ -5,16 +5,15 @@ import {
 import Log from '../../../../log';
 import { confirmAsync } from '../../../../prompts';
 import { Account } from '../../../../user/Account';
-import { Action, CredentialsManager } from '../../../CredentialsManager';
 import { Context } from '../../../context';
 import { AppLookupParams } from '../../api/GraphqlClient';
 import { selectDistributionCertificateWithDependenciesAsync } from './DistributionCertificateUtils';
 import { RemoveProvisioningProfiles } from './RemoveProvisioningProfile';

-export class SelectAndRemoveDistributionCertificate implements Action {
+export class SelectAndRemoveDistributionCertificate {
  constructor(private account: Account) {}

-  async runAsync(_manager: CredentialsManager, ctx: Context): Promise<void> {
+  async runAsync(ctx: Context): Promise<void> {
    const selected = await selectDistributionCertificateWithDependenciesAsync(ctx, this.account);
    if (selected) {
      await new RemoveDistributionCertificate(this.account, selected).runAsync(ctx);
@@ -1,199 +1,223 @@
 import assert from 'assert';
+import chalk from 'chalk';
+import differenceBy from 'lodash/differenceBy';
+import isEqual from 'lodash/isEqual';
 import nullthrows from 'nullthrows';

+import DeviceCreateAction, { RegistrationMethod } from '../../../../devices/actions/create/action';
 import {
-  AppleDevice,
+  AppleDeviceFragment,
+  AppleProvisioningProfileFragment,
+  AppleTeamFragment,
  IosAppBuildCredentialsFragment,
  IosDistributionType,
 } from '../../../../graphql/generated';
 import Log from '../../../../log';
-import { confirmAsync } from '../../../../prompts';
-import { Action, CredentialsManager } from '../../../CredentialsManager';
+import { confirmAsync, pressAnyKeyToContinueAsync } from '../../../../prompts';
 import { Context } from '../../../context';
 import { AppLookupParams } from '../../api/GraphqlClient';
-import { AppleProvisioningProfileMutationResult } from '../../api/graphql/mutations/AppleProvisioningProfileMutation';
-import { AppleDeviceFragmentWithAppleTeam } from '../../api/graphql/queries/AppleDeviceQuery';
-import { AppleProvisioningProfileQueryResult } from '../../api/graphql/queries/AppleProvisioningProfileQuery';
-import { ProvisioningProfileStoreInfo } from '../../appstore/Credentials.types';
-import { ProfileClass } from '../../appstore/provisioningProfile';
-import { AppleTeamMissingError, MissingCredentialsNonInteractiveError } from '../../errors';
+import { MissingCredentialsNonInteractiveError } from '../../errors';
+import { validateProvisioningProfileAsync } from '../../validators/validateProvisioningProfile';
 import { resolveAppleTeamIfAuthenticatedAsync } from './AppleTeamUtils';
-import { chooseDevices } from './DeviceUtils';
-import { doUDIDsMatch, isDevPortalAdhocProfileValid } from './ProvisioningProfileUtils';
+import { assignBuildCredentialsAsync, getBuildCredentialsAsync } from './BuildCredentialsUtils';
+import { chooseDevices, formatDeviceLabel } from './DeviceUtils';
 import { SetupDistributionCertificate } from './SetupDistributionCertificate';

-export class SetupAdhocProvisioningProfile implements Action {
-  private _iosAppBuildCredentials?: IosAppBuildCredentialsFragment;
-
+export class SetupAdhocProvisioningProfile {
  constructor(private app: AppLookupParams) {}

-  public get iosAppBuildCredentials(): IosAppBuildCredentialsFragment {
-    assert(
-      this._iosAppBuildCredentials,
-      'iosAppBuildCredentials can be accessed only after calling .runAsync()'
-    );
-    return this._iosAppBuildCredentials;
-  }
+  async runAsync(ctx: Context): Promise<IosAppBuildCredentialsFragment> {
+    const distCert = await new SetupDistributionCertificate(
+      this.app,
+      IosDistributionType.AdHoc
+    ).runAsync(ctx);
+
+    const areBuildCredentialsSetup = await this.areBuildCredentialsSetupAsync(ctx);

-  async runAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
    if (ctx.nonInteractive) {
-      try {
-        await this.runNonInteractiveAsync(manager, ctx);
-      } catch (err) {
-        if (err instanceof AppleTeamMissingError) {
-          throw new MissingCredentialsNonInteractiveError();
-        }
-        throw err;
+      if (areBuildCredentialsSetup) {
+        return nullthrows(await getBuildCredentialsAsync(ctx, this.app, IosDistributionType.AdHoc));
+      } else {
+        throw new MissingCredentialsNonInteractiveError(
+          'Provisioning profile is not configured correctly. Please run this command again in interactive mode.'
+        );
      }
-    } else {
-      await this.runInteractiveAsync(manager, ctx);
    }
-  }

-  private async runNonInteractiveAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
-    // 1. Setup Distribution Certificate
-    const distCertAction = new SetupDistributionCertificate(this.app);
-    await manager.runActionAsync(distCertAction);
-
-    // 2. Fetch profile from EAS servers
-    const currentProfile = await ctx.newIos.getProvisioningProfileAsync(
+    const currentBuildCredentials = await getBuildCredentialsAsync(
+      ctx,
      this.app,
      IosDistributionType.AdHoc
    );
-
-    if (!currentProfile) {
-      throw new MissingCredentialsNonInteractiveError();
-    }
-
-    // TODO: implement validation
-    Log.warn(
-      'Provisioning Profile is not validated for non-interactive internal distribution builds.'
-    );
-
-    // app credentials should exist here because the profile exists
-    const appCredentials = nullthrows(
-      await ctx.newIos.getIosAppCredentialsWithBuildCredentialsAsync(this.app, {
-        iosDistributionType: IosDistributionType.AdHoc,
-      })
-    );
-    this._iosAppBuildCredentials = appCredentials.iosAppBuildCredentialsArray[0];
-  }
-
-  private async runInteractiveAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
-    // 0. Ensure the user is authenticated with Apple and resolve the Apple team object
-    await ctx.appStore.ensureAuthenticatedAsync();
-    const appleTeam = nullthrows(await resolveAppleTeamIfAuthenticatedAsync(ctx, this.app));
-
-    // 1. Fetch devices registered on EAS servers
-    const registeredAppleDevices = await ctx.newIos.getDevicesForAppleTeamAsync(
-      this.app,
-      appleTeam
-    );
-    const registeredAppleDeviceIdentifiers = registeredAppleDevices.map(
-      ({ identifier }) => identifier
-    );
-    if (registeredAppleDeviceIdentifiers.length === 0) {
-      throw new Error(`Run 'eas device:create' to register your devices first`);
-    }
-
-    // 2. Setup Distribution Certificate
-    const distCertAction = new SetupDistributionCertificate(this.app);
-    await manager.runActionAsync(distCertAction);
-    const distCert = distCertAction.distributionCertificate;
-
-    let profileFromExpoServersToUse:
-      | AppleProvisioningProfileQueryResult
-      | AppleProvisioningProfileMutationResult
-      | null = await ctx.newIos.getProvisioningProfileAsync(this.app, IosDistributionType.AdHoc, {
-      appleTeam,
-    });
-
-    // 4. Choose devices for internal distribution
-    let chosenDevices: AppleDeviceFragmentWithAppleTeam[];
-    if (profileFromExpoServersToUse) {
-      const appleDeviceIdentifiersFromProfile = ((profileFromExpoServersToUse.appleDevices ??
-        []) as AppleDevice[]).map(({ identifier }) => identifier);
-
-      let shouldAskToChooseDevices = true;
-      if (doUDIDsMatch(appleDeviceIdentifiersFromProfile, registeredAppleDeviceIdentifiers)) {
-        shouldAskToChooseDevices = await confirmAsync({
-          message: `All your registered devices are present in the Provisioning Profile. Would you like to exclude some devices?`,
-          initial: false,
-        });
+    if (areBuildCredentialsSetup) {
+      const buildCredentials = nullthrows(currentBuildCredentials);
+      if (await this.shouldGenerateNewProfileAsync(ctx, buildCredentials)) {
+        return buildCredentials;
      }
-
-      chosenDevices = shouldAskToChooseDevices
-        ? await chooseDevices(registeredAppleDevices, appleDeviceIdentifiersFromProfile)
-        : registeredAppleDevices;
-    } else {
-      chosenDevices = await chooseDevices(registeredAppleDevices);
    }

-    // 5. Try to find the profile on Apple Developer Portal
-    const currentProfileFromDevPortal = await this.getProfileFromDevPortalAsync(ctx);
+    // 1. Resolve Apple Team
+    let appleTeam: AppleTeamFragment | null =
+      distCert.appleTeam ?? currentBuildCredentials?.provisioningProfile?.appleTeam ?? null;
+    if (!appleTeam) {
+      await ctx.appStore.ensureAuthenticatedAsync();
+      appleTeam = await resolveAppleTeamIfAuthenticatedAsync(ctx, this.app);
+    }
+    assert(appleTeam, 'Apple Team must be defined here');

-    // 6. Validate the profile and possibly recreate it
-    let profileToUse: ProvisioningProfileStoreInfo;
-    let profileWasRecreated = false;
-    if (isDevPortalAdhocProfileValid(currentProfileFromDevPortal, distCert, chosenDevices)) {
-      profileToUse = nullthrows(currentProfileFromDevPortal);
-    } else {
-      const chosenDeviceUDIDs = chosenDevices.map(({ identifier }) => identifier);
-      await ctx.appStore.createOrReuseAdhocProvisioningProfileAsync(
-        chosenDeviceUDIDs,
-        this.app.bundleIdentifier,
-        distCert.serialNumber
-      );
-      profileToUse = nullthrows(await this.getProfileFromDevPortalAsync(ctx));
-      profileWasRecreated = true;
+    // 2. Fetch devices registered on EAS servers
+    let registeredAppleDevices = await ctx.newIos.getDevicesForAppleTeamAsync(this.app, appleTeam);
+    if (registeredAppleDevices.length === 0) {
+      const shouldRegisterDevices = await confirmAsync({
+        message: `You don't have any registered devices yet. Would you like to register them now?`,
+        initial: true,
+      });
+
+      if (shouldRegisterDevices) {
+        registeredAppleDevices = await this.registerDevicesAsync(ctx, appleTeam);
+      } else {
+        throw new Error(`Run 'eas device:create' to register your devices first`);
+      }
    }

-    // 7. Send profile to www if new has been created
+    // 3. Choose devices for internal distribution
+    const provisionedDeviceIdentifiers = (
+      currentBuildCredentials?.provisioningProfile?.appleDevices ?? []
+    ).map(i => i.identifier);
+    const chosenDevices = await chooseDevices(registeredAppleDevices, provisionedDeviceIdentifiers);
+
+    // 4. Reuse or create the profile on Apple Developer Portal
+    const provisioningProfileStoreInfo = await ctx.appStore.createOrReuseAdhocProvisioningProfileAsync(
+      chosenDevices.map(({ identifier }) => identifier),
+      this.app.bundleIdentifier,
+      distCert.serialNumber
+    );
+
+    // 5. Create or update the profile on servers
    const appleAppIdentifier = await ctx.newIos.createOrGetExistingAppleAppIdentifierAsync(
      this.app,
      appleTeam
    );
-    if (profileFromExpoServersToUse) {
-      if (profileWasRecreated) {
-        profileFromExpoServersToUse = await ctx.newIos.updateProvisioningProfileAsync(
-          profileFromExpoServersToUse.id,
+    let appleProvisioningProfile: AppleProvisioningProfileFragment | null = null;
+    if (currentBuildCredentials?.provisioningProfile) {
+      if (
+        currentBuildCredentials.provisioningProfile.developerPortalIdentifier !==
+        provisioningProfileStoreInfo.provisioningProfileId
+      ) {
+        await ctx.newIos.deleteProvisioningProfilesAsync([
+          currentBuildCredentials.provisioningProfile.id,
+        ]);
+        appleProvisioningProfile = await ctx.newIos.createProvisioningProfileAsync(
+          this.app,
+          appleAppIdentifier,
          {
-            appleProvisioningProfile: profileToUse.provisioningProfile,
-            developerPortalIdentifier: profileToUse.provisioningProfileId,
+            appleProvisioningProfile: provisioningProfileStoreInfo.provisioningProfile,
+            developerPortalIdentifier: provisioningProfileStoreInfo.provisioningProfileId,
          }
        );
+      } else {
+        appleProvisioningProfile = currentBuildCredentials.provisioningProfile;
      }
    } else {
-      profileFromExpoServersToUse = await ctx.newIos.createProvisioningProfileAsync(
+      appleProvisioningProfile = await ctx.newIos.createProvisioningProfileAsync(
        this.app,
        appleAppIdentifier,
        {
-          appleProvisioningProfile: profileToUse.provisioningProfile,
-          developerPortalIdentifier: profileToUse.provisioningProfileId,
+          appleProvisioningProfile: provisioningProfileStoreInfo.provisioningProfile,
+          developerPortalIdentifier: provisioningProfileStoreInfo.provisioningProfileId,
        }
      );
    }

-    // 8. Create (or update) app build credentials
-    this._iosAppBuildCredentials = await ctx.newIos.createOrUpdateIosAppBuildCredentialsAsync(
+    // 6. Create (or update) app build credentials
+    assert(appleProvisioningProfile);
+    return await assignBuildCredentialsAsync(
+      ctx,
      this.app,
-      {
-        appleTeam,
-        appleAppIdentifierId: appleAppIdentifier.id,
-        appleDistributionCertificateId: distCert.id,
-        appleProvisioningProfileId: profileFromExpoServersToUse.id,
-        iosDistributionType: IosDistributionType.AdHoc,
-      }
+      IosDistributionType.AdHoc,
+      distCert,
+      appleProvisioningProfile,
+      appleTeam
    );
  }

-  private async getProfileFromDevPortalAsync(
-    ctx: Context
-  ): Promise<ProvisioningProfileStoreInfo | null> {
-    const profilesFromDevPortal = await ctx.appStore.listProvisioningProfilesAsync(
-      this.app.bundleIdentifier,
-      ProfileClass.Adhoc
+  private async areBuildCredentialsSetupAsync(ctx: Context): Promise<boolean> {
+    const buildCredentials = await getBuildCredentialsAsync(
+      ctx,
+      this.app,
+      IosDistributionType.AdHoc
    );
-    return profilesFromDevPortal.length >= 1 ? profilesFromDevPortal[0] : null;
+    return await validateProvisioningProfileAsync(ctx, this.app, buildCredentials);
+  }
+
+  private async shouldGenerateNewProfileAsync(
+    ctx: Context,
+    buildCredentials: IosAppBuildCredentialsFragment
+  ): Promise<boolean> {
+    const provisioningProfile = nullthrows(buildCredentials.provisioningProfile);
+
+    const appleTeam = nullthrows(provisioningProfile.appleTeam);
+    const registeredAppleDevices = await ctx.newIos.getDevicesForAppleTeamAsync(
+      this.app,
+      appleTeam
+    );
+
+    const provisionedDevices = provisioningProfile.appleDevices;
+
+    const allRegisteredDevicesAreProvisioned = doUDIDsMatch(
+      registeredAppleDevices.map(({ identifier }) => identifier),
+      provisionedDevices.map(({ identifier }) => identifier)
+    );
+
+    if (allRegisteredDevicesAreProvisioned) {
+      return await confirmAsync({
+        message: `All your registered devices are present in the Provisioning Profile. Would you like to reuse it?`,
+        initial: true,
+      });
+    } else {
+      const missingDevices = differenceBy(registeredAppleDevices, provisionedDevices, 'identifier');
+      Log.warn(`The provisioning profile is missing the following devices:`);
+      for (const missingDevice of missingDevices) {
+        Log.warn(`- ${formatDeviceLabel(missingDevice)}`);
+      }
+      return !(await confirmAsync({
+        message: `Would you like to choose the devices to provision again?`,
+        initial: true,
+      }));
+    }
+  }
+
+  private async registerDevicesAsync(
+    ctx: Context,
+    appleTeam: AppleTeamFragment
+  ): Promise<AppleDeviceFragment[]> {
+    const action = new DeviceCreateAction(this.app.account, appleTeam);
+    const method = await action.runAsync();
+
+    while (true) {
+      if (method !== RegistrationMethod.INPUT) {
+        Log.newLine();
+        Log.log(chalk.bold("Press any key if you've already finished device registration."));
+        await pressAnyKeyToContinueAsync();
+      }
+      Log.newLine();
+
+      const devices = await ctx.newIos.getDevicesForAppleTeamAsync(this.app, appleTeam, {
+        useCache: false,
+      });
+      if (devices.length === 0) {
+        Log.warn('There are still no registered devices.');
+        // if the user used the input method there should be some devices available
+        if (method === RegistrationMethod.INPUT) {
+          throw new Error('Input registration method has failed');
+        }
+      } else {
+        return devices;
+      }
+    }
  }
 }
+
+function doUDIDsMatch(udidsA: string[], udidsB: string[]): boolean {
+  return isEqual(new Set(udidsA), new Set(udidsB));
+}
@@ -0,0 +1,189 @@
+import chalk from 'chalk';
+import nullthrows from 'nullthrows';
+
+import {
+  AppleDistributionCertificateFragment,
+  AppleProvisioningProfileFragment,
+  AppleTeamFragment,
+  IosAppBuildCredentialsFragment,
+  IosDistributionType,
+} from '../../../../graphql/generated';
+import Log from '../../../../log';
+import { confirmAsync } from '../../../../prompts';
+import { Context } from '../../../context';
+import {
+  IosTargetCredentials,
+  isCredentialsMap,
+  readIosCredentialsAsync,
+} from '../../../credentialsJson/read';
+import { AppLookupParams } from '../../api/GraphqlClient';
+import { displayProjectCredentials } from '../../utils/printCredentialsBeta';
+import { readAppleTeam } from '../../utils/provisioningProfile';
+import {
+  assignBuildCredentialsAsync,
+  getBuildCredentialsAsync,
+  getDistributionCertificateAsync,
+  getProvisioningProfileAsync,
+} from './BuildCredentialsUtils';
+
+export class SetupBuildCredentialsFromCredentialsJson {
+  constructor(private app: AppLookupParams, private distributionType: IosDistributionType) {}
+
+  async getDistributionCertificateToAssignAsync(
+    ctx: Context,
+    targetCredentials: IosTargetCredentials,
+    appleTeam: AppleTeamFragment,
+    currentDistributionCertificate: AppleDistributionCertificateFragment | null
+  ): Promise<AppleDistributionCertificateFragment> {
+    const { distributionCertificate } = targetCredentials;
+    const { certP12, certPassword } = distributionCertificate;
+
+    if (!currentDistributionCertificate) {
+      return await ctx.newIos.createDistributionCertificateAsync(this.app, {
+        certP12,
+        certPassword,
+        teamId: appleTeam.appleTeamIdentifier,
+        teamName: appleTeam.appleTeamName ?? undefined,
+      });
+    }
+
+    const isSameCertificate = currentDistributionCertificate.certificateP12 === certP12;
+    if (!isSameCertificate) {
+      return await ctx.newIos.createDistributionCertificateAsync(this.app, {
+        certP12,
+        certPassword,
+        teamId: appleTeam.appleTeamIdentifier,
+        teamName: appleTeam.appleTeamName ?? undefined,
+      });
+    }
+
+    // If the configured Distribution Certificate is the same as the new one, just use the currently configured certificate
+    return currentDistributionCertificate;
+  }
+
+  async createNewProvisioningProfileAsync(
+    ctx: Context,
+    targetCredentials: IosTargetCredentials,
+    appleTeam: AppleTeamFragment
+  ): Promise<AppleProvisioningProfileFragment> {
+    const { provisioningProfile } = targetCredentials;
+
+    const appleAppIdentifier = await ctx.newIos.createOrGetExistingAppleAppIdentifierAsync(
+      this.app,
+      appleTeam
+    );
+    return await ctx.newIos.createProvisioningProfileAsync(this.app, appleAppIdentifier, {
+      appleProvisioningProfile: provisioningProfile,
+    });
+  }
+
+  async getProvisioningProfileToAssignAsync(
+    ctx: Context,
+    targetCredentials: IosTargetCredentials,
+    appleTeam: AppleTeamFragment,
+    currentProvisioningProfile: AppleProvisioningProfileFragment | null
+  ): Promise<AppleProvisioningProfileFragment> {
+    const { provisioningProfile } = targetCredentials;
+
+    if (!currentProvisioningProfile) {
+      return await this.createNewProvisioningProfileAsync(ctx, targetCredentials, appleTeam);
+    }
+
+    const isSameProfile = currentProvisioningProfile.provisioningProfile === provisioningProfile;
+    if (!isSameProfile) {
+      return await this.createNewProvisioningProfileAsync(ctx, targetCredentials, appleTeam);
+    }
+
+    // If the configured Provisioning Profile is the same as the new one, just use the currently configured profile
+    return currentProvisioningProfile;
+  }
+
+  async runAsync(ctx: Context): Promise<IosAppBuildCredentialsFragment> {
+    let localCredentials;
+    try {
+      localCredentials = await readIosCredentialsAsync(ctx.projectDir);
+    } catch (error) {
+      Log.error(
+        'Reading credentials from credentials.json failed. Make sure this file is correct and all credentials are present there.'
+      );
+      throw error;
+    }
+
+    // TODO: implement storing multi-target credentials on EAS servers
+    if (isCredentialsMap(localCredentials)) {
+      throw new Error(
+        'Storing multi-target iOS credentials from credentials.json on EAS servers is not yet supported.'
+      );
+    }
+
+    // currently configured credentials
+    const buildCredentials = await getBuildCredentialsAsync(ctx, this.app, this.distributionType);
+    const currentDistributionCertificate = await getDistributionCertificateAsync(
+      ctx,
+      this.app,
+      this.distributionType
+    );
+    const currentProfile = await getProvisioningProfileAsync(ctx, this.app, this.distributionType);
+    const appInfo = `@${this.app.account.name}/${this.app.projectName} (${this.app.bundleIdentifier})`;
+
+    // new credentials from local json
+    const appleTeamFromProvisioningProfile = readAppleTeam(localCredentials.provisioningProfile);
+    const appleTeam = await ctx.newIos.createOrGetExistingAppleTeamAsync(this.app, {
+      appleTeamIdentifier: appleTeamFromProvisioningProfile.teamId,
+      appleTeamName: appleTeamFromProvisioningProfile.teamName,
+    });
+    const distributionCertificateToAssign = await this.getDistributionCertificateToAssignAsync(
+      ctx,
+      localCredentials,
+      appleTeam,
+      currentDistributionCertificate
+    );
+    const provisioningProfileToAssign = await this.getProvisioningProfileToAssignAsync(
+      ctx,
+      localCredentials,
+      appleTeam,
+      currentProfile
+    );
+
+    const didCredentialsChange =
+      !currentDistributionCertificate ||
+      !currentProfile ||
+      currentDistributionCertificate.id !== distributionCertificateToAssign.id ||
+      currentProfile.id !== provisioningProfileToAssign.id;
+    if (!didCredentialsChange) {
+      Log.log('Credentials have already been configured to your credentials json.');
+      return nullthrows(buildCredentials, 'buildCredentials should have been defined.');
+    }
+
+    if (buildCredentials) {
+      Log.log('Currently configured credentials:');
+      displayProjectCredentials(this.app, buildCredentials);
+      if (!ctx.nonInteractive) {
+        const confirm = await confirmAsync({
+          message: `Would you like to replace this configuration with credentials from credentials json?`,
+        });
+        if (!confirm) {
+          throw new Error('Aborting setup of build credentials from credentials json');
+        }
+      }
+    }
+
+    Log.log(`Assigning credentials from credentials json to ${appInfo}...`);
+    const newBuildCredentials = await assignBuildCredentialsAsync(
+      ctx,
+      this.app,
+      this.distributionType,
+      distributionCertificateToAssign,
+      provisioningProfileToAssign,
+      appleTeam
+    );
+
+    Log.log('New credentials configuration:');
+    displayProjectCredentials(this.app, newBuildCredentials);
+
+    Log.newLine();
+    Log.log(chalk.green(`All credentials are ready to build ${appInfo}`));
+    Log.newLine();
+    return newBuildCredentials;
+  }
+}
@@ -8,7 +8,6 @@ import {
 } from '../../../../graphql/generated';
 import Log from '../../../../log';
 import { confirmAsync, promptAsync } from '../../../../prompts';
-import { Action, CredentialsManager } from '../../../CredentialsManager';
 import { Context } from '../../../context';
 import { AppLookupParams } from '../../api/GraphqlClient';
 import { AppleDistributionCertificateMutationResult } from '../../api/graphql/mutations/AppleDistributionCertificateMutation';
@@ -18,34 +17,25 @@ import { resolveAppleTeamIfAuthenticatedAsync } from './AppleTeamUtils';
 import { CreateDistributionCertificate } from './CreateDistributionCertificate';
 import { formatDistributionCertificate } from './DistributionCertificateUtils';

-export class SetupDistributionCertificate implements Action {
+export class SetupDistributionCertificate {
  private validDistCerts?: AppleDistributionCertificateFragment[];
-  private _distributionCertificate?: AppleDistributionCertificateFragment;

-  constructor(private app: AppLookupParams) {}
+  constructor(private app: AppLookupParams, private distributionType: IosDistributionType) {}

-  public get distributionCertificate(): AppleDistributionCertificateFragment {
-    assert(
-      this._distributionCertificate,
-      'distributionCertificate can be accessed only after calling .runAsync()'
-    );
-    return this._distributionCertificate;
-  }
-
-  public async runAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
+  public async runAsync(ctx: Context): Promise<AppleDistributionCertificateFragment> {
    const appleTeam = await resolveAppleTeamIfAuthenticatedAsync(ctx, this.app);

    try {
      const currentCertificate = await ctx.newIos.getDistributionCertificateForAppAsync(
        this.app,
-        IosDistributionType.AdHoc,
+        this.distributionType,
        { appleTeam }
      );

      if (ctx.nonInteractive) {
-        await this.runNonInteractiveAsync(ctx, currentCertificate);
+        return await this.runNonInteractiveAsync(ctx, currentCertificate);
      } else {
-        await this.runInteractiveAsync(ctx, manager, currentCertificate);
+        return await this.runInteractiveAsync(ctx, currentCertificate);
      }
    } catch (err) {
      if (err instanceof AppleTeamMissingError && ctx.nonInteractive) {
@@ -58,34 +48,29 @@ export class SetupDistributionCertificate implements Action {
  private async runNonInteractiveAsync(
    ctx: Context,
    currentCertificate: AppleDistributionCertificateFragment | null
-  ): Promise<void> {
+  ): Promise<AppleDistributionCertificateFragment> {
    // TODO: implement validation
    Log.addNewLineIfNone();
-    Log.warn(
-      'Distribution Certificate is not validated for non-interactive internal distribution builds.'
-    );
+    Log.warn('Distribution Certificate is not validated for non-interactive builds.');
    if (!currentCertificate) {
      throw new MissingCredentialsNonInteractiveError();
    }
-    this._distributionCertificate = currentCertificate;
+    return currentCertificate;
  }

  private async runInteractiveAsync(
    ctx: Context,
-    manager: CredentialsManager,
    currentCertificate: AppleDistributionCertificateFragment | null
-  ): Promise<void> {
+  ): Promise<AppleDistributionCertificateFragment> {
    if (await this.isCurrentCertificateValidAsync(ctx, currentCertificate)) {
      assert(currentCertificate, 'currentCertificate is defined here');
-      this._distributionCertificate = currentCertificate;
-      return;
+      return currentCertificate;
    }

    const validDistCertsOnFile = await this.getValidDistCertsAsync(ctx);
-    this._distributionCertificate =
-      validDistCertsOnFile.length === 0
-        ? await this.createNewDistCertAsync(manager)
-        : await this.createOrReuseDistCert(manager, ctx);
+    return validDistCertsOnFile.length === 0
+      ? await this.createNewDistCertAsync(ctx)
+      : await this.createOrReuseDistCert(ctx);
  }

  private async isCurrentCertificateValidAsync(
@@ -105,10 +90,7 @@ export class SetupDistributionCertificate implements Action {
    return isValid;
  }

-  private async createOrReuseDistCert(
-    manager: CredentialsManager,
-    ctx: Context
-  ): Promise<AppleDistributionCertificateFragment> {
+  private async createOrReuseDistCert(ctx: Context): Promise<AppleDistributionCertificateFragment> {
    const validDistCerts = await this.getValidDistCertsAsync(ctx);
    const autoselectedDistCert = validDistCerts[0];

@@ -139,18 +121,16 @@ export class SetupDistributionCertificate implements Action {
    });

    if (action === 'GENERATE') {
-      return await this.createNewDistCertAsync(manager);
+      return await this.createNewDistCertAsync(ctx);
    } else {
      return await this.reuseDistCertAsync(ctx);
    }
  }

  private async createNewDistCertAsync(
-    manager: CredentialsManager
+    ctx: Context
  ): Promise<AppleDistributionCertificateMutationResult> {
-    const action = new CreateDistributionCertificate(this.app);
-    await manager.runActionAsync(action);
-    return action.distributionCertificate;
+    return new CreateDistributionCertificate(this.app).runAsync(ctx);
  }

  private async reuseDistCertAsync(ctx: Context): Promise<AppleDistributionCertificate> {
@@ -0,0 +1,12 @@
+import { IosAppBuildCredentialsFragment } from '../../../../graphql/generated';
+import { Context } from '../../../context';
+import { AppLookupParams } from '../../api/GraphqlClient';
+import { SetupAdhocProvisioningProfile } from './SetupAdhocProvisioningProfile';
+
+export class SetupInternalProvisioningProfile {
+  constructor(private app: AppLookupParams) {}
+
+  async runAsync(ctx: Context): Promise<IosAppBuildCredentialsFragment> {
+    return await new SetupAdhocProvisioningProfile(this.app).runAsync(ctx);
+  }
+}
@@ -0,0 +1,147 @@
+import nullthrows from 'nullthrows';
+
+import {
+  AppleDistributionCertificateFragment,
+  AppleProvisioningProfileFragment,
+  IosAppBuildCredentialsFragment,
+  IosDistributionType,
+} from '../../../../graphql/generated';
+import { confirmAsync } from '../../../../prompts';
+import { Context } from '../../../context';
+import { AppLookupParams } from '../../api/GraphqlClient';
+import { ProvisioningProfileStoreInfo } from '../../appstore/Credentials.types';
+import { MissingCredentialsNonInteractiveError } from '../../errors';
+import { validateProvisioningProfileAsync } from '../../validators/validateProvisioningProfile';
+import { formatProvisioningProfileFromApple } from '../ProvisioningProfileUtils';
+import {
+  assignBuildCredentialsAsync,
+  getBuildCredentialsAsync,
+  getProvisioningProfileAsync,
+} from './BuildCredentialsUtils';
+import { ConfigureProvisioningProfile } from './ConfigureProvisioningProfile';
+import { CreateProvisioningProfile } from './CreateProvisioningProfile';
+import { SetupDistributionCertificate } from './SetupDistributionCertificate';
+
+export class SetupProvisioningProfile {
+  constructor(private app: AppLookupParams, private distributionType: IosDistributionType) {}
+
+  async areBuildCredentialsSetupAsync(ctx: Context): Promise<boolean> {
+    const buildCredentials = await getBuildCredentialsAsync(ctx, this.app, this.distributionType);
+    return await validateProvisioningProfileAsync(ctx, this.app, buildCredentials);
+  }
+
+  async assignNewAndDeleteOldProfileAsync(
+    ctx: Context,
+    distCert: AppleDistributionCertificateFragment,
+    currentProfile: AppleProvisioningProfileFragment
+  ): Promise<IosAppBuildCredentialsFragment> {
+    const buildCredentials = await this.createAndAssignProfileAsync(ctx, distCert);
+    // delete 'currentProfile' since its no longer valid
+    await ctx.newIos.deleteProvisioningProfilesAsync([currentProfile.id]);
+    return buildCredentials;
+  }
+
+  async createAndAssignProfileAsync(
+    ctx: Context,
+    distCert: AppleDistributionCertificateFragment
+  ): Promise<IosAppBuildCredentialsFragment> {
+    const provisioningProfile = await new CreateProvisioningProfile(this.app, distCert).runAsync(
+      ctx
+    );
+    return await assignBuildCredentialsAsync(
+      ctx,
+      this.app,
+      this.distributionType,
+      distCert,
+      provisioningProfile
+    );
+  }
+
+  async configureAndAssignProfileAsync(
+    ctx: Context,
+    distCert: AppleDistributionCertificateFragment,
+    originalProvisioningProfile: AppleProvisioningProfileFragment
+  ): Promise<IosAppBuildCredentialsFragment | null> {
+    const profileConfigurator = new ConfigureProvisioningProfile(
+      this.app,
+      distCert,
+      originalProvisioningProfile
+    );
+    const updatedProvisioningProfile = await profileConfigurator.runAsync(ctx);
+    if (!updatedProvisioningProfile) {
+      return null;
+    }
+    return await assignBuildCredentialsAsync(
+      ctx,
+      this.app,
+      this.distributionType,
+      distCert,
+      updatedProvisioningProfile
+    );
+  }
+
+  async runAsync(ctx: Context): Promise<IosAppBuildCredentialsFragment> {
+    const distCert = await new SetupDistributionCertificate(
+      this.app,
+      this.distributionType
+    ).runAsync(ctx);
+
+    const areBuildCredentialsSetup = await this.areBuildCredentialsSetupAsync(ctx);
+    if (areBuildCredentialsSetup) {
+      return nullthrows(await getBuildCredentialsAsync(ctx, this.app, this.distributionType));
+    }
+    if (ctx.nonInteractive) {
+      throw new MissingCredentialsNonInteractiveError(
+        'Provisioning profile is not configured correctly. Please run this command again in interactive mode.'
+      );
+    }
+
+    const currentProfile = await getProvisioningProfileAsync(ctx, this.app, this.distributionType);
+    if (!currentProfile) {
+      return await this.createAndAssignProfileAsync(ctx, distCert);
+    }
+
+    // See if the profile we have exists on the Apple Servers
+    const existingProfiles = await ctx.appStore.listProvisioningProfilesAsync(
+      this.app.bundleIdentifier
+    );
+    const currentProfileFromServer = this.getCurrentProfileStoreInfo(
+      existingProfiles,
+      currentProfile
+    );
+    if (!currentProfileFromServer) {
+      return await this.assignNewAndDeleteOldProfileAsync(ctx, distCert, currentProfile);
+    }
+
+    const confirm = await confirmAsync({
+      message: `${formatProvisioningProfileFromApple(
+        currentProfileFromServer
+      )} \n  Would you like to reuse the original profile?`,
+    });
+    if (!confirm) {
+      return await this.assignNewAndDeleteOldProfileAsync(ctx, distCert, currentProfile);
+    }
+
+    // If we get here, we've verified the current profile still exists on Apple
+    // But something wasn't quite right, so we want to fix and update it
+    const updatedProfile = await this.configureAndAssignProfileAsync(ctx, distCert, currentProfile);
+    if (!updatedProfile) {
+      // Something went wrong, so just create a new profile instead
+      return await this.assignNewAndDeleteOldProfileAsync(ctx, distCert, currentProfile);
+    }
+    return updatedProfile;
+  }
+
+  private getCurrentProfileStoreInfo(
+    profiles: ProvisioningProfileStoreInfo[],
+    currentProfile: AppleProvisioningProfileFragment
+  ): ProvisioningProfileStoreInfo | null {
+    return (
+      profiles.find(profile =>
+        currentProfile.developerPortalIdentifier
+          ? currentProfile.developerPortalIdentifier === profile.provisioningProfileId
+          : currentProfile.provisioningProfile === profile.provisioningProfile
+      ) ?? null
+    );
+  }
+}
@@ -0,0 +1,20 @@
+import {
+  AppleDistributionCertificateFragment,
+  AppleProvisioningProfileFragment,
+} from '../../../../../graphql/generated';
+import { testProvisioningProfileFragment } from '../../../../__tests__/fixtures-ios';
+import { Context } from '../../../../context';
+import { AppLookupParams } from '../../../api/GraphqlClient';
+import { AppleProvisioningProfileMutationResult } from '../../../api/graphql/mutations/AppleProvisioningProfileMutation';
+
+export class ConfigureProvisioningProfile {
+  constructor(
+    private app: AppLookupParams,
+    private distributionCertificate: AppleDistributionCertificateFragment,
+    private originalProvisioningProfile: AppleProvisioningProfileFragment
+  ) {}
+
+  public async runAsync(ctx: Context): Promise<AppleProvisioningProfileMutationResult | null> {
+    return testProvisioningProfileFragment;
+  }
+}
@@ -0,0 +1,16 @@
+import { AppleDistributionCertificateFragment } from '../../../../../graphql/generated';
+import { testProvisioningProfileFragment } from '../../../../__tests__/fixtures-ios';
+import { Context } from '../../../../context';
+import { AppLookupParams } from '../../../api/GraphqlClient';
+import { AppleProvisioningProfileMutationResult } from '../../../api/graphql/mutations/AppleProvisioningProfileMutation';
+
+export class CreateProvisioningProfile {
+  constructor(
+    private app: AppLookupParams,
+    private distributionCertificate: AppleDistributionCertificateFragment
+  ) {}
+
+  async runAsync(ctx: Context): Promise<AppleProvisioningProfileMutationResult> {
+    return testProvisioningProfileFragment;
+  }
+}
@@ -0,0 +1,14 @@
+import {
+  AppleDistributionCertificateFragment,
+  IosDistributionType,
+} from '../../../../../graphql/generated';
+import { testDistCertFragmentOneDependency } from '../../../../__tests__/fixtures-ios';
+import { Context } from '../../../../context';
+import { AppLookupParams } from '../../../api/GraphqlClient';
+export class SetupDistributionCertificate {
+  constructor(private app: AppLookupParams, private distributionType: IosDistributionType) {}
+
+  public async runAsync(_ctx: Context): Promise<AppleDistributionCertificateFragment> {
+    return testDistCertFragmentOneDependency;
+  }
+}
@@ -0,0 +1,64 @@
+import { confirmAsync } from '../../../../../prompts';
+import { getAppstoreMock, testAuthCtx } from '../../../../__tests__/fixtures-appstore';
+import { createCtxMock } from '../../../../__tests__/fixtures-context';
+import {
+  testDistCertFragmentNoDependencies,
+  testProvisioningProfile,
+  testProvisioningProfileFragment,
+} from '../../../../__tests__/fixtures-ios';
+import { MissingCredentialsNonInteractiveError } from '../../../errors';
+import { getAppLookupParamsFromContext } from '../BuildCredentialsUtils';
+import { ConfigureProvisioningProfile } from '../ConfigureProvisioningProfile';
+jest.mock('../../../../../prompts');
+(confirmAsync as jest.Mock).mockImplementation(() => true);
+
+describe('ConfigureProvisioningProfile', () => {
+  it('configures a Provisioning Profile in Interactive Mode', async () => {
+    const mockProvisioningProfileFromApple = {
+      provisioningProfileId: testProvisioningProfileFragment.developerPortalIdentifier,
+      provisioningProfile: testProvisioningProfileFragment.provisioningProfile,
+    };
+    const ctx = createCtxMock({
+      nonInteractive: false,
+      appStore: {
+        ...getAppstoreMock(),
+        ensureAuthenticatedAsync: jest.fn(() => testAuthCtx),
+        authCtx: testAuthCtx,
+        createProvisioningProfileAsync: jest.fn(() => testProvisioningProfile),
+        listProvisioningProfilesAsync: jest.fn(() => [mockProvisioningProfileFromApple]),
+        useExistingProvisioningProfileAsync: jest.fn(() => mockProvisioningProfileFromApple),
+      },
+    });
+    const appLookupParams = getAppLookupParamsFromContext(ctx);
+    const provProfConfigurator = new ConfigureProvisioningProfile(
+      appLookupParams,
+      testDistCertFragmentNoDependencies,
+      testProvisioningProfileFragment
+    );
+    await provProfConfigurator.runAsync(ctx);
+
+    // expect provisioning profile not to be updated on expo servers
+    expect((ctx.newIos.updateProvisioningProfileAsync as any).mock.calls.length).toBe(1);
+    // expect provisioning profile not to be updated on apple portal
+    expect((ctx.appStore.useExistingProvisioningProfileAsync as any).mock.calls.length).toBe(1);
+  });
+  it('errors in Non Interactive Mode', async () => {
+    const ctx = createCtxMock({
+      nonInteractive: true,
+    });
+    const appLookupParams = getAppLookupParamsFromContext(ctx);
+    const provProfConfigurator = new ConfigureProvisioningProfile(
+      appLookupParams,
+      testDistCertFragmentNoDependencies,
+      testProvisioningProfileFragment
+    );
+    await expect(provProfConfigurator.runAsync(ctx)).rejects.toThrowError(
+      MissingCredentialsNonInteractiveError
+    );
+
+    // expect provisioning profile not to be updated on expo servers
+    expect((ctx.newIos.updateProvisioningProfileAsync as any).mock.calls.length).toBe(0);
+    // expect provisioning profile not to be updated on apple portal
+    expect((ctx.appStore.useExistingProvisioningProfileAsync as any).mock.calls.length).toBe(0);
+  });
+});
@@ -0,0 +1,55 @@
+import { confirmAsync } from '../../../../../prompts';
+import { getAppstoreMock, testAuthCtx } from '../../../../__tests__/fixtures-appstore';
+import { createCtxMock } from '../../../../__tests__/fixtures-context';
+import {
+  testDistCertFragmentNoDependencies,
+  testProvisioningProfile,
+} from '../../../../__tests__/fixtures-ios';
+import { MissingCredentialsNonInteractiveError } from '../../../errors';
+import { getAppLookupParamsFromContext } from '../BuildCredentialsUtils';
+import { CreateProvisioningProfile } from '../CreateProvisioningProfile';
+jest.mock('../../../../../prompts');
+(confirmAsync as jest.Mock).mockImplementation(() => true);
+
+describe('CreateProvisioningProfile', () => {
+  it('creates a Provisioning Profile in Interactive Mode', async () => {
+    const ctx = createCtxMock({
+      nonInteractive: false,
+      appStore: {
+        ...getAppstoreMock(),
+        ensureAuthenticatedAsync: jest.fn(() => testAuthCtx),
+        authCtx: testAuthCtx,
+        createProvisioningProfileAsync: jest.fn(() => testProvisioningProfile),
+      },
+    });
+    const appLookupParams = getAppLookupParamsFromContext(ctx);
+    const createProvProfAction = new CreateProvisioningProfile(
+      appLookupParams,
+      testDistCertFragmentNoDependencies
+    );
+    await createProvProfAction.runAsync(ctx);
+
+    // expect provisioning profile to be created on expo servers
+    expect((ctx.newIos.createProvisioningProfileAsync as any).mock.calls.length).toBe(1);
+    // expect provisioning profile to be created on apple portal
+    expect((ctx.appStore.createProvisioningProfileAsync as any).mock.calls.length).toBe(1);
+  });
+  it('errors in Non Interactive Mode', async () => {
+    const ctx = createCtxMock({
+      nonInteractive: true,
+    });
+    const appLookupParams = getAppLookupParamsFromContext(ctx);
+    const createProvProfAction = new CreateProvisioningProfile(
+      appLookupParams,
+      testDistCertFragmentNoDependencies
+    );
+    await expect(createProvProfAction.runAsync(ctx)).rejects.toThrowError(
+      MissingCredentialsNonInteractiveError
+    );
+
+    // expect provisioning profile not to be created on expo servers
+    expect((ctx.newIos.createProvisioningProfileAsync as any).mock.calls.length).toBe(0);
+    // expect provisioning profile not to be created on apple portal
+    expect((ctx.appStore.createProvisioningProfileAsync as any).mock.calls.length).toBe(0);
+  });
+});
@@ -4,7 +4,7 @@ import {
  testDistCertFragmentNoDependencies,
  testDistCertFragmentOneDependency,
 } from '../../../../__tests__/fixtures-ios';
-import { ManageIosBeta } from '../../../../manager/ManageIosBeta';
+import { getAppLookupParamsFromContext } from '../BuildCredentialsUtils';
 import { RemoveDistributionCertificate } from '../RemoveDistributionCertificate';

 jest.mock('../../../../../prompts');
@@ -13,7 +13,7 @@ jest.mock('../../../../../prompts');
 describe('RemoveDistributionCertificate', () => {
  it('deletes the distribution certificate on Expo and Apple servers when there are no App Dependencies in Interactive Mode', async () => {
    const ctx = createCtxMock({ nonInteractive: false });
-    const appLookupParams = ManageIosBeta.getAppLookupParamsFromContext(ctx);
+    const appLookupParams = getAppLookupParamsFromContext(ctx);
    const removeDistCertAction = new RemoveDistributionCertificate(
      appLookupParams.account,
      testDistCertFragmentNoDependencies
@@ -29,7 +29,7 @@ describe('RemoveDistributionCertificate', () => {
  });
  it('deletes the distribution certificate on Expo servers when there are no App Dependencies in Non-Interactive Mode', async () => {
    const ctx = createCtxMock({ nonInteractive: true });
-    const appLookupParams = ManageIosBeta.getAppLookupParamsFromContext(ctx);
+    const appLookupParams = getAppLookupParamsFromContext(ctx);
    const removeDistCertAction = new RemoveDistributionCertificate(
      appLookupParams.account,
      testDistCertFragmentNoDependencies
@@ -45,7 +45,7 @@ describe('RemoveDistributionCertificate', () => {
  });
  it('deletes the distribution certificate and its provisioning profile on Expo and Apple servers when there are App Dependencies in Interactive Mode', async () => {
    const ctx = createCtxMock({ nonInteractive: false });
-    const appLookupParams = ManageIosBeta.getAppLookupParamsFromContext(ctx);
+    const appLookupParams = getAppLookupParamsFromContext(ctx);
    const removeDistCertAction = new RemoveDistributionCertificate(
      appLookupParams.account,
      testDistCertFragmentOneDependency
@@ -61,7 +61,7 @@ describe('RemoveDistributionCertificate', () => {
  });
  it('errors when the distribution certificate has App Dependencies in Non-Interactive Mode', async () => {
    const ctx = createCtxMock({ nonInteractive: true });
-    const appLookupParams = ManageIosBeta.getAppLookupParamsFromContext(ctx);
+    const appLookupParams = getAppLookupParamsFromContext(ctx);
    const removeDistCertAction = new RemoveDistributionCertificate(
      appLookupParams.account,
      testDistCertFragmentOneDependency
Author	SHA1	Message	Date
Dominik Sokal	05b8eef622	v0.11.0	2021-04-20 15:08:57 +02:00
Dominik Sokal	50e56b5bc4	fix building APKs for Android managed projects (#349 ) * fix building APKs for Android managed projects * update CHANGELOG	2021-04-20 14:39:58 +02:00
Dominik Sokal	30ab4e62ec	simplify credentials providers - remove auto option (#345 ) * simplify credentials providers - remove auto option * update changelog * address PR feedback	2021-04-20 10:39:37 +02:00
Dominik Sokal	a1d901294b	allow for registering devices when building app for internal distribution (#340 ) * allow for registering devices when building app for internal distribution * update CHANGELOG	2021-04-19 12:39:20 +02:00
Dominik Sokal	eed818cfe5	refactor setting up adhoc provisioning profile (#338 ) * refactor appstore provisioning profile validation * refactor SetupAdhocProvisioningProfile * update CHANGELOG * address PR feedback	2021-04-19 12:29:37 +02:00
Dominik Sokal	db0b6bfcf5	remove redundant finally block	2021-04-16 15:54:44 +02:00
Dominik Sokal	da81c1c6df	remove incorrect usage example from secret:list command	2021-04-16 14:16:41 +02:00
Dominik Sokal	42d3296f07	update CHANGELOG	2021-04-16 14:13:09 +02:00
Dominik Sokal	f9b4b1a6e8	v0.10.0	2021-04-16 13:56:25 +02:00
Will Schurman	d03603a75f	Use special Expo SDK runtime version for managed projects (#336 )	2021-04-15 11:15:02 -07:00
Juwan Wheatley	ffa9e5ef66	[eas-cli] make secrets commands follow styleguide (#315 ) * [eas-cli] make CLI more styleguide-compliant * add --json flag * update changelog * json flag is a new feature, not a breaking change * remove secrets JSON flag since we still show non-result output (and same for other commands) * remove extra import	2021-04-15 13:05:28 -04:00
Dominik Sokal	e7f3cf9c74	Pass --preserveWatchOutput to tsc --watch This makes the 'yarn start' output preserve the output for previous tsc runs.	2021-04-15 16:42:04 +02:00
Dominik Sokal	e82a4a0a57	replace all iOS -> Ios (#337 )	2021-04-15 12:23:14 +02:00
Bartłomiej Klocek	175f07fac9	[eas cli][submit] Use GraphQL instead of REST endpoints (#333 ) * Autogenerated gql code * Add Submission Query * Add Submission Mutation * Use GQL generated types * Remove Submission types * Replace SubmissionPlatform with AppPlatform * Update Fix tests	2021-04-15 11:43:02 +02:00
Dominik Sokal	2869744a5d	add support for adhoc and universal distribution within enterprise teams (#335 ) * [eas-json] add enterpriseProvisioning prop * implement generating enterprise universal credentials * fix tests	2021-04-15 10:42:59 +02:00
Dominik Sokal	99f898a483	refactor IosCredentialsProvider to use graphql (#329 ) * refactor IosCredentialsProvider to use graphql * add tests for IosCredentialsProvider * address PR feedback * fix tests	2021-04-15 10:23:42 +02:00
Dominik Sokal	1448db96e6	don't update capabilities if there's nothing to change (#334 ) * don't update capabilities if there's nothing to change * add tests * update CHANGELOG	2021-04-15 10:19:30 +02:00
Quinlan Jung	e02036a46a	[eas-cli] ilovecats deletion	2021-04-14 14:31:04 -07:00
Quinlan JungandDominik Sokal	09f33263cb	[eas-cli] use new graphql api in SetupBuildCredentialsFromCredentials… (#328 ) * [eas-cli] use new graphql api in SetupBuildCredentialsFromCredentialsJson * pr feedback * tests * Update packages/eas-cli/src/credentials/ios/actions/new/BuildCredentialsUtils.ts Co-authored-by: Dominik Sokal <[email protected]> * pr feedback Co-authored-by: Dominik Sokal <[email protected]>	2021-04-14 14:28:06 -07:00
jkh	412b1ec74c	[eas-cli] add update:delete command (#332 )	2021-04-14 12:04:56 -07:00
jkh	9a1538fb4d	add eas update:view [ID] (#327 )	2021-04-14 11:04:58 -07:00
jkh	0ad9b31ee3	[eas-cli] update channel:list to handle rollouts (#331 )	2021-04-14 11:04:49 -07:00
Wojciech Kozyra	4cbb7bb2f2	[eas-cli] Support for local builds (#305 ) * [eas-cli] Support for local builds * add CHANGELOG + mark as experimental * review feedback	2021-04-14 09:08:06 +02:00
jkh	ae109cd8c6	[eas-cli] handle branch with no updates gracefully (#330 )	2021-04-13 07:11:54 -07:00
Dominik Sokal	fbaba774a6	enable type checking for tests and mocks (#325 ) * use separate tsconfig files for development and release * fix type errors in tests * add typecheck script * address PR feedback	2021-04-13 11:49:07 +02:00
jkh	38bc8062a4	[eas-cli] make branch name a positional instead of a named arg (#326 )	2021-04-12 10:50:41 -07:00
Dominik Sokal	d41d184b55	add start script (#323 )	2021-04-12 16:36:56 +02:00
jkh	d6d32a7a7d	[eas-cli] clean up formatting of list/view commands (#322 )	2021-04-12 07:19:37 -07:00
Dominik Sokal	15a9532fa7	refactor credentials actions (#321 ) * make SetupAdhocProvisioningProfile.runAsync return result * make SetupDistributionCertificate.runAsync return result * print ios credentials using new display function * generate graphql code * update CHANGELOG * address PR feedback * updates changes after running generate-graphql-code * address more PR feedback * fix lint warning	2021-04-12 11:38:06 +02:00
Dominik Sokal	3b9fb724fe	update CONTRIBUTING.md	2021-04-12 10:41:36 +02:00
Dominik Sokal	33767b5635	update CHANGELOG	2021-04-12 10:18:27 +02:00
Test User	175fc2b30e	v0.9.1	2021-04-09 14:43:36 -07:00
Quinlan Jung	aec9347d69	[eas-cli] fix validation check of provisioning profile (#318 ) * [eas-cli] fix validation check of provisioning profile * changelog and stuff * quin not dominik * move the changelog thing	2021-04-09 13:05:25 -07:00
Quinlan Jung	91500d07c0	[eas-cli] replace SetupProvisioningProfile (#317 ) * [eas-cli] replace SetupProvisioningProfile * changelog * more changelog	2021-04-09 13:02:12 -07:00
Test User	62ca14b504	Commit README updates	2021-04-09 10:13:28 -07:00
Test User	9158a95d57	v0.9.0	2021-04-09 09:59:29 -07:00
Test User	d0f3e387e7	Bump @expo/config-plugins to fix eas build:configure on Windows	2021-04-09 09:58:43 -07:00
jkh	158856f8ec	[eas-cli] upgrade @urql/core and add retry (#320 )	2021-04-09 07:19:04 -07:00
Dominik Sokal	1e59957753	Update CHANGELOG.md	2021-04-09 11:50:36 +02:00
Dominik Sokal	f97d46040c	add commands for managing webhooks (#314 ) * add webhook:create command * add webhook:list command * add webhook:view command * add webhook:update command * add webhook:delete command * generate graphql code * update CHANGELOG * address PR feedback	2021-04-09 11:50:07 +02:00
Dominik Sokal	d7485cb5d2	fix first ios build for a project without ios.bundleIdentifier in app.json (#319 ) * fix first ios build for a project without ios.bundleIdentifier in app.json * update CHANGELOG * address PR feedback * address more PR feedback	2021-04-09 11:31:17 +02:00
Bartłomiej Klocek James Ide Brent Vatne	071fdb7f4a	[eas submit] Added new common error messages (#311 ) * [eas submit] Added new common error messages * Update CHANGELOG * Apply suggestions from code review Co-authored-by: James Ide <[email protected]> Co-authored-by: Brent Vatne <[email protected]> Co-authored-by: James Ide <[email protected]> Co-authored-by: Brent Vatne <[email protected]>	2021-04-09 08:17:33 +02:00
jkh	6dd96ffb20	[eas-cli] add more info to transient errors (#316 )	2021-04-08 16:26:34 -04:00
Quinlan Jung	f56fb0f7de	[eas-cli] setupProvisioningProfile using graphql (#301 ) * [eas-cli] setupProvisioningProfile using graphql refactor fix lint setup provisioning profile * refactor stuff * add comments for ppl * simplify logic * tests * pr feedback	2021-04-08 11:19:14 -07:00
Wojciech Kozyra	7d28f6add9	add LICENSE (#313 )	2021-04-08 12:35:50 +02:00
Juwan Wheatley	eebef3e461	[eas-cli] use autocomplete list for secrets:delete (#309 ) * [eas-cli] use autocomplete list for secrets:delete * update changelog * check if secret is account-wide and tell user that it could affect multiple apps	2021-04-07 13:08:00 -04:00
Dominik Sokal	8336f630ea	update CHANGELOG	2021-04-06 12:55:17 +02:00
Dominik Sokal	7d6bdbb6ed	v0.8.1	2021-04-06 12:30:31 +02:00
Dominik Sokal	403b5c237f	don't use graphql cache for polling builds (#310 ) * don't use graphql cache for polling builds * update CHANGELOG	2021-04-06 12:29:41 +02:00
Dominik Sokal	2367ed7911	update CHANGELOG.md	2021-04-06 11:21:13 +02:00
Dominik Sokal	b650f76979	v0.8.0	2021-04-06 11:12:43 +02:00
Dominik Sokal	96e59c198d	update CHANGELOG.md	2021-04-06 11:11:47 +02:00
Dominik Sokal	bf1704d268	use graphql for generating upload sessions (#307 ) * use graphql for generating upload sessions * address PR feedback * fix tests	2021-04-06 11:06:47 +02:00
Dominik Sokal	279dfd00c8	eas build - use GraphQL instead of REST endpoints for build queries (#306 ) * use graphql for printing pending builds * use graphql for polling build status * remove some unused code	2021-04-02 12:10:59 +02:00
Dominik Sokal	4d2577865a	eas build - use GraphQL instead of REST endpoints (#303 ) * regenerate graphql schema * use graphql mutations for creating builds	2021-04-02 12:06:10 +02:00
Quinlan Jung	9d88fba40e	[eas-cli] configure provisioning profile using new api (#299 ) * [eas-cli] configure provisioning profile using new api change positional args * configure prov prof: pr feedback * fix lint	2021-04-01 23:16:34 -07:00
Juwan Wheatley	9d2353b4f7	[eas-cli] use flags for secrets:create and rename target to scope (#300 ) * use flags instead of args for secrets:create * rename target to scope * show secret ID before timestamp * add changelog entries and note about name validation source of truth	2021-04-01 16:13:44 -04:00
Dominik Sokal	44b338d50a	unhide secrets:create and secrets:delete (#302 )	2021-04-01 19:06:23 +02:00
Bartłomiej Klocek	62114cab3b	[Submit] Skip tar extraction logic in CLI (#297 ) * [submit] Skip tar extraction logic for URL * Remove tar extraction utils * Update CHANGELOG * Simplified path handling code * New unit tests * Add URL validation	2021-04-01 18:11:23 +02:00
Dominik Sokal	d426fb0355	fix string interpolation	2021-04-01 11:34:32 +02:00
Quinlan Jung	2a8d6683ff	[eas-cli] fix typo in tests	2021-03-31 17:57:46 -07:00
Juwan WheatleyandDominik Sokal	7b18165390	[eas-cli] fix secret name validation when prompted (#298 ) * [eas-cli] fix secret name validation when prompted * add changelog entry * Update CHANGELOG.md Co-authored-by: Dominik Sokal <[email protected]> Co-authored-by: Dominik Sokal <[email protected]>	2021-03-31 19:43:46 -04:00
Dominik Sokal	814a44ac27	change cache object schema + rename secretEnvs -> environmentSecrets (#295 ) * change cache object schema * update CHANGELOG.md * rename secretEnvs -> environmentSecrets * update @expo/eas-build-job to 0.2.22	2021-03-31 10:20:04 +02:00
jkh	f5483c8996	[eas-cli] add command `eas channel:rollout` (#290 )	2021-03-30 13:43:37 -07:00
Juwan Wheatley	acdbed4762	[eas-cli] fix "irreversible" typo (#282 )	2021-03-30 16:24:19 +02:00
Dominik Sokal	f09e4b54cf	add distribution/release channel to graphql formatter	2021-03-30 16:23:41 +02:00
Vincent Thibault	859fdf5e46	Add distribution/channel informations in build:view/list (#284 ) * Add new informations in build:view/list * Update CHANGELOG.md * Add nullish coalescing operator	2021-03-30 16:17:16 +02:00
Wojciech Kozyra	6aa72d5b7d	[eas-cli] add analytics support (#162 )	2021-03-29 11:58:05 +02:00
Quinlan Jung	886900df29	[eas-cli] make dist cert setup generic with graphql api (#294 ) * [eas-cli] make dist cert setup generic * fix tsc	2021-03-26 13:17:07 -07:00
Quinlan Jung	a450fed1f8	[eas-cli] create provisioning profile using graphql api (#293 )	2021-03-26 13:16:37 -07:00
Dominik Sokal	4c78100adb	use graphql to create unpublished app (#288 )	2021-03-26 09:01:42 +01:00
Dominik Sokal	0317e6fe71	refactor build:list and build:view to use graphql (#286 )	2021-03-26 08:56:04 +01:00
jkh	6825877344	[eas-cli] add support for rollouts to channel:view command (#289 )	2021-03-24 07:04:07 -07:00
Dominik Sokal	a47ea88d28	Update CHANGELOG.md	2021-03-23 10:37:57 +01:00
Wojciech Kozyra	a9e7f304ec	Update CHANGELOG.md	2021-03-22 13:36:10 +01:00