eas-cli 3.18.3 → 4.0.0

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>;

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCurrentMachineMethodAsync = void 0;
+const tslib_1 = require("tslib");
+const spawn_async_1 = tslib_1.__importDefault(require("@expo/spawn-async"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const os_1 = tslib_1.__importDefault(require("os"));
+const AppleDeviceMutation_1 = require("../../../credentials/ios/api/graphql/mutations/AppleDeviceMutation");
+const generated_1 = require("../../../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const ora_1 = require("../../../ora");
+const prompts_1 = require("../../../prompts");
+const errors_1 = require("../../utils/errors");
+const utils_1 = require("./utils");
+async function runCurrentMachineMethodAsync(graphqlClient, accountId, appleTeam) {
+    log_1.default.newLine();
+    log_1.default.log(chalk_1.default.white('Checking if current machine is an Apple Silicon one.'));
+    if (!isMachineAppleSilicon()) {
+        throw new errors_1.DeviceCreateError("Current machine is not of Apple Silicon type - provisioning UDID can't be added automatically.");
+    }
+    log_1.default.log(chalk_1.default.green('Check successful.'));
+    await collectDataAndRegisterDeviceAsync(graphqlClient, { accountId, appleTeam });
+}
+exports.runCurrentMachineMethodAsync = runCurrentMachineMethodAsync;
+function isMachineAppleSilicon() {
+    return os_1.default.cpus()[0].model.includes('Apple M') && process.platform === 'darwin';
+}
+async function collectDataAndRegisterDeviceAsync(graphqlClient, { accountId, appleTeam, }) {
+    const deviceData = await collectDeviceDataAsync(appleTeam);
+    if (!deviceData) {
+        return;
+    }
+    const { udid, deviceClass, name } = deviceData;
+    const spinner = (0, ora_1.ora)(`Registering Apple device on Expo`).start();
+    try {
+        await AppleDeviceMutation_1.AppleDeviceMutation.createAppleDeviceAsync(graphqlClient, {
+            appleTeamId: appleTeam.id,
+            identifier: udid,
+            name,
+            deviceClass: deviceClass !== null && deviceClass !== void 0 ? deviceClass : undefined,
+        }, accountId);
+    }
+    catch (err) {
+        spinner.fail();
+        throw err;
+    }
+    spinner.succeed();
+}
+async function collectDeviceDataAsync(appleTeam, initialValues = {}) {
+    log_1.default.log(chalk_1.default.white('Fetching the provisioning UDID.'));
+    const [udid, defaultMachineName] = await fetchCurrentMachineUDIDAsync();
+    log_1.default.log(chalk_1.default.green(`Fetched the provisioning UDID - ${udid}`));
+    const name = await (0, utils_1.promptForNameAsync)(defaultMachineName !== null && defaultMachineName !== void 0 ? defaultMachineName : initialValues.name);
+    const deviceClass = generated_1.AppleDeviceClass.Mac;
+    const deviceData = {
+        udid,
+        name,
+        deviceClass,
+    };
+    (0, utils_1.printDeviceData)(deviceData, appleTeam);
+    const registrationConfirmed = await (0, prompts_1.confirmAsync)({
+        message: 'Is this what you want to register?',
+    });
+    if (!registrationConfirmed) {
+        log_1.default.log('No worries, just try again.');
+        log_1.default.newLine();
+        return null;
+    }
+    else {
+        return deviceData;
+    }
+}
+async function fetchCurrentMachineUDIDAsync() {
+    var _a, _b;
+    try {
+        const profilerData = (await (0, spawn_async_1.default)('system_profiler', ['-json', 'SPHardwareDataType'])).stdout.trim();
+        if (!profilerData) {
+            const message = 'Failed to fetch the provisioning UDID from system profiler';
+            log_1.default.error(message);
+            throw new errors_1.DeviceCreateError(message);
+        }
+        const profilerDataJSON = JSON.parse(profilerData);
+        const provisioningUDID = (_a = profilerDataJSON === null || profilerDataJSON === void 0 ? void 0 : profilerDataJSON.SPHardwareDataType[0]) === null || _a === void 0 ? void 0 : _a.provisioning_UDID;
+        if (!provisioningUDID) {
+            const message = 'System profiler data did not contain the provisioning UDID';
+            log_1.default.error(message);
+            throw new errors_1.DeviceCreateError(message);
+        }
+        const defaultMachineName = (_b = profilerDataJSON === null || profilerDataJSON === void 0 ? void 0 : profilerDataJSON.SPHardwareDataType[0]) === null || _b === void 0 ? void 0 : _b.machine_name;
+        return [provisioningUDID, defaultMachineName];
+    }
+    catch (err) {
+        if (!(err instanceof errors_1.DeviceCreateError)) {
+            const message = `Failed to fetch the provisioning UDID of the current machine - ${err.message}`;
+            log_1.default.error(message);
+            throw new errors_1.DeviceCreateError(message);
+        }
+        throw err;
+    }
+}

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

@@ -15,6 +15,7 @@ const DEVICE_IMPORT_CHUNK_SIZE = 10;
 const DEVICE_CLASS_TO_GRAPHQL_TYPE = {
     [apple_utils_1.DeviceClass.IPAD]: generated_1.AppleDeviceClass.Ipad,
     [apple_utils_1.DeviceClass.IPHONE]: generated_1.AppleDeviceClass.Iphone,
+    [apple_utils_1.DeviceClass.MAC]: generated_1.AppleDeviceClass.Mac,
 };
 async function runDeveloperPortalMethodAsync(graphqlClient, appStoreApi, accountId, appleTeam) {
     const appleAuthCtx = await appStoreApi.ensureAuthenticatedAsync();
@@ -61,7 +62,7 @@ async function findUnregisteredPortalDevicesAsync(graphqlClient, appleAuthCtx, a
     }, {});
     const portalDevices = await apple_utils_1.Device.getAsync((0, authenticate_1.getRequestContext)(appleAuthCtx));
     return portalDevices.filter(portalDevice => !(portalDevice.attributes.udid in expoRegisteredDevicesByUdid) &&
-        [apple_utils_1.DeviceClass.IPAD, apple_utils_1.DeviceClass.IPHONE, apple_utils_1.DeviceClass.APPLE_TV].includes(portalDevice.attributes.deviceClass));
+        [apple_utils_1.DeviceClass.IPAD, apple_utils_1.DeviceClass.IPHONE, apple_utils_1.DeviceClass.APPLE_TV, apple_utils_1.DeviceClass.MAC].includes(portalDevice.attributes.deviceClass));
 }
 async function chooseDevicesToImportAsync(devices) {
     const { chosenDevices } = await (0, prompts_1.promptAsync)({

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

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