@expo/build-tools 18.0.6 → 18.2.0

package/dist/buildErrors/buildErrorHandlers.d.ts

@@ -2,6 +2,7 @@ import { ErrorHandler } from './errors.types';
 export declare class TrackedBuildError extends Error {
     errorCode: string;
     message: string;
-    constructor(errorCode: string, message: string);
+    metadata?: Record<string, unknown> | undefined;
+    constructor(errorCode: string, message: string, metadata?: Record<string, unknown> | undefined);
 }
 export declare const buildErrorHandlers: ErrorHandler<TrackedBuildError>[];

package/dist/buildErrors/buildErrorHandlers.js

@@ -9,10 +9,12 @@ const escapeRegExp_1 = __importDefault(require("lodash/escapeRegExp"));
 class TrackedBuildError extends Error {
     errorCode;
     message;
-    constructor(errorCode, message) {
+    metadata;
+    constructor(errorCode, message, metadata) {
         super(message);
         this.errorCode = errorCode;
         this.message = message;
+        this.metadata = metadata;
     }
 }
 exports.TrackedBuildError = TrackedBuildError;
@@ -130,7 +132,9 @@ exports.buildErrorHandlers = [
         // example log:
         // [stderr] WARN tarball tarball data for @typescript-eslint/typescript-estree@5.26.0 (sha512-cozo/GbwixVR0sgfHItz3t1yXu521yn71Wj6PlYCFA3WPhy51CUPkifFKfBis91bDclGmAY45hhaAXVjdn4new==) seems to be corrupted. Trying again.
         regexp: /tarball tarball data for ([^ ]*) .* seems to be corrupted. Trying again/,
-        createError: (match) => new TrackedBuildError('NPM_CORRUPTED_PACKAGE', `npm: corrupted package ${match[1]}`),
+        createError: (match) => new TrackedBuildError('NPM_CORRUPTED_PACKAGE', `npm: corrupted package ${match[1]}`, {
+            packageName: match[1],
+        }),
     })),
     ...[eas_build_job_1.BuildPhase.INSTALL_DEPENDENCIES, eas_build_job_1.BuildPhase.PREBUILD].map(phase => ({
         phase,

package/dist/buildErrors/detectError.js

@@ -58,21 +58,15 @@ async function resolveBuildPhaseErrorAsync(error, logLines, errorContext, buildL
         : (resolveError(userErrorHandlers_1.userErrorHandlers, logLines, errorContext, xcodeBuildLogs) ??
             new eas_build_job_1.errors.UnknownError(errorContext.phase));
     const buildError = resolveError(buildErrorHandlers_1.buildErrorHandlers, logLines, errorContext, xcodeBuildLogs);
-    const isUnknownUserError = !userFacingError ||
-        [
-            eas_build_job_1.errors.ErrorCode.UNKNOWN_ERROR,
-            eas_build_job_1.errors.ErrorCode.UNKNOWN_GRADLE_ERROR,
-            eas_build_job_1.errors.ErrorCode.UNKNOWN_FASTLANE_ERROR,
-        ].includes(userFacingError.errorCode);
-    const message = (isUnknownUserError ? buildError?.message : userFacingError.message) ?? userFacingError.message;
-    const errorCode = (isUnknownUserError ? buildError?.errorCode : userFacingError.errorCode) ??
-        userFacingError.errorCode;
-    return new eas_build_job_1.errors.BuildError(message, {
-        errorCode,
-        userFacingErrorCode: userFacingError.errorCode,
-        userFacingMessage: userFacingError.message,
+    const trackingCode = buildError && buildError.errorCode !== userFacingError.errorCode
+        ? buildError.errorCode
+        : undefined;
+    return new eas_build_job_1.errors.BuildError(userFacingError.message, {
+        errorCode: userFacingError.errorCode,
+        trackingCode,
         docsUrl: userFacingError.docsUrl,
-        innerError: error,
+        cause: error,
         buildPhase: phase,
+        metadata: buildError?.metadata,
     });
 }

package/dist/common/installDependencies.js

@@ -13,7 +13,8 @@ async function installDependenciesAsync({ packageManager, env, logger, infoCallb
     let args;
     switch (packageManager) {
         case packageManager_1.PackageManager.NPM: {
-            args = useFrozenLockfile ? ['ci', '--include=dev'] : ['install'];
+            args = useFrozenLockfile ? ['ci'] : ['install'];
+            args.push('--include=dev');
             break;
         }
         case packageManager_1.PackageManager.PNPM: {
@@ -35,7 +36,12 @@ async function installDependenciesAsync({ packageManager, env, logger, infoCallb
                 }
             }
             else {
-                args = ['install', ...(useFrozenLockfile ? ['--frozen-lockfile'] : [])];
+                args = [
+                    'install',
+                    ...(useFrozenLockfile ? ['--frozen-lockfile'] : []),
+                    '--production',
+                    'false',
+                ];
             }
             break;
         }

package/dist/context.js

@@ -197,7 +197,7 @@ class BuildContext {
             this.logger.error({ err }, '');
         }
         else {
-            this.logger.error(`Error: ${buildError.userFacingMessage}`);
+            this.logger.error(`Error: ${buildError.message}`);
         }
         return buildError;
     }

package/dist/steps/functions/internalMaestroTest.js

@@ -18,6 +18,7 @@ const zod_1 = require("zod");
 const AndroidEmulatorUtils_1 = require("../../utils/AndroidEmulatorUtils");
 const IosSimulatorUtils_1 = require("../../utils/IosSimulatorUtils");
 const findMaestroPathsFlowsToExecuteAsync_1 = require("../../utils/findMaestroPathsFlowsToExecuteAsync");
+const retry_1 = require("../../utils/retry");
 const strings_1 = require("../../utils/strings");
 function createInternalEasMaestroTestFunction(ctx) {
     return new steps_1.BuildFunction({
@@ -344,9 +345,11 @@ const MaestroOutputFormatToExtensionMap = {
     junit: 'xml',
     html: 'html',
 };
+const ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS = [60_000, 120_000, 180_000];
+const ANDROID_STARTUP_RETRIES_COUNT = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS.length - 1;
 async function withCleanDeviceAsync({ platform, sourceDeviceIdentifier, localDeviceName, env, logger, fn, }) {
     // Clone and start the device
-    let localDeviceIdentifier;
+    let localDeviceIdentifier = null;
     switch (platform) {
         case 'ios': {
             logger.info(`Cloning iOS Simulator ${sourceDeviceIdentifier} to ${localDeviceName}...`);
@@ -369,27 +372,69 @@ async function withCleanDeviceAsync({ platform, sourceDeviceIdentifier, localDev
             break;
         }
         case 'android': {
-            logger.info(`Cloning Android Emulator ${sourceDeviceIdentifier} to ${localDeviceName}...`);
-            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.cloneAsync({
-                sourceDeviceName: sourceDeviceIdentifier,
-                destinationDeviceName: localDeviceName,
-                env,
+            await (0, retry_1.retryAsync)(async (attemptCount) => {
+                const timeoutMs = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS[attemptCount];
+                const attempt = attemptCount + 1;
+                const maxAttempts = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS.length;
+                let serialId = null;
+                try {
+                    logger.info(`Cloning Android Emulator ${sourceDeviceIdentifier} to ${localDeviceName} (attempt ${attempt}/${maxAttempts})...`);
+                    await AndroidEmulatorUtils_1.AndroidEmulatorUtils.cloneAsync({
+                        sourceDeviceName: sourceDeviceIdentifier,
+                        destinationDeviceName: localDeviceName,
+                        env,
+                        logger,
+                    });
+                    logger.info(`Starting Android Emulator ${localDeviceName} (attempt ${attempt}/${maxAttempts})...`);
+                    const startResult = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.startAsync({
+                        deviceName: localDeviceName,
+                        env,
+                    });
+                    serialId = startResult.serialId;
+                    logger.info(`Waiting for Android Emulator ${localDeviceName} to be ready...`);
+                    await AndroidEmulatorUtils_1.AndroidEmulatorUtils.waitForReadyAsync({
+                        serialId,
+                        env,
+                        timeoutMs,
+                        logger,
+                    });
+                    localDeviceIdentifier = serialId;
+                }
+                catch (err) {
+                    logger.warn({ err }, `Failed to start Android Emulator ${localDeviceName} on attempt ${attempt}/${maxAttempts}.`);
+                    try {
+                        if (serialId) {
+                            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.deleteAsync({
+                                serialId,
+                                deviceName: localDeviceName,
+                                env,
+                            });
+                        }
+                        else {
+                            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.deleteAsync({
+                                deviceName: localDeviceName,
+                                env,
+                            });
+                        }
+                    }
+                    catch (cleanupErr) {
+                        logger.warn({ err: cleanupErr }, `Failed to clean up Android Emulator ${localDeviceName}.`);
+                    }
+                    throw err;
+                }
+            }, {
                 logger,
+                retryOptions: {
+                    retries: ANDROID_STARTUP_RETRIES_COUNT,
+                    retryIntervalMs: 1_000,
+                },
             });
-            logger.info(`Starting Android Emulator ${localDeviceName}...`);
-            const { serialId } = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.startAsync({
-                deviceName: localDeviceName,
-                env,
-            });
-            logger.info(`Waiting for Android Emulator ${localDeviceName} to be ready...`);
-            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.waitForReadyAsync({
-                serialId,
-                env,
-            });
-            localDeviceIdentifier = serialId;
             break;
         }
     }
+    if (!localDeviceIdentifier) {
+        throw new Error('Device did not return an identifier after startup.');
+    }
     // Run the function
     const fnResult = await (0, results_1.asyncResult)(fn({ deviceIdentifier: localDeviceIdentifier }));
     // Stop the device

package/dist/steps/functions/restoreCache.js

@@ -89,10 +89,6 @@ function createRestoreCacheFunction() {
         fn: async (stepsCtx, { env, inputs, outputs }) => {
             const { logger } = stepsCtx;
             try {
-                if (stepsCtx.global.staticContext.job.platform) {
-                    logger.error('Caches are not supported in build jobs yet.');
-                    return;
-                }
                 const paths = zod_1.default
                     .array(zod_1.default.string())
                     .parse((inputs.path.value ?? '').split(/[\r\n]+/))

package/dist/steps/functions/startAndroidEmulator.js

@@ -9,6 +9,8 @@ const steps_1 = require("@expo/steps");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
 const AndroidEmulatorUtils_1 = require("../../utils/AndroidEmulatorUtils");
 const retry_1 = require("../../utils/retry");
+const ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS = [60_000, 120_000, 180_000];
+const ANDROID_STARTUP_RETRIES_COUNT = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS.length - 1;
 function createStartAndroidEmulatorBuildFunction() {
     return new steps_1.BuildFunction({
         namespace: 'eas',
@@ -68,24 +70,71 @@ function createStartAndroidEmulatorBuildFunction() {
                     retryIntervalMs: 1_000,
                 },
             });
-            logger.info('Creating emulator device');
-            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.createAsync({
-                deviceName,
-                systemImagePackage,
-                deviceIdentifier: deviceIdentifier ?? null,
-                env,
+            let emulatorPromise = null;
+            let serialId = null;
+            await (0, retry_1.retryAsync)(async (attemptCount) => {
+                const timeoutMs = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS[attemptCount];
+                const attempt = attemptCount + 1;
+                const maxAttempts = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS.length;
+                const attemptSuffix = attempt > 1 ? ` (attempt ${attempt}/${maxAttempts})` : '';
+                let attemptSerialId = null;
+                try {
+                    logger.info(`Creating emulator device${attemptSuffix}.`);
+                    await AndroidEmulatorUtils_1.AndroidEmulatorUtils.createAsync({
+                        deviceName,
+                        systemImagePackage,
+                        deviceIdentifier: deviceIdentifier ?? null,
+                        env,
+                        logger,
+                    });
+                    logger.info(`Starting emulator device${attemptSuffix}.`);
+                    const startResult = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.startAsync({
+                        deviceName,
+                        env,
+                    });
+                    attemptSerialId = startResult.serialId;
+                    await AndroidEmulatorUtils_1.AndroidEmulatorUtils.waitForReadyAsync({
+                        env,
+                        serialId: attemptSerialId,
+                        timeoutMs,
+                        logger,
+                    });
+                    logger.info(`${deviceName} is ready.`);
+                    serialId = attemptSerialId;
+                    emulatorPromise = startResult.emulatorPromise;
+                }
+                catch (err) {
+                    logger.warn({ err }, `${deviceName} failed to start on attempt ${attempt}/${maxAttempts}.`);
+                    try {
+                        if (attemptSerialId) {
+                            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.deleteAsync({
+                                serialId: attemptSerialId,
+                                deviceName,
+                                env,
+                            });
+                        }
+                        else {
+                            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.deleteAsync({
+                                deviceName,
+                                env,
+                            });
+                        }
+                    }
+                    catch (cleanupErr) {
+                        logger.warn({ err: cleanupErr }, `Failed to clean up ${deviceName}.`);
+                    }
+                    throw err;
+                }
+            }, {
                 logger,
+                retryOptions: {
+                    retries: ANDROID_STARTUP_RETRIES_COUNT,
+                    retryIntervalMs: 1_000,
+                },
             });
-            logger.info('Starting emulator device');
-            const { emulatorPromise, serialId } = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.startAsync({
-                deviceName,
-                env,
-            });
-            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.waitForReadyAsync({
-                env,
-                serialId,
-            });
-            logger.info(`${deviceName} is ready.`);
+            if (!serialId || !emulatorPromise) {
+                throw new Error(`Failed to start emulator ${deviceName}.`);
+            }
             const count = Number(inputs.count.value ?? 1);
             if (count > 1) {
                 logger.info(`Requested ${count} emulators, shutting down ${deviceName} for cloning.`);
@@ -98,24 +147,64 @@ function createStartAndroidEmulatorBuildFunction() {
                 await (0, results_1.asyncResult)(emulatorPromise);
                 for (let i = 0; i < count; i++) {
                     const cloneIdentifier = `eas-simulator-${i + 1}`;
-                    logger.info(`Cloning ${deviceName} to ${cloneIdentifier}...`);
-                    await AndroidEmulatorUtils_1.AndroidEmulatorUtils.cloneAsync({
-                        sourceDeviceName: deviceName,
-                        destinationDeviceName: cloneIdentifier,
-                        env,
+                    await (0, retry_1.retryAsync)(async (attemptCount) => {
+                        const timeoutMs = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS[attemptCount];
+                        const attempt = attemptCount + 1;
+                        const maxAttempts = ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS.length;
+                        const attemptSuffix = attempt > 1 ? ` (attempt ${attempt}/${maxAttempts})` : '';
+                        let cloneSerialId = null;
+                        try {
+                            logger.info(`Cloning ${deviceName} to ${cloneIdentifier}${attemptSuffix}.`);
+                            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.cloneAsync({
+                                sourceDeviceName: deviceName,
+                                destinationDeviceName: cloneIdentifier,
+                                env,
+                                logger,
+                            });
+                            logger.info(`Starting emulator device${attemptSuffix}.`);
+                            const startResult = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.startAsync({
+                                deviceName: cloneIdentifier,
+                                env,
+                            });
+                            cloneSerialId = startResult.serialId;
+                            logger.info('Waiting for emulator to become ready');
+                            await AndroidEmulatorUtils_1.AndroidEmulatorUtils.waitForReadyAsync({
+                                serialId: cloneSerialId,
+                                env,
+                                timeoutMs,
+                                logger,
+                            });
+                            logger.info(`${cloneIdentifier} is ready.`);
+                        }
+                        catch (err) {
+                            logger.warn({ err }, `${cloneIdentifier} failed to start on attempt ${attempt}/${maxAttempts}.`);
+                            try {
+                                if (cloneSerialId) {
+                                    await AndroidEmulatorUtils_1.AndroidEmulatorUtils.deleteAsync({
+                                        serialId: cloneSerialId,
+                                        deviceName: cloneIdentifier,
+                                        env,
+                                    });
+                                }
+                                else {
+                                    await AndroidEmulatorUtils_1.AndroidEmulatorUtils.deleteAsync({
+                                        deviceName: cloneIdentifier,
+                                        env,
+                                    });
+                                }
+                            }
+                            catch (cleanupErr) {
+                                logger.warn({ err: cleanupErr }, `Failed to clean up ${cloneIdentifier}.`);
+                            }
+                            throw err;
+                        }
+                    }, {
                         logger,
+                        retryOptions: {
+                            retries: ANDROID_STARTUP_RETRIES_COUNT,
+                            retryIntervalMs: 1_000,
+                        },
                     });
-                    logger.info('Starting emulator device');
-                    const { serialId } = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.startAsync({
-                        deviceName: cloneIdentifier,
-                        env,
-                    });
-                    logger.info('Waiting for emulator to become ready');
-                    await AndroidEmulatorUtils_1.AndroidEmulatorUtils.waitForReadyAsync({
-                        serialId,
-                        env,
-                    });
-                    logger.info(`${cloneIdentifier} is ready.`);
                 }
             }
         },

package/dist/steps/functions/uploadToAsc.d.ts

@@ -1,2 +1,14 @@
 import { BuildFunction } from '@expo/steps';
 export declare function createUploadToAscBuildFunction(): BuildFunction;
+export declare function isClosedVersionTrainError(messages: {
+    code: string;
+}[]): boolean;
+export declare function isInvalidBundleIdentifierError(messages: {
+    code: string;
+}[]): boolean;
+export declare function isMissingPurposeStringError(messages: {
+    code: string;
+}[]): boolean;
+export declare function parseMissingUsageDescriptionKeys(messages: {
+    description: string;
+}[]): string[];

package/dist/steps/functions/uploadToAsc.js

@@ -37,6 +37,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createUploadToAscBuildFunction = createUploadToAscBuildFunction;
+exports.isClosedVersionTrainError = isClosedVersionTrainError;
+exports.isInvalidBundleIdentifierError = isInvalidBundleIdentifierError;
+exports.isMissingPurposeStringError = isMissingPurposeStringError;
+exports.parseMissingUsageDescriptionKeys = parseMissingUsageDescriptionKeys;
+const errors_1 = require("@expo/eas-build-job/dist/errors");
+const results_1 = require("@expo/results");
 const steps_1 = require("@expo/steps");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const jose = __importStar(require("jose"));
@@ -45,6 +51,8 @@ const node_path_1 = __importDefault(require("node:path"));
 const promises_1 = require("node:timers/promises");
 const zod_1 = require("zod");
 const AscApiClient_1 = require("../utils/ios/AscApiClient");
+const AscApiUtils_1 = require("../utils/ios/AscApiUtils");
+const readIpaInfo_1 = require("./readIpaInfo");
 function createUploadToAscBuildFunction() {
     return new steps_1.BuildFunction({
         namespace: 'eas',
@@ -127,27 +135,16 @@ function createUploadToAscBuildFunction() {
                 .setExpirationTime('20m')
                 .sign(privateKey);
             const client = new AscApiClient_1.AscApiClient({ token, logger: stepsCtx.logger });
-            stepsCtx.logger.info('Reading App information...');
-            const appResponse = await client.getAsync('/v1/apps/:id', { 'fields[apps]': ['bundleId', 'name'] }, { id: appleAppIdentifier });
-            stepsCtx.logger.info(`Uploading Build to "${appResponse.data.attributes.name}" (${appResponse.data.attributes.bundleId})...`);
+            stepsCtx.logger.info(`Reading App information for Apple app identifier: ${appleAppIdentifier}...`);
+            const appResponse = await AscApiUtils_1.AscApiUtils.getAppInfoAsync({ client, appleAppIdentifier });
+            const ascAppBundleIdentifier = appResponse.data.attributes.bundleId;
+            stepsCtx.logger.info(`Uploading Build to "${appResponse.data.attributes.name}" (${ascAppBundleIdentifier})...`);
             stepsCtx.logger.info('Creating Build Upload...');
-            const buildUploadResponse = await client.postAsync('/v1/buildUploads', {
-                data: {
-                    type: 'buildUploads',
-                    attributes: {
-                        platform: 'IOS',
-                        cfBundleShortVersionString: bundleShortVersion,
-                        cfBundleVersion: bundleVersion,
-                    },
-                    relationships: {
-                        app: {
-                            data: {
-                                type: 'apps',
-                                id: appleAppIdentifier,
-                            },
-                        },
-                    },
-                },
+            const buildUploadResponse = await AscApiUtils_1.AscApiUtils.createBuildUploadAsync({
+                client,
+                appleAppIdentifier,
+                bundleShortVersion,
+                bundleVersion,
             });
             const buildUploadId = buildUploadResponse.data.id;
             const buildUploadUrl = `https://appstoreconnect.apple.com/apps/${appleAppIdentifier}/testflight/ios/${buildUploadId}`;
@@ -223,10 +220,18 @@ function createUploadToAscBuildFunction() {
             }
             stepsCtx.logger.info('Checking build upload status...');
             const waitingForBuildStartedAt = Date.now();
+            const waitingLogIntervalMs = 10 * 1000;
+            let lastWaitLogTime = 0;
+            let lastWaitLogState = null;
             while (Date.now() - waitingForBuildStartedAt < 30 * 60 * 1000 /* 30 minutes */) {
                 const { data: { attributes: { state }, }, } = await client.getAsync(`/v1/buildUploads/:id`, { 'fields[buildUploads]': ['state', 'build'], include: ['build'] }, { id: buildUploadId });
                 if (state.state === 'AWAITING_UPLOAD' || state.state === 'PROCESSING') {
-                    stepsCtx.logger.info(`Waiting for build upload to complete... (status = ${state.state})`);
+                    const now = Date.now();
+                    if (lastWaitLogState !== state.state || now - lastWaitLogTime >= waitingLogIntervalMs) {
+                        stepsCtx.logger.info(`Waiting for build upload to complete... (status = ${state.state})`);
+                        lastWaitLogTime = now;
+                        lastWaitLogState = state.state;
+                    }
                     await (0, promises_1.setTimeout)(2000);
                     continue;
                 }
@@ -242,6 +247,35 @@ function createUploadToAscBuildFunction() {
                     stepsCtx.logger.error(`Errors:\n${itemizeMessages(errors)}\n`);
                 }
                 if (state.state === 'FAILED') {
+                    if (isInvalidBundleIdentifierError(errors)) {
+                        const ipaInfoResult = await (0, results_1.asyncResult)((0, readIpaInfo_1.readIpaInfoAsync)(ipaPath));
+                        const ipaBundleIdentifier = ipaInfoResult.ok
+                            ? ipaInfoResult.value.bundleIdentifier
+                            : null;
+                        throw new errors_1.UserFacingError('EAS_UPLOAD_TO_ASC_INVALID_BUNDLE_ID', `Build upload was rejected by App Store Connect because the app bundle identifier in the IPA does not match the selected App Store Connect app.\n\n` +
+                            `IPA bundle identifier: ${ipaBundleIdentifier ?? '(unavailable)'}\n` +
+                            `App Store Connect app bundle identifier: ${ascAppBundleIdentifier}\n\n` +
+                            'Bundle identifier cannot be changed for an existing App Store Connect app. ' +
+                            'If you selected the wrong app, change the Apple app identifier in the submit profile. ' +
+                            'If you selected the right app, you may want to select a different build to upload (or rebuild with a different profile).');
+                    }
+                    if (isMissingPurposeStringError(errors)) {
+                        const missingUsageDescriptionKeys = parseMissingUsageDescriptionKeys(errors);
+                        throw new errors_1.UserFacingError('EAS_UPLOAD_TO_ASC_MISSING_PURPOSE_STRING', `Build upload was rejected by App Store Connect because Info.plist is missing one or more privacy purpose strings.\n\n` +
+                            `${missingUsageDescriptionKeys.length > 0
+                                ? `Missing keys reported by App Store Connect:\n- ${missingUsageDescriptionKeys.join('\n- ')}\n\n`
+                                : ''}` +
+                            'Add the missing keys with clear user-facing explanations, then rebuild and submit again.\n' +
+                            'If you use Continuous Native Generation (CNG), update `ios.infoPlist` in app.json/app.config.js.\n' +
+                            'If you do not use CNG, update your app target Info.plist directly.', {
+                            docsUrl: 'https://docs.expo.dev/guides/permissions/#ios',
+                        });
+                    }
+                    if (isClosedVersionTrainError(errors)) {
+                        throw new errors_1.UserFacingError('EAS_UPLOAD_TO_ASC_CLOSED_VERSION_TRAIN', `Build upload was rejected by App Store Connect because the ${bundleShortVersion} app version is not accepted for new build submissions. ` +
+                            'This usually means the version train is closed or lower than a previously approved version. ' +
+                            'Bump the iOS app version (CFBundleShortVersionString, e.g. expo.version) to a higher version, then rebuild and submit again.');
+                    }
                     throw new Error(`Build upload (ID: ${buildUploadId}) failed.`);
                 }
                 else if (state.state === 'COMPLETE') {
@@ -255,6 +289,27 @@ function createUploadToAscBuildFunction() {
 function itemizeMessages(messages) {
     return `- ${messages.map(m => `${m.description} (${m.code})`).join('\n- ')}`;
 }
+function isClosedVersionTrainError(messages) {
+    return (messages.length > 0 &&
+        messages.every(message => ['90062', '90186', '90478'].includes(message.code)));
+}
+function isInvalidBundleIdentifierError(messages) {
+    return (messages.length > 0 && messages.every(message => ['90054', '90055'].includes(message.code)));
+}
+function isMissingPurposeStringError(messages) {
+    return messages.length > 0 && messages.every(message => message.code === '90683');
+}
+function parseMissingUsageDescriptionKeys(messages) {
+    const usageDescriptionKeyRegex = /\b(\w+UsageDescription)\b/g;
+    const keys = new Set();
+    for (const message of messages) {
+        const matches = message.description.matchAll(usageDescriptionKeyRegex);
+        for (const match of matches) {
+            keys.add(match[1]);
+        }
+    }
+    return [...keys];
+}
 async function uploadChunksAsync({ uploadOperations, ipaPath, logger, }) {
     const fd = await fs_extra_1.default.open(ipaPath, 'r');
     try {

package/dist/steps/utils/ios/AscApiClient.d.ts

@@ -1,6 +1,36 @@
 import { bunyan } from '@expo/logger';
 import { z } from 'zod';
+declare const AscErrorResponseSchema: z.ZodObject<{
+    errors: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
+        code: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+        detail: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 declare const GetApi: {
+    '/v1/apps': {
+        path: z.ZodObject<{}, z.core.$strip>;
+        request: z.ZodObject<{
+            'fields[apps]': z.ZodArray<z.ZodEnum<{
+                name: "name";
+                bundleId: "bundleId";
+            }>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        response: z.ZodObject<{
+            data: z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"apps">;
+                id: z.ZodString;
+                attributes: z.ZodObject<{
+                    bundleId: z.ZodString;
+                    name: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
     '/v1/apps/:id': {
         path: z.ZodObject<{
             id: z.ZodString;
@@ -222,6 +252,12 @@ declare const PatchApi: {
         }, z.core.$strip>;
     };
 };
+export type AscApiClientGetApi = {
+    [Path in keyof typeof GetApi]: {
+        request: z.input<(typeof GetApi)[Path]['request']>;
+        response: z.output<(typeof GetApi)[Path]['response']>;
+    };
+};
 export type AscApiClientPostApi = {
     [Path in keyof typeof PostApi]: {
         request: z.input<(typeof PostApi)[Path]['request']>;
@@ -234,6 +270,13 @@ export type AscApiClientPatchApi = {
         response: z.output<(typeof PatchApi)[Path]['response']>;
     };
 };
+export declare class AscApiRequestError extends Error {
+    readonly status: number;
+    readonly responseJson: z.output<typeof AscErrorResponseSchema>;
+    constructor(message: string, status: number, responseJson: z.output<typeof AscErrorResponseSchema>, options?: {
+        cause?: unknown;
+    });
+}
 export declare class AscApiClient {
     private readonly baseUrl;
     private readonly token;

package/dist/steps/utils/ios/AscApiClient.js

@@ -3,11 +3,42 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AscApiClient = void 0;
+exports.AscApiClient = exports.AscApiRequestError = void 0;
 const results_1 = require("@expo/results");
 const node_fetch_1 = __importDefault(require("node-fetch"));
 const zod_1 = require("zod");
+const AscErrorResponseSchema = zod_1.z.object({
+    errors: zod_1.z
+        .array(zod_1.z.object({
+        id: zod_1.z.string().optional(),
+        status: zod_1.z.string().optional(),
+        code: zod_1.z.string().optional(),
+        title: zod_1.z.string().optional(),
+        detail: zod_1.z.string().optional(),
+        source: zod_1.z.unknown().optional(),
+    }))
+        .min(1),
+});
 const GetApi = {
+    '/v1/apps': {
+        path: zod_1.z.object({}),
+        request: zod_1.z.object({
+            'fields[apps]': zod_1.z.array(zod_1.z.enum(['bundleId', 'name'])).refine(opts => {
+                return opts.includes('bundleId') && opts.includes('name');
+            }),
+            limit: zod_1.z.number().int().min(1).max(200).optional(),
+        }),
+        response: zod_1.z.object({
+            data: zod_1.z.array(zod_1.z.object({
+                type: zod_1.z.literal('apps'),
+                id: zod_1.z.string(),
+                attributes: zod_1.z.object({
+                    bundleId: zod_1.z.string(),
+                    name: zod_1.z.string(),
+                }),
+            })),
+        }),
+    },
     '/v1/apps/:id': {
         path: zod_1.z.object({
             id: zod_1.z.string(),
@@ -212,6 +243,16 @@ const PatchApi = {
         }),
     },
 };
+class AscApiRequestError extends Error {
+    status;
+    responseJson;
+    constructor(message, status, responseJson, options) {
+        super(message, { cause: options?.cause });
+        this.status = status;
+        this.responseJson = responseJson;
+    }
+}
+exports.AscApiRequestError = AscApiRequestError;
 class AscApiClient {
     baseUrl = 'https://api.appstoreconnect.apple.com';
     token;
@@ -283,11 +324,20 @@ class AscApiClient {
         });
         if (!response.ok) {
             const text = await response.text();
+            const parsedAscErrorResponse = await (0, results_1.asyncResult)((async () => AscErrorResponseSchema.parse(JSON.parse(text)))());
+            if (parsedAscErrorResponse.ok) {
+                throw new AscApiRequestError(`Unexpected response (${response.status}) from App Store Connect: ${text}`, response.status, parsedAscErrorResponse.value, { cause: response });
+            }
             throw new Error(`Unexpected response (${response.status}) from App Store Connect: ${text}`, {
                 cause: response,
             });
         }
-        const json = await response.json();
+        const text = await response.text();
+        const parsedJson = await (0, results_1.asyncResult)((async () => JSON.parse(text))());
+        if (!parsedJson.ok) {
+            throw new Error(`Malformed JSON response from App Store Connect (${response.status}): ${text}`);
+        }
+        const json = parsedJson.value;
         this.logger?.debug(`Response from App Store Connect: ${JSON.stringify(json, null, 2)}`);
         const parsedResponse = await (0, results_1.asyncResult)((async () => responseSchema.parse(json))());
         if (!parsedResponse.ok) {

package/dist/steps/utils/ios/AscApiUtils.d.ts

@@ -0,0 +1,13 @@
+import { AscApiClient, AscApiClientGetApi, AscApiClientPostApi } from './AscApiClient';
+export declare namespace AscApiUtils {
+    function getAppInfoAsync({ client, appleAppIdentifier, }: {
+        client: Pick<AscApiClient, 'getAsync'>;
+        appleAppIdentifier: string;
+    }): Promise<AscApiClientGetApi['/v1/apps/:id']['response']>;
+    function createBuildUploadAsync({ client, appleAppIdentifier, bundleShortVersion, bundleVersion, }: {
+        client: Pick<AscApiClient, 'postAsync'>;
+        appleAppIdentifier: string;
+        bundleShortVersion: string;
+        bundleVersion: string;
+    }): Promise<AscApiClientPostApi['/v1/buildUploads']['response']>;
+}

package/dist/steps/utils/ios/AscApiUtils.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AscApiUtils = void 0;
+const errors_1 = require("@expo/eas-build-job/dist/errors");
+const AscApiClient_1 = require("./AscApiClient");
+var AscApiUtils;
+(function (AscApiUtils) {
+    async function getAppInfoAsync({ client, appleAppIdentifier, }) {
+        try {
+            return await client.getAsync('/v1/apps/:id', { 'fields[apps]': ['bundleId', 'name'] }, { id: appleAppIdentifier });
+        }
+        catch (error) {
+            const notFoundErrors = error instanceof AscApiClient_1.AscApiRequestError && error.status === 404
+                ? error.responseJson.errors
+                : [];
+            const isAppNotFoundError = notFoundErrors.length > 0 && notFoundErrors.every(item => item.code === 'NOT_FOUND');
+            if (!isAppNotFoundError) {
+                throw error;
+            }
+            let visibleAppsSummary = null;
+            try {
+                visibleAppsSummary = await getVisibleAppsSummaryAsync(client);
+            }
+            catch {
+                // Don't hide the original NOT_FOUND error with a secondary lookup failure.
+                throw error;
+            }
+            throw new errors_1.UserFacingError('EAS_UPLOAD_TO_ASC_APP_NOT_FOUND', `App Store Connect app for application identifier ${appleAppIdentifier} was not found. ` +
+                'Verify the configured application identifier and that the App Store Connect API key has access to the application in the correct App Store Connect account.' +
+                (visibleAppsSummary
+                    ? `\n\nExample applications visible to this API key:\n${visibleAppsSummary}`
+                    : ''), {
+                docsUrl: 'https://expo.fyi/asc-app-id',
+                cause: error,
+            });
+        }
+    }
+    AscApiUtils.getAppInfoAsync = getAppInfoAsync;
+    async function createBuildUploadAsync({ client, appleAppIdentifier, bundleShortVersion, bundleVersion, }) {
+        try {
+            return await client.postAsync('/v1/buildUploads', {
+                data: {
+                    type: 'buildUploads',
+                    attributes: {
+                        platform: 'IOS',
+                        cfBundleShortVersionString: bundleShortVersion,
+                        cfBundleVersion: bundleVersion,
+                    },
+                    relationships: {
+                        app: {
+                            data: {
+                                type: 'apps',
+                                id: appleAppIdentifier,
+                            },
+                        },
+                    },
+                },
+            });
+        }
+        catch (error) {
+            const errors = error instanceof AscApiClient_1.AscApiRequestError && error.status === 409
+                ? error.responseJson.errors
+                : [];
+            const isDuplicateVersionError = errors.length > 0 &&
+                errors.every(item => item.code === 'ENTITY_ERROR.ATTRIBUTE.INVALID.DUPLICATE');
+            if (isDuplicateVersionError) {
+                throw new errors_1.UserFacingError('EAS_UPLOAD_TO_ASC_VERSION_DUPLICATE', `Increment Build Number: Build number ${bundleVersion} for app version ${bundleShortVersion} has already been used. ` +
+                    'App Store Connect requires unique build numbers within each app version (version train). ' +
+                    'Increment it by setting ios.buildNumber in app.json, or set "autoIncrement": true in eas.json (recommended). Then rebuild and resubmit.', {
+                    docsUrl: 'https://docs.expo.dev/build-reference/app-versions/',
+                    cause: error,
+                });
+            }
+            throw error;
+        }
+    }
+    AscApiUtils.createBuildUploadAsync = createBuildUploadAsync;
+})(AscApiUtils || (exports.AscApiUtils = AscApiUtils = {}));
+async function getVisibleAppsSummaryAsync(client) {
+    const appsResponse = await client.getAsync('/v1/apps', {
+        'fields[apps]': ['bundleId', 'name'],
+        limit: 10,
+    });
+    if (appsResponse.data.length === 0) {
+        return '  (none)';
+    }
+    return appsResponse.data
+        .map(app => `- ${app.attributes.name} (${app.attributes.bundleId}) (ID: ${app.id})`)
+        .join('\n');
+}

package/dist/utils/AndroidEmulatorUtils.d.ts

@@ -41,9 +41,11 @@ export declare namespace AndroidEmulatorUtils {
         emulatorPromise: SpawnPromise<SpawnResult>;
         serialId: AndroidDeviceSerialId;
     }>;
-    function waitForReadyAsync({ serialId, env, }: {
+    function waitForReadyAsync({ serialId, env, timeoutMs, logger, }: {
         serialId: AndroidDeviceSerialId;
         env: NodeJS.ProcessEnv;
+        timeoutMs?: number;
+        logger?: bunyan;
     }): Promise<void>;
     function collectLogsAsync({ serialId, env, }: {
         serialId: AndroidDeviceSerialId;
@@ -51,10 +53,15 @@ export declare namespace AndroidEmulatorUtils {
     }): Promise<{
         outputPath: string;
     }>;
-    function deleteAsync({ serialId, env, }: {
+    function stopAsync({ serialId, env, }: {
         serialId: AndroidDeviceSerialId;
         env: NodeJS.ProcessEnv;
     }): Promise<void>;
+    function deleteAsync({ serialId, deviceName, env, }: {
+        serialId?: AndroidDeviceSerialId;
+        deviceName?: AndroidVirtualDeviceName;
+        env: NodeJS.ProcessEnv;
+    }): Promise<void>;
     function startScreenRecordingAsync({ serialId, env, }: {
         serialId: AndroidDeviceSerialId;
         env: NodeJS.ProcessEnv;

package/dist/utils/AndroidEmulatorUtils.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AndroidEmulatorUtils = void 0;
+const results_1 = require("@expo/results");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
 const assert_1 = __importDefault(require("assert"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
@@ -14,6 +15,7 @@ const promises_1 = require("node:timers/promises");
 const retry_1 = require("./retry");
 var AndroidEmulatorUtils;
 (function (AndroidEmulatorUtils) {
+    const RETRY_INTERVAL_MS = 1_000;
     AndroidEmulatorUtils.defaultSystemImagePackage = `system-images;android-30;default;${process.arch === 'arm64' ? 'arm64-v8a' : 'x86_64'}`;
     async function getAvailableDevicesAsync({ env, }) {
         const result = await (0, turtle_spawn_1.default)('avdmanager', ['list', 'device', '--compact', '--null'], { env });
@@ -253,21 +255,37 @@ var AndroidEmulatorUtils;
         return { emulatorPromise, serialId };
     }
     AndroidEmulatorUtils.startAsync = startAsync;
-    async function waitForReadyAsync({ serialId, env, }) {
+    async function waitForReadyAsync({ serialId, env, timeoutMs = 3 * 60 * 1_000, logger, }) {
+        const retries = Math.max(0, Math.ceil(timeoutMs / RETRY_INTERVAL_MS) - 1);
         await (0, retry_1.retryAsync)(async () => {
             const { stdout } = await (0, turtle_spawn_1.default)('adb', ['-s', serialId, 'shell', 'getprop', 'sys.boot_completed'], { env });
             if (!stdout.startsWith('1')) {
                 throw new Error(`Emulator (${serialId}) boot has not completed.`);
             }
+            const hasNetworkConnection = await hasNetworkConnectionAsync({ serialId, env });
+            if (!hasNetworkConnection) {
+                throw new Error(`Emulator (${serialId}) network is not ready.`);
+            }
         }, {
-            // Retry every second for 3 minutes.
             retryOptions: {
-                retries: 3 * 60,
-                retryIntervalMs: 1_000,
+                retries,
+                retryIntervalMs: RETRY_INTERVAL_MS,
             },
+            logger,
         });
     }
     AndroidEmulatorUtils.waitForReadyAsync = waitForReadyAsync;
+    async function hasNetworkConnectionAsync({ serialId, env, }) {
+        const networkReadyCheckCommand = env.ANDROID_EMULATOR_NETWORK_READY_COMMAND?.trim();
+        if (networkReadyCheckCommand) {
+            const customNetworkCheckResult = await (0, results_1.asyncResult)((0, turtle_spawn_1.default)('adb', ['-s', serialId, 'shell', networkReadyCheckCommand], { env }));
+            return customNetworkCheckResult.ok;
+        }
+        const netcatResult = await (0, results_1.asyncResult)((0, turtle_spawn_1.default)('adb', ['-s', serialId, 'shell', 'nc', '-w', '1', '1.1.1.1', '443'], 
+        // Close stdin to make netcat exit cleanly on Android images that don't support `-z`.
+        { env, stdio: ['ignore', 'pipe', 'pipe'] }));
+        return netcatResult.ok;
+    }
     async function collectLogsAsync({ serialId, env, }) {
         const outputDir = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'android-emulator-logs-'));
         const outputPath = node_path_1.default.join(outputDir, `${serialId}.log`);
@@ -298,11 +316,7 @@ var AndroidEmulatorUtils;
         return { outputPath };
     }
     AndroidEmulatorUtils.collectLogsAsync = collectLogsAsync;
-    async function deleteAsync({ serialId, env, }) {
-        const adbEmuAvdName = await (0, turtle_spawn_1.default)('adb', ['-s', serialId, 'emu', 'avd', 'name'], {
-            env,
-        });
-        const deviceName = adbEmuAvdName.stdout.replace(/\r\n/g, '\n').split('\n')[0];
+    async function stopAsync({ serialId, env, }) {
         await (0, turtle_spawn_1.default)('adb', ['-s', serialId, 'emu', 'kill'], { env });
         await (0, retry_1.retryAsync)(async () => {
             const devices = await getAttachedDevicesAsync({ env });
@@ -312,10 +326,25 @@ var AndroidEmulatorUtils;
         }, {
             retryOptions: {
                 retries: 3 * 60,
-                retryIntervalMs: 1_000,
+                retryIntervalMs: RETRY_INTERVAL_MS,
             },
         });
-        await (0, turtle_spawn_1.default)('avdmanager', ['delete', 'avd', '-n', deviceName], { env });
+    }
+    AndroidEmulatorUtils.stopAsync = stopAsync;
+    async function deleteAsync({ serialId, deviceName, env, }) {
+        let resolvedDeviceName = deviceName;
+        if (!resolvedDeviceName && serialId) {
+            const adbEmuAvdName = await (0, turtle_spawn_1.default)('adb', ['-s', serialId, 'emu', 'avd', 'name'], {
+                env,
+            });
+            resolvedDeviceName = adbEmuAvdName.stdout.replace(/\r\n/g, '\n').split('\n')[0];
+        }
+        (0, assert_1.default)(resolvedDeviceName, 'Either "serialId" or "deviceName" must resolve to a device name.');
+        const serialIdToStop = serialId ?? (await getSerialIdAsync({ deviceName: resolvedDeviceName, env })) ?? undefined;
+        if (serialIdToStop) {
+            await stopAsync({ serialId: serialIdToStop, env });
+        }
+        await (0, turtle_spawn_1.default)('avdmanager', ['delete', 'avd', '-n', resolvedDeviceName], { env });
     }
     AndroidEmulatorUtils.deleteAsync = deleteAsync;
     async function startScreenRecordingAsync({ serialId, env, }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "18.0.6",
+  "version": "18.2.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -38,14 +38,14 @@
     "@expo/config": "10.0.6",
     "@expo/config-plugins": "9.0.12",
     "@expo/downloader": "18.0.1",
-    "@expo/eas-build-job": "18.0.2",
+    "@expo/eas-build-job": "18.2.0",
     "@expo/env": "^0.4.0",
     "@expo/logger": "18.0.1",
     "@expo/package-manager": "1.9.10",
     "@expo/plist": "^0.2.0",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "18.0.2",
+    "@expo/steps": "18.2.0",
     "@expo/template-file": "18.0.1",
     "@expo/turtle-spawn": "18.0.1",
     "@expo/xcpretty": "^4.3.1",
@@ -97,5 +97,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "df8ebc8f84809e52032661f9f08768650440e5c0"
+  "gitHead": "5f400d77660990422c6976a65dfb41f99374c5cc"
 }