@donotuse/eas-cli 18.5.0-rc.1

package/build/credentials/ios/appstore/contractMessages.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatContractMessage = formatContractMessage;
+exports.assertContractMessagesAsync = assertContractMessagesAsync;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const convertHTMLToASCII_1 = require("../utils/convertHTMLToASCII");
+/**
+ * **Does not support App Store Connect API (CI).**
+ */
+async function getContractStatusAsync(context) {
+    try {
+        const capabilities = await apple_utils_1.ITCAgreements.getCapabilitiesAsync(context);
+        return capabilities?.contractStatus ?? null;
+    }
+    catch (error) {
+        log_1.default.warn(`Failed to get iTunes contract status: ${error.message}`);
+        return null;
+    }
+}
+/**
+ * **Does not support App Store Connect API (CI).**
+ */
+async function getContractMessagesAsync(context) {
+    try {
+        return await apple_utils_1.ITCAgreements.getContractMessagesAsync(context);
+    }
+    catch (error) {
+        log_1.default.warn(`Failed to get iTunes contract messages: ${error.message}`);
+        return null;
+    }
+}
+/**
+ * **Does not support App Store Connect API (CI).**
+ */
+async function getRequiredContractMessagesAsync(context) {
+    // This emulates the check that's performed on the ASC website's "apps"
+    // page before presenting the (+) create app button.
+    const status = await getContractStatusAsync(context);
+    if (status) {
+        if (['FREE_APP_AGREEMENT_ACTIVE', 'PAID_APP_AGREEMENT_ACTIVE'].includes(status)) {
+            // The user can freely create an app, no contracts need to be accepted.
+            // No need to check for messages because afaict no vital messages will be present.
+            return { messages: [], isFatal: false };
+        }
+        else if (['FREE_APP_AGREEMENT_OUTDATED', 'PAID_APP_AGREEMENT_OUTDATED', 'EXPIRED_MEMBERSHIP'].includes(status)) {
+            // The user cannot create an app until they've reviewed, and agreed to the updated agreements
+            // or renewed their membership on ASC.
+            // Get the exact messages from ASC to show the user a useful message.
+            return { messages: (await getContractMessagesAsync(context)) ?? [], isFatal: true };
+        }
+    }
+    // The contract messages aren't documented so if a new one is present we cannot be sure if it's fatal or not.
+    // This will check for messages, if none exist, then the process will continue.
+    // Otherwise messages will be present and the process will stop.
+    // There is a small chance that this could result in a false positive if the messages are extraneous, so we'll also
+    // prompt the user to open an issue so we can address the new contract state if it ever appears.
+    // TODO: Maybe a silent analytic would be better
+    log_1.default.error(`\nUnexpected Apple developer contract status "${status}". Open an issue on https://github.com/expo/eas-cli`);
+    log_1.default.newLine();
+    return { messages: (await getContractMessagesAsync(context)) ?? [], isFatal: false };
+}
+const rootUrl = 'https://appstoreconnect.apple.com';
+function formatContractMessage(message) {
+    return (0, convertHTMLToASCII_1.convertHTMLToASCII)({
+        content: '\u203A ' +
+            [message.subject && `<b>${message.subject}</b>`, message.message]
+                .filter(Boolean)
+                .join('<br />'),
+        rootUrl,
+    });
+}
+/**
+ * **Does not support App Store Connect API (CI).**
+ */
+async function assertContractMessagesAsync(context, spinner) {
+    const { messages, isFatal } = await getRequiredContractMessagesAsync(context);
+    if (Array.isArray(messages) && messages.length) {
+        if (spinner) {
+            spinner.stop();
+        }
+        log_1.default.newLine();
+        log_1.default.log(chalk_1.default.yellow.bold('Messages from App Store Connect:'));
+        log_1.default.newLine();
+        for (const message of messages) {
+            if (log_1.default.isDebug) {
+                log_1.default.log(JSON.stringify(message, null, 2));
+                log_1.default.newLine();
+            }
+            log_1.default.addNewLineIfNone();
+            log_1.default.log(formatContractMessage(message));
+        }
+        log_1.default.addNewLineIfNone();
+        // Only throw an error if we know that the status is fatal, otherwise attempt to finish the process.
+        if (isFatal) {
+            throw new Error('App Store Connect has agreement updates that must be resolved');
+        }
+    }
+}

package/build/credentials/ios/appstore/distributionCertificate.d.ts

@@ -0,0 +1,14 @@
+import { Certificate, RequestContext } from '@expo/apple-utils';
+import { DistributionCertificate, DistributionCertificateStoreInfo } from './Credentials.types';
+import { AuthCtx } from './authenticateTypes';
+export declare class AppleTooManyCertsError extends Error {
+}
+export declare function getCertificateBySerialNumberAsync(context: RequestContext, serialNumber: string): Promise<Certificate>;
+export declare function getDistributionCertificateAsync(context: RequestContext, serialNumber: string): Promise<Certificate | null>;
+export declare function transformCertificate(cert: Certificate): DistributionCertificateStoreInfo;
+export declare function listDistributionCertificatesAsync(authCtx: AuthCtx): Promise<DistributionCertificateStoreInfo[]>;
+/**
+ * Run from `eas credentials` -> iOS -> Add new Distribution Certificate
+ */
+export declare function createDistributionCertificateAsync(authCtx: AuthCtx): Promise<DistributionCertificate>;
+export declare function revokeDistributionCertificateAsync(authCtx: AuthCtx, ids: string[]): Promise<void>;

package/build/credentials/ios/appstore/distributionCertificate.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppleTooManyCertsError = void 0;
+exports.getCertificateBySerialNumberAsync = getCertificateBySerialNumberAsync;
+exports.getDistributionCertificateAsync = getDistributionCertificateAsync;
+exports.transformCertificate = transformCertificate;
+exports.listDistributionCertificatesAsync = listDistributionCertificatesAsync;
+exports.createDistributionCertificateAsync = createDistributionCertificateAsync;
+exports.revokeDistributionCertificateAsync = revokeDistributionCertificateAsync;
+const apple_utils_1 = require("@expo/apple-utils");
+const authenticate_1 = require("./authenticate");
+const ora_1 = require("../../../ora");
+class AppleTooManyCertsError extends Error {
+}
+exports.AppleTooManyCertsError = AppleTooManyCertsError;
+async function getCertificateBySerialNumberAsync(context, serialNumber) {
+    const cert = (await apple_utils_1.Certificate.getAsync(context)).find(item => item.attributes.serialNumber === serialNumber);
+    if (!cert) {
+        throw new Error(`No certificate exists with serial number "${serialNumber}"`);
+    }
+    return cert;
+}
+async function getDistributionCertificateAsync(context, serialNumber) {
+    // At most, this returns 2 values.
+    const certificates = await apple_utils_1.Certificate.getAsync(context, {
+        query: {
+            filter: {
+                certificateType: [apple_utils_1.CertificateType.IOS_DISTRIBUTION, apple_utils_1.CertificateType.DISTRIBUTION],
+            },
+        },
+    });
+    return (certificates.find(certificate => certificate.attributes.serialNumber === serialNumber) ?? null);
+}
+function transformCertificate(cert) {
+    return {
+        id: cert.id,
+        name: cert.attributes.name,
+        status: cert.attributes.status,
+        created: new Date(cert.attributes.requestedDate).getTime() / 1000,
+        expires: new Date(cert.attributes.expirationDate).getTime() / 1000,
+        ownerName: cert.attributes.ownerName,
+        ownerId: cert.attributes.ownerId,
+        serialNumber: cert.attributes.serialNumber,
+    };
+}
+async function listDistributionCertificatesAsync(authCtx) {
+    const spinner = (0, ora_1.ora)(`Fetching Apple distribution certificates`).start();
+    try {
+        const context = (0, authenticate_1.getRequestContext)(authCtx);
+        const certs = (await apple_utils_1.Certificate.getAsync(context, {
+            query: {
+                filter: {
+                    certificateType: [
+                        apple_utils_1.CertificateType.DISTRIBUTION,
+                        apple_utils_1.CertificateType.IOS_DISTRIBUTION,
+                        apple_utils_1.CertificateType.MAC_APP_DISTRIBUTION,
+                    ],
+                },
+            },
+        })).map(transformCertificate);
+        spinner.succeed(`Fetched Apple distribution certificates`);
+        return certs;
+    }
+    catch (error) {
+        spinner.fail(`Failed to fetch Apple distribution certificates`);
+        throw error;
+    }
+}
+/**
+ * Run from `eas credentials` -> iOS -> Add new Distribution Certificate
+ */
+async function createDistributionCertificateAsync(authCtx) {
+    const spinner = (0, ora_1.ora)(`Creating Apple distribution certificate`).start();
+    try {
+        const context = (0, authenticate_1.getRequestContext)(authCtx);
+        const results = await (0, apple_utils_1.createCertificateAndP12Async)(context, {
+            certificateType: apple_utils_1.CertificateType.IOS_DISTRIBUTION,
+        });
+        spinner.succeed(`Created Apple distribution certificate`);
+        return {
+            certId: results.certificate.id,
+            certP12: results.certificateP12,
+            certPassword: results.password,
+            certPrivateSigningKey: results.privateSigningKey,
+            distCertSerialNumber: results.certificate.attributes.serialNumber,
+            teamId: authCtx.team.id,
+            teamName: authCtx.team.name,
+        };
+    }
+    catch (error) {
+        spinner.fail('Failed to create Apple distribution certificate');
+        // TODO: Move check into apple-utils
+        if (/You already have a current .* certificate or a pending certificate request/.test(error.message)) {
+            throw new AppleTooManyCertsError('Maximum number of certificates generated');
+        }
+        throw error;
+    }
+}
+async function revokeDistributionCertificateAsync(authCtx, ids) {
+    const name = `Apple distribution certificate${ids?.length === 1 ? '' : 's'}`;
+    const spinner = (0, ora_1.ora)(`Revoking ${name}`).start();
+    try {
+        const context = (0, authenticate_1.getRequestContext)(authCtx);
+        await Promise.all(ids.map(id => apple_utils_1.Certificate.deleteAsync(context, { id })));
+        spinner.succeed(`Revoked ${name}`);
+    }
+    catch (error) {
+        spinner.fail(`Failed to revoke ${name}`);
+        throw error;
+    }
+}

package/build/credentials/ios/appstore/ensureAppExists.d.ts

@@ -0,0 +1,53 @@
+import { App, BundleId, RequestContext } from '@expo/apple-utils';
+import { JSONObject } from '@expo/json-file';
+import { AuthCtx, UserAuthCtx } from './authenticateTypes';
+export interface IosCapabilitiesOptions {
+    entitlements: JSONObject;
+    usesBroadcastPushNotifications: boolean;
+    /**
+     * The bundle identifier of the parent app. Required for App Clips.
+     * App Clips are detected by the presence of the
+     * `com.apple.developer.parent-application-identifiers` entitlement.
+     */
+    parentBundleIdentifier?: string;
+}
+export interface AppLookupParams {
+    accountName: string;
+    projectName: string;
+    bundleIdentifier: string;
+}
+export declare function ensureBundleIdExistsAsync(authCtx: AuthCtx, { accountName, projectName, bundleIdentifier }: AppLookupParams, options?: IosCapabilitiesOptions): Promise<void>;
+export declare function ensureBundleIdExistsWithNameAsync(authCtx: AuthCtx, { name, bundleIdentifier }: {
+    name: string;
+    bundleIdentifier: string;
+}, options?: IosCapabilitiesOptions): Promise<void>;
+export declare function syncCapabilitiesAsync(bundleId: BundleId, { entitlements, ...rest }: IosCapabilitiesOptions): Promise<void>;
+export declare function syncCapabilityIdentifiersAsync(bundleId: BundleId, { entitlements }: IosCapabilitiesOptions): Promise<void>;
+export declare function ensureAppExistsAsync(userAuthCtx: UserAuthCtx, { name, language, companyName, bundleIdentifier, sku, }: {
+    name: string;
+    language?: string;
+    companyName?: string;
+    bundleIdentifier: string;
+    sku?: string;
+}): Promise<App>;
+export declare function createAppAsync(context: RequestContext, props: {
+    bundleId: string;
+    name: string;
+    primaryLocale?: string;
+    companyName?: string;
+    sku?: string;
+}, retryCount?: number): Promise<App>;
+export declare function isAppleError(error: any): error is {
+    data: {
+        errors: {
+            id: string;
+            status: string;
+            /** 'ENTITY_ERROR.ATTRIBUTE.INVALID.INVALID_CHARACTERS' */
+            code: string;
+            /** 'An attribute value has invalid characters.' */
+            title: string;
+            /** 'App Name contains certain Unicode symbols, emoticons, diacritics, special characters, or private use characters that are not permitted.' */
+            detail: string;
+        }[];
+    };
+};

package/build/credentials/ios/appstore/ensureAppExists.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureBundleIdExistsAsync = ensureBundleIdExistsAsync;
+exports.ensureBundleIdExistsWithNameAsync = ensureBundleIdExistsWithNameAsync;
+exports.syncCapabilitiesAsync = syncCapabilitiesAsync;
+exports.syncCapabilityIdentifiersAsync = syncCapabilityIdentifiersAsync;
+exports.ensureAppExistsAsync = ensureAppExistsAsync;
+exports.createAppAsync = createAppAsync;
+exports.isAppleError = isAppleError;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const node_crypto_1 = require("node:crypto");
+const authenticate_1 = require("./authenticate");
+const bundleIdCapabilities_1 = require("./bundleIdCapabilities");
+const capabilityIdentifiers_1 = require("./capabilityIdentifiers");
+const contractMessages_1 = require("./contractMessages");
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const ora_1 = require("../../../ora");
+/**
+ * The entitlement key that indicates a target is an App Clip.
+ * When present, the target requires special bundle ID registration with a parent app relationship.
+ */
+const APP_CLIP_PARENT_APPLICATION_IDENTIFIERS_ENTITLEMENT = 'com.apple.developer.parent-application-identifiers';
+async function ensureBundleIdExistsAsync(authCtx, { accountName, projectName, bundleIdentifier }, options) {
+    await ensureBundleIdExistsWithNameAsync(authCtx, {
+        name: `@${accountName}/${projectName}`,
+        bundleIdentifier,
+    }, options);
+}
+async function ensureBundleIdExistsWithNameAsync(authCtx, { name, bundleIdentifier }, options) {
+    const context = (0, authenticate_1.getRequestContext)(authCtx);
+    // Detect App Clips by the presence of the parent-application-identifiers entitlement
+    const isAppClip = Boolean(options?.entitlements?.[APP_CLIP_PARENT_APPLICATION_IDENTIFIERS_ENTITLEMENT]);
+    const typeLabel = isAppClip ? 'App Clip bundle identifier' : 'bundle identifier';
+    const spinner = (0, ora_1.ora)(`Linking ${typeLabel} ${chalk_1.default.dim(bundleIdentifier)}`).start();
+    let bundleId;
+    try {
+        // Get the bundle id
+        bundleId = await apple_utils_1.BundleId.findAsync(context, { identifier: bundleIdentifier });
+        if (!bundleId) {
+            spinner.text = `Registering ${typeLabel} ${chalk_1.default.dim(bundleIdentifier)}`;
+            if (isAppClip && options?.parentBundleIdentifier) {
+                // App Clips require the parent bundle ID's opaque ID
+                bundleId = await createAppClipBundleIdAsync(context, {
+                    name,
+                    bundleIdentifier,
+                    parentBundleIdentifier: options.parentBundleIdentifier,
+                });
+            }
+            else {
+                // If it doesn't exist, create it
+                bundleId = await apple_utils_1.BundleId.createAsync(context, {
+                    name,
+                    identifier: bundleIdentifier,
+                });
+            }
+        }
+        spinner.succeed(`${isAppClip ? 'App Clip bundle' : 'Bundle'} identifier registered ${chalk_1.default.dim(bundleIdentifier)}`);
+    }
+    catch (err) {
+        if (err.message.match(/An App ID with Identifier '(.*)' is not available/)) {
+            spinner.fail(`The ${typeLabel} ${chalk_1.default.bold(bundleIdentifier)} is not available to team "${authCtx.team.name}" (${authCtx.team.id}), change it in your app config and try again.`);
+        }
+        else {
+            spinner.fail(`Failed to register ${typeLabel} ${chalk_1.default.dim(bundleIdentifier)}`);
+            // Assert contract errors for easier resolution when the user has an expired developer account.
+            if (err.message.match(/forbidden for security reasons/) ||
+                // Unable to process request - PLA Update available - You currently don't have access to this membership resource. To resolve this issue, agree to the latest Program License Agreement in your developer account.
+                err.message.match(/agree/)) {
+                if ((0, authenticate_1.isUserAuthCtx)(authCtx)) {
+                    await (0, contractMessages_1.assertContractMessagesAsync)(context);
+                }
+                else {
+                    log_1.default.warn(`You currently don't have access to this membership resource. To resolve this issue, agree to the latest Program License Agreement in your developer account.`);
+                }
+            }
+        }
+        throw err;
+    }
+    if (options) {
+        await syncCapabilitiesAsync(bundleId, options);
+    }
+}
+/**
+ * Creates an App Clip bundle identifier.
+ * App Clips require the parent bundle ID's opaque ID for registration.
+ */
+async function createAppClipBundleIdAsync(context, { name, bundleIdentifier, parentBundleIdentifier, }) {
+    // First, find the parent bundle ID to get its opaque ID
+    const parentBundleId = await apple_utils_1.BundleId.findAsync(context, {
+        identifier: parentBundleIdentifier,
+    });
+    if (!parentBundleId) {
+        throw new Error(`Cannot create App Clip bundle identifier "${bundleIdentifier}" because the parent bundle identifier "${parentBundleIdentifier}" is not registered. ` +
+            `Please ensure the parent app's bundle identifier is registered first.`);
+    }
+    // Create the App Clip bundle ID with the parent relationship
+    return await apple_utils_1.BundleId.createAppClipAsync(context, {
+        name,
+        identifier: bundleIdentifier,
+        parentBundleIdId: parentBundleId.id,
+    });
+}
+async function syncCapabilitiesAsync(bundleId, { entitlements, ...rest }) {
+    const spinner = (0, ora_1.ora)(`Syncing capabilities`).start();
+    // Stop spinning in debug mode so we can print other information
+    if (log_1.default.isDebug) {
+        spinner.stop();
+    }
+    try {
+        const { enabled, disabled } = await (0, bundleIdCapabilities_1.syncCapabilitiesForEntitlementsAsync)(bundleId, entitlements, rest);
+        const results = [buildMessage('Enabled', enabled), buildMessage('Disabled', disabled)]
+            .filter(Boolean)
+            .join(' | ') || 'No updates';
+        spinner.succeed(`Synced capabilities: ` + chalk_1.default.dim(results));
+    }
+    catch (err) {
+        spinner.fail(`Failed to sync capabilities ${chalk_1.default.dim(bundleId.attributes.identifier)}`);
+        throw err;
+    }
+    // Always run this after syncing the capabilities...
+    await syncCapabilityIdentifiersAsync(bundleId, { entitlements, ...rest });
+}
+const buildMessage = (title, items) => items.length ? `${title}: ${items.join(', ')}` : '';
+async function syncCapabilityIdentifiersAsync(bundleId, { entitlements }) {
+    const spinner = (0, ora_1.ora)(`Syncing capabilities identifiers`).start();
+    // Stop spinning in debug mode so we can print other information
+    if (log_1.default.isDebug) {
+        spinner.stop();
+    }
+    try {
+        const { created, linked } = await (0, capabilityIdentifiers_1.syncCapabilityIdentifiersForEntitlementsAsync)(bundleId, entitlements);
+        const results = [buildMessage('Created', created), buildMessage('Linked', linked)]
+            .filter(Boolean)
+            .join(' | ') || 'No updates';
+        spinner.succeed(`Synced capability identifiers: ` + chalk_1.default.dim(results));
+    }
+    catch (err) {
+        spinner.fail(`Failed to sync capability identifiers ${chalk_1.default.dim(bundleId.attributes.identifier)}`);
+        throw err;
+    }
+}
+async function ensureAppExistsAsync(userAuthCtx, { name, language, companyName, bundleIdentifier, sku, }) {
+    const context = (0, authenticate_1.getRequestContext)(userAuthCtx);
+    const spinner = (0, ora_1.ora)(`Linking to App Store Connect ${chalk_1.default.dim(bundleIdentifier)}`).start();
+    let app = await apple_utils_1.App.findAsync(context, { bundleId: bundleIdentifier });
+    if (!app) {
+        spinner.text = `Creating App Store Connect app ${chalk_1.default.bold(name)} ${chalk_1.default.dim(bundleIdentifier)}`;
+        try {
+            // Assert contract errors when the user needs to create an app.
+            await (0, contractMessages_1.assertContractMessagesAsync)(context, spinner);
+            /**
+             * **Does not support App Store Connect API (CI).**
+             */
+            app = await createAppAsync(context, {
+                bundleId: bundleIdentifier,
+                name,
+                primaryLocale: language,
+                companyName,
+                sku,
+            });
+        }
+        catch (error) {
+            if (error.message.match(/An App ID with Identifier '(.*)' is not available/)) {
+                throw new Error(`\nThe bundle identifier "${bundleIdentifier}" is not available to provider "${userAuthCtx.authState?.session.provider.name}. Change it in your app config and try again.\n`);
+            }
+            spinner.fail(`Failed to create App Store app ${chalk_1.default.dim(name)}`);
+            error.message +=
+                '\nVisit https://appstoreconnect.apple.com and resolve any warnings, then try again.';
+            throw error;
+        }
+    }
+    else {
+        // TODO: Update app name when API gives us that possibility
+    }
+    spinner.succeed(`Prepared App Store Connect for ${chalk_1.default.bold(name)} ${chalk_1.default.dim(bundleIdentifier)}`);
+    return app;
+}
+function sanitizeName(name) {
+    return (name
+        // Replace emojis with a `-`
+        .replace(/[\p{Emoji}]/gu, '-')
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .trim());
+}
+async function createAppAsync(context, props, retryCount = 0) {
+    try {
+        /**
+         * **Does not support App Store Connect API (CI).**
+         */
+        return await apple_utils_1.App.createAsync(context, props);
+    }
+    catch (error) {
+        if (retryCount >= 5) {
+            throw error;
+        }
+        if (error instanceof Error) {
+            const handleDuplicateNameErrorAsync = async () => {
+                const generatedName = props.name + ` (${(0, node_crypto_1.randomBytes)(3).toString('hex')})`;
+                log_1.default.warn(`App name "${props.name}" is already taken. Using generated name "${generatedName}" which can be changed later from https://appstoreconnect.apple.com.`);
+                // Sanitize the name and try again.
+                return await createAppAsync(context, {
+                    ...props,
+                    name: generatedName,
+                }, retryCount + 1);
+            };
+            if (isAppleError(error)) {
+                // New error class that is thrown when the name is already taken but belongs to you.
+                if (error.data.errors.some(e => e.code === 'ENTITY_ERROR.ATTRIBUTE.INVALID.DUPLICATE.SAME_ACCOUNT' ||
+                    e.code === 'ENTITY_ERROR.ATTRIBUTE.INVALID.DUPLICATE.DIFFERENT_ACCOUNT')) {
+                    return await handleDuplicateNameErrorAsync();
+                }
+            }
+            if ('code' in error && typeof error.code === 'string') {
+                if (
+                // Name is invalid
+                error.code === 'APP_CREATE_NAME_INVALID'
+                // UnexpectedAppleResponse: An attribute value has invalid characters. - App Name contains certain Unicode symbols, emoticons, diacritics, special characters, or private use characters that are not permitted.
+                // Name is taken
+                ) {
+                    const sanitizedName = sanitizeName(props.name);
+                    if (sanitizedName === props.name) {
+                        throw error;
+                    }
+                    log_1.default.warn(`App name "${props.name}" contains invalid characters. Using sanitized name "${sanitizedName}" which can be changed later from https://appstoreconnect.apple.com.`);
+                    // Sanitize the name and try again.
+                    return await createAppAsync(context, {
+                        ...props,
+                        name: sanitizedName,
+                    }, retryCount + 1);
+                }
+                if (
+                // UnexpectedAppleResponse: The provided entity includes an attribute with a value that has already been used on a different account. - The App Name you entered is already being used. If you have trademark rights to
+                // this name and would like it released for your use, submit a claim.
+                error.code === 'APP_CREATE_NAME_UNAVAILABLE') {
+                    return await handleDuplicateNameErrorAsync();
+                }
+            }
+        }
+        throw error;
+    }
+}
+function isAppleError(error) {
+    return 'data' in error && 'errors' in error.data && Array.isArray(error.data.errors);
+}

package/build/credentials/ios/appstore/ensureTestFlightGroup.d.ts

@@ -0,0 +1,6 @@
+import { App } from '@expo/apple-utils';
+/**
+ * Ensure a TestFlight internal group with access to all builds exists for the app and has all admin users invited to it.
+ * This allows users to instantly access their builds from TestFlight after it finishes processing.
+ */
+export declare function ensureTestFlightGroupExistsAsync(app: App): Promise<void>;