@donotuse/eas-cli 18.5.0-rc.1

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetUpBuildCredentialsFromCredentialsJson = void 0;
+const tslib_1 = require("tslib");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const SetUpTargetBuildCredentialsFromCredentialsJson_1 = require("./SetUpTargetBuildCredentialsFromCredentialsJson");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const target_1 = require("../../../project/ios/target");
+const read_1 = require("../../credentialsJson/read");
+const utils_1 = require("../../credentialsJson/utils");
+class SetUpBuildCredentialsFromCredentialsJson {
+    app;
+    targets;
+    distributionType;
+    constructor(app, targets, distributionType) {
+        this.app = app;
+        this.targets = targets;
+        this.distributionType = distributionType;
+    }
+    async runAsync(ctx) {
+        const credentialsJson = await this.readCredentialsJsonAsync(ctx);
+        (0, utils_1.ensureAllTargetsAreConfigured)(this.targets, credentialsJson);
+        const hasManyTargets = this.targets.length > 1;
+        for (const target of this.targets) {
+            if (hasManyTargets) {
+                log_1.default.newLine();
+                log_1.default.log(`Setting up credentials for target ${chalk_1.default.bold(target.targetName)} (${target.bundleIdentifier})`);
+                log_1.default.newLine();
+            }
+            await new SetUpTargetBuildCredentialsFromCredentialsJson_1.SetUpTargetBuildCredentialsFromCredentialsJson({
+                account: this.app.account,
+                projectName: this.app.projectName,
+                bundleIdentifier: target.bundleIdentifier,
+                parentBundleIdentifier: target.parentBundleIdentifier,
+            }, this.distributionType, credentialsJson[target.targetName]).runAsync(ctx);
+        }
+    }
+    async readCredentialsJsonAsync(ctx) {
+        const applicationTarget = (0, target_1.findApplicationTarget)(this.targets);
+        try {
+            return await (0, read_1.readIosCredentialsAsync)(ctx.projectDir, applicationTarget);
+        }
+        catch (error) {
+            log_1.default.error('Reading credentials from credentials.json failed. Make sure this file is correct and all credentials are present there.');
+            throw error;
+        }
+    }
+}
+exports.SetUpBuildCredentialsFromCredentialsJson = SetUpBuildCredentialsFromCredentialsJson;

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

@@ -0,0 +1,17 @@
+import { AppleDistributionCertificate, AppleDistributionCertificateFragment, IosDistributionType } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/graphql/types/AppLookupParams';
+export declare class SetUpDistributionCertificate {
+    private readonly app;
+    private readonly distributionType;
+    private validDistCerts?;
+    constructor(app: AppLookupParams, distributionType: IosDistributionType);
+    runAsync(ctx: CredentialsContext): Promise<AppleDistributionCertificateFragment>;
+    private runNonInteractiveAsync;
+    private runInteractiveAsync;
+    private isCurrentCertificateValidAsync;
+    private createOrReuseDistCertAsync;
+    private createNewDistCertAsync;
+    reuseDistCertAsync(ctx: CredentialsContext): Promise<AppleDistributionCertificate>;
+    private getValidDistCertsAsync;
+}

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

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetUpDistributionCertificate = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const AppleTeamUtils_1 = require("./AppleTeamUtils");
+const CreateDistributionCertificate_1 = require("./CreateDistributionCertificate");
+const DistributionCertificateUtils_1 = require("./DistributionCertificateUtils");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+const sortBy_1 = tslib_1.__importDefault(require("../../../utils/expodash/sortBy"));
+const errors_1 = require("../../errors");
+const CredentialsUtils_1 = require("../appstore/CredentialsUtils");
+const errors_2 = require("../errors");
+class SetUpDistributionCertificate {
+    app;
+    distributionType;
+    validDistCerts;
+    constructor(app, distributionType) {
+        this.app = app;
+        this.distributionType = distributionType;
+    }
+    async runAsync(ctx) {
+        const appleTeam = await (0, AppleTeamUtils_1.resolveAppleTeamIfAuthenticatedAsync)(ctx, this.app);
+        try {
+            const currentCertificate = await ctx.ios.getDistributionCertificateForAppAsync(ctx.graphqlClient, this.app, this.distributionType, { appleTeam });
+            if (ctx.nonInteractive) {
+                return await this.runNonInteractiveAsync(ctx, currentCertificate);
+            }
+            else {
+                return await this.runInteractiveAsync(ctx, currentCertificate);
+            }
+        }
+        catch (err) {
+            if (err instanceof errors_2.AppleTeamMissingError && ctx.nonInteractive) {
+                throw new errors_1.MissingCredentialsNonInteractiveError();
+            }
+            throw err;
+        }
+    }
+    async runNonInteractiveAsync(_ctx, currentCertificate) {
+        // TODO: implement validation
+        log_1.default.addNewLineIfNone();
+        log_1.default.warn('Distribution Certificate is not validated for non-interactive builds.');
+        if (!currentCertificate) {
+            throw new errors_1.MissingCredentialsNonInteractiveError();
+        }
+        return currentCertificate;
+    }
+    async runInteractiveAsync(ctx, currentCertificate) {
+        if (await this.isCurrentCertificateValidAsync(ctx, currentCertificate)) {
+            (0, assert_1.default)(currentCertificate, 'currentCertificate is defined here');
+            return currentCertificate;
+        }
+        const validDistCertsOnFile = await this.getValidDistCertsAsync(ctx);
+        return validDistCertsOnFile.length === 0
+            ? await this.createNewDistCertAsync(ctx)
+            : await this.createOrReuseDistCertAsync(ctx);
+    }
+    async isCurrentCertificateValidAsync(ctx, currentCertificate) {
+        if (!currentCertificate) {
+            return false;
+        }
+        const now = new Date();
+        if (now < new Date(currentCertificate.validityNotBefore) ||
+            now > new Date(currentCertificate.validityNotAfter)) {
+            return false;
+        }
+        if (!ctx.appStore.authCtx) {
+            log_1.default.warn("Skipping Distribution Certificate validation on Apple Servers because we aren't authenticated.");
+            return true;
+        }
+        const validCertSerialNumbers = (await this.getValidDistCertsAsync(ctx)).map(i => i.serialNumber);
+        const isValid = validCertSerialNumbers.includes(currentCertificate.serialNumber);
+        if (!isValid) {
+            log_1.default.warn('Current distribution certificate is no longer valid in Apple Dev Portal');
+        }
+        return isValid;
+    }
+    async createOrReuseDistCertAsync(ctx) {
+        const validDistCerts = await this.getValidDistCertsAsync(ctx);
+        const autoselectedDistCert = validDistCerts[0];
+        const useAutoselected = ctx.autoAcceptCredentialReuse ||
+            (await (0, prompts_1.confirmAsync)({
+                message: `Reuse this distribution certificate?\n${(0, DistributionCertificateUtils_1.formatDistributionCertificate)(autoselectedDistCert)}`,
+            }));
+        if (useAutoselected) {
+            log_1.default.log(`Using distribution certificate with serial number ${autoselectedDistCert.serialNumber}`);
+            return autoselectedDistCert;
+        }
+        const { action } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'action',
+            message: 'Select the iOS distribution certificate to use for code signing:',
+            choices: [
+                {
+                    title: '[Choose another existing certificate] (Recommended)',
+                    value: 'CHOOSE_EXISTING',
+                },
+                { title: '[Add a new certificate]', value: 'GENERATE' },
+            ],
+        });
+        if (action === 'GENERATE') {
+            return await this.createNewDistCertAsync(ctx);
+        }
+        else {
+            return await this.reuseDistCertAsync(ctx);
+        }
+    }
+    async createNewDistCertAsync(ctx) {
+        return await new CreateDistributionCertificate_1.CreateDistributionCertificate(this.app.account).runAsync(ctx);
+    }
+    async reuseDistCertAsync(ctx) {
+        const validDistCerts = await this.getValidDistCertsAsync(ctx);
+        const { distCert } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'distCert',
+            message: 'Select the iOS Distribution Certificate from the list:',
+            choices: validDistCerts.map(distCert => ({
+                title: (0, DistributionCertificateUtils_1.formatDistributionCertificate)(distCert),
+                value: distCert,
+            })),
+        });
+        return distCert;
+    }
+    async getValidDistCertsAsync(ctx) {
+        if (this.validDistCerts) {
+            return this.validDistCerts;
+        }
+        const validDistCertSerialNumbers = (0, CredentialsUtils_1.getValidCertSerialNumbers)(await ctx.appStore.listDistributionCertificatesAsync());
+        const validDistCertSerialNumberSet = new Set(validDistCertSerialNumbers);
+        const distCertsForAccount = await ctx.ios.getDistributionCertificatesForAccountAsync(ctx.graphqlClient, this.app.account);
+        const distCertsForAppleTeam = distCertsForAccount.filter(distCert => {
+            return (!distCert.appleTeam ||
+                distCert.appleTeam.appleTeamIdentifier === ctx.appStore.authCtx?.team.id);
+        });
+        const validDistCerts = distCertsForAppleTeam.filter(distCert => {
+            return validDistCertSerialNumberSet.has(distCert.serialNumber);
+        });
+        this.validDistCerts = (0, sortBy_1.default)(validDistCerts, 'validityNotAfter', 'desc');
+        return this.validDistCerts;
+    }
+}
+exports.SetUpDistributionCertificate = SetUpDistributionCertificate;

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

@@ -0,0 +1,24 @@
+import { IosAppBuildCredentialsFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/graphql/types/AppLookupParams';
+import { Target } from '../types';
+/**
+ * It's used when setting up credentials for internal distribution but `enterpriseProvisioning` is not set.
+ *
+ * TLDR: If the user authenticates with an account with Apple Developer Enterprise Program membership we ask them
+ * to choose if they want to set up an adhoc or universal distribution provisioning profile. Otherwise, always
+ * set up an adhoc provisioning profile.
+ */
+interface Options {
+    app: AppLookupParams;
+    target: Target;
+}
+export declare class SetUpInternalProvisioningProfile {
+    private readonly options;
+    constructor(options: Options);
+    runAsync(ctx: CredentialsContext): Promise<IosAppBuildCredentialsFragment>;
+    private setupAdhocProvisioningProfileAsync;
+    private setupUniversalProvisioningProfileAsync;
+    private askForDistributionTypeAndSetupAsync;
+}
+export {};

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetUpInternalProvisioningProfile = void 0;
+const tslib_1 = require("tslib");
+const BuildCredentialsUtils_1 = require("./BuildCredentialsUtils");
+const SetUpAdhocProvisioningProfile_1 = require("./SetUpAdhocProvisioningProfile");
+const SetUpProvisioningProfile_1 = require("./SetUpProvisioningProfile");
+const generated_1 = require("../../../graphql/generated");
+const log_1 = tslib_1.__importStar(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+class SetUpInternalProvisioningProfile {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async runAsync(ctx) {
+        const buildCredentials = await (0, BuildCredentialsUtils_1.getAllBuildCredentialsAsync)(ctx, this.options.app);
+        const adhocBuildCredentialsExist = buildCredentials.filter(({ iosDistributionType }) => iosDistributionType === generated_1.IosDistributionType.AdHoc).length > 0;
+        const enterpriseBuildCredentialsExist = buildCredentials.filter(({ iosDistributionType }) => iosDistributionType === generated_1.IosDistributionType.Enterprise).length > 0;
+        if (!ctx.nonInteractive) {
+            if (ctx.appStore.authCtx) {
+                if (ctx.appStore.authCtx.team.inHouse) {
+                    return await this.askForDistributionTypeAndSetupAsync(ctx, 'Which credentials would you like to set up?');
+                }
+                else {
+                    return await this.setupAdhocProvisioningProfileAsync(ctx);
+                }
+            }
+            else {
+                if (adhocBuildCredentialsExist && enterpriseBuildCredentialsExist) {
+                    log_1.default.log('You have set up both adhoc and universal distribution credentials.');
+                    return await this.askForDistributionTypeAndSetupAsync(ctx, 'Which credentials would you like to use?');
+                }
+                else if (adhocBuildCredentialsExist) {
+                    return await this.setupAdhocProvisioningProfileAsync(ctx);
+                }
+                else if (enterpriseBuildCredentialsExist) {
+                    return await this.setupUniversalProvisioningProfileAsync(ctx);
+                }
+                else {
+                    log_1.default.addNewLineIfNone();
+                    log_1.default.log('You need to log in to your Apple Developer account to generate credentials for internal distribution builds, or provide credentials via credentials.json');
+                    log_1.default.log((0, log_1.learnMore)('https://docs.expo.dev/app-signing/local-credentials/'));
+                    const { team } = await ctx.appStore.ensureAuthenticatedAsync();
+                    if (team.inHouse) {
+                        return await this.askForDistributionTypeAndSetupAsync(ctx, 'Which credentials would you like to set up?');
+                    }
+                    else {
+                        return await this.setupAdhocProvisioningProfileAsync(ctx);
+                    }
+                }
+            }
+        }
+        else {
+            if (adhocBuildCredentialsExist && enterpriseBuildCredentialsExist) {
+                throw new Error(`You're in non-interactive mode. You have set up both adhoc and universal distribution credentials. Set the 'enterpriseProvisioning' property (to 'adhoc' or 'universal') in eas.json to choose the credentials to use.`);
+            }
+            else if (adhocBuildCredentialsExist) {
+                return await this.setupAdhocProvisioningProfileAsync(ctx);
+            }
+            else if (enterpriseBuildCredentialsExist) {
+                return await this.setupUniversalProvisioningProfileAsync(ctx);
+            }
+            else {
+                throw new Error(`You're in non-interactive mode. EAS CLI couldn't find any credentials suitable for internal distribution. Run this command again in interactive mode.`);
+            }
+        }
+    }
+    async setupAdhocProvisioningProfileAsync(ctx) {
+        const { app, target } = this.options;
+        return await new SetUpAdhocProvisioningProfile_1.SetUpAdhocProvisioningProfile({ app, target }).runAsync(ctx);
+    }
+    async setupUniversalProvisioningProfileAsync(ctx) {
+        return await new SetUpProvisioningProfile_1.SetUpProvisioningProfile(this.options.app, this.options.target, generated_1.IosDistributionType.Enterprise).runAsync(ctx);
+    }
+    async askForDistributionTypeAndSetupAsync(ctx, message) {
+        const { distributionType } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'distributionType',
+            message,
+            choices: [
+                { title: 'Universal Distribution', value: generated_1.IosDistributionType.Enterprise },
+                { title: 'Adhoc Distribution', value: generated_1.IosDistributionType.AdHoc },
+            ],
+        });
+        if (distributionType === generated_1.IosDistributionType.Enterprise) {
+            return await this.setupUniversalProvisioningProfileAsync(ctx);
+        }
+        else {
+            return await this.setupAdhocProvisioningProfileAsync(ctx);
+        }
+    }
+}
+exports.SetUpInternalProvisioningProfile = SetUpInternalProvisioningProfile;

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

@@ -0,0 +1,19 @@
+import { AppleDistributionCertificateFragment, AppleProvisioningProfileFragment, IosAppBuildCredentialsFragment, IosDistributionType } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/graphql/types/AppLookupParams';
+import { Target } from '../types';
+/**
+ * Sets up either APP_STORE or ENTERPRISE provisioning profiles
+ */
+export declare class SetUpProvisioningProfile {
+    private readonly app;
+    private readonly target;
+    private readonly distributionType;
+    constructor(app: AppLookupParams, target: Target, distributionType: IosDistributionType);
+    areBuildCredentialsSetupAsync(ctx: CredentialsContext): Promise<boolean>;
+    assignNewAndDeleteOldProfileAsync(ctx: CredentialsContext, distCert: AppleDistributionCertificateFragment, currentProfile: AppleProvisioningProfileFragment): Promise<IosAppBuildCredentialsFragment>;
+    createAndAssignProfileAsync(ctx: CredentialsContext, distCert: AppleDistributionCertificateFragment): Promise<IosAppBuildCredentialsFragment>;
+    configureAndAssignProfileAsync(ctx: CredentialsContext, distCert: AppleDistributionCertificateFragment, originalProvisioningProfile: AppleProvisioningProfileFragment): Promise<IosAppBuildCredentialsFragment | null>;
+    runAsync(ctx: CredentialsContext): Promise<IosAppBuildCredentialsFragment>;
+    private getCurrentProfileStoreInfo;
+}

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetUpProvisioningProfile = void 0;
+const tslib_1 = require("tslib");
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const BuildCredentialsUtils_1 = require("./BuildCredentialsUtils");
+const ConfigureProvisioningProfile_1 = require("./ConfigureProvisioningProfile");
+const CreateProvisioningProfile_1 = require("./CreateProvisioningProfile");
+const ProvisioningProfileUtils_1 = require("./ProvisioningProfileUtils");
+const SetUpDistributionCertificate_1 = require("./SetUpDistributionCertificate");
+const log_1 = require("../../../log");
+const target_1 = require("../../../project/ios/target");
+const prompts_1 = require("../../../prompts");
+const errors_1 = require("../../errors");
+const authenticateTypes_1 = require("../appstore/authenticateTypes");
+const validateProvisioningProfile_1 = require("../validators/validateProvisioningProfile");
+/**
+ * Sets up either APP_STORE or ENTERPRISE provisioning profiles
+ */
+class SetUpProvisioningProfile {
+    app;
+    target;
+    distributionType;
+    constructor(app, target, distributionType) {
+        this.app = app;
+        this.target = target;
+        this.distributionType = distributionType;
+    }
+    async areBuildCredentialsSetupAsync(ctx) {
+        const buildCredentials = await (0, BuildCredentialsUtils_1.getBuildCredentialsAsync)(ctx, this.app, this.distributionType);
+        return await (0, validateProvisioningProfile_1.validateProvisioningProfileAsync)(ctx, this.target, this.app, buildCredentials);
+    }
+    async assignNewAndDeleteOldProfileAsync(ctx, distCert, currentProfile) {
+        const buildCredentials = await this.createAndAssignProfileAsync(ctx, distCert);
+        // delete 'currentProfile' since its no longer valid
+        await ctx.ios.deleteProvisioningProfilesAsync(ctx.graphqlClient, [currentProfile.id]);
+        return buildCredentials;
+    }
+    async createAndAssignProfileAsync(ctx, distCert) {
+        const provisioningProfile = await new CreateProvisioningProfile_1.CreateProvisioningProfile(this.app, this.target, distCert).runAsync(ctx);
+        return await (0, BuildCredentialsUtils_1.assignBuildCredentialsAsync)(ctx, this.app, this.distributionType, distCert, provisioningProfile);
+    }
+    async configureAndAssignProfileAsync(ctx, distCert, originalProvisioningProfile) {
+        const profileConfigurator = new ConfigureProvisioningProfile_1.ConfigureProvisioningProfile(this.app, this.target, distCert, originalProvisioningProfile);
+        const updatedProvisioningProfile = await profileConfigurator.runAsync(ctx);
+        if (!updatedProvisioningProfile) {
+            return null;
+        }
+        return await (0, BuildCredentialsUtils_1.assignBuildCredentialsAsync)(ctx, this.app, this.distributionType, distCert, updatedProvisioningProfile);
+    }
+    async runAsync(ctx) {
+        const distCert = await new SetUpDistributionCertificate_1.SetUpDistributionCertificate(this.app, this.distributionType).runAsync(ctx);
+        const areBuildCredentialsSetup = await this.areBuildCredentialsSetupAsync(ctx);
+        if (areBuildCredentialsSetup) {
+            return (0, nullthrows_1.default)(await (0, BuildCredentialsUtils_1.getBuildCredentialsAsync)(ctx, this.app, this.distributionType));
+        }
+        if (ctx.freezeCredentials) {
+            throw new errors_1.ForbidCredentialModificationError('Provisioning profile is not configured correctly. Remove the --freeze-credentials flag to configure it.');
+        }
+        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 currentProfile = await (0, BuildCredentialsUtils_1.getProvisioningProfileAsync)(ctx, this.app, this.distributionType);
+        if (!currentProfile) {
+            return await this.createAndAssignProfileAsync(ctx, distCert);
+        }
+        // See if the profile we have exists on the Apple Servers
+        const applePlatform = (0, target_1.getApplePlatformFromTarget)(this.target);
+        const existingProfiles = await ctx.appStore.listProvisioningProfilesAsync(this.app.bundleIdentifier, applePlatform);
+        const currentProfileFromServer = this.getCurrentProfileStoreInfo(existingProfiles, currentProfile);
+        if (!currentProfileFromServer) {
+            return await this.assignNewAndDeleteOldProfileAsync(ctx, distCert, currentProfile);
+        }
+        const isNonInteractiveOrUserDidConfirmAsync = async () => {
+            if (ctx.nonInteractive || ctx.autoAcceptCredentialReuse) {
+                return true;
+            }
+            return await (0, prompts_1.confirmAsync)({
+                message: `${(0, ProvisioningProfileUtils_1.formatProvisioningProfileFromApple)(currentProfileFromServer)} \n  Would you like to reuse the original profile?`,
+            });
+        };
+        const confirm = await isNonInteractiveOrUserDidConfirmAsync();
+        if (!confirm) {
+            return await this.assignNewAndDeleteOldProfileAsync(ctx, distCert, currentProfile);
+        }
+        // If we get here, we've verified the current profile still exists on Apple
+        // But something wasn't quite right, so we want to fix and update it
+        const updatedProfile = await this.configureAndAssignProfileAsync(ctx, distCert, currentProfile);
+        if (!updatedProfile) {
+            // Something went wrong, so just create a new profile instead
+            return await this.assignNewAndDeleteOldProfileAsync(ctx, distCert, currentProfile);
+        }
+        return updatedProfile;
+    }
+    getCurrentProfileStoreInfo(profiles, currentProfile) {
+        return (profiles.find(profile => currentProfile.developerPortalIdentifier
+            ? currentProfile.developerPortalIdentifier === profile.provisioningProfileId
+            : currentProfile.provisioningProfile === profile.provisioningProfile) ?? null);
+    }
+}
+exports.SetUpProvisioningProfile = SetUpProvisioningProfile;

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

@@ -0,0 +1,10 @@
+import { CommonIosAppCredentialsFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/graphql/types/AppLookupParams';
+export declare class SetUpPushKey {
+    private readonly app;
+    constructor(app: AppLookupParams);
+    isPushKeySetupAsync(ctx: CredentialsContext): Promise<boolean>;
+    runAsync(ctx: CredentialsContext): Promise<CommonIosAppCredentialsFragment | null>;
+    private createOrReusePushKeyAsync;
+}

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetUpPushKey = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const AssignPushKey_1 = require("./AssignPushKey");
+const CreatePushKey_1 = require("./CreatePushKey");
+const PushKeyUtils_1 = require("./PushKeyUtils");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+class SetUpPushKey {
+    app;
+    constructor(app) {
+        this.app = app;
+    }
+    async isPushKeySetupAsync(ctx) {
+        const pushKey = await ctx.ios.getPushKeyForAppAsync(ctx.graphqlClient, this.app);
+        return !!pushKey;
+    }
+    async runAsync(ctx) {
+        if (ctx.nonInteractive) {
+            throw new Error(`Push keys cannot be setup in non-interactive mode.`);
+        }
+        const isPushKeySetup = await this.isPushKeySetupAsync(ctx);
+        if (isPushKeySetup) {
+            return await ctx.ios.getIosAppCredentialsWithCommonFieldsAsync(ctx.graphqlClient, this.app);
+        }
+        const pushKeysForAccount = await ctx.ios.getPushKeysForAccountAsync(ctx.graphqlClient, this.app.account);
+        let pushKey;
+        if (pushKeysForAccount.length === 0) {
+            pushKey = await new CreatePushKey_1.CreatePushKey(this.app.account).runAsync(ctx);
+        }
+        else {
+            pushKey = await this.createOrReusePushKeyAsync(ctx);
+        }
+        return await new AssignPushKey_1.AssignPushKey(this.app).runAsync(ctx, pushKey);
+    }
+    async createOrReusePushKeyAsync(ctx) {
+        const pushKeysForAccount = await ctx.ios.getPushKeysForAccountAsync(ctx.graphqlClient, this.app.account);
+        (0, assert_1.default)(pushKeysForAccount.length > 0, 'createOrReusePushKeyAsync: There are no Push Keys available in your EAS account.');
+        if (ctx.appStore.authCtx) {
+            // only provide autoselect if we can find a push key that is certainly valid
+            const validPushKeys = ctx.appStore.authCtx
+                ? await (0, PushKeyUtils_1.getValidAndTrackedPushKeysOnEasServersAsync)(ctx, pushKeysForAccount)
+                : [];
+            if (validPushKeys.length > 0) {
+                const autoselectedPushKey = validPushKeys[0];
+                const useAutoselected = ctx.autoAcceptCredentialReuse ||
+                    (await (0, prompts_1.confirmAsync)({
+                        message: `Reuse this Push Key?\n${(0, PushKeyUtils_1.formatPushKey)(autoselectedPushKey, validPushKeys.map(pushKey => pushKey.keyIdentifier))}`,
+                    }));
+                if (useAutoselected) {
+                    log_1.default.log(`Using push key with ID ${autoselectedPushKey.keyIdentifier}`);
+                    return autoselectedPushKey;
+                }
+            }
+        }
+        // When auto-accepting and no valid push key was found, generate a new one without prompting
+        if (ctx.autoAcceptCredentialReuse) {
+            return await new CreatePushKey_1.CreatePushKey(this.app.account).runAsync(ctx);
+        }
+        const { action } = await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'action',
+            message: 'Select the Apple Push Key to use for your project:',
+            choices: [
+                {
+                    title: '[Choose another existing push key] (Recommended)',
+                    value: 'CHOOSE_EXISTING',
+                },
+                { title: '[Add a new push key]', value: 'GENERATE' },
+            ],
+        });
+        if (action === 'GENERATE') {
+            return await new CreatePushKey_1.CreatePushKey(this.app.account).runAsync(ctx);
+        }
+        else {
+            return (0, nullthrows_1.default)(await (0, PushKeyUtils_1.selectPushKeyAsync)(ctx, this.app.account));
+        }
+    }
+}
+exports.SetUpPushKey = SetUpPushKey;

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

@@ -0,0 +1,20 @@
+import { DistributionType, IosEnterpriseProvisioning } from '@expo/eas-json';
+import { JSONObject } from '@expo/json-file';
+import { IosAppBuildCredentialsFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams as GraphQLAppLookupParams } from '../api/graphql/types/AppLookupParams';
+import { Target } from '../types';
+interface Options {
+    app: GraphQLAppLookupParams;
+    distribution: DistributionType;
+    enterpriseProvisioning?: IosEnterpriseProvisioning;
+    entitlements: JSONObject;
+    target: Target;
+}
+export declare class SetUpTargetBuildCredentials {
+    private readonly options;
+    constructor(options: Options);
+    runAsync(ctx: CredentialsContext): Promise<IosAppBuildCredentialsFragment>;
+    setupBuildCredentialsAsync(ctx: CredentialsContext): Promise<IosAppBuildCredentialsFragment>;
+}
+export {};

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetUpTargetBuildCredentials = void 0;
+const tslib_1 = require("tslib");
+const SetUpAdhocProvisioningProfile_1 = require("./SetUpAdhocProvisioningProfile");
+const SetUpInternalProvisioningProfile_1 = require("./SetUpInternalProvisioningProfile");
+const SetUpProvisioningProfile_1 = require("./SetUpProvisioningProfile");
+const generated_1 = require("../../../graphql/generated");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+class SetUpTargetBuildCredentials {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async runAsync(ctx) {
+        const { app, entitlements, target } = this.options;
+        await ctx.bestEffortAppStoreAuthenticateAsync();
+        if (ctx.appStore.authCtx) {
+            await ctx.appStore.ensureBundleIdExistsAsync({
+                accountName: app.account.name,
+                bundleIdentifier: app.bundleIdentifier,
+                projectName: app.projectName,
+            }, {
+                entitlements,
+                usesBroadcastPushNotifications: ctx.usesBroadcastPushNotifications,
+                parentBundleIdentifier: target.parentBundleIdentifier,
+            });
+        }
+        try {
+            return await this.setupBuildCredentialsAsync(ctx);
+        }
+        catch (error) {
+            log_1.default.error('Failed to set up credentials.');
+            throw error;
+        }
+    }
+    async setupBuildCredentialsAsync(ctx) {
+        const { app, distribution, enterpriseProvisioning, target } = this.options;
+        if (distribution === 'internal') {
+            if (enterpriseProvisioning === 'adhoc') {
+                return await new SetUpAdhocProvisioningProfile_1.SetUpAdhocProvisioningProfile({ app, target }).runAsync(ctx);
+            }
+            else if (enterpriseProvisioning === 'universal') {
+                return await new SetUpProvisioningProfile_1.SetUpProvisioningProfile(app, target, generated_1.IosDistributionType.Enterprise).runAsync(ctx);
+            }
+            else {
+                return await new SetUpInternalProvisioningProfile_1.SetUpInternalProvisioningProfile({ app, target }).runAsync(ctx);
+            }
+        }
+        else {
+            return await new SetUpProvisioningProfile_1.SetUpProvisioningProfile(app, target, generated_1.IosDistributionType.AppStore).runAsync(ctx);
+        }
+    }
+}
+exports.SetUpTargetBuildCredentials = SetUpTargetBuildCredentials;

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

@@ -0,0 +1,14 @@
+import { AppleDistributionCertificateFragment, AppleProvisioningProfileFragment, AppleTeamFragment, IosAppBuildCredentialsFragment, IosDistributionType } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { IosTargetCredentials } from '../../credentialsJson/types';
+import { AppLookupParams } from '../api/graphql/types/AppLookupParams';
+export declare class SetUpTargetBuildCredentialsFromCredentialsJson {
+    private readonly app;
+    private readonly distributionType;
+    private readonly targetCredentials;
+    constructor(app: AppLookupParams, distributionType: IosDistributionType, targetCredentials: IosTargetCredentials);
+    runAsync(ctx: CredentialsContext): Promise<IosAppBuildCredentialsFragment>;
+    getDistributionCertificateToAssignAsync(ctx: CredentialsContext, appleTeam: AppleTeamFragment, currentDistributionCertificate: AppleDistributionCertificateFragment | null): Promise<AppleDistributionCertificateFragment>;
+    getProvisioningProfileToAssignAsync(ctx: CredentialsContext, appleTeam: AppleTeamFragment, currentProvisioningProfile: AppleProvisioningProfileFragment | null): Promise<AppleProvisioningProfileFragment>;
+    createNewProvisioningProfileAsync(ctx: CredentialsContext, appleTeam: AppleTeamFragment): Promise<AppleProvisioningProfileFragment>;
+}