eas-cli 3.18.2 → 4.0.0

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");
@@ -51,7 +53,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 +127,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>;

package/build/rollout/actions/EndRollout.js

@@ -10,13 +10,14 @@ const ChannelQuery_1 = require("../../graphql/queries/ChannelQuery");
 const log_1 = tslib_1.__importDefault(require("../../log"));
 const prompts_1 = require("../../prompts");
 const republish_1 = require("../../update/republish");
+const code_signing_1 = require("../../utils/code-signing");
 const formatFields_1 = tslib_1.__importDefault(require("../../utils/formatFields"));
 const branch_mapping_2 = require("../branch-mapping");
 const utils_1 = require("../utils");
 var EndOutcome;
 (function (EndOutcome) {
-    EndOutcome["REPUBLISH_AND_ROUTE_BACK"] = "republish-and-route-back";
-    EndOutcome["ROUTE_BACK"] = "route-back";
+    EndOutcome["REPUBLISH_AND_REVERT"] = "republish-and-revert";
+    EndOutcome["REVERT"] = "revert";
 })(EndOutcome = exports.EndOutcome || (exports.EndOutcome = {}));
 function isNonInteractiveOptions(options) {
     return !!options.outcome;
@@ -28,7 +29,7 @@ function assertNonInteractiveOptions(options) {
  * End an existing rollout for the project.
  */
 class EndRollout {
-    constructor(channelInfo, options = {}) {
+    constructor(channelInfo, options) {
         this.channelInfo = channelInfo;
         this.options = options;
     }
@@ -44,18 +45,15 @@ class EndRollout {
         const rolledOutUpdateGroup = rolledOutBranch.updateGroups[0];
         let outcome;
         if (!rolledOutUpdateGroup) {
-            log_1.default.log(`⚠️  There is no Update Group being served on ${rolledOutBranch.name}.`);
-            (0, assert_1.default)(this.options.outcome !== EndOutcome.REPUBLISH_AND_ROUTE_BACK, 'The only valid outcome for this rollout is to route back to the default branch. ');
-            outcome = EndOutcome.ROUTE_BACK;
+            log_1.default.log(`⚠️  There is no update group being served on the ${rolledOutBranch.name} branch.`);
+            (0, assert_1.default)(this.options.outcome !== EndOutcome.REPUBLISH_AND_REVERT, `The only valid outcome for this rollout is to revert users back to the ${rollout.defaultBranch.name} branch. `);
+            outcome = EndOutcome.REVERT;
         }
         else {
             outcome = (_a = this.options.outcome) !== null && _a !== void 0 ? _a : (await this.selectOutcomeAsync(rollout));
         }
         const didConfirm = await this.confirmOutcomeAsync(ctx, outcome, rollout);
         if (!didConfirm) {
-            if (!rolledOutUpdateGroup) {
-                log_1.default.log(`If you wish to stop serving updates to your users, you can edit your rollout to 100% on ${chalk_1.default.bold(rolledOutBranch.name)} instead`);
-            }
             throw new Error('Aborting...');
         }
         return await this.performOutcomeAsync(ctx, rollout, outcome);
@@ -81,34 +79,36 @@ class EndRollout {
         const defaultUpdateGroup = defaultBranch.updateGroups[0];
         const outcomes = [
             {
-                value: EndOutcome.REPUBLISH_AND_ROUTE_BACK,
+                value: EndOutcome.REPUBLISH_AND_REVERT,
                 title: (0, utils_1.formatBranchWithUpdateGroup)(rolledOutUpdateGroup, rolledOutBranch, percentRolledOut),
             },
             {
-                value: EndOutcome.ROUTE_BACK,
+                value: EndOutcome.REVERT,
                 title: (0, utils_1.formatBranchWithUpdateGroup)(defaultUpdateGroup, defaultBranch, 100 - percentRolledOut),
             },
         ];
         const { outcome: selectedOutcome } = await (0, prompts_1.promptAsync)({
             type: 'select',
             name: 'outcome',
-            message: `Which Update Group would you like to serve?`,
+            message: `Which update group would you like to serve?`,
             choices: outcomes,
         });
         log_1.default.newLine();
-        if (selectedOutcome === EndOutcome.REPUBLISH_AND_ROUTE_BACK) {
-            log_1.default.log(`🍽️  The Update Group you chose is served by branch ${chalk_1.default.bold(rolledOutBranch.name)}`);
+        if (selectedOutcome === EndOutcome.REPUBLISH_AND_REVERT) {
+            log_1.default.log(`➡️ 📱 The update group you chose is served by branch ${chalk_1.default.bold(rolledOutBranch.name)}`);
         }
         else {
-            log_1.default.log(`🍽️  The Update Group you chose is served by branch ${chalk_1.default.bold(defaultBranch.name)}`);
+            log_1.default.log(`➡️ 📱 The update group you chose is served by branch ${chalk_1.default.bold(defaultBranch.name)}`);
         }
         return selectedOutcome;
     }
     async performOutcomeAsync(ctx, rollout, outcome) {
+        var _a;
         const { graphqlClient, app } = ctx;
         const { rolledOutBranch, defaultBranch } = rollout;
         const rolledOutUpdateGroup = rolledOutBranch.updateGroups[0];
-        if (outcome === EndOutcome.REPUBLISH_AND_ROUTE_BACK) {
+        if (outcome === EndOutcome.REPUBLISH_AND_REVERT) {
+            const codeSigningInfo = await (0, code_signing_1.getCodeSigningInfoAsync)(ctx.app.exp, (_a = this.options.privateKeyPath) !== null && _a !== void 0 ? _a : undefined);
             const arbitraryUpdate = rolledOutUpdateGroup[0];
             const { message: oldUpdateMessage, group: oldGroupId } = arbitraryUpdate;
             const newUpdateMessage = `Republish "${oldUpdateMessage}" - group: ${oldGroupId}`;
@@ -121,6 +121,7 @@ class EndRollout {
                     branchId: update.branch.id,
                     branchName: update.branch.name,
                 })),
+                codeSigningInfo,
                 targetBranch: { branchId: defaultBranch.id, branchName: defaultBranch.name },
                 updateMessage: newUpdateMessage,
             });
@@ -131,7 +132,7 @@ class EndRollout {
             branchMapping: JSON.stringify(alwaysTrueDefaultBranchMapping),
         });
         log_1.default.addNewLineIfNone();
-        log_1.default.log(`🚗 Routed all traffic back to branch ${chalk_1.default.bold(defaultBranch.name)}`);
+        log_1.default.log(`⬅️ Reverted all users back to branch ${chalk_1.default.bold(defaultBranch.name)}`);
         log_1.default.log(`✅ Successfully ended rollout`);
         return newChannelInfo;
     }
@@ -142,19 +143,19 @@ class EndRollout {
         }
         const { rolledOutBranch, defaultBranch } = rollout;
         log_1.default.newLine();
-        if (selectedOutcome === EndOutcome.REPUBLISH_AND_ROUTE_BACK) {
+        if (selectedOutcome === EndOutcome.REPUBLISH_AND_REVERT) {
             log_1.default.log(`Ending the rollout will do the following:`);
             const actions = (0, formatFields_1.default)([
                 {
                     label: '1.',
-                    value: `🔁 Republish the Update Group from ${chalk_1.default.bold(rolledOutBranch.name)} onto ${chalk_1.default.bold(defaultBranch.name)}`,
+                    value: `🔁 Republish the update group from ${chalk_1.default.bold(rolledOutBranch.name)} onto ${chalk_1.default.bold(defaultBranch.name)}`,
                 },
-                { label: '2.', value: `⬅️  Route all users back to ${chalk_1.default.bold(defaultBranch.name)}` },
+                { label: '2.', value: `⬅️  Revert all users back to ${chalk_1.default.bold(defaultBranch.name)}` },
             ]);
             log_1.default.log(actions);
         }
         else {
-            log_1.default.log(`⬅️  Ending the rollout will route all users back to ${chalk_1.default.bold(defaultBranch.name)}`);
+            log_1.default.log(`⬅️  Ending the rollout will revert all users back to ${chalk_1.default.bold(defaultBranch.name)}`);
         }
         return await (0, prompts_1.confirmAsync)({
             message: `Continue?`,

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

@@ -2,7 +2,7 @@ import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
 import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
 import { UpdateChannelObject } from '../../graphql/queries/ChannelQuery';
 import { NonInteractiveOptions as EditRolloutNonInteractiveOptions } from './EditRollout';
-import { NonInteractiveOptions as EndRolloutNonInteractiveOptions } from './EndRollout';
+import { GeneralOptions as EndRolloutGeneralOptions, NonInteractiveOptions as EndRolloutNonInteractiveOptions } from './EndRollout';
 export declare enum ManageRolloutActions {
     EDIT = "Edit",
     END = "End",
@@ -14,10 +14,10 @@ export declare enum ManageRolloutActions {
 export declare class ManageRollout implements EASUpdateAction<EASUpdateAction> {
     private channelInfo;
     private options;
-    constructor(channelInfo: UpdateChannelBasicInfoFragment, options?: {
+    constructor(channelInfo: UpdateChannelBasicInfoFragment, options: {
         callingAction?: EASUpdateAction;
         action?: ManageRolloutActions.EDIT | ManageRolloutActions.END;
-    } & Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions>);
+    } & Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions> & EndRolloutGeneralOptions);
     runAsync(ctx: EASUpdateContext): Promise<EASUpdateAction>;
     selectActionAsync(): Promise<ManageRolloutActions>;
     getChannelObjectAsync(ctx: EASUpdateContext): Promise<UpdateChannelObject>;

package/build/rollout/actions/ManageRollout.js

@@ -20,7 +20,7 @@ var ManageRolloutActions;
  * Manage a rollout for the project.
  */
 class ManageRollout {
-    constructor(channelInfo, options = {}) {
+    constructor(channelInfo, options) {
         this.channelInfo = channelInfo;
         this.options = options;
     }

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

@@ -1,18 +1,20 @@
 import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
 import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
+import { CodeSigningInfo } from '../../utils/code-signing';
 import { NonInteractiveOptions as CreateRolloutNonInteractiveOptions } from './CreateRollout';
 import { NonInteractiveOptions as EditRolloutNonInteractiveOptions } from './EditRollout';
-import { NonInteractiveOptions as EndRolloutNonInteractiveOptions } from './EndRollout';
+import { GeneralOptions as EndRolloutGeneralOptions, NonInteractiveOptions as EndRolloutNonInteractiveOptions } from './EndRollout';
 import { RolloutActions } from './RolloutMainMenu';
 /**
  * Control a rollout in non interactive mode.
  */
 export declare class NonInteractiveRollout implements EASUpdateAction<void> {
     private options;
-    constructor(options?: {
+    constructor(options: {
         channelName?: string;
+        codeSigningInfo?: CodeSigningInfo;
         action?: RolloutActions;
-    } & Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions> & Partial<CreateRolloutNonInteractiveOptions>);
+    } & Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions> & EndRolloutGeneralOptions & Partial<CreateRolloutNonInteractiveOptions>);
     runAsync(ctx: EASUpdateContext): Promise<void>;
-    runActionAsync(ctx: EASUpdateContext, action: RolloutActions, channelInfo: UpdateChannelBasicInfoFragment, options: Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions> & Partial<CreateRolloutNonInteractiveOptions>): Promise<UpdateChannelBasicInfoFragment>;
+    runActionAsync(ctx: EASUpdateContext, action: RolloutActions, channelInfo: UpdateChannelBasicInfoFragment, options: Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions> & EndRolloutGeneralOptions & Partial<CreateRolloutNonInteractiveOptions>): Promise<UpdateChannelBasicInfoFragment>;
 }

package/build/rollout/actions/NonInteractiveRollout.js

@@ -11,7 +11,7 @@ const RolloutMainMenu_1 = require("./RolloutMainMenu");
  * Control a rollout in non interactive mode.
  */
 class NonInteractiveRollout {
-    constructor(options = {}) {
+    constructor(options) {
         this.options = options;
     }
     async runAsync(ctx) {

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

@@ -2,7 +2,7 @@ import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
 import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
 import { NonInteractiveOptions as CreateRolloutNonInteractiveOptions } from './CreateRollout';
 import { NonInteractiveOptions as EditRolloutNonInteractiveOptions } from './EditRollout';
-import { NonInteractiveOptions as EndRolloutNonInteractiveOptions } from './EndRollout';
+import { GeneralOptions as EndRolloutGeneralOptions, NonInteractiveOptions as EndRolloutNonInteractiveOptions } from './EndRollout';
 import { ManageRolloutActions } from './ManageRollout';
 export declare enum MainMenuActions {
     CREATE_NEW = "Create a new rollout",
@@ -14,14 +14,14 @@ export type RolloutActions = MainMenuActions.CREATE_NEW | ManageRolloutActions.E
  */
 export declare class RolloutMainMenu implements EASUpdateAction<void> {
     private options;
-    constructor(options?: {
+    constructor(options: {
         channelName?: string;
         action?: RolloutActions;
-    } & Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions> & Partial<CreateRolloutNonInteractiveOptions>);
+    } & Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions> & EndRolloutGeneralOptions & Partial<CreateRolloutNonInteractiveOptions>);
     runAsync(ctx: EASUpdateContext): Promise<void>;
     runActionAsync(ctx: EASUpdateContext, menuAction: MainMenuActions): Promise<null>;
     selectRolloutAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment | null>;
-    selectChannelAsync(ctx: EASUpdateContext, filterPredicate?: (channelInfo: UpdateChannelBasicInfoFragment) => boolean): Promise<UpdateChannelBasicInfoFragment>;
+    selectChannelToRolloutAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment>;
     resolveChannelNameAsync(ctx: EASUpdateContext, channelName: string): Promise<UpdateChannelBasicInfoFragment>;
     toMainMenuAction(action: RolloutActions): MainMenuActions;
     promptMenuActionAsync(): Promise<MainMenuActions>;

package/build/rollout/actions/RolloutMainMenu.js

@@ -20,7 +20,7 @@ var MainMenuActions;
  * Manage a rollout for the project.
  */
 class RolloutMainMenu {
-    constructor(options = {}) {
+    constructor(options) {
         this.options = options;
     }
     async runAsync(ctx) {
@@ -38,7 +38,7 @@ class RolloutMainMenu {
             case MainMenuActions.CREATE_NEW: {
                 const channelInfo = channelName
                     ? await this.resolveChannelNameAsync(ctx, channelName)
-                    : await this.selectChannelAsync(ctx, channelInfo => !(0, branch_mapping_1.isRollout)(channelInfo));
+                    : await this.selectChannelToRolloutAsync(ctx);
                 await new CreateRollout_1.CreateRollout(channelInfo, this.options).runAsync(ctx);
                 return null;
             }
@@ -67,11 +67,20 @@ class RolloutMainMenu {
         const channelInfo = await selectRollout.runAsync(ctx);
         return channelInfo;
     }
-    async selectChannelAsync(ctx, filterPredicate) {
-        const selectChannelAction = new SelectChannel_1.SelectChannel({ filterPredicate });
+    async selectChannelToRolloutAsync(ctx) {
+        let hasSomeChannel = false;
+        const selectChannelAction = new SelectChannel_1.SelectChannel({
+            filterPredicate: (channelInfo) => {
+                hasSomeChannel = true;
+                return !(0, branch_mapping_1.isRollout)(channelInfo);
+            },
+        });
         const channelInfo = await selectChannelAction.runAsync(ctx);
         if (!channelInfo) {
-            throw new Error(`You dont have any channels. Create one with <TODO>`);
+            const error = hasSomeChannel
+                ? new Error('All your channels are already part of a rollout.')
+                : new Error(`You dont have any channels. Create one with \`eas channel:create\``);
+            throw error;
         }
         return channelInfo;
     }

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

@@ -5,7 +5,7 @@ import { Connection } from '../../utils/relay';
 /**
  * Select a runtime from a branch
  */
-export declare class SelectRuntime implements EASUpdateAction<string> {
+export declare class SelectRuntime implements EASUpdateAction<string | null> {
     private branchInfo;
     private options;
     private printedType;
@@ -14,23 +14,20 @@ export declare class SelectRuntime implements EASUpdateAction<string> {
     });
     warnNoRuntime(): void;
     formatCantFindRuntime(): string;
-    runAsync(ctx: EASUpdateContext): Promise<string>;
+    runAsync(ctx: EASUpdateContext): Promise<string | null>;
     getNewestRuntimeAsync(graphqlClient: ExpoGraphqlClient, { appId, branchName, anotherBranchIdToIntersectRuntimesBy, }: {
         appId: string;
         branchName: string;
         anotherBranchIdToIntersectRuntimesBy?: string;
-    }): Promise<Connection<RuntimeFragment> | null>;
+    }): Promise<Connection<RuntimeFragment>>;
     displayLatestUpdateGroupAsync({ graphqlClient, appId, branchName, runtime, }: {
         graphqlClient: ExpoGraphqlClient;
         appId: string;
         branchName: string;
         runtime: RuntimeFragment;
     }): Promise<string>;
-    selectRuntimesAsync(graphqlClient: ExpoGraphqlClient, { appId, branchName, anotherBranchIdToIntersectRuntimesBy, batchSize, }: {
+    selectRuntimesAsync(graphqlClient: ExpoGraphqlClient, { appId, batchSize, }: {
         appId: string;
-        branchName: string;
-        anotherBranchIdToIntersectRuntimesBy?: string;
         batchSize?: number;
     }): Promise<RuntimeFragment | null>;
-    promptForRuntimeAsync(): Promise<string>;
 }

package/build/rollout/actions/SelectRuntime.js

@@ -11,12 +11,6 @@ const log_1 = tslib_1.__importStar(require("../../log"));
 const prompts_1 = require("../../prompts");
 const relay_1 = require("../../utils/relay");
 const utils_2 = require("../utils");
-function beginSentence(phrase) {
-    if (typeof phrase !== 'string' || phrase.length === 0) {
-        return phrase; // Return the input without any modification if it's not a string or empty
-    }
-    return phrase.charAt(0).toUpperCase() + phrase.slice(1);
-}
 /**
  * Select a runtime from a branch
  */
@@ -32,8 +26,7 @@ class SelectRuntime {
         if (this.options.anotherBranchToIntersectRuntimesBy) {
             const intersectBranchName = this.options.anotherBranchToIntersectRuntimesBy.name;
             log_1.default.warn(`⚠️  Branches ${this.branchInfo.name} and ${intersectBranchName} dont have any updates with the same runtime.`);
-            // TODO(quin): write a learn more
-            log_1.default.warn(`Your updates could be misconfigured. ${(0, log_1.learnMore)('https://expo.fyi/todo')}`);
+            log_1.default.warn(`Your updates could be misconfigured. ${(0, log_1.learnMore)('https://expo.fyi/eas-update-rollouts')}`);
         }
         else {
             // no runtime on branch means no updates published on branch
@@ -41,10 +34,10 @@ class SelectRuntime {
         }
     }
     formatCantFindRuntime() {
-        return `🕵️ Not finding the update you were looking for? ${(0, log_1.learnMore)('https://expo.fyi/todo')}`;
+        return `🕵️ Not finding the update you were looking for? ${(0, log_1.learnMore)('https://expo.fyi/eas-update-rollouts')}`;
     }
     async runAsync(ctx) {
-        var _a, _b;
+        var _a;
         const { nonInteractive, graphqlClient, app } = ctx;
         const { projectId } = app;
         if (nonInteractive) {
@@ -55,14 +48,14 @@ class SelectRuntime {
             branchName: this.branchInfo.name,
             anotherBranchIdToIntersectRuntimesBy: (_a = this.options.anotherBranchToIntersectRuntimesBy) === null || _a === void 0 ? void 0 : _a.id,
         });
-        if (!newestRuntimeConnection) {
+        if (newestRuntimeConnection.edges.length === 0) {
             log_1.default.addNewLineIfNone();
             this.warnNoRuntime();
-            return await this.promptForRuntimeAsync();
+            return null;
         }
-        const moreThanOneRuntime = newestRuntimeConnection.edges.length > 1;
-        log_1.default.log(`✅ ${beginSentence(this.printedType)}${moreThanOneRuntime ? 's' : ''} detected`);
-        if (!moreThanOneRuntime) {
+        const onlyOneRuntime = newestRuntimeConnection.edges.length === 1 && !newestRuntimeConnection.pageInfo.hasNextPage;
+        log_1.default.log(`✅ ${beginSentence(this.printedType)}${onlyOneRuntime ? '' : 's'} detected`);
+        if (onlyOneRuntime) {
             const runtime = newestRuntimeConnection.edges[0].node;
             const formattedRuntimeWithGroup = await this.displayLatestUpdateGroupAsync({
                 graphqlClient,
@@ -82,14 +75,12 @@ class SelectRuntime {
             else {
                 log_1.default.newLine();
                 log_1.default.warn(this.formatCantFindRuntime());
-                return await this.promptForRuntimeAsync();
+                return null;
             }
         }
         log_1.default.log(this.formatCantFindRuntime());
         const selectedRuntime = await this.selectRuntimesAsync(graphqlClient, {
             appId: projectId,
-            branchName: this.branchInfo.name,
-            anotherBranchIdToIntersectRuntimesBy: (_b = this.options.anotherBranchToIntersectRuntimesBy) === null || _b === void 0 ? void 0 : _b.id,
         });
         if (!selectedRuntime) {
             throw new Error(`No ${this.printedType} selected`);
@@ -97,7 +88,7 @@ class SelectRuntime {
         return selectedRuntime.version;
     }
     async getNewestRuntimeAsync(graphqlClient, { appId, branchName, anotherBranchIdToIntersectRuntimesBy, }) {
-        const connection = await RuntimeQuery_1.RuntimeQuery.getRuntimesOnBranchAsync(graphqlClient, {
+        return await RuntimeQuery_1.RuntimeQuery.getRuntimesOnBranchAsync(graphqlClient, {
             appId,
             name: branchName,
             first: 1,
@@ -105,11 +96,6 @@ class SelectRuntime {
                 branchId: anotherBranchIdToIntersectRuntimesBy,
             },
         });
-        const { edges } = connection;
-        if (edges.length === 0) {
-            return null;
-        }
-        return connection;
     }
     async displayLatestUpdateGroupAsync({ graphqlClient, appId, branchName, runtime, }) {
         const updateGroups = await UpdateQuery_1.UpdateQuery.viewUpdateGroupsOnBranchAsync(graphqlClient, {
@@ -122,19 +108,20 @@ class SelectRuntime {
             },
         });
         (0, assert_1.default)(updateGroups.length < 2, `Expected at most one update group. Received: ${JSON.stringify(updateGroups)}`);
-        return (0, utils_2.formatRuntimeWithUpdateGroup)(updateGroups[0], runtime);
+        return (0, utils_2.formatRuntimeWithUpdateGroup)(updateGroups[0], runtime, branchName);
     }
-    async selectRuntimesAsync(graphqlClient, { appId, branchName, anotherBranchIdToIntersectRuntimesBy, batchSize = 5, }) {
+    async selectRuntimesAsync(graphqlClient, { appId, batchSize = 5, }) {
         const queryAsync = async (queryParams) => {
+            var _a;
             return await RuntimeQuery_1.RuntimeQuery.getRuntimesOnBranchAsync(graphqlClient, {
                 appId,
-                name: branchName,
+                name: this.branchInfo.name,
                 first: queryParams.first,
                 after: queryParams.after,
                 last: queryParams.last,
                 before: queryParams.before,
                 filter: {
-                    branchId: anotherBranchIdToIntersectRuntimesBy,
+                    branchId: (_a = this.options.anotherBranchToIntersectRuntimesBy) === null || _a === void 0 ? void 0 : _a.id,
                 },
             });
         };
@@ -142,7 +129,7 @@ class SelectRuntime {
             return await this.displayLatestUpdateGroupAsync({
                 graphqlClient,
                 appId,
-                branchName,
+                branchName: this.branchInfo.name,
                 runtime,
             });
         };
@@ -153,15 +140,11 @@ class SelectRuntime {
             pageSize: batchSize,
         });
     }
-    async promptForRuntimeAsync() {
-        log_1.default.log(`You can input a runtime manually then publish an update later.`);
-        const { runtimeVersion } = await (0, prompts_1.promptAsync)({
-            type: 'text',
-            name: 'runtimeVersion',
-            message: 'Input a runtime version:',
-            initial: '1.0.0',
-        });
-        return runtimeVersion;
-    }
 }
 exports.SelectRuntime = SelectRuntime;
+function beginSentence(phrase) {
+    if (typeof phrase !== 'string' || phrase.length === 0) {
+        return phrase; // Return the input without any modification if it's not a string or empty
+    }
+    return phrase.charAt(0).toUpperCase() + phrase.slice(1);
+}

package/build/rollout/branch-mapping.js

@@ -41,7 +41,7 @@ function getRolloutInfoFromBranchMapping(branchMapping) {
         (0, branch_mapping_1.assertNumber)(operand);
         return {
             rolledOutBranchId,
-            percentRolledOut: operand * 100,
+            percentRolledOut: Math.round(operand * 100),
             runtimeVersion,
             defaultBranchId,
         };
@@ -53,7 +53,7 @@ function getRolloutInfoFromBranchMapping(branchMapping) {
         (0, branch_mapping_1.assertNumber)(operand);
         return {
             rolledOutBranchId,
-            percentRolledOut: operand * 100,
+            percentRolledOut: Math.round(operand * 100),
             defaultBranchId,
         };
     }