eas-cli 3.18.2 → 4.0.0

package/build/channel/utils.d.ts

@@ -1,13 +1,2 @@
 import { UpdateBranchObject, UpdateChannelObject } from '../graphql/queries/ChannelQuery';
-import { BranchMapping } from './branch-mapping';
-/**
- * Get the branch mapping and determine whether it is a rollout.
- * Ensure that the branch mapping is properly formatted.
- */
-export declare function getBranchMapping(branchMappingString?: string): {
-    branchMapping: BranchMapping;
-    isRollout: boolean;
-    rolloutPercent?: number;
-};
-export declare function logChannelDetails(channel: UpdateChannelObject): void;
 export declare function getUpdateBranch(channel: UpdateChannelObject, branchId: string): UpdateBranchObject;

package/build/channel/utils.js

@@ -1,98 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUpdateBranch = exports.logChannelDetails = exports.getBranchMapping = void 0;
-const tslib_1 = require("tslib");
-const assert_1 = tslib_1.__importDefault(require("assert"));
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const log_1 = tslib_1.__importDefault(require("../log"));
-const utils_1 = require("../update/utils");
-const branch_mapping_1 = require("./branch-mapping");
-/**
- * Get the branch mapping and determine whether it is a rollout.
- * Ensure that the branch mapping is properly formatted.
- */
-function getBranchMapping(branchMappingString) {
-    var _a;
-    if (!branchMappingString) {
-        throw new Error('Missing branch mapping.');
-    }
-    let branchMapping;
-    try {
-        branchMapping = JSON.parse(branchMappingString);
-    }
-    catch {
-        throw new Error(`Could not parse branchMapping string into a JSON: "${branchMappingString}"`);
-    }
-    (0, assert_1.default)(branchMapping, 'Branch Mapping must be defined.');
-    if (branchMapping.version !== 0) {
-        throw new Error('Branch mapping must be version 0.');
-    }
-    const isRollout = branchMapping.data.length === 2;
-    const branchMappingNode = (_a = branchMapping.data[0]) === null || _a === void 0 ? void 0 : _a.branchMappingLogic;
-    let rolloutPercent;
-    if ((0, branch_mapping_1.isNodeObject)(branchMappingNode)) {
-        (0, branch_mapping_1.assertNumber)(branchMappingNode.operand);
-        rolloutPercent = branchMappingNode.operand;
-    }
-    switch (branchMapping.data.length) {
-        case 0:
-            break;
-        case 1:
-            if (branchMapping.data[0].branchMappingLogic !== 'true') {
-                throw new Error('Branch mapping logic for a single branch must be "true"');
-            }
-            break;
-        case 2:
-            (0, branch_mapping_1.assertNodeObject)(branchMappingNode);
-            if (branchMappingNode.clientKey !== 'rolloutToken') {
-                throw new Error('Client key of initial branch mapping must be "rolloutToken"');
-            }
-            if (branchMappingNode.branchMappingOperator !== 'hash_lt') {
-                throw new Error('Branch mapping operator of initial branch mapping must be "hash_lt"');
-            }
-            if (rolloutPercent == null) {
-                throw new Error('Branch mapping is missing a "rolloutPercent"');
-            }
-            if (branchMapping.data[1].branchMappingLogic !== 'true') {
-                throw new Error('Branch mapping logic for a the second branch of a rollout must be "true"');
-            }
-            break;
-        default:
-            throw new Error('Branch mapping data must have length less than or equal to 2.');
-    }
-    return { branchMapping, isRollout, rolloutPercent };
-}
-exports.getBranchMapping = getBranchMapping;
-function logChannelDetails(channel) {
-    const { branchMapping, isRollout, rolloutPercent } = getBranchMapping(channel.branchMapping);
-    if (branchMapping.data.length > 2) {
-        throw new Error('Branch Mapping data must have length less than or equal to 2.');
-    }
-    const rolloutBranchIds = branchMapping.data.map(data => data.branchId);
-    const branchDescription = channel.updateBranches.flatMap(branch => {
-        const updateGroupWithBranchDescriptions = (0, utils_1.getUpdateGroupDescriptionsWithBranch)(branch.updateGroups);
-        const isRolloutBranch = isRollout && rolloutBranchIds.includes(branch.id);
-        const isBaseBranch = rolloutBranchIds.length > 0 && rolloutBranchIds[0] === branch.id;
-        let rolloutPercentNumber = undefined;
-        if (isRolloutBranch) {
-            rolloutPercentNumber = isBaseBranch ? rolloutPercent * 100 : (1 - rolloutPercent) * 100;
-        }
-        return updateGroupWithBranchDescriptions.map(({ branch, ...updateGroup }) => ({
-            branch,
-            branchRolloutPercentage: rolloutPercentNumber,
-            update: updateGroup,
-        }));
-    });
-    if (branchDescription.length === 0) {
-        log_1.default.log(chalk_1.default.dim('No branches are pointed to this channel.'));
-    }
-    else {
-        log_1.default.log(branchDescription
-            .map(description => (0, utils_1.formatBranch)(description))
-            .join(`\n\n${chalk_1.default.dim('———')}\n\n`));
-    }
-}
-exports.logChannelDetails = logChannelDetails;
+exports.getUpdateBranch = void 0;
 function getUpdateBranchNullable(channel, branchId) {
     const updateBranches = channel.updateBranches;
     const updateBranch = updateBranches.find(branch => branch.id === branchId);

package/build/commands/channel/edit.js

@@ -8,6 +8,7 @@ const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const graphql_1 = require("graphql");
 const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
 const queries_1 = require("../../branch/queries");
+const branch_mapping_1 = require("../../channel/branch-mapping");
 const queries_2 = require("../../channel/queries");
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
 const flags_1 = require("../../commandUtils/flags");
@@ -16,6 +17,7 @@ const BranchQuery_1 = require("../../graphql/queries/BranchQuery");
 const ChannelQuery_1 = require("../../graphql/queries/ChannelQuery");
 const UpdateChannelBasicInfo_1 = require("../../graphql/types/UpdateChannelBasicInfo");
 const log_1 = tslib_1.__importDefault(require("../../log"));
+const branch_mapping_2 = require("../../rollout/branch-mapping");
 const json_1 = require("../../utils/json");
 async function updateChannelBranchMappingAsync(graphqlClient, { channelId, branchMapping }) {
     const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
@@ -57,9 +59,12 @@ class ChannelEdit extends EasCommand_1.default {
                 selectionPromptTitle: 'Select a channel to edit',
                 paginatedQueryOptions: { json, nonInteractive, offset: 0 },
             });
-        if (existingChannel.updateBranches.length > 1) {
+        if ((0, branch_mapping_2.isRollout)(existingChannel)) {
             throw new Error('There is a rollout in progress. Manage it with "channel:rollout" instead.');
         }
+        else if (!(0, branch_mapping_1.hasStandardBranchMap)(existingChannel)) {
+            throw new Error('Only standard branch mappings can be edited with this command.');
+        }
         const branch = branchFlag
             ? await BranchQuery_1.BranchQuery.getBranchByNameAsync(graphqlClient, {
                 appId: projectId,

package/build/commands/channel/rollout.d.ts

@@ -1,4 +1,10 @@
 import EasCommand from '../../commandUtils/EasCommand';
+import { EndOutcome } from '../../rollout/actions/EndRollout';
+declare enum ActionRawFlagValue {
+    CREATE = "create",
+    EDIT = "edit",
+    END = "end"
+}
 export default class ChannelRollout extends EasCommand {
     static description: string;
     static args: {
@@ -8,13 +14,19 @@ export default class ChannelRollout extends EasCommand {
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        branch: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        action: import("@oclif/core/lib/interfaces").OptionFlag<ActionRawFlagValue | undefined>;
         percent: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined>;
-        end: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        outcome: import("@oclif/core/lib/interfaces").OptionFlag<EndOutcome | undefined>;
+        branch: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'runtime-version': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'private-key-path': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
     };
     static contextDefinition: {
         loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
         privateProjectConfig: import("../../commandUtils/context/PrivateProjectConfigContextField").PrivateProjectConfigContextField;
     };
     runAsync(): Promise<void>;
+    private getAction;
+    private sanitizeArgsAndFlags;
 }
+export {};

package/build/commands/channel/rollout.js

@@ -3,262 +3,72 @@ var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const core_1 = require("@oclif/core");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const queries_1 = require("../../branch/queries");
-const branch_mapping_1 = require("../../channel/branch-mapping");
-const queries_2 = require("../../channel/queries");
-const utils_1 = require("../../channel/utils");
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
 const flags_1 = require("../../commandUtils/flags");
-const BranchQuery_1 = require("../../graphql/queries/BranchQuery");
-const ChannelQuery_1 = require("../../graphql/queries/ChannelQuery");
 const log_1 = tslib_1.__importDefault(require("../../log"));
-const projectUtils_1 = require("../../project/projectUtils");
-const prompts_1 = require("../../prompts");
-const json_1 = require("../../utils/json");
-const edit_1 = require("./edit");
-async function promptForRolloutPercentAsync({ promptMessage, }) {
-    const { name: rolloutPercent } = await (0, prompts_1.promptAsync)({
-        type: 'text',
-        name: 'name',
-        format: value => {
-            return parseInt(value, 10);
-        },
-        message: promptMessage,
-        initial: 0,
-        validate: (rolloutPercent) => {
-            const floatValue = parseFloat(rolloutPercent);
-            return Number.isInteger(floatValue) && floatValue >= 0 && floatValue <= 100
-                ? true
-                : 'The rollout percentage must be an integer between 0 and 100 inclusive.';
-        },
-    });
-    return rolloutPercent;
-}
-function getRolloutInfo(channel) {
-    var _b;
-    const { branchMapping } = (0, utils_1.getBranchMapping)(channel.branchMapping);
-    const [newBranchId, oldBranchId] = branchMapping.data.map(d => d.branchId);
-    const newBranch = channel.updateBranches.filter(branch => branch.id === newBranchId)[0];
-    const oldBranch = channel.updateBranches.filter(branch => branch.id === oldBranchId)[0];
-    if (!newBranch || !oldBranch) {
-        throw new Error(`Branch mapping rollout is missing a branch for channel "${channel.name}".`);
-    }
-    const branchMappingNode = (_b = branchMapping.data[0]) === null || _b === void 0 ? void 0 : _b.branchMappingLogic;
-    (0, branch_mapping_1.assertNodeObject)(branchMappingNode);
-    (0, branch_mapping_1.assertNumber)(branchMappingNode.operand);
-    const currentPercent = 100 * branchMappingNode.operand;
-    return { newBranch, oldBranch, currentPercent };
-}
-async function startRolloutAsync(graphqlClient, { channelName, branchName, percent, projectId, displayName, currentBranchMapping, channel, nonInteractive, }) {
-    const branch = await BranchQuery_1.BranchQuery.getBranchByNameAsync(graphqlClient, {
-        appId: projectId,
-        name: branchName,
-    });
-    const oldBranchId = currentBranchMapping.data[0].branchId;
-    if (branch.id === oldBranchId) {
-        throw new Error(`channel "${channelName}" is already pointing at branch "${branchName}". Rollouts must be done with distinct branches.`);
-    }
-    if (percent == null) {
-        if (nonInteractive) {
-            throw new Error('You must specify a percent with the --percent flag when initiating a rollout with the --non-interactive flag.');
-        }
-        const promptMessage = `What percent of users should be directed to the branch "${branchName}"?`;
-        percent = await promptForRolloutPercentAsync({ promptMessage });
-    }
-    const newBranchMapping = {
-        version: 0,
-        data: [
-            {
-                branchId: branch.id,
-                branchMappingLogic: {
-                    operand: percent / 100,
-                    clientKey: 'rolloutToken',
-                    branchMappingOperator: 'hash_lt',
-                },
-            },
-            currentBranchMapping.data[0],
-        ],
-    };
-    const newChannelInfo = await (0, edit_1.updateChannelBranchMappingAsync)(graphqlClient, {
-        channelId: channel.id,
-        branchMapping: JSON.stringify(newBranchMapping),
-    });
-    const oldBranch = channel.updateBranches.filter(branch => branch.id === oldBranchId)[0];
-    if (!oldBranch) {
-        throw new Error(`Branch mapping is missing its only branch for channel "${channelName}" on app "${displayName}"`);
-    }
-    const logMessage = `Started a rollout of branch ${chalk_1.default.bold(branchName)} on channel ${chalk_1.default.bold(channelName)}! ${chalk_1.default.bold(percent)}% of users will be directed to branch ${chalk_1.default.bold(branchName)}, ${chalk_1.default.bold(100 - percent)}% to branch ${chalk_1.default.bold(oldBranch.name)}.`;
-    return { newChannelInfo, logMessage };
-}
-async function editRolloutAsync(graphqlClient, { channelName, percent, nonInteractive, currentBranchMapping, channel, }) {
-    const { newBranch, oldBranch, currentPercent } = getRolloutInfo(channel);
-    if (percent == null) {
-        if (nonInteractive) {
-            throw new Error('A rollout is already in progress. If you wish to modify it you must use specify the new rollout percentage with the --percent flag.');
-        }
-        const promptMessage = `Currently ${currentPercent}% of all users are routed to branch ${newBranch.name} and ${100 - currentPercent}% of all users are routed to branch ${oldBranch.name}. What percent of users should be directed to the branch ${newBranch.name}?`;
-        percent = await promptForRolloutPercentAsync({ promptMessage });
-    }
-    const newBranchMapping = { ...currentBranchMapping };
-    newBranchMapping.data[0].branchMappingLogic.operand = percent / 100;
-    const newChannelInfo = await (0, edit_1.updateChannelBranchMappingAsync)(graphqlClient, {
-        channelId: channel.id,
-        branchMapping: JSON.stringify(newBranchMapping),
-    });
-    const logMessage = `Rollout of branch ${chalk_1.default.bold(newBranch.name)} on channel ${chalk_1.default.bold(channelName)} updated from ${chalk_1.default.bold(currentPercent)}% to ${chalk_1.default.bold(percent)}%. ${chalk_1.default.bold(percent)}% of users will be directed to branch ${chalk_1.default.bold(newBranch.name)}, ${chalk_1.default.bold(100 - percent)}% to branch ${chalk_1.default.bold(oldBranch.name)}.`;
-    return { newChannelInfo, logMessage };
-}
-async function endRolloutAsync(graphqlClient, { channelName, branchName, nonInteractive, projectId, channel, }) {
-    // end rollout
-    const { newBranch, oldBranch, currentPercent } = getRolloutInfo(channel);
-    let endOnNewBranch;
-    if (branchName) {
-        const branch = await BranchQuery_1.BranchQuery.getBranchByNameAsync(graphqlClient, {
-            appId: projectId,
-            name: branchName,
-        });
-        switch (branch.id) {
-            case newBranch.id:
-                endOnNewBranch = true;
-                break;
-            case oldBranch.id:
-                endOnNewBranch = false;
-                break;
-            default:
-                throw new Error(`The branch "${branchName}" specified by --branch must be one of the branches involved in the rollout: "${newBranch.name}" or "${oldBranch.name}".`);
-        }
-    }
-    else {
-        if (nonInteractive) {
-            throw new Error('Branch name must be specified with the --branch flag when both the --end and --non-interactive flag are true.');
-        }
-        endOnNewBranch = await (0, prompts_1.selectAsync)('Ending the rollout will send all traffic to a single branch. Which one should that be?', [
-            {
-                title: `${newBranch.name} ${chalk_1.default.grey(`- current percent: ${currentPercent}%`)}`,
-                value: true,
-            },
-            {
-                title: `${oldBranch.name} ${chalk_1.default.grey(`- current percent: ${100 - currentPercent}%`)}`,
-                value: false,
-            },
-        ]);
-    }
-    if (endOnNewBranch == null) {
-        throw new Error('Branch to end on is undefined.');
-    }
-    const newBranchMapping = {
-        version: 0,
-        data: [
-            {
-                branchId: endOnNewBranch ? newBranch.id : oldBranch.id,
-                branchMappingLogic: 'true',
-            },
-        ],
-    };
-    const newChannelInfo = await (0, edit_1.updateChannelBranchMappingAsync)(graphqlClient, {
-        channelId: channel.id,
-        branchMapping: JSON.stringify(newBranchMapping),
-    });
-    const logMessage = `Rollout on channel ${chalk_1.default.bold(channelName)} ended. All traffic is now sent to branch ${chalk_1.default.bold(endOnNewBranch ? newBranch.name : oldBranch.name)}`;
-    return { newChannelInfo, logMessage };
-}
+const EndRollout_1 = require("../../rollout/actions/EndRollout");
+const ManageRollout_1 = require("../../rollout/actions/ManageRollout");
+const NonInteractiveRollout_1 = require("../../rollout/actions/NonInteractiveRollout");
+const RolloutMainMenu_1 = require("../../rollout/actions/RolloutMainMenu");
+var ActionRawFlagValue;
+(function (ActionRawFlagValue) {
+    ActionRawFlagValue["CREATE"] = "create";
+    ActionRawFlagValue["EDIT"] = "edit";
+    ActionRawFlagValue["END"] = "end";
+})(ActionRawFlagValue || (ActionRawFlagValue = {}));
 class ChannelRollout extends EasCommand_1.default {
     async runAsync() {
-        const { args: { channel: channelNameArg }, flags: { json: jsonFlag, end: endFlag, branch: branchName, percent, 'non-interactive': nonInteractive, }, } = await this.parse(ChannelRollout);
-        const { privateProjectConfig: { projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(ChannelRollout, {
-            nonInteractive,
+        const { args, flags } = await this.parse(ChannelRollout);
+        const argsAndFlags = this.sanitizeArgsAndFlags({ ...flags, ...args });
+        const { privateProjectConfig: { exp, projectId }, loggedIn: { graphqlClient }, } = await this.getContextAsync(ChannelRollout, {
+            nonInteractive: argsAndFlags.nonInteractive,
         });
-        if (jsonFlag) {
-            (0, json_1.enableJsonOutput)();
-        }
-        const projectDisplayName = await (0, projectUtils_1.getDisplayNameForProjectIdAsync)(graphqlClient, projectId);
-        let channelName = channelNameArg;
-        if (!channelName) {
-            const { name } = await (0, queries_2.selectChannelOnAppAsync)(graphqlClient, {
-                projectId,
-                selectionPromptTitle: 'Select a channel on which to perform a rollout',
-                paginatedQueryOptions: {
-                    json: jsonFlag,
-                    nonInteractive,
-                    offset: 0,
-                },
-            });
-            channelName = name;
-        }
-        const channel = await ChannelQuery_1.ChannelQuery.viewUpdateChannelAsync(graphqlClient, {
-            appId: projectId,
-            channelName,
-        });
-        if (!channel) {
-            throw new Error(`Could not find a channel named "${channelName}". Check which channels exist on this project with ${chalk_1.default.bold('eas channel:list')}.`);
-        }
-        const { branchMapping: currentBranchMapping, isRollout } = (0, utils_1.getBranchMapping)(channel.branchMapping);
-        if (currentBranchMapping.data.length === 0) {
-            throw new Error('The channel is not pointing at any branches.');
-        }
-        if (currentBranchMapping.data.length > 2) {
-            throw new Error('"channel:rollout" cannot handle branch mappings with more than 2 branches.');
-        }
-        // This combination doesn't make sense. Throw an error explaining the options.
-        if (isRollout && branchName && !endFlag) {
-            throw new Error(`There is a rollout in progress. You can only either edit the rollout percent or 'end' it.`);
-        }
-        /**
-         * This if/else block has three branches:
-         *  1. The branch mapping is not a rollout, i.e. it is pointing to a single branch.
-         *  2. The branch mapping is a rollout.
-         *    a. increase/decrease the rollout percentage.
-         *    b. end the rollout.
-         */
-        let rolloutMutationResult;
-        if (!isRollout) {
-            rolloutMutationResult = await startRolloutAsync(graphqlClient, {
-                channelName,
-                branchName: branchName !== null && branchName !== void 0 ? branchName : (await promptForBranchNameAsync({
-                    graphqlClient,
-                    projectId,
-                    channelName,
-                    nonInteractive,
-                    json: jsonFlag,
-                })),
-                percent,
-                nonInteractive,
-                projectId,
-                displayName: projectDisplayName,
-                currentBranchMapping,
-                channel,
-            });
-        }
-        else if (endFlag) {
-            rolloutMutationResult = await endRolloutAsync(graphqlClient, {
-                channelName,
-                branchName,
-                nonInteractive,
-                projectId,
-                channel,
-            });
+        if (argsAndFlags.json) {
+            // TODO(quin): implement json output
+            throw new Error('Developer Preview doesnt support JSON output yet');
+        }
+        const app = { projectId, exp };
+        const ctx = {
+            projectId,
+            nonInteractive: argsAndFlags.nonInteractive,
+            graphqlClient,
+            app,
+        };
+        if (argsAndFlags.nonInteractive) {
+            await new NonInteractiveRollout_1.NonInteractiveRollout(argsAndFlags).runAsync(ctx);
         }
         else {
-            rolloutMutationResult = await editRolloutAsync(graphqlClient, {
-                channelName,
-                percent,
-                nonInteractive,
-                currentBranchMapping,
-                channel,
-            });
-        }
-        if (!rolloutMutationResult) {
-            throw new Error('rollout result is empty');
+            log_1.default.addNewLineIfNone();
+            log_1.default.warn(`✨ This command is in Developer Preview and has not been released to production yet`);
+            log_1.default.addNewLineIfNone();
+            await new RolloutMainMenu_1.RolloutMainMenu(argsAndFlags).runAsync(ctx);
         }
-        const { newChannelInfo, logMessage } = rolloutMutationResult;
-        if (jsonFlag) {
-            (0, json_1.printJsonOnlyOutput)(newChannelInfo);
-        }
-        else {
-            log_1.default.withTick(logMessage);
+    }
+    getAction(action) {
+        switch (action) {
+            case ActionRawFlagValue.CREATE:
+                return RolloutMainMenu_1.MainMenuActions.CREATE_NEW;
+            case ActionRawFlagValue.EDIT:
+                return ManageRollout_1.ManageRolloutActions.EDIT;
+            case ActionRawFlagValue.END:
+                return ManageRollout_1.ManageRolloutActions.END;
         }
     }
+    sanitizeArgsAndFlags(rawFlags) {
+        var _b;
+        const action = rawFlags.action;
+        return {
+            channelName: rawFlags.channel,
+            percent: rawFlags.percent,
+            outcome: rawFlags.outcome,
+            branchNameToRollout: rawFlags.branch,
+            runtimeVersion: rawFlags['runtime-version'],
+            privateKeyPath: (_b = rawFlags['private-key-path']) !== null && _b !== void 0 ? _b : null,
+            action: action ? this.getAction(action) : undefined,
+            nonInteractive: rawFlags['non-interactive'],
+            json: rawFlags.json,
+        };
+    }
 }
 exports.default = ChannelRollout;
 _a = ChannelRollout;
@@ -270,17 +80,62 @@ ChannelRollout.args = [
     },
 ];
 ChannelRollout.flags = {
-    branch: core_1.Flags.string({
-        description: 'branch to rollout',
+    action: core_1.Flags.enum({
+        description: 'Rollout action to perform',
+        options: Object.values(ActionRawFlagValue),
         required: false,
+        relationships: [
+            {
+                type: 'all',
+                flags: [
+                    {
+                        name: 'percent',
+                        // eslint-disable-next-line async-protect/async-suffix
+                        when: async (flags) => {
+                            return (!!flags['non-interactive'] &&
+                                (flags['action'] === ActionRawFlagValue.CREATE ||
+                                    flags['action'] === ActionRawFlagValue.EDIT));
+                        },
+                    },
+                    {
+                        name: 'outcome',
+                        // eslint-disable-next-line async-protect/async-suffix
+                        when: async (flags) => !!flags['non-interactive'] && flags['action'] === ActionRawFlagValue.END,
+                    },
+                    {
+                        name: 'branch',
+                        // eslint-disable-next-line async-protect/async-suffix
+                        when: async (flags) => !!flags['non-interactive'] && flags['action'] === ActionRawFlagValue.CREATE,
+                    },
+                    {
+                        name: 'runtime-version',
+                        // eslint-disable-next-line async-protect/async-suffix
+                        when: async (flags) => !!flags['non-interactive'] && flags['action'] === ActionRawFlagValue.CREATE,
+                    },
+                ],
+            },
+        ],
     }),
     percent: core_1.Flags.integer({
-        description: 'percent of users to send to the new branch',
+        description: 'Percent of users to send to the new branch. Use with --action=edit or --action=create',
         required: false,
     }),
-    end: core_1.Flags.boolean({
-        description: 'end the rollout',
-        default: false,
+    outcome: core_1.Flags.enum({
+        description: 'End outcome of rollout. Use with --action=end',
+        options: Object.values(EndRollout_1.EndOutcome),
+        required: false,
+    }),
+    branch: core_1.Flags.string({
+        description: 'Branch to roll out. Use with --action=create',
+        required: false,
+    }),
+    'runtime-version': core_1.Flags.string({
+        description: 'Runtime version to target. Use with --action=create',
+        required: false,
+    }),
+    'private-key-path': core_1.Flags.string({
+        description: `File containing the PEM-encoded private key corresponding to the certificate in expo-updates' configuration. Defaults to a file named "private-key.pem" in the certificate's directory.`,
+        required: false,
     }),
     ...flags_1.EasNonInteractiveAndJsonFlags,
 };
@@ -288,22 +143,3 @@ ChannelRollout.contextDefinition = {
     ..._a.ContextOptions.ProjectConfig,
     ..._a.ContextOptions.LoggedIn,
 };
-async function promptForBranchNameAsync({ graphqlClient, projectId, channelName, nonInteractive, json, }) {
-    if (nonInteractive) {
-        throw new Error('Must supply branch flag in non-interactive mode');
-    }
-    const { name: branchName } = await (0, queries_1.selectBranchOnAppAsync)(graphqlClient, {
-        projectId,
-        promptTitle: `Which branch would you like roll out on ${channelName}?`,
-        displayTextForListItem: updateBranch => ({
-            title: updateBranch.name,
-        }),
-        // discard limit and offset because this query is not their intended target
-        paginatedQueryOptions: {
-            json,
-            nonInteractive,
-            offset: 0,
-        },
-    });
-    return branchName;
-}

package/build/commands/update/republish.d.ts

@@ -1,23 +1,4 @@
-import { Platform } from '@expo/config';
 import EasCommand from '../../commandUtils/EasCommand';
-type UpdateRepublishRawFlags = {
-    branch?: string;
-    channel?: string;
-    group?: string;
-    message?: string;
-    platform: string;
-    'non-interactive': boolean;
-    json?: boolean;
-};
-type UpdateRepublishFlags = {
-    branchName?: string;
-    channelName?: string;
-    groupId?: string;
-    updateMessage?: string;
-    platform: Platform[];
-    nonInteractive: boolean;
-    json: boolean;
-};
 export default class UpdateRepublish extends EasCommand {
     static description: string;
     static flags: {
@@ -28,12 +9,12 @@ export default class UpdateRepublish extends EasCommand {
         group: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
         message: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
         platform: import("@oclif/core/lib/interfaces").OptionFlag<string>;
+        'private-key-path': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
     };
     static contextDefinition: {
         loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
         privateProjectConfig: import("../../commandUtils/context/PrivateProjectConfigContextField").PrivateProjectConfigContextField;
     };
     runAsync(): Promise<void>;
-    sanitizeFlags(rawFlags: UpdateRepublishRawFlags): UpdateRepublishFlags;
+    private sanitizeFlags;
 }
-export {};