v0.4.2

* [eas-cli] use newer @expo/config-plugins

* [eas-cli][eas-json] add buildConfiguration to eas.json

* address PR feedback

* upgrade @expo/eas-build-job and @expo/config-plugins

* [eas-json] reuse type from @expo/eas-build-job

* [eas-json] fix exports

.eslintignore

@@ -1,2 +1,7 @@
-build
+**/build/**
+!packages/eas-cli/src/commands/build/**
+!packages/eas-cli/src/build/**
+
+packages/eas-cli/src/graphql/generated.ts
+
 node_modules

.github/PULL_REQUEST_TEMPLATE

@@ -0,0 +1,11 @@
+# Why
+
+Please describe the motivation for this PR, and link to relevant GitHub issues, forums posts, or feature requests.
+
+# How
+
+How did you build this feature or fix this bug and why?
+
+# Test Plan
+
+Please describe how you tested this change and how a reviewer could reproduce your test, especially if this PR does not include automated tests! If possible, please also provide terminal output and/or screenshots demonstrating your test/reproduction.

.github/workflows/install.yml

@@ -0,0 +1,18 @@
+name: Installer tests
+on:
+  push:
+    branches: [main]
+  pull_request:
+    types: [opened, synchronize]
+
+jobs:
+  test:
+    name: Run the installer
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    steps:
+      - uses: actions/checkout@v2
+      - run: bash bin/install.sh
+      - run: eas --version

.github/workflows/release.yml

@@ -0,0 +1,115 @@
+on:
+  push:
+    tags:
+      - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
+
+name: Release workflow
+
+jobs:
+  release:
+    name: Create a release
+    runs-on: ubuntu-latest
+    outputs:
+      upload_url: ${{ steps.create_release.outputs.upload_url }}
+    steps:
+      - id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
+        with:
+          tag_name: ${{ github.ref }}
+          draft: true
+  build-linux:
+    name: Build for Linux
+    runs-on: ubuntu-latest
+    needs: release
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: '14'
+      - run: yarn install --frozen-lockfile --check-files
+      - run: yarn build
+      - name: Build tarballs
+        working-directory: ${{ github.workspace }}/packages/eas-cli
+        run: yarn oclif-dev pack --targets linux-x64,linux-arm
+      - name: Upload linux-x64 tarball
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.release.outputs.upload_url }}
+          asset_path: packages/eas-cli/dist/eas-linux-x64.tar.gz
+          asset_name: eas-linux-x64.tar.gz
+          asset_content_type: application/gzip
+      - name: Upload linux-arm tarball
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.release.outputs.upload_url }}
+          asset_path: packages/eas-cli/dist/eas-linux-arm.tar.gz
+          asset_name: eas-linux-arm.tar.gz
+          asset_content_type: application/gzip
+  build-mac:
+    name: Build for macOS
+    # Use macOS to get the correct platform specific dependencies
+    runs-on: macos-latest
+    needs: release
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: '14'
+      - run: yarn install --frozen-lockfile --check-files
+      - run: yarn build
+      - name: Build tarballs
+        working-directory: ${{ github.workspace }}/packages/eas-cli
+        run: yarn oclif-dev pack --targets darwin-x64
+      - name: Upload darwin-x64 tarball
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.release.outputs.upload_url }}
+          asset_path: packages/eas-cli/dist/eas-darwin-x64.tar.gz
+          asset_name: eas-darwin-x64.tar.gz
+          asset_content_type: application/gzip
+  build-windows:
+    name: Build for Windows
+    runs-on: ubuntu-latest
+    needs: release
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: '14'
+      - run: yarn install --frozen-lockfile --check-files
+      - run: sudo apt-get install nsis
+      - run: yarn build
+      - run: yarn oclif-dev pack:win
+        working-directory: ${{ github.workspace }}/packages/eas-cli
+      - id: x64
+        run: echo "::set-output name=filename::$(ls eas-*-x64.exe)"
+        working-directory: ${{ github.workspace }}/packages/eas-cli/dist/win
+      - id: x86
+        run: echo "::set-output name=filename::$(ls eas-*-x86.exe)"
+        working-directory: ${{ github.workspace }}/packages/eas-cli/dist/win
+      - name: Upload x64 installer
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.release.outputs.upload_url }}
+          asset_path: packages/eas-cli/dist/win/${{ steps.x64.outputs.filename }}
+          asset_name: ${{ steps.x64.outputs.filename }}
+          asset_content_type: application/gzip
+      - name: Upload x86 installer
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.release.outputs.upload_url }}
+          asset_path: packages/eas-cli/dist/win/${{ steps.x86.outputs.filename }}
+          asset_name: ${{ steps.x86.outputs.filename }}
+          asset_content_type: application/gzip

.github/workflows/size.yml

@@ -0,0 +1,18 @@
+name: Size
+on:
+  pull_request:
+    types: [synchronize, opened]
+jobs:
+  compare:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v1
+        with:
+          node-version: '14'
+      - uses: preactjs/compressed-size-action@v2
+        with:
+          build-script: 'build:tarballs:linux'
+          repo-token: '${{ secrets.GITHUB_TOKEN }}'
+          pattern: './packages/eas-cli/dist/*.tar.gz'
+          compression: 'none'

.github/workflows/test.yml

@@ -11,15 +11,25 @@ jobs:
     strategy:
       matrix:
         node: ['12', '14']
+        include:
+          - node: '14'
+            coverage: true
     name: Test with Node ${{ matrix.node }}
     steps:
       - uses: actions/checkout@v2
-        with:
-          fetch-depth: 1
       - name: Setup node
         uses: actions/setup-node@v1
         with:
           node-version: ${{ matrix.node }}
       - run: yarn install --frozen-lockfile --check-files
+      - run: yarn lerna run build
       - run: yarn test
-      - run: yarn lint
+        if: ${{ !matrix.coverage }}
+      - run: yarn test --coverage
+        if: ${{ matrix.coverage }}
+      - run: yarn lint --max-warnings=0
+      - run: shellcheck bin/*.sh
+      - uses: codecov/codecov-action@v1
+        if: ${{ matrix.coverage }}
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}

.gitignore

@@ -1,8 +1,13 @@
 *-debug.log
 *-error.log
+
+**/build/**
+!packages/eas-cli/src/commands/build/**
+!packages/eas-cli/src/build/**
+
 dist
-build
 /package-lock.json
 tmp
 node_modules
+coverage
 .history

CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+This is the log of notable changes to EAS CLI and related packages.
+
+## main
+
+### 🛠 Breaking changes
+
+### 🎉 New features
+
+### 🐛 Bug fixes
+
+- Fix detecting application target (iOS builds). ([#238](https://github.com/expo/eas-cli/pull/2238) by [@dsokal](https://github.com/dsokal))
+
+## [0.4.1](https://github.com/expo/eas-cli/releases/tag/v0.4.1) - 2021-02-16
+
+### 🐛 Bug fixes
+
+- Fix `"buildType" is not allowed` error. ([#595bf](https://github.com/expo/eas-cli/commit/595bfecf1cbff0f76e7fd2049fe16f6f38bbe150) by [@wkozyra95](https://github.com/wkozyra95))
+
+## [0.4.0](https://github.com/expo/eas-cli/releases/tag/v0.4.0) - 2021-02-16
+
+### 🎉 New features
+
+- Add build:cancel command. ([#219](https://github.com/expo/eas-cli/pull/219) by [@wkozyra95](https://github.com/wkozyra95))
+- Implement version auto increment for iOS builds. ([#231](https://github.com/expo/eas-cli/pull/231) by [@dsokal](https://github.com/dsokal))
+- Add support for builder environment customizations. ([#230](https://github.com/expo/eas-cli/pull/230) by [@wkozyra95](https://github.com/wkozyra95))
+- Add `schemeBuildConfiguration` option for generic iOS builds. ([#234](https://github.com/expo/eas-cli/pull/234) by [@dsokal](https://github.com/dsokal))
+
+### 🐛 Bug fixes
+
+- Fix `--no-wait` flag for `eas build`. ([#226](https://github.com/expo/eas-cli/pull/226) by [paul-ridgway](https://github.com/paul-ridgway))
+- Fix running builds from project subdirectories. ([#229](https://github.com/expo/eas-cli/pull/229) by [@wkozyra95](https://github.com/wkozyra95))

CONTRIBUTING.md

@@ -0,0 +1,9 @@
+## 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 lerna publish from-git` in the repository root folder. This will publish the packages to npm.

bin/install.sh

@@ -0,0 +1,131 @@
+#!/bin/bash
+
+# This script downloads the latest release version of EAS CLI from GitHub and
+# installs it in /usr/local/bin
+
+{
+  # All code is inside a block to ensure the script executes only when
+  # downloaded completely.
+
+  set -euo pipefail
+
+  prefix="${EAS_PREFIX:-/usr/local}"
+  temp_dir="$(mktemp -d)"
+  
+  if  [ -t 1 ] && [ -z "${NO_COLOR:-}" ]
+  then
+    # Use colors when stdout is a terminal and NO_COLOR isn't set.
+    text_bold=$'\033[1m'
+    text_normal=$'\033[22m'
+    text_red=$'\033[31m'
+    text_default_color=$'\033[39m'
+  else
+    # Disable colors
+    text_bold=""
+    text_normal=""
+    text_red=""
+    text_default_color=""
+  fi
+
+  abort() {
+    echo -e "$text_bold$text_red$1$text_normal$text_default_color"
+    exit 1
+  }
+
+  install() {
+    needs_sudo=""
+    # Make sure path exists and can be written to by the current user.
+    if ! mkdir -p "$prefix/lib" || [[ ! -w "$prefix/lib" ]]
+    then
+      needs_sudo=true
+    fi
+    if ! mkdir -p "$prefix/bin" || [[ ! -w "$prefix/bin" ]]
+    then
+      needs_sudo=true
+    fi
+    if ! rm -rf "$prefix/lib/eas"
+    then
+      needs_sudo=true
+    fi
+    # Run commands with sudo if necessary.
+    if [ -n "$needs_sudo" ]
+    then
+      if [ "$EUID" -ne 0 ]
+      then
+        echo "Installing requires superuser access."
+        echo "The sudo command will prompt for your password."
+      fi
+      sudo rm -rf "$prefix/lib/eas"
+      sudo mv "$temp_dir/eas" "$prefix/lib/eas"
+      sudo ln -fs "$prefix/lib/eas/bin/eas" "$prefix/bin/eas"
+    else
+      mv "$temp_dir/eas" "$prefix/lib/eas"
+      ln -fs "$prefix/lib/eas/bin/eas" "$prefix/bin/eas"
+    fi
+  }
+
+  if [[ ! ":$PATH:" == *":$prefix/bin:"* ]]; then
+    abort "Your path is missing $prefix/bin, you need to add this to \$PATH use this installer."
+  fi
+  
+  hardware="$(uname -m)"
+  case "$hardware" in
+    x86_64)
+      arch="x64"
+      ;;
+    arm*)
+      arch="arm"
+      ;;
+    *)
+      abort "Unsupported CPU architecture $hardware."
+      ;;
+  esac
+
+  case "$(uname -s)" in
+    Darwin*)
+      platform="darwin"
+      if [[ "$arch" != "x64" ]]; then
+        abort "Unsupported CPU architecture $hardware on macOS."
+      fi
+      ;;
+    Linux*)
+      platform="linux"
+      ;;
+    *)
+      abort "This installer is supported only on macOS, Linux, and Windows Subsystem for Linux."
+      ;;
+  esac
+
+  url="https://github.com/expo/eas-cli/releases/latest/download/eas-$platform-$arch.tar.gz"
+  echo "Installing EAS CLI from $url"
+
+  mkdir -p "$temp_dir"
+  cd "$temp_dir"
+  
+  echo
+  echo "Downloading..."
+  if [ "$(command -v curl)" ]
+  then
+    curl --location --progress-bar "$url" | tar xz
+  else
+    wget -O- "$url" | tar xz
+  fi
+
+  # Move the installation over and link the executable (may require sudo)
+  install
+
+  # Test the bundled node binary and if it doesn't work remove it (fall back to
+  # node installed in path).
+  "$prefix/lib/eas/bin/node" -v > /dev/null || {
+    rm "$prefix/lib/eas/bin/node"
+  }
+
+  # Test the CLI
+  executable=$(command -v eas) || abort "Could not run eas after installation."
+  echo
+  echo -e "EAS CLI is installed to ${executable}"
+  eas --version
+
+  echo
+  echo -e "Type ${text_bold}eas --help${text_normal} to get started."
+}

codecov.yml

@@ -0,0 +1,18 @@
+comment: false
+coverage:
+  round: up
+  precision: 2
+  range: 30..100
+  status:
+    patch: false
+    project:
+      default:
+        informational: true
+      eas-cli:
+        informational: true
+        paths:
+          - packages/eas-cli
+      eas-json:
+        informational: true
+        paths:
+          - packages/eas-json

jest.config.js

@@ -1,7 +1,7 @@
 module.exports = {
   projects: [
     require('./packages/eas-cli/jest.config.js'),
-    require('./packages/config/jest.config.js'),
+    require('./packages/eas-json/jest.config.js'),
   ],
   testPathIgnorePatterns: ['.*'],
 };

jest/babel.config.js

@@ -1,11 +1,6 @@
 module.exports = function (api) {
   api.cache(true);
   return {
-    // Only use this when running tests
-    env: {
-      test: {
-        presets: ['@expo/babel-preset-cli'],
-      },
-    },
+    presets: ['@expo/babel-preset-cli'],
   };
 };

jest/jest.config.js

@@ -5,4 +5,5 @@ module.exports = {
     '^.+\\.[jt]sx?$': ['babel-jest', { configFile: require.resolve('./babel.config.js') }],
   },
   watchPlugins: ['jest-watch-typeahead/filename', 'jest-watch-typeahead/testname'],
+  collectCoverageFrom: ['<rootDir>/src/**/*.{ts,tsx,js,jsx}'],
 };

lerna.json

@@ -1,5 +1,5 @@
 {
   "npmClient": "yarn",
   "useWorkspaces": true,
-  "version": "0.0.0"
+  "version": "0.4.2"
 }

package.json

@@ -4,14 +4,19 @@
     "packages/*"
   ],
   "scripts": {
+    "build": "lerna run build",
+    "build:tarballs:linux": "yarn build && yarn workspace eas-cli oclif-dev pack --targets linux-x64",
     "eas": "packages/eas-cli/bin/run",
     "lint": "eslint . --ext .ts",
+    "release": "lerna version",
     "test": "jest"
   },
   "devDependencies": {
+    "@expo/oclif-dev-cli": "1.24.0-expo",
     "@types/jest": "^26.0.13",
     "eslint": "^6.6.0",
     "eslint-config-universe": "^4.0.0",
+    "eslint-plugin-graphql": "^4.0.0",
     "jest": "^26.4.2",
     "jest-watch-typeahead": "^0.6.1",
     "lerna": "^3.22.1",

packages/config/src/EasJsonReader.ts

@@ -1,94 +0,0 @@
-import { Platform } from '@expo/build-tools';
-import fs from 'fs-extra';
-import path from 'path';
-
-import {
-  AndroidBuildProfile,
-  BuildProfile,
-  EasConfig,
-  Workflow,
-  iOSBuildProfile,
-} from './Config.types';
-import { EasJsonSchema, schemaBuildProfileMap } from './EasJsonSchema';
-
-interface EasJson {
-  builds: {
-    android?: { [key: string]: AndroidBuildProfile };
-    ios?: { [key: string]: iOSBuildProfile };
-  };
-}
-
-interface BuildProfilePreValidation {
-  workflow: Workflow;
-}
-
-export class EasJsonReader {
-  constructor(private projectDir: string, private platform: 'android' | 'ios' | 'all') {}
-
-  public async readAsync(buildProfileName: string): Promise<EasConfig> {
-    const easJson = await this.readFile();
-
-    let androidConfig;
-    if (['android', 'all'].includes(this.platform)) {
-      androidConfig = this.validateBuildProfile<AndroidBuildProfile>(
-        Platform.Android,
-        buildProfileName,
-        easJson.builds?.android?.[buildProfileName]
-      );
-    }
-    let iosConfig;
-    if (['ios', 'all'].includes(this.platform)) {
-      iosConfig = this.validateBuildProfile<iOSBuildProfile>(
-        Platform.iOS,
-        buildProfileName,
-        easJson.builds?.ios?.[buildProfileName]
-      );
-    }
-    return {
-      builds: {
-        ...(androidConfig ? { android: androidConfig } : {}),
-        ...(iosConfig ? { ios: iosConfig } : {}),
-      },
-    };
-  }
-
-  private validateBuildProfile<T extends BuildProfile>(
-    platform: 'android' | 'ios' | 'all',
-    buildProfileName: string,
-    buildProfile?: BuildProfilePreValidation
-  ): T {
-    if (!buildProfile) {
-      throw new Error(`There is no profile named ${buildProfileName} for platform ${platform}`);
-    }
-    const schema = schemaBuildProfileMap[platform][buildProfile?.workflow];
-    if (!schema) {
-      throw new Error('invalid workflow'); // this should be validated earlier
-    }
-    const { value, error } = schema.validate(buildProfile, {
-      stripUnknown: true,
-      convert: true,
-      abortEarly: false,
-    });
-
-    if (error) {
-      throw new Error(
-        `Object "${platform}.${buildProfileName}" in eas.json is not valid [${error.toString()}]`
-      );
-    }
-    return value;
-  }
-
-  private async readFile(): Promise<EasJson> {
-    const rawFile = await fs.readFile(path.join(this.projectDir, 'eas.json'), 'utf-8');
-    const json = JSON.parse(rawFile);
-
-    const { value, error } = EasJsonSchema.validate(json, {
-      abortEarly: false,
-    });
-
-    if (error) {
-      throw new Error(`eas.json is not valid [${error.toString()}]`);
-    }
-    return value;
-  }
-}

packages/config/src/EasJsonSchema.ts

@@ -1,58 +0,0 @@
-import Joi from '@hapi/joi';
-
-const AndroidGenericSchema = Joi.object({
-  workflow: Joi.string().valid('generic').required(),
-  credentialsSource: Joi.string().valid('local', 'remote', 'auto').default('auto'),
-  gradleCommand: Joi.string(),
-  artifactPath: Joi.string(),
-  withoutCredentials: Joi.boolean(),
-});
-
-const AndroidManagedSchema = Joi.object({
-  workflow: Joi.string().valid('managed').required(),
-  credentialsSource: Joi.string().valid('local', 'remote', 'auto').default('auto'),
-  buildType: Joi.string().valid('apk', 'app-bundle').default('app-bundle'),
-});
-
-const iOSGenericSchema = Joi.object({
-  workflow: Joi.string().valid('generic').required(),
-  credentialsSource: Joi.string().valid('local', 'remote', 'auto').default('auto'),
-  scheme: Joi.string(),
-  artifactPath: Joi.string(),
-});
-
-const iOSManagedSchema = Joi.object({
-  workflow: Joi.string().valid('managed').required(),
-  credentialsSource: Joi.string().valid('local', 'remote', 'auto').default('auto'),
-  buildType: Joi.string().valid('archive', 'simulator'),
-});
-
-const schemaBuildProfileMap: Record<string, Record<string, Joi.Schema>> = {
-  android: {
-    generic: AndroidGenericSchema,
-    managed: AndroidManagedSchema,
-  },
-  ios: {
-    managed: iOSManagedSchema,
-    generic: iOSGenericSchema,
-  },
-};
-
-const EasJsonSchema = Joi.object({
-  builds: Joi.object({
-    android: Joi.object().pattern(
-      Joi.string(),
-      Joi.object({
-        workflow: Joi.string().valid('generic', 'managed').required(),
-      }).unknown(true) // profile is validated further only if build is for that platform
-    ),
-    ios: Joi.object().pattern(
-      Joi.string(),
-      Joi.object({
-        workflow: Joi.string().valid('generic', 'managed').required(),
-      }).unknown(true) // profile is validated further only if build is for that platform
-    ),
-  }),
-});
-
-export { EasJsonSchema, schemaBuildProfileMap };

packages/eas-cli/.eslintrc.js

@@ -0,0 +1,37 @@
+module.exports = {
+  rules: {
+    'import/no-cycle': 'error',
+    'import/no-extraneous-dependencies': [
+      'error',
+      { devDependencies: ['**/__tests__/**/*', '**/__mocks__/**/*'] },
+    ],
+    'graphql/template-strings': [
+      'error',
+      {
+        env: 'apollo',
+        schemaJson: require('./graphql.schema.json'),
+      },
+    ],
+    'graphql/named-operations': [
+      'error',
+      {
+        schemaJson: require('./graphql.schema.json'),
+      },
+    ],
+    'graphql/required-fields': [
+      'error',
+      {
+        env: 'apollo',
+        schemaJson: require('./graphql.schema.json'),
+        requiredFields: ['id'],
+      },
+    ],
+    'graphql/capitalized-type-name': [
+      'error',
+      {
+        schemaJson: require('./graphql.schema.json'),
+      },
+    ],
+  },
+  plugins: ['graphql'],
+};

packages/eas-cli/README.md

@@ -8,68 +8,205 @@ EAS command line tool
 [![License](https://img.shields.io/npm/l/eas-cli.svg)](https://github.com/expo/eas-cli/blob/main/package.json)
 
 <!-- toc -->
-
-- [eas-cli](#eas-cli)
-- [Usage](#usage)
-- [Commands](#commands)
+* [eas-cli](#eas-cli)
+* [Usage](#usage)
+* [Commands](#commands)
 <!-- tocstop -->
 
 # Usage
 
 <!-- usage -->
-
 ```sh-session
 $ npm install -g eas-cli
 $ eas COMMAND
 running command...
 $ eas (-v|--version|version)
-eas-cli/0.0.0 darwin-x64 node-v12.13.0
+eas-cli/0.4.2 darwin-x64 node-v14.15.4
 $ eas --help [COMMAND]
 USAGE
   $ eas COMMAND
 ...
 ```
-
 <!-- usagestop -->
 
 # Commands
 
 <!-- commands -->
+* [`eas account:login`](#eas-accountlogin)
+* [`eas account:logout`](#eas-accountlogout)
+* [`eas account:view`](#eas-accountview)
+* [`eas build`](#eas-build)
+* [`eas build:cancel [BUILD_ID]`](#eas-buildcancel-build_id)
+* [`eas build:configure`](#eas-buildconfigure)
+* [`eas build:list`](#eas-buildlist)
+* [`eas build:view [BUILD_ID]`](#eas-buildview-build_id)
+* [`eas credentials`](#eas-credentials)
+* [`eas device:create`](#eas-devicecreate)
+* [`eas device:list`](#eas-devicelist)
+* [`eas device:view [UDID]`](#eas-deviceview-udid)
+* [`eas help [COMMAND]`](#eas-help-command)
+* [`eas submit --platform=(android|ios)`](#eas-submit---platformandroidios)
 
-- [`eas build`](#eas-build)
-- [`eas build:status`](#eas-buildstatus)
-- [`eas help [COMMAND]`](#eas-help-command)
-- [`eas login`](#eas-login)
-- [`eas logout`](#eas-logout)
-- [`eas update`](#eas-update)
-- [`eas update:show`](#eas-updateshow)
-- [`eas whoami`](#eas-whoami)
+## `eas account:login`
+
+log in with your Expo account
+
+```
+USAGE
+  $ eas account:login
+
+ALIASES
+  $ eas login
+```
+
+_See code: [build/commands/account/login.ts](https://github.com/expo/eas-cli/blob/v0.4.2/build/commands/account/login.ts)_
+
+## `eas account:logout`
+
+log out
+
+```
+USAGE
+  $ eas account:logout
+
+ALIASES
+  $ eas logout
+```
+
+_See code: [build/commands/account/logout.ts](https://github.com/expo/eas-cli/blob/v0.4.2/build/commands/account/logout.ts)_
+
+## `eas account:view`
+
+show the username you are logged in as
+
+```
+USAGE
+  $ eas account:view
+
+ALIASES
+  $ eas whoami
+```
+
+_See code: [build/commands/account/view.ts](https://github.com/expo/eas-cli/blob/v0.4.2/build/commands/account/view.ts)_
 
 ## `eas build`
 
-build an app binary for your project
+Start a build
 
 ```
 USAGE
   $ eas build
+
+OPTIONS
+  -p, --platform=(android|ios|all)
+  --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
+  --skip-project-configuration      Skip project configuration
+  --[no-]wait                       Wait for build(s) to complete
 ```
 
-_See code: [src/commands/build/index.ts](https://github.com/expo/eas-cli/blob/v0.0.0/src/commands/build/index.ts)_
+_See code: [build/commands/build/index.ts](https://github.com/expo/eas-cli/blob/v0.4.2/build/commands/build/index.ts)_
 
-## `eas build:status`
+## `eas build:cancel [BUILD_ID]`
 
-get the status of the latest builds for your project
+Cancel a build.
 
 ```
 USAGE
-  $ eas build:status
-
-OPTIONS
-  --platform=(all|android|ios)
-  --status=(in-queue|in-progress|errored|finished)
+  $ eas build:cancel [BUILD_ID]
 ```
 
-_See code: [src/commands/build/status.ts](https://github.com/expo/eas-cli/blob/v0.0.0/src/commands/build/status.ts)_
+_See code: [build/commands/build/cancel.ts](https://github.com/expo/eas-cli/blob/v0.4.2/build/commands/build/cancel.ts)_
+
+## `eas build:configure`
+
+Configure the project to support EAS Build.
+
+```
+USAGE
+  $ eas build:configure
+
+OPTIONS
+  -p, --platform=(android|ios|all)  Platform to configure
+  --allow-experimental              Enable experimental configuration steps.
+```
+
+_See code: [build/commands/build/configure.ts](https://github.com/expo/eas-cli/blob/v0.4.2/build/commands/build/configure.ts)_
+
+## `eas build:list`
+
+list all builds for your project
+
+```
+USAGE
+  $ eas build:list
+
+OPTIONS
+  --limit=limit
+  --platform=(all|android|ios)
+  --status=(in-queue|in-progress|errored|finished|canceled)
+```
+
+_See code: [build/commands/build/list.ts](https://github.com/expo/eas-cli/blob/v0.4.2/build/commands/build/list.ts)_
+
+## `eas build:view [BUILD_ID]`
+
+view a build for your project
+
+```
+USAGE
+  $ eas build:view [BUILD_ID]
+```
+
+_See code: [build/commands/build/view.ts](https://github.com/expo/eas-cli/blob/v0.4.2/build/commands/build/view.ts)_
+
+## `eas credentials`
+
+Manage your credentials
+
+```
+USAGE
+  $ eas credentials
+```
+
+_See code: [build/commands/credentials.ts](https://github.com/expo/eas-cli/blob/v0.4.2/build/commands/credentials.ts)_
+
+## `eas device:create`
+
+register new Apple Devices to use for internal distribution
+
+```
+USAGE
+  $ eas device:create
+```
+
+_See code: [build/commands/device/create.ts](https://github.com/expo/eas-cli/blob/v0.4.2/build/commands/device/create.ts)_
+
+## `eas device:list`
+
+list all registered devices for your account
+
+```
+USAGE
+  $ eas device:list
+
+OPTIONS
+  --apple-team-id=apple-team-id
+```
+
+_See code: [build/commands/device/list.ts](https://github.com/expo/eas-cli/blob/v0.4.2/build/commands/device/list.ts)_
+
+## `eas device:view [UDID]`
+
+view a device for your project
+
+```
+USAGE
+  $ eas device:view [UDID]
+```
+
+_See code: [build/commands/device/view.ts](https://github.com/expo/eas-cli/blob/v0.4.2/build/commands/device/view.ts)_
 
 ## `eas help [COMMAND]`
 
@@ -88,62 +225,83 @@ OPTIONS
 
 _See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v3.2.0/src/commands/help.ts)_
 
-## `eas login`
+## `eas submit --platform=(android|ios)`
 
-log in with your EAS account
+Submits build artifact to app store
 
 ```
 USAGE
-  $ eas login
-```
+  $ eas submit --platform=(android|ios)
 
-_See code: [src/commands/login.ts](https://github.com/expo/eas-cli/blob/v0.0.0/src/commands/login.ts)_
+OPTIONS
+  -p, --platform=(android|ios)                                       For which platform you want to submit a build
 
-## `eas logout`
+  Android specific options=android-package                           Android package name (default: expo.android.package
+                                                                     from app config)
 
-log out
+  iOS specific options=app-name                                      The name of your app as it will appear on the App
+                                                                     Store (default: expo.name from app config)
 
-```
-USAGE
-  $ eas logout
-```
+  iOS specific options=apple-id                                      Your Apple ID username (you can also set
+                                                                     EXPO_APPLE_ID env variable)
 
-_See code: [src/commands/logout.ts](https://github.com/expo/eas-cli/blob/v0.0.0/src/commands/logout.ts)_
+  iOS specific options=apple-team-id                                 Your Apple Developer Team ID
 
-## `eas update`
+  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:
+                                                                     https://expo.fyi/asc-app-id
 
-create a revision for given channel
+  iOS specific options=bundle-identifier                             Your iOS Bundle Identifier (default:
+                                                                     expo.ios.bundleIdentifier from app config)
 
-```
-USAGE
-  $ eas update
+  iOS specific options=company-name                                  The name of your company, needed only for the first
+                                                                     upload of any app to App Store
+
+  --id=id                                                            ID of the build to submit
+
+  Android specific options=key                                       Path to the JSON key used to authenticate with
+                                                                     Google Play
+
+  iOS specific options=language                                      [default: en-US] Primary language (e.g. English,
+                                                                     German, ...)
+
+  --latest                                                           Submit the latest build for specified platform
+
+  --path=path                                                        Path to the .apk/.aab file
+
+  Android specific options=(completed|draft|halted|inProgress)       [default: completed] Release status (used when
+                                                                     uploading new APKs/AABs)
+
+  iOS specific options=sku                                           An unique ID for your app that is not visible on
+                                                                     the App Store, will be generated unless provided
+
+  Android specific options=(production|beta|alpha|internal|rollout)  [default: internal] The track of the application to
+                                                                     use
+
+  Android specific options=(apk|aab)                                 Android archive type
+
+  --url=url                                                          App archive url
+
+  --verbose                                                          Always print logs from Submission Service
 
 ALIASES
-  $ eas update:publish
+  $ eas build:submit
+
+EXAMPLES
+  $ eas submit --platform=ios
+       - Fully interactive iOS submission
+
+  $ eas submit --platform=android
+       - Fully interactive Android submission
+
+  $ eas submit -p android --latest --key=/path/to/google-services.json
+       - Minimal non-interactive Android submission, however it can ask you for other params if not specified
+
+  $ EXPO_APPLE_APP_SPECIFIC_PASSWORD=xxx eas submit -p ios --latest [email protected] --asc-app-id=1234567890,
+       - Minimal non-interactive iOS submission, assuming you already have an app in App Store Connect
+         and provide its App ID
 ```
 
-_See code: [src/commands/update/index.ts](https://github.com/expo/eas-cli/blob/v0.0.0/src/commands/update/index.ts)_
-
-## `eas update:show`
-
-details about a particular revision
-
-```
-USAGE
-  $ eas update:show
-```
-
-_See code: [src/commands/update/show.ts](https://github.com/expo/eas-cli/blob/v0.0.0/src/commands/update/show.ts)_
-
-## `eas whoami`
-
-show the username you are logged in as
-
-```
-USAGE
-  $ eas whoami
-```
-
-_See code: [src/commands/whoami.ts](https://github.com/expo/eas-cli/blob/v0.0.0/src/commands/whoami.ts)_
-
+_See code: [build/commands/submit.ts](https://github.com/expo/eas-cli/blob/v0.4.2/build/commands/submit.ts)_
 <!-- commandsstop -->

packages/eas-cli/__mocks__/@expo/config.ts

@@ -1,3 +0,0 @@
-const getConfig = jest.fn();
-
-export { getConfig };

packages/eas-cli/__mocks__/ora.ts

@@ -0,0 +1,7 @@
+export default jest.fn().mockReturnValue({
+  start: jest.fn().mockReturnValue({
+    fail: jest.fn(),
+    succeed: jest.fn(),
+  }),
+  succeed: jest.fn(),
+});

packages/eas-cli/annotate-graphql-codegen.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env sh
+
+OUTFILE="src/graphql/generated.ts"
+
+content="/**
+ * This file was generated using GraphQL Codegen
+ * Command: yarn generate-graphql-code
+ * Run this during development for automatic type generation when editing GraphQL documents
+ * For more info and docs, visit https://graphql-code-generator.com/
+ */
+"
+
+printf '%s\n%s\n' "$content" "$(cat $OUTFILE)" > $OUTFILE

packages/eas-cli/global-setup.ts

@@ -0,0 +1,3 @@
+module.exports = async () => {
+  process.env.TZ = 'UTC';
+};

packages/eas-cli/graphql-codegen.yml

@@ -0,0 +1,18 @@
+overwrite: true
+schema: 'https://staging.exp.host/--/graphql'
+documents:
+  - 'src/graphql/**/!(*.d).{ts,tsx}'
+  - 'src/credentials/ios/api/graphql/**/!(*.d).{ts,tsx}'
+generates:
+  src/graphql/generated.ts:
+    plugins:
+      - 'typescript'
+      - 'typescript-operations'
+    config:
+      dedupeOperationSuffix: true
+    hooks:
+      afterOneFileWrite:
+        - ./annotate-graphql-codegen.sh
+  ./graphql.schema.json:
+    plugins:
+      - 'introspection'

packages/eas-cli/jest.config.js

@@ -2,4 +2,5 @@ module.exports = {
   ...require('../../jest/jest.config.js'),
   rootDir: __dirname,
   roots: ['src', '__mocks__'],
+  globalSetup: './global-setup.ts',
 };

packages/eas-cli/package.json

@@ -1,74 +1,103 @@
 {
   "name": "eas-cli",
   "description": "EAS command line tool",
-  "version": "0.0.0",
+  "version": "0.4.2",
   "author": "Expo <[email protected]>",
   "bin": {
     "eas": "./bin/run"
   },
   "bugs": "https://github.com/expo/eas-cli/issues",
   "dependencies": {
-    "@eas/config": "0.0.1",
-    "@expo/config": "^3.3.9",
+    "@expo/apple-utils": "0.0.0-alpha.17",
+    "@expo/config": "~3.3.19",
+    "@expo/config-plugins": "1.0.19-alpha.0",
+    "@expo/eas-build-job": "0.2.11",
+    "@expo/eas-json": "^0.4.1",
     "@expo/json-file": "^8.2.24",
-    "@expo/plist": "^0.0.10",
+    "@expo/plist": "^0.0.11",
+    "@expo/plugin-warn-if-update-available": "^1.7.0",
+    "@expo/results": "^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",
     "chalk": "^4.1.0",
+    "cli-table3": "^0.6.0",
     "dateformat": "^3.0.3",
     "env-paths": "^2.2.0",
+    "fast-glob": "^3.2.4",
+    "figures": "^3.2.0",
     "form-data": "^3.0.0",
     "fs-extra": "^9.0.1",
+    "getenv": "^1.0.0",
     "got": "^11.5.2",
+    "graphql": "^15.3.0",
     "graphql-tag": "^2.11.0",
+    "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",
     "node-forge": "^0.10.0",
+    "nullthrows": "^1.1.1",
     "ora": "^5.1.0",
     "pkg-dir": "^4.2.0",
     "progress": "^2.0.3",
     "prompts": "^2.3.2",
+    "qrcode-terminal": "^0.12.0",
+    "semver": "^7.3.4",
+    "strip-ansi": "^6.0.0",
+    "tar": "^6.0.5",
+    "tempy": "^0.7.0",
+    "terminal-link": "^2.1.1",
+    "timeago.js": "^4.0.2",
     "tslib": "^1",
+    "turndown": "^7.0.0",
     "untildify": "^4.0.0",
     "uuid": "^8.3.0",
-    "wordwrap": "^1.0.0"
+    "wrap-ansi": "^7.0.0"
   },
   "devDependencies": {
     "@babel/core": "^7.11.6",
     "@babel/preset-env": "^7.11.5",
     "@babel/preset-typescript": "^7.10.4",
     "@expo/babel-preset-cli": "^0.2.17",
-    "@expo/oclif-dev-cli": "1.23.0-expo",
+    "@graphql-codegen/cli": "^1.19.2",
+    "@graphql-codegen/introspection": "^1.18.0",
+    "@graphql-codegen/typescript": "^1.17.11",
+    "@graphql-codegen/typescript-operations": "^1.17.10",
+    "@types/color-string": "^1.5.0",
     "@types/dateformat": "^3.0.1",
     "@types/form-data": "^2.5.0",
     "@types/fs-extra": "^9.0.1",
+    "@types/getenv": "^1.0.0",
     "@types/lodash": "^4.14.161",
+    "@types/mime": "^2.0.3",
     "@types/node": "^12",
     "@types/node-fetch": "^2.5.7",
     "@types/node-forge": "^0.9.5",
     "@types/progress": "^2.0.3",
-    "@types/prompts": "^2.0.8",
+    "@types/prompts": "^2.0.9",
+    "@types/semver": "^7.3.4",
+    "@types/tar": "^4.0.3",
+    "@types/tough-cookie": "^4.0.0",
     "@types/uuid": "^8.3.0",
-    "@types/wordwrap": "^1.0.0",
+    "@types/wrap-ansi": "^3.0.0",
     "@vercel/ncc": "^0.23.0",
+    "axios": "^0.21.0",
     "babel-jest": "^26.3.0",
-    "graphql": "^15.3.0",
     "memfs": "^3.2.0",
-    "tempy": "^0.7.0",
+    "mockdate": "^3.0.2",
+    "nock": "^13.0.5",
     "ts-node": "^8",
     "typescript": "^3.9.7",
     "wonka": "^4.0.14"
   },
-  "optionalDependencies": {
-    "@expo/traveling-fastlane-darwin": "1.15.1",
-    "@expo/traveling-fastlane-linux": "1.15.1"
-  },
   "engines": {
     "node": ">=8.0.0"
   },
@@ -89,26 +118,53 @@
     "bin": "eas",
     "commands": "./build/commands",
     "plugins": [
-      "@oclif/plugin-help"
+      "@oclif/plugin-help",
+      "@expo/plugin-warn-if-update-available"
     ],
+    "helpClass": "./build/help",
     "topics": {
       "build": {
         "description": "build app binaries"
       },
+      "channel": {
+        "description": "manage update channels"
+      },
+      "release": {
+        "description": "manage update releases"
+      },
       "update": {
-        "description": "roll out changes"
+        "description": "manage individual updates"
       },
       "webhook": {
         "description": "manage webhooks"
       }
+    },
+    "warn-if-update-available": {
+      "timeoutInDays": 0.5,
+      "message": "<%= chalk.bold('★') %> <%= chalk.bold(config.name + '@' + latest) %> <%= chalk.bold('is now available, please upgrade.') %>\n<%= chalk.dim('Proceeding with outdated version') %>\n"
+    },
+    "update": {
+      "node": {
+        "version": "12.13.0"
+      },
+      "s3": {
+        "templates": {
+          "target": {
+            "unversioned": "<%- bin %>-<%- platform %>-<%- arch %><%- ext %>",
+            "versioned": "<%- bin %>-<%- platform %>-<%- arch %><%- ext %>"
+          }
+        }
+      }
     }
   },
   "repository": "expo/eas-cli",
   "scripts": {
     "postpack": "rm -f oclif.manifest.json",
-    "prepack": "rm -rf build && tsc -b && oclif-dev manifest && oclif-dev readme",
+    "prepack": "rm -rf build && yarn build && yarn oclif-dev manifest && yarn oclif-dev readme",
+    "build": "tsc",
     "test": "jest",
-    "version": "oclif-dev readme && git add README.md"
+    "version": "yarn oclif-dev readme && git add README.md",
+    "generate-graphql-code": "graphql-codegen --config graphql-codegen.yml"
   },
   "types": "build/index.d.ts"
 }

packages/eas-cli/src/ApiV2Error.ts

@@ -0,0 +1,27 @@
+import { JSONValue } from '@expo/json-file';
+import { HTTPError, RequestError } from 'got/dist/source';
+
+export default class ApiV2Error extends RequestError {
+  readonly name = 'ApiV2Error';
+  readonly expoApiV2ErrorCode: string;
+  readonly expoApiV2ErrorDetails?: JSONValue;
+  readonly expoApiV2ErrorServerStack?: string;
+  readonly expoApiV2ErrorMetadata?: object;
+
+  constructor(
+    originalError: HTTPError,
+    response: {
+      message: string;
+      code: string;
+      stack?: string;
+      details?: JSONValue;
+      metadata?: object;
+    }
+  ) {
+    super(response.message, originalError, originalError.request);
+    this.expoApiV2ErrorCode = response.code;
+    this.expoApiV2ErrorDetails = response.details;
+    this.expoApiV2ErrorServerStack = response.stack;
+    this.expoApiV2ErrorMetadata = response.metadata;
+  }
+}

packages/eas-cli/src/__tests__/api-test.ts

@@ -0,0 +1,53 @@
+import assert from 'assert';
+import { RequestError } from 'got/dist/source';
+import nock from 'nock';
+
+import ApiV2Error from '../ApiV2Error';
+import { apiClient, getExpoApiBaseUrl } from '../api';
+
+describe('apiClient', () => {
+  it('converts Expo APIv2 error to ApiV2Error', async () => {
+    nock(getExpoApiBaseUrl())
+      .post('/--/api/v2/test')
+      .reply(400, {
+        errors: [
+          {
+            message: 'hellomessage',
+            code: 'TEST_CODE',
+            stack: 'line 1: hello',
+            details: { who: 'world' },
+            metadata: { an: 'object' },
+          },
+        ],
+      });
+
+    let error: Error;
+    try {
+      await apiClient.post('test');
+    } catch (e) {
+      error = e;
+    }
+
+    expect(error).toBeInstanceOf(ApiV2Error);
+    assert(error instanceof ApiV2Error);
+
+    expect(error.message).toEqual('hellomessage');
+    expect(error.expoApiV2ErrorCode).toEqual('TEST_CODE');
+    expect(error.expoApiV2ErrorDetails).toEqual({ who: 'world' });
+    expect(error.expoApiV2ErrorMetadata).toEqual({ an: 'object' });
+    expect(error.expoApiV2ErrorServerStack).toEqual('line 1: hello');
+  });
+
+  it('does not convert non-APIv2 error to ApiV2Error', async () => {
+    nock(getExpoApiBaseUrl()).post('/--/api/v2/test').reply(500, 'Something went wrong');
+
+    let error: Error;
+    try {
+      await apiClient.post('test');
+    } catch (e) {
+      error = e;
+    }
+    expect(error).toBeInstanceOf(RequestError);
+    expect(error).not.toBeInstanceOf(ApiV2Error);
+  });
+});

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

@@ -0,0 +1,62 @@
+import { Actor } from '../user/User';
+
+interface MockProject {
+  projectRoot: string;
+  projectTree: Record<string, string>;
+  appJSON: AppJSON;
+  packageJSON: PackageJSON;
+}
+
+interface PackageJSON {
+  name: string;
+  version: string;
+  description: string;
+  main: string;
+}
+
+interface AppJSON {
+  expo: {
+    name: string;
+    version: string;
+    slug: string;
+    sdkVersion: string;
+    owner?: string;
+    [key: string]: any;
+  };
+}
+
+function createTestProject(
+  user: Actor,
+  appJSONExtraData?: Record<string, object | string>
+): MockProject {
+  const projectRoot = '/test-project';
+  const packageJSON: PackageJSON = {
+    name: 'testing123',
+    version: '0.1.0',
+    description: 'fake description',
+    main: 'index.js',
+  };
+
+  const owner = appJSONExtraData?.owner as string | undefined;
+  const appJSON: AppJSON = {
+    expo: {
+      name: 'testing 123',
+      version: '0.1.0',
+      slug: 'testing-123',
+      sdkVersion: '33.0.0',
+      owner: owner ?? (user.__typename === 'User' ? user.username : undefined),
+      ...appJSONExtraData,
+    },
+  };
+  return {
+    appJSON,
+    packageJSON,
+    projectRoot,
+    projectTree: {
+      [projectRoot + '/package.json']: JSON.stringify(packageJSON, null, 2),
+      [projectRoot + '/app.json']: JSON.stringify(appJSON, null, 2),
+    },
+  };
+}
+
+export { createTestProject };

packages/eas-cli/src/api.ts

@@ -1,16 +1,7 @@
-import { createClient as createUrqlClient } from '@urql/core';
-import got, { NormalizedOptions } from 'got';
-import fetch from 'node-fetch';
+import got, { HTTPError, NormalizedOptions, RequestError } from 'got';
 
-import { getAccessToken, getSessionSecret } from './user/User';
-
-type AccessTokenHeaders = {
-  authorization: string;
-};
-
-type SessionHeaders = {
-  'expo-session': string;
-};
+import ApiV2Error from './ApiV2Error';
+import { getAccessToken, getSessionSecret } from './user/sessionStorage';
 
 export const apiClient = got.extend({
   prefixUrl: getExpoApiBaseUrl() + '/--/api/v2/',
@@ -28,31 +19,22 @@ export const apiClient = got.extend({
         }
       },
     ],
-  },
-});
-
-export const graphqlClient = createUrqlClient({
-  url: getExpoApiBaseUrl() + '/--/graphql',
-  // @ts-expect-error Type 'typeof fetch' is not assignable to type '(input: RequestInfo, init?: RequestInit | undefined) => Promise<Response>'.
-  fetch,
-  fetchOptions: (): { headers?: AccessTokenHeaders | SessionHeaders } => {
-    const token = getAccessToken();
-    if (token) {
-      return {
-        headers: {
-          authorization: `Bearer ${token}`,
-        },
-      };
-    }
-    const sessionSecret = getSessionSecret();
-    if (sessionSecret) {
-      return {
-        headers: {
-          'expo-session': sessionSecret,
-        },
-      };
-    }
-    return {};
+    beforeError: [
+      (error: RequestError): RequestError => {
+        if (error instanceof HTTPError) {
+          let result: { [key: string]: any };
+          try {
+            result = JSON.parse(error.response.body as string);
+          } catch (e2) {
+            return error;
+          }
+          if (result.errors?.length) {
+            return new ApiV2Error(error, result.errors[0]);
+          }
+        }
+        return error;
+      },
+    ],
   },
 });
 
@@ -60,8 +42,18 @@ export function getExpoApiBaseUrl(): string {
   if (process.env.EXPO_STAGING) {
     return `https://staging.exp.host`;
   } else if (process.env.EXPO_LOCAL) {
-    return `http://exp.test`;
+    return `http://127.0.0.1:3000`;
   } else {
     return `https://exp.host`;
   }
 }
+
+export function getExpoWebsiteBaseUrl(): string {
+  if (process.env.EXPO_STAGING) {
+    return `https://staging.expo.io`;
+  } else if (process.env.EXPO_LOCAL) {
+    return `http://expo.test`;
+  } else {
+    return `https://expo.io`;
+  }
+}

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

@@ -0,0 +1,294 @@
+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');
+    });
+  });
+});

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

@@ -0,0 +1,92 @@
+import { ExpoConfig } from '@expo/config';
+import { AndroidConfig } from '@expo/config-plugins';
+import fs from 'fs-extra';
+
+import Log from '../../log';
+import { getProjectAccountName } from '../../project/projectUtils';
+import { ensureLoggedInAsync } from '../../user/actions';
+import { ensureValidVersions } from '../utils/updates';
+
+export async function configureUpdatesAsync(projectDir: string, exp: ExpoConfig): Promise<void> {
+  ensureValidVersions(exp);
+  const accountName = getProjectAccountName(exp, await ensureLoggedInAsync());
+  const buildGradlePath = AndroidConfig.Paths.getAppBuildGradle(projectDir);
+  const buildGradleContents = await fs.readFile(buildGradlePath, 'utf8');
+
+  if (!AndroidConfig.Updates.isBuildGradleConfigured(projectDir, buildGradleContents)) {
+    const updatedBuildGradleContents = AndroidConfig.Updates.ensureBuildGradleContainsConfigurationScript(
+      projectDir,
+      buildGradleContents
+    );
+    await fs.writeFile(buildGradlePath, updatedBuildGradleContents);
+  }
+
+  const androidManifestPath = await AndroidConfig.Paths.getAndroidManifestAsync(projectDir);
+  if (!androidManifestPath) {
+    throw new Error(`Could not find AndroidManifest.xml in project directory: "${projectDir}"`);
+  }
+  const androidManifest = await AndroidConfig.Manifest.readAndroidManifestAsync(
+    androidManifestPath
+  );
+
+  if (!AndroidConfig.Updates.isMainApplicationMetaDataSynced(exp, androidManifest, accountName)) {
+    const result = AndroidConfig.Updates.setUpdatesConfig(exp, androidManifest, accountName);
+
+    await AndroidConfig.Manifest.writeAndroidManifestAsync(androidManifestPath, result);
+  }
+}
+
+export async function syncUpdatesConfigurationAsync(
+  projectDir: string,
+  exp: ExpoConfig
+): Promise<void> {
+  ensureValidVersions(exp);
+  const accountName = getProjectAccountName(exp, await ensureLoggedInAsync());
+  try {
+    await ensureUpdatesConfiguredAsync(projectDir, exp);
+  } catch (error) {
+    Log.error(
+      'expo-updates module is not configured. Please run "eas build:configure" first to configure the project'
+    );
+    throw error;
+  }
+
+  const androidManifestPath = await AndroidConfig.Paths.getAndroidManifestAsync(projectDir);
+  if (!androidManifestPath) {
+    throw new Error(`Could not find AndroidManifest.xml in project directory: "${projectDir}"`);
+  }
+  let androidManifest = await AndroidConfig.Manifest.readAndroidManifestAsync(androidManifestPath);
+
+  if (!AndroidConfig.Updates.areVersionsSynced(exp, androidManifest)) {
+    androidManifest = AndroidConfig.Updates.setVersionsConfig(exp, androidManifest);
+    await AndroidConfig.Manifest.writeAndroidManifestAsync(androidManifestPath, androidManifest);
+  }
+
+  if (!AndroidConfig.Updates.isMainApplicationMetaDataSynced(exp, androidManifest, accountName)) {
+    Log.warn(
+      'Native project configuration is not synced with values present in your app.json, run "eas build:configure" to make sure all values are applied in the native project'
+    );
+  }
+}
+
+async function ensureUpdatesConfiguredAsync(projectDir: string, exp: ExpoConfig): Promise<void> {
+  const buildGradlePath = AndroidConfig.Paths.getAppBuildGradle(projectDir);
+  const buildGradleContents = await fs.readFile(buildGradlePath, 'utf8');
+
+  if (!AndroidConfig.Updates.isBuildGradleConfigured(projectDir, buildGradleContents)) {
+    const gradleScriptApply = AndroidConfig.Updates.formatApplyLineForBuildGradle(projectDir);
+    throw new Error(`Missing ${gradleScriptApply} in ${buildGradlePath}`);
+  }
+
+  const androidManifestPath = await AndroidConfig.Paths.getAndroidManifestAsync(projectDir);
+  if (!androidManifestPath) {
+    throw new Error(`Could not find AndroidManifest.xml in project directory: "${projectDir}"`);
+  }
+  const androidManifest = await AndroidConfig.Manifest.readAndroidManifestAsync(
+    androidManifestPath
+  );
+
+  if (!AndroidConfig.Updates.isMainApplicationMetaDataSet(androidManifest)) {
+    throw new Error('Missing values in AndroidManifest.xml');
+  }
+}

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

@@ -0,0 +1,187 @@
+import { ExpoConfig, getConfigFilePaths } from '@expo/config';
+import { AndroidConfig } from '@expo/config-plugins';
+import assert from 'assert';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+
+import Log from '../../log';
+import {
+  ensureAppIdentifierIsDefinedAsync,
+  getAndroidApplicationIdAsync,
+  getProjectConfigDescription,
+} from '../../project/projectUtils';
+import { promptAsync } from '../../prompts';
+import { gitAddAsync } from '../../utils/git';
+import { Platform } from '../types';
+
+enum ApplicationIdSource {
+  AndroidProject,
+  AppJson,
+}
+
+function isApplicationIdValid(applicationId: string): boolean {
+  return /^[a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)+$/.test(applicationId);
+}
+
+export async function ensureApplicationIdIsValidAsync(projectDir: string) {
+  const applicationId = await ensureAppIdentifierIsDefinedAsync(projectDir, Platform.Android);
+  if (!isApplicationIdValid(applicationId)) {
+    const configDescription = getProjectConfigDescription(projectDir);
+    Log.error(
+      `Invalid format of Android applicationId. Only alphanumeric characters, '.' and '_' are allowed, and each '.' must be followed by a letter.`
+    );
+    Log.error(`Update "android.package" in ${configDescription} and run this command again.`);
+    throw new Error('Invalid applicationId');
+  }
+}
+
+export async function configureApplicationIdAsync(
+  projectDir: string,
+  exp: ExpoConfig,
+  allowExperimental: boolean
+): Promise<void> {
+  const configDescription = getProjectConfigDescription(projectDir);
+  const applicationIdFromConfig = AndroidConfig.Package.getPackage(exp);
+  const applicationIdFromAndroidProject = await getAndroidApplicationIdAsync(projectDir);
+
+  if (applicationIdFromAndroidProject && applicationIdFromConfig) {
+    if (applicationIdFromConfig !== applicationIdFromAndroidProject) {
+      Log.newLine();
+      Log.warn(
+        `We detected that your Android project is configured with a different application id than the one defined in ${configDescription}.`
+      );
+      const hasApplicationIdInStaticConfig = await hasApplicationIdInStaticConfigAsync(
+        projectDir,
+        exp
+      );
+      if (!hasApplicationIdInStaticConfig) {
+        Log.log(`If you choose the one defined in ${configDescription} we'll automatically configure your Android project with it.
+However, if you choose the one defined in the Android project you'll have to update ${configDescription} on your own.`);
+      }
+      Log.newLine();
+      const { applicationIdSource } = await promptAsync({
+        type: 'select',
+        name: 'applicationIdSource',
+        message: 'Which application id should we use?',
+        choices: [
+          {
+            title: `${chalk.bold(
+              applicationIdFromAndroidProject
+            )} - In build.gradle in Android project`,
+            value: ApplicationIdSource.AndroidProject,
+          },
+          {
+            title: `${chalk.bold(applicationIdFromConfig)} - In your ${configDescription}`,
+            value: ApplicationIdSource.AppJson,
+          },
+        ],
+      });
+      switch (applicationIdSource) {
+        case ApplicationIdSource.AppJson: {
+          await updateApplicationIdInBuildGradleAsync(projectDir, exp);
+          break;
+        }
+        case ApplicationIdSource.AndroidProject: {
+          if (hasApplicationIdInStaticConfig) {
+            await updateAppJsonConfigAsync(projectDir, exp, applicationIdFromAndroidProject);
+          } else {
+            throw new Error(missingPackageMessage(configDescription));
+          }
+          break;
+        }
+      }
+    }
+  } else if (!applicationIdFromAndroidProject && !applicationIdFromConfig) {
+    throw new Error(missingPackageMessage(configDescription));
+  } else if (applicationIdFromAndroidProject && !applicationIdFromConfig) {
+    if (getConfigFilePaths(projectDir).staticConfigPath) {
+      await updateAppJsonConfigAsync(projectDir, exp, applicationIdFromAndroidProject);
+    } else {
+      throw new Error(missingPackageMessage(configDescription));
+    }
+  } else if (!applicationIdFromAndroidProject && applicationIdFromConfig) {
+    // This should never happen, adding warning just in case
+    Log.warn(
+      'applicationId is not specified in your ./android/app/build.gradle file. Make sure your project is configured correctly before building.'
+    );
+    return;
+  }
+  if (allowExperimental) {
+    // this step is optional, the Play store is using applicationId value from build.gradle
+    // to identify the app, so package name does not need to be updated
+    await updatePackageNameAsync(projectDir, exp);
+    await gitAddAsync(path.join(projectDir, 'android'), { intentToAdd: true });
+  }
+}
+
+function missingPackageMessage(configDescription: string): string {
+  return `Please define "android.package" in ${configDescription} and run "eas build:configure" again.`;
+}
+
+async function updateAppJsonConfigAsync(
+  projectDir: string,
+  exp: ExpoConfig,
+  newApplicationId: string
+): Promise<void> {
+  const paths = getConfigFilePaths(projectDir);
+  assert(paths.staticConfigPath, "can't update dynamic configs");
+
+  const rawStaticConfig = await fs.readJSON(paths.staticConfigPath);
+  rawStaticConfig.expo = {
+    ...rawStaticConfig.expo,
+    android: { ...rawStaticConfig.expo?.android, package: newApplicationId },
+  };
+  await fs.writeJson(paths.staticConfigPath, rawStaticConfig, { spaces: 2 });
+
+  exp.android = { ...exp.android, package: newApplicationId };
+}
+
+/**
+ * Check if static config exists and if expo.android.package is defined there.
+ * It will return false if the value in static config is different than "android.package" in ExpoConfig
+ */
+async function hasApplicationIdInStaticConfigAsync(
+  projectDir: string,
+  exp: ExpoConfig
+): Promise<boolean> {
+  if (!exp.android?.package) {
+    return false;
+  }
+  const paths = getConfigFilePaths(projectDir);
+  if (!paths.staticConfigPath) {
+    return false;
+  }
+  const rawStaticConfig = await fs.readJson(paths.staticConfigPath);
+  return rawStaticConfig?.expo?.android?.package === exp.android.package;
+}
+
+async function updateApplicationIdInBuildGradleAsync(projectDir: string, exp: ExpoConfig) {
+  const buildGradlePath = AndroidConfig.Paths.getAppBuildGradle(projectDir);
+  const buildGradleContents = await fs.readFile(buildGradlePath, 'utf8');
+  const updatedBuildGradleContents = AndroidConfig.Package.setPackageInBuildGradle(
+    exp,
+    buildGradleContents
+  );
+  await fs.writeFile(buildGradlePath, updatedBuildGradleContents);
+}
+
+async function updatePackageNameAsync(projectDir: string, exp: ExpoConfig): Promise<void> {
+  await AndroidConfig.Package.renamePackageOnDisk(exp, projectDir);
+
+  const androidManifestPath = await AndroidConfig.Paths.getAndroidManifestAsync(projectDir);
+  if (!androidManifestPath) {
+    throw new Error(`Could not find AndroidManifest.xml in project directory: "${projectDir}"`);
+  }
+  const androidManifest = await AndroidConfig.Manifest.readAndroidManifestAsync(
+    androidManifestPath
+  );
+  const updatedAndroidManifest = AndroidConfig.Package.setPackageInAndroidManifest(
+    exp,
+    androidManifest
+  );
+  await AndroidConfig.Manifest.writeAndroidManifestAsync(
+    androidManifestPath,
+    updatedAndroidManifest
+  );
+}

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

@@ -0,0 +1,113 @@
+import { Workflow } from '@expo/eas-build-job';
+import { EasConfig } from '@expo/eas-json';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+
+import AndroidCredentialsProvider, {
+  AndroidCredentials,
+} from '../../credentials/android/AndroidCredentialsProvider';
+import { createCredentialsContextAsync } from '../../credentials/context';
+import Log from '../../log';
+import { toggleConfirmAsync } from '../../prompts';
+import { CredentialsResult, prepareBuildRequestForPlatformAsync } from '../build';
+import { BuildContext, CommandContext, createBuildContext } from '../context';
+import { ensureCredentialsAsync } from '../credentials';
+import { Platform } from '../types';
+import { ensureApplicationIdIsValidAsync } from './applicationId';
+import { validateAndSyncProjectConfigurationAsync } from './configure';
+import { prepareJobAsync } from './prepareJob';
+
+export async function prepareAndroidBuildAsync(
+  commandCtx: CommandContext,
+  easConfig: EasConfig
+): Promise<() => Promise<string>> {
+  const buildCtx = createBuildContext<Platform.Android>({
+    commandCtx,
+    platform: Platform.Android,
+    easConfig,
+  });
+  const { buildProfile } = buildCtx;
+
+  if (
+    buildProfile.workflow === Workflow.Generic &&
+    !(await fs.pathExists(path.join(commandCtx.projectDir, 'android')))
+  ) {
+    throw new Error(
+      `"android" directory not found. If you're trying to build a managed project, set ${chalk.bold(
+        `builds.android.${commandCtx.profile}.workflow`
+      )} in "eas.json" to "managed".`
+    );
+  }
+
+  if (
+    buildProfile.workflow === Workflow.Generic &&
+    buildProfile.distribution === 'internal' &&
+    buildProfile.gradleCommand?.match(/bundle/)
+  ) {
+    Log.addNewLineIfNone();
+    Log.warn(
+      `You're building your Android app for internal distribution. However, we've detected that the Gradle command you defined (${chalk.underline(
+        buildProfile.gradleCommand
+      )}) includes string 'bundle'.
+This means that it will most likely produce an AAB and you will not be able to install it on your Android devices straight from the Expo website.`
+    );
+    Log.newLine();
+    const confirmed = await toggleConfirmAsync({ message: 'Would you like to proceed?' });
+    if (!confirmed) {
+      Log.error('Please update eas.json and come back again.');
+      process.exit(1);
+    }
+  }
+
+  await ensureApplicationIdIsValidAsync(commandCtx.projectDir);
+
+  return await prepareBuildRequestForPlatformAsync({
+    ctx: buildCtx,
+    projectConfiguration: {},
+    ensureCredentialsAsync: ensureAndroidCredentialsAsync,
+    ensureProjectConfiguredAsync: async () => {
+      if (buildCtx.buildProfile.workflow === Workflow.Generic) {
+        await validateAndSyncProjectConfigurationAsync(commandCtx.projectDir, commandCtx.exp);
+      }
+    },
+    prepareJobAsync,
+  });
+}
+
+function shouldProvideCredentials(ctx: BuildContext<Platform.Android>): boolean {
+  return (
+    ctx.buildProfile.workflow === Workflow.Managed ||
+    (ctx.buildProfile.workflow === Workflow.Generic && !ctx.buildProfile.withoutCredentials)
+  );
+}
+
+async function ensureAndroidCredentialsAsync(
+  ctx: BuildContext<Platform.Android>
+): Promise<CredentialsResult<AndroidCredentials> | undefined> {
+  if (!shouldProvideCredentials(ctx)) {
+    return;
+  }
+  const provider = new AndroidCredentialsProvider(
+    await createCredentialsContextAsync(ctx.commandCtx.projectDir, {
+      nonInteractive: ctx.commandCtx.nonInteractive,
+    }),
+    {
+      app: {
+        projectName: ctx.commandCtx.projectName,
+        accountName: ctx.commandCtx.accountName,
+      },
+      skipCredentialsCheck: ctx.commandCtx.skipCredentialsCheck,
+    }
+  );
+  const credentialsSource = await ensureCredentialsAsync(
+    provider,
+    ctx.buildProfile.workflow,
+    ctx.buildProfile.credentialsSource,
+    ctx.commandCtx.nonInteractive
+  );
+  return {
+    credentials: await provider.getCredentialsAsync(credentialsSource),
+    source: credentialsSource,
+  };
+}

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

@@ -0,0 +1,50 @@
+import { ExpoConfig } from '@expo/config';
+import { AndroidConfig } from '@expo/config-plugins';
+
+import Log from '../../log';
+import { getAndroidApplicationIdAsync } from '../../project/projectUtils';
+import { gitAddAsync } from '../../utils/git';
+import { ConfigureContext } from '../context';
+import { isExpoUpdatesInstalled } from '../utils/updates';
+import { configureUpdatesAsync, syncUpdatesConfigurationAsync } from './UpdatesModule';
+import { configureApplicationIdAsync, ensureApplicationIdIsValidAsync } from './applicationId';
+
+export async function configureAndroidAsync(ctx: ConfigureContext): Promise<void> {
+  if (!ctx.hasAndroidNativeProject) {
+    return;
+  }
+  await AndroidConfig.EasBuild.configureEasBuildAsync(ctx.projectDir);
+  await configureApplicationIdAsync(ctx.projectDir, ctx.exp, ctx.allowExperimental);
+  await ensureApplicationIdIsValidAsync(ctx.projectDir);
+
+  const easGradlePath = AndroidConfig.EasBuild.getEasBuildGradlePath(ctx.projectDir);
+  await gitAddAsync(easGradlePath, { intentToAdd: true });
+
+  if (isExpoUpdatesInstalled(ctx.projectDir)) {
+    await configureUpdatesAsync(ctx.projectDir, ctx.exp);
+  }
+  Log.withTick('Android project configured');
+}
+
+export async function validateAndSyncProjectConfigurationAsync(
+  projectDir: string,
+  exp: ExpoConfig
+): Promise<void> {
+  const applicationIdFromAndroidProject = await getAndroidApplicationIdAsync(projectDir);
+  const packageNameFromConfig = AndroidConfig.Package.getPackage(exp);
+  const isApplicationIdConfigured =
+    applicationIdFromAndroidProject && applicationIdFromAndroidProject === packageNameFromConfig;
+
+  const isEasBuildGradleConfigured = await AndroidConfig.EasBuild.isEasBuildGradleConfiguredAsync(
+    projectDir
+  );
+  if (!isEasBuildGradleConfigured || !isApplicationIdConfigured) {
+    throw new Error(
+      'Project is not configured. Please run "eas build:configure" to configure the project.'
+    );
+  }
+
+  if (isExpoUpdatesInstalled(projectDir)) {
+    await syncUpdatesConfigurationAsync(projectDir, exp);
+  }
+}

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

@@ -0,0 +1,123 @@
+import {
+  Android,
+  ArchiveSource,
+  ArchiveSourceType,
+  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 { getProjectAccountNameAsync } from '../../project/projectUtils';
+import { gitRootDirectoryAsync } from '../../utils/git';
+import { BuildContext } from '../context';
+import { Platform } from '../types';
+
+interface JobData {
+  archiveBucketKey: string;
+  credentials?: AndroidCredentials;
+}
+
+export async function prepareJobAsync(
+  ctx: BuildContext<Platform.Android>,
+  jobData: JobData
+): Promise<Job> {
+  if (ctx.buildProfile.workflow === Workflow.Generic) {
+    const partialJob = await prepareGenericJobAsync(ctx, jobData, ctx.buildProfile);
+    return sanitizeJob(partialJob);
+  } else if (ctx.buildProfile.workflow === Workflow.Managed) {
+    const partialJob = await prepareManagedJobAsync(ctx, jobData, ctx.buildProfile);
+    return sanitizeJob(partialJob);
+  } else {
+    throw new Error("Unknown workflow. Shouldn't happen");
+  }
+}
+
+interface CommonJobProperties {
+  platform: Platform.Android;
+  projectArchive: ArchiveSource;
+  builderEnvironment: Android.BuilderEnvironment;
+  secrets: {
+    buildCredentials?: {
+      keystore: Android.Keystore;
+    };
+    secretEnvs?: Record<string, string>;
+  };
+}
+
+async function prepareJobCommonAsync(
+  ctx: BuildContext<Platform.Android>,
+  jobData: JobData
+): Promise<Partial<CommonJobProperties>> {
+  const secretEnvs = await readSecretEnvsAsync(ctx.commandCtx.projectDir);
+  const credentials = jobData.credentials;
+  const buildCredentials = credentials
+    ? {
+        buildCredentials: {
+          keystore: {
+            dataBase64: credentials.keystore.keystore,
+            keystorePassword: credentials.keystore.keystorePassword,
+            keyAlias: credentials.keystore.keyAlias,
+            keyPassword: credentials.keystore.keyPassword,
+          },
+        },
+      }
+    : {};
+
+  return {
+    platform: Platform.Android,
+    projectArchive: {
+      type: ArchiveSourceType.S3,
+      bucketKey: jobData.archiveBucketKey,
+    },
+    builderEnvironment: {
+      image: ctx.buildProfile.image,
+      node: ctx.buildProfile.node,
+      yarn: ctx.buildProfile.yarn,
+      ndk: ctx.buildProfile.ndk,
+      env: ctx.buildProfile.env,
+    },
+    secrets: {
+      ...(secretEnvs ? { secretEnvs } : {}),
+      ...buildCredentials,
+    },
+  };
+}
+
+async function prepareGenericJobAsync(
+  ctx: BuildContext<Platform.Android>,
+  jobData: JobData,
+  buildProfile: AndroidGenericBuildProfile
+): Promise<Partial<Android.GenericJob>> {
+  const projectRootDirectory =
+    path.relative(await gitRootDirectoryAsync(), ctx.commandCtx.projectDir) || '.';
+  return {
+    ...(await prepareJobCommonAsync(ctx, jobData)),
+    type: Workflow.Generic,
+    gradleCommand: buildProfile.gradleCommand,
+    artifactPath: buildProfile.artifactPath,
+    releaseChannel: buildProfile.releaseChannel,
+    projectRootDirectory,
+  };
+}
+
+async function prepareManagedJobAsync(
+  ctx: BuildContext<Platform.Android>,
+  jobData: JobData,
+  buildProfile: AndroidManagedBuildProfile
+): Promise<Partial<Android.ManagedJob>> {
+  const projectRootDirectory =
+    path.relative(await gitRootDirectoryAsync(), ctx.commandCtx.projectDir) || '.';
+  const accountName = await getProjectAccountNameAsync(ctx.commandCtx.projectDir);
+  return {
+    ...(await prepareJobCommonAsync(ctx, jobData)),
+    type: Workflow.Managed,
+    username: accountName,
+    buildType: buildProfile.buildType,
+    releaseChannel: buildProfile.releaseChannel,
+    projectRootDirectory,
+  };
+}

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

@@ -0,0 +1,221 @@
+import { Job } from '@expo/eas-build-job';
+import { CredentialsSource } from '@expo/eas-json';
+import fs from 'fs-extra';
+
+import { apiClient } from '../api';
+import Log from '../log';
+import { promptAsync } from '../prompts';
+import { UploadType, uploadAsync } from '../uploads';
+import { createProgressTracker } from '../utils/progress';
+import { platformDisplayNames } from './constants';
+import { BuildContext } from './context';
+import { collectMetadata } from './metadata';
+import { AnalyticsEvent, Platform, TrackingContext } from './types';
+import Analytics from './utils/analytics';
+import { printDeprecationWarnings } from './utils/printBuildInfo';
+import {
+  commitPromptAsync,
+  isGitStatusCleanAsync,
+  makeProjectTarballAsync,
+  showDiffAsync,
+} from './utils/repository';
+
+export interface CredentialsResult<Credentials> {
+  source: CredentialsSource.LOCAL | CredentialsSource.REMOTE;
+  credentials: Credentials;
+}
+
+interface Builder<TPlatform extends Platform, Credentials, ProjectConfiguration> {
+  ctx: BuildContext<TPlatform>;
+  projectConfiguration: ProjectConfiguration;
+
+  ensureCredentialsAsync(
+    ctx: BuildContext<TPlatform>
+  ): Promise<CredentialsResult<Credentials> | undefined>;
+  ensureProjectConfiguredAsync(ctx: BuildContext<TPlatform>): Promise<void>;
+  prepareJobAsync(
+    ctx: BuildContext<TPlatform>,
+    jobData: {
+      archiveBucketKey: string;
+      credentials?: Credentials;
+      projectConfiguration?: ProjectConfiguration;
+    }
+  ): Promise<Job>;
+}
+
+export async function prepareBuildRequestForPlatformAsync<
+  TPlatform extends Platform,
+  Credentials,
+  ProjectConfiguration
+>(builder: Builder<TPlatform, Credentials, ProjectConfiguration>): Promise<() => Promise<string>> {
+  const credentialsResult = await withAnalyticsAsync(
+    async () => await builder.ensureCredentialsAsync(builder.ctx),
+    {
+      successEvent: AnalyticsEvent.GATHER_CREDENTIALS_SUCCESS,
+      failureEvent: AnalyticsEvent.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,
+      trackingCtx: builder.ctx.trackingCtx,
+    });
+  }
+
+  if (!(await isGitStatusCleanAsync())) {
+    Log.addNewLineIfNone();
+    await reviewAndCommitChangesAsync(
+      `[EAS Build] Run EAS Build for ${platformDisplayNames[builder.ctx.platform as Platform]}`,
+      {
+        nonInteractive: builder.ctx.commandCtx.nonInteractive,
+      }
+    );
+  }
+
+  const archiveBucketKey = await uploadProjectAsync(builder.ctx);
+
+  const metadata = await collectMetadata(builder.ctx, {
+    credentialsSource: credentialsResult?.source,
+  });
+  const job = await builder.prepareJobAsync(builder.ctx, {
+    archiveBucketKey,
+    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,
+        }
+      );
+    } catch (error) {
+      const body = error?.response?.body;
+      if (body && JSON.parse(body)?.errors?.[0]?.code === 'TURTLE_DEPRECATED_JOB_FORMAT') {
+        Log.error('EAS Build API has changed, please upgrade to the latest eas-cli');
+      }
+      throw error;
+    }
+  };
+}
+
+async function uploadProjectAsync<TPlatform extends Platform>(
+  ctx: BuildContext<TPlatform>
+): Promise<string> {
+  let projectTarballPath;
+  try {
+    return await withAnalyticsAsync(
+      async () => {
+        const projectTarball = await makeProjectTarballAsync();
+        projectTarballPath = projectTarball.path;
+
+        const { bucketKey } = await uploadAsync(
+          UploadType.TURTLE_PROJECT_SOURCES,
+          projectTarball.path,
+          createProgressTracker({
+            total: projectTarball.size,
+            message: 'Uploading to EAS Build',
+            completedMessage: `Uploaded to EAS`,
+          })
+        );
+        return bucketKey;
+      },
+      {
+        successEvent: AnalyticsEvent.PROJECT_UPLOAD_SUCCESS,
+        failureEvent: AnalyticsEvent.PROJECT_UPLOAD_FAIL,
+        trackingCtx: ctx.trackingCtx,
+      }
+    );
+  } finally {
+    if (projectTarballPath) {
+      await fs.remove(projectTarballPath);
+    }
+  }
+}
+
+async function withAnalyticsAsync<Result>(
+  fn: () => Promise<Result>,
+  analytics: {
+    successEvent: AnalyticsEvent;
+    failureEvent: AnalyticsEvent;
+    trackingCtx: TrackingContext;
+  }
+): Promise<Result> {
+  try {
+    const result = await fn();
+    Analytics.logEvent(analytics.successEvent, analytics.trackingCtx);
+    return result;
+  } catch (error) {
+    Analytics.logEvent(analytics.failureEvent, {
+      ...analytics.trackingCtx,
+      reason: error.message,
+    });
+    throw error;
+  }
+}
+
+enum ShouldCommitChanges {
+  Yes,
+  ShowDiffFirst,
+  Abort,
+}
+
+async function reviewAndCommitChangesAsync(
+  commitMessage: string,
+  { nonInteractive, askedFirstTime = true }: { nonInteractive: boolean; askedFirstTime?: boolean }
+): Promise<void> {
+  if (nonInteractive) {
+    throw new Error(
+      'Cannot commit changes when --non-interactive is specified. Run the command in interactive mode to review and commit changes.'
+    );
+  }
+  const { selected } = await promptAsync({
+    type: 'select',
+    name: 'selected',
+    message: 'Can we commit these changes to git for you?',
+    choices: [
+      { title: 'Yes', value: ShouldCommitChanges.Yes },
+      ...(askedFirstTime
+        ? [{ title: 'Show the diff and ask me again', value: ShouldCommitChanges.ShowDiffFirst }]
+        : []),
+      {
+        title: 'Abort build process',
+        value: ShouldCommitChanges.Abort,
+      },
+    ],
+  });
+
+  if (selected === ShouldCommitChanges.Abort) {
+    throw new Error(
+      "Aborting, run the command again once you're ready. Make sure to commit any changes you've made."
+    );
+  } else if (selected === ShouldCommitChanges.Yes) {
+    await commitPromptAsync(commitMessage);
+    Log.withTick('Committed changes.');
+  } else if (selected === ShouldCommitChanges.ShowDiffFirst) {
+    await showDiffAsync();
+    await reviewAndCommitChangesAsync(commitMessage, { nonInteractive, askedFirstTime: false });
+  }
+}

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

@@ -0,0 +1,161 @@
+import { getConfig } from '@expo/config';
+import { EasJsonReader } from '@expo/eas-json';
+import fs from 'fs-extra';
+import path from 'path';
+
+import Log from '../log';
+import { promptAsync } from '../prompts';
+import { ensureLoggedInAsync } from '../user/actions';
+import { gitAddAsync } from '../utils/git';
+import { configureAndroidAsync } from './android/configure';
+import { ConfigureContext } from './context';
+import { configureIosAsync } from './ios/configure';
+import { RequestedPlatform } from './types';
+import {
+  commitPromptAsync,
+  ensureGitRepoExistsAsync,
+  isGitStatusCleanAsync,
+  maybeBailOnGitStatusAsync,
+  showDiffAsync,
+} from './utils/repository';
+
+const configureCommitMessage = {
+  [RequestedPlatform.Android]: 'Configure EAS Build for Android',
+  [RequestedPlatform.iOS]: 'Configure EAS Build for iOS',
+  [RequestedPlatform.All]: 'Configure EAS Build',
+};
+
+export async function configureAsync(options: {
+  platform: RequestedPlatform;
+  projectDir: string;
+  allowExperimental: boolean;
+}): Promise<void> {
+  await ensureGitRepoExistsAsync();
+  await maybeBailOnGitStatusAsync();
+
+  const { exp } = getConfig(options.projectDir, { skipSDKVersionRequirement: true });
+
+  const ctx: ConfigureContext = {
+    user: await ensureLoggedInAsync(),
+    projectDir: options.projectDir,
+    exp,
+    allowExperimental: options.allowExperimental,
+    requestedPlatform: options.platform,
+    shouldConfigureAndroid: [RequestedPlatform.All, RequestedPlatform.Android].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')),
+  };
+
+  Log.newLine();
+  await ensureEasJsonExistsAsync(ctx);
+  if (ctx.shouldConfigureAndroid) {
+    await configureAndroidAsync(ctx);
+  }
+  if (ctx.shouldConfigureIos) {
+    await configureIosAsync(ctx);
+  }
+
+  if (!(await isGitStatusCleanAsync())) {
+    Log.newLine();
+    await reviewAndCommitChangesAsync(configureCommitMessage[options.platform]);
+  } else {
+    Log.newLine();
+    Log.withTick('No changes were necessary, the project is already configured correctly.');
+  }
+}
+
+export async function ensureEasJsonExistsAsync(ctx: ConfigureContext): Promise<void> {
+  const easJsonPath = path.join(ctx.projectDir, 'eas.json');
+  let existingEasJson;
+
+  if (await fs.pathExists(easJsonPath)) {
+    const reader = new EasJsonReader(ctx.projectDir, ctx.requestedPlatform);
+    await reader.validateAsync();
+
+    existingEasJson = await reader.readRawAsync();
+    Log.withTick('Validated eas.json');
+
+    // If we have already populated eas.json with the default fields for the
+    // platform then proceed
+    if (ctx.requestedPlatform !== 'all' && existingEasJson.builds[ctx.requestedPlatform]) {
+      return;
+    } else if (
+      ctx.requestedPlatform === 'all' &&
+      existingEasJson.builds.ios &&
+      existingEasJson.builds.android
+    ) {
+      return;
+    }
+  }
+
+  const shouldInitIOS =
+    ['all', 'ios'].includes(ctx.requestedPlatform) && !existingEasJson?.builds.ios;
+  const shouldInitAndroid =
+    ['all', 'android'].includes(ctx.requestedPlatform) && !existingEasJson?.builds.android;
+
+  const easJson = {
+    builds: {
+      ...existingEasJson,
+      ...(shouldInitAndroid
+        ? {
+            android: {
+              release: {
+                workflow: ctx.hasAndroidNativeProject ? 'generic' : 'managed',
+              },
+            },
+          }
+        : null),
+      ...(shouldInitIOS
+        ? {
+            ios: {
+              release: {
+                workflow: ctx.hasIosNativeProject ? 'generic' : 'managed',
+              },
+            },
+          }
+        : null),
+    },
+  };
+
+  await fs.writeFile(easJsonPath, `${JSON.stringify(easJson, null, 2)}\n`);
+  await gitAddAsync(easJsonPath, { intentToAdd: true });
+  Log.withTick(`${existingEasJson ? 'Updated' : 'Generated'} eas.json`);
+}
+
+enum ShouldCommitChanges {
+  Yes,
+  ShowDiffFirst,
+  Skip,
+}
+
+async function reviewAndCommitChangesAsync(
+  commitMessage: string,
+  askedFirstTime: boolean = true
+): Promise<void> {
+  const { selected } = await promptAsync({
+    type: 'select',
+    name: 'selected',
+    message: 'Can we commit these changes to git for you?',
+    choices: [
+      { title: 'Yes', value: ShouldCommitChanges.Yes },
+      ...(askedFirstTime
+        ? [{ title: 'Show the diff and ask me again', value: ShouldCommitChanges.ShowDiffFirst }]
+        : []),
+      {
+        title: 'Skip committing changes, I will do it later on my own',
+        value: ShouldCommitChanges.Skip,
+      },
+    ],
+  });
+
+  if (selected === ShouldCommitChanges.Yes) {
+    await commitPromptAsync(commitMessage);
+    Log.withTick('Committed changes');
+  } else if (selected === ShouldCommitChanges.ShowDiffFirst) {
+    await showDiffAsync();
+    await reviewAndCommitChangesAsync(commitMessage, false);
+  }
+}

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

@@ -0,0 +1,12 @@
+import { Platform, RequestedPlatform } from './types';
+
+export const platformDisplayNames = {
+  [RequestedPlatform.iOS]: 'iOS',
+  [RequestedPlatform.Android]: 'Android',
+  [RequestedPlatform.All]: 'Android and iOS',
+};
+
+export const platformEmojis = {
+  [Platform.iOS]: '🍎',
+  [Platform.Android]: '🤖',
+};

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

@@ -0,0 +1,114 @@
+import { ExpoConfig, getConfig } from '@expo/config';
+import { AndroidBuildProfile, EasConfig, iOSBuildProfile } from '@expo/eas-json';
+
+import { getProjectAccountName } from '../project/projectUtils';
+import { Actor } from '../user/User';
+import { ensureLoggedInAsync } from '../user/actions';
+import { Platform, RequestedPlatform, TrackingContext } from './types';
+
+export interface CommandContext {
+  requestedPlatform: RequestedPlatform;
+  profile: string;
+  projectDir: string;
+  projectId: string;
+  user: Actor;
+  accountName: string;
+  projectName: string;
+  exp: ExpoConfig;
+  trackingCtx: TrackingContext;
+  nonInteractive: boolean;
+  skipCredentialsCheck: boolean;
+  skipProjectConfiguration: boolean;
+  waitForBuildEnd: boolean;
+}
+
+export async function createCommandContextAsync({
+  requestedPlatform,
+  profile,
+  projectDir,
+  projectId,
+  trackingCtx,
+  nonInteractive = false,
+  skipCredentialsCheck = false,
+  skipProjectConfiguration = false,
+  waitForBuildEnd,
+}: {
+  requestedPlatform: RequestedPlatform;
+  profile: string;
+  projectId: string;
+  projectDir: string;
+  trackingCtx: TrackingContext;
+  nonInteractive: boolean;
+  skipCredentialsCheck: boolean;
+  skipProjectConfiguration: boolean;
+  waitForBuildEnd: boolean;
+}): Promise<CommandContext> {
+  const user = await ensureLoggedInAsync();
+  const { exp } = getConfig(projectDir, { skipSDKVersionRequirement: true });
+  const accountName = getProjectAccountName(exp, user);
+  const projectName = exp.slug;
+
+  return {
+    requestedPlatform,
+    profile,
+    projectDir,
+    projectId,
+    user,
+    accountName,
+    projectName,
+    exp,
+    trackingCtx,
+    nonInteractive,
+    skipCredentialsCheck,
+    skipProjectConfiguration,
+    waitForBuildEnd,
+  };
+}
+
+export interface ConfigureContext {
+  user: Actor;
+  projectDir: string;
+  exp: ExpoConfig;
+  allowExperimental: boolean;
+  requestedPlatform: RequestedPlatform;
+  shouldConfigureAndroid: boolean;
+  shouldConfigureIos: boolean;
+  hasAndroidNativeProject: boolean;
+  hasIosNativeProject: boolean;
+}
+
+type PlatformBuildProfile<T extends Platform> = T extends Platform.Android
+  ? AndroidBuildProfile
+  : iOSBuildProfile;
+
+export interface BuildContext<T extends Platform> {
+  commandCtx: CommandContext;
+  trackingCtx: TrackingContext;
+  platform: T;
+  buildProfile: PlatformBuildProfile<T>;
+}
+
+export function createBuildContext<T extends Platform>({
+  platform,
+  easConfig,
+  commandCtx,
+}: {
+  platform: T;
+  easConfig: EasConfig;
+  commandCtx: CommandContext;
+}): BuildContext<T> {
+  const buildProfile = easConfig.builds[platform] as PlatformBuildProfile<T> | undefined;
+  if (!buildProfile) {
+    throw new Error(`${platform} build profile does not exist`);
+  }
+  const builderTrackingCtx = {
+    ...commandCtx.trackingCtx,
+    platform,
+  };
+  return {
+    commandCtx,
+    trackingCtx: builderTrackingCtx,
+    platform,
+    buildProfile,
+  };
+}

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

@@ -0,0 +1,153 @@
+import { EasJsonReader } from '@expo/eas-json';
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { apiClient } from '../api';
+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 { printBuildResults, printLogsUrls } from './utils/printBuildInfo';
+import { ensureGitRepoExistsAsync, ensureGitStatusIsCleanAsync } from './utils/repository';
+
+export async function buildAsync(commandCtx: CommandContext): Promise<void> {
+  await ensureGitRepoExistsAsync();
+  await ensureGitStatusIsCleanAsync(commandCtx.nonInteractive);
+
+  const scheduledBuilds = await startBuildsAsync(commandCtx);
+  Log.newLine();
+  printLogsUrls(commandCtx.accountName, scheduledBuilds);
+  Log.newLine();
+
+  if (commandCtx.waitForBuildEnd) {
+    const builds = await waitForBuildEndAsync(
+      commandCtx,
+      scheduledBuilds.map(i => i.buildId)
+    );
+    Log.newLine();
+    printBuildResults(commandCtx.accountName, builds);
+  }
+}
+
+async function startBuildsAsync(
+  commandCtx: CommandContext
+): Promise<{ platform: Platform; buildId: string }[]> {
+  const shouldBuildAndroid = [RequestedPlatform.Android, RequestedPlatform.All].includes(
+    commandCtx.requestedPlatform
+  );
+  const shouldBuildiOS = [RequestedPlatform.iOS, RequestedPlatform.All].includes(
+    commandCtx.requestedPlatform
+  );
+  const easConfig = await new EasJsonReader(
+    commandCtx.projectDir,
+    commandCtx.requestedPlatform
+  ).readAsync(commandCtx.profile);
+
+  const builds: {
+    platform: Platform;
+    sendBuildRequestAsync: () => Promise<string>;
+  }[] = [];
+  if (shouldBuildAndroid) {
+    const sendBuildRequestAsync = await prepareAndroidBuildAsync(commandCtx, easConfig);
+    builds.push({ platform: Platform.Android, sendBuildRequestAsync });
+  }
+  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(),
+    }))
+  );
+}
+
+async function waitForBuildEndAsync(
+  commandCtx: CommandContext,
+  buildIds: string[],
+  { timeoutSec = 1800, intervalSec = 30 } = {}
+): Promise<(Build | 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(
+      buildIds.map(async buildId => {
+        try {
+          const { data } = await apiClient
+            .get(`projects/${commandCtx.projectId}/builds/${buildId}`)
+            .json();
+          return data;
+        } catch (err) {
+          return null;
+        }
+      })
+    );
+    if (builds.length === 1) {
+      switch (builds[0]?.status) {
+        case BuildStatus.FINISHED:
+          spinner.succeed('Build finished');
+          return builds;
+        case BuildStatus.IN_QUEUE:
+          spinner.text = 'Build queued...';
+          break;
+        case BuildStatus.CANCELED:
+          spinner.text = 'Build canceled';
+          spinner.stopAndPersist();
+          return builds;
+        case BuildStatus.IN_PROGRESS:
+          spinner.text = 'Build in progress...';
+          break;
+        case BuildStatus.ERRORED:
+          spinner.fail('Build failed');
+          throw new Error(`Standalone build failed!`);
+        default:
+          spinner.warn('Unknown status.');
+          throw new Error(`Unknown status: ${builds} - aborting!`);
+      }
+    } else {
+      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(
+                build.status
+              )
+            : false
+        ).length === builds.length
+      ) {
+        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 unknownState = builds.length - inQueue - inProgress - errored - finished;
+        spinner.text = [
+          inQueue && `Builds in queue: ${inQueue}`,
+          inProgress && `Builds in progress: ${inProgress}`,
+          canceled && `Builds canceled: ${canceled}`,
+          errored && chalk.red(`Builds failed: ${errored}`),
+          finished && chalk.green(`Builds finished: ${finished}`),
+          unknownState && chalk.red(`Builds in unknown state: ${unknownState}`),
+        ]
+          .filter(i => i)
+          .join('\t');
+      }
+    }
+    time = new Date().getTime();
+    await sleep(intervalSec * 1000);
+  }
+  spinner.warn('Timed out');
+  throw new Error(
+    'Timeout reached! It is taking longer than expected to finish the build, aborting...'
+  );
+}

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

@@ -0,0 +1,104 @@
+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);
+  }
+}

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

@@ -0,0 +1,88 @@
+import { ExpoConfig } from '@expo/config';
+import { IOSConfig } from '@expo/config-plugins';
+import fs from 'fs-extra';
+
+import Log from '../../log';
+import { getProjectAccountName } from '../../project/projectUtils';
+import { ensureLoggedInAsync } from '../../user/actions';
+import { gitAddAsync } from '../../utils/git';
+import { ensureValidVersions } from '../utils/updates';
+import { readPlistAsync, writePlistAsync } from './plist';
+
+export async function configureUpdatesAsync(projectDir: string, exp: ExpoConfig): Promise<void> {
+  ensureValidVersions(exp);
+  const accountName = getProjectAccountName(exp, await ensureLoggedInAsync());
+  let xcodeProject = IOSConfig.XcodeUtils.getPbxproj(projectDir);
+
+  if (!IOSConfig.Updates.isShellScriptBuildPhaseConfigured(projectDir, xcodeProject)) {
+    xcodeProject = IOSConfig.Updates.ensureBundleReactNativePhaseContainsConfigurationScript(
+      projectDir,
+      xcodeProject
+    );
+    await fs.writeFile(IOSConfig.Paths.getPBXProjectPath(projectDir), xcodeProject.writeSync());
+  }
+
+  let expoPlist = await readExpoPlistAsync(projectDir);
+  if (!IOSConfig.Updates.isPlistConfigurationSynced(exp, expoPlist, accountName)) {
+    expoPlist = IOSConfig.Updates.setUpdatesConfig(exp, expoPlist, accountName);
+    await writeExpoPlistAsync(projectDir, expoPlist);
+  }
+  // TODO: ensure ExpoPlist in pbxproj
+}
+
+export async function syncUpdatesConfigurationAsync(
+  projectDir: string,
+  exp: ExpoConfig
+): Promise<void> {
+  ensureValidVersions(exp);
+  const accountName = getProjectAccountName(exp, await ensureLoggedInAsync());
+  try {
+    await ensureUpdatesConfiguredAsync(projectDir, exp);
+  } catch (error) {
+    Log.error(
+      'expo-updates module is not configured. Please run "eas build:configure" first to configure the project'
+    );
+    throw error;
+  }
+
+  let expoPlist = await readExpoPlistAsync(projectDir);
+  if (!IOSConfig.Updates.isPlistVersionConfigurationSynced(exp, expoPlist)) {
+    expoPlist = IOSConfig.Updates.setVersionsConfig(exp, expoPlist);
+    await writeExpoPlistAsync(projectDir, expoPlist);
+  }
+
+  if (!IOSConfig.Updates.isPlistConfigurationSynced(exp, expoPlist, accountName)) {
+    Log.warn(
+      'Native project configuration is not synced with values present in your app.json, run "eas build:configure" to make sure all values are applied in the native project'
+    );
+  }
+}
+
+async function ensureUpdatesConfiguredAsync(projectDir: string, exp: ExpoConfig): Promise<void> {
+  const xcodeProject = IOSConfig.XcodeUtils.getPbxproj(projectDir);
+
+  if (!IOSConfig.Updates.isShellScriptBuildPhaseConfigured(projectDir, xcodeProject)) {
+    const script = 'expo-updates/scripts/create-manifest-ios.sh';
+    const buildPhase = '"Bundle React Native code and images"';
+    throw new Error(`Path to ${script} is missing in a ${buildPhase} build phase.`);
+  }
+
+  const expoPlist = await readExpoPlistAsync(projectDir);
+  if (!IOSConfig.Updates.isPlistConfigurationSet(expoPlist)) {
+    throw new Error('Missing values in Expo.plist');
+  }
+}
+
+async function readExpoPlistAsync(projectDir: string): Promise<IOSConfig.ExpoPlist> {
+  const expoPlistPath = IOSConfig.Paths.getExpoPlistPath(projectDir);
+  return await readPlistAsync(expoPlistPath);
+}
+
+async function writeExpoPlistAsync(
+  projectDir: string,
+  expoPlist: IOSConfig.ExpoPlist
+): Promise<void> {
+  const expoPlistPath = IOSConfig.Paths.getExpoPlistPath(projectDir);
+  await writePlistAsync(expoPlistPath, expoPlist);
+  await gitAddAsync(expoPlistPath, { intentToAdd: true });
+}

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

@@ -0,0 +1,200 @@
+import { ExpoConfig } from '@expo/config';
+import fs from 'fs-extra';
+import { vol } from 'memfs';
+import os from 'os';
+
+import { readPlistAsync } from '../plist';
+import { BumpStrategy, bumpVersionAsync, bumpVersionInAppJsonAsync } from '../version';
+
+jest.mock('fs');
+
+const originalConsoleLog = console.log;
+beforeAll(() => {
+  console.log = jest.fn();
+});
+afterAll(() => {
+  console.log = originalConsoleLog;
+  // do not remove the following line
+  // this fixes a weird error with tempy in @expo/image-utils
+  fs.removeSync(os.tmpdir());
+});
+
+beforeEach(() => {
+  vol.reset();
+  // do not remove the following line
+  // this fixes a weird error with tempy in @expo/image-utils
+  fs.mkdirpSync(os.tmpdir());
+});
+
+// generic workflow
+describe(bumpVersionAsync, () => {
+  it('bumps expo.ios.buildNumber and CFBundleVersion when strategy = BumpStrategy.BUILD_NUMBER', async () => {
+    const fakeExp = initGenericProject();
+
+    await bumpVersionAsync({
+      bumpStrategy: BumpStrategy.BUILD_NUMBER,
+      projectDir: '/repo',
+      exp: fakeExp,
+    });
+
+    const appJSON = await fs.readJSON('/repo/app.json');
+    const infoPlist = await readPlistAsync('/repo/ios/myproject/Info.plist');
+    expect(fakeExp.version).toBe('1.0.0');
+    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');
+    expect(infoPlist['CFBundleVersion']).toBe('2');
+  });
+
+  it('bumps expo.version and CFBundleShortVersionString when strategy = BumpStrategy.SHORT_VERSION', async () => {
+    const fakeExp = initGenericProject();
+
+    await bumpVersionAsync({
+      bumpStrategy: BumpStrategy.SHORT_VERSION,
+      projectDir: '/repo',
+      exp: fakeExp,
+    });
+
+    const appJSON = await fs.readJSON('/repo/app.json');
+    const infoPlist = await readPlistAsync('/repo/ios/myproject/Info.plist');
+    expect(fakeExp.version).toBe('1.0.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');
+    expect(infoPlist['CFBundleVersion']).toBe('1');
+  });
+
+  it('does not bump any version when strategy = BumpStrategy.NOOP', async () => {
+    const fakeExp = initGenericProject();
+
+    await bumpVersionAsync({
+      bumpStrategy: BumpStrategy.NOOP,
+      projectDir: '/repo',
+      exp: fakeExp,
+    });
+
+    const appJSON = await fs.readJSON('/repo/app.json');
+    const infoPlist = await readPlistAsync('/repo/ios/myproject/Info.plist');
+    expect(fakeExp.version).toBe('1.0.0');
+    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');
+    expect(infoPlist['CFBundleVersion']).toBe('1');
+  });
+});
+
+// managed workflow
+describe(bumpVersionInAppJsonAsync, () => {
+  it('bumps expo.ios.buildNumber when strategy = BumpStrategy.BUILD_NUMBER', async () => {
+    const fakeExp = initManagedProject();
+
+    await bumpVersionInAppJsonAsync({
+      bumpStrategy: BumpStrategy.BUILD_NUMBER,
+      projectDir: '/repo',
+      exp: fakeExp,
+    });
+
+    const appJSON = await fs.readJSON('/repo/app.json');
+    expect(fakeExp.version).toBe('1.0.0');
+    expect(fakeExp.ios.buildNumber).toBe('2');
+    expect(appJSON.expo.version).toBe('1.0.0');
+    expect(appJSON.expo.ios.buildNumber).toBe('2');
+  });
+
+  it('bumps expo.version when strategy = BumpStrategy.SHORT_VERSION', async () => {
+    const fakeExp = initManagedProject();
+
+    await bumpVersionInAppJsonAsync({
+      bumpStrategy: BumpStrategy.SHORT_VERSION,
+      projectDir: '/repo',
+      exp: fakeExp,
+    });
+
+    const appJSON = await fs.readJSON('/repo/app.json');
+    expect(fakeExp.version).toBe('1.0.1');
+    expect(fakeExp.ios.buildNumber).toBe('1');
+    expect(appJSON.expo.version).toBe('1.0.1');
+    expect(appJSON.expo.ios.buildNumber).toBe('1');
+  });
+
+  it('does not bump any version when strategy = BumpStrategy.NOOP', async () => {
+    const fakeExp = initManagedProject();
+
+    await bumpVersionInAppJsonAsync({
+      bumpStrategy: BumpStrategy.NOOP,
+      projectDir: '/repo',
+      exp: fakeExp,
+    });
+
+    const appJSON = await fs.readJSON('/repo/app.json');
+    expect(fakeExp.version).toBe('1.0.0');
+    expect(fakeExp.ios.buildNumber).toBe('1');
+    expect(appJSON.expo.version).toBe('1.0.0');
+    expect(appJSON.expo.ios.buildNumber).toBe('1');
+  });
+});
+
+function initGenericProject(): ExpoConfig {
+  vol.fromJSON(
+    {
+      './app.json': JSON.stringify({
+        expo: {
+          version: '1.0.0',
+          ios: {
+            buildNumber: '1',
+          },
+        },
+      }),
+      './ios/myproject/Info.plist': `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleShortVersionString</key>
+  <string>1.0.0</string>
+  <key>CFBundleVersion</key>
+  <string>1</string>
+</dict>
+</plist>`,
+    },
+    '/repo'
+  );
+
+  const fakeExp: ExpoConfig = {
+    name: 'myproject',
+    slug: 'myproject',
+    version: '1.0.0',
+    ios: {
+      buildNumber: '1',
+    },
+  };
+  return fakeExp;
+}
+
+function initManagedProject(): ExpoConfig {
+  vol.fromJSON(
+    {
+      './app.json': JSON.stringify({
+        expo: {
+          version: '1.0.0',
+          ios: {
+            buildNumber: '1',
+          },
+        },
+      }),
+    },
+    '/repo'
+  );
+
+  const fakeExp: ExpoConfig = {
+    name: 'myproject',
+    slug: 'myproject',
+    version: '1.0.0',
+    ios: {
+      buildNumber: '1',
+    },
+  };
+  return fakeExp;
+}

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

@@ -0,0 +1,104 @@
+import { IOSConfig } from '@expo/config-plugins';
+import { 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 Log from '../../log';
+import { promptAsync } from '../../prompts';
+import { prepareBuildRequestForPlatformAsync } from '../build';
+import { BuildContext, CommandContext, createBuildContext } from '../context';
+import { Platform } from '../types';
+import { ensureBundleIdentifierIsValidAsync } from './bundleIdentifer';
+import { validateAndSyncProjectConfigurationAsync } from './configure';
+import { ensureIosCredentialsAsync } from './credentials';
+import { prepareJobAsync } from './prepareJob';
+
+export async function prepareIosBuildAsync(
+  commandCtx: CommandContext,
+  easConfig: EasConfig
+): Promise<() => Promise<string>> {
+  const buildCtx = createBuildContext<Platform.iOS>({
+    commandCtx,
+    platform: Platform.iOS,
+    easConfig,
+  });
+
+  if (
+    buildCtx.buildProfile.workflow === Workflow.Generic &&
+    !(await fs.pathExists(path.join(commandCtx.projectDir, 'ios')))
+  ) {
+    throw new Error(
+      `"ios" directory not found. If you're trying to build a managed project, set ${chalk.bold(
+        `builds.ios.${commandCtx.profile}.workflow`
+      )} in "eas.json" to "managed".`
+    );
+  }
+
+  let iosBuildScheme: string | undefined;
+  let iosApplicationTarget: string | undefined;
+  if (buildCtx.buildProfile.workflow === Workflow.Generic) {
+    iosBuildScheme = buildCtx.buildProfile.scheme ?? (await resolveSchemeAsync(buildCtx));
+    iosApplicationTarget = await IOSConfig.BuildScheme.getApplicationTargetForSchemeAsync(
+      buildCtx.commandCtx.projectDir,
+      iosBuildScheme
+    );
+  }
+
+  await ensureBundleIdentifierIsValidAsync(commandCtx.projectDir);
+
+  return await prepareBuildRequestForPlatformAsync({
+    ctx: buildCtx,
+    projectConfiguration: {
+      iosBuildScheme,
+      iosApplicationTarget,
+    },
+    ensureCredentialsAsync: ensureIosCredentialsAsync,
+    ensureProjectConfiguredAsync: async () => {
+      await validateAndSyncProjectConfigurationAsync({
+        projectDir: commandCtx.projectDir,
+        exp: commandCtx.exp,
+        buildProfile: buildCtx.buildProfile,
+      });
+    },
+    prepareJobAsync,
+  });
+}
+
+async function resolveSchemeAsync(ctx: BuildContext<Platform.iOS>): Promise<string> {
+  const schemes = IOSConfig.BuildScheme.getSchemesFromXcodeproj(ctx.commandCtx.projectDir);
+  if (schemes.length === 1) {
+    return schemes[0];
+  }
+
+  const sortedSchemes = sortBy(schemes);
+  Log.newLine();
+  Log.log(
+    `We've found multiple schemes in your Xcode project: ${chalk.bold(sortedSchemes.join(', '))}`
+  );
+  Log.log(
+    `You can specify the scheme you want to build at ${chalk.bold(
+      `builds.ios.${ctx.commandCtx.profile}.scheme`
+    )} in eas.json.`
+  );
+  if (ctx.commandCtx.nonInteractive) {
+    const withoutTvOS = sortedSchemes.filter(i => !i.includes('tvOS'));
+    const scheme = withoutTvOS.length > 0 ? withoutTvOS[0] : sortedSchemes[0];
+    Log.log(
+      `You've run Expo CLI in non-interactive mode, choosing the ${chalk.bold(scheme)} scheme.`
+    );
+    Log.newLine();
+    return scheme;
+  } else {
+    const { selectedScheme } = await promptAsync({
+      type: 'select',
+      name: 'selectedScheme',
+      message: 'Which scheme would you like to build now?',
+      choices: sortedSchemes.map(scheme => ({ title: scheme, value: scheme })),
+    });
+    Log.newLine();
+    return selectedScheme as string;
+  }
+}

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

@@ -0,0 +1,134 @@
+import { ExpoConfig, getConfigFilePaths } from '@expo/config';
+import { IOSConfig } from '@expo/config-plugins';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+
+import Log from '../../log';
+import {
+  ensureAppIdentifierIsDefinedAsync,
+  getProjectConfigDescription,
+} from '../../project/projectUtils';
+import { promptAsync } from '../../prompts';
+import { Platform } from '../types';
+import { updateAppJsonConfigAsync } from '../utils/appJson';
+
+enum BundleIdentiferSource {
+  XcodeProject,
+  AppJson,
+}
+
+function isBundleIdentifierValid(bundleIdentifier: string): boolean {
+  return /^[a-zA-Z][a-zA-Z0-9\-.]+$/.test(bundleIdentifier);
+}
+
+export async function ensureBundleIdentifierIsValidAsync(projectDir: string) {
+  const bundleIdentifier = await ensureAppIdentifierIsDefinedAsync(projectDir, Platform.iOS);
+  if (!isBundleIdentifierValid(bundleIdentifier)) {
+    const configDescription = getProjectConfigDescription(projectDir);
+    Log.error(
+      `Invalid format of iOS bundleId. Only alphanumeric characters, '.' and '-' are allowed, and each '.' must be followed by a letter.`
+    );
+    Log.error(`Update "ios.bundleIdentifier" in ${configDescription} and run this command again.`);
+    throw new Error('Invalid bundleIdentifier');
+  }
+}
+
+export async function configureBundleIdentifierAsync(
+  projectDir: string,
+  exp: ExpoConfig
+): Promise<void> {
+  const configDescription = getProjectConfigDescription(projectDir);
+  const bundleIdentifierFromPbxproj = IOSConfig.BundleIdentifier.getBundleIdentifierFromPbxproj(
+    projectDir
+  );
+  const bundleIdentifierFromConfig = IOSConfig.BundleIdentifier.getBundleIdentifier(exp);
+  if (bundleIdentifierFromPbxproj && bundleIdentifierFromConfig) {
+    if (bundleIdentifierFromPbxproj !== bundleIdentifierFromConfig) {
+      Log.addNewLineIfNone();
+      Log.warn(
+        `We detected that your Xcode project is configured with a different bundle identifier than the one defined in ${configDescription}.`
+      );
+      const hasBundleIdentifierInStaticConfig = await hasBundleIdentifierInStaticConfigAsync(
+        projectDir,
+        exp
+      );
+      if (!hasBundleIdentifierInStaticConfig) {
+        Log.log(`If you choose the one defined in ${configDescription} we'll automatically configure your Xcode project with it.
+However, if you choose the one defined in the Xcode project you'll have to update ${configDescription} on your own.`);
+      }
+      Log.newLine();
+      const { bundleIdentifierSource } = await promptAsync({
+        type: 'select',
+        name: 'bundleIdentifierSource',
+        message: 'Which bundle identifier should we use?',
+        choices: [
+          {
+            title: `${chalk.bold(bundleIdentifierFromPbxproj)} - In Xcode project`,
+            value: BundleIdentiferSource.XcodeProject,
+          },
+          {
+            title: `${chalk.bold(bundleIdentifierFromConfig)} - In your ${configDescription}`,
+            value: BundleIdentiferSource.AppJson,
+          },
+        ],
+      });
+      switch (bundleIdentifierSource) {
+        case BundleIdentiferSource.AppJson: {
+          IOSConfig.BundleIdentifier.setBundleIdentifierForPbxproj(
+            projectDir,
+            bundleIdentifierFromConfig
+          );
+          break;
+        }
+        case BundleIdentiferSource.XcodeProject: {
+          if (hasBundleIdentifierInStaticConfig) {
+            await updateAppJsonConfigAsync({ projectDir, exp }, config => {
+              config.ios = { ...config.ios, bundleIdentifier: bundleIdentifierFromPbxproj };
+            });
+          } else {
+            throw new Error(missingBundleIdentifierMessage(configDescription));
+          }
+          break;
+        }
+      }
+    }
+  } else if (!bundleIdentifierFromPbxproj && !bundleIdentifierFromConfig) {
+    throw new Error(missingBundleIdentifierMessage(configDescription));
+  } else if (bundleIdentifierFromPbxproj && !bundleIdentifierFromConfig) {
+    if (getConfigFilePaths(projectDir).staticConfigPath) {
+      await updateAppJsonConfigAsync({ projectDir, exp }, config => {
+        config.ios = { ...config.ios, bundleIdentifier: bundleIdentifierFromPbxproj };
+      });
+    } else {
+      throw new Error(missingBundleIdentifierMessage(configDescription));
+    }
+  } else if (!bundleIdentifierFromPbxproj && bundleIdentifierFromConfig) {
+    IOSConfig.BundleIdentifier.setBundleIdentifierForPbxproj(
+      projectDir,
+      bundleIdentifierFromConfig
+    );
+  }
+}
+
+function missingBundleIdentifierMessage(configDescription: string): string {
+  return `Please define "ios.bundleIdentifier" in ${configDescription} and run "eas build:configure" again.`;
+}
+
+/**
+ * Check if static config exists and if ios.bundleIdentifier is defined there.
+ * It will return false if the value in static config is different than "ios.bundleIdentifier" in ExpoConfig
+ */
+async function hasBundleIdentifierInStaticConfigAsync(
+  projectDir: string,
+  exp: ExpoConfig
+): Promise<boolean> {
+  if (!exp.ios?.bundleIdentifier) {
+    return false;
+  }
+  const paths = getConfigFilePaths(projectDir);
+  if (!paths.staticConfigPath) {
+    return false;
+  }
+  const rawStaticConfig = await fs.readJson(paths.staticConfigPath);
+  return rawStaticConfig?.expo?.ios?.bundleIdentifier === exp.ios.bundleIdentifier;
+}

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

@@ -0,0 +1,69 @@
+import { ExpoConfig } from '@expo/config';
+import { IOSConfig } from '@expo/config-plugins';
+import { Workflow } from '@expo/eas-build-job';
+import { VersionAutoIncrement, iOSBuildProfile } from '@expo/eas-json';
+
+import Log from '../../log';
+import { ConfigureContext } from '../context';
+import { isExpoUpdatesInstalled } from '../utils/updates';
+import { configureUpdatesAsync, syncUpdatesConfigurationAsync } from './UpdatesModule';
+import {
+  configureBundleIdentifierAsync,
+  ensureBundleIdentifierIsValidAsync,
+} from './bundleIdentifer';
+import { BumpStrategy, bumpVersionAsync, bumpVersionInAppJsonAsync } from './version';
+
+export async function configureIosAsync(ctx: ConfigureContext): Promise<void> {
+  if (!ctx.hasIosNativeProject) {
+    return;
+  }
+  await configureBundleIdentifierAsync(ctx.projectDir, ctx.exp);
+  await ensureBundleIdentifierIsValidAsync(ctx.projectDir);
+
+  if (isExpoUpdatesInstalled(ctx.projectDir)) {
+    await configureUpdatesAsync(ctx.projectDir, ctx.exp);
+  }
+  Log.withTick('iOS project configured');
+}
+
+export async function validateAndSyncProjectConfigurationAsync({
+  projectDir,
+  exp,
+  buildProfile,
+}: {
+  projectDir: string;
+  exp: ExpoConfig;
+  buildProfile: iOSBuildProfile;
+}): Promise<void> {
+  const { workflow, autoIncrement } = buildProfile;
+  const versionBumpStrategy = resolveVersionBumpStrategy(autoIncrement);
+
+  if (workflow === Workflow.Generic) {
+    const bundleIdentifierFromPbxproj = IOSConfig.BundleIdentifier.getBundleIdentifierFromPbxproj(
+      projectDir
+    );
+    if (!bundleIdentifierFromPbxproj || bundleIdentifierFromPbxproj !== exp.ios?.bundleIdentifier) {
+      throw new Error(
+        'Bundle identifier is not configured correctly in your Xcode project. Please run "eas build:configure" to configure it.'
+      );
+    }
+    if (isExpoUpdatesInstalled(projectDir)) {
+      await syncUpdatesConfigurationAsync(projectDir, exp);
+    }
+    await bumpVersionAsync({ projectDir, exp, bumpStrategy: versionBumpStrategy });
+  } else {
+    await bumpVersionInAppJsonAsync({ projectDir, exp, bumpStrategy: versionBumpStrategy });
+  }
+}
+
+function resolveVersionBumpStrategy(autoIncrement: VersionAutoIncrement): BumpStrategy {
+  if (autoIncrement === true) {
+    return BumpStrategy.BUILD_NUMBER;
+  } else if (autoIncrement === false) {
+    return BumpStrategy.NOOP;
+  } else if (autoIncrement === 'buildNumber') {
+    return BumpStrategy.BUILD_NUMBER;
+  } else {
+    return BumpStrategy.SHORT_VERSION;
+  }
+}

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

@@ -0,0 +1,73 @@
+import { Workflow } from '@expo/eas-build-job';
+import { CredentialsSource, DistributionType } from '@expo/eas-json';
+import assert from 'assert';
+
+import { createCredentialsContextAsync } from '../../credentials/context';
+import IosCredentialsProvider, {
+  IosCredentials,
+} from '../../credentials/ios/IosCredentialsProvider';
+import { AppLookupParams } from '../../credentials/ios/credentials';
+import { CredentialsResult } from '../build';
+import { BuildContext } from '../context';
+import { ensureCredentialsAsync } from '../credentials';
+import { Platform } from '../types';
+
+export async function ensureIosCredentialsAsync(
+  ctx: BuildContext<Platform.iOS>
+): Promise<CredentialsResult<IosCredentials> | undefined> {
+  if (!shouldProvideCredentials(ctx)) {
+    return;
+  }
+  assert(ctx.commandCtx.exp?.ios?.bundleIdentifier, 'ios.bundleIdentifier is required');
+  return await resolveIosCredentialsAsync(ctx.commandCtx.projectDir, {
+    app: {
+      accountName: ctx.commandCtx.accountName,
+      projectName: ctx.commandCtx.projectName,
+      bundleIdentifier: ctx.commandCtx.exp.ios.bundleIdentifier,
+    },
+    workflow: ctx.buildProfile.workflow,
+    credentialsSource: ctx.buildProfile.credentialsSource,
+    distribution: ctx.buildProfile.distribution ?? DistributionType.STORE,
+    nonInteractive: ctx.commandCtx.nonInteractive,
+    skipCredentialsCheck: ctx.commandCtx.skipCredentialsCheck,
+  });
+}
+
+interface ResolveCredentialsParams {
+  app: AppLookupParams;
+  workflow: Workflow;
+  credentialsSource: CredentialsSource;
+  distribution: DistributionType;
+  nonInteractive: boolean;
+  skipCredentialsCheck: boolean;
+}
+
+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
+  );
+  return {
+    credentials: await provider.getCredentialsAsync(credentialsSource),
+    source: credentialsSource,
+  };
+}
+
+function shouldProvideCredentials(ctx: BuildContext<Platform.iOS>): boolean {
+  return true;
+}

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

@@ -0,0 +1,22 @@
+import { IOSConfig } from '@expo/config-plugins';
+import plist from '@expo/plist';
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function readPlistAsync(plistPath: string): Promise<object> {
+  if (await fs.pathExists(plistPath)) {
+    const expoPlistContent = await fs.readFile(plistPath, 'utf8');
+    return plist.parse(expoPlistContent);
+  } else {
+    return {};
+  }
+}
+
+export async function writePlistAsync(
+  plistPath: string,
+  plistObject: IOSConfig.ExpoPlist | IOSConfig.InfoPlist
+): Promise<void> {
+  const contents = plist.build(plistObject);
+  await fs.mkdirp(path.dirname(plistPath));
+  await fs.writeFile(plistPath, contents);
+}

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

@@ -0,0 +1,168 @@
+import {
+  ArchiveSource,
+  ArchiveSourceType,
+  Job,
+  Workflow,
+  iOS,
+  sanitizeJob,
+} from '@expo/eas-build-job';
+import { iOSGenericBuildProfile, iOSManagedBuildProfile } from '@expo/eas-json';
+import assert from 'assert';
+import path from 'path';
+
+import {
+  IosCredentials,
+  IosTargetCredentials,
+  isCredentialsMap,
+  readSecretEnvsAsync,
+} 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;
+  credentials?: IosCredentials;
+  projectConfiguration: {
+    iosBuildScheme?: string;
+    iosApplicationTarget?: string;
+  };
+}
+
+export async function prepareJobAsync(
+  ctx: BuildContext<Platform.iOS>,
+  jobData: JobData
+): Promise<Job> {
+  if (ctx.buildProfile.workflow === Workflow.Generic) {
+    const partialJob = await prepareGenericJobAsync(ctx, jobData, ctx.buildProfile);
+    return sanitizeJob(partialJob);
+  } else if (ctx.buildProfile.workflow === Workflow.Managed) {
+    const partialJob = await prepareManagedJobAsync(ctx, jobData, ctx.buildProfile);
+    return sanitizeJob(partialJob);
+  } else {
+    throw new Error("Unknown workflow. Shouldn't happen");
+  }
+}
+
+interface CommonJobProperties {
+  platform: Platform.iOS;
+  projectArchive: ArchiveSource;
+  builderEnvironment: iOS.BuilderEnvironment;
+  releaseChannel: string;
+  secrets: {
+    buildCredentials: iOS.BuildCredentials;
+    secretEnvs?: Record<string, string>;
+  };
+}
+
+async function prepareJobCommonAsync(
+  ctx: BuildContext<Platform.iOS>,
+  {
+    archiveBucketKey,
+    credentials,
+    targetName,
+  }: { archiveBucketKey: string; credentials?: IosCredentials; targetName?: string }
+): Promise<Partial<CommonJobProperties>> {
+  const secretEnvs = await readSecretEnvsAsync(ctx.commandCtx.projectDir);
+
+  let buildCredentials: CommonJobProperties['secrets']['buildCredentials'] = {};
+  if (credentials && isCredentialsMap(credentials)) {
+    const targets = Object.keys(credentials);
+    for (const target of targets) {
+      buildCredentials[target] = prepareTargetCredentials(credentials[target]);
+    }
+  } else if (credentials) {
+    // targetName
+    // - for managed projects: sanitized .name from the app config
+    // - for generic projects: name of the application target
+    assert(targetName, 'target name should be defined');
+    buildCredentials = {
+      [targetName]: prepareTargetCredentials(credentials),
+    };
+  }
+
+  return {
+    platform: Platform.iOS,
+    projectArchive: {
+      type: ArchiveSourceType.S3,
+      bucketKey: archiveBucketKey,
+    },
+    builderEnvironment: {
+      image: ctx.buildProfile.image,
+      node: ctx.buildProfile.node,
+      yarn: ctx.buildProfile.yarn,
+      cocoapods: ctx.buildProfile.cocoapods,
+      fastlane: ctx.buildProfile.fastlane,
+      env: ctx.buildProfile.env,
+    },
+    secrets: {
+      ...(secretEnvs ? { secretEnvs } : {}),
+      buildCredentials,
+    },
+  };
+}
+
+function prepareTargetCredentials(targetCredentials: IosTargetCredentials): iOS.TargetCredentials {
+  return {
+    provisioningProfileBase64: targetCredentials.provisioningProfile,
+    distributionCertificate: {
+      dataBase64: targetCredentials.distributionCertificate.certP12,
+      password: targetCredentials.distributionCertificate.certPassword,
+    },
+  };
+}
+
+async function prepareGenericJobAsync(
+  ctx: BuildContext<Platform.iOS>,
+  jobData: JobData,
+  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,
+    })),
+    type: Workflow.Generic,
+    scheme: jobData.projectConfiguration.iosBuildScheme,
+    schemeBuildConfiguration: buildProfile.schemeBuildConfiguration,
+    artifactPath: buildProfile.artifactPath,
+    releaseChannel: buildProfile.releaseChannel,
+    projectRootDirectory,
+  };
+}
+
+async function prepareManagedJobAsync(
+  ctx: BuildContext<Platform.iOS>,
+  jobData: JobData,
+  buildProfile: iOSManagedBuildProfile
+): Promise<Partial<iOS.ManagedJob>> {
+  const projectRootDirectory =
+    path.relative(await gitRootDirectoryAsync(), ctx.commandCtx.projectDir) || '.';
+  const accountName = await getProjectAccountNameAsync(ctx.commandCtx.projectDir);
+  const targetName = sanitizedName(ctx.commandCtx.exp.name);
+  return {
+    ...(await prepareJobCommonAsync(ctx, {
+      archiveBucketKey: jobData.archiveBucketKey,
+      credentials: jobData.credentials,
+      targetName,
+    })),
+    type: Workflow.Managed,
+    buildType: buildProfile.buildType,
+    username: accountName,
+    releaseChannel: buildProfile.releaseChannel,
+    projectRootDirectory,
+  };
+}
+
+// copy-pasted from expo-cli/packages/xdl/src/Exp.ts
+// it's used in eject
+function sanitizedName(name: string) {
+  return name
+    .replace(/[\W_]+/g, '')
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '');
+}

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

@@ -0,0 +1,139 @@
+import { ExpoConfig, getConfigFilePaths } from '@expo/config';
+import { IOSConfig } from '@expo/config-plugins';
+import chalk from 'chalk';
+import nullthrows from 'nullthrows';
+import semver from 'semver';
+
+import Log from '../../log';
+import { promptAsync } from '../../prompts';
+import { updateAppJsonConfigAsync } from '../utils/appJson';
+import { readPlistAsync, writePlistAsync } from './plist';
+
+export enum BumpStrategy {
+  SHORT_VERSION,
+  BUILD_NUMBER,
+  NOOP,
+}
+
+export async function bumpVersionAsync({
+  bumpStrategy,
+  projectDir,
+  exp,
+}: {
+  projectDir: string;
+  exp: ExpoConfig;
+  bumpStrategy: BumpStrategy;
+}): Promise<void> {
+  if (bumpStrategy === BumpStrategy.NOOP) {
+    return;
+  }
+  ensureStaticConfigExists(projectDir);
+  const infoPlist = await readInfoPlistAsync(projectDir);
+  await bumpVersionInAppJsonAsync({ bumpStrategy, projectDir, exp });
+  Log.log('Updated versions in app.json');
+  await writeVersionsToInfoPlistAsync({ projectDir, exp, infoPlist });
+  Log.log('Synchronized versions with Info.plist');
+}
+
+export async function bumpVersionInAppJsonAsync({
+  bumpStrategy,
+  projectDir,
+  exp,
+}: {
+  bumpStrategy: BumpStrategy;
+  projectDir: string;
+  exp: ExpoConfig;
+}): Promise<void> {
+  if (bumpStrategy === BumpStrategy.NOOP) {
+    return;
+  }
+  ensureStaticConfigExists(projectDir);
+  Log.addNewLineIfNone();
+  if (bumpStrategy === BumpStrategy.SHORT_VERSION) {
+    const shortVersion = IOSConfig.Version.getVersion(exp);
+    if (semver.valid(shortVersion)) {
+      const bumpedShortVersion = nullthrows(semver.inc(shortVersion, 'patch'));
+      Log.log(
+        `Bumping ${chalk.bold('expo.version')} from ${chalk.bold(shortVersion)} to ${chalk.bold(
+          bumpedShortVersion
+        )}`
+      );
+      await updateAppJsonConfigAsync({ projectDir, exp }, config => {
+        config.version = bumpedShortVersion;
+      });
+    } else {
+      Log.log(`${chalk.bold('expo.version')} = ${chalk.bold(shortVersion)} is not a valid semver`);
+      const { bumpedShortVersion } = await promptAsync({
+        type: 'text',
+        name: 'bumpedShortVersion',
+        message: 'What is the next version?',
+      });
+      await updateAppJsonConfigAsync({ projectDir, exp }, config => {
+        config.version = bumpedShortVersion;
+      });
+    }
+  } else {
+    const buildNumber = IOSConfig.Version.getBuildNumber(exp);
+    if (buildNumber.match(/^\d+(\.\d+)*$/)) {
+      const comps = buildNumber.split('.');
+      comps[comps.length - 1] = String(Number(comps[comps.length - 1]) + 1);
+      const bumpedBuildNumber = comps.join('.');
+      Log.log(
+        `Bumping ${chalk.bold('expo.ios.buildNumber')} from ${chalk.bold(
+          buildNumber
+        )} to ${chalk.bold(bumpedBuildNumber)}`
+      );
+      await updateAppJsonConfigAsync({ projectDir, exp }, config => {
+        config.ios = { ...config.ios, buildNumber: String(bumpedBuildNumber) };
+      });
+    } else {
+      Log.log(`${chalk.bold('expo.ios.buildNumber')} = ${chalk.bold(buildNumber)} is not a number`);
+      const { bumpedBuildNumber } = await promptAsync({
+        type: 'text',
+        name: 'bumpedBuildNumber',
+        message: 'What is the next build number?',
+      });
+      await updateAppJsonConfigAsync({ projectDir, exp }, config => {
+        config.ios = { ...config.ios, buildNumber: String(bumpedBuildNumber) };
+      });
+    }
+  }
+}
+
+async function readInfoPlistAsync(projectDir: string): Promise<IOSConfig.InfoPlist> {
+  const infoPlistPath = IOSConfig.Paths.getInfoPlistPath(projectDir);
+  return await readPlistAsync(infoPlistPath);
+}
+
+async function writeVersionsToInfoPlistAsync({
+  projectDir,
+  exp,
+  infoPlist,
+}: {
+  projectDir: string;
+  exp: ExpoConfig;
+  infoPlist: IOSConfig.InfoPlist;
+}): Promise<IOSConfig.InfoPlist> {
+  let updatedInfoPlist = IOSConfig.Version.setVersion(exp, infoPlist);
+  updatedInfoPlist = IOSConfig.Version.setBuildNumber(exp, updatedInfoPlist);
+  await writeInfoPlistAsync({ projectDir, infoPlist: updatedInfoPlist });
+  return updatedInfoPlist;
+}
+
+async function writeInfoPlistAsync({
+  projectDir,
+  infoPlist,
+}: {
+  projectDir: string;
+  infoPlist: IOSConfig.InfoPlist;
+}): Promise<void> {
+  const infoPlistPath = IOSConfig.Paths.getInfoPlistPath(projectDir);
+  await writePlistAsync(infoPlistPath, infoPlist);
+}
+
+function ensureStaticConfigExists(projectDir: string): void {
+  const paths = getConfigFilePaths(projectDir);
+  if (!paths.staticConfigPath) {
+    throw new Error('autoIncrement option is not supported when using app.config.js');
+  }
+}

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

@@ -0,0 +1,34 @@
+import { CredentialsSource, DistributionType } from '@expo/eas-json';
+
+import { getAppIdentifierAsync } from '../project/projectUtils';
+import { BuildContext } from './context';
+import { BuildMetadata, Platform } from './types';
+
+/**
+ * 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');
+
+export async function collectMetadata<T extends Platform>(
+  ctx: BuildContext<T>,
+  {
+    credentialsSource,
+  }: {
+    credentialsSource?: CredentialsSource.LOCAL | CredentialsSource.REMOTE;
+  }
+): Promise<BuildMetadata> {
+  return {
+    appVersion: ctx.commandCtx.exp.version!,
+    cliVersion: packageJSON.version,
+    workflow: ctx.buildProfile.workflow,
+    credentialsSource,
+    sdkVersion: ctx.commandCtx.exp.sdkVersion,
+    trackingContext: ctx.trackingCtx,
+    distribution: ctx.buildProfile.distribution ?? DistributionType.STORE,
+    appName: ctx.commandCtx.exp.name,
+    appIdentifier:
+      (await getAppIdentifierAsync(ctx.commandCtx.projectDir, ctx.platform)) ?? undefined,
+  };
+}

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

@@ -0,0 +1,125 @@
+import { Platform, Workflow } from '@expo/eas-build-job';
+import {
+  AndroidBuildProfile,
+  CredentialsSource,
+  DistributionType,
+  iOSBuildProfile,
+} from '@expo/eas-json';
+
+export enum RequestedPlatform {
+  Android = 'android',
+  iOS = 'ios',
+  All = 'all',
+}
+
+export { Platform };
+
+export enum BuildStatus {
+  IN_QUEUE = 'in-queue',
+  IN_PROGRESS = 'in-progress',
+  ERRORED = 'errored',
+  FINISHED = 'finished',
+  CANCELED = 'canceled',
+}
+
+export type TrackingContext = Record<string, string | number>;
+
+export interface Build {
+  id: string;
+  status: BuildStatus;
+  platform: Platform;
+  createdAt: string;
+  updatedAt: string;
+  artifacts?: BuildArtifacts;
+  metadata?: Partial<BuildMetadata>;
+}
+
+interface BuildArtifacts {
+  buildUrl?: string;
+  logsUrl: string;
+}
+
+export type BuildMetadata = {
+  /**
+   * Application version (the expo.version key in app.json/app.config.js)
+   */
+  appVersion: string;
+
+  /**
+   * EAS CLI version
+   */
+  cliVersion: string;
+
+  /**
+   * Build workflow
+   * It's either 'generic' or 'managed'
+   */
+  workflow: Workflow;
+
+  /**
+   * Credentials source
+   * Credentials could be obtained either from credential.json or EAS servers.
+   */
+  credentialsSource?: CredentialsSource.LOCAL | CredentialsSource.REMOTE;
+
+  /**
+   * Expo SDK version
+   * It's determined by the expo package version in package.json.
+   * It's undefined if the expo package is not installed for the project.
+   */
+  sdkVersion?: string;
+
+  /**
+   * Release channel (for expo-updates)
+   * It's undefined if the expo-updates package is not installed for the project.
+   */
+  releaseChannel?: string;
+
+  /**
+   * Tracking context
+   * It's used to track build process across different Expo services and tools.
+   */
+  trackingContext: TrackingContext;
+
+  /**
+   * Distribution type
+   * Indicates whether this is a build for store or internal distribution.
+   */
+  distribution: DistributionType;
+
+  /**
+   * App name (expo.name in app.json/app.config.js)
+   */
+  appName?: string;
+
+  /**
+   * App identifier:
+   * - iOS builds: the bundle identifier (expo.ios.bundleIdentifier in app.json/app.config.js)
+   * - Android builds: the application id (expo.android.package in app.json/app.config.js)
+   */
+  appIdentifier?: 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',
+}

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

@@ -0,0 +1,3 @@
+export default {
+  logEvent: (a: any, b: any) => {},
+};

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

@@ -0,0 +1,25 @@
+// import { ExpoConfig, getConfigFilePaths } from '@expo/config';
+import * as ExpoConfig from '@expo/config';
+import assert from 'assert';
+import fs from 'fs-extra';
+
+export async function updateAppJsonConfigAsync(
+  {
+    projectDir,
+    exp,
+  }: {
+    projectDir: string;
+    exp: ExpoConfig.ExpoConfig;
+  },
+  modifyConfig: (config: any) => void
+): Promise<void> {
+  const paths = ExpoConfig.getConfigFilePaths(projectDir);
+  assert(paths.staticConfigPath, "can't update dynamic config");
+
+  const rawStaticConfig = await fs.readJSON(paths.staticConfigPath);
+  rawStaticConfig.expo = rawStaticConfig.expo ?? {};
+  modifyConfig(rawStaticConfig.expo);
+  await fs.writeJson(paths.staticConfigPath, rawStaticConfig, { spaces: 2 });
+
+  modifyConfig(exp);
+}

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

@@ -0,0 +1,76 @@
+import chalk from 'chalk';
+
+import formatFields from '../../utils/formatFields';
+import { platformDisplayNames } from '../constants';
+import { Build, BuildStatus } from '../types';
+import { getBuildLogsUrl } from './url';
+
+interface Options {
+  accountName: string;
+}
+
+export default function formatBuild(build: Build, { accountName }: Options) {
+  const fields: { label: string; value: string }[] = [
+    { label: 'ID', value: build.id },
+    {
+      label: 'Platform',
+      value: platformDisplayNames[build.platform],
+    },
+    {
+      label: 'Status',
+      get value() {
+        switch (build.status) {
+          case BuildStatus.IN_QUEUE:
+            return chalk.blue('in queue');
+          case BuildStatus.IN_PROGRESS:
+            return chalk.blue('in progress');
+          case BuildStatus.CANCELED:
+            return chalk.gray('canceled');
+          case BuildStatus.FINISHED:
+            return chalk.green('finished');
+          case BuildStatus.ERRORED:
+            return chalk.red('errored');
+          default:
+            return 'unknown';
+        }
+      },
+    },
+    {
+      label: 'Logs',
+      value: getBuildLogsUrl({ buildId: build.id, account: accountName }),
+    },
+    {
+      label: 'Artifact',
+      get value() {
+        if (build.status === BuildStatus.IN_QUEUE || build.status === BuildStatus.IN_PROGRESS) {
+        }
+        switch (build.status) {
+          case BuildStatus.IN_QUEUE:
+          case BuildStatus.IN_PROGRESS:
+            return '<in progress>';
+          case BuildStatus.CANCELED:
+          case BuildStatus.ERRORED:
+            return '---------';
+          case BuildStatus.FINISHED: {
+            const url = build.artifacts?.buildUrl;
+            return url ? url : chalk.red('not found');
+          }
+          default:
+            return 'unknown';
+        }
+      },
+    },
+    { label: 'Started at', value: new Date(build.createdAt).toLocaleString() },
+    {
+      label: 'Finished at',
+      value:
+        build.status === BuildStatus.IN_QUEUE || build.status === BuildStatus.IN_PROGRESS
+          ? '<in progress>'
+          : new Date(build.updatedAt).toLocaleString(),
+    },
+    // TODO: we can do it once we migrate to GraphQL
+    // { label: 'Started by', get: build => 'TODO' },
+  ];
+
+  return formatFields(fields);
+}

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

@@ -0,0 +1,90 @@
+import { DistributionType } from '@expo/eas-json';
+import assert from 'assert';
+import chalk from 'chalk';
+
+import Log from '../../log';
+import { platformDisplayNames, platformEmojis } from '../constants';
+import { Build } from '../types';
+import { getBuildLogsUrl } from './url';
+
+export interface DeprecationInfo {
+  type: 'user-facing' | 'internal';
+  message: string;
+}
+
+export function printLogsUrls(
+  accountName: string,
+  builds: { platform: 'android' | 'ios'; buildId: string }[]
+): void {
+  if (builds.length === 1) {
+    const { buildId } = builds[0];
+    const logsUrl = getBuildLogsUrl({
+      buildId,
+      account: accountName,
+    });
+    Log.log(`Build details: ${chalk.underline(logsUrl)}`);
+  } else {
+    builds.forEach(({ buildId, platform }) => {
+      const logsUrl = getBuildLogsUrl({
+        buildId,
+        account: accountName,
+      });
+      Log.log(`${platformDisplayNames[platform]} build details: ${chalk.underline(logsUrl)}`);
+    });
+  }
+}
+
+export function printBuildResults(accountName: string, builds: (Build | null)[]): void {
+  if (builds.length === 1) {
+    const [build] = builds;
+    assert(build, 'Build should be defined');
+    printBuildResult(accountName, build);
+  } else {
+    (builds.filter(i => i) as Build[])
+      .filter(build => build.status === 'finished')
+      .forEach(build => printBuildResult(accountName, build));
+  }
+}
+
+function printBuildResult(accountName: string, build: Build): void {
+  if (build.metadata?.distribution === DistributionType.INTERNAL) {
+    const logsUrl = getBuildLogsUrl({
+      buildId: build.id,
+      account: accountName,
+    });
+    Log.log(
+      `${platformEmojis[build.platform]} Open this link on your ${
+        platformDisplayNames[build.platform]
+      } devices to install the app:`
+    );
+    Log.log(`${chalk.underline(logsUrl)}`);
+    Log.newLine();
+  } else {
+    // TODO: it looks like buildUrl could possibly be undefined, based on the code below.
+    // we should account for this case better if it is possible
+    const url = build.artifacts?.buildUrl ?? '';
+    Log.log(`${platformEmojis[build.platform]} ${platformDisplayNames[build.platform]} app:`);
+    Log.log(`${chalk.underline(url)}`);
+    Log.newLine();
+  }
+}
+
+export function printDeprecationWarnings(deprecationInfo?: DeprecationInfo): void {
+  if (!deprecationInfo) {
+    return;
+  }
+  if (deprecationInfo.type === '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') {
+    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.'
+    );
+    Log.warn(deprecationInfo.message);
+  } else {
+    Log.warn('An unexpected warning was encountered. Please report it as a bug:');
+    Log.warn(deprecationInfo);
+  }
+}

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

@@ -0,0 +1,179 @@
+import spawnAsync from '@expo/spawn-async';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import ora from 'ora';
+import path from 'path';
+import tar from 'tar';
+import { v4 as uuidv4 } from 'uuid';
+
+import Log from '../../log';
+import { confirmAsync, promptAsync } from '../../prompts';
+import {
+  doesGitRepoExistAsync,
+  getGitDiffOutputAsync,
+  gitDiffAsync,
+  gitRootDirectoryAsync,
+  gitStatusAsync,
+  isGitInstalledAsync,
+} from '../../utils/git';
+import { getTmpDirectory } from '../../utils/paths';
+import { endTimer, formatMilliseconds, startTimer } from '../../utils/timer';
+
+async function ensureGitRepoExistsAsync(): Promise<void> {
+  if (!(await isGitInstalledAsync())) {
+    throw new Error('git command not found, install it before proceeding');
+  }
+
+  if (await doesGitRepoExistAsync()) {
+    return;
+  }
+
+  Log.warn("It looks like you haven't initialized the git repository yet.");
+  Log.warn('EAS Build requires you to use a git repository for your project.');
+
+  const confirmInit = await confirmAsync({
+    message: `Would you like to run 'git init' in the current directory?`,
+  });
+  if (!confirmInit) {
+    throw new Error(
+      'A git repository is required for building your project. Initialize it and run this command again.'
+    );
+  }
+  await spawnAsync('git', ['init']);
+
+  Log.log("We're going to make an initial commit for you repository.");
+
+  await spawnAsync('git', ['add', '-A']);
+  await commitPromptAsync('Initial commit');
+}
+
+async function isGitStatusCleanAsync(): Promise<boolean> {
+  const changes = await gitStatusAsync();
+  return changes.length === 0;
+}
+
+async function maybeBailOnGitStatusAsync(): Promise<void> {
+  if (await isGitStatusCleanAsync()) {
+    return;
+  }
+  Log.addNewLineIfNone();
+  Log.warn(`${chalk.bold('Warning!')} Your git working tree is dirty.`);
+  Log.log(
+    `It's recommended to ${chalk.bold(
+      'commit all your changes before proceeding'
+    )}, so you can revert the changes made by this command if necessary.`
+  );
+  const answer = await confirmAsync({
+    message: `Would you like to proceed?`,
+  });
+
+  if (!answer) {
+    throw new Error('Please commit all changes. Aborting...');
+  }
+}
+
+async function ensureGitStatusIsCleanAsync(nonInteractive = false): Promise<void> {
+  if (await isGitStatusCleanAsync()) {
+    return;
+  }
+  Log.addNewLineIfNone();
+  Log.warn(`${chalk.bold('Warning!')} Your git working tree is dirty.`);
+  Log.log(
+    `This operation needs to be run on a clean working tree, please ${chalk.bold(
+      'commit all your changes before proceeding'
+    )}.`
+  );
+  if (nonInteractive) {
+    throw new Error('Please commit all changes. Aborting...');
+  }
+  const answer = await confirmAsync({
+    message: `Commit changes to git?`,
+  });
+  if (answer) {
+    await commitPromptAsync();
+  } else {
+    throw new Error('Please commit all changes. Aborting...');
+  }
+}
+
+async function makeProjectTarballAsync(): Promise<{ path: string; size: number }> {
+  const spinner = ora('Compressing project files');
+
+  await fs.mkdirp(getTmpDirectory());
+  const shallowClonePath = path.join(getTmpDirectory(), `${uuidv4()}-shallow-clone`);
+  const tarPath = path.join(getTmpDirectory(), `${uuidv4()}.tar.gz`);
+
+  // If the compression takes longer then a second, show the spinner.
+  // This can happen when the user has a lot of resources or doesn't ignore their CocoaPods.
+  // A basic project on a Mac can compress in roughly ~40ms.
+  // A fairly complex project without CocoaPods ignored can take up to 30s.
+  const timer = setTimeout(
+    () => {
+      spinner.start();
+    },
+    Log.isDebug ? 1 : 1000
+  );
+  // TODO: Possibly warn after more time about unoptimized assets.
+  const compressTimerLabel = 'makeProjectTarballAsync';
+  startTimer(compressTimerLabel);
+
+  try {
+    await spawnAsync('git', [
+      'clone',
+      '--local',
+      '--no-hardlinks',
+      '--depth',
+      '1',
+      `file://${await gitRootDirectoryAsync()}`,
+      shallowClonePath,
+    ]);
+    await tar.create({ cwd: shallowClonePath, file: tarPath, prefix: 'project', gzip: true }, [
+      '.',
+    ]);
+  } finally {
+    // Stop the timer
+    clearTimeout(timer);
+    await fs.remove(shallowClonePath);
+
+    const duration = endTimer(compressTimerLabel);
+    if (spinner.isSpinning) {
+      const prettyTime = formatMilliseconds(duration);
+      spinner.succeed(`Compressed project files ${chalk.dim(prettyTime)}`);
+    }
+  }
+
+  const { size } = await fs.stat(tarPath);
+  return { size, path: tarPath };
+}
+
+async function showDiffAsync() {
+  const outputTooLarge = (await getGitDiffOutputAsync()).split(/\r\n|\r|\n/).length > 100;
+  await gitDiffAsync({ withPager: outputTooLarge });
+}
+
+async function commitPromptAsync(initialCommitMessage?: string): Promise<void> {
+  const { message } = await promptAsync({
+    type: 'text',
+    name: 'message',
+    message: 'Commit message:',
+    initial: initialCommitMessage,
+    validate: (input: string) => input !== '',
+  });
+  await commitChangedFilesAsync(message);
+}
+
+async function commitChangedFilesAsync(message: string): Promise<void> {
+  await spawnAsync('git', ['add', '-u']);
+  await spawnAsync('git', ['commit', '-m', message]);
+}
+
+export {
+  isGitStatusCleanAsync,
+  showDiffAsync,
+  commitPromptAsync,
+  commitChangedFilesAsync,
+  ensureGitRepoExistsAsync,
+  ensureGitStatusIsCleanAsync,
+  maybeBailOnGitStatusAsync,
+  makeProjectTarballAsync,
+};

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

@@ -0,0 +1,14 @@
+import { ExpoConfig, getPackageJson } from '@expo/config';
+
+export function isExpoUpdatesInstalled(projectDir: string) {
+  const packageJson = getPackageJson(projectDir);
+  return packageJson.dependencies && 'expo-updates' in packageJson.dependencies;
+}
+
+export function ensureValidVersions(exp: ExpoConfig): void {
+  if (!exp.runtimeVersion && !exp.sdkVersion) {
+    throw new Error(
+      "Couldn't find either 'runtimeVersion' or 'sdkVersion' to configure 'expo-updates'. Please specify at least one of these properties under the 'expo' key in 'app.json'"
+    );
+  }
+}

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

@@ -0,0 +1,15 @@
+import { getExpoWebsiteBaseUrl } from '../../api';
+
+export function getBuildLogsUrl({
+  buildId,
+  account,
+}: {
+  buildId: string;
+  account: string;
+}): string {
+  return `${getExpoWebsiteBaseUrl()}/accounts/${account}/builds/${buildId}`;
+}
+
+export function getArtifactUrl(artifactId: string): string {
+  return `${getExpoWebsiteBaseUrl()}/artifacts/${artifactId}`;
+}

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

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/command';
+
+import Log from '../../log';
+import { showLoginPromptAsync } from '../../user/actions';
+
+export default class AccountLogin extends Command {
+  static description = 'log in with your Expo account';
+
+  static aliases = ['login'];
+
+  async run() {
+    Log.log('Log in to EAS');
+    await showLoginPromptAsync();
+    Log.log('Logged in');
+  }
+}

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

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/command';
+
+import Log from '../../log';
+import { logoutAsync } from '../../user/User';
+
+export default class AccountLogout extends Command {
+  static description = 'log out';
+
+  static aliases = ['logout'];
+
+  async run() {
+    await logoutAsync();
+    Log.log('Logged out');
+  }
+}

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

@@ -0,0 +1,22 @@
+import { Command } from '@oclif/command';
+import chalk from 'chalk';
+
+import Log from '../../log';
+import { getUserAsync } from '../../user/User';
+import { getActorDisplayName } from '../../user/actions';
+
+export default class AccountView extends Command {
+  static description = 'show the username you are logged in as';
+
+  static aliases = ['whoami'];
+
+  async run() {
+    const user = await getUserAsync();
+    if (user) {
+      Log.log(chalk.green(getActorDisplayName(user)));
+    } else {
+      Log.warn('Not logged in');
+      process.exit(1);
+    }
+  }
+}

packages/eas-cli/src/commands/branch/create.ts

@@ -0,0 +1,113 @@
+import { getConfig } from '@expo/config';
+import { Command, flags } from '@oclif/command';
+import chalk from 'chalk';
+import gql from 'graphql-tag';
+
+import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
+import { UpdateBranch } from '../../graphql/generated';
+import Log from '../../log';
+import { ensureProjectExistsAsync } from '../../project/ensureProjectExists';
+import { findProjectRootAsync, getProjectAccountName } from '../../project/projectUtils';
+import { promptAsync } from '../../prompts';
+import { ensureLoggedInAsync } from '../../user/actions';
+import { getBranchNameAsync } from '../../utils/git';
+
+export async function createUpdateBranchOnAppAsync({
+  appId,
+  branchName,
+}: {
+  appId: string;
+  branchName: string;
+}): Promise<Pick<UpdateBranch, 'id' | 'branchName'>> {
+  const data = await withErrorHandlingAsync(
+    graphqlClient
+      .mutation<
+        { updateBranch: { createUpdateBranchForApp: Pick<UpdateBranch, 'id' | 'branchName'> } },
+        { appId: string; branchName: string }
+      >(
+        gql`
+          mutation createUpdateBranchForApp($appId: ID!, $branchName: String!) {
+            updateBranch {
+              createUpdateBranchForApp(appId: $appId, branchName: $branchName) {
+                id
+                branchName
+              }
+            }
+          }
+        `,
+        {
+          appId,
+          branchName,
+        }
+      )
+      .toPromise()
+  );
+  return data.updateBranch.createUpdateBranchForApp;
+}
+
+export default class BranchCreate extends Command {
+  static hidden = true;
+  static description = 'Create a branch on the current project.';
+
+  static args = [
+    {
+      name: 'branchName',
+      required: false,
+      description: 'Name of the branch to create',
+    },
+  ];
+
+  static flags = {
+    json: flags.boolean({
+      description: 'return a json with the new branch ID and name.',
+      default: false,
+    }),
+  };
+
+  async run() {
+    let {
+      args: { branchName },
+      flags,
+    } = this.parse(BranchCreate);
+
+    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 = getProjectAccountName(exp, await ensureLoggedInAsync());
+    const projectId = await ensureProjectExistsAsync({
+      accountName,
+      projectName: exp.slug,
+    });
+
+    if (!branchName) {
+      const validationMessage = 'Branch name may not be empty.';
+      if (flags.json) {
+        throw new Error(validationMessage);
+      }
+      ({ branchName } = await promptAsync({
+        type: 'text',
+        name: 'branchName',
+        message: 'Please name the branch:',
+        initial:
+          (await getBranchNameAsync()) || `branch-${Math.random().toString(36).substr(2, 4)}`,
+        validate: value => (value ? true : validationMessage),
+      }));
+    }
+
+    const newBranch = await createUpdateBranchOnAppAsync({ appId: projectId, branchName });
+
+    if (flags.json) {
+      Log.log(newBranch);
+      return;
+    }
+
+    Log.withTick(
+      `️Created a new branch: ${chalk.bold(newBranch.branchName)} on project ${chalk.bold(
+        `@${accountName}/${exp.slug}`
+      )}.`
+    );
+  }
+}

packages/eas-cli/src/commands/branch/list.ts

@@ -0,0 +1,112 @@
+import { Command, flags } from '@oclif/command';
+import { CLIError } from '@oclif/errors';
+import CliTable from 'cli-table3';
+import gql from 'graphql-tag';
+import { format } from 'timeago.js';
+
+import { graphqlClient } from '../../graphql/client';
+import { RootQuery, Update, UpdateBranch } from '../../graphql/generated';
+import Log from '../../log';
+import { findProjectRootAsync, getProjectFullNameAsync } from '../../project/projectUtils';
+import { getActorDisplayName } from '../../user/actions';
+
+const BRANCHES_LIMIT = 10_000;
+
+export default class BranchList extends Command {
+  static hidden = true;
+
+  static description = 'List all branches on this project.';
+
+  static flags = {
+    json: flags.boolean({
+      description: 'return output as JSON',
+      default: false,
+    }),
+  };
+
+  async run() {
+    const { flags } = this.parse(BranchList);
+
+    const projectDir = await findProjectRootAsync(process.cwd());
+    if (!projectDir) {
+      throw new Error('Please run this command inside a project directory.');
+    }
+    const fullName = await getProjectFullNameAsync(projectDir);
+    const branches = await this.listBranchesAsync({ fullName });
+    if (flags.json) {
+      Log.log(JSON.stringify(branches, null, 2));
+    } else {
+      const table = new CliTable({ head: ['Branch', 'Latest update'] });
+      table.push(
+        ...branches.map((branch: UpdateBranch) => [
+          branch.branchName,
+          formatUpdate(branch.updates[0]),
+        ])
+      );
+      Log.log(table.toString());
+      if (branches.length >= BRANCHES_LIMIT) {
+        Log.warn(`Showing first ${BRANCHES_LIMIT} branches, some results might be omitted.`);
+      }
+    }
+  }
+
+  async listBranchesAsync({ fullName }: { fullName: string }): Promise<UpdateBranch[]> {
+    const { data, error } = await graphqlClient
+      .query<RootQuery>(
+        gql`
+          query BranchesByAppQuery($fullName: String!, $limit: Int!) {
+            app {
+              byFullName(fullName: $fullName) {
+                id
+                fullName
+                updateBranches(offset: 0, limit: $limit) {
+                  id
+                  branchName
+                  updates(offset: 0, limit: 1) {
+                    id
+                    actor {
+                      __typename
+                      id
+                      ... on User {
+                        username
+                      }
+                      ... on Robot {
+                        firstName
+                      }
+                    }
+                    updatedAt
+                    updateMessage
+                  }
+                }
+              }
+            }
+          }
+        `,
+        {
+          fullName,
+          limit: BRANCHES_LIMIT,
+        }
+      )
+      .toPromise();
+
+    if (error) {
+      if (error.networkError) {
+        throw new CLIError(`Fetching branches failed: ${error.networkError.message}`);
+      } else {
+        throw new CLIError(error.graphQLErrors.map(e => e.message).join('\n'));
+      }
+    }
+
+    return data?.app?.byFullName.updateBranches ?? [];
+  }
+}
+
+function formatUpdate(update: Update | undefined): string {
+  if (!update) {
+    return 'N/A';
+  }
+  const message = update.updateMessage ? `"${update.updateMessage}" ` : '';
+  return `${message}(${format(update.updatedAt, 'en_US')} by ${getActorDisplayName(
+    update.actor as any
+  )})`;
+}

packages/eas-cli/src/commands/branch/publish.ts

@@ -0,0 +1,159 @@
+import { getConfig } from '@expo/config';
+import { Command, flags } from '@oclif/command';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import ora from 'ora';
+
+import { PublishMutation } from '../../graphql/mutations/PublishMutation';
+import Log from '../../log';
+import { ensureProjectExistsAsync } from '../../project/ensureProjectExists';
+import {
+  findProjectRootAsync,
+  getBranchByNameAsync,
+  getProjectAccountNameAsync,
+} from '../../project/projectUtils';
+import { buildUpdateInfoGroupAsync, collectAssets, uploadAssetsAsync } from '../../project/publish';
+import { promptAsync } from '../../prompts';
+import { getLastCommitMessageAsync } from '../../utils/git';
+
+export default class BranchPublish extends Command {
+  static hidden = true;
+  static description = 'Publish an update group to a branch.';
+
+  static flags = {
+    'input-dir': flags.string({
+      description: 'location of the bundle',
+      default: 'dist',
+      required: false,
+    }),
+    branch: flags.string({
+      description: 'current name of the branch.',
+    }),
+    message: flags.string({
+      description: 'Short message describing the updates.',
+      required: false,
+    }),
+    json: flags.boolean({
+      description: `return a json with the edited branch's ID and name.`,
+      default: false,
+    }),
+  };
+
+  async run() {
+    let {
+      flags: { json: jsonFlag, branch: branchName, message: updateMessage, 'input-dir': inputDir },
+    } = this.parse(BranchPublish);
+
+    const projectDir = await findProjectRootAsync(process.cwd());
+    if (!projectDir) {
+      throw new Error('Please run this command inside a project directory.');
+    }
+
+    const accountName = await getProjectAccountNameAsync(projectDir);
+    const {
+      exp: { slug, runtimeVersion },
+    } = getConfig(projectDir, { skipSDKVersionRequirement: true });
+    if (!runtimeVersion) {
+      throw new Error(
+        "Couldn't find 'runtimeVersion'. Please specify it under the 'expo' key in 'app.json'"
+      );
+    }
+    const projectId = await ensureProjectExistsAsync({
+      accountName,
+      projectName: slug,
+    });
+
+    if (!branchName) {
+      const validationMessage = 'branch name may not be empty.';
+      if (jsonFlag) {
+        throw new Error(validationMessage);
+      }
+      ({ branchName } = await promptAsync({
+        type: 'text',
+        name: 'branchName',
+        message: 'Please enter the name of the branch to publish on:',
+        validate: value => (value ? true : validationMessage),
+      }));
+    }
+
+    if (!updateMessage) {
+      const validationMessage = 'publish message may not be empty.';
+      if (jsonFlag) {
+        throw new Error(validationMessage);
+      }
+      ({ publishMessage: updateMessage } = await promptAsync({
+        type: 'text',
+        name: 'publishMessage',
+        message: `Please enter a publication message.`,
+        initial: (await getLastCommitMessageAsync())?.trim(),
+        validate: value => (value ? true : validationMessage),
+      }));
+    }
+
+    const { id: branchId } = await getBranchByNameAsync({
+      appId: projectId,
+      branchName: branchName!,
+    });
+
+    let updateInfoGroup;
+    const assetSpinner = ora('Uploading assets...').start();
+    try {
+      const assets = collectAssets(inputDir!);
+      await uploadAssetsAsync(assets);
+      updateInfoGroup = await buildUpdateInfoGroupAsync(assets);
+      assetSpinner.succeed('Uploaded assets!');
+    } catch (e) {
+      assetSpinner.fail('Failed to upload assets');
+      throw e;
+    }
+
+    let newUpdateGroup;
+    const publishSpinner = ora('Publishing...').start();
+    try {
+      newUpdateGroup = await PublishMutation.publishUpdateGroupAsync({
+        branchId,
+        updateInfoGroup,
+        runtimeVersion,
+        updateMessage,
+      });
+      publishSpinner.succeed('Published!');
+    } catch (e) {
+      publishSpinner.fail('Failed to published updates');
+      throw e;
+    }
+
+    if (jsonFlag) {
+      Log.log(newUpdateGroup);
+    } else {
+      const outputMessage = new Table({
+        wordWrap: true,
+        chars: {
+          top: '',
+          'top-mid': '',
+          'top-left': '',
+          'top-right': '',
+          bottom: '',
+          'bottom-mid': '',
+          'bottom-left': '',
+          'bottom-right': '',
+          left: '',
+          'left-mid': '',
+          mid: '',
+          'mid-mid': '',
+          right: '',
+          'right-mid': '',
+          middle: ' ',
+        },
+        style: { 'padding-left': 0, 'padding-right': 0 },
+      });
+      outputMessage.push(
+        [chalk.dim('project'), `@${accountName}/${slug}`],
+        [chalk.dim('branch'), branchName],
+        [chalk.dim('runtimeVersion'), runtimeVersion],
+        [chalk.dim('updateGroupID'), newUpdateGroup.updateGroup],
+        [chalk.dim('message'), updateMessage]
+      );
+      Log.log(outputMessage.toString());
+    }
+  }
+}

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

@@ -0,0 +1,132 @@
+import { getConfig } from '@expo/config';
+import { Command, flags } from '@oclif/command';
+import chalk from 'chalk';
+import gql from 'graphql-tag';
+
+import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
+import { EditUpdateBranchInput, UpdateBranch } from '../../graphql/generated';
+import Log from '../../log';
+import { ensureProjectExistsAsync } from '../../project/ensureProjectExists';
+import { findProjectRootAsync, getProjectAccountName } from '../../project/projectUtils';
+import { promptAsync } from '../../prompts';
+import { ensureLoggedInAsync } from '../../user/actions';
+
+async function renameUpdateBranchOnAppAsync({
+  appId,
+  currentName,
+  newName,
+}: {
+  appId: string;
+  currentName: string;
+  newName: string;
+}): Promise<UpdateBranch> {
+  const data = await withErrorHandlingAsync(
+    graphqlClient
+      .mutation<
+        { updateBranch: { editUpdateBranch: UpdateBranch } },
+        {
+          input: EditUpdateBranchInput;
+        }
+      >(
+        gql`
+          mutation EditUpdateBranch($input: EditUpdateBranchInput!) {
+            updateBranch {
+              editUpdateBranch(input: $input) {
+                id
+                branchName
+              }
+            }
+          }
+        `,
+        {
+          input: {
+            appId,
+            branchName: currentName,
+            newBranchName: newName,
+          },
+        }
+      )
+      .toPromise()
+  );
+  return data.updateBranch.editUpdateBranch;
+}
+
+export default class BranchRename extends Command {
+  static hidden = true;
+  static description = 'Rename a branch.';
+
+  static flags = {
+    from: flags.string({
+      description: 'current name of the branch.',
+      required: false,
+    }),
+    to: flags.string({
+      description: 'new name of the branch.',
+      required: false,
+    }),
+    json: flags.boolean({
+      description: `return a json with the edited branch's ID and name.`,
+      default: false,
+    }),
+  };
+
+  async run() {
+    let {
+      flags: { json: jsonFlag, from: currentName, to: newName },
+    } = this.parse(BranchRename);
+
+    const projectDir = await findProjectRootAsync(process.cwd());
+    if (!projectDir) {
+      throw new Error('Please run this command inside a project directory.');
+    }
+    const { exp } = await getConfig(projectDir, { skipSDKVersionRequirement: true });
+    const accountName = getProjectAccountName(exp, await ensureLoggedInAsync());
+    const projectId = await ensureProjectExistsAsync({
+      accountName,
+      projectName: exp.slug,
+    });
+
+    if (!currentName) {
+      const validationMessage = 'current name may not be empty.';
+      if (jsonFlag) {
+        throw new Error(validationMessage);
+      }
+      ({ currentName } = await promptAsync({
+        type: 'text',
+        name: 'currentName',
+        message: 'Please enter the current name of the branch to rename:',
+        validate: value => (value ? true : validationMessage),
+      }));
+    }
+
+    if (!newName) {
+      const validationMessage = 'new name may not be empty.';
+      if (jsonFlag) {
+        throw new Error(validationMessage);
+      }
+      ({ newName } = await promptAsync({
+        type: 'text',
+        name: 'newName',
+        message: `Please rename ${currentName}`,
+        validate: value => (value ? true : validationMessage),
+      }));
+    }
+
+    const editedBranch = await renameUpdateBranchOnAppAsync({
+      appId: projectId,
+      currentName: currentName!,
+      newName: newName!,
+    });
+
+    if (jsonFlag) {
+      Log.log(editedBranch);
+      return;
+    }
+
+    Log.withTick(
+      `️Renamed branch from ${currentName} to ${chalk.bold(
+        editedBranch.branchName
+      )} on project ${chalk.bold(`@${accountName}/${exp.slug}`)}.`
+    );
+  }
+}

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

@@ -0,0 +1,176 @@
+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 { groupBy } from 'lodash';
+
+import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
+import { Update } from '../../graphql/generated';
+import Log from '../../log';
+import { ensureProjectExistsAsync } from '../../project/ensureProjectExists';
+import { findProjectRootAsync, getProjectAccountNameAsync } from '../../project/projectUtils';
+import { promptAsync } from '../../prompts';
+
+const PAGE_LIMIT = 10_000;
+
+type TruncatedUpdate = Pick<Update, 'updateGroup' | 'updateMessage' | 'createdAt' | 'actor'>;
+
+async function viewUpdateBranchAsync({
+  appId,
+  branchName,
+}: {
+  appId: string;
+  branchName: string;
+}): Promise<{
+  id: string;
+  branchName: string;
+  updates: TruncatedUpdate[];
+}> {
+  const data = await withErrorHandlingAsync(
+    graphqlClient
+      .mutation<
+        {
+          app: {
+            byId: {
+              updateBranchByBranchName: {
+                id: string;
+                branchName: string;
+                updates: TruncatedUpdate[];
+              };
+            };
+          };
+        },
+        {
+          appId: string;
+          branchName: string;
+          limit: number;
+        }
+      >(
+        gql`
+          query ViewBranch($appId: String!, $branchName: String!, $limit: Int!) {
+            app {
+              byId(appId: $appId) {
+                id
+                updateBranchByBranchName(branchName: $branchName) {
+                  id
+                  branchName
+                  updates(offset: 0, limit: $limit) {
+                    id
+                    updateGroup
+                    updateMessage
+                    createdAt
+                    actor {
+                      id
+                      ... on User {
+                        firstName
+                      }
+                      ... on Robot {
+                        firstName
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        `,
+        {
+          appId,
+          branchName,
+          limit: PAGE_LIMIT,
+        }
+      )
+      .toPromise()
+  );
+  return data.app.byId.updateBranchByBranchName;
+}
+
+export default class BranchView extends Command {
+  static hidden = true;
+  static description = 'View a branch.';
+
+  static args = [
+    {
+      name: 'branchName',
+      required: false,
+      description: 'Name of the branch to view',
+    },
+  ];
+
+  static flags = {
+    json: flags.boolean({
+      description: `return a json with the branch's ID name and recent update groups.`,
+      default: false,
+    }),
+  };
+
+  async run() {
+    let {
+      args: { branchName },
+      flags: { json: jsonFlag },
+    } = this.parse(BranchView);
+
+    const projectDir = await findProjectRootAsync(process.cwd());
+    if (!projectDir) {
+      throw new Error('Please run this command inside a project directory.');
+    }
+    const accountName = await getProjectAccountNameAsync(projectDir);
+    const {
+      exp: { slug },
+    } = getConfig(projectDir, { skipSDKVersionRequirement: true });
+    const projectId = await ensureProjectExistsAsync({
+      accountName,
+      projectName: slug,
+    });
+
+    if (!branchName) {
+      const validationMessage = 'Branch name may not be empty.';
+      if (jsonFlag) {
+        throw new Error(validationMessage);
+      }
+      ({ branchName } = await promptAsync({
+        type: 'text',
+        name: 'branchName',
+        message: 'Please enter the name of the branch to view:',
+        validate: value => (value ? true : validationMessage),
+      }));
+    }
+
+    const UpdateBranch = await viewUpdateBranchAsync({
+      appId: projectId,
+      branchName,
+    });
+
+    const updates = Object.values(groupBy(UpdateBranch.updates, u => u.updateGroup)).map(
+      updateGroup => updateGroup[0]
+    );
+
+    if (jsonFlag) {
+      Log.log({ ...UpdateBranch, updates });
+      return;
+    }
+
+    const updateGroupTable = new Table({
+      head: ['createdAt', 'updateMessage', 'updateGroup', 'actor'],
+      wordWrap: true,
+    });
+
+    for (const update of updates) {
+      updateGroupTable.push([
+        new Date(update.createdAt).toLocaleString(),
+        update.updateMessage,
+        update.updateGroup,
+        update.actor?.firstName,
+      ]);
+    }
+
+    Log.withTick(
+      `️Branch: ${chalk.bold(UpdateBranch.branchName)} on project ${chalk.bold(
+        `@${accountName}/${slug}`
+      )}. Branch ID: ${chalk.bold(UpdateBranch.id)}`
+    );
+    Log.log(chalk.bold('Recent update groups published on this branch:'));
+    Log.log(updateGroupTable.toString());
+  }
+}

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

@@ -0,0 +1,138 @@
+import { Command } from '@oclif/command';
+import chalk from 'chalk';
+import gql from 'graphql-tag';
+import ora from 'ora';
+
+import { platformEmojis } from '../../build/constants';
+import { Platform } from '../../build/types';
+import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
+import { AppPlatform, Build, BuildStatus } from '../../graphql/generated';
+import { BuildQuery } from '../../graphql/queries/BuildQuery';
+import Log from '../../log';
+import {
+  findProjectRootAsync,
+  getProjectFullNameAsync,
+  getProjectIdAsync,
+} from '../../project/projectUtils';
+import { confirmAsync, selectAsync } from '../../prompts';
+
+async function cancelBuildAsync(buildId: string): Promise<Pick<Build, 'id' | 'status'>> {
+  const data = await withErrorHandlingAsync(
+    graphqlClient
+      .mutation<{ build: { cancel: { id: string; status: BuildStatus } } }>(
+        gql`
+          mutation CancelBuildMutation($buildId: ID!) {
+            build(buildId: $buildId) {
+              cancel {
+                id
+                status
+              }
+            }
+          }
+        `,
+        { buildId }
+      )
+      .toPromise()
+  );
+  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 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}`;
+}
+
+async function selectBuildToCancelAsync(
+  projectId: string,
+  projectFullName: string
+): Promise<string | null> {
+  const spinner = ora().start('Fetching the uncompleted builds…');
+  let builds;
+  try {
+    const [inQueueBuilds, inProgressBuilds] = await Promise.all([
+      BuildQuery.allForAppAsync(projectId, { status: BuildStatus.InQueue }),
+      BuildQuery.allForAppAsync(projectId, { status: BuildStatus.InProgress }),
+    ]);
+    spinner.stop();
+    builds = [...inQueueBuilds, ...inProgressBuilds];
+  } catch (error) {
+    spinner.fail(
+      `Something went wrong and we couldn't fetch the builds for the project ${projectFullName}.`
+    );
+    throw error;
+  }
+  if (builds.length === 0) {
+    Log.warn(`There aren't any uncompleted builds for the project ${projectFullName}.`);
+    return null;
+  } else if (builds.length === 1) {
+    Log.log('Found one build');
+    Log.log(formatUnfinishedBuild(builds[0]));
+    await confirmAsync({
+      message: 'Do you want to cancel it?',
+    });
+    return builds[0].id;
+  } else {
+    const buildId = await selectAsync<string>(
+      'Which build do you want to cancel?',
+      builds.map(build => ({
+        title: formatUnfinishedBuild(build),
+        value: build.id,
+      }))
+    );
+    return buildId;
+  }
+}
+
+async function ensureBuildExistsAsync(buildId: string): Promise<void> {
+  try {
+    await BuildQuery.byIdAsync(buildId);
+  } catch (err) {
+    throw new Error(`Couldn't find a build matching the id ${buildId}`);
+  }
+}
+
+export default class BuildCancel extends Command {
+  static description = 'Cancel a build.';
+
+  static args = [{ name: 'BUILD_ID' }];
+
+  async run() {
+    const { BUILD_ID: buildIdFromArg } = this.parse(BuildCancel).args;
+
+    const projectDir = (await findProjectRootAsync()) ?? process.cwd();
+    const projectId = await getProjectIdAsync(projectDir);
+    const projectFullName = await getProjectFullNameAsync(projectDir);
+
+    if (buildIdFromArg) {
+      await ensureBuildExistsAsync(buildIdFromArg);
+    }
+
+    const buildId = buildIdFromArg || (await selectBuildToCancelAsync(projectId, projectFullName));
+    if (!buildId) {
+      return;
+    }
+
+    const spinner = ora().start('Canceling the build…');
+    try {
+      const { status } = await cancelBuildAsync(buildId);
+      if (status === BuildStatus.Canceled) {
+        spinner.succeed('Build canceled');
+      } else {
+        spinner.text = 'Build is already completed';
+        spinner.stopAndPersist();
+      }
+    } catch (error) {
+      spinner.fail(`Something went wrong and we couldn't cancel your build ${buildId}`);
+      throw error;
+    }
+  }
+}

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

@@ -0,0 +1,100 @@
+import { Command, flags } from '@oclif/command';
+import chalk from 'chalk';
+
+import { configureAsync } from '../../build/configure';
+import { RequestedPlatform } from '../../build/types';
+import Log, { learnMore } from '../../log';
+import { findProjectRootAsync } from '../../project/projectUtils';
+import { promptAsync } from '../../prompts';
+import { ensureLoggedInAsync } from '../../user/actions';
+
+export default class BuildConfigure extends Command {
+  static description = 'Configure the project to support EAS Build.';
+
+  static flags = {
+    platform: flags.enum({
+      description: 'Platform to configure',
+      char: 'p',
+      options: ['android', 'ios', 'all'],
+    }),
+    'allow-experimental': flags.boolean({
+      description: 'Enable experimental configuration steps.',
+      default: false,
+    }),
+  };
+
+  async run() {
+    const { flags } = this.parse(BuildConfigure);
+    Log.log(
+      '💡 The following process will configure your iOS and/or Android project to be compatible with EAS Build. These changes only apply to your local project files and you can safely revert them at any time.'
+    );
+    Log.newLine();
+
+    const platform =
+      (flags.platform as RequestedPlatform | undefined) ?? (await promptForPlatformAsync());
+    const allowExperimental = flags['allow-experimental'];
+
+    if (allowExperimental) {
+      Log.warn(
+        `Project configuration will execute some additional steps that might fail if structure of your native project is significantly different from ${chalk.bold(
+          'expo eject'
+        )} or ${chalk.bold('expo init')}`
+      );
+    }
+
+    await ensureLoggedInAsync();
+    await configureAsync({
+      platform,
+      allowExperimental,
+      projectDir: (await findProjectRootAsync()) ?? process.cwd(),
+    });
+
+    Log.newLine();
+    logSuccess(platform);
+  }
+}
+
+function logSuccess(platform: RequestedPlatform) {
+  let platformsText = 'iOS and Android projects are';
+  let storesText = 'the Apple App Store or Google Play Store';
+
+  if (platform === 'android') {
+    platformsText = 'Android project is';
+    storesText = 'the Google Play Store';
+  } else if (platform === 'ios') {
+    platformsText = 'iOS project is';
+    storesText = 'the Apple App Store';
+  }
+
+  Log.log(`🎉 Your ${platformsText} ready to build.
+
+- Run ${chalk.bold('eas build')} when you are ready to create your first build.
+- Once the build is completed, run ${chalk.bold('eas submit')} to upload the app to ${storesText}
+- ${learnMore(
+    'https://docs.expo.io/build/introduction',
+    'Learn more about other capabilities of EAS Build'
+  )}`);
+}
+
+async function promptForPlatformAsync(): Promise<RequestedPlatform> {
+  const { platform } = await promptAsync({
+    type: 'select',
+    message: 'Which platforms would you like to configure for EAS Build?',
+    name: 'platform',
+    choices: [
+      {
+        title: 'All',
+        value: RequestedPlatform.All,
+      },
+      {
+        title: 'iOS',
+        value: RequestedPlatform.iOS,
+      },
+      {
+        title: 'Android',
+        value: RequestedPlatform.Android,
+      },
+    ],
+  });
+  return platform;
+}

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

@@ -1,11 +1,219 @@
-import { Command } from '@oclif/command';
+import { Command, flags } from '@oclif/command';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import { v4 as uuidv4 } from 'uuid';
 
-export default class BuildIndex extends Command {
-  static description = 'build an app binary for your project';
+import { apiClient } from '../../api';
+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 { isGitStatusCleanAsync } from '../../build/utils/repository';
+import { AppPlatform } from '../../graphql/generated';
+import { BuildQuery } from '../../graphql/queries/BuildQuery';
+import Log, { learnMore } from '../../log';
+import {
+  isEasEnabledForProjectAsync,
+  warnEasUnavailable,
+} from '../../project/isEasEnabledForProject';
+import {
+  findProjectRootAsync,
+  getProjectAccountNameAsync,
+  getProjectIdAsync,
+} from '../../project/projectUtils';
+import { confirmAsync, promptAsync } from '../../prompts';
+import { Actor } from '../../user/User';
+import { ensureLoggedInAsync } from '../../user/actions';
 
-  static flags = {};
+export default class Build extends Command {
+  static description = 'Start a build';
 
-  async run() {
-    throw new Error('Not implemented');
+  static flags = {
+    platform: flags.enum({ char: 'p', options: ['android', 'ios', 'all'] }),
+    'skip-credentials-check': flags.boolean({
+      default: false,
+      description: 'Skip validation of build credentials',
+    }),
+    'skip-project-configuration': flags.boolean({
+      default: false,
+      description: 'Skip project configuration',
+    }),
+    profile: flags.string({
+      default: 'release',
+      description: 'Name of the build profile from eas.json',
+    }),
+    'non-interactive': flags.boolean({
+      default: false,
+      description: 'Run command in --non-interactive mode',
+    }),
+    wait: flags.boolean({
+      default: true,
+      allowNo: true,
+      description: 'Wait for build(s) to complete',
+    }),
+  };
+
+  async run(): Promise<void> {
+    const { flags } = this.parse(Build);
+    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 platform =
+      (flags.platform as RequestedPlatform | undefined) ?? (await promptForPlatformAsync());
+
+    const projectDir = (await findProjectRootAsync()) ?? process.cwd();
+    const projectId = await getProjectIdAsync(projectDir);
+
+    if (!(await isEasEnabledForProjectAsync(projectId))) {
+      warnEasUnavailable();
+      process.exitCode = 1;
+      return;
+    }
+
+    const accountName = await getProjectAccountNameAsync(projectDir);
+    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,
+      projectDir,
+      projectId,
+      trackingCtx,
+      nonInteractive,
+      skipCredentialsCheck: flags['skip-credentials-check'],
+      skipProjectConfiguration: flags['skip-project-configuration'],
+      waitForBuildEnd: flags.wait,
+    });
+    await buildAsync(commandCtx);
+  }
+}
+
+async function ensureNoPendingBuildsExistAsync({
+  user,
+  platform,
+  accountName,
+  projectId,
+}: {
+  user: Actor;
+  platform: RequestedPlatform;
+  accountName: string;
+  projectId: string;
+}): Promise<boolean> {
+  // allow expo admins to run as many builds as they wish
+  if (user.isExpoAdmin) {
+    return false;
+  }
+
+  const appPlatforms = toAppPlatforms(platform);
+  const maybePendingBuilds = await Promise.all(
+    appPlatforms.map(appPlatform => BuildQuery.getPendingBuildIdAsync(accountName, appPlatform))
+  );
+  const pendingBuilds = maybePendingBuilds.filter(i => i !== null);
+  if (pendingBuilds.length > 0) {
+    Log.newLine();
+    Log.error(
+      'Your other builds are still pending. Wait for them to complete before running this command again.'
+    );
+    Log.newLine();
+    const results = await Promise.all(
+      pendingBuilds.map(pendingBuild => {
+        return apiClient.get<{ data: BuildType }>(
+          `projects/${projectId}/builds/${pendingBuild?.id}`,
+          {
+            responseType: 'json',
+          }
+        );
+      })
+    );
+
+    for (const result of results) {
+      Log.log(formatBuild(result.body.data, { accountName }));
+    }
+
+    process.exitCode = 1;
+    return true;
+  }
+  return false;
+}
+
+function toAppPlatforms(requestedPlatform: RequestedPlatform): AppPlatform[] {
+  if (requestedPlatform === RequestedPlatform.All) {
+    return [AppPlatform.Android, AppPlatform.Ios];
+  } else if (requestedPlatform === RequestedPlatform.Android) {
+    return [AppPlatform.Android];
+  } else {
+    return [AppPlatform.Ios];
+  }
+}
+
+async function promptForPlatformAsync(): Promise<RequestedPlatform> {
+  const { platform } = await promptAsync({
+    type: 'select',
+    message: 'Build for platforms',
+    name: 'platform',
+    choices: [
+      {
+        title: 'All',
+        value: RequestedPlatform.All,
+      },
+      {
+        title: 'iOS',
+        value: RequestedPlatform.iOS,
+      },
+      {
+        title: 'Android',
+        value: RequestedPlatform.Android,
+      },
+    ],
+  });
+  return platform;
+}
+
+async function ensureProjectConfiguredAsync(projectDir: string): Promise<void> {
+  if (await fs.pathExists(path.join(projectDir, 'eas.json'))) {
+    return;
+  }
+  const confirm = await confirmAsync({
+    message: 'This app is not set up for building with EAS. Set it up now?',
+  });
+  if (confirm) {
+    await configureAsync({
+      projectDir,
+      platform: RequestedPlatform.All,
+      allowExperimental: false,
+    });
+    if (!(await isGitStatusCleanAsync())) {
+      throw new Error(
+        'Build process requires clean git working tree, please commit all your changes and run `eas build` again'
+      );
+    }
+  } else {
+    throw new Error(
+      `Aborting, please run ${chalk.bold('eas build:configure')} or create eas.json (${learnMore(
+        'https://docs.expo.io/build/eas-json'
+      )})`
+    );
   }
 }

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

@@ -0,0 +1,68 @@
+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 Log from '../../log';
+import {
+  findProjectRootAsync,
+  getProjectAccountNameAsync,
+  getProjectFullNameAsync,
+  getProjectIdAsync,
+} from '../../project/projectUtils';
+
+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'] }),
+    limit: flags.integer(),
+  };
+
+  async run() {
+    const { platform, status, limit = 10 } = this.parse(BuildList).flags;
+
+    const projectDir = (await findProjectRootAsync()) ?? process.cwd();
+    const projectId = await getProjectIdAsync(projectDir);
+    const accountName = await getProjectAccountNameAsync(projectDir);
+    const projectName = await getProjectFullNameAsync(projectDir);
+
+    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;
+
+      if (builds.length) {
+        if (platform || status) {
+          spinner.succeed(
+            `Showing ${builds.length} matching builds for the project ${projectName}`
+          );
+        } else {
+          spinner.succeed(`Showing last ${builds.length} builds for the project ${projectName}`);
+        }
+
+        const list = builds
+          .map(build => formatBuild(build, { accountName }))
+          .join(`\n\n${chalk.dim('———')}\n\n`);
+
+        Log.log(`\n${list}`);
+      } else {
+        spinner.fail(`Couldn't find any builds for the project ${projectName}`);
+      }
+    } catch (e) {
+      spinner.fail(`Something went wrong and we couldn't fetch the build list ${projectName}`);
+      throw e;
+    }
+  }
+}

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

@@ -1,15 +0,0 @@
-import { Command, flags } from '@oclif/command';
-
-export default class BuildStatus extends Command {
-  static description = 'get the status of the latest builds for your project';
-
-  static flags = {
-    platform: flags.enum({ options: ['all', 'android', 'ios'] }),
-    status: flags.enum({ options: ['in-queue', 'in-progress', 'errored', 'finished'] }),
-  };
-
-  async run() {
-    // const { flags } = this.parse(Add);
-    throw new Error('Not implemented');
-  }
-}

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

@@ -0,0 +1,86 @@
+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 Log from '../../log';
+import {
+  findProjectRootAsync,
+  getProjectAccountNameAsync,
+  getProjectFullNameAsync,
+  getProjectIdAsync,
+} from '../../project/projectUtils';
+
+export default class BuildView extends Command {
+  static description = 'view a build for your project';
+
+  static args = [{ name: 'BUILD_ID' }];
+
+  async run() {
+    const { BUILD_ID: buildId } = this.parse(BuildView).args;
+
+    const projectDir = (await findProjectRootAsync()) ?? process.cwd();
+    const projectId = await getProjectIdAsync(projectDir);
+    const accountName = await getProjectAccountNameAsync(projectDir);
+    const projectName = await getProjectFullNameAsync(projectDir);
+
+    const spinner = ora().start('Fetching the build…');
+
+    try {
+      let build: Build;
+
+      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];
+      } else {
+        const response = await apiClient.get<{ data: Build }>(
+          `projects/${projectId}/builds/${buildId}`,
+          {
+            responseType: 'json',
+          }
+        );
+
+        build = response.body.data;
+      }
+
+      if (buildId) {
+        spinner.succeed(`Found a matching build for the project ${projectName}`);
+      } else {
+        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}`);
+        }
+      } 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}`
+          );
+        }
+      }
+
+      throw error;
+    }
+  }
+}

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

@@ -0,0 +1,155 @@
+import { getConfig } from '@expo/config';
+import { Command, flags } from '@oclif/command';
+import chalk from 'chalk';
+import gql from 'graphql-tag';
+
+import { graphqlClient, withErrorHandlingAsync } from '../../graphql/client';
+import { UpdateChannel } from '../../graphql/generated';
+import Log from '../../log';
+import { ensureProjectExistsAsync } from '../../project/ensureProjectExists';
+import {
+  findProjectRootAsync,
+  getBranchByNameAsync,
+  getProjectAccountNameAsync,
+} from '../../project/projectUtils';
+import { promptAsync } from '../../prompts';
+import { createUpdateBranchOnAppAsync } from '../branch/create';
+
+async function createUpdateChannelOnAppAsync({
+  appId,
+  channelName,
+  branchId,
+}: {
+  appId: string;
+  channelName: string;
+  branchId: string;
+}): Promise<UpdateChannel> {
+  // Point the new channel at a branch with its same name.
+  const branchMapping = JSON.stringify({
+    data: [{ branchId, branchMappingLogic: 'true' }],
+    version: 0,
+  });
+  const data = await withErrorHandlingAsync(
+    graphqlClient
+      .mutation<
+        { updateChannel: { createUpdateChannelForApp: UpdateChannel } },
+        { appId: string; channelName: string; branchMapping: string }
+      >(
+        gql`
+          mutation CreateUpdateChannelForApp(
+            $appId: ID!
+            $channelName: String!
+            $branchMapping: String!
+          ) {
+            updateChannel {
+              createUpdateChannelForApp(
+                appId: $appId
+                channelName: $channelName
+                branchMapping: $branchMapping
+              ) {
+                id
+                channelName
+                branchMapping
+              }
+            }
+          }
+        `,
+        {
+          appId,
+          channelName,
+          branchMapping,
+        }
+      )
+      .toPromise()
+  );
+  return data.updateChannel.createUpdateChannelForApp;
+}
+
+export default class ChannelCreate extends Command {
+  static hidden = true;
+  static description = 'Create a channel on the current project.';
+
+  static args = [
+    {
+      name: 'channelName',
+      required: false,
+      description: 'Name of the channel to create',
+    },
+  ];
+
+  static flags = {
+    json: flags.boolean({
+      description:
+        'print output as a JSON object with the new channel ID, name and branch mapping.',
+      default: false,
+    }),
+  };
+
+  async run() {
+    let {
+      args: { channelName },
+      flags: { json: jsonFlag },
+    } = this.parse(ChannelCreate);
+
+    const projectDir = await findProjectRootAsync(process.cwd());
+    if (!projectDir) {
+      throw new Error('Please run this command inside a project directory.');
+    }
+    const accountName = await getProjectAccountNameAsync(projectDir);
+    const {
+      exp: { slug },
+    } = getConfig(projectDir, { skipSDKVersionRequirement: true });
+    const projectId = await ensureProjectExistsAsync({
+      accountName,
+      projectName: slug,
+    });
+
+    if (!channelName) {
+      const validationMessage = 'Channel name may not be empty.';
+      if (jsonFlag) {
+        throw new Error(validationMessage);
+      }
+      ({ channelName } = await promptAsync({
+        type: 'text',
+        name: 'channelName',
+        message: 'Please name the channel:',
+        validate: value => (value ? true : validationMessage),
+      }));
+    }
+
+    let branchId: string;
+    let branchMessage: string;
+    try {
+      const existingBranch = await getBranchByNameAsync({
+        appId: projectId,
+        branchName: channelName,
+      });
+      branchId = existingBranch.id;
+      branchMessage = `We found a branch with the same name`;
+    } catch (e) {
+      const newBranch = await createUpdateBranchOnAppAsync({
+        appId: projectId,
+        branchName: channelName,
+      });
+      branchId = newBranch.id;
+      branchMessage = `We also went ahead and made a branch with the same name`;
+    }
+
+    const newChannel = await createUpdateChannelOnAppAsync({
+      appId: projectId,
+      channelName,
+      branchId,
+    });
+
+    if (jsonFlag) {
+      Log.log(newChannel);
+      return;
+    }
+
+    Log.withTick(
+      `️Created a new channel ${chalk.bold(newChannel.channelName)} on project ${chalk.bold(
+        `@${accountName}/${slug}`
+      )}. ${branchMessage} and have pointed the channel at it. You can now update your app by publishing!`
+    );
+  }
+}

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

@@ -1,6 +1,6 @@
 import { Command } from '@oclif/command';
 
-import { runCredentialsManagerAsync } from '../credentials/CredentialsManager';
+import { CredentialsManager } from '../credentials/CredentialsManager';
 import { createCredentialsContextAsync } from '../credentials/context';
 import { SelectPlatform } from '../credentials/manager/SelectPlatform';
 
@@ -9,6 +9,6 @@ export default class Credentials extends Command {
 
   async run() {
     const ctx = await createCredentialsContextAsync(process.cwd(), {});
-    await runCredentialsManagerAsync(ctx, new SelectPlatform());
+    new CredentialsManager(ctx).runActionAsync(new SelectPlatform());
   }
 }

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

@@ -0,0 +1,91 @@
+import { Command, flags } from '@oclif/command';
+import assert from 'assert';
+import chalk from 'chalk';
+import ora from 'ora';
+
+import { AppleDeviceQuery } from '../../credentials/ios/api/graphql/queries/AppleDeviceQuery';
+import { AppleTeamQuery } from '../../credentials/ios/api/graphql/queries/AppleTeamQuery';
+import formatDevice from '../../devices/utils/formatDevice';
+import Log from '../../log';
+import { findProjectRootAsync, getProjectAccountNameAsync } from '../../project/projectUtils';
+import { promptAsync } from '../../prompts';
+
+export default class BuildList extends Command {
+  static description = 'list all registered devices for your account';
+
+  static flags = {
+    'apple-team-id': flags.string(),
+  };
+
+  async run() {
+    let appleTeamIdentifier = this.parse(BuildList).flags['apple-team-id'];
+
+    const projectDir = (await findProjectRootAsync()) ?? process.cwd();
+    const accountName = await getProjectAccountNameAsync(projectDir);
+
+    let spinner: ora.Ora;
+
+    if (!appleTeamIdentifier) {
+      spinner = ora().start('Fetching the list of teams for the project…');
+
+      try {
+        const teams = await AppleTeamQuery.getAllForAccountAsync(accountName);
+
+        if (teams.length) {
+          spinner.succeed();
+
+          if (teams.length === 1) {
+            appleTeamIdentifier = teams[0].appleTeamIdentifier;
+          } else {
+            const result = await promptAsync({
+              type: 'select',
+              name: 'appleTeamIdentifier',
+              message: 'What Apple Team would you like to list devices for?',
+              choices: teams.map(team => ({
+                title: `${team.appleTeamName} (ID: ${team.appleTeamIdentifier})`,
+                value: team.appleTeamIdentifier,
+              })),
+            });
+
+            appleTeamIdentifier = result.appleTeamIdentifier;
+          }
+        } else {
+          spinner.fail(`Couldn't find any teams for the account ${accountName}`);
+        }
+      } catch (e) {
+        spinner.fail(`Something went wrong and we couldn't fetch the list of teams`);
+        throw e;
+      }
+    }
+
+    assert(appleTeamIdentifier, 'No team identifier is specified');
+
+    spinner = ora().start('Fetching the list of devices for the team…');
+
+    try {
+      const result = await AppleDeviceQuery.getAllForAppleTeamAsync(
+        accountName,
+        appleTeamIdentifier
+      );
+
+      if (result?.appleDevices.length) {
+        const { appleTeamName, appleDevices } = result;
+
+        spinner.succeed(`Found ${appleDevices.length} devices for team ${appleTeamName}`);
+
+        const list = appleDevices
+          .map(device =>
+            formatDevice(device, { appleTeamName, appleTeamIdentifier: appleTeamIdentifier! })
+          )
+          .join(`\n\n${chalk.dim('———')}\n\n`);
+
+        Log.log(`\n${list}`);
+      } else {
+        spinner.fail(`Couldn't find any devices for the team ${appleTeamIdentifier}`);
+      }
+    } catch (e) {
+      spinner.fail(`Something went wrong and we couldn't fetch the device list`);
+      throw e;
+    }
+  }
+}

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

@@ -0,0 +1,51 @@
+import { Command } from '@oclif/command';
+import ora from 'ora';
+
+import { AppleDeviceQuery } from '../../credentials/ios/api/graphql/queries/AppleDeviceQuery';
+import formatDevice from '../../devices/utils/formatDevice';
+import Log from '../../log';
+import { findProjectRootAsync, getProjectAccountNameAsync } from '../../project/projectUtils';
+
+export default class DeviceView extends Command {
+  static description = 'view a device for your project';
+
+  static args = [{ name: 'UDID' }];
+
+  async run() {
+    const { UDID } = this.parse(DeviceView).args;
+
+    if (!UDID) {
+      Log.log(
+        `The device UDID is required to view a specific device. For example:
+
+   eas device:view 00005787-000872430189501D
+
+If you are not sure what is the UDID of the device you are looking for, run:
+
+   eas device:list
+`
+      );
+      throw new Error('Device UDID is missing');
+    }
+
+    const projectDir = (await findProjectRootAsync()) ?? process.cwd();
+    const accountName = await getProjectAccountNameAsync(projectDir);
+
+    const spinner = ora().start(`Fetching device details for ${UDID}…`);
+
+    try {
+      const device = await AppleDeviceQuery.getByDeviceIdentifier(accountName, UDID);
+
+      if (device) {
+        spinner.succeed('Fetched device details');
+        Log.log(`\n${formatDevice(device, device.appleTeam)}`);
+      } else {
+        spinner.fail(`Couldn't find a device with the UDID ${UDID}`);
+      }
+    } catch (e) {
+      console.log(e);
+      spinner.fail(`Something went wrong and we couldn't fetch the device with UDID ${UDID}`);
+      throw e;
+    }
+  }
+}

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

@@ -1,13 +0,0 @@
-import { Command } from '@oclif/command';
-
-import { showLoginPromptAsync } from '../user/actions';
-
-export default class Login extends Command {
-  static description = 'log in with your EAS account';
-
-  async run() {
-    this.log('Log in to EAS');
-    await showLoginPromptAsync();
-    this.log('Logged in.');
-  }
-}

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

@@ -1,12 +0,0 @@
-import { Command } from '@oclif/command';
-
-import { logoutAsync } from '../user/User';
-
-export default class Logout extends Command {
-  static description = 'log out';
-
-  async run() {
-    await logoutAsync();
-    this.log('Logged out.');
-  }
-}

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

@@ -0,0 +1,231 @@
+import { Command, flags } from '@oclif/command';
+
+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 { ensureLoggedInAsync } from '../user/actions';
+
+const COMMON_FLAGS = '';
+const ANDROID_FLAGS = 'Android specific options';
+const IOS_FLAGS = 'iOS specific options';
+
+export default class BuildSubmit extends Command {
+  static description = 'Submits build artifact to app store';
+  static usage = 'submit --platform=(android|ios)';
+  static aliases = ['build:submit'];
+
+  static examples = [
+    `$ eas submit --platform=ios
+    - Fully interactive iOS submission\n`,
+    `$ eas submit --platform=android
+    - Fully interactive Android submission\n`,
+    `$ eas submit -p android --latest --key=/path/to/google-services.json
+    - Minimal non-interactive Android submission, however it can ask you for other params if not specified\n`,
+    `$ EXPO_APPLE_APP_SPECIFIC_PASSWORD=xxx eas submit -p ios --latest [email protected] --asc-app-id=1234567890,
+    - Minimal non-interactive iOS submission, assuming you already have an app in App Store Connect
+      and provide its App ID`,
+  ];
+
+  static flags = {
+    platform: flags.enum({
+      char: 'p',
+      description: 'For which platform you want to submit a build',
+      options: ['android', 'ios'],
+      helpLabel: COMMON_FLAGS,
+    }),
+
+    /* Common flags for both platforms */
+    latest: flags.boolean({
+      description: 'Submit the latest build for specified platform',
+      exclusive: ['id', 'path', 'url'],
+      default: false,
+      helpLabel: COMMON_FLAGS,
+    }),
+    id: flags.string({
+      description: 'ID of the build to submit',
+      exclusive: ['latest, path, url'],
+      helpLabel: COMMON_FLAGS,
+    }),
+    path: flags.string({
+      description: 'Path to the .apk/.aab file',
+      exclusive: ['latest', 'id', 'url'],
+      helpLabel: COMMON_FLAGS,
+    }),
+    url: flags.string({
+      description: 'App archive url',
+      exclusive: ['latest', 'id', 'path'],
+      helpLabel: COMMON_FLAGS,
+    }),
+
+    verbose: flags.boolean({
+      description: 'Always print logs from Submission Service',
+      default: false,
+      helpLabel: COMMON_FLAGS,
+    }),
+
+    /* Android specific flags */
+    type: flags.enum<'apk' | 'aab'>({
+      description: 'Android archive type',
+      options: ['apk', 'aab'],
+      helpLabel: ANDROID_FLAGS,
+    }),
+
+    key: flags.string({
+      description: 'Path to the JSON key used to authenticate with Google Play',
+      helpLabel: ANDROID_FLAGS,
+    }),
+    'android-package': flags.string({
+      description: 'Android package name (default: expo.android.package from app config)',
+      helpLabel: ANDROID_FLAGS,
+    }),
+
+    track: flags.enum({
+      description: 'The track of the application to use',
+      default: 'internal',
+      options: ['production', 'beta', 'alpha', 'internal', 'rollout'],
+      helpLabel: ANDROID_FLAGS,
+    }),
+    'release-status': flags.enum({
+      description: 'Release status (used when uploading new APKs/AABs)',
+      default: 'completed',
+      options: ['completed', 'draft', 'halted', 'inProgress'],
+      helpLabel: ANDROID_FLAGS,
+    }),
+
+    /* iOS specific flags */
+    'apple-id': flags.string({
+      description: 'Your Apple ID username (you can also set EXPO_APPLE_ID env variable)',
+      helpLabel: IOS_FLAGS,
+    }),
+    'asc-app-id': flags.string({
+      description: `App Store Connect unique application Apple ID number. Providing this param results in skipping app creation step. ${learnMore(
+        'https://expo.fyi/asc-app-id'
+      )}`,
+      helpLabel: IOS_FLAGS,
+    }),
+    'apple-team-id': flags.string({
+      description: 'Your Apple Developer Team ID',
+      helpLabel: IOS_FLAGS,
+    }),
+    'app-name': flags.string({
+      description:
+        'The name of your app as it will appear on the App Store (default: expo.name from app config)',
+      helpLabel: IOS_FLAGS,
+    }),
+    'bundle-identifier': flags.string({
+      description:
+        'Your iOS Bundle Identifier (default: expo.ios.bundleIdentifier from app config)',
+      helpLabel: IOS_FLAGS,
+    }),
+    sku: flags.string({
+      description:
+        'An unique ID for your app that is not visible on the App Store, will be generated unless provided',
+      helpLabel: IOS_FLAGS,
+    }),
+    language: flags.string({
+      description: 'Primary language (e.g. English, German, ...)',
+      default: 'en-US',
+      helpLabel: IOS_FLAGS,
+    }),
+    'company-name': flags.string({
+      description:
+        'The name of your company, needed only for the first upload of any app to App Store',
+      helpLabel: IOS_FLAGS,
+    }),
+  };
+
+  async run(): Promise<void> {
+    const {
+      flags: {
+        // android
+        'android-package': androidPackage,
+        'release-status': releaseStatus,
+
+        // ios
+        'apple-id': appleId,
+        'asc-app-id': ascAppId,
+        'apple-team-id': appleTeamId,
+        'app-name': appName,
+        'bundle-identifier': bundleIdentifier,
+        'company-name': companyName,
+
+        // common
+        platform: platformFromParams,
+        ...flags
+      },
+    } = this.parse(BuildSubmit);
+
+    await ensureLoggedInAsync();
+
+    const platform = platformFromParams ?? (await promptForPlatformAsync());
+
+    const projectDir = (await findProjectRootAsync()) ?? process.cwd();
+    const projectId = await getProjectIdAsync(projectDir);
+
+    if (!(await isEasEnabledForProjectAsync(projectId))) {
+      warnEasUnavailable();
+      process.exitCode = 1;
+      return;
+    }
+
+    // TODO: Make this work outside project dir
+    if (!projectDir) {
+      throw new Error("Please run this command inside your project's directory");
+    }
+
+    if (platform === SubmissionPlatform.Android) {
+      const options: AndroidSubmitCommandFlags = {
+        androidPackage,
+        releaseStatus,
+        ...flags,
+      };
+
+      const ctx = AndroidSubmitCommand.createContext(projectDir, projectId, options);
+      const command = new AndroidSubmitCommand(ctx);
+      await command.runAsync();
+    } else if (platform === SubmissionPlatform.iOS) {
+      const options: IosSubmitCommandFlags = {
+        appleId,
+        ascAppId,
+        appleTeamId,
+        appName,
+        bundleIdentifier,
+        companyName,
+        ...flags,
+      };
+
+      const ctx = IosSubmitCommand.createContext(projectDir, projectId, options);
+      const command = new IosSubmitCommand(ctx);
+      await command.runAsync();
+    } else {
+      throw new Error(`Unsupported platform: ${platform}!`);
+    }
+  }
+}
+
+async function promptForPlatformAsync(): Promise<SubmissionPlatform> {
+  const { platform } = await promptAsync({
+    type: 'select',
+    message: 'Submit to platform',
+    name: 'platform',
+    choices: [
+      {
+        title: 'iOS',
+        value: SubmissionPlatform.iOS,
+      },
+      {
+        title: 'Android',
+        value: SubmissionPlatform.Android,
+      },
+    ],
+  });
+  return platform;
+}

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

@@ -1,11 +0,0 @@
-import { Command } from '@oclif/command';
-
-export default class UpdateIndex extends Command {
-  static description = 'create a revision for given channel';
-
-  static aliases = ['update:publish'];
-
-  async run() {
-    throw new Error('Not implemented');
-  }
-}

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

@@ -1,6 +1,7 @@
 import { Command } from '@oclif/command';
 
 export default class UpdateShow extends Command {
+  static hidden = true;
   static description = 'details about a particular revision';
 
   async run() {

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

@@ -1,19 +0,0 @@
-import { Command } from '@oclif/command';
-import chalk from 'chalk';
-
-import log from '../log';
-import { getUserAsync } from '../user/User';
-
-export default class Whoami extends Command {
-  static description = 'show the username you are logged in as';
-
-  async run() {
-    const user = await getUserAsync();
-    if (user?.username) {
-      log(chalk.green(user.username));
-    } else {
-      log.warn('Not logged in.');
-      process.exit(1);
-    }
-  }
-}

packages/eas-cli/src/credentials/CredentialsManager.ts

@@ -1,69 +1,13 @@
-import log from '../log';
 import { Context } from './context';
 
-export interface CredentialsManager {
-  runActionAsync(action: Action): Promise<void>;
-
-  pushNextAction(action: Action): void;
-
-  popAction(): Action | null;
+export interface Action<T = void> {
+  runAsync(manager: CredentialsManager, ctx: Context): Promise<T>;
 }
 
-export interface Action {
-  runAsync(manager: CredentialsManager, ctx: Context): Promise<void>;
-}
+export class CredentialsManager {
+  constructor(private ctx: Context) {}
 
-export class QuitError extends Error {}
-
-export async function runCredentialsManagerAsync(ctx: Context, startAction: Action): Promise<void> {
-  const manager = new CredentialsManagerImpl(ctx, startAction);
-  await manager.runManagerAsync();
-}
-
-class CredentialsManagerImpl implements CredentialsManager {
-  private actionStack: Action[] = [];
-
-  constructor(private ctx: Context, startAction: Action) {
-    this.actionStack.push(startAction);
-  }
-
-  public pushNextAction(action: Action): void {
-    this.actionStack.push(action);
-  }
-
-  public popAction(): Action | null {
-    return this.actionStack.pop() ?? null;
-  }
-
-  public async runActionAsync(action: Action) {
-    await new CredentialsManagerImpl(this.ctx, action).doRunManagerAsync();
-  }
-
-  public async runManagerAsync(): Promise<void> {
-    try {
-      await this.doRunManagerAsync();
-    } catch (error) {
-      if (error instanceof QuitError) {
-        return;
-      }
-      throw error;
-    }
-  }
-
-  private async doRunManagerAsync(): Promise<void> {
-    while (true) {
-      try {
-        const currentAction = this.popAction();
-        if (!currentAction) {
-          return;
-        }
-        await currentAction.runAsync(this, this.ctx);
-      } catch (error) {
-        if (error instanceof QuitError) {
-          throw error;
-        }
-        log.error(error);
-      }
-    }
+  public async runActionAsync<T>(action: Action<T>): Promise<T> {
+    return await action.runAsync(this, this.ctx);
   }
 }

packages/eas-cli/src/credentials/CredentialsProvider.ts

@@ -0,0 +1,8 @@
+import { Platform } from '@expo/eas-build-job';
+
+export interface CredentialsProvider {
+  platform: Platform;
+  hasRemoteAsync(): Promise<boolean>;
+  hasLocalAsync(): Promise<boolean>;
+  isLocalSyncedAsync(): Promise<boolean>;
+}

packages/eas-cli/src/credentials/__tests__/fixtures-appstore.ts

@@ -0,0 +1,17 @@
+export function getAppstoreMock() {
+  return {
+    ensureAuthenticatedAsync: jest.fn(),
+    ensureBundleIdExistsAsync: jest.fn(),
+    listDistributionCertificatesAsync: jest.fn(),
+    createDistributionCertificateAsync: jest.fn(),
+    revokeDistributionCertificateAsync: jest.fn(),
+    listPushKeysAsync: jest.fn(),
+    createPushKeyAsync: jest.fn(),
+    revokePushKeyAsync: jest.fn(),
+    useExistingProvisioningProfileAsync: jest.fn(),
+    listProvisioningProfilesAsync: jest.fn(),
+    createProvisioningProfileAsync: jest.fn(),
+    revokeProvisioningProfileAsync: jest.fn(),
+    createOrReuseAdhocProvisioningProfileAsync: jest.fn(),
+  };
+}

packages/eas-cli/src/credentials/__tests__/fixtures-constants.ts

@@ -1,14 +1,16 @@
-import { User } from '../../user/User';
+import { Actor } from '../../user/User';
 
-export const jester: User = {
+export const jester: Actor = {
+  __typename: 'User',
+  id: 'jester-id',
   username: 'jester',
-  userId: 'jester-id',
   accounts: [{ id: 'jester-account-id', name: 'jester' }],
 };
 
-export const jester2: User = {
+export const jester2: Actor = {
+  __typename: 'User',
+  id: 'jester2-id',
   username: 'jester2',
-  userId: 'jester2-id',
   accounts: [{ id: 'jester2-account-id', name: 'jester2' }],
 };
 

packages/eas-cli/src/credentials/__tests__/fixtures-context.ts

@@ -3,20 +3,27 @@ import merge from 'lodash/merge';
 import { CredentialsManager } from '../CredentialsManager';
 import { Context } from '../context';
 import { getAndroidApiMockWithoutCredentials } from './fixtures-android';
+import { getAppstoreMock } from './fixtures-appstore';
 import { testAppJson, testUsername } from './fixtures-constants';
+import { getIosApiMockWithoutCredentials } from './fixtures-ios';
+import { getNewIosApiMockWithoutCredentials } from './fixtures-new-ios';
 
 export function createCtxMock(mockOverride: Record<string, any> = {}): Context {
   const defaultMock = {
-    ios: jest.fn(),
+    ios: getIosApiMockWithoutCredentials(),
+    newIos: getNewIosApiMockWithoutCredentials(),
     android: getAndroidApiMockWithoutCredentials(),
-    appStore: jest.fn(),
+    appStore: getAppstoreMock(),
     ensureAppleCtx: jest.fn(),
+    ensureProjectContext: jest.fn(),
     user: {
+      __typename: 'User',
       username: testUsername,
+      accounts: [{ id: 'test-account-id', name: testUsername }],
     },
     hasAppleCtx: jest.fn(() => true),
     hasProjectContext: true,
-    manifest: testAppJson,
+    exp: testAppJson,
     projectDir: '.',
   };
   return merge(defaultMock, mockOverride) as any;
@@ -28,10 +35,6 @@ export function createManagerMock(mockOverride: Record<string, any> = {}): Crede
       runActionAsync: jest.fn(() => {
         throw new Error('unexpected call'); // should be implemented in test directly
       }),
-      pushNextAction: jest.fn(() => {
-        throw new Error('unexpected call'); // should be implemented in test directly
-      }),
-      popAction: jest.fn(),
     },
     mockOverride
   );

packages/eas-cli/src/credentials/__tests__/fixtures-ios.ts

@@ -0,0 +1,216 @@
+import {
+  AppFragment,
+  AppleAppIdentifierFragment,
+  AppleDistributionCertificateFragment,
+  AppleTeamFragment,
+} from '../../graphql/generated';
+import {
+  DistributionCertificate,
+  DistributionCertificateStoreInfo,
+  ProvisioningProfile,
+  ProvisioningProfileStoreInfo,
+  PushKey,
+  PushKeyStoreInfo,
+} from '../ios/appstore/Credentials.types';
+import { IosDistCredentials, IosPushCredentials } from '../ios/credentials';
+import { testProvisioningProfileBase64 } from './fixtures-base64-data';
+import { testBundleIdentifier, testExperienceName } from './fixtures-constants';
+
+const today = new Date();
+const tomorrow = new Date(today.getTime() + 24 * 60 * 60 * 1000);
+
+export const testAppleTeam = {
+  id: 'test-team-id',
+};
+export const testProvisioningProfile: ProvisioningProfile = {
+  provisioningProfileId: 'test-id',
+  provisioningProfile: testProvisioningProfileBase64,
+  teamId: 'id',
+};
+export const testProvisioningProfiles = [testProvisioningProfile];
+export const testProvisioningProfileFromApple: ProvisioningProfileStoreInfo = {
+  name: 'test-name',
+  status: 'Active',
+  expires: tomorrow.getTime(),
+  distributionMethod: 'test',
+  certificates: [],
+  provisioningProfileId: testProvisioningProfile.provisioningProfileId,
+  provisioningProfile: testProvisioningProfile.provisioningProfile,
+  teamId: 'id',
+};
+export const testProvisioningProfilesFromApple = [testProvisioningProfileFromApple];
+
+export const testAppleTeamFragment: AppleTeamFragment = {
+  id: 'test-apple-team-id-1',
+  appleTeamIdentifier: 'test-apple-team-identifier',
+};
+
+export const testAppleAppIdentifierFragment: AppleAppIdentifierFragment = {
+  id: 'test-apple-app-identifier-id-1',
+  bundleIdentifier: 'foo.bar.com',
+};
+
+export const testAppFragment: AppFragment = {
+  id: 'test-app-id',
+  fullName: '@testuser/testapp',
+  slug: 'testapp',
+};
+
+export const testDistCertFragmentNoDependencies: AppleDistributionCertificateFragment = {
+  id: 'test-dist-cert-id-1',
+  certificateP12: 'Y2VydHAxMg==',
+  certificatePassword: 'test-password',
+  serialNumber: 'test-serial',
+  developerPortalIdentifier: 'test-developer-identifier',
+  validityNotAfter: new Date(),
+  validityNotBefore: new Date(),
+  updatedAt: new Date(),
+  appleTeam: { ...testAppleTeamFragment },
+  iosAppBuildCredentialsList: [],
+};
+
+export const testDistCertFragmentOneDependency: AppleDistributionCertificateFragment = {
+  id: 'test-dist-cert-id-1',
+  certificateP12: 'Y2VydHAxMg==',
+  certificatePassword: 'test-password',
+  serialNumber: 'test-serial',
+  developerPortalIdentifier: 'test-developer-identifier',
+  validityNotAfter: new Date(),
+  validityNotBefore: new Date(),
+  updatedAt: new Date(),
+  appleTeam: { ...testAppleTeamFragment },
+  iosAppBuildCredentialsList: [
+    {
+      id: 'test-build-credentials-id',
+      iosAppCredentials: {
+        id: 'test-app-credentials-id',
+        appleAppIdentifier: { ...testAppleAppIdentifierFragment },
+        app: { ...testAppFragment },
+      },
+      provisioningProfile: {
+        id: 'test-provisioning-profile-id',
+        developerPortalIdentifier: 'test-developer-identifier',
+      },
+    },
+  ],
+};
+
+export const testDistCert: DistributionCertificate = {
+  certP12: 'Y2VydHAxMg==',
+  certPassword: 'test-password',
+  distCertSerialNumber: 'test-serial',
+  teamId: 'test-team-id',
+};
+export const testIosDistCredential: IosDistCredentials = {
+  id: 1,
+  type: 'dist-cert',
+  ...testDistCert,
+};
+export const testIosDistCredentials = [testIosDistCredential];
+export const testDistCertFromApple: DistributionCertificateStoreInfo = {
+  id: 'test-id',
+  name: 'test-name',
+  status: 'Active',
+  created: today.getTime(),
+  expires: tomorrow.getTime(),
+  ownerName: 'test-owner',
+  ownerId: 'test-id',
+  serialNumber: testIosDistCredential.distCertSerialNumber as string,
+};
+export const testDistCertsFromApple = [testDistCertFromApple];
+
+export const testPushKey: PushKey = {
+  apnsKeyP8: 'test-p8',
+  apnsKeyId: 'test-key-id',
+  teamId: 'test-team-id',
+};
+
+export const testIosPushCredential: IosPushCredentials = {
+  id: 2,
+  type: 'push-key',
+  ...testPushKey,
+};
+export const testIosPushCredentials = [testIosPushCredential];
+export const testPushKeyFromApple: PushKeyStoreInfo = {
+  id: testIosPushCredential.apnsKeyId,
+  name: 'test-name',
+};
+export const testPushKeysFromApple = [testPushKeyFromApple];
+export const testLegacyPushCert = {
+  pushId: 'test-push-id',
+  pushP12: 'test-push-p12',
+  pushPassword: 'test-push-password',
+};
+export const testAppCredential = {
+  experienceName: testExperienceName,
+  bundleIdentifier: testBundleIdentifier,
+  distCredentialsId: testIosDistCredential.id,
+  pushCredentialsId: testIosPushCredential.id,
+  credentials: {
+    ...testProvisioningProfile,
+  },
+};
+export const testAllCredentialsForApp = {
+  ...testAppCredential,
+  pushCredentials: testPushKey,
+  distCredentials: testDistCert,
+};
+export const testAppCredentials = [testAppCredential];
+export const testAllCredentials = {
+  userCredentials: [...testIosDistCredentials, ...testIosPushCredentials],
+  appCredentials: testAppCredentials,
+};
+
+export function getIosApiMock() {
+  return {
+    getAllCredentials: jest.fn(() => testAllCredentials),
+    getDistributionCertificateAsync: jest.fn(() => testIosDistCredential),
+    getDistributionCertificateByIdAsync: jest.fn(id =>
+      id === testIosDistCredential.id ? testIosDistCredential : null
+    ),
+    createDistributionCertificateAsync: jest.fn((owner, cert) => ({
+      id: 123,
+      type: 'dist-cert',
+      ...cert,
+    })),
+    updateDistributionCertificateAsync: jest.fn(),
+    deleteDistributionCertificateAsync: jest.fn(),
+    useDistributionCertificateAsync: jest.fn(),
+    getPushKey: jest.fn(() => testIosPushCredential),
+    createPushKeyAsync: jest.fn((owner, key) => ({ id: 124, type: 'push-key', ...key })),
+    updatePushKeyAsync: jest.fn(),
+    deletePushKeyAsync: jest.fn(),
+    usePushKeyAsync: jest.fn(),
+
+    getAppCredentialsAsync: jest.fn(() => testAppCredentials),
+    getProvisioningProfileAsync: jest.fn(() => testProvisioningProfile),
+    updateProvisioningProfileAsync: jest.fn(),
+    deleteProvisioningProfileAsync: jest.fn(),
+  };
+}
+
+export function getIosApiMockWithoutCredentials() {
+  return {
+    getAllCredentials: jest.fn(() => ({ appCredentials: [], userCredentials: [] })),
+    getDistributionCertificateAsync: jest.fn(() => null),
+    getDistributionCertificateByIdAsync: jest.fn(() => {
+      throw new Error('not found');
+    }),
+    createDistributionCertificateAsync: jest.fn(),
+    updateDistributionCertificateAsync: jest.fn(),
+    deleteDistributionCertificateAsync: jest.fn(),
+    useDistributionCertificateAsync: jest.fn(),
+    getPushKeyAsync: jest.fn(() => null),
+    createPushKeyAsync: jest.fn(),
+    updatePushKeyAsync: jest.fn(),
+    deletePushKeyAsync: jest.fn(),
+    usePushKeyAsync: jest.fn(),
+    getAppCredentialsAsync: jest.fn(app => ({
+      experienceName: `${app.accountName}/${app.projectName}`,
+      bundleIdentifier: app.bundleIdentifier,
+    })),
+    getProvisioningProfileAsync: jest.fn(() => null),
+    updateProvisioningProfileAsync: jest.fn(),
+    deleteProvisioningProfileAsync: jest.fn(),
+  };
+}

packages/eas-cli/src/credentials/__tests__/fixtures-new-ios.ts

@@ -0,0 +1,141 @@
+import {
+  DistributionCertificate,
+  DistributionCertificateStoreInfo,
+  ProvisioningProfile,
+  ProvisioningProfileStoreInfo,
+  PushKey,
+  PushKeyStoreInfo,
+} from '../ios/appstore/Credentials.types';
+import { IosDistCredentials, IosPushCredentials } from '../ios/credentials';
+import { testProvisioningProfileBase64 } from './fixtures-base64-data';
+import { testBundleIdentifier, testExperienceName } from './fixtures-constants';
+
+const today = new Date();
+const tomorrow = new Date(today.getTime() + 24 * 60 * 60 * 1000);
+
+export const testAppleTeam = {
+  id: 'test-team-id',
+};
+export const testProvisioningProfile: ProvisioningProfile = {
+  provisioningProfileId: 'test-id',
+  provisioningProfile: testProvisioningProfileBase64,
+  teamId: 'id',
+};
+export const testProvisioningProfiles = [testProvisioningProfile];
+export const testProvisioningProfileFromApple: ProvisioningProfileStoreInfo = {
+  name: 'test-name',
+  status: 'Active',
+  expires: tomorrow.getTime(),
+  distributionMethod: 'test',
+  certificates: [],
+  provisioningProfileId: testProvisioningProfile.provisioningProfileId,
+  provisioningProfile: testProvisioningProfile.provisioningProfile,
+  teamId: 'id',
+};
+export const testProvisioningProfilesFromApple = [testProvisioningProfileFromApple];
+
+export const testDistCert: DistributionCertificate = {
+  certP12: 'Y2VydHAxMg==',
+  certPassword: 'test-password',
+  distCertSerialNumber: 'test-serial',
+  teamId: 'test-team-id',
+};
+export const testIosDistCredential: IosDistCredentials = {
+  id: 1,
+  type: 'dist-cert',
+  ...testDistCert,
+};
+export const testIosDistCredentials = [testIosDistCredential];
+export const testDistCertFromApple: DistributionCertificateStoreInfo = {
+  id: 'test-id',
+  name: 'test-name',
+  status: 'Active',
+  created: today.getTime(),
+  expires: tomorrow.getTime(),
+  ownerName: 'test-owner',
+  ownerId: 'test-id',
+  serialNumber: testIosDistCredential.distCertSerialNumber as string,
+};
+export const testDistCertsFromApple = [testDistCertFromApple];
+
+export const testPushKey: PushKey = {
+  apnsKeyP8: 'test-p8',
+  apnsKeyId: 'test-key-id',
+  teamId: 'test-team-id',
+};
+
+export const testIosPushCredential: IosPushCredentials = {
+  id: 2,
+  type: 'push-key',
+  ...testPushKey,
+};
+export const testIosPushCredentials = [testIosPushCredential];
+export const testPushKeyFromApple: PushKeyStoreInfo = {
+  id: testIosPushCredential.apnsKeyId,
+  name: 'test-name',
+};
+export const testPushKeysFromApple = [testPushKeyFromApple];
+export const testLegacyPushCert = {
+  pushId: 'test-push-id',
+  pushP12: 'test-push-p12',
+  pushPassword: 'test-push-password',
+};
+export const testAppCredential = {
+  experienceName: testExperienceName,
+  bundleIdentifier: testBundleIdentifier,
+  distCredentialsId: testIosDistCredential.id,
+  pushCredentialsId: testIosPushCredential.id,
+  credentials: {
+    ...testProvisioningProfile,
+  },
+};
+export const testAllCredentialsForApp = {
+  ...testAppCredential,
+  pushCredentials: testPushKey,
+  distCredentials: testDistCert,
+};
+export const testAppCredentials = [testAppCredential];
+export const testAllCredentials = {
+  userCredentials: [...testIosDistCredentials, ...testIosPushCredentials],
+  appCredentials: testAppCredentials,
+};
+
+export function getNewIosApiMockWithoutCredentials() {
+  return {
+    getAppAsync: jest.fn(),
+    createOrUpdateIosAppBuildCredentialsAsync: jest.fn(),
+    getIosAppCredentialsWithBuildCredentialsAsync: jest.fn(),
+    createOrGetExistingIosAppCredentialsWithBuildCredentialsAsync: jest.fn(),
+    createOrGetExistingAppleTeamAsync: jest.fn(),
+    createOrGetExistingAppleAppIdentifierAsync: jest.fn(),
+    getDevicesForAppleTeamAsync: jest.fn(),
+    createProvisioningProfileAsync: jest.fn(),
+    getProvisioningProfileAsync: jest.fn(),
+    updateProvisioningProfileAsync: jest.fn(),
+    deleteProvisioningProfilesAsync: jest.fn(),
+    getDistributionCertificateForAppAsync: jest.fn(),
+    getDistributionCertificatesForAccountAsync: jest.fn(),
+    createDistributionCertificateAsync: jest.fn(),
+    deleteDistributionCertificateAsync: jest.fn(),
+  };
+}
+
+export function getNewIosApiMockWithCredentials() {
+  return {
+    getAppAsync: jest.fn(),
+    createOrUpdateIosAppBuildCredentialsAsync: jest.fn(),
+    getIosAppCredentialsWithBuildCredentialsAsync: jest.fn(),
+    createOrGetExistingIosAppCredentialsWithBuildCredentialsAsync: jest.fn(),
+    createOrGetExistingAppleTeamAsync: jest.fn(),
+    createOrGetExistingAppleAppIdentifierAsync: jest.fn(),
+    getDevicesForAppleTeamAsync: jest.fn(),
+    createProvisioningProfileAsync: jest.fn(),
+    getProvisioningProfileAsync: jest.fn(),
+    updateProvisioningProfileAsync: jest.fn(),
+    deleteProvisioningProfilesAsync: jest.fn(),
+    getDistributionCertificateForAppAsync: jest.fn(),
+    getDistributionCertificatesForAccountAsync: jest.fn(),
+    createDistributionCertificateAsync: jest.fn(),
+    deleteDistributionCertificateAsync: jest.fn(),
+  };
+}

packages/eas-cli/src/credentials/android/AndroidCredentialsProvider.ts

@@ -0,0 +1,101 @@
+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';
+import { Keystore } from './credentials';
+
+export interface AndroidCredentials {
+  keystore: Keystore;
+}
+
+interface AppLookupParams {
+  projectName: string;
+  accountName: string;
+}
+
+interface Options {
+  app: AppLookupParams;
+  skipCredentialsCheck?: boolean;
+}
+
+export default class AndroidCredentialsProvider implements CredentialsProvider {
+  public readonly platform = Platform.Android;
+
+  constructor(private ctx: Context, private options: Options) {}
+
+  private get projectFullName(): string {
+    const { projectName, accountName } = this.options.app;
+    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> {
+    switch (src) {
+      case CredentialsSource.LOCAL:
+        return await this.getLocalAsync();
+      case CredentialsSource.REMOTE:
+        return await this.getRemoteAsync();
+    }
+    throw new Error('Unknown');
+  }
+
+  private async getRemoteAsync(): Promise<AndroidCredentials> {
+    await new CredentialsManager(this.ctx).runActionAsync(
+      new SetupBuildCredentials(this.projectFullName)
+    );
+    const keystore = await this.ctx.android.fetchKeystoreAsync(this.projectFullName);
+    if (!keystore) {
+      throw new Error('Unable to set up credentials, failed to fetch keystore from EAS servers');
+    }
+    return { keystore };
+  }
+
+  private async getLocalAsync(): Promise<AndroidCredentials> {
+    return await credentialsJsonReader.readAndroidCredentialsAsync(this.ctx.projectDir);
+  }
+}

packages/eas-cli/src/credentials/android/actions/DownloadKeystore.ts

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import fs from 'fs-extra';
 
-import log from '../../../log';
+import Log from '../../../log';
 import { confirmAsync } from '../../../prompts';
 import { maybeRenameExistingFileAsync } from '../../../utils/files';
 import { Action, CredentialsManager } from '../../CredentialsManager';
@@ -18,7 +18,7 @@ export class DownloadKeystore implements Action {
   public async runAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
     const keystore = await ctx.android.fetchKeystoreAsync(this.projectFullName);
     if (!keystore) {
-      log.warn('There is no valid Keystore defined for this app');
+      Log.warn('There is no valid Keystore defined for this app');
       return;
     }
 
@@ -34,11 +34,11 @@ export class DownloadKeystore implements Action {
 
     await maybeRenameExistingFileAsync(ctx.projectDir, keystorePath);
 
-    log(`Saving Keystore to ${keystorePath}`);
+    Log.log(`Saving Keystore to ${keystorePath}`);
     await fs.writeFile(keystorePath, keystore.keystore, 'base64');
 
     if (displayCredentials) {
-      log(`Keystore credentials
+      Log.log(`Keystore credentials
   Keystore password: ${chalk.bold(keystore.keystorePassword)}
   Key alias:         ${chalk.bold(keystore.keyAlias)}
   Key password:      ${chalk.bold(keystore.keyPassword)}
@@ -54,7 +54,7 @@ export class BackupKeystore implements Action {
 
   public async runAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
     if (await ctx.android.fetchKeystoreAsync(this.projectFullName)) {
-      log.warn('Backing up your old Android Keystore now...');
+      Log.warn('Backing up your old Android Keystore now...');
       await manager.runActionAsync(
         new DownloadKeystore(this.projectFullName, {
           displayCredentials: true,

packages/eas-cli/src/credentials/android/actions/FcmKey.ts

@@ -1,6 +1,4 @@
-import chalk from 'chalk';
-
-import log from '../../../log';
+import Log from '../../../log';
 import { promptAsync } from '../../../prompts';
 import { Action, CredentialsManager } from '../../CredentialsManager';
 import { Context } from '../../context';
@@ -19,6 +17,6 @@ export class UpdateFcmKey implements Action {
     ]);
 
     await ctx.android.updateFcmKeyAsync(this.experienceName, fcmApiKey);
-    log(chalk.green('Updated successfully'));
+    Log.succeed('Updated successfully');
   }
 }

packages/eas-cli/src/credentials/android/actions/RemoveKeystore.ts

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 
-import log from '../../../log';
+import Log from '../../../log';
 import { confirmAsync } from '../../../prompts';
 import { Action, CredentialsManager } from '../../CredentialsManager';
 import { Context } from '../../context';
@@ -11,7 +11,7 @@ export class RemoveKeystore implements Action {
 
   async runAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
     if (!(await ctx.android.fetchKeystoreAsync(this.projectFullName))) {
-      log.warn('There is no Keystore defined for this app.');
+      Log.warn('There is no Keystore defined for this app.');
       return;
     }
 
@@ -31,29 +31,29 @@ export class RemoveKeystore implements Action {
       await manager.runActionAsync(new BackupKeystore(this.projectFullName));
 
       await ctx.android.removeKeystoreAsync(this.projectFullName);
-      log(chalk.green('Keystore removed successfully.'));
+      Log.succeed('Keystore removed');
     }
   }
 
   displayWarning() {
-    log.newLine();
-    log.warn(
+    Log.newLine();
+    Log.warn(
       `Clearing your Android build credentials from our build servers is a ${chalk.bold(
         'PERMANENT and IRREVERSIBLE action.'
       )}`
     );
-    log.warn(
+    Log.warn(
       chalk.bold(
         'Android Keystore must be identical to the one previously used to submit your app to the Google Play Store.'
       )
     );
-    log.warn(
+    Log.warn(
       'Please read https://docs.expo.io/distribution/building-standalone-apps/#if-you-choose-to-build-for-android for more info before proceeding.'
     );
-    log.newLine();
-    log.warn(
+    Log.newLine();
+    Log.warn(
       chalk.bold('Your Keystore will be backed up to your current directory if you continue.')
     );
-    log.newLine();
+    Log.newLine();
   }
 }

packages/eas-cli/src/credentials/android/actions/SetupBuildCredentials.ts

@@ -1,5 +1,8 @@
+import Log from '../../../log';
 import { Action, CredentialsManager } from '../../CredentialsManager';
 import { Context } from '../../context';
+import { readAndroidCredentialsAsync } from '../../credentialsJson/read';
+import { validateKeystoreAsync } from '../utils/keystore';
 import { UpdateKeystore } from './UpdateKeystore';
 
 export class SetupBuildCredentials implements Action {
@@ -13,6 +16,30 @@ export class SetupBuildCredentials implements Action {
       throw new Error('Generating a new Keystore is not supported in --non-interactive mode');
     }
 
-    manager.pushNextAction(new UpdateKeystore(this.projectFullName));
+    await manager.runActionAsync(new UpdateKeystore(this.projectFullName));
+  }
+}
+
+export class SetupBuildCredentialsFromCredentialsJson implements Action {
+  constructor(
+    private projectFullName: string,
+    private options: { skipKeystoreValidation: boolean }
+  ) {}
+
+  async runAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
+    let localCredentials;
+    try {
+      localCredentials = await readAndroidCredentialsAsync(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;
+    }
+    if (!this.options.skipKeystoreValidation) {
+      await validateKeystoreAsync(localCredentials.keystore);
+    }
+    await ctx.android.updateKeystoreAsync(this.projectFullName, localCredentials.keystore);
+    Log.succeed('Keystore updated');
   }
 }

packages/eas-cli/src/credentials/android/actions/UpdateCredentialsJson.ts

@@ -0,0 +1,16 @@
+import Log from '../../../log';
+import { Action, CredentialsManager } from '../../CredentialsManager';
+import { Context } from '../../context';
+import { updateAndroidCredentialsAsync } from '../../credentialsJson/update';
+
+export class UpdateCredentialsJson implements Action {
+  constructor(private projectFullName: string) {}
+
+  async runAsync(manager: CredentialsManager, ctx: Context): Promise<void> {
+    Log.log('Updating Android credentials in credentials.json');
+    await updateAndroidCredentialsAsync(ctx);
+    Log.succeed(
+      'Android part of your local credentials.json is synced with values stored on EAS servers.'
+    );
+  }
+}

packages/eas-cli/src/credentials/android/actions/UpdateKeystore.ts

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 
-import log from '../../../log';
+import Log from '../../../log';
 import { Action, CredentialsManager } from '../../CredentialsManager';
 import { Context } from '../../context';
 import { askForUserProvidedAsync } from '../../utils/promptForCredentials';
@@ -17,7 +17,7 @@ export class UpdateKeystore implements Action {
     const keystore = await this.provideOrGenerateAsync();
 
     await ctx.android.updateKeystoreAsync(this.projectFullName, keystore);
-    log(chalk.green('Keystore updated successfully.'));
+    Log.succeed('Keystore updated');
   }
 
   private async provideOrGenerateAsync(): Promise<Keystore> {
@@ -30,17 +30,17 @@ export class UpdateKeystore implements Action {
   }
 
   private displayWarning() {
-    log.newLine();
-    log.warn(
+    Log.newLine();
+    Log.warn(
       `Updating your Android build credentials will remove previous version from our servers, this is a ${chalk.bold(
         'PERMANENT and IRREVERSIBLE action.'
       )}`
     );
-    log.warn(
+    Log.warn(
       chalk.bold(
         'Android Keystore must be identical to the one previously used to submit your app to the Google Play Store.'
       )
     );
-    log.newLine();
+    Log.newLine();
   }
 }