eas-cli 3.18.3 → 4.0.1

package/build/channel/utils.js

@@ -1,65 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUpdateBranch = exports.getBranchMapping = void 0;
-const tslib_1 = require("tslib");
-const assert_1 = tslib_1.__importDefault(require("assert"));
-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;
+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

@@ -62,7 +62,7 @@ class ChannelEdit extends EasCommand_1.default {
         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)) {
+        else if (!(0, branch_mapping_1.hasStandardBranchMap)(existingChannel) && !(0, branch_mapping_1.hasEmptyBranchMap)(existingChannel)) {
             throw new Error('Only standard branch mappings can be edited with this command.');
         }
         const branch = branchFlag

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.js

@@ -36,14 +36,14 @@ class UpdateRepublish extends EasCommand_1.default {
             throw new Error(`There are no updates on branch "${existingUpdates[0].branchName}" published for the platform(s) "${rawFlags.platform}" with group ID "${flags.groupId ? flags.groupId : updatesToPublish[0].groupId}". Did you mean to publish a new update instead?`);
         }
         if (rawFlags.platform === 'all') {
-            log_1.default.withTick(`The republished update will appear only on: ${rawFlags.platform}`);
+            log_1.default.withTick(`The republished update group will appear only on: ${rawFlags.platform}`);
         }
         else {
             const platformsFromUpdates = updatesToPublish.map(update => update.platform);
             if (platformsFromUpdates.length < defaultRepublishPlatforms.length) {
-                log_1.default.warn(`You are republishing an update that wasn't published for all platforms.`);
+                log_1.default.warn(`You are republishing an update group that wasn't published for all platforms.`);
             }
-            log_1.default.withTick(`The republished update will appear on the same platforms it was originally published on: ${platformsFromUpdates.join(', ')}`);
+            log_1.default.withTick(`The republished update group will appear on the same platforms it was originally published on: ${platformsFromUpdates.join(', ')}`);
         }
         const updateMessage = await getOrAskUpdateMessageAsync(updatesToPublish, flags);
         const arbitraryUpdate = updatesToPublish[0];
@@ -88,11 +88,11 @@ _a = UpdateRepublish;
 UpdateRepublish.description = 'roll back to an existing update';
 UpdateRepublish.flags = {
     channel: core_1.Flags.string({
-        description: 'Channel name to select an update to republish from',
+        description: 'Channel name to select an update group to republish from',
         exclusive: ['branch', 'group'],
     }),
     branch: core_1.Flags.string({
-        description: 'Branch name to select an update to republish from',
+        description: 'Branch name to select an update group to republish from',
         exclusive: ['channel', 'group'],
     }),
     group: core_1.Flags.string({
@@ -101,7 +101,7 @@ UpdateRepublish.flags = {
     }),
     message: core_1.Flags.string({
         char: 'm',
-        description: 'Short message describing the republished update',
+        description: 'Short message describing the republished update group',
         required: false,
     }),
     platform: core_1.Flags.enum({

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

@@ -5,7 +5,8 @@ export declare enum RegistrationMethod {
     WEBSITE = 0,
     INPUT = 1,
     DEVELOPER_PORTAL = 2,
-    EXIT = 3
+    CURRENT_MACHINE = 3,
+    EXIT = 4
 }
 export default class DeviceCreateAction {
     private graphqlClient;

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

@@ -5,6 +5,7 @@ const tslib_1 = require("tslib");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const log_1 = tslib_1.__importDefault(require("../../../log"));
 const prompts_1 = require("../../../prompts");
+const currentMachineMethod_1 = require("./currentMachineMethod");
 const developerPortalMethod_1 = require("./developerPortalMethod");
 const inputMethod_1 = require("./inputMethod");
 const registrationUrlMethod_1 = require("./registrationUrlMethod");
@@ -13,7 +14,8 @@ var RegistrationMethod;
     RegistrationMethod[RegistrationMethod["WEBSITE"] = 0] = "WEBSITE";
     RegistrationMethod[RegistrationMethod["INPUT"] = 1] = "INPUT";
     RegistrationMethod[RegistrationMethod["DEVELOPER_PORTAL"] = 2] = "DEVELOPER_PORTAL";
-    RegistrationMethod[RegistrationMethod["EXIT"] = 3] = "EXIT";
+    RegistrationMethod[RegistrationMethod["CURRENT_MACHINE"] = 3] = "CURRENT_MACHINE";
+    RegistrationMethod[RegistrationMethod["EXIT"] = 4] = "EXIT";
 })(RegistrationMethod = exports.RegistrationMethod || (exports.RegistrationMethod = {}));
 class DeviceCreateAction {
     constructor(graphqlClient, appStoreApi, account, appleTeam) {
@@ -33,6 +35,9 @@ class DeviceCreateAction {
         else if (method === RegistrationMethod.INPUT) {
             await (0, inputMethod_1.runInputMethodAsync)(this.graphqlClient, this.account.id, this.appleTeam);
         }
+        else if (method === RegistrationMethod.CURRENT_MACHINE) {
+            await (0, currentMachineMethod_1.runCurrentMachineMethodAsync)(this.graphqlClient, this.account.id, this.appleTeam);
+        }
         else if (method === RegistrationMethod.EXIT) {
             log_1.default.log('Bye!');
             process.exit(0);
@@ -57,6 +62,10 @@ class DeviceCreateAction {
                     title: `${chalk_1.default.bold('Input')} - allows you to type in UDIDs (advanced option)`,
                     value: RegistrationMethod.INPUT,
                 },
+                {
+                    title: `${chalk_1.default.bold('Current Machine')} - automatically sets the provisioning UDID of the current Apple Silicon machine`,
+                    value: RegistrationMethod.CURRENT_MACHINE,
+                },
                 { title: chalk_1.default.bold('Exit'), value: RegistrationMethod.EXIT },
             ],
             validate: (val) => Object.values(RegistrationMethod).includes(val),

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

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