@donotuse/eas-cli 18.5.0-rc.1

package/build/credentials/credentialsJson/types.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CredentialsJsonSchema = void 0;
+const tslib_1 = require("tslib");
+const joi_1 = tslib_1.__importDefault(require("joi"));
+const CredentialsJsonIosTargetCredentialsSchema = joi_1.default.object({
+    provisioningProfilePath: joi_1.default.string().required(),
+    distributionCertificate: joi_1.default.object({
+        path: joi_1.default.string().required(),
+        password: joi_1.default.string().allow('').required(),
+    }).required(),
+});
+exports.CredentialsJsonSchema = joi_1.default.object({
+    android: joi_1.default.object({
+        keystore: joi_1.default.object({
+            keystorePath: joi_1.default.string().required(),
+            keystorePassword: joi_1.default.string().allow('').required(),
+            keyAlias: joi_1.default.string().required(),
+            keyPassword: joi_1.default.string().allow(''),
+        }).required(),
+    }),
+    ios: [
+        CredentialsJsonIosTargetCredentialsSchema,
+        joi_1.default.object().pattern(joi_1.default.string().required(), CredentialsJsonIosTargetCredentialsSchema.required()),
+    ],
+});

package/build/credentials/credentialsJson/update.d.ts

@@ -0,0 +1,14 @@
+import { AndroidAppBuildCredentialsFragment, IosDistributionType } from '../../graphql/generated';
+import { CredentialsContext } from '../context';
+import { App, Target } from '../ios/types';
+/**
+ * Update Android credentials.json with values from www, content of credentials.json
+ * is not validated
+ */
+export declare function updateAndroidCredentialsAsync(ctx: CredentialsContext, buildCredentials: AndroidAppBuildCredentialsFragment): Promise<void>;
+/**
+ * Update iOS credentials in credentials.json with values from www, contents
+ * of credentials.json are not validated, if www has incomplete credentials
+ * credentials.json will be updated partially
+ */
+export declare function updateIosCredentialsAsync(ctx: CredentialsContext, app: App, targets: Target[], distributionType: IosDistributionType): Promise<void>;

package/build/credentials/credentialsJson/update.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateAndroidCredentialsAsync = updateAndroidCredentialsAsync;
+exports.updateIosCredentialsAsync = updateIosCredentialsAsync;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const read_1 = require("./read");
+const utils_1 = require("./utils");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const target_1 = require("../../project/ios/target");
+const zipObject_1 = tslib_1.__importDefault(require("../../utils/expodash/zipObject"));
+const git_1 = tslib_1.__importDefault(require("../../vcs/clients/git"));
+/**
+ * Update Android credentials.json with values from www, content of credentials.json
+ * is not validated
+ */
+async function updateAndroidCredentialsAsync(ctx, buildCredentials) {
+    const rawCredentialsJson = (await (0, read_1.readRawAsync)(ctx.projectDir, { throwIfMissing: false })) ?? {};
+    const keystore = buildCredentials.androidKeystore;
+    if (!keystore) {
+        throw new Error('There are no credentials configured for this project on EAS servers');
+    }
+    const keystorePath = rawCredentialsJson?.android?.keystore?.keystorePath ?? 'credentials/android/keystore.jks';
+    log_1.default.log(`Writing Keystore to ${keystorePath}`);
+    await updateFileAsync(ctx.projectDir, keystorePath, keystore.keystore);
+    const shouldWarnKeystore = await isFileUntrackedAsync(keystorePath, ctx.vcsClient);
+    const androidCredentials = {
+        keystore: {
+            keystorePath,
+            keystorePassword: keystore.keystorePassword,
+            keyAlias: keystore.keyAlias,
+            keyPassword: keystore.keyPassword ?? undefined,
+        },
+    };
+    rawCredentialsJson.android = androidCredentials;
+    await fs_extra_1.default.writeJson((0, utils_1.getCredentialsJsonPath)(ctx.projectDir), rawCredentialsJson, {
+        spaces: 2,
+    });
+    const shouldWarnCredentialsJson = await isFileUntrackedAsync('credentials.json', ctx.vcsClient);
+    const newFilePaths = [];
+    if (shouldWarnKeystore) {
+        newFilePaths.push(keystorePath);
+    }
+    if (shouldWarnCredentialsJson) {
+        newFilePaths.push('credentials.json');
+    }
+    displayUntrackedFilesWarning(newFilePaths);
+}
+/**
+ * Update iOS credentials in credentials.json with values from www, contents
+ * of credentials.json are not validated, if www has incomplete credentials
+ * credentials.json will be updated partially
+ */
+async function updateIosCredentialsAsync(ctx, app, targets, distributionType) {
+    const rawCredentialsJson = (await (0, read_1.readRawAsync)(ctx.projectDir, { throwIfMissing: false })) ?? {};
+    if (typeof rawCredentialsJson.ios?.provisioningProfilePath === 'string') {
+        const applicationTarget = (0, target_1.findApplicationTarget)(targets);
+        rawCredentialsJson.ios = {
+            [applicationTarget.targetName]: rawCredentialsJson.ios,
+        };
+    }
+    const targetBuildCredentialsList = await Promise.all(targets.map(target => getTargetBuildCredentialsAsync(ctx, app, target, distributionType)));
+    const targetBuildsCredentialsMap = (0, zipObject_1.default)(targets.map(({ targetName }) => targetName), targetBuildCredentialsList);
+    let areAllTargetsConfigured = true;
+    const notConfiguredTargetLabels = [];
+    for (const [targetName, targetAppBuildCredentials] of Object.entries(targetBuildsCredentialsMap)) {
+        if (!targetAppBuildCredentials) {
+            areAllTargetsConfigured = false;
+            const { bundleIdentifier } = (0, target_1.findTargetByName)(targets, targetName);
+            notConfiguredTargetLabels.push(`${targetName} (Bundle Identifier: ${bundleIdentifier})`);
+        }
+    }
+    if (!areAllTargetsConfigured) {
+        const errorMessage = targets.length === 1
+            ? `There are no credentials configured for the ${distributionType} distribution of this project on EAS servers`
+            : `Some of the build targets don't have credentials configured for the ${distributionType} distribution of this project on EAS servers: ${notConfiguredTargetLabels}`;
+        throw new Error(errorMessage);
+    }
+    const iosCredentials = {};
+    const targetCredentialsPathsMap = createTargetCredentialsPathsMap(targets, rawCredentialsJson.ios);
+    for (const target of targets) {
+        iosCredentials[target.targetName] = await backupTargetCredentialsAsync(ctx, {
+            // app build credentials must exist for target because otherwise an error must have been thrown earlier
+            targetCredentials: (0, nullthrows_1.default)(targetBuildsCredentialsMap[target.targetName]),
+            targetCredentialsPaths: targetCredentialsPathsMap[target.targetName],
+        });
+    }
+    if (Object.keys(iosCredentials).length === 1) {
+        rawCredentialsJson.ios = iosCredentials[Object.keys(iosCredentials)[0]];
+    }
+    else {
+        rawCredentialsJson.ios = iosCredentials;
+    }
+    await fs_extra_1.default.writeJson((0, utils_1.getCredentialsJsonPath)(ctx.projectDir), rawCredentialsJson, {
+        spaces: 2,
+    });
+    const newFilePaths = [];
+    for (const [, targetCredentials] of Object.entries(iosCredentials)) {
+        if (await isFileUntrackedAsync(targetCredentials.distributionCertificate.path, ctx.vcsClient)) {
+            newFilePaths.push(targetCredentials.distributionCertificate.path);
+        }
+        if (await isFileUntrackedAsync(targetCredentials.provisioningProfilePath, ctx.vcsClient)) {
+            newFilePaths.push(targetCredentials.provisioningProfilePath);
+        }
+    }
+    if (await isFileUntrackedAsync('credentials.json', ctx.vcsClient)) {
+        newFilePaths.push('credentials.json');
+    }
+    displayUntrackedFilesWarning(newFilePaths);
+}
+function createTargetCredentialsPathsMap(targets, rawCredentialsJsonMap) {
+    const hasManyTargets = targets.length > 1;
+    const paths = {};
+    // 1. Create initial target credentials paths map
+    for (const target of targets) {
+        const rawTargetCredentialsJson = rawCredentialsJsonMap?.[target.targetName];
+        const filePrefix = hasManyTargets ? `${target.targetName}-` : '';
+        paths[target.targetName] = {
+            provisioningProfilePath: rawTargetCredentialsJson?.provisioningProfilePath ??
+                `credentials/ios/${filePrefix}profile.mobileprovision`,
+            distCertPath: rawTargetCredentialsJson?.distributionCertificate?.path ??
+                `credentials/ios/${filePrefix}dist-cert.p12`,
+        };
+    }
+    // 2. Look for duplicates and prefix them with target names
+    const deduplicatedPaths = {};
+    const usedProfilePaths = new Set();
+    const usedDistCertPaths = new Set();
+    for (const [targetName, { provisioningProfilePath, distCertPath }] of Object.entries(paths)) {
+        const newProvisioningProfilePath = usedProfilePaths.has(provisioningProfilePath)
+            ? path_1.default.join(path_1.default.dirname(provisioningProfilePath), `${targetName}-${path_1.default.basename(provisioningProfilePath)}`)
+            : provisioningProfilePath;
+        usedProfilePaths.add(newProvisioningProfilePath);
+        const newDistCertPath = usedDistCertPaths.has(distCertPath)
+            ? path_1.default.join(path_1.default.dirname(distCertPath), `${targetName}-${path_1.default.basename(distCertPath)}`)
+            : distCertPath;
+        usedDistCertPaths.add(newDistCertPath);
+        deduplicatedPaths[targetName] = {
+            distCertPath: newDistCertPath,
+            provisioningProfilePath: newProvisioningProfilePath,
+        };
+    }
+    return deduplicatedPaths;
+}
+async function getTargetBuildCredentialsAsync(ctx, app, target, iosDistributionType) {
+    const appCredentials = await ctx.ios.getIosAppCredentialsWithCommonFieldsAsync(ctx.graphqlClient, {
+        account: app.account,
+        projectName: app.projectName,
+        bundleIdentifier: target.bundleIdentifier,
+        parentBundleIdentifier: target.parentBundleIdentifier,
+    });
+    const appBuildCredentials = appCredentials?.iosAppBuildCredentialsList.find(appBuildCredentials => appBuildCredentials.iosDistributionType === iosDistributionType) ?? null;
+    if (appBuildCredentials === null) {
+        return null;
+    }
+    if (!(appBuildCredentials.provisioningProfile?.provisioningProfile !== undefined &&
+        appBuildCredentials.distributionCertificate?.certificateP12 !== undefined &&
+        appBuildCredentials.distributionCertificate?.certificatePassword !== undefined)) {
+        return null;
+    }
+    return {
+        distributionCertificate: {
+            certificateP12: (0, nullthrows_1.default)(appBuildCredentials.distributionCertificate.certificateP12),
+            certificatePassword: (0, nullthrows_1.default)(appBuildCredentials.distributionCertificate.certificatePassword),
+        },
+        provisioningProfile: (0, nullthrows_1.default)(appBuildCredentials.provisioningProfile.provisioningProfile),
+    };
+}
+async function backupTargetCredentialsAsync(ctx, { targetCredentials, targetCredentialsPaths, }) {
+    const { provisioningProfilePath, distCertPath } = targetCredentialsPaths;
+    log_1.default.log(`Writing Provisioning Profile to ${provisioningProfilePath}`);
+    await updateFileAsync(ctx.projectDir, provisioningProfilePath, targetCredentials.provisioningProfile);
+    log_1.default.log(`Writing Distribution Certificate to ${distCertPath}`);
+    await updateFileAsync(ctx.projectDir, distCertPath, targetCredentials.distributionCertificate.certificateP12);
+    return {
+        distributionCertificate: {
+            path: distCertPath,
+            password: targetCredentials.distributionCertificate.certificatePassword,
+        },
+        provisioningProfilePath,
+    };
+}
+async function updateFileAsync(projectDir, filePath, base64Data) {
+    const absolutePath = path_1.default.isAbsolute(filePath) ? filePath : path_1.default.join(projectDir, filePath);
+    if (await fs_extra_1.default.pathExists(absolutePath)) {
+        await fs_extra_1.default.remove(absolutePath);
+    }
+    if (base64Data) {
+        await fs_extra_1.default.mkdirp(path_1.default.dirname(filePath));
+        await fs_extra_1.default.writeFile(filePath, Buffer.from(base64Data, 'base64'));
+    }
+}
+async function isFileUntrackedAsync(path, vcsClient) {
+    if (vcsClient instanceof git_1.default) {
+        return await vcsClient.isFileUntrackedAsync(path);
+    }
+    return false;
+}
+function displayUntrackedFilesWarning(newFilePaths) {
+    if (newFilePaths.length === 1) {
+        log_1.default.warn(`File ${newFilePaths[0]} is currently untracked, remember to add it to .gitignore, or to encrypt it (e.g. with git-crypt).`);
+    }
+    else if (newFilePaths.length > 1) {
+        log_1.default.warn(`Files ${newFilePaths.join(', ')} are currently untracked, remember to add them to .gitignore, or to encrypt them (e.g. with git-crypt).`);
+    }
+}

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

@@ -0,0 +1,4 @@
+import { IosCredentials } from './types';
+import { Target } from '../ios/types';
+export declare function getCredentialsJsonPath(projectDir: string): string;
+export declare function ensureAllTargetsAreConfigured(targets: Target[], credentialsJson: IosCredentials): void;

package/build/credentials/credentialsJson/utils.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCredentialsJsonPath = getCredentialsJsonPath;
+exports.ensureAllTargetsAreConfigured = ensureAllTargetsAreConfigured;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+function getCredentialsJsonPath(projectDir) {
+    return path_1.default.join(projectDir, 'credentials.json');
+}
+function ensureAllTargetsAreConfigured(targets, credentialsJson) {
+    const notConfiguredTargets = [];
+    for (const target of targets) {
+        if (!(target.targetName in credentialsJson)) {
+            notConfiguredTargets.push(target.targetName);
+            continue;
+        }
+    }
+    if (notConfiguredTargets.length > 0) {
+        const errorMessage = targets.length === 1
+            ? 'Credentials are not defined in credentials.json'
+            : `Credentials for target${notConfiguredTargets.length === 1 ? '' : 's'} ${notConfiguredTargets
+                .map(i => `'${i}'`)
+                .join(',')} are not defined in credentials.json`;
+        throw new Error(errorMessage);
+    }
+}

package/build/credentials/errors.d.ts

@@ -0,0 +1,19 @@
+export declare class MissingCredentialsNonInteractiveError extends Error {
+    constructor(message?: string);
+}
+export declare class InsufficientAuthenticationNonInteractiveError extends Error {
+    constructor(message?: string);
+}
+export declare class ForbidCredentialModificationError extends Error {
+    constructor(message?: string);
+}
+export declare class MissingCredentialsError extends Error {
+    constructor(message?: string);
+}
+export declare class UnsupportedCredentialsChoiceError extends Error {
+    choice: string;
+    constructor(message: string, choice: string);
+}
+export declare class AndroidPackageNotDefinedError extends Error {
+    constructor(message?: string);
+}

package/build/credentials/errors.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidPackageNotDefinedError = exports.UnsupportedCredentialsChoiceError = exports.MissingCredentialsError = exports.ForbidCredentialModificationError = exports.InsufficientAuthenticationNonInteractiveError = exports.MissingCredentialsNonInteractiveError = void 0;
+const log_1 = require("../log");
+class MissingCredentialsNonInteractiveError extends Error {
+    constructor(message) {
+        super(message ?? 'Credentials are not set up. Run this command again in interactive mode.');
+    }
+}
+exports.MissingCredentialsNonInteractiveError = MissingCredentialsNonInteractiveError;
+class InsufficientAuthenticationNonInteractiveError extends Error {
+    constructor(message) {
+        super(message ??
+            `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')}`);
+    }
+}
+exports.InsufficientAuthenticationNonInteractiveError = InsufficientAuthenticationNonInteractiveError;
+class ForbidCredentialModificationError extends Error {
+    constructor(message) {
+        super(message ??
+            'Credentials cannot be modified. Run this command again without the --freeze-credentials flag.');
+    }
+}
+exports.ForbidCredentialModificationError = ForbidCredentialModificationError;
+class MissingCredentialsError extends Error {
+    constructor(message) {
+        super(message ?? 'Credentials are not set up.');
+    }
+}
+exports.MissingCredentialsError = MissingCredentialsError;
+class UnsupportedCredentialsChoiceError extends Error {
+    choice;
+    constructor(message, choice) {
+        super(message);
+        this.choice = choice;
+    }
+}
+exports.UnsupportedCredentialsChoiceError = UnsupportedCredentialsChoiceError;
+class AndroidPackageNotDefinedError extends Error {
+    constructor(message) {
+        super(message ?? 'android.package needs to be defined in your app.json/app.config.js file');
+    }
+}
+exports.AndroidPackageNotDefinedError = AndroidPackageNotDefinedError;

package/build/credentials/ios/IosCredentialsProvider.d.ts

@@ -0,0 +1,23 @@
+import { Platform } from '@expo/eas-build-job';
+import { CredentialsSource, DistributionType, IosEnterpriseProvisioning } from '@expo/eas-json';
+import { App, IosCredentials, Target } from './types';
+import { CredentialsContext } from '../context';
+interface Options {
+    app: App;
+    targets: Target[];
+    distribution: DistributionType;
+    enterpriseProvisioning?: IosEnterpriseProvisioning;
+}
+export default class IosCredentialsProvider {
+    private readonly ctx;
+    private readonly options;
+    readonly platform = Platform.IOS;
+    constructor(ctx: CredentialsContext, options: Options);
+    getCredentialsAsync(src: CredentialsSource.LOCAL | CredentialsSource.REMOTE): Promise<IosCredentials>;
+    private getLocalAsync;
+    private getRemoteAsync;
+    private getPushKeyAsync;
+    private disablePushNotificationsSetupInEasJsonAsync;
+    private assertProvisioningProfileType;
+}
+export {};

package/build/credentials/ios/IosCredentialsProvider.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const eas_build_job_1 = require("@expo/eas-build-job");
+const eas_json_1 = require("@expo/eas-json");
+const BuildCredentialsUtils_1 = require("./actions/BuildCredentialsUtils");
+const SetUpBuildCredentials_1 = require("./actions/SetUpBuildCredentials");
+const SetUpPushKey_1 = require("./actions/SetUpPushKey");
+const provisioningProfile_1 = require("./utils/provisioningProfile");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const target_1 = require("../../project/ios/target");
+const projectUtils_1 = require("../../project/projectUtils");
+const prompts_1 = require("../../prompts");
+const credentialsJsonReader = tslib_1.__importStar(require("../credentialsJson/read"));
+const utils_1 = require("../credentialsJson/utils");
+var PushNotificationSetupOption;
+(function (PushNotificationSetupOption) {
+    PushNotificationSetupOption[PushNotificationSetupOption["YES"] = 0] = "YES";
+    PushNotificationSetupOption[PushNotificationSetupOption["NO"] = 1] = "NO";
+    PushNotificationSetupOption[PushNotificationSetupOption["NO_DONT_ASK_AGAIN"] = 2] = "NO_DONT_ASK_AGAIN";
+})(PushNotificationSetupOption || (PushNotificationSetupOption = {}));
+class IosCredentialsProvider {
+    ctx;
+    options;
+    platform = eas_build_job_1.Platform.IOS;
+    constructor(ctx, options) {
+        this.ctx = ctx;
+        this.options = options;
+    }
+    async getCredentialsAsync(src) {
+        let buildCredentials;
+        if (src === eas_json_1.CredentialsSource.LOCAL) {
+            buildCredentials = await this.getLocalAsync();
+        }
+        else {
+            buildCredentials = await this.getRemoteAsync();
+        }
+        await this.getPushKeyAsync(this.ctx, this.options.targets);
+        return buildCredentials;
+    }
+    async getLocalAsync() {
+        const applicationTarget = (0, target_1.findApplicationTarget)(this.options.targets);
+        const iosCredentials = await credentialsJsonReader.readIosCredentialsAsync(this.ctx.projectDir, applicationTarget);
+        (0, utils_1.ensureAllTargetsAreConfigured)(this.options.targets, iosCredentials);
+        for (const target of this.options.targets) {
+            this.assertProvisioningProfileType(iosCredentials[target.targetName].provisioningProfile, target.targetName);
+        }
+        return iosCredentials;
+    }
+    async getRemoteAsync() {
+        return await new SetUpBuildCredentials_1.SetUpBuildCredentials({
+            app: this.options.app,
+            targets: this.options.targets,
+            distribution: this.options.distribution,
+            enterpriseProvisioning: this.options.enterpriseProvisioning,
+        }).runAsync(this.ctx);
+    }
+    async getPushKeyAsync(ctx, targets) {
+        if (ctx.nonInteractive) {
+            return null;
+        }
+        const applicationTarget = (0, target_1.findApplicationTarget)(targets);
+        const app = await (0, BuildCredentialsUtils_1.getAppFromContextAsync)(ctx);
+        const appLookupParams = {
+            ...app,
+            bundleIdentifier: applicationTarget.bundleIdentifier,
+            parentBundleIdentifier: applicationTarget.parentBundleIdentifier,
+        };
+        const setupPushKeyAction = new SetUpPushKey_1.SetUpPushKey(appLookupParams);
+        const isPushKeySetup = await setupPushKeyAction.isPushKeySetupAsync(ctx);
+        if (isPushKeySetup) {
+            log_1.default.succeed(`Push Notifications are set up`);
+            return null;
+        }
+        if (ctx.easJsonCliConfig?.promptToConfigurePushNotifications === false) {
+            return null;
+        }
+        else if (ctx.easJsonCliConfig?.promptToConfigurePushNotifications === undefined &&
+            !(0, projectUtils_1.isExpoNotificationsInstalled)(ctx.projectDir)) {
+            return null;
+        }
+        const setupOption = await (0, prompts_1.selectAsync)(`Would you like to set up Push Notifications for your project?`, [
+            { title: 'Yes', value: PushNotificationSetupOption.YES },
+            { title: 'No', value: PushNotificationSetupOption.NO },
+            {
+                title: `No, don't ask again (preference will be saved to eas.json)`,
+                value: PushNotificationSetupOption.NO_DONT_ASK_AGAIN,
+            },
+        ]);
+        if (setupOption === PushNotificationSetupOption.YES) {
+            return await setupPushKeyAction.runAsync(ctx);
+        }
+        else {
+            if (setupOption === PushNotificationSetupOption.NO_DONT_ASK_AGAIN) {
+                await this.disablePushNotificationsSetupInEasJsonAsync(ctx);
+            }
+            return null;
+        }
+    }
+    async disablePushNotificationsSetupInEasJsonAsync(ctx) {
+        const easJsonAccessor = eas_json_1.EasJsonAccessor.fromProjectPath(ctx.projectDir);
+        await easJsonAccessor.readRawJsonAsync();
+        easJsonAccessor.patch(easJsonRawObject => {
+            easJsonRawObject.cli = {
+                ...easJsonRawObject?.cli,
+                promptToConfigurePushNotifications: false,
+            };
+            return easJsonRawObject;
+        });
+        await easJsonAccessor.writeAsync();
+        log_1.default.withTick('Updated eas.json');
+    }
+    assertProvisioningProfileType(provisioningProfile, targetName) {
+        const isAdHoc = (0, provisioningProfile_1.isAdHocProfile)(provisioningProfile);
+        const isEnterprise = (0, provisioningProfile_1.isEnterpriseUniversalProfile)(provisioningProfile);
+        if (this.options.distribution === 'internal') {
+            if (this.options.enterpriseProvisioning === 'universal' && !isEnterprise) {
+                throw new Error(`You must use a universal provisioning profile${targetName ? ` (target '${targetName})'` : ''} for internal distribution if you specified "enterpriseProvisioning": "universal" in eas.json`);
+            }
+            else if (this.options.enterpriseProvisioning === 'adhoc' && !isAdHoc) {
+                throw new Error(`You must use an adhoc provisioning profile${targetName ? ` (target '${targetName})'` : ''} for internal distribution if you specified "enterpriseProvisioning": "adhoc" in eas.json`);
+            }
+            else if (!this.options.enterpriseProvisioning && !isEnterprise && !isAdHoc) {
+                throw new Error(`You must use an adhoc provisioning profile${targetName ? ` (target '${targetName})'` : ''} for internal distribution.`);
+            }
+        }
+        else if (isAdHoc) {
+            throw new Error(`You can't use an adhoc provisioning profile${targetName ? ` (target '${targetName}')` : ''} for app store distribution.`);
+        }
+    }
+}
+exports.default = IosCredentialsProvider;

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

@@ -0,0 +1,2 @@
+import { AppleTeamFragment } from '../../../graphql/generated';
+export declare function formatAppleTeam({ appleTeamIdentifier, appleTeamName, }: Pick<AppleTeamFragment, 'appleTeamIdentifier' | 'appleTeamName'>): string;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatAppleTeam = formatAppleTeam;
+function formatAppleTeam({ appleTeamIdentifier, appleTeamName, }) {
+    return `Team ID: ${appleTeamIdentifier}${appleTeamName ? `, Team name: ${appleTeamName}` : ''}`;
+}

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

@@ -0,0 +1,4 @@
+import { AppleTeamFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AppLookupParams } from '../api/graphql/types/AppLookupParams';
+export declare function resolveAppleTeamIfAuthenticatedAsync(ctx: CredentialsContext, app: AppLookupParams): Promise<AppleTeamFragment | null>;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAppleTeamIfAuthenticatedAsync = resolveAppleTeamIfAuthenticatedAsync;
+async function resolveAppleTeamIfAuthenticatedAsync(ctx, app) {
+    if (!ctx.appStore.authCtx) {
+        return null;
+    }
+    return await ctx.ios.createOrGetExistingAppleTeamAndUpdateNameIfChangedAsync(ctx.graphqlClient, app.account.id, {
+        appleTeamIdentifier: ctx.appStore.authCtx.team.id,
+        appleTeamName: ctx.appStore.authCtx.team.name,
+    });
+}

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

@@ -0,0 +1,20 @@
+import { AccountFragment, AppStoreConnectApiKeyFragment } from '../../../graphql/generated';
+import { CredentialsContext } from '../../context';
+import { AscApiKey } from '../appstore/Credentials.types';
+import { AscApiKeyPath, MinimalAscApiKey } from '../credentials';
+export declare enum AppStoreApiKeyPurpose {
+    SUBMISSION_SERVICE = "EAS Submit"
+}
+export declare function promptForAscApiKeyPathAsync(ctx: CredentialsContext): Promise<AscApiKeyPath>;
+export declare function promptForIssuerIdAsync(): Promise<string>;
+export declare function getMinimalAscApiKeyAsync(ascApiKey: AscApiKey): Promise<MinimalAscApiKey>;
+export declare function provideOrGenerateAscApiKeyAsync(ctx: CredentialsContext, purpose: AppStoreApiKeyPurpose): Promise<MinimalAscApiKey>;
+export declare function getAscApiKeyName(purpose: AppStoreApiKeyPurpose): string;
+export declare function getAscApiKeysFromAccountAsync(ctx: CredentialsContext, account: AccountFragment, { filterDifferentAppleTeam }?: {
+    filterDifferentAppleTeam?: boolean;
+}): Promise<AppStoreConnectApiKeyFragment[]>;
+export declare function selectAscApiKeysFromAccountAsync(ctx: CredentialsContext, account: AccountFragment, { filterDifferentAppleTeam }?: {
+    filterDifferentAppleTeam?: boolean;
+}): Promise<AppStoreConnectApiKeyFragment | null>;
+export declare function sortAscApiKeysByUpdatedAtDesc(keys: AppStoreConnectApiKeyFragment[]): AppStoreConnectApiKeyFragment[];
+export declare function formatAscApiKey(ascApiKey: AppStoreConnectApiKeyFragment): string;