@donotuse/eas-cli 18.5.0-rc.1

package/build/rollout/actions/CreateRollout.js

@@ -0,0 +1,239 @@
+"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 SelectRuntime_1 = require("./SelectRuntime");
+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 resolveRuntimeVersionAsync_1 = require("../../project/resolveRuntimeVersionAsync");
+const workflow_1 = require("../../project/workflow");
+const prompts_1 = require("../../prompts");
+const filter_1 = require("../../utils/expodash/filter");
+const branch_mapping_2 = require("../branch-mapping");
+const utils_2 = require("../utils");
+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 {
+    channelInfo;
+    options;
+    constructor(channelInfo, options = {}) {
+        this.channelInfo = channelInfo;
+        this.options = options;
+    }
+    async runAsync(ctx) {
+        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.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}`);
+        }
+        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 = this.options.runtimeVersion ??
+            (await this.selectRuntimeVersionAsync(ctx, branchInfoToRollout, defaultBranchId));
+        log_1.default.newLine();
+        const promptMessage = `What percent of users should be rolled out to branch ${branchInfoToRollout.name}?`;
+        const percent = this.options.percent ?? (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) {
+        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 updateGroups[0] ?? 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 selectSharedRuntimeAction = new SelectRuntime_1.SelectRuntime(branchToRollout, {
+            anotherBranchToIntersectRuntimesBy: defaultBranchRtvAgnostic,
+        });
+        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 workflows = await (0, workflow_1.resolveWorkflowPerPlatformAsync)(ctx.app.projectDir, ctx.vcsClient);
+        const runtimes = (await Promise.all(platforms.map(platform => (0, resolveRuntimeVersionAsync_1.resolveRuntimeVersionAsync)({
+            projectDir: ctx.app.projectDir,
+            exp: ctx.app.exp,
+            platform,
+            workflow: workflows[platform],
+            env: undefined,
+        }))))
+            .map(runtime => runtime?.runtimeVersion)
+            .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 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) {
+            // 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;
+    }
+    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,16 @@
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
+export type NonInteractiveOptions = {
+    percent: number;
+};
+/**
+ * Edit an existing rollout for the project.
+ */
+export declare class EditRollout implements EASUpdateAction<UpdateChannelBasicInfoFragment> {
+    private readonly channelInfo;
+    private readonly options;
+    constructor(channelInfo: UpdateChannelBasicInfoFragment, options?: Partial<NonInteractiveOptions>);
+    runAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment>;
+    private confirmEditAsync;
+    private getChannelObjectAsync;
+}

package/build/rollout/actions/EditRollout.js

@@ -0,0 +1,83 @@
+"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 {
+    channelInfo;
+    options;
+    constructor(channelInfo, options = {}) {
+        this.channelInfo = channelInfo;
+        this.options = options;
+    }
+    async runAsync(ctx) {
+        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 rolled out to the ${rolledOutBranch.name} branch ?`;
+        const percent = this.options.percent ?? (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(`📝 ${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...');
+        }
+        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,25 @@
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
+export declare enum EndOutcome {
+    REPUBLISH_AND_REVERT = "republish-and-revert",
+    REVERT = "revert"
+}
+export type GeneralOptions = {
+    privateKeyPath: string | null;
+};
+export type NonInteractiveOptions = {
+    outcome: EndOutcome;
+};
+/**
+ * End an existing rollout for the project.
+ */
+export declare class EndRollout implements EASUpdateAction<UpdateChannelBasicInfoFragment> {
+    private readonly channelInfo;
+    private readonly options;
+    constructor(channelInfo: UpdateChannelBasicInfoFragment, options: Partial<NonInteractiveOptions> & GeneralOptions);
+    runAsync(ctx: EASUpdateContext): Promise<UpdateChannelBasicInfoFragment>;
+    private getChannelObjectAsync;
+    private selectOutcomeAsync;
+    private performOutcomeAsync;
+    private confirmOutcomeAsync;
+}

package/build/rollout/actions/EndRollout.js

@@ -0,0 +1,165 @@
+"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 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_REVERT"] = "republish-and-revert";
+    EndOutcome["REVERT"] = "revert";
+})(EndOutcome || (exports.EndOutcome = 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 {
+    channelInfo;
+    options;
+    constructor(channelInfo, options) {
+        this.channelInfo = channelInfo;
+        this.options = options;
+    }
+    async runAsync(ctx) {
+        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 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 = this.options.outcome ?? (await this.selectOutcomeAsync(rollout));
+        }
+        const didConfirm = await this.confirmOutcomeAsync(ctx, outcome, rollout);
+        if (!didConfirm) {
+            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_REVERT,
+                title: (0, utils_1.formatBranchWithUpdateGroup)(rolledOutUpdateGroup, rolledOutBranch, percentRolledOut),
+            },
+            {
+                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?`,
+            choices: outcomes,
+        });
+        log_1.default.newLine();
+        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)}`);
+        }
+        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_REVERT) {
+            const codeSigningInfo = await (0, code_signing_1.getCodeSigningInfoAsync)(ctx.app.exp, this.options.privateKeyPath ?? undefined);
+            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,
+                })),
+                codeSigningInfo,
+                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(`⬅️ Reverted all users 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_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)}`,
+                },
+                { 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 revert 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 { NonInteractiveOptions as EditRolloutNonInteractiveOptions } from './EditRollout';
+import { GeneralOptions as EndRolloutGeneralOptions, NonInteractiveOptions as EndRolloutNonInteractiveOptions } from './EndRollout';
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+import { UpdateChannelBasicInfoFragment } from '../../graphql/generated';
+export declare enum ManageRolloutActions {
+    EDIT = "Edit",
+    END = "End",
+    VIEW = "View",
+    GO_BACK = "Go back"
+}
+/**
+ * Manage a rollout for the project.
+ */
+export declare class ManageRollout implements EASUpdateAction<EASUpdateAction> {
+    private readonly channelInfo;
+    private readonly options;
+    constructor(channelInfo: UpdateChannelBasicInfoFragment, options: {
+        callingAction?: EASUpdateAction;
+        action?: ManageRolloutActions.EDIT | ManageRolloutActions.END | ManageRolloutActions.VIEW;
+    } & Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions> & EndRolloutGeneralOptions);
+    runAsync(ctx: EASUpdateContext): Promise<EASUpdateAction>;
+    private selectActionAsync;
+    private getChannelObjectAsync;
+}

package/build/rollout/actions/ManageRollout.js

@@ -0,0 +1,90 @@
+"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 EditRollout_1 = require("./EditRollout");
+const EndRollout_1 = require("./EndRollout");
+const ChannelQuery_1 = require("../../graphql/queries/ChannelQuery");
+const prompts_1 = require("../../prompts");
+const branch_mapping_1 = require("../branch-mapping");
+const utils_1 = require("../utils");
+var ManageRolloutActions;
+(function (ManageRolloutActions) {
+    ManageRolloutActions["EDIT"] = "Edit";
+    ManageRolloutActions["END"] = "End";
+    ManageRolloutActions["VIEW"] = "View";
+    ManageRolloutActions["GO_BACK"] = "Go back";
+})(ManageRolloutActions || (exports.ManageRolloutActions = ManageRolloutActions = {}));
+/**
+ * Manage a rollout for the project.
+ */
+class ManageRollout {
+    channelInfo;
+    options;
+    constructor(channelInfo, options) {
+        this.channelInfo = channelInfo;
+        this.options = options;
+    }
+    async runAsync(ctx) {
+        const { nonInteractive } = ctx;
+        if (nonInteractive) {
+            throw new Error(`Rollout selection cannot be run in non-interactive mode. Available actions: ${[
+                ManageRolloutActions.EDIT,
+                ManageRolloutActions.END,
+                ManageRolloutActions.VIEW,
+            ].join(', ')}.`);
+        }
+        const channelObject = await this.getChannelObjectAsync(ctx);
+        (0, utils_1.printRollout)(channelObject);
+        const action = this.options.action ?? (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.VIEW:
+                // Rollout is automatically printed in interactive mode
+                return new Noop();
+            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;
+class Noop {
+    async runAsync() { }
+}

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

@@ -0,0 +1,23 @@
+import { NonInteractiveOptions as CreateRolloutNonInteractiveOptions } from './CreateRollout';
+import { NonInteractiveOptions as EditRolloutNonInteractiveOptions } from './EditRollout';
+import { GeneralOptions as EndRolloutGeneralOptions, NonInteractiveOptions as EndRolloutNonInteractiveOptions } from './EndRollout';
+import { RolloutActions } from './RolloutMainMenu';
+import { EASUpdateAction, EASUpdateContext } from '../../eas-update/utils';
+/**
+ * Control a rollout in non interactive mode.
+ */
+export declare class NonInteractiveRollout implements EASUpdateAction<void> {
+    private readonly options;
+    constructor(options: {
+        channelName?: string;
+        json?: boolean;
+        action?: RolloutActions;
+    } & Partial<EditRolloutNonInteractiveOptions> & Partial<EndRolloutNonInteractiveOptions> & EndRolloutGeneralOptions & Partial<CreateRolloutNonInteractiveOptions>);
+    runAsync(ctx: EASUpdateContext): Promise<void>;
+    private runActionAsync;
+    private viewRollout;
+    private getJsonAsync;
+    private getRolloutJsonAsync;
+    private getRuntimeVersion;
+    private getChannelObjectAsync;
+}