eas-cli 3.18.3 → 4.0.1

package/build/devices/actions/create/currentMachineMethod.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCurrentMachineMethodAsync = void 0;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const os_1 = tslib_1.__importDefault(require("os"));
+const AppleDeviceMutation_1 = require("../../../credentials/ios/api/graphql/mutations/AppleDeviceMutation");
+const generated_1 = require("../../../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const ora_1 = require("../../../ora");
+const prompts_1 = require("../../../prompts");
+const errors_1 = require("../../utils/errors");
+const utils_1 = require("./utils");
+async function runCurrentMachineMethodAsync(graphqlClient, accountId, appleTeam) {
+    log_1.default.newLine();
+    log_1.default.log(chalk_1.default.white('Checking if current machine is an Apple Silicon one.'));
+    if (!isMachineAppleSilicon()) {
+        throw new errors_1.DeviceCreateError("Current machine is not of Apple Silicon type - provisioning UDID can't be added automatically.");
+    }
+    log_1.default.log(chalk_1.default.green('Check successful.'));
+    await collectDataAndRegisterDeviceAsync(graphqlClient, { accountId, appleTeam });
+}
+exports.runCurrentMachineMethodAsync = runCurrentMachineMethodAsync;
+function isMachineAppleSilicon() {
+    return os_1.default.cpus()[0].model.includes('Apple M') && process.platform === 'darwin';
+}
+async function collectDataAndRegisterDeviceAsync(graphqlClient, { accountId, appleTeam, }) {
+    const deviceData = await collectDeviceDataAsync(appleTeam);
+    if (!deviceData) {
+        return;
+    }
+    const { udid, deviceClass, name } = deviceData;
+    const spinner = (0, ora_1.ora)(`Registering Apple device on Expo`).start();
+    try {
+        await AppleDeviceMutation_1.AppleDeviceMutation.createAppleDeviceAsync(graphqlClient, {
+            appleTeamId: appleTeam.id,
+            identifier: udid,
+            name,
+            deviceClass: deviceClass !== null && deviceClass !== void 0 ? deviceClass : undefined,
+        }, accountId);
+    }
+    catch (err) {
+        spinner.fail();
+        throw err;
+    }
+    spinner.succeed();
+}
+async function collectDeviceDataAsync(appleTeam, initialValues = {}) {
+    log_1.default.log(chalk_1.default.white('Fetching the provisioning UDID.'));
+    const [udid, defaultMachineName] = await fetchCurrentMachineUDIDAsync();
+    log_1.default.log(chalk_1.default.green(`Fetched the provisioning UDID - ${udid}`));
+    const name = await (0, utils_1.promptForNameAsync)(defaultMachineName !== null && defaultMachineName !== void 0 ? defaultMachineName : initialValues.name);
+    const deviceClass = generated_1.AppleDeviceClass.Mac;
+    const deviceData = {
+        udid,
+        name,
+        deviceClass,
+    };
+    (0, utils_1.printDeviceData)(deviceData, appleTeam);
+    const registrationConfirmed = await (0, prompts_1.confirmAsync)({
+        message: 'Is this what you want to register?',
+    });
+    if (!registrationConfirmed) {
+        log_1.default.log('No worries, just try again.');
+        log_1.default.newLine();
+        return null;
+    }
+    else {
+        return deviceData;
+    }
+}
+async function fetchCurrentMachineUDIDAsync() {
+    var _a, _b;
+    try {
+        const profilerData = (await (0, spawn_async_1.default)('system_profiler', ['-json', 'SPHardwareDataType'])).stdout.trim();
+        if (!profilerData) {
+            const message = 'Failed to fetch the provisioning UDID from system profiler';
+            log_1.default.error(message);
+            throw new errors_1.DeviceCreateError(message);
+        }
+        const profilerDataJSON = JSON.parse(profilerData);
+        const provisioningUDID = (_a = profilerDataJSON === null || profilerDataJSON === void 0 ? void 0 : profilerDataJSON.SPHardwareDataType[0]) === null || _a === void 0 ? void 0 : _a.provisioning_UDID;
+        if (!provisioningUDID) {
+            const message = 'System profiler data did not contain the provisioning UDID';
+            log_1.default.error(message);
+            throw new errors_1.DeviceCreateError(message);
+        }
+        const defaultMachineName = (_b = profilerDataJSON === null || profilerDataJSON === void 0 ? void 0 : profilerDataJSON.SPHardwareDataType[0]) === null || _b === void 0 ? void 0 : _b.machine_name;
+        return [provisioningUDID, defaultMachineName];
+    }
+    catch (err) {
+        if (!(err instanceof errors_1.DeviceCreateError)) {
+            const message = `Failed to fetch the provisioning UDID of the current machine - ${err.message}`;
+            log_1.default.error(message);
+            throw new errors_1.DeviceCreateError(message);
+        }
+        throw err;
+    }
+}

package/build/devices/actions/create/developerPortalMethod.js

@@ -15,6 +15,7 @@ const DEVICE_IMPORT_CHUNK_SIZE = 10;
 const DEVICE_CLASS_TO_GRAPHQL_TYPE = {
     [apple_utils_1.DeviceClass.IPAD]: generated_1.AppleDeviceClass.Ipad,
     [apple_utils_1.DeviceClass.IPHONE]: generated_1.AppleDeviceClass.Iphone,
+    [apple_utils_1.DeviceClass.MAC]: generated_1.AppleDeviceClass.Mac,
 };
 async function runDeveloperPortalMethodAsync(graphqlClient, appStoreApi, accountId, appleTeam) {
     const appleAuthCtx = await appStoreApi.ensureAuthenticatedAsync();
@@ -61,7 +62,7 @@ async function findUnregisteredPortalDevicesAsync(graphqlClient, appleAuthCtx, a
     }, {});
     const portalDevices = await apple_utils_1.Device.getAsync((0, authenticate_1.getRequestContext)(appleAuthCtx));
     return portalDevices.filter(portalDevice => !(portalDevice.attributes.udid in expoRegisteredDevicesByUdid) &&
-        [apple_utils_1.DeviceClass.IPAD, apple_utils_1.DeviceClass.IPHONE, apple_utils_1.DeviceClass.APPLE_TV].includes(portalDevice.attributes.deviceClass));
+        [apple_utils_1.DeviceClass.IPAD, apple_utils_1.DeviceClass.IPHONE, apple_utils_1.DeviceClass.APPLE_TV, apple_utils_1.DeviceClass.MAC].includes(portalDevice.attributes.deviceClass));
 }
 async function chooseDevicesToImportAsync(devices) {
     const { chosenDevices } = await (0, prompts_1.promptAsync)({

package/build/devices/actions/create/inputMethod.d.ts

@@ -1,4 +1,3 @@
 import { ExpoGraphqlClient } from '../../../commandUtils/context/contextUtils/createGraphqlClient';
 import { AppleTeam } from '../../../graphql/generated';
 export declare function runInputMethodAsync(graphqlClient: ExpoGraphqlClient, accountId: string, appleTeam: Pick<AppleTeam, 'appleTeamIdentifier' | 'appleTeamName' | 'id'>): Promise<void>;
-export declare function promptForUDIDAsync(initial?: string): Promise<string>;

package/build/devices/actions/create/inputMethod.js

@@ -1,15 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promptForUDIDAsync = exports.runInputMethodAsync = void 0;
+exports.runInputMethodAsync = void 0;
 const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const AppleDeviceMutation_1 = require("../../../credentials/ios/api/graphql/mutations/AppleDeviceMutation");
-const generated_1 = require("../../../graphql/generated");
 const log_1 = tslib_1.__importDefault(require("../../../log"));
 const ora_1 = require("../../../ora");
 const prompts_1 = require("../../../prompts");
-const udids_1 = require("../../udids");
-const formatDevice_1 = require("../../utils/formatDevice");
+const utils_1 = require("./utils");
 async function runInputMethodAsync(graphqlClient, accountId, appleTeam) {
     log_1.default.newLine();
     log_1.default.log(chalk_1.default.yellow('This is an advanced option. Use at your own risk.'));
@@ -42,20 +40,15 @@ async function collectDataAndRegisterDeviceAsync(graphqlClient, { accountId, app
     spinner.succeed();
 }
 async function collectDeviceDataAsync(appleTeam, initialValues = {}) {
-    const udid = await promptForUDIDAsync(initialValues.udid);
-    const name = await promptForNameAsync(initialValues.name);
-    const deviceClass = await promptForDeviceClassAsync(initialValues.deviceClass);
+    const udid = await (0, utils_1.promptForUDIDAsync)(initialValues.udid);
+    const name = await (0, utils_1.promptForNameAsync)(initialValues.name);
+    const deviceClass = await (0, utils_1.promptForDeviceClassAsync)(initialValues.deviceClass);
     const deviceData = {
         udid,
         name,
         deviceClass,
     };
-    log_1.default.newLine();
-    log_1.default.log(`We are going to register the following device in our database.
-This device will ${chalk_1.default.bold('not')} be registered on the Apple Developer Portal until it is chosen for an internal distribution build.`);
-    log_1.default.newLine();
-    log_1.default.log((0, formatDevice_1.formatNewDevice)({ ...deviceData, identifier: deviceData.udid }, appleTeam));
-    log_1.default.newLine();
+    (0, utils_1.printDeviceData)(deviceData, appleTeam);
     const registrationConfirmed = await (0, prompts_1.confirmAsync)({
         message: 'Is this what you want to register?',
     });
@@ -68,54 +61,3 @@ This device will ${chalk_1.default.bold('not')} be registered on the Apple Devel
         return deviceData;
     }
 }
-async function promptForUDIDAsync(initial) {
-    const { udid } = await (0, prompts_1.promptAsync)({
-        type: 'text',
-        name: 'udid',
-        message: 'UDID:',
-        initial,
-        validate: (rawVal) => {
-            const val = (0, udids_1.normalizeUDID)(rawVal);
-            if (!val || val === '') {
-                return 'UDID cannot be empty';
-            }
-            else if (val.length !== 25 && val.length !== 40) {
-                return 'UDID should be a 25 or 40-character string';
-            }
-            else if (!(0, udids_1.isValidUDID)(val)) {
-                return 'UDID is invalid';
-            }
-            else {
-                return true;
-            }
-        },
-        format: (val) => (0, udids_1.normalizeUDID)(val),
-    });
-    return udid;
-}
-exports.promptForUDIDAsync = promptForUDIDAsync;
-async function promptForNameAsync(initial) {
-    const { name } = await (0, prompts_1.promptAsync)({
-        type: 'text',
-        name: 'name',
-        message: 'Device name (optional):',
-        initial,
-    });
-    return name;
-}
-async function promptForDeviceClassAsync(initial) {
-    const choices = [
-        { title: 'iPhone', value: generated_1.AppleDeviceClass.Iphone },
-        { title: 'iPad', value: generated_1.AppleDeviceClass.Ipad },
-        { title: 'Not sure (leave empty)', value: null },
-    ];
-    const values = choices.map(({ value }) => value);
-    const { deviceClass } = await (0, prompts_1.promptAsync)({
-        type: 'select',
-        name: 'deviceClass',
-        message: 'Device class (optional):',
-        choices,
-        initial: initial !== undefined && values.indexOf(initial),
-    });
-    return deviceClass;
-}

package/build/devices/actions/create/utils.d.ts

@@ -0,0 +1,10 @@
+import { AppleDeviceClass, AppleTeam } from '../../../graphql/generated';
+export interface DeviceData {
+    udid: string;
+    name?: string;
+    deviceClass: AppleDeviceClass | null;
+}
+export declare function promptForDeviceClassAsync(initial?: AppleDeviceClass | null): Promise<AppleDeviceClass | null>;
+export declare function promptForNameAsync(initial?: string): Promise<string | undefined>;
+export declare function promptForUDIDAsync(initial?: string): Promise<string>;
+export declare function printDeviceData(deviceData: DeviceData, appleTeam: Pick<AppleTeam, 'appleTeamIdentifier' | 'appleTeamName'>): void;

package/build/devices/actions/create/utils.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printDeviceData = exports.promptForUDIDAsync = exports.promptForNameAsync = exports.promptForDeviceClassAsync = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const generated_1 = require("../../../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+const udids_1 = require("../../udids");
+const formatDevice_1 = require("../../utils/formatDevice");
+async function promptForDeviceClassAsync(initial) {
+    const choices = [
+        { title: 'iPhone', value: generated_1.AppleDeviceClass.Iphone },
+        { title: 'iPad', value: generated_1.AppleDeviceClass.Ipad },
+        { title: 'Mac', value: generated_1.AppleDeviceClass.Mac },
+        { title: 'Not sure (leave empty)', value: null },
+    ];
+    const values = choices.map(({ value }) => value);
+    const { deviceClass } = await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'deviceClass',
+        message: 'Device class (optional):',
+        choices,
+        initial: initial !== undefined && values.indexOf(initial),
+    });
+    return deviceClass;
+}
+exports.promptForDeviceClassAsync = promptForDeviceClassAsync;
+async function promptForNameAsync(initial) {
+    const { name } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'name',
+        message: 'Device name (optional):',
+        initial,
+    });
+    return name;
+}
+exports.promptForNameAsync = promptForNameAsync;
+async function promptForUDIDAsync(initial) {
+    const { udid } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'udid',
+        message: 'UDID:',
+        initial,
+        validate: (rawVal) => {
+            const val = (0, udids_1.normalizeUDID)(rawVal);
+            if (!val || val === '') {
+                return 'UDID cannot be empty';
+            }
+            else if (val.length !== 25 && val.length !== 40) {
+                return 'UDID should be a 25 or 40-character string';
+            }
+            else if (!(0, udids_1.isValidUDID)(val)) {
+                return 'UDID is invalid';
+            }
+            else {
+                return true;
+            }
+        },
+        format: (val) => (0, udids_1.normalizeUDID)(val),
+    });
+    return udid;
+}
+exports.promptForUDIDAsync = promptForUDIDAsync;
+function printDeviceData(deviceData, appleTeam) {
+    log_1.default.newLine();
+    log_1.default.log(`We are going to register the following device in our database.
+  This device will ${chalk_1.default.bold('not')} be registered on the Apple Developer Portal until it is chosen for an internal distribution build.`);
+    log_1.default.newLine();
+    log_1.default.log((0, formatDevice_1.formatNewDevice)({ ...deviceData, identifier: deviceData.udid }, appleTeam));
+    log_1.default.newLine();
+}
+exports.printDeviceData = printDeviceData;

package/build/devices/manager.js

@@ -10,10 +10,10 @@ const log_1 = tslib_1.__importDefault(require("../log"));
 const projectUtils_1 = require("../project/projectUtils");
 const prompts_1 = require("../prompts");
 const action_1 = tslib_1.__importDefault(require("./actions/create/action"));
-const CREATE_COMMAND_DESCRIPTION = `This command lets you register your Apple devices (iPhones and iPads) for internal distribution of your app.
+const CREATE_COMMAND_DESCRIPTION = `This command lets you register your Apple devices (iPhones, iPads and Macs) for internal distribution of your app.
 Internal distribution means that you won't need to upload your app archive to App Store / Testflight.
-Your app archive (.ipa) will be installable on your equipment as long as you sign your application with an adhoc provisiong profile.
-The provisioning profile needs to contain the UDIDs (unique identifiers) of your iPhones and iPads.
+Your app archive (.ipa) will be installable on your equipment as long as you sign your application with an adhoc provisioning profile.
+The provisioning profile needs to contain the UDIDs (unique identifiers) of your iPhones, iPads and Macs.
 
 First of all, choose the Expo account under which you want to register your devices.
 Later, authenticate with Apple and choose your desired Apple Team (if your Apple ID has access to multiple teams).`;

package/build/devices/utils/errors.d.ts

@@ -1,3 +1,6 @@
 export declare class DeviceNotFoundError extends Error {
     constructor(message?: string);
 }
+export declare class DeviceCreateError extends Error {
+    constructor(message?: string);
+}

package/build/devices/utils/errors.js

@@ -1,9 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceNotFoundError = void 0;
+exports.DeviceCreateError = exports.DeviceNotFoundError = void 0;
 class DeviceNotFoundError extends Error {
     constructor(message) {
         super(message !== null && message !== void 0 ? message : 'Device not found.');
     }
 }
 exports.DeviceNotFoundError = DeviceNotFoundError;
+class DeviceCreateError extends Error {
+    constructor(message) {
+        super(message !== null && message !== void 0 ? message : 'Failed to create a device.');
+    }
+}
+exports.DeviceCreateError = DeviceCreateError;

package/build/devices/utils/formatDevice.js

@@ -7,6 +7,7 @@ const formatFields_1 = tslib_1.__importDefault(require("../../utils/formatFields
 const DEVICE_CLASS_DISPLAY_NAMES = {
     [generated_1.AppleDeviceClass.Iphone]: 'iPhone',
     [generated_1.AppleDeviceClass.Ipad]: 'iPad',
+    [generated_1.AppleDeviceClass.Mac]: 'Mac',
 };
 function formatDeviceClass(device) {
     if (!device.deviceClass || !DEVICE_CLASS_DISPLAY_NAMES[device.deviceClass]) {

package/build/graphql/generated.d.ts

@@ -1391,7 +1391,8 @@ export type AppleDevice = {
 };
 export declare enum AppleDeviceClass {
     Ipad = "IPAD",
-    Iphone = "IPHONE"
+    Iphone = "IPHONE",
+    Mac = "MAC"
 }
 export type AppleDeviceInput = {
     appleTeamId: Scalars['ID'];
@@ -3713,7 +3714,7 @@ export type SsoUser = Actor & UserActor & {
     twitterUsername?: Maybe<Scalars['String']>;
     username: Scalars['String'];
     /** Web notifications linked to a user */
-    webNotifications: Array<Notification>;
+    websiteNotifications: Array<Notification>;
 };
 /** Represents a human SSO (not robot) actor. */
 export type SsoUserActivityTimelineProjectActivitiesArgs = {
@@ -4356,7 +4357,7 @@ export type User = Actor & UserActor & {
     /** @deprecated No longer supported */
     twitterUsername?: Maybe<Scalars['String']>;
     username: Scalars['String'];
-    webNotifications: Array<Notification>;
+    websiteNotifications: Array<Notification>;
 };
 /** Represents a human (not robot) actor. */
 export type UserActivityTimelineProjectActivitiesArgs = {
@@ -4435,7 +4436,7 @@ export type UserActor = {
     twitterUsername?: Maybe<Scalars['String']>;
     username: Scalars['String'];
     /** Web notifications linked to a user */
-    webNotifications: Array<Notification>;
+    websiteNotifications: Array<Notification>;
 };
 /** A human user (type User or SSOUser) that can login to the Expo website, use Expo services, and be a member of accounts. */
 export type UserActorActivityTimelineProjectActivitiesArgs = {

package/build/graphql/generated.js

@@ -83,6 +83,7 @@ var AppleDeviceClass;
 (function (AppleDeviceClass) {
     AppleDeviceClass["Ipad"] = "IPAD";
     AppleDeviceClass["Iphone"] = "IPHONE";
+    AppleDeviceClass["Mac"] = "MAC";
 })(AppleDeviceClass = exports.AppleDeviceClass || (exports.AppleDeviceClass = {}));
 var AppsFilter;
 (function (AppsFilter) {

package/build/graphql/types/credentials/AppleDevice.js

@@ -7,6 +7,7 @@ const generated_1 = require("../../generated");
 exports.APPLE_DEVICE_CLASS_LABELS = {
     [generated_1.AppleDeviceClass.Ipad]: 'iPad',
     [generated_1.AppleDeviceClass.Iphone]: 'iPhone',
+    [generated_1.AppleDeviceClass.Mac]: 'Mac',
 };
 exports.AppleDeviceFragmentNode = (0, graphql_tag_1.default) `
   fragment AppleDeviceFragment on AppleDevice {

package/build/rollout/actions/CreateRollout.d.ts

@@ -18,6 +18,8 @@ export declare class CreateRollout implements EASUpdateAction<UpdateChannelBasic
     getChannelObjectAsync(ctx: EASUpdateContext, runtimeVersion: string): Promise<UpdateChannelObject>;
     getLatestUpdateGroupOnBranchAsync(ctx: EASUpdateContext, branchInfo: UpdateBranchBasicInfoFragment, runtimeVersion: string): Promise<UpdateFragment[] | null>;
     selectRuntimeVersionAsync(ctx: EASUpdateContext, branchToRollout: UpdateBranchBasicInfoFragment, defaultBranchId: string): Promise<string>;
+    selectRuntimeVersionFromAlternativeSourceAsync(ctx: EASUpdateContext, branchToRollout: UpdateBranchBasicInfoFragment, defaultBranch: UpdateBranchBasicInfoFragment): Promise<string>;
+    selectRuntimeVersionFromProjectConfigAsync(ctx: EASUpdateContext): Promise<string>;
     selectBranchAsync(ctx: EASUpdateContext, defaultBranchId: string): Promise<UpdateBranchBasicInfoFragment>;
     resolveBranchNameAsync(ctx: EASUpdateContext, branchName: string): Promise<UpdateBranchBasicInfoFragment>;
 }

package/build/rollout/actions/CreateRollout.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateRollout = void 0;
 const tslib_1 = require("tslib");
+const config_plugins_1 = require("@expo/config-plugins");
 const assert_1 = tslib_1.__importDefault(require("assert"));
 const SelectBranch_1 = require("../../branch/actions/SelectBranch");
 const branch_mapping_1 = require("../../channel/branch-mapping");
@@ -12,6 +13,7 @@ const ChannelQuery_1 = require("../../graphql/queries/ChannelQuery");
 const UpdateQuery_1 = require("../../graphql/queries/UpdateQuery");
 const log_1 = tslib_1.__importDefault(require("../../log"));
 const prompts_1 = require("../../prompts");
+const filter_1 = require("../../utils/expodash/filter");
 const branch_mapping_2 = require("../branch-mapping");
 const utils_2 = require("../utils");
 const SelectRuntime_1 = require("./SelectRuntime");
@@ -39,6 +41,9 @@ class CreateRollout {
         if ((0, branch_mapping_2.isRollout)(this.channelInfo)) {
             throw new Error(`A rollout is already in progress for channel ${this.channelInfo.name}`);
         }
+        if ((0, branch_mapping_1.hasEmptyBranchMap)(this.channelInfo)) {
+            throw new Error(`Your channel needs to be linked to a branch before a rollout can be created. Do this by running 'eas channel:edit'`);
+        }
         if (!(0, branch_mapping_1.hasStandardBranchMap)(this.channelInfo)) {
             throw new Error(`You have a custom branch mapping. Map your channel to a single branch before creating a rollout. Received: ${this.channelInfo.branchMapping}`);
         }
@@ -51,7 +56,7 @@ class CreateRollout {
         }
         const runtimeVersion = (_a = this.options.runtimeVersion) !== null && _a !== void 0 ? _a : (await this.selectRuntimeVersionAsync(ctx, branchInfoToRollout, defaultBranchId));
         log_1.default.newLine();
-        const promptMessage = `What percent of users should be routed to branch ${branchInfoToRollout.name}?`;
+        const promptMessage = `What percent of users should be rolled out to branch ${branchInfoToRollout.name}?`;
         const percent = (_b = this.options.percent) !== null && _b !== void 0 ? _b : (await (0, utils_2.promptForRolloutPercentAsync)({ promptMessage }));
         const rolloutBranchMapping = (0, branch_mapping_2.createRolloutBranchMapping)({
             defaultBranchId,
@@ -125,20 +130,92 @@ class CreateRollout {
             channelName: this.channelInfo.name,
         });
         const defaultBranchRtvAgnostic = (0, utils_1.getUpdateBranch)(channelObjectRtvAgnostic, defaultBranchId);
-        const selectRuntimeAction = new SelectRuntime_1.SelectRuntime(branchToRollout, {
+        const selectSharedRuntimeAction = new SelectRuntime_1.SelectRuntime(branchToRollout, {
             anotherBranchToIntersectRuntimesBy: defaultBranchRtvAgnostic,
         });
-        return await selectRuntimeAction.runAsync(ctx);
+        const sharedRuntime = await selectSharedRuntimeAction.runAsync(ctx);
+        if (sharedRuntime) {
+            return sharedRuntime;
+        }
+        return await this.selectRuntimeVersionFromAlternativeSourceAsync(ctx, branchToRollout, defaultBranchRtvAgnostic);
+    }
+    async selectRuntimeVersionFromAlternativeSourceAsync(ctx, branchToRollout, defaultBranch) {
+        const { runtimeSource: selectedRuntimeSource } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'runtimeSource',
+            message: `What would you like to do?`,
+            choices: [
+                {
+                    value: 'DEFAULT_BRANCH_RUNTIME',
+                    title: `Find a runtime supported on the ${defaultBranch.name} branch`,
+                },
+                {
+                    value: 'ROLLED_OUT_BRANCH_RUNTIME',
+                    title: `Find a runtime supported on the ${branchToRollout.name} branch`,
+                },
+                {
+                    value: 'PROJECT_RUNTIME',
+                    title: 'Use the runtime specified in your project config',
+                },
+            ],
+        });
+        if (selectedRuntimeSource === 'DEFAULT_BRANCH_RUNTIME') {
+            const selectDefaultBranchRuntimeAction = new SelectRuntime_1.SelectRuntime(defaultBranch);
+            const defaultBranchRuntime = await selectDefaultBranchRuntimeAction.runAsync(ctx);
+            if (defaultBranchRuntime) {
+                return defaultBranchRuntime;
+            }
+        }
+        else if (selectedRuntimeSource === 'ROLLED_OUT_BRANCH_RUNTIME') {
+            const selectBranchToRolloutRuntimeAction = new SelectRuntime_1.SelectRuntime(branchToRollout);
+            const branchToRolloutRuntime = await selectBranchToRolloutRuntimeAction.runAsync(ctx);
+            if (branchToRolloutRuntime) {
+                return branchToRolloutRuntime;
+            }
+        }
+        else if (selectedRuntimeSource === 'PROJECT_RUNTIME') {
+            return await this.selectRuntimeVersionFromProjectConfigAsync(ctx);
+        }
+        else {
+            throw new Error(`Unexpected runtime source: ${selectedRuntimeSource}`);
+        }
+        return await this.selectRuntimeVersionFromAlternativeSourceAsync(ctx, branchToRollout, defaultBranch);
+    }
+    async selectRuntimeVersionFromProjectConfigAsync(ctx) {
+        const platforms = ['ios', 'android'];
+        const runtimes = platforms
+            .map(platform => config_plugins_1.Updates.getRuntimeVersion(ctx.app.exp, platform))
+            .filter(filter_1.truthy);
+        const dedupedRuntimes = [...new Set(runtimes)];
+        if (dedupedRuntimes.length === 0) {
+            throw new Error(`Your project config doesn't specify a runtime. Ensure your project is configured correctly for EAS Update by running \`eas update:configure\``);
+        }
+        else if (dedupedRuntimes.length === 1) {
+            const runtime = dedupedRuntimes[0];
+            log_1.default.log(`🔧 Your project config currently supports runtime ${runtime}`);
+            return runtime;
+        }
+        const { runtime: selectedRuntime } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'runtime',
+            message: `Select a runtime supported by your project config`,
+            choices: runtimes.map((runtime, index) => ({
+                title: `${runtime} ${index === 0 ? '[iOS runtime]' : '[Android runtime]'}`,
+                value: runtime,
+            })),
+        });
+        return selectedRuntime;
     }
     async selectBranchAsync(ctx, defaultBranchId) {
         const selectBranchAction = new SelectBranch_1.SelectBranch({
-            printedType: 'branch to rollout',
+            printedType: 'branch to roll out',
             // we don't want to show the default branch as an option
             filterPredicate: (branchInfo) => branchInfo.id !== defaultBranchId,
         });
         const branchInfo = await selectBranchAction.runAsync(ctx);
         if (!branchInfo) {
-            throw new Error(`You dont have any branches. Create one with 'eas branch:create'`);
+            // We know the user has at least one branch, since we have `defaultBranchId`
+            throw new Error(`You don't have a second branch to roll out. Create it with 'eas branch:create'`);
         }
         return branchInfo;
     }

package/build/rollout/actions/EditRollout.js

@@ -33,12 +33,15 @@ class EditRollout {
         const channelObject = await this.getChannelObjectAsync(ctx);
         const rollout = (0, branch_mapping_1.getRollout)(channelObject);
         const { rolledOutBranch, defaultBranch } = rollout;
-        const promptMessage = `What percent of users should be directed to the ${rolledOutBranch.name} branch ?`;
+        const promptMessage = `What percent of users should be rolled out to the ${rolledOutBranch.name} branch ?`;
         const percent = (_a = this.options.percent) !== null && _a !== void 0 ? _a : (await (0, utils_1.promptForRolloutPercentAsync)({ promptMessage }));
+        if (percent === 0 || percent === 100) {
+            log_1.default.warn(`Editing the percent to ${percent} will not end the rollout. You'll need to end the rollout from the main menu.`);
+        }
         const oldBranchMapping = (0, branch_mapping_1.getRolloutBranchMapping)(channelObject.branchMapping);
         const newBranchMapping = (0, branch_mapping_1.editRolloutBranchMapping)(oldBranchMapping, percent);
         log_1.default.newLine();
-        log_1.default.log(`📝 The updated rollout will send ${chalk_1.default.bold(percent)}% of users to the ${chalk_1.default.bold(rolledOutBranch.name)} branch and ${chalk_1.default.bold(100 - percent)}% to the ${chalk_1.default.bold(defaultBranch.name)} branch.`);
+        log_1.default.log(`📝 ${chalk_1.default.bold(percent)}% of users will be rolled out to the ${chalk_1.default.bold(rolledOutBranch.name)} branch and ${chalk_1.default.bold(100 - percent)}% will remain on the ${chalk_1.default.bold(defaultBranch.name)} branch.`);
         const confirmEdit = await this.confirmEditAsync(ctx);
         if (!confirmEdit) {
             throw new Error('Aborting...');

package/build/rollout/actions/EndRollout.d.ts

@@ -3,9 +3,12 @@ import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
 import { UpdateChannelObject } from '../../graphql/queries/ChannelQuery';
 import { Rollout } from '../branch-mapping';
 export declare enum EndOutcome {
-    REPUBLISH_AND_ROUTE_BACK = "republish-and-route-back",
-    ROUTE_BACK = "route-back"
+    REPUBLISH_AND_REVERT = "republish-and-revert",
+    REVERT = "revert"
 }
+export type GeneralOptions = {
+    privateKeyPath: string | null;
+};
 export type NonInteractiveOptions = {
     outcome: EndOutcome;
 };
@@ -15,7 +18,7 @@ export type NonInteractiveOptions = {
 export declare class EndRollout implements EASUpdateAction<UpdateChannelBasicInfoFragment> {
     private channelInfo;
     private options;
-    constructor(channelInfo: UpdateChannelBasicInfoFragment, options?: Partial<NonInteractiveOptions>);
+    constructor(channelInfo: UpdateChannelBasicInfoFragment, options: Partial<NonInteractiveOptions> & GeneralOptions);
     runAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment>;
     getChannelObjectAsync(ctx: EASUpdateContext): Promise<UpdateChannelObject>;
     selectOutcomeAsync(rollout: Rollout): Promise<EndOutcome>;