@donotuse/eas-cli 18.5.0-rc.1

package/build/credentials/ios/actions/AscApiKeyUtils.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppStoreApiKeyPurpose = void 0;
+exports.promptForAscApiKeyPathAsync = promptForAscApiKeyPathAsync;
+exports.promptForIssuerIdAsync = promptForIssuerIdAsync;
+exports.getMinimalAscApiKeyAsync = getMinimalAscApiKeyAsync;
+exports.provideOrGenerateAscApiKeyAsync = provideOrGenerateAscApiKeyAsync;
+exports.getAscApiKeyName = getAscApiKeyName;
+exports.getAscApiKeysFromAccountAsync = getAscApiKeysFromAccountAsync;
+exports.selectAscApiKeysFromAccountAsync = selectAscApiKeysFromAccountAsync;
+exports.sortAscApiKeysByUpdatedAtDesc = sortAscApiKeysByUpdatedAtDesc;
+exports.formatAscApiKey = formatAscApiKey;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const nanoid_1 = require("nanoid");
+const path_1 = tslib_1.__importDefault(require("path"));
+const AppleTeamFormatting_1 = require("./AppleTeamFormatting");
+const log_1 = tslib_1.__importStar(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+const date_1 = require("../../../utils/date");
+const promptForCredentials_1 = require("../../utils/promptForCredentials");
+const credentials_1 = require("../credentials");
+const validateAscApiKey_1 = require("../validators/validateAscApiKey");
+var AppStoreApiKeyPurpose;
+(function (AppStoreApiKeyPurpose) {
+    AppStoreApiKeyPurpose["SUBMISSION_SERVICE"] = "EAS Submit";
+})(AppStoreApiKeyPurpose || (exports.AppStoreApiKeyPurpose = AppStoreApiKeyPurpose = {}));
+async function promptForAscApiKeyPathAsync(ctx) {
+    const { keyId, keyP8Path } = await promptForKeyP8AndIdAsync();
+    const bestEffortIssuerId = await getBestEffortIssuerIdAsync(ctx, keyId);
+    if (bestEffortIssuerId) {
+        log_1.default.log(`Detected Issuer ID: ${bestEffortIssuerId}`);
+        return { keyId, issuerId: bestEffortIssuerId, keyP8Path };
+    }
+    const issuerId = await promptForIssuerIdAsync();
+    return { keyId, issuerId, keyP8Path };
+}
+async function promptForIssuerIdAsync() {
+    log_1.default.log(chalk_1.default.bold('An App Store Connect Issuer ID is required'));
+    log_1.default.log(`If you're not sure what this is or how to find yours, ${(0, log_1.learnMore)('https://expo.fyi/asc-issuer-id')}`);
+    // Do not perform uuid validation - Apple's issuerIds are not RFC4122 compliant
+    const { issuerId } = await (0, promptForCredentials_1.getCredentialsFromUserAsync)(credentials_1.ascApiKeyIssuerIdSchema);
+    return issuerId;
+}
+async function getMinimalAscApiKeyAsync(ascApiKey) {
+    return {
+        ...ascApiKey,
+        issuerId: ascApiKey.issuerId ?? (await promptForIssuerIdAsync()),
+    };
+}
+async function provideOrGenerateAscApiKeyAsync(ctx, purpose) {
+    if (ctx.nonInteractive) {
+        throw new Error(`A new App Store Connect API Key cannot be created in non-interactive mode.`);
+    }
+    // When auto-accepting credentials, always auto-generate without asking for user input
+    if (ctx.autoAcceptCredentialReuse) {
+        return await generateAscApiKeyAsync(ctx, purpose);
+    }
+    const userProvided = await promptForAscApiKeyAsync(ctx);
+    if (!userProvided) {
+        return await generateAscApiKeyAsync(ctx, purpose);
+    }
+    if (!ctx.appStore.authCtx) {
+        log_1.default.warn('Unable to validate App Store Connect API Key, you are not authenticated with Apple.');
+        return userProvided;
+    }
+    const isValidAndTracked = await (0, validateAscApiKey_1.isAscApiKeyValidAndTrackedAsync)(ctx, userProvided);
+    if (isValidAndTracked) {
+        return userProvided;
+    }
+    const useUserProvided = await (0, prompts_1.confirmAsync)({
+        message: `App Store Connect API Key with ID ${userProvided.keyId} is not valid on Apple's servers. Proceed anyway?`,
+    });
+    if (useUserProvided) {
+        return userProvided;
+    }
+    return await provideOrGenerateAscApiKeyAsync(ctx, purpose);
+}
+async function generateAscApiKeyAsync(ctx, purpose) {
+    await ctx.appStore.ensureAuthenticatedAsync();
+    const ascApiKey = await ctx.appStore.createAscApiKeyAsync(ctx.analytics, {
+        nickname: getAscApiKeyName(purpose),
+    });
+    return await getMinimalAscApiKeyAsync(ascApiKey);
+}
+function getAscApiKeyName(purpose) {
+    const nameParts = ['[Expo]', purpose, (0, nanoid_1.nanoid)(10)];
+    return nameParts.join(' ');
+}
+async function promptForAscApiKeyAsync(ctx) {
+    const shouldAutoGenerateCredentials = await (0, promptForCredentials_1.shouldAutoGenerateCredentialsAsync)(credentials_1.ascApiKeyIdSchema);
+    if (shouldAutoGenerateCredentials) {
+        return null;
+    }
+    const ascApiKeyPath = await promptForAscApiKeyPathAsync(ctx);
+    const { keyP8Path, keyId, issuerId } = ascApiKeyPath;
+    return { keyP8: await fs_extra_1.default.readFile(keyP8Path, 'utf-8'), keyId, issuerId };
+}
+async function promptForKeyP8AndIdAsync() {
+    log_1.default.log(chalk_1.default.bold('An App Store Connect Api key is required to upload your app to the Apple App Store Connect'));
+    log_1.default.log(`If you're not sure what this is or how to create one, ${(0, log_1.learnMore)('https://expo.fyi/creating-asc-api-key')}`);
+    const { keyP8Path } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'keyP8Path',
+        message: 'Path to App Store Connect API Key:',
+        initial: 'AuthKey_ABCD.p8',
+        // eslint-disable-next-line async-protect/async-suffix
+        validate: async (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.';
+            }
+        },
+    });
+    const regex = /^AuthKey_(?<keyId>\w+)\.p8$/; // Common ASC Api file name downloaded from Apple
+    const bestEffortKeyId = path_1.default.basename(keyP8Path).match(regex)?.groups?.keyId;
+    const { keyId } = await (0, promptForCredentials_1.getCredentialsFromUserAsync)(credentials_1.ascApiKeyIdSchema, {
+        keyId: bestEffortKeyId,
+    });
+    return { keyId, keyP8Path };
+}
+async function getBestEffortIssuerIdAsync(ctx, ascApiKeyId) {
+    if (!ctx.appStore.authCtx) {
+        return null;
+    }
+    const ascApiKeyInfo = await ctx.appStore.getAscApiKeyAsync(ascApiKeyId);
+    return ascApiKeyInfo?.issuerId ?? null;
+}
+async function getAscApiKeysFromAccountAsync(ctx, account, { filterDifferentAppleTeam } = {}) {
+    const ascApiKeysForAccount = await ctx.ios.getAscApiKeysForAccountAsync(ctx.graphqlClient, account);
+    if (!filterDifferentAppleTeam) {
+        return ascApiKeysForAccount;
+    }
+    else {
+        return filterKeysFromDifferentAppleTeam(ctx, ascApiKeysForAccount);
+    }
+}
+async function selectAscApiKeysFromAccountAsync(ctx, account, { filterDifferentAppleTeam } = {}) {
+    const ascApiKeysForAccount = await getAscApiKeysFromAccountAsync(ctx, account, {
+        filterDifferentAppleTeam,
+    });
+    if (ascApiKeysForAccount.length === 0) {
+        if (filterDifferentAppleTeam) {
+            const maybeAppleTeamId = ctx.appStore.authCtx?.team.id;
+            log_1.default.warn(`There are no App Store Connect API Keys in your EAS account${maybeAppleTeamId ? ` matching Apple Team ID: ${maybeAppleTeamId}.` : '.'}`);
+        }
+        else {
+            log_1.default.warn(`There are no App Store Connect API Keys available in your EAS account.`);
+        }
+        return null;
+    }
+    return await selectAscApiKeysAsync(ascApiKeysForAccount);
+}
+async function selectAscApiKeysAsync(ascApiKeys) {
+    const sortedAscApiKeys = sortAscApiKeysByUpdatedAtDesc(ascApiKeys);
+    const { chosenAscApiKey } = await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'chosenAscApiKey',
+        message: 'Select an API Key from the list:',
+        choices: sortedAscApiKeys.map(ascApiKey => ({
+            title: formatAscApiKey(ascApiKey),
+            value: ascApiKey,
+        })),
+    });
+    return chosenAscApiKey;
+}
+function filterKeysFromDifferentAppleTeam(ctx, keys) {
+    if (!ctx.appStore.authCtx) {
+        return keys;
+    }
+    const teamId = ctx.appStore.authCtx.team.id;
+    return keys.filter(key => !key.appleTeam || key.appleTeam?.appleTeamIdentifier === teamId);
+}
+function sortAscApiKeysByUpdatedAtDesc(keys) {
+    return keys.sort((keyA, keyB) => new Date(keyB.updatedAt).getTime() - new Date(keyA.updatedAt).getTime());
+}
+function formatAscApiKey(ascApiKey) {
+    const { keyIdentifier, appleTeam, name, updatedAt } = ascApiKey;
+    let line = '';
+    line += `Key ID: ${keyIdentifier}`;
+    if (name) {
+        line += chalk_1.default.gray(`\n    Name: ${name}`);
+    }
+    if (appleTeam) {
+        line += chalk_1.default.gray(`\n    ${(0, AppleTeamFormatting_1.formatAppleTeam)(appleTeam)}`);
+    }
+    line += chalk_1.default.gray(`\n    Updated: ${(0, date_1.fromNow)(new Date(updatedAt))} ago`);
+    return line;
+}

package/build/credentials/ios/actions/AssignAscApiKey.d.ts

@@ -0,0 +1,9 @@
+import { AppStoreApiKeyPurpose } from './AscApiKeyUtils';
+import { AppStoreConnectApiKeyFragment, CommonIosAppCredentialsFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/graphql/types/AppLookupParams';
+export declare class AssignAscApiKey {
+    private readonly app;
+    constructor(app: AppLookupParams);
+    runAsync(ctx: CredentialsContext, ascApiKey: AppStoreConnectApiKeyFragment, purpose: AppStoreApiKeyPurpose): Promise<CommonIosAppCredentialsFragment>;
+}

package/build/credentials/ios/actions/AssignAscApiKey.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssignAscApiKey = void 0;
+const tslib_1 = require("tslib");
+const AppleTeamUtils_1 = require("./AppleTeamUtils");
+const AscApiKeyUtils_1 = require("./AscApiKeyUtils");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+class AssignAscApiKey {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async runAsync(ctx, ascApiKey, purpose) {
+        const appleTeam = (await (0, AppleTeamUtils_1.resolveAppleTeamIfAuthenticatedAsync)(ctx, this.app)) ?? ascApiKey.appleTeam ?? null;
+        const appCredentials = await ctx.ios.createOrGetIosAppCredentialsWithCommonFieldsAsync(ctx.graphqlClient, this.app, { appleTeam: appleTeam ?? undefined });
+        let updatedAppCredentials;
+        if (purpose === AscApiKeyUtils_1.AppStoreApiKeyPurpose.SUBMISSION_SERVICE) {
+            updatedAppCredentials = await ctx.ios.updateIosAppCredentialsAsync(ctx.graphqlClient, appCredentials, {
+                ascApiKeyIdForSubmissions: ascApiKey.id,
+            });
+        }
+        else {
+            throw new Error(`${purpose} is not yet supported.`);
+        }
+        log_1.default.succeed(`App Store Connect API Key assigned to ${this.app.projectName}: ${this.app.bundleIdentifier} for ${purpose}.`);
+        return updatedAppCredentials;
+    }
+}
+exports.AssignAscApiKey = AssignAscApiKey;

package/build/credentials/ios/actions/AssignPushKey.d.ts

@@ -0,0 +1,8 @@
+import { ApplePushKeyFragment, CommonIosAppCredentialsFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/graphql/types/AppLookupParams';
+export declare class AssignPushKey {
+    private readonly app;
+    constructor(app: AppLookupParams);
+    runAsync(ctx: CredentialsContext, pushKey: ApplePushKeyFragment): Promise<CommonIosAppCredentialsFragment>;
+}

package/build/credentials/ios/actions/AssignPushKey.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssignPushKey = void 0;
+const tslib_1 = require("tslib");
+const AppleTeamUtils_1 = require("./AppleTeamUtils");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+class AssignPushKey {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async runAsync(ctx, pushKey) {
+        const appleTeam = (await (0, AppleTeamUtils_1.resolveAppleTeamIfAuthenticatedAsync)(ctx, this.app)) ?? pushKey.appleTeam ?? null;
+        const appCredentials = await ctx.ios.createOrGetIosAppCredentialsWithCommonFieldsAsync(ctx.graphqlClient, this.app, { appleTeam: appleTeam ?? undefined });
+        const updatedAppCredentials = await ctx.ios.updateIosAppCredentialsAsync(ctx.graphqlClient, appCredentials, {
+            applePushKeyId: pushKey.id,
+        });
+        log_1.default.succeed(`Push Key assigned to ${this.app.projectName}: ${this.app.bundleIdentifier}`);
+        return updatedAppCredentials;
+    }
+}
+exports.AssignPushKey = AssignPushKey;

package/build/credentials/ios/actions/BuildCredentialsUtils.d.ts

@@ -0,0 +1,11 @@
+import { AppleDistributionCertificateFragment, AppleProvisioningProfileFragment, AppleTeamFragment, IosDistributionType as GraphQLIosDistributionType, IosAppBuildCredentialsFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/graphql/types/AppLookupParams';
+import { App, Target } from '../types';
+export declare function getAllBuildCredentialsAsync(ctx: CredentialsContext, app: AppLookupParams): Promise<IosAppBuildCredentialsFragment[]>;
+export declare function getBuildCredentialsAsync(ctx: CredentialsContext, app: AppLookupParams, iosDistributionType: GraphQLIosDistributionType): Promise<IosAppBuildCredentialsFragment | null>;
+export declare function getProvisioningProfileAsync(ctx: CredentialsContext, app: AppLookupParams, iosDistributionType: GraphQLIosDistributionType): Promise<AppleProvisioningProfileFragment | null>;
+export declare function getDistributionCertificateAsync(ctx: CredentialsContext, app: AppLookupParams, iosDistributionType: GraphQLIosDistributionType): Promise<AppleDistributionCertificateFragment | null>;
+export declare function assignBuildCredentialsAsync(ctx: CredentialsContext, app: AppLookupParams, iosDistributionType: GraphQLIosDistributionType, distCert: AppleDistributionCertificateFragment, provisioningProfile: AppleProvisioningProfileFragment, appleTeam?: AppleTeamFragment): Promise<IosAppBuildCredentialsFragment>;
+export declare function getAppFromContextAsync(ctx: CredentialsContext): Promise<App>;
+export declare function getAppLookupParamsFromContextAsync(ctx: CredentialsContext, target: Target): Promise<AppLookupParams>;

package/build/credentials/ios/actions/BuildCredentialsUtils.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllBuildCredentialsAsync = getAllBuildCredentialsAsync;
+exports.getBuildCredentialsAsync = getBuildCredentialsAsync;
+exports.getProvisioningProfileAsync = getProvisioningProfileAsync;
+exports.getDistributionCertificateAsync = getDistributionCertificateAsync;
+exports.assignBuildCredentialsAsync = assignBuildCredentialsAsync;
+exports.getAppFromContextAsync = getAppFromContextAsync;
+exports.getAppLookupParamsFromContextAsync = getAppLookupParamsFromContextAsync;
+const tslib_1 = require("tslib");
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const AppleTeamUtils_1 = require("./AppleTeamUtils");
+const projectUtils_1 = require("../../../project/projectUtils");
+async function getAllBuildCredentialsAsync(ctx, app) {
+    const appCredentials = await ctx.ios.getIosAppCredentialsWithBuildCredentialsAsync(ctx.graphqlClient, app, {});
+    if (!appCredentials) {
+        return [];
+    }
+    return appCredentials.iosAppBuildCredentialsList;
+}
+async function getBuildCredentialsAsync(ctx, app, iosDistributionType) {
+    const appCredentials = await ctx.ios.getIosAppCredentialsWithBuildCredentialsAsync(ctx.graphqlClient, app, {
+        iosDistributionType,
+    });
+    if (!appCredentials || appCredentials.iosAppBuildCredentialsList.length === 0) {
+        return null;
+    }
+    const [buildCredentials] = appCredentials.iosAppBuildCredentialsList;
+    return buildCredentials;
+}
+async function getProvisioningProfileAsync(ctx, app, iosDistributionType) {
+    const buildCredentials = await getBuildCredentialsAsync(ctx, app, iosDistributionType);
+    return buildCredentials?.provisioningProfile ?? null;
+}
+async function getDistributionCertificateAsync(ctx, app, iosDistributionType) {
+    const buildCredentials = await getBuildCredentialsAsync(ctx, app, iosDistributionType);
+    return buildCredentials?.distributionCertificate ?? null;
+}
+async function assignBuildCredentialsAsync(ctx, app, iosDistributionType, distCert, provisioningProfile, appleTeam) {
+    const resolvedAppleTeam = (0, nullthrows_1.default)(appleTeam ?? (await (0, AppleTeamUtils_1.resolveAppleTeamIfAuthenticatedAsync)(ctx, app)));
+    const appleAppIdentifier = await ctx.ios.createOrGetExistingAppleAppIdentifierAsync(ctx.graphqlClient, app, resolvedAppleTeam);
+    return await ctx.ios.createOrUpdateIosAppBuildCredentialsAsync(ctx.graphqlClient, app, {
+        appleTeam: resolvedAppleTeam,
+        appleAppIdentifierId: appleAppIdentifier.id,
+        appleDistributionCertificateId: distCert.id,
+        appleProvisioningProfileId: provisioningProfile.id,
+        iosDistributionType,
+    });
+}
+async function getAppFromContextAsync(ctx) {
+    const exp = await ctx.getExpoConfigAsync();
+    const projectName = exp.slug;
+    const projectId = await ctx.getProjectIdAsync();
+    const account = await (0, projectUtils_1.getOwnerAccountForProjectIdAsync)(ctx.graphqlClient, projectId);
+    return {
+        account,
+        projectName,
+    };
+}
+async function getAppLookupParamsFromContextAsync(ctx, target) {
+    const app = await getAppFromContextAsync(ctx);
+    return { ...app, bundleIdentifier: target.bundleIdentifier };
+}

package/build/credentials/ios/actions/ConfigureProvisioningProfile.d.ts

@@ -0,0 +1,14 @@
+import { AppleDistributionCertificateFragment, AppleProvisioningProfileFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppleProvisioningProfileMutationResult } from '../api/graphql/mutations/AppleProvisioningProfileMutation';
+import { AppLookupParams } from '../api/graphql/types/AppLookupParams';
+import { Target } from '../types';
+export declare class ConfigureProvisioningProfile {
+    private readonly app;
+    private readonly target;
+    private readonly distributionCertificate;
+    private readonly originalProvisioningProfile;
+    constructor(app: AppLookupParams, target: Target, distributionCertificate: AppleDistributionCertificateFragment, originalProvisioningProfile: AppleProvisioningProfileFragment);
+    runAsync(ctx: CredentialsContext): Promise<AppleProvisioningProfileMutationResult | null>;
+    private configureAndUpdateAsync;
+}

package/build/credentials/ios/actions/ConfigureProvisioningProfile.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigureProvisioningProfile = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_1 = tslib_1.__importStar(require("../../../log"));
+const ora_1 = require("../../../ora");
+const target_1 = require("../../../project/ios/target");
+const errors_1 = require("../../errors");
+const authenticateTypes_1 = require("../appstore/authenticateTypes");
+class ConfigureProvisioningProfile {
+    app;
+    target;
+    distributionCertificate;
+    originalProvisioningProfile;
+    constructor(app, target, distributionCertificate, originalProvisioningProfile) {
+        this.app = app;
+        this.target = target;
+        this.distributionCertificate = distributionCertificate;
+        this.originalProvisioningProfile = originalProvisioningProfile;
+    }
+    async runAsync(ctx) {
+        if (ctx.freezeCredentials) {
+            throw new errors_1.ForbidCredentialModificationError('Remove the --freeze-credentials flag to configure a Provisioning Profile.');
+        }
+        else if (ctx.nonInteractive &&
+            ctx.appStore.defaultAuthenticationMode !== authenticateTypes_1.AuthenticationMode.API_KEY) {
+            throw new errors_1.InsufficientAuthenticationNonInteractiveError(`In order to configure your Provisioning Profile, authentication with an ASC API key is required in non-interactive mode. ${(0, log_1.learnMore)('https://docs.expo.dev/build/building-on-ci/#optional-provide-an-asc-api-token-for-your-apple-team')}`);
+        }
+        const { developerPortalIdentifier, provisioningProfile } = this.originalProvisioningProfile;
+        if (!developerPortalIdentifier && !provisioningProfile) {
+            log_1.default.warn("The provisioning profile we have on file cannot be configured on Apple's servers.");
+            return null;
+        }
+        if (!ctx.appStore.authCtx) {
+            log_1.default.warn("Without access to your Apple account we can't configure provisioning profiles for you.");
+            log_1.default.warn('Make sure to recreate the profile if you selected a new distribution certificate.');
+            return null;
+        }
+        const applePlatform = (0, target_1.getApplePlatformFromTarget)(this.target);
+        const profilesFromApple = await ctx.appStore.listProvisioningProfilesAsync(this.app.bundleIdentifier, applePlatform);
+        const [matchingProfile] = profilesFromApple.filter(appleInfo => developerPortalIdentifier
+            ? appleInfo.provisioningProfileId === developerPortalIdentifier
+            : appleInfo.provisioningProfile === provisioningProfile);
+        if (!matchingProfile) {
+            log_1.default.warn(`Profile ${developerPortalIdentifier ? `${developerPortalIdentifier} ` : ''}not found on Apple Developer Portal.`);
+            return null;
+        }
+        return await this.configureAndUpdateAsync(ctx, ctx.appStore.authCtx, this.app, matchingProfile);
+    }
+    async configureAndUpdateAsync(ctx, authCtx, app, profileFromApple) {
+        const { developerPortalIdentifier, certificateP12, certificatePassword, serialNumber } = this.distributionCertificate;
+        (0, assert_1.default)(certificateP12 && certificatePassword, 'Distribution Certificate P12 and Password is required');
+        // configure profile on Apple's Server to use our distCert
+        const updatedProfile = await ctx.appStore.useExistingProvisioningProfileAsync(app.bundleIdentifier, profileFromApple, {
+            certId: developerPortalIdentifier ?? undefined,
+            certP12: certificateP12,
+            certPassword: certificatePassword,
+            distCertSerialNumber: serialNumber,
+            teamId: authCtx.team.id,
+        });
+        const bundleIdTag = `(${app.bundleIdentifier})`;
+        const slugTag = `@${app.account.name}/${app.projectName}`;
+        const projectTag = `${chalk_1.default.bold(slugTag)} ${chalk_1.default.dim(bundleIdTag)}`;
+        const spinner = (0, ora_1.ora)(`Updating Expo profile for ${projectTag}`).start();
+        try {
+            const configuredProvisioningProfile = await ctx.ios.updateProvisioningProfileAsync(ctx.graphqlClient, this.originalProvisioningProfile.id, {
+                appleProvisioningProfile: updatedProfile.provisioningProfile,
+                developerPortalIdentifier: updatedProfile.provisioningProfileId,
+            });
+            spinner.succeed(`Updated Expo profile for ${projectTag}`);
+            return configuredProvisioningProfile;
+        }
+        catch (error) {
+            spinner.fail();
+            throw error;
+        }
+    }
+}
+exports.ConfigureProvisioningProfile = ConfigureProvisioningProfile;

package/build/credentials/ios/actions/CreateAscApiKey.d.ts

@@ -0,0 +1,8 @@
+import { AppStoreApiKeyPurpose } from './AscApiKeyUtils';
+import { AccountFragment, AppStoreConnectApiKeyFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+export declare class CreateAscApiKey {
+    private readonly account;
+    constructor(account: AccountFragment);
+    runAsync(ctx: CredentialsContext, purpose: AppStoreApiKeyPurpose): Promise<AppStoreConnectApiKeyFragment>;
+}

package/build/credentials/ios/actions/CreateAscApiKey.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateAscApiKey = void 0;
+const AscApiKeyUtils_1 = require("./AscApiKeyUtils");
+class CreateAscApiKey {
+    account;
+    constructor(account) {
+        this.account = account;
+    }
+    async runAsync(ctx, purpose) {
+        if (ctx.nonInteractive) {
+            throw new Error(`A new App Store Connect API Key cannot be created in non-interactive mode.`);
+        }
+        const ascApiKey = await (0, AscApiKeyUtils_1.provideOrGenerateAscApiKeyAsync)(ctx, purpose);
+        return await ctx.ios.createAscApiKeyAsync(ctx.graphqlClient, this.account, ascApiKey);
+    }
+}
+exports.CreateAscApiKey = CreateAscApiKey;

package/build/credentials/ios/actions/CreateDistributionCertificate.d.ts

@@ -0,0 +1,8 @@
+import { AccountFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppleDistributionCertificateMutationResult } from '../api/graphql/mutations/AppleDistributionCertificateMutation';
+export declare class CreateDistributionCertificate {
+    private readonly account;
+    constructor(account: AccountFragment);
+    runAsync(ctx: CredentialsContext): Promise<AppleDistributionCertificateMutationResult>;
+}

package/build/credentials/ios/actions/CreateDistributionCertificate.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDistributionCertificate = void 0;
+const tslib_1 = require("tslib");
+const DistributionCertificateUtils_1 = require("./DistributionCertificateUtils");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+class CreateDistributionCertificate {
+    account;
+    constructor(account) {
+        this.account = account;
+    }
+    async runAsync(ctx) {
+        const distCert = await (0, DistributionCertificateUtils_1.provideOrGenerateDistributionCertificateAsync)(ctx);
+        const result = await ctx.ios.createDistributionCertificateAsync(ctx.graphqlClient, this.account, distCert);
+        log_1.default.succeed('Created distribution certificate');
+        return result;
+    }
+}
+exports.CreateDistributionCertificate = CreateDistributionCertificate;

package/build/credentials/ios/actions/CreateProvisioningProfile.d.ts

@@ -0,0 +1,14 @@
+import { AppleDistributionCertificateFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppleProvisioningProfileMutationResult } from '../api/graphql/mutations/AppleProvisioningProfileMutation';
+import { AppLookupParams } from '../api/graphql/types/AppLookupParams';
+import { Target } from '../types';
+export declare class CreateProvisioningProfile {
+    private readonly app;
+    private readonly target;
+    private readonly distributionCertificate;
+    constructor(app: AppLookupParams, target: Target, distributionCertificate: AppleDistributionCertificateFragment);
+    runAsync(ctx: CredentialsContext): Promise<AppleProvisioningProfileMutationResult>;
+    private maybeGetUserProvidedAsync;
+    private provideOrGenerateAsync;
+}

package/build/credentials/ios/actions/CreateProvisioningProfile.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateProvisioningProfile = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const AppleTeamUtils_1 = require("./AppleTeamUtils");
+const ProvisioningProfileUtils_1 = require("./ProvisioningProfileUtils");
+const log_1 = tslib_1.__importStar(require("../../../log"));
+const errors_1 = require("../../errors");
+const promptForCredentials_1 = require("../../utils/promptForCredentials");
+const authenticateTypes_1 = require("../appstore/authenticateTypes");
+const credentials_1 = require("../credentials");
+class CreateProvisioningProfile {
+    app;
+    target;
+    distributionCertificate;
+    constructor(app, target, distributionCertificate) {
+        this.app = app;
+        this.target = target;
+        this.distributionCertificate = distributionCertificate;
+    }
+    async runAsync(ctx) {
+        if (ctx.freezeCredentials) {
+            throw new errors_1.ForbidCredentialModificationError('Run this command again without the --freeze-credentials flag in order to generate a new Provisioning Profile.');
+        }
+        else if (ctx.nonInteractive &&
+            ctx.appStore.defaultAuthenticationMode !== authenticateTypes_1.AuthenticationMode.API_KEY) {
+            throw new errors_1.InsufficientAuthenticationNonInteractiveError(`In order to generate a new Provisioning Profile, authentication with an ASC API key is required in non-interactive mode. ${(0, log_1.learnMore)('https://docs.expo.dev/build/building-on-ci/#optional-provide-an-asc-api-token-for-your-apple-team')}`);
+        }
+        const appleAuthCtx = await ctx.appStore.ensureAuthenticatedAsync();
+        const provisioningProfile = await this.provideOrGenerateAsync(ctx, appleAuthCtx);
+        const appleTeam = (0, nullthrows_1.default)(await (0, AppleTeamUtils_1.resolveAppleTeamIfAuthenticatedAsync)(ctx, this.app));
+        const appleAppIdentifier = await ctx.ios.createOrGetExistingAppleAppIdentifierAsync(ctx.graphqlClient, this.app, appleTeam);
+        const provisioningProfileMutationResult = await ctx.ios.createProvisioningProfileAsync(ctx.graphqlClient, this.app, appleAppIdentifier, {
+            appleProvisioningProfile: provisioningProfile.provisioningProfile,
+            developerPortalIdentifier: provisioningProfile.provisioningProfileId,
+        });
+        log_1.default.succeed('Created provisioning profile');
+        return provisioningProfileMutationResult;
+    }
+    async maybeGetUserProvidedAsync(ctx) {
+        if (ctx.nonInteractive || ctx.autoAcceptCredentialReuse) {
+            return null;
+        }
+        const userProvided = await (0, promptForCredentials_1.askForUserProvidedAsync)(credentials_1.provisioningProfileSchema);
+        if (userProvided) {
+            // userProvided profiles don't come with ProvisioningProfileId's (only accessible from Apple Portal API)
+            log_1.default.warn('Provisioning profile: Unable to validate specified profile.');
+            return userProvided;
+        }
+        return null;
+    }
+    async provideOrGenerateAsync(ctx, appleAuthCtx) {
+        const maybeUserProvided = await this.maybeGetUserProvidedAsync(ctx);
+        if (maybeUserProvided) {
+            // userProvided profiles don't come with ProvisioningProfileId's (only accessible from Apple Portal API)
+            log_1.default.warn('Provisioning profile: Unable to validate specified profile.');
+            return maybeUserProvided;
+        }
+        (0, assert_1.default)(this.distributionCertificate.certificateP12, 'Distribution Certificate must have p12 certificate');
+        (0, assert_1.default)(this.distributionCertificate.certificatePassword, 'Distribution Certificate must have certificate password');
+        return await (0, ProvisioningProfileUtils_1.generateProvisioningProfileAsync)(ctx, this.target, this.app.bundleIdentifier, {
+            certId: this.distributionCertificate.developerPortalIdentifier ?? undefined,
+            certP12: this.distributionCertificate.certificateP12,
+            certPassword: this.distributionCertificate.certificatePassword,
+            distCertSerialNumber: this.distributionCertificate.serialNumber,
+            teamId: this.distributionCertificate.appleTeam?.appleTeamIdentifier ?? appleAuthCtx.team.id,
+        });
+    }
+}
+exports.CreateProvisioningProfile = CreateProvisioningProfile;

package/build/credentials/ios/actions/CreatePushKey.d.ts

@@ -0,0 +1,7 @@
+import { AccountFragment, ApplePushKeyFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+export declare class CreatePushKey {
+    private readonly account;
+    constructor(account: AccountFragment);
+    runAsync(ctx: CredentialsContext): Promise<ApplePushKeyFragment>;
+}

package/build/credentials/ios/actions/CreatePushKey.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreatePushKey = void 0;
+const tslib_1 = require("tslib");
+const PushKeyUtils_1 = require("./PushKeyUtils");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+class CreatePushKey {
+    account;
+    constructor(account) {
+        this.account = account;
+    }
+    async runAsync(ctx) {
+        if (ctx.nonInteractive) {
+            throw new Error(`A new push key cannot be created in non-interactive mode.`);
+        }
+        const pushKey = await (0, PushKeyUtils_1.provideOrGeneratePushKeyAsync)(ctx);
+        const result = await ctx.ios.createPushKeyAsync(ctx.graphqlClient, this.account, pushKey);
+        log_1.default.succeed('Created push key');
+        return result;
+    }
+}
+exports.CreatePushKey = CreatePushKey;

package/build/credentials/ios/actions/DeviceUtils.d.ts

@@ -0,0 +1,3 @@
+import { AppleDevice, AppleDeviceFragment } from '../../../graphql/generated';
+export declare function chooseDevicesAsync(allDevices: AppleDeviceFragment[], preselectedDeviceIdentifiers?: string[]): Promise<AppleDevice[]>;
+export declare function formatDeviceLabel(device: AppleDeviceFragment): string;