@expo/build-tools 18.1.0 → 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

@@ -3,3 +3,12 @@ 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

@@ -38,7 +38,11 @@ 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"));
@@ -48,6 +52,7 @@ 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',
@@ -130,9 +135,10 @@ function createUploadToAscBuildFunction() {
                 .setExpirationTime('20m')
                 .sign(privateKey);
             const client = new AscApiClient_1.AscApiClient({ token, logger: stepsCtx.logger });
-            stepsCtx.logger.info('Reading App information...');
+            stepsCtx.logger.info(`Reading App information for Apple app identifier: ${appleAppIdentifier}...`);
             const appResponse = await AscApiUtils_1.AscApiUtils.getAppInfoAsync({ client, appleAppIdentifier });
-            stepsCtx.logger.info(`Uploading Build to "${appResponse.data.attributes.name}" (${appResponse.data.attributes.bundleId})...`);
+            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 AscApiUtils_1.AscApiUtils.createBuildUploadAsync({
                 client,
@@ -241,9 +247,34 @@ 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} version train is closed. ` +
-                            'Bump the iOS app version (CFBundleShortVersionString, e.g. expo.version) to a higher version and submit again.');
+                        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.`);
                 }
@@ -259,7 +290,25 @@ 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'].includes(message.code)));
+    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');

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

@@ -30,8 +30,8 @@ var AscApiUtils;
                 (visibleAppsSummary
                     ? `\n\nExample applications visible to this API key:\n${visibleAppsSummary}`
                     : ''), {
-                cause: error,
                 docsUrl: 'https://expo.fyi/asc-app-id',
+                cause: error,
             });
         }
     }
@@ -67,8 +67,8 @@ var AscApiUtils;
                 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.', {
-                    cause: error,
                     docsUrl: 'https://docs.expo.dev/build-reference/app-versions/',
+                    cause: error,
                 });
             }
             throw error;

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.1.0",
+  "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": "61b601de883b5c65d87163d8477b8a9250bc2de9"
+  "gitHead": "5f400d77660990422c6976a65dfb41f99374c5cc"
 }