eas-cli 3.18.0 → 3.18.2

package/build/metadata/apple/config/reader.js

@@ -140,7 +140,7 @@ class AppleConfigReader {
         return {
             locale,
             description: info.description,
-            keywords: (_b = info.keywords) === null || _b === void 0 ? void 0 : _b.join(', '),
+            keywords: (_b = info.keywords) === null || _b === void 0 ? void 0 : _b.join(','),
             // TODO: maybe move this to task logic, it's more an exception than data handling
             whatsNew: context.versionIsFirst ? undefined : info.releaseNotes || exports.DEFAULT_WHATSNEW,
             marketingUrl: info.marketingUrl,

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

@@ -0,0 +1,23 @@
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+import { UpdateBranchBasicInfoFragment, UpdateChannelBasicInfoFragment, UpdateFragment } from '../../graphql/generated';
+import { UpdateChannelObject } from '../../graphql/queries/ChannelQuery';
+export type NonInteractiveOptions = {
+    branchNameToRollout: string;
+    percent: number;
+    runtimeVersion: string;
+};
+/**
+ * Create a rollout for the project.
+ */
+export declare class CreateRollout implements EASUpdateAction<UpdateChannelBasicInfoFragment> {
+    private channelInfo;
+    private options;
+    constructor(channelInfo: UpdateChannelBasicInfoFragment, options?: Partial<NonInteractiveOptions>);
+    runAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment>;
+    confirmCreationAsync(ctx: EASUpdateContext): Promise<boolean>;
+    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>;
+    selectBranchAsync(ctx: EASUpdateContext, defaultBranchId: string): Promise<UpdateBranchBasicInfoFragment>;
+    resolveBranchNameAsync(ctx: EASUpdateContext, branchName: string): Promise<UpdateBranchBasicInfoFragment>;
+}

package/build/rollout/actions/CreateRollout.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateRollout = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const SelectBranch_1 = require("../../branch/actions/SelectBranch");
+const branch_mapping_1 = require("../../channel/branch-mapping");
+const utils_1 = require("../../channel/utils");
+const edit_1 = require("../../commands/channel/edit");
+const BranchQuery_1 = require("../../graphql/queries/BranchQuery");
+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 branch_mapping_2 = require("../branch-mapping");
+const utils_2 = require("../utils");
+const SelectRuntime_1 = require("./SelectRuntime");
+function isNonInteractiveOptions(options) {
+    return !!options.branchNameToRollout && !!options.percent && !!options.runtimeVersion;
+}
+function assertNonInteractiveOptions(options) {
+    (0, assert_1.default)(isNonInteractiveOptions(options), '--branch, --percent and --runtime-version are required for creating a rollout in non-interactive mode.');
+}
+/**
+ * Create a rollout for the project.
+ */
+class CreateRollout {
+    constructor(channelInfo, options = {}) {
+        this.channelInfo = channelInfo;
+        this.options = options;
+    }
+    async runAsync(ctx) {
+        var _a, _b;
+        const { branchNameToRollout } = this.options;
+        const { nonInteractive, graphqlClient } = ctx;
+        if (nonInteractive) {
+            assertNonInteractiveOptions(this.options);
+        }
+        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.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}`);
+        }
+        const defaultBranchId = (0, branch_mapping_1.getStandardBranchId)(this.channelInfo);
+        const branchInfoToRollout = branchNameToRollout
+            ? await this.resolveBranchNameAsync(ctx, branchNameToRollout)
+            : await this.selectBranchAsync(ctx, defaultBranchId);
+        if (branchInfoToRollout.id === defaultBranchId) {
+            throw new Error(`Channel ${this.channelInfo.name} is already mapped to branch ${branchInfoToRollout.name}.`);
+        }
+        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 percent = (_b = this.options.percent) !== null && _b !== void 0 ? _b : (await (0, utils_2.promptForRolloutPercentAsync)({ promptMessage }));
+        const rolloutBranchMapping = (0, branch_mapping_2.createRolloutBranchMapping)({
+            defaultBranchId,
+            rolloutBranchId: branchInfoToRollout.id,
+            percent,
+            runtimeVersion,
+        });
+        const channelObject = await this.getChannelObjectAsync(ctx, runtimeVersion);
+        const defaultBranch = (0, utils_1.getUpdateBranch)(channelObject, defaultBranchId);
+        const defaultUpdateGroup = defaultBranch.updateGroups[0];
+        const rolloutInfo = (0, branch_mapping_2.getRolloutInfoFromBranchMapping)(rolloutBranchMapping);
+        const rolledOutBranchUpdateGroup = await this.getLatestUpdateGroupOnBranchAsync(ctx, branchInfoToRollout, runtimeVersion);
+        const rolledOutBranch = (0, ChannelQuery_1.composeUpdateBranchObject)(branchInfoToRollout, rolledOutBranchUpdateGroup ? [rolledOutBranchUpdateGroup] : []);
+        const rollout = (0, branch_mapping_2.composeRollout)(rolloutInfo, defaultBranch, rolledOutBranch);
+        (0, utils_2.displayRolloutDetails)(this.channelInfo.name, rollout);
+        log_1.default.log((0, utils_2.formatBranchWithUpdateGroup)(defaultUpdateGroup, defaultBranch, 100 - rollout.percentRolledOut));
+        log_1.default.addNewLineIfNone();
+        log_1.default.log((0, utils_2.formatBranchWithUpdateGroup)(rolledOutBranchUpdateGroup, rolledOutBranch, rollout.percentRolledOut));
+        log_1.default.addNewLineIfNone();
+        const didConfirm = await this.confirmCreationAsync(ctx);
+        if (!didConfirm) {
+            throw new Error('Aborting...');
+        }
+        const newChannelInfo = await (0, edit_1.updateChannelBranchMappingAsync)(graphqlClient, {
+            channelId: this.channelInfo.id,
+            branchMapping: JSON.stringify(rolloutBranchMapping),
+        });
+        log_1.default.succeed('✅ Successfully created rollout');
+        return newChannelInfo;
+    }
+    async confirmCreationAsync(ctx) {
+        const { nonInteractive } = ctx;
+        if (nonInteractive) {
+            return true;
+        }
+        return await (0, prompts_1.confirmAsync)({
+            message: `Create rollout?`,
+        });
+    }
+    async getChannelObjectAsync(ctx, runtimeVersion) {
+        const { graphqlClient, app } = ctx;
+        const { projectId } = app;
+        return await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
+            appId: projectId,
+            channelName: this.channelInfo.name,
+            filter: { runtimeVersions: [runtimeVersion] },
+        });
+    }
+    async getLatestUpdateGroupOnBranchAsync(ctx, branchInfo, runtimeVersion) {
+        var _a;
+        const { graphqlClient, app } = ctx;
+        const { projectId } = app;
+        const updateGroups = await UpdateQuery_1.UpdateQuery.viewUpdateGroupsOnBranchAsync(graphqlClient, {
+            appId: projectId,
+            branchName: branchInfo.name,
+            limit: 1,
+            offset: 0,
+            filter: {
+                runtimeVersions: [runtimeVersion],
+            },
+        });
+        (0, assert_1.default)(updateGroups.length < 2, `Expected at most one update group. Received: ${JSON.stringify(updateGroups)}`);
+        return (_a = updateGroups[0]) !== null && _a !== void 0 ? _a : null;
+    }
+    async selectRuntimeVersionAsync(ctx, branchToRollout, defaultBranchId) {
+        const { graphqlClient, app } = ctx;
+        const { projectId } = app;
+        // we just want the branch name, not the update group
+        const channelObjectRtvAgnostic = await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
+            appId: projectId,
+            channelName: this.channelInfo.name,
+        });
+        const defaultBranchRtvAgnostic = (0, utils_1.getUpdateBranch)(channelObjectRtvAgnostic, defaultBranchId);
+        const selectRuntimeAction = new SelectRuntime_1.SelectRuntime(branchToRollout, {
+            anotherBranchToIntersectRuntimesBy: defaultBranchRtvAgnostic,
+        });
+        return await selectRuntimeAction.runAsync(ctx);
+    }
+    async selectBranchAsync(ctx, defaultBranchId) {
+        const selectBranchAction = new SelectBranch_1.SelectBranch({
+            printedType: 'branch to rollout',
+            // 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'`);
+        }
+        return branchInfo;
+    }
+    async resolveBranchNameAsync(ctx, branchName) {
+        const { graphqlClient, app } = ctx;
+        return await BranchQuery_1.BranchQuery.getBranchByNameAsync(graphqlClient, {
+            appId: app.projectId,
+            name: branchName,
+        });
+    }
+}
+exports.CreateRollout = CreateRollout;

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

@@ -0,0 +1,17 @@
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
+import { UpdateChannelObject } from '../../graphql/queries/ChannelQuery';
+export type NonInteractiveOptions = {
+    percent: number;
+};
+/**
+ * Edit an existing rollout for the project.
+ */
+export declare class EditRollout implements EASUpdateAction<UpdateChannelBasicInfoFragment> {
+    private channelInfo;
+    private options;
+    constructor(channelInfo: UpdateChannelBasicInfoFragment, options?: Partial<NonInteractiveOptions>);
+    runAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment>;
+    confirmEditAsync(ctx: EASUpdateContext): Promise<boolean>;
+    getChannelObjectAsync(ctx: EASUpdateContext): Promise<UpdateChannelObject>;
+}

package/build/rollout/actions/EditRollout.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditRollout = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const edit_1 = require("../../commands/channel/edit");
+const ChannelQuery_1 = require("../../graphql/queries/ChannelQuery");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+const branch_mapping_1 = require("../branch-mapping");
+const utils_1 = require("../utils");
+function isNonInteractiveOptions(options) {
+    return !!options.percent;
+}
+function assertNonInteractiveOptions(options) {
+    (0, assert_1.default)(isNonInteractiveOptions(options), '--percent is required for editing a rollout in non-interactive mode.');
+}
+/**
+ * Edit an existing rollout for the project.
+ */
+class EditRollout {
+    constructor(channelInfo, options = {}) {
+        this.channelInfo = channelInfo;
+        this.options = options;
+    }
+    async runAsync(ctx) {
+        var _a;
+        const { nonInteractive, graphqlClient } = ctx;
+        if (nonInteractive) {
+            assertNonInteractiveOptions(this.options);
+        }
+        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 percent = (_a = this.options.percent) !== null && _a !== void 0 ? _a : (await (0, utils_1.promptForRolloutPercentAsync)({ promptMessage }));
+        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.`);
+        const confirmEdit = await this.confirmEditAsync(ctx);
+        if (!confirmEdit) {
+            throw new Error('Aborting...');
+        }
+        const newChannelInfo = await (0, edit_1.updateChannelBranchMappingAsync)(graphqlClient, {
+            channelId: channelObject.id,
+            branchMapping: JSON.stringify(newBranchMapping),
+        });
+        log_1.default.addNewLineIfNone();
+        log_1.default.log(`✅ Successfuly updated rollout`);
+        return newChannelInfo;
+    }
+    async confirmEditAsync(ctx) {
+        const { nonInteractive } = ctx;
+        if (nonInteractive) {
+            return true;
+        }
+        return await (0, prompts_1.confirmAsync)({
+            message: `Confirm changes?`,
+        });
+    }
+    async getChannelObjectAsync(ctx) {
+        const { graphqlClient, app } = ctx;
+        const { projectId } = app;
+        if (!(0, branch_mapping_1.isRollout)(this.channelInfo)) {
+            throw new Error(`The channel ${chalk_1.default.bold(this.channelInfo.name)} is not a rollout. To end a rollout, you must specify a channel with an ongoing rollout.`);
+        }
+        const rolloutInfo = (0, branch_mapping_1.getRolloutInfo)(this.channelInfo);
+        return await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
+            appId: projectId,
+            channelName: this.channelInfo.name,
+            ...((0, branch_mapping_1.isConstrainedRolloutInfo)(rolloutInfo)
+                ? { filter: { runtimeVersions: [rolloutInfo.runtimeVersion] } }
+                : {}),
+        });
+    }
+}
+exports.EditRollout = EditRollout;

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

@@ -0,0 +1,24 @@
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+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"
+}
+export type NonInteractiveOptions = {
+    outcome: EndOutcome;
+};
+/**
+ * End an existing rollout for the project.
+ */
+export declare class EndRollout implements EASUpdateAction<UpdateChannelBasicInfoFragment> {
+    private channelInfo;
+    private options;
+    constructor(channelInfo: UpdateChannelBasicInfoFragment, options?: Partial<NonInteractiveOptions>);
+    runAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment>;
+    getChannelObjectAsync(ctx: EASUpdateContext): Promise<UpdateChannelObject>;
+    selectOutcomeAsync(rollout: Rollout): Promise<EndOutcome>;
+    performOutcomeAsync(ctx: EASUpdateContext, rollout: Rollout, outcome: EndOutcome): Promise<UpdateChannelBasicInfoFragment>;
+    confirmOutcomeAsync(ctx: EASUpdateContext, selectedOutcome: EndOutcome, rollout: Rollout): Promise<boolean>;
+}

package/build/rollout/actions/EndRollout.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndRollout = exports.EndOutcome = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const branch_mapping_1 = require("../../channel/branch-mapping");
+const edit_1 = require("../../commands/channel/edit");
+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 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 = exports.EndOutcome || (exports.EndOutcome = {}));
+function isNonInteractiveOptions(options) {
+    return !!options.outcome;
+}
+function assertNonInteractiveOptions(options) {
+    (0, assert_1.default)(isNonInteractiveOptions(options), '--outcome is required for ending a rollout in non-interactive mode.');
+}
+/**
+ * End an existing rollout for the project.
+ */
+class EndRollout {
+    constructor(channelInfo, options = {}) {
+        this.channelInfo = channelInfo;
+        this.options = options;
+    }
+    async runAsync(ctx) {
+        var _a;
+        const { nonInteractive } = ctx;
+        if (nonInteractive) {
+            assertNonInteractiveOptions(this.options);
+        }
+        const channelObject = await this.getChannelObjectAsync(ctx);
+        const rollout = (0, branch_mapping_2.getRollout)(channelObject);
+        const { rolledOutBranch } = rollout;
+        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;
+        }
+        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);
+    }
+    async getChannelObjectAsync(ctx) {
+        const { graphqlClient, app } = ctx;
+        const { projectId } = app;
+        if (!(0, branch_mapping_2.isRollout)(this.channelInfo)) {
+            throw new Error(`The channel ${chalk_1.default.bold(this.channelInfo.name)} is not a rollout. To end a rollout, you must specify a channel with an ongoing rollout.`);
+        }
+        const rolloutInfo = (0, branch_mapping_2.getRolloutInfo)(this.channelInfo);
+        return await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
+            appId: projectId,
+            channelName: this.channelInfo.name,
+            ...((0, branch_mapping_2.isConstrainedRolloutInfo)(rolloutInfo)
+                ? { filter: { runtimeVersions: [rolloutInfo.runtimeVersion] } }
+                : {}),
+        });
+    }
+    async selectOutcomeAsync(rollout) {
+        const { rolledOutBranch, percentRolledOut, defaultBranch } = rollout;
+        const rolledOutUpdateGroup = rolledOutBranch.updateGroups[0];
+        const defaultUpdateGroup = defaultBranch.updateGroups[0];
+        const outcomes = [
+            {
+                value: EndOutcome.REPUBLISH_AND_ROUTE_BACK,
+                title: (0, utils_1.formatBranchWithUpdateGroup)(rolledOutUpdateGroup, rolledOutBranch, percentRolledOut),
+            },
+            {
+                value: EndOutcome.ROUTE_BACK,
+                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?`,
+            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)}`);
+        }
+        else {
+            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) {
+        const { graphqlClient, app } = ctx;
+        const { rolledOutBranch, defaultBranch } = rollout;
+        const rolledOutUpdateGroup = rolledOutBranch.updateGroups[0];
+        if (outcome === EndOutcome.REPUBLISH_AND_ROUTE_BACK) {
+            const arbitraryUpdate = rolledOutUpdateGroup[0];
+            const { message: oldUpdateMessage, group: oldGroupId } = arbitraryUpdate;
+            const newUpdateMessage = `Republish "${oldUpdateMessage}" - group: ${oldGroupId}`;
+            await (0, republish_1.republishAsync)({
+                graphqlClient,
+                app,
+                updatesToPublish: rolledOutUpdateGroup.map(update => ({
+                    ...update,
+                    groupId: update.group,
+                    branchId: update.branch.id,
+                    branchName: update.branch.name,
+                })),
+                targetBranch: { branchId: defaultBranch.id, branchName: defaultBranch.name },
+                updateMessage: newUpdateMessage,
+            });
+        }
+        const alwaysTrueDefaultBranchMapping = (0, branch_mapping_1.getAlwaysTrueBranchMapping)(defaultBranch.id);
+        const newChannelInfo = await (0, edit_1.updateChannelBranchMappingAsync)(graphqlClient, {
+            channelId: this.channelInfo.id,
+            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(`✅ Successfully ended rollout`);
+        return newChannelInfo;
+    }
+    async confirmOutcomeAsync(ctx, selectedOutcome, rollout) {
+        const { nonInteractive } = ctx;
+        if (nonInteractive) {
+            return true;
+        }
+        const { rolledOutBranch, defaultBranch } = rollout;
+        log_1.default.newLine();
+        if (selectedOutcome === EndOutcome.REPUBLISH_AND_ROUTE_BACK) {
+            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)}`,
+                },
+                { label: '2.', value: `⬅️  Route 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)}`);
+        }
+        return await (0, prompts_1.confirmAsync)({
+            message: `Continue?`,
+        });
+    }
+}
+exports.EndRollout = EndRollout;

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

@@ -0,0 +1,24 @@
+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';
+export declare enum ManageRolloutActions {
+    EDIT = "Edit",
+    END = "End",
+    GO_BACK = "Go back"
+}
+/**
+ * Manage a rollout for the project.
+ */
+export declare class ManageRollout implements EASUpdateAction<EASUpdateAction> {
+    private channelInfo;
+    private options;
+    constructor(channelInfo: UpdateChannelBasicInfoFragment, options?: {
+        callingAction?: EASUpdateAction;
+        action?: ManageRolloutActions.EDIT | ManageRolloutActions.END;
+    } & Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions>);
+    runAsync(ctx: EASUpdateContext): Promise<EASUpdateAction>;
+    selectActionAsync(): Promise<ManageRolloutActions>;
+    getChannelObjectAsync(ctx: EASUpdateContext): Promise<UpdateChannelObject>;
+}

package/build/rollout/actions/ManageRollout.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManageRollout = exports.ManageRolloutActions = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const ChannelQuery_1 = require("../../graphql/queries/ChannelQuery");
+const prompts_1 = require("../../prompts");
+const branch_mapping_1 = require("../branch-mapping");
+const utils_1 = require("../utils");
+const EditRollout_1 = require("./EditRollout");
+const EndRollout_1 = require("./EndRollout");
+var ManageRolloutActions;
+(function (ManageRolloutActions) {
+    ManageRolloutActions["EDIT"] = "Edit";
+    ManageRolloutActions["END"] = "End";
+    ManageRolloutActions["GO_BACK"] = "Go back";
+})(ManageRolloutActions = exports.ManageRolloutActions || (exports.ManageRolloutActions = {}));
+/**
+ * Manage a rollout for the project.
+ */
+class ManageRollout {
+    constructor(channelInfo, options = {}) {
+        this.channelInfo = channelInfo;
+        this.options = options;
+    }
+    async runAsync(ctx) {
+        var _a;
+        const { nonInteractive } = ctx;
+        if (nonInteractive) {
+            throw new Error(`rollout selection cannot be run in non-interactive mode.`);
+        }
+        const channelObject = await this.getChannelObjectAsync(ctx);
+        (0, utils_1.printRollout)(channelObject);
+        const action = (_a = this.options.action) !== null && _a !== void 0 ? _a : (await this.selectActionAsync());
+        switch (action) {
+            case ManageRolloutActions.EDIT:
+                return new EditRollout_1.EditRollout(this.channelInfo, this.options);
+            case ManageRolloutActions.END:
+                return new EndRollout_1.EndRollout(this.channelInfo, this.options);
+            case ManageRolloutActions.GO_BACK:
+                (0, assert_1.default)(this.options.callingAction, 'calling action must be defined');
+                return this.options.callingAction;
+        }
+    }
+    async selectActionAsync() {
+        const manageOptions = [ManageRolloutActions.EDIT, ManageRolloutActions.END];
+        if (this.options.callingAction) {
+            manageOptions.push(ManageRolloutActions.GO_BACK);
+        }
+        const { manageOption: selectedManageOption } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'manageOption',
+            message: `What would you like to do?`,
+            choices: manageOptions.map(manageOption => ({
+                value: manageOption,
+                title: manageOption,
+            })),
+        });
+        return selectedManageOption;
+    }
+    async getChannelObjectAsync(ctx) {
+        const { graphqlClient, app } = ctx;
+        const { projectId } = app;
+        if (!(0, branch_mapping_1.isRollout)(this.channelInfo)) {
+            throw new Error(`The channel ${chalk_1.default.bold(this.channelInfo.name)} is not a rollout. To manage a rollout, you must specify a channel with an ongoing rollout.`);
+        }
+        const rolloutInfo = (0, branch_mapping_1.getRolloutInfo)(this.channelInfo);
+        return await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
+            appId: projectId,
+            channelName: this.channelInfo.name,
+            ...((0, branch_mapping_1.isConstrainedRolloutInfo)(rolloutInfo)
+                ? { filter: { runtimeVersions: [rolloutInfo.runtimeVersion] } }
+                : {}),
+        });
+    }
+}
+exports.ManageRollout = ManageRollout;

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

@@ -0,0 +1,18 @@
+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 { RolloutActions } from './RolloutMainMenu';
+/**
+ * Control a rollout in non interactive mode.
+ */
+export declare class NonInteractiveRollout implements EASUpdateAction<void> {
+    private options;
+    constructor(options?: {
+        channelName?: string;
+        action?: RolloutActions;
+    } & Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions> & Partial<CreateRolloutNonInteractiveOptions>);
+    runAsync(ctx: EASUpdateContext): Promise<void>;
+    runActionAsync(ctx: EASUpdateContext, action: RolloutActions, channelInfo: UpdateChannelBasicInfoFragment, options: Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions> & Partial<CreateRolloutNonInteractiveOptions>): Promise<UpdateChannelBasicInfoFragment>;
+}

package/build/rollout/actions/NonInteractiveRollout.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonInteractiveRollout = void 0;
+const ChannelQuery_1 = require("../../graphql/queries/ChannelQuery");
+const CreateRollout_1 = require("./CreateRollout");
+const EditRollout_1 = require("./EditRollout");
+const EndRollout_1 = require("./EndRollout");
+const ManageRollout_1 = require("./ManageRollout");
+const RolloutMainMenu_1 = require("./RolloutMainMenu");
+/**
+ * Control a rollout in non interactive mode.
+ */
+class NonInteractiveRollout {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async runAsync(ctx) {
+        const { channelName, action } = this.options;
+        const { nonInteractive, app, graphqlClient } = ctx;
+        if (!nonInteractive) {
+            throw new Error(`This action is meant for non-interactive mode.`);
+        }
+        if (!channelName) {
+            throw new Error(`The channel argument is required in non-interactive mode. Run eas channel:rollout [channel-name]`);
+        }
+        const channelInfo = await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
+            appId: app.projectId,
+            channelName,
+        });
+        if (!action) {
+            throw new Error(`--action is required in non-interactive mode.`);
+        }
+        await this.runActionAsync(ctx, action, channelInfo, this.options);
+    }
+    async runActionAsync(ctx, action, channelInfo, options) {
+        switch (action) {
+            case RolloutMainMenu_1.MainMenuActions.CREATE_NEW:
+                return await new CreateRollout_1.CreateRollout(channelInfo, options).runAsync(ctx);
+            case ManageRollout_1.ManageRolloutActions.EDIT:
+                return await new EditRollout_1.EditRollout(channelInfo, options).runAsync(ctx);
+            case ManageRollout_1.ManageRolloutActions.END:
+                return await new EndRollout_1.EndRollout(channelInfo, options).runAsync(ctx);
+        }
+    }
+}
+exports.NonInteractiveRollout = NonInteractiveRollout;