@donotuse/eas-cli 18.5.0-rc.1

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistrationMethod = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const currentMachineMethod_1 = require("./currentMachineMethod");
+const developerPortalMethod_1 = require("./developerPortalMethod");
+const inputMethod_1 = require("./inputMethod");
+const registrationUrlMethod_1 = require("./registrationUrlMethod");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+var RegistrationMethod;
+(function (RegistrationMethod) {
+    RegistrationMethod[RegistrationMethod["WEBSITE"] = 0] = "WEBSITE";
+    RegistrationMethod[RegistrationMethod["INPUT"] = 1] = "INPUT";
+    RegistrationMethod[RegistrationMethod["DEVELOPER_PORTAL"] = 2] = "DEVELOPER_PORTAL";
+    RegistrationMethod[RegistrationMethod["CURRENT_MACHINE"] = 3] = "CURRENT_MACHINE";
+    RegistrationMethod[RegistrationMethod["EXIT"] = 4] = "EXIT";
+})(RegistrationMethod || (exports.RegistrationMethod = RegistrationMethod = {}));
+class DeviceCreateAction {
+    graphqlClient;
+    appStoreApi;
+    account;
+    appleTeam;
+    constructor(graphqlClient, appStoreApi, account, appleTeam) {
+        this.graphqlClient = graphqlClient;
+        this.appStoreApi = appStoreApi;
+        this.account = account;
+        this.appleTeam = appleTeam;
+    }
+    async runAsync() {
+        const method = await this.askForRegistrationMethodAsync();
+        if (method === RegistrationMethod.WEBSITE) {
+            await (0, registrationUrlMethod_1.runRegistrationUrlMethodAsync)(this.graphqlClient, this.account.id, this.appleTeam);
+        }
+        else if (method === RegistrationMethod.DEVELOPER_PORTAL) {
+            await (0, developerPortalMethod_1.runDeveloperPortalMethodAsync)(this.graphqlClient, this.appStoreApi, this.account, this.appleTeam);
+        }
+        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);
+        }
+        return method;
+    }
+    async askForRegistrationMethodAsync() {
+        const { method } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'method',
+            message: `How would you like to register your devices?`,
+            choices: [
+                {
+                    title: `${chalk_1.default.bold('Website')} - generates a registration URL to be opened on your devices`,
+                    value: RegistrationMethod.WEBSITE,
+                },
+                {
+                    title: `${chalk_1.default.bold('Developer Portal')} - import devices already registered on Apple Developer Portal`,
+                    value: RegistrationMethod.DEVELOPER_PORTAL,
+                },
+                {
+                    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),
+            initial: RegistrationMethod.WEBSITE,
+        });
+        return method;
+    }
+}
+exports.default = DeviceCreateAction;

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,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCurrentMachineMethodAsync = runCurrentMachineMethodAsync;
+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 utils_1 = require("./utils");
+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");
+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 });
+}
+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 EAS`).start();
+    try {
+        await AppleDeviceMutation_1.AppleDeviceMutation.createAppleDeviceAsync(graphqlClient, {
+            appleTeamId: appleTeam.id,
+            identifier: udid,
+            name,
+            deviceClass: 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 ?? 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() {
+    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 = profilerDataJSON?.SPHardwareDataType[0]?.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 = profilerDataJSON?.SPHardwareDataType[0]?.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.d.ts

@@ -0,0 +1,6 @@
+import { Device } from '@expo/apple-utils';
+import { ExpoGraphqlClient } from '../../../commandUtils/context/contextUtils/createGraphqlClient';
+import AppStoreApi from '../../../credentials/ios/appstore/AppStoreApi';
+import { AccountFragment, AppleTeam } from '../../../graphql/generated';
+export declare function runDeveloperPortalMethodAsync(graphqlClient: ExpoGraphqlClient, appStoreApi: AppStoreApi, account: AccountFragment, appleTeam: Pick<AppleTeam, 'appleTeamIdentifier' | 'appleTeamName' | 'id'>): Promise<void>;
+export declare function formatDeviceLabel(device: Device): string;

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDeveloperPortalMethodAsync = runDeveloperPortalMethodAsync;
+exports.formatDeviceLabel = formatDeviceLabel;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const AppleDeviceMutation_1 = require("../../../credentials/ios/api/graphql/mutations/AppleDeviceMutation");
+const AppleDeviceQuery_1 = require("../../../credentials/ios/api/graphql/queries/AppleDeviceQuery");
+const authenticate_1 = require("../../../credentials/ios/appstore/authenticate");
+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 chunk_1 = tslib_1.__importDefault(require("../../../utils/expodash/chunk"));
+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, account, appleTeam) {
+    const appleAuthCtx = await appStoreApi.ensureAuthenticatedAsync();
+    const unregisteredPortalDevices = await findUnregisteredPortalDevicesAsync(graphqlClient, appleAuthCtx, account.name, appleTeam);
+    if (unregisteredPortalDevices.length === 0) {
+        log_1.default.log('All your devices registered on Apple Developer Portal are already imported to EAS.');
+        return;
+    }
+    const devicesToImport = await chooseDevicesToImportAsync(unregisteredPortalDevices);
+    await importDevicesAsync(graphqlClient, account.id, appleTeam, devicesToImport);
+}
+async function importDevicesAsync(graphqlClient, accountId, appleTeam, devices) {
+    const spinner = (0, ora_1.ora)(`Importing ${devices.length} Apple device${devices.length === 1 ? '' : 's'} to EAS`).start();
+    const deviceChunks = (0, chunk_1.default)(devices, DEVICE_IMPORT_CHUNK_SIZE);
+    try {
+        for (const deviceChunk of deviceChunks) {
+            await importDeviceChunkAsync(graphqlClient, accountId, appleTeam, deviceChunk);
+        }
+    }
+    catch (err) {
+        spinner.fail();
+        throw err;
+    }
+    spinner.succeed();
+}
+async function importDeviceChunkAsync(graphqlClient, accountId, appleTeam, devices) {
+    const promises = devices.map(device => {
+        return AppleDeviceMutation_1.AppleDeviceMutation.createAppleDeviceAsync(graphqlClient, {
+            appleTeamId: appleTeam.id,
+            identifier: device.attributes.udid,
+            name: device.attributes.name,
+            deviceClass: DEVICE_CLASS_TO_GRAPHQL_TYPE[device.attributes.deviceClass] ?? undefined,
+        }, accountId);
+    });
+    await Promise.all(promises);
+}
+async function findUnregisteredPortalDevicesAsync(graphqlClient, appleAuthCtx, accountName, appleTeam) {
+    const expoRegisteredDevices = await AppleDeviceQuery_1.AppleDeviceQuery.getAllByAppleTeamIdentifierAsync(graphqlClient, accountName, appleTeam.appleTeamIdentifier, { useCache: false });
+    const expoRegisteredDevicesByUdid = expoRegisteredDevices.reduce((acc, device) => {
+        acc[device.identifier] = device;
+        return acc;
+    }, {});
+    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, apple_utils_1.DeviceClass.MAC].includes(portalDevice.attributes.deviceClass));
+}
+async function chooseDevicesToImportAsync(devices) {
+    const { chosenDevices } = await (0, prompts_1.promptAsync)({
+        type: 'multiselect',
+        name: 'chosenDevices',
+        message: 'Which devices do you want to import to EAS?',
+        choices: devices.map(device => ({
+            value: device,
+            title: formatDeviceLabel(device),
+            selected: true,
+        })),
+    });
+    return chosenDevices;
+}
+function formatDeviceLabel(device) {
+    const deviceDetails = formatDeviceDetails(device);
+    return `${device.attributes.name} - ${device.attributes.udid})${deviceDetails !== '' ? ` - ${deviceDetails}` : ''}`;
+}
+function formatDeviceDetails(device) {
+    let details = device.attributes.deviceClass;
+    if (device.attributes.model) {
+        details = device.attributes.model;
+    }
+    return details === '' ? details : `(${details})`;
+}

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

@@ -0,0 +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>;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInputMethodAsync = runInputMethodAsync;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const utils_1 = require("./utils");
+const AppleDeviceMutation_1 = require("../../../credentials/ios/api/graphql/mutations/AppleDeviceMutation");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const ora_1 = require("../../../ora");
+const prompts_1 = require("../../../prompts");
+async function runInputMethodAsync(graphqlClient, accountId, appleTeam) {
+    log_1.default.newLine();
+    log_1.default.log(chalk_1.default.yellow('This is an advanced option. Use at your own risk.'));
+    log_1.default.newLine();
+    let registerNextDevice = true;
+    while (registerNextDevice) {
+        await collectDataAndRegisterDeviceAsync(graphqlClient, { accountId, appleTeam });
+        log_1.default.newLine();
+        registerNextDevice = await (0, prompts_1.confirmAsync)({
+            message: 'Do you want to register another device?',
+        });
+    }
+}
+async function collectDataAndRegisterDeviceAsync(graphqlClient, { accountId, appleTeam, }) {
+    const { udid, deviceClass, name } = await collectDeviceDataAsync(appleTeam);
+    const spinner = (0, ora_1.ora)(`Registering Apple device on EAS`).start();
+    try {
+        await AppleDeviceMutation_1.AppleDeviceMutation.createAppleDeviceAsync(graphqlClient, {
+            appleTeamId: appleTeam.id,
+            identifier: udid,
+            name,
+            deviceClass: deviceClass ?? undefined,
+        }, accountId);
+    }
+    catch (err) {
+        spinner.fail();
+        throw err;
+    }
+    spinner.succeed();
+}
+async function collectDeviceDataAsync(appleTeam, initialValues = {}) {
+    const udid = await (0, utils_1.promptForUDIDAsync)(initialValues.udid);
+    const name = await (0, utils_1.promptForNameAsync)(initialValues.name);
+    const deviceClass = await (0, utils_1.promptForDeviceClassAsync)(initialValues.deviceClass);
+    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 await collectDeviceDataAsync(appleTeam, deviceData);
+    }
+    else {
+        return deviceData;
+    }
+}

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRegistrationUrlMethodAsync = runRegistrationUrlMethodAsync;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const indent_string_1 = tslib_1.__importDefault(require("indent-string"));
+const qrcode_terminal_1 = tslib_1.__importDefault(require("qrcode-terminal"));
+const url_1 = require("url");
+const api_1 = require("../../../api");
+const AppleDeviceRegistrationRequestMutation_1 = require("../../../credentials/ios/api/graphql/mutations/AppleDeviceRegistrationRequestMutation");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+async function runRegistrationUrlMethodAsync(graphqlClient, accountId, appleTeam) {
+    const registrationURL = await generateDeviceRegistrationURLAsync(graphqlClient, accountId, appleTeam);
+    log_1.default.newLine();
+    qrcode_terminal_1.default.generate(registrationURL, { small: true }, code => {
+        log_1.default.log(`${(0, indent_string_1.default)(code, 2)}\n`);
+    });
+    log_1.default.log('Open the following link on your iOS devices (or scan the QR code) and follow the instructions to install the development profile:');
+    log_1.default.log(chalk_1.default.green(`${registrationURL}`));
+}
+async function generateDeviceRegistrationURLAsync(graphqlClient, accountId, appleTeam) {
+    const appleDeviceRegistrationRequest = await AppleDeviceRegistrationRequestMutation_1.AppleDeviceRegistrationRequestMutation.createAppleDeviceRegistrationRequestAsync(graphqlClient, appleTeam.id, accountId);
+    return formatRegistrationURL(appleDeviceRegistrationRequest.id);
+}
+function formatRegistrationURL(id) {
+    return new url_1.URL(`/register-device/${id}`, (0, api_1.getExpoWebsiteBaseUrl)()).toString();
+}

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

@@ -0,0 +1,10 @@
+import { AppleDeviceClass, AppleTeam } from '../../../graphql/generated';
+export interface DeviceData {
+    udid: string;
+    name?: string;
+    deviceClass: AppleDeviceClass | null;
+}
+export declare function promptForDeviceClassAsync(initial?: AppleDeviceClass | null): Promise<AppleDeviceClass | null>;
+export declare function promptForNameAsync(initial?: string): Promise<string | undefined>;
+export declare function promptForUDIDAsync(initial?: string): Promise<string>;
+export declare function printDeviceData(deviceData: DeviceData, appleTeam: Pick<AppleTeam, 'appleTeamIdentifier' | 'appleTeamName'>): void;

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptForDeviceClassAsync = promptForDeviceClassAsync;
+exports.promptForNameAsync = promptForNameAsync;
+exports.promptForUDIDAsync = promptForUDIDAsync;
+exports.printDeviceData = printDeviceData;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const generated_1 = require("../../../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+const udids_1 = require("../../udids");
+const formatDevice_1 = require("../../utils/formatDevice");
+async function promptForDeviceClassAsync(initial) {
+    const choices = [
+        { title: 'iPhone', value: generated_1.AppleDeviceClass.Iphone },
+        { title: 'iPad', value: generated_1.AppleDeviceClass.Ipad },
+        { title: 'Mac', value: generated_1.AppleDeviceClass.Mac },
+        { title: 'Not sure (leave empty)', value: null },
+    ];
+    const values = choices.map(({ value }) => value);
+    const { deviceClass } = await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'deviceClass',
+        message: 'Device class (optional):',
+        choices,
+        initial: initial !== undefined && values.indexOf(initial),
+    });
+    return deviceClass;
+}
+async function promptForNameAsync(initial) {
+    const { name } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'name',
+        message: 'Device name (optional):',
+        initial,
+    });
+    return name;
+}
+async function promptForUDIDAsync(initial) {
+    const { udid } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'udid',
+        message: 'UDID:',
+        initial,
+        validate: (rawVal) => {
+            const val = (0, udids_1.normalizeUDID)(rawVal);
+            if (!val || val === '') {
+                return 'UDID cannot be empty';
+            }
+            else if (val.length !== 25 && val.length !== 40) {
+                return 'UDID should be a 25 or 40-character string';
+            }
+            else if (!(0, udids_1.isValidUDID)(val)) {
+                return 'UDID is invalid';
+            }
+            else {
+                return true;
+            }
+        },
+        format: (val) => (0, udids_1.normalizeUDID)(val),
+    });
+    return udid;
+}
+function printDeviceData(deviceData, appleTeam) {
+    log_1.default.newLine();
+    log_1.default.log(`We are going to register the following device in our database.
+  This device will ${chalk_1.default.bold('not')} be registered on the Apple Developer Portal until it is chosen for an internal distribution build.`);
+    log_1.default.newLine();
+    log_1.default.log((0, formatDevice_1.formatNewDevice)({ ...deviceData, identifier: deviceData.udid }, appleTeam));
+    log_1.default.newLine();
+}

package/build/devices/context.d.ts

@@ -0,0 +1,15 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import AppStoreApi from '../credentials/ios/appstore/AppStoreApi';
+import { Actor } from '../user/User';
+export interface DeviceManagerContext {
+    appStore: AppStoreApi;
+    user: Actor;
+    graphqlClient: ExpoGraphqlClient;
+    projectId: string | null;
+}
+export declare function createContextAsync({ appStore, user, graphqlClient, projectId, }: {
+    appStore: AppStoreApi;
+    user: Actor;
+    graphqlClient: ExpoGraphqlClient;
+    projectId: string | undefined;
+}): Promise<DeviceManagerContext>;

package/build/devices/context.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContextAsync = createContextAsync;
+async function createContextAsync({ appStore, user, graphqlClient, projectId, }) {
+    return {
+        appStore,
+        user,
+        graphqlClient,
+        projectId: projectId ?? null,
+    };
+}

package/build/devices/manager.d.ts

@@ -0,0 +1,19 @@
+import { DeviceManagerContext } from './context';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { AccountFragment } from '../graphql/generated';
+import { Actor } from '../user/User';
+export default class DeviceManager {
+    private readonly ctx;
+    constructor(ctx: DeviceManagerContext);
+    createAsync(): Promise<void>;
+    private resolveAccountAsync;
+}
+export declare class AccountResolver {
+    private readonly graphqlClient;
+    private readonly projectId;
+    private readonly user;
+    constructor(graphqlClient: ExpoGraphqlClient, projectId: string | null, user: Actor);
+    resolveAccountAsync(): Promise<AccountFragment>;
+    private resolveProjectAccountAsync;
+    private promptForAccountAsync;
+}

package/build/devices/manager.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountResolver = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const action_1 = tslib_1.__importDefault(require("./actions/create/action"));
+const GraphqlClient_1 = require("../credentials/ios/api/GraphqlClient");
+const log_1 = tslib_1.__importDefault(require("../log"));
+const projectUtils_1 = require("../project/projectUtils");
+const prompts_1 = require("../prompts");
+const CREATE_COMMAND_DESCRIPTION = `This command lets you register your Apple devices (iPhones, iPads and Macs) for internal distribution of your app.
+Internal distribution means that you won't need to upload your app archive to App Store / Testflight.
+Your app archive (.ipa) will be installable on your equipment as long as you sign your application with an adhoc provisioning profile.
+The provisioning profile needs to contain the UDIDs (unique identifiers) of your iPhones, iPads and Macs.
+
+First of all, choose the Expo account under which you want to register your devices.
+Later, authenticate with Apple and choose your desired Apple Team (if your Apple ID has access to multiple teams).`;
+class DeviceManager {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async createAsync() {
+        log_1.default.log(chalk_1.default.green(CREATE_COMMAND_DESCRIPTION));
+        log_1.default.addNewLineIfNone();
+        const account = await this.resolveAccountAsync();
+        const appleAuthCtx = await this.ctx.appStore.ensureAuthenticatedAsync();
+        const appleTeam = await (0, GraphqlClient_1.createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync)(this.ctx.graphqlClient, account.id, {
+            appleTeamIdentifier: appleAuthCtx.team.id,
+            appleTeamName: appleAuthCtx.team.name,
+        });
+        const action = new action_1.default(this.ctx.graphqlClient, this.ctx.appStore, account, appleTeam);
+        await action.runAsync();
+    }
+    async resolveAccountAsync() {
+        const resolver = new AccountResolver(this.ctx.graphqlClient, this.ctx.projectId, this.ctx.user);
+        return await resolver.resolveAccountAsync();
+    }
+}
+exports.default = DeviceManager;
+class AccountResolver {
+    graphqlClient;
+    projectId;
+    user;
+    constructor(graphqlClient, projectId, user) {
+        this.graphqlClient = graphqlClient;
+        this.projectId = projectId;
+        this.user = user;
+    }
+    async resolveAccountAsync() {
+        if (this.projectId) {
+            const account = await this.resolveProjectAccountAsync();
+            if (account) {
+                return account;
+            }
+        }
+        return await this.promptForAccountAsync();
+    }
+    async resolveProjectAccountAsync() {
+        (0, assert_1.default)(this.projectId, 'expo config is not set');
+        const account = await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(this.graphqlClient, this.projectId);
+        const useProjectAccount = await (0, prompts_1.confirmAsync)({
+            message: `You're inside the project directory. Would you like to use the ${chalk_1.default.underline(account.name)} account?`,
+        });
+        return useProjectAccount ? account : undefined;
+    }
+    async promptForAccountAsync() {
+        const choices = this.user.accounts.map(account => ({
+            title: account.name,
+            value: account,
+        }));
+        const { account } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'account',
+            message: 'Which account to use?',
+            choices,
+        });
+        return account;
+    }
+}
+exports.AccountResolver = AccountResolver;

package/build/devices/queries.d.ts

@@ -0,0 +1,22 @@
+import { AppleTeamIdAndName } from './utils/formatDevice';
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { PaginatedQueryOptions } from '../commandUtils/pagination';
+import { AppleDeviceFragment, AppleTeamFragment } from '../graphql/generated';
+export declare const TEAMS_LIMIT = 50;
+export declare const DEVICES_LIMIT = 50;
+export declare function selectAppleTeamOnAccountAsync(graphqlClient: ExpoGraphqlClient, { accountName, selectionPromptTitle, paginatedQueryOptions, }: {
+    accountName: string;
+    selectionPromptTitle: string;
+    paginatedQueryOptions: PaginatedQueryOptions;
+}): Promise<AppleTeamFragment>;
+export declare function selectAppleDeviceOnAppleTeamAsync(graphqlClient: ExpoGraphqlClient, { accountName, appleTeamIdentifier, selectionPromptTitle, paginatedQueryOptions, }: {
+    accountName: string;
+    appleTeamIdentifier: string;
+    selectionPromptTitle: string;
+    paginatedQueryOptions: PaginatedQueryOptions;
+}): Promise<AppleDeviceFragment>;
+export declare function listAndRenderAppleDevicesOnAppleTeamAsync(graphqlClient: ExpoGraphqlClient, { accountName, appleTeam, paginatedQueryOptions, }: {
+    accountName: string;
+    appleTeam: AppleTeamIdAndName;
+    paginatedQueryOptions: PaginatedQueryOptions;
+}): Promise<void>;