@donotuse/eas-cli 18.5.0-rc.1

package/build/credentials/manager/SelectAndroidBuildCredentials.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectExistingAndroidBuildCredentials = exports.SelectAndroidBuildCredentials = exports.SelectAndroidBuildCredentialsResultType = void 0;
+const tslib_1 = require("tslib");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+const BuildCredentialsUtils_1 = require("../android/actions/BuildCredentialsUtils");
+var SelectAndroidBuildCredentialsResultType;
+(function (SelectAndroidBuildCredentialsResultType) {
+    SelectAndroidBuildCredentialsResultType[SelectAndroidBuildCredentialsResultType["CREATE_REQUEST"] = 0] = "CREATE_REQUEST";
+    SelectAndroidBuildCredentialsResultType[SelectAndroidBuildCredentialsResultType["EXISTING_CREDENTIALS"] = 1] = "EXISTING_CREDENTIALS";
+})(SelectAndroidBuildCredentialsResultType || (exports.SelectAndroidBuildCredentialsResultType = SelectAndroidBuildCredentialsResultType = {}));
+/**
+ * Return a selected Android Build Credential, or a request to make a new one
+ */
+class SelectAndroidBuildCredentials {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async runAsync(ctx) {
+        const buildCredentialsList = await ctx.android.getAndroidAppBuildCredentialsListAsync(ctx.graphqlClient, this.app);
+        if (buildCredentialsList.length === 0) {
+            return {
+                resultType: SelectAndroidBuildCredentialsResultType.CREATE_REQUEST,
+                result: {
+                    isDefault: true,
+                    name: await (0, BuildCredentialsUtils_1.promptForNameAsync)(),
+                },
+            };
+        }
+        const sortedBuildCredentialsList = (0, BuildCredentialsUtils_1.sortBuildCredentials)(buildCredentialsList);
+        const sortedBuildCredentialsChoices = sortedBuildCredentialsList.map(buildCredentials => ({
+            title: buildCredentials.isDefault
+                ? `${buildCredentials.name} (Default)`
+                : buildCredentials.name,
+            value: buildCredentials,
+        }));
+        const buildCredentialsResultOrRequestToCreateNew = (await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'buildCredentialsResultOrRequestToCreateNew',
+            message: 'Select build credentials',
+            choices: [
+                ...sortedBuildCredentialsChoices,
+                {
+                    title: 'Create A New Build Credential Configuration',
+                    value: SelectAndroidBuildCredentialsResultType.CREATE_REQUEST,
+                },
+            ],
+        })).buildCredentialsResultOrRequestToCreateNew;
+        if (buildCredentialsResultOrRequestToCreateNew !==
+            SelectAndroidBuildCredentialsResultType.CREATE_REQUEST) {
+            return {
+                resultType: SelectAndroidBuildCredentialsResultType.EXISTING_CREDENTIALS,
+                result: buildCredentialsResultOrRequestToCreateNew,
+            };
+        }
+        const defaultCredentialsExists = buildCredentialsList.some(buildCredentials => buildCredentials.isDefault);
+        return {
+            resultType: SelectAndroidBuildCredentialsResultType.CREATE_REQUEST,
+            result: {
+                isDefault: !defaultCredentialsExists, // make default if there isn't one
+                name: await (0, BuildCredentialsUtils_1.promptForNameAsync)(),
+            },
+        };
+    }
+}
+exports.SelectAndroidBuildCredentials = SelectAndroidBuildCredentials;
+class SelectExistingAndroidBuildCredentials {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async runAsync(ctx) {
+        const buildCredentialsList = await ctx.android.getAndroidAppBuildCredentialsListAsync(ctx.graphqlClient, this.app);
+        if (buildCredentialsList.length === 0) {
+            log_1.default.log(`You don't have any Android Build Credentials`);
+            return null;
+        }
+        else if (buildCredentialsList.length === 1) {
+            return buildCredentialsList[0];
+        }
+        const sortedBuildCredentialsList = (0, BuildCredentialsUtils_1.sortBuildCredentials)(buildCredentialsList);
+        const sortedBuildCredentialsChoices = sortedBuildCredentialsList.map(buildCredentials => ({
+            title: buildCredentials.isDefault
+                ? `${buildCredentials.name} (Default)`
+                : buildCredentials.name,
+            value: buildCredentials,
+        }));
+        return (await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'buildCredentials',
+            message: 'Select build credentials',
+            choices: sortedBuildCredentialsChoices,
+        })).buildCredentials;
+    }
+}
+exports.SelectExistingAndroidBuildCredentials = SelectExistingAndroidBuildCredentials;

package/build/credentials/manager/SelectBuildProfileFromEasJson.d.ts

@@ -0,0 +1,9 @@
+import { Platform } from '@expo/eas-build-job';
+import { BuildProfile } from '@expo/eas-json';
+export declare class SelectBuildProfileFromEasJson<T extends Platform> {
+    private readonly platform;
+    private readonly easJsonAccessor;
+    constructor(projectDir: string, platform: T);
+    runAsync(): Promise<BuildProfile<T>>;
+    getProfileNameFromEasConfigAsync(): Promise<string>;
+}

package/build/credentials/manager/SelectBuildProfileFromEasJson.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectBuildProfileFromEasJson = void 0;
+const tslib_1 = require("tslib");
+const eas_json_1 = require("@expo/eas-json");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+class SelectBuildProfileFromEasJson {
+    platform;
+    easJsonAccessor;
+    constructor(projectDir, platform) {
+        this.platform = platform;
+        this.easJsonAccessor = eas_json_1.EasJsonAccessor.fromProjectPath(projectDir);
+    }
+    async runAsync() {
+        const profileName = await this.getProfileNameFromEasConfigAsync();
+        const easConfig = await eas_json_1.EasJsonUtils.getBuildProfileAsync(this.easJsonAccessor, this.platform, profileName);
+        log_1.default.succeed(`Using build profile: ${profileName}`);
+        return easConfig;
+    }
+    async getProfileNameFromEasConfigAsync() {
+        const buildProfileNames = await eas_json_1.EasJsonUtils.getBuildProfileNamesAsync(this.easJsonAccessor);
+        if (buildProfileNames.length === 0) {
+            throw new Error('You need at least one iOS build profile declared in eas.json. Go to https://docs.expo.dev/build/eas-json/ for more details');
+        }
+        else if (buildProfileNames.length === 1) {
+            return buildProfileNames[0];
+        }
+        const { profileName } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'profileName',
+            message: 'Which build profile do you want to configure?',
+            choices: buildProfileNames.map(profileName => ({ value: profileName, title: profileName })),
+        });
+        return profileName;
+    }
+}
+exports.SelectBuildProfileFromEasJson = SelectBuildProfileFromEasJson;

package/build/credentials/manager/SelectIosDistributionTypeGraphqlFromBuildProfile.d.ts

@@ -0,0 +1,10 @@
+import { Platform } from '@expo/eas-build-job';
+import { BuildProfile } from '@expo/eas-json';
+import { IosDistributionType as IosDistributionTypeGraphql } from '../../graphql/generated';
+import { CredentialsContext } from '../context';
+export declare class SelectIosDistributionTypeGraphqlFromBuildProfile {
+    private readonly buildProfile;
+    constructor(buildProfile: BuildProfile<Platform.IOS>);
+    runAsync(ctx: CredentialsContext): Promise<IosDistributionTypeGraphql>;
+    resolveInternalDistributionAsync(ctx: CredentialsContext): Promise<IosDistributionTypeGraphql>;
+}

package/build/credentials/manager/SelectIosDistributionTypeGraphqlFromBuildProfile.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectIosDistributionTypeGraphqlFromBuildProfile = void 0;
+const generated_1 = require("../../graphql/generated");
+const prompts_1 = require("../../prompts");
+class SelectIosDistributionTypeGraphqlFromBuildProfile {
+    buildProfile;
+    constructor(buildProfile) {
+        this.buildProfile = buildProfile;
+    }
+    async runAsync(ctx) {
+        const { distribution, simulator } = this.buildProfile;
+        if (simulator) {
+            throw new Error('A simulator distribution does not require credentials to be configured.');
+        }
+        else if (distribution === 'store') {
+            return generated_1.IosDistributionType.AppStore;
+        }
+        else {
+            return await this.resolveInternalDistributionAsync(ctx);
+        }
+    }
+    async resolveInternalDistributionAsync(ctx) {
+        // check if the type is specified in eas config
+        const maybeEnterpriseProvisioning = this.buildProfile.enterpriseProvisioning;
+        if (maybeEnterpriseProvisioning) {
+            switch (maybeEnterpriseProvisioning) {
+                case 'universal':
+                    return generated_1.IosDistributionType.Enterprise;
+                case 'adhoc':
+                    return generated_1.IosDistributionType.AdHoc;
+                default:
+                    throw new Error(`Unsupported Enterprise Provisioning type: ${maybeEnterpriseProvisioning}`);
+            }
+        }
+        // only enterprise accounts support enterprise distributions
+        const isDefinitelyNotAnEnterpriseAccount = ctx.appStore.authCtx?.team.inHouse === false;
+        if (isDefinitelyNotAnEnterpriseAccount) {
+            return generated_1.IosDistributionType.AdHoc;
+        }
+        if (ctx.nonInteractive) {
+            throw new Error('Unable to determine type of internal distribution. Run this command in interactive mode.');
+        }
+        // ask the user as a last resort
+        const { iosDistributionTypeGraphql } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'iosDistributionTypeGraphql',
+            message: 'Which type of internal distribution would you like to configure?',
+            choices: [
+                {
+                    value: generated_1.IosDistributionType.AdHoc,
+                    title: 'Adhoc: distribution to a small number of test users',
+                },
+                {
+                    value: generated_1.IosDistributionType.Enterprise,
+                    title: 'Enterprise: distribution to members of your company. Restricted to Apple Enterprise Accounts.',
+                },
+            ],
+        });
+        return iosDistributionTypeGraphql;
+    }
+}
+exports.SelectIosDistributionTypeGraphqlFromBuildProfile = SelectIosDistributionTypeGraphqlFromBuildProfile;

package/build/credentials/manager/SelectPlatform.d.ts

@@ -0,0 +1,17 @@
+import { Analytics } from '../../analytics/AnalyticsManager';
+import { DynamicConfigContextFn } from '../../commandUtils/context/DynamicProjectConfigContextField';
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { Actor } from '../../user/User';
+import { Client } from '../../vcs/vcs';
+import { CredentialsContextProjectInfo } from '../context';
+export declare class SelectPlatform {
+    readonly actor: Actor;
+    readonly graphqlClient: ExpoGraphqlClient;
+    readonly vcsClient: Client;
+    readonly analytics: Analytics;
+    readonly projectInfo: CredentialsContextProjectInfo | null;
+    readonly getDynamicPrivateProjectConfigAsync: DynamicConfigContextFn;
+    private readonly flagPlatform?;
+    constructor(actor: Actor, graphqlClient: ExpoGraphqlClient, vcsClient: Client, analytics: Analytics, projectInfo: CredentialsContextProjectInfo | null, getDynamicPrivateProjectConfigAsync: DynamicConfigContextFn, flagPlatform?: string | undefined);
+    runAsync(): Promise<void>;
+}

package/build/credentials/manager/SelectPlatform.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectPlatform = void 0;
+const ManageAndroid_1 = require("./ManageAndroid");
+const ManageIos_1 = require("./ManageIos");
+const platform_1 = require("../../platform");
+class SelectPlatform {
+    actor;
+    graphqlClient;
+    vcsClient;
+    analytics;
+    projectInfo;
+    getDynamicPrivateProjectConfigAsync;
+    flagPlatform;
+    constructor(actor, graphqlClient, vcsClient, analytics, projectInfo, getDynamicPrivateProjectConfigAsync, flagPlatform) {
+        this.actor = actor;
+        this.graphqlClient = graphqlClient;
+        this.vcsClient = vcsClient;
+        this.analytics = analytics;
+        this.projectInfo = projectInfo;
+        this.getDynamicPrivateProjectConfigAsync = getDynamicPrivateProjectConfigAsync;
+        this.flagPlatform = flagPlatform;
+    }
+    async runAsync() {
+        const platform = await (0, platform_1.selectPlatformWithExitOptionAsync)(this.flagPlatform);
+        if (platform === 'ios') {
+            await new ManageIos_1.ManageIos(this, process.cwd()).runAsync();
+            return;
+        }
+        await new ManageAndroid_1.ManageAndroid(this, process.cwd()).runAsync();
+    }
+}
+exports.SelectPlatform = SelectPlatform;

package/build/credentials/manager/SetDefaultAndroidKeystore.d.ts

@@ -0,0 +1,8 @@
+import { AndroidAppBuildCredentialsFragment } from '../../graphql/generated';
+import { AppLookupParams } from '../android/api/GraphqlClient';
+import { CredentialsContext } from '../context';
+export declare class SetDefaultAndroidKeystore {
+    private readonly app;
+    constructor(app: AppLookupParams);
+    runAsync(ctx: CredentialsContext): Promise<AndroidAppBuildCredentialsFragment | undefined>;
+}

package/build/credentials/manager/SetDefaultAndroidKeystore.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetDefaultAndroidKeystore = void 0;
+const tslib_1 = require("tslib");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+const BuildCredentialsUtils_1 = require("../android/actions/BuildCredentialsUtils");
+class SetDefaultAndroidKeystore {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async runAsync(ctx) {
+        const buildCredentialsList = await ctx.android.getAndroidAppBuildCredentialsListAsync(ctx.graphqlClient, this.app);
+        if (buildCredentialsList.length === 0) {
+            log_1.default.log(`You don't have any Android build credentials`);
+            return;
+        }
+        const sortedBuildCredentialsList = (0, BuildCredentialsUtils_1.sortBuildCredentials)(buildCredentialsList);
+        const sortedBuildCredentialsChoices = sortedBuildCredentialsList.map(buildCredentials => ({
+            title: buildCredentials.isDefault
+                ? `${buildCredentials.name} (Default)`
+                : buildCredentials.name,
+            value: buildCredentials,
+        }));
+        const { buildCredentialsResult } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'buildCredentialsResult',
+            message: 'Select build credentials',
+            choices: [...sortedBuildCredentialsChoices, { title: 'Cancel', value: null }],
+        });
+        if (!buildCredentialsResult?.androidKeystore) {
+            return;
+        }
+        log_1.default.log('Updating the default build credentials for this project...');
+        return await ctx.android.setDefaultAndroidAppBuildCredentialsAsync(ctx.graphqlClient, {
+            ...buildCredentialsResult,
+            isDefault: true,
+        });
+    }
+}
+exports.SetDefaultAndroidKeystore = SetDefaultAndroidKeystore;

package/build/credentials/manager/SetUpAndroidBuildCredentials.d.ts

@@ -0,0 +1,7 @@
+import { Action } from './HelperActions';
+import { ManageAndroid } from './ManageAndroid';
+export declare class SetUpAndroidBuildCredentials extends ManageAndroid {
+    private readonly setUpBuildCredentialsWithProfileNameFromFlag;
+    constructor(callingAction: Action, projectDir: string, setUpBuildCredentialsWithProfileNameFromFlag: string);
+    runAsync(): Promise<void>;
+}

package/build/credentials/manager/SetUpAndroidBuildCredentials.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetUpAndroidBuildCredentials = void 0;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const Actions_1 = require("./Actions");
+const CheckBuildProfileFlagAgainstEasJson_1 = require("./CheckBuildProfileFlagAgainstEasJson");
+const ManageAndroid_1 = require("./ManageAndroid");
+const context_1 = require("../context");
+class SetUpAndroidBuildCredentials extends ManageAndroid_1.ManageAndroid {
+    setUpBuildCredentialsWithProfileNameFromFlag;
+    constructor(callingAction, projectDir, setUpBuildCredentialsWithProfileNameFromFlag) {
+        super(callingAction, projectDir);
+        this.setUpBuildCredentialsWithProfileNameFromFlag = setUpBuildCredentialsWithProfileNameFromFlag;
+    }
+    async runAsync() {
+        const hasProjectContext = !!this.callingAction.projectInfo;
+        const buildProfile = hasProjectContext
+            ? await new CheckBuildProfileFlagAgainstEasJson_1.CheckBuildProfileFlagAgainstEasJson(this.projectDir, eas_build_job_1.Platform.ANDROID, this.setUpBuildCredentialsWithProfileNameFromFlag).runAsync()
+            : null;
+        let projectInfo = null;
+        if (hasProjectContext) {
+            const { exp, projectId } = await this.callingAction.getDynamicPrivateProjectConfigAsync({
+                env: buildProfile?.env,
+            });
+            projectInfo = { exp, projectId };
+        }
+        const ctx = new context_1.CredentialsContext({
+            projectDir: process.cwd(),
+            projectInfo,
+            user: this.callingAction.actor,
+            graphqlClient: this.callingAction.graphqlClient,
+            analytics: this.callingAction.analytics,
+            env: buildProfile?.env,
+            nonInteractive: false,
+            vcsClient: this.callingAction.vcsClient,
+        });
+        let gradleContext;
+        if (ctx.hasProjectContext) {
+            (0, assert_1.default)(buildProfile, 'buildProfile must be defined in a project context');
+            gradleContext = await this.createProjectContextAsync(ctx, buildProfile);
+        }
+        if (this.setUpBuildCredentialsWithProfileNameFromFlag) {
+            await this.runProjectSpecificActionAsync(ctx, Actions_1.AndroidActionType.SetUpBuildCredentials, gradleContext);
+        }
+    }
+}
+exports.SetUpAndroidBuildCredentials = SetUpAndroidBuildCredentials;

package/build/credentials/manager/SetUpBuildCredentialsCommandAction.d.ts

@@ -0,0 +1,20 @@
+import { Platform } from '@expo/eas-build-job';
+import { Analytics } from '../../analytics/AnalyticsManager';
+import { DynamicConfigContextFn } from '../../commandUtils/context/DynamicProjectConfigContextField';
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { Actor } from '../../user/User';
+import { Client } from '../../vcs/vcs';
+import { CredentialsContextProjectInfo } from '../context';
+export declare class SetUpBuildCredentialsCommandAction {
+    readonly actor: Actor;
+    readonly graphqlClient: ExpoGraphqlClient;
+    readonly vcsClient: Client;
+    readonly analytics: Analytics;
+    readonly projectInfo: CredentialsContextProjectInfo | null;
+    readonly getDynamicPrivateProjectConfigAsync: DynamicConfigContextFn;
+    private readonly platform;
+    private readonly profileName;
+    private readonly projectDir;
+    constructor(actor: Actor, graphqlClient: ExpoGraphqlClient, vcsClient: Client, analytics: Analytics, projectInfo: CredentialsContextProjectInfo | null, getDynamicPrivateProjectConfigAsync: DynamicConfigContextFn, platform: Platform, profileName: string, projectDir: string);
+    runAsync(): Promise<void>;
+}

package/build/credentials/manager/SetUpBuildCredentialsCommandAction.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetUpBuildCredentialsCommandAction = void 0;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const SetUpAndroidBuildCredentials_1 = require("../manager/SetUpAndroidBuildCredentials");
+const SetUpIosBuildCredentials_1 = require("../manager/SetUpIosBuildCredentials");
+class SetUpBuildCredentialsCommandAction {
+    actor;
+    graphqlClient;
+    vcsClient;
+    analytics;
+    projectInfo;
+    getDynamicPrivateProjectConfigAsync;
+    platform;
+    profileName;
+    projectDir;
+    constructor(actor, graphqlClient, vcsClient, analytics, projectInfo, getDynamicPrivateProjectConfigAsync, platform, profileName, projectDir) {
+        this.actor = actor;
+        this.graphqlClient = graphqlClient;
+        this.vcsClient = vcsClient;
+        this.analytics = analytics;
+        this.projectInfo = projectInfo;
+        this.getDynamicPrivateProjectConfigAsync = getDynamicPrivateProjectConfigAsync;
+        this.platform = platform;
+        this.profileName = profileName;
+        this.projectDir = projectDir;
+    }
+    async runAsync() {
+        if (this.platform === eas_build_job_1.Platform.IOS) {
+            await new SetUpIosBuildCredentials_1.SetUpIosBuildCredentials(this, this.projectDir, this.profileName).runAsync();
+            return;
+        }
+        await new SetUpAndroidBuildCredentials_1.SetUpAndroidBuildCredentials(this, this.projectDir, this.profileName).runAsync();
+    }
+}
+exports.SetUpBuildCredentialsCommandAction = SetUpBuildCredentialsCommandAction;

package/build/credentials/manager/SetUpIosBuildCredentials.d.ts

@@ -0,0 +1,7 @@
+import { Action } from './HelperActions';
+import { ManageIos } from './ManageIos';
+export declare class SetUpIosBuildCredentials extends ManageIos {
+    private readonly setUpBuildCredentialsWithProfileNameFromFlag;
+    constructor(callingAction: Action, projectDir: string, setUpBuildCredentialsWithProfileNameFromFlag: string);
+    runAsync(): Promise<void>;
+}

package/build/credentials/manager/SetUpIosBuildCredentials.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetUpIosBuildCredentials = void 0;
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const Actions_1 = require("./Actions");
+const CheckBuildProfileFlagAgainstEasJson_1 = require("./CheckBuildProfileFlagAgainstEasJson");
+const ManageIos_1 = require("./ManageIos");
+const projectUtils_1 = require("../../project/projectUtils");
+const actions_1 = require("../../user/actions");
+const context_1 = require("../context");
+class SetUpIosBuildCredentials extends ManageIos_1.ManageIos {
+    setUpBuildCredentialsWithProfileNameFromFlag;
+    constructor(callingAction, projectDir, setUpBuildCredentialsWithProfileNameFromFlag) {
+        super(callingAction, projectDir);
+        this.setUpBuildCredentialsWithProfileNameFromFlag = setUpBuildCredentialsWithProfileNameFromFlag;
+    }
+    async runAsync() {
+        const buildProfile = this.callingAction.projectInfo
+            ? await new CheckBuildProfileFlagAgainstEasJson_1.CheckBuildProfileFlagAgainstEasJson(this.projectDir, eas_build_job_1.Platform.IOS, this.setUpBuildCredentialsWithProfileNameFromFlag).runAsync()
+            : null;
+        let projectInfo = null;
+        if (this.callingAction.projectInfo) {
+            const { exp, projectId } = await this.callingAction.getDynamicPrivateProjectConfigAsync({
+                env: buildProfile?.env,
+            });
+            projectInfo = { exp, projectId };
+        }
+        const ctx = new context_1.CredentialsContext({
+            projectDir: this.projectDir,
+            projectInfo,
+            user: this.callingAction.actor,
+            graphqlClient: this.callingAction.graphqlClient,
+            analytics: this.callingAction.analytics,
+            env: buildProfile?.env,
+            nonInteractive: false,
+            vcsClient: this.callingAction.vcsClient,
+        });
+        await ctx.bestEffortAppStoreAuthenticateAsync();
+        const getAccountForProjectAsync = async (projectId) => {
+            return await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(ctx.graphqlClient, projectId);
+        };
+        const account = ctx.hasProjectContext
+            ? await getAccountForProjectAsync(await ctx.getProjectIdAsync())
+            : (0, actions_1.ensureActorHasPrimaryAccount)(ctx.user);
+        let app = null;
+        let targets = null;
+        if (ctx.hasProjectContext) {
+            (0, assert_1.default)(buildProfile, 'buildProfile must be defined in project context');
+            const projectContext = await this.createProjectContextAsync(ctx, account, buildProfile);
+            app = projectContext.app;
+            targets = projectContext.targets;
+        }
+        await this.runProjectSpecificActionAsync(ctx, (0, nullthrows_1.default)(app, 'app must be defined in project context'), (0, nullthrows_1.default)(targets, 'targets must be defined in project context'), (0, nullthrows_1.default)(buildProfile, 'buildProfile must be defined in project context'), Actions_1.IosActionType.SetUpBuildCredentials);
+    }
+}
+exports.SetUpIosBuildCredentials = SetUpIosBuildCredentials;

package/build/credentials/utils/promptForCredentials.d.ts

@@ -0,0 +1,17 @@
+export type Question = {
+    field: string;
+    question: string;
+    type: 'file' | 'string' | 'password';
+    base64Encode?: boolean;
+};
+export type CredentialSchema<T> = {
+    name: string;
+    questions: Question[];
+    provideMethodQuestion?: {
+        question?: string;
+    };
+    transformResultAsync?: (answers: Partial<T>) => Promise<T>;
+};
+export declare function askForUserProvidedAsync<T>(schema: CredentialSchema<T>, initialValues?: Partial<T>): Promise<T | null>;
+export declare function getCredentialsFromUserAsync<T>(credentialsSchema: CredentialSchema<T>, initialValues?: Partial<T>): Promise<T>;
+export declare function shouldAutoGenerateCredentialsAsync<T>(schema: CredentialSchema<T>): Promise<boolean>;

package/build/credentials/utils/promptForCredentials.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askForUserProvidedAsync = askForUserProvidedAsync;
+exports.getCredentialsFromUserAsync = getCredentialsFromUserAsync;
+exports.shouldAutoGenerateCredentialsAsync = shouldAutoGenerateCredentialsAsync;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const untildify_1 = tslib_1.__importDefault(require("untildify"));
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+let expertPromptLogged = false;
+const EXPERT_PROMPT = () => {
+    if (expertPromptLogged) {
+        return;
+    }
+    log_1.default.warn(`
+In this mode, we won't be able to make sure that your credentials are valid.
+Double check that you're uploading valid files for your app otherwise you may encounter strange errors!
+When building for IOS make sure you've created your App ID on the Apple Developer Portal, that your App ID
+is in app.json as \`bundleIdentifier\`, and that the provisioning profile you
+upload matches that Team ID and App ID.
+`);
+    expertPromptLogged = true;
+};
+async function askForUserProvidedAsync(schema, initialValues = {}) {
+    if (await shouldAutoGenerateCredentialsAsync(schema)) {
+        return null;
+    }
+    EXPERT_PROMPT();
+    return await getCredentialsFromUserAsync(schema, initialValues);
+}
+async function getCredentialsFromUserAsync(credentialsSchema, initialValues = {}) {
+    const results = {};
+    for (const question of credentialsSchema.questions) {
+        results[question.field] = await askQuestionAndProcessAnswerAsync(question, initialValues?.[question.field]);
+    }
+    return credentialsSchema.transformResultAsync
+        ? await credentialsSchema.transformResultAsync(results)
+        : results;
+}
+async function shouldAutoGenerateCredentialsAsync(schema) {
+    const answer = await (0, prompts_1.confirmAsync)({
+        message: schema?.provideMethodQuestion?.question ?? `Generate a new ${schema.name}?`,
+        initial: true,
+    });
+    return answer;
+}
+async function askQuestionAndProcessAnswerAsync(definition, initialValue) {
+    const questionObject = buildQuestionObject(definition, initialValue);
+    const { input } = await (0, prompts_1.promptAsync)(questionObject);
+    return await processAnswerAsync(definition, input);
+}
+function buildQuestionObject({ type, question }, initialValue) {
+    switch (type) {
+        case 'string':
+            return {
+                type: 'text',
+                name: 'input',
+                initial: initialValue,
+                message: question,
+                validate: validateNonEmptyInput,
+            };
+        case 'file':
+            return {
+                type: 'text',
+                name: 'input',
+                message: question,
+                format: produceAbsolutePath,
+                validate: validateExistingFileAsync,
+            };
+        case 'password':
+            return {
+                type: 'password',
+                name: 'input',
+                message: question,
+                validate: validateNonEmptyInput,
+            };
+    }
+}
+async function processAnswerAsync({ type, base64Encode }, input) {
+    if (type === 'file') {
+        return await fs_extra_1.default.readFile(input, base64Encode ? 'base64' : 'utf8');
+    }
+    else {
+        return input;
+    }
+}
+function produceAbsolutePath(filePath) {
+    const untildified = (0, untildify_1.default)(filePath.trim());
+    return !path_1.default.isAbsolute(untildified) ? path_1.default.resolve(untildified) : untildified;
+}
+function validateNonEmptyInput(val) {
+    return val !== '';
+}
+async function validateExistingFileAsync(filePath) {
+    try {
+        const stats = await fs_extra_1.default.stat(filePath);
+        if (stats.isFile()) {
+            return true;
+        }
+        return 'Input is not a file.';
+    }
+    catch {
+        return 'File does not exist.';
+    }
+}

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

@@ -0,0 +1,19 @@
+import { ExpoGraphqlClient } from '../../../commandUtils/context/contextUtils/createGraphqlClient';
+import AppStoreApi from '../../../credentials/ios/appstore/AppStoreApi';
+import { AccountFragment, AppleTeam } from '../../../graphql/generated';
+export declare enum RegistrationMethod {
+    WEBSITE = 0,
+    INPUT = 1,
+    DEVELOPER_PORTAL = 2,
+    CURRENT_MACHINE = 3,
+    EXIT = 4
+}
+export default class DeviceCreateAction {
+    private readonly graphqlClient;
+    private readonly appStoreApi;
+    private readonly account;
+    private readonly appleTeam;
+    constructor(graphqlClient: ExpoGraphqlClient, appStoreApi: AppStoreApi, account: AccountFragment, appleTeam: Pick<AppleTeam, 'appleTeamIdentifier' | 'appleTeamName' | 'id'>);
+    runAsync(): Promise<RegistrationMethod>;
+    private askForRegistrationMethodAsync;
+}