@expo/build-tools 18.1.0 → 18.4.0

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;
-const errors_1 = require("@expo/eas-build-job/dist/errors");
+exports.isInvalidBundleIdentifierError = isInvalidBundleIdentifierError;
+exports.isMissingPurposeStringError = isMissingPurposeStringError;
+exports.parseMissingUsageDescriptionKeys = parseMissingUsageDescriptionKeys;
+const eas_build_job_1 = require("@expo/eas-build-job");
+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 eas_build_job_1.UserError('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 eas_build_job_1.UserError('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 eas_build_job_1.UserError('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/android/gradle.js

@@ -25,7 +25,7 @@ async function runGradleCommand({ logger, gradleCommand, androidDir, env, extraE
                 return line;
             }
         },
-        env: { ...env, ...extraEnv },
+        env: { ...env, ...extraEnv, LC_ALL: 'C.UTF-8' },
     });
     if (env.EAS_BUILD_RUNNER === 'eas-build' && process.platform === 'linux') {
         adjustOOMScore(spawnPromise, logger);

package/dist/steps/utils/android/gradleConfig.d.ts

@@ -1,6 +1,9 @@
+import { Android } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
+import { BuildContext } from '../../../context';
 export declare function injectCredentialsGradleConfig(logger: bunyan, workingDir: string): Promise<void>;
 export declare function injectConfigureVersionGradleConfig(logger: bunyan, workingDir: string, { versionCode, versionName }: {
     versionCode?: string;
     versionName?: string;
 }): Promise<void>;
+export declare function warnIfLegacyEasBuildGradleExists(ctx: BuildContext<Android.Job>): Promise<void>;

package/dist/steps/utils/android/gradleConfig.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.injectCredentialsGradleConfig = injectCredentialsGradleConfig;
 exports.injectConfigureVersionGradleConfig = injectConfigureVersionGradleConfig;
+exports.warnIfLegacyEasBuildGradleExists = warnIfLegacyEasBuildGradleExists;
 const config_plugins_1 = require("@expo/config-plugins");
 const template_file_1 = require("@expo/template-file");
 const fs_extra_1 = __importDefault(require("fs-extra"));
@@ -41,6 +42,19 @@ async function deleteEasBuildConfigureVersionGradle(workingDir) {
     const targetPath = getEasBuildConfigureVersionGradlePath(workingDir);
     await fs_extra_1.default.remove(targetPath);
 }
+let legacyEasBuildGradleWarningEmitted = false;
+async function warnIfLegacyEasBuildGradleExists(ctx) {
+    const legacyGradlePath = getLegacyEasBuildGradlePath(ctx.getReactNativeProjectDirectory());
+    if ((await fs_extra_1.default.pathExists(legacyGradlePath)) &&
+        (process.env.NODE_ENV === 'test' || !legacyEasBuildGradleWarningEmitted)) {
+        legacyEasBuildGradleWarningEmitted = true;
+        ctx.logger.warn('eas-build.gradle script is deprecated, please remove it from your project.');
+        ctx.markBuildPhaseHasWarnings();
+    }
+}
+function getLegacyEasBuildGradlePath(projectRoot) {
+    return path_1.default.join(projectRoot, 'android/app/eas-build.gradle');
+}
 function getEasBuildInjectCredentialsGradlePath(workingDir) {
     return path_1.default.join(workingDir, 'android/app/eas-build-inject-android-credentials.gradle');
 }
@@ -83,6 +97,6 @@ function hasLine(haystack, needle) {
     return (haystack
         .replace(/\r\n/g, '\n')
         .split('\n')
-        // Check for both single and double quotes
+        // Check for both single and double quotes.
         .some(line => line === needle || line === needle.replace(/"/g, "'")));
 }

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AscApiUtils = void 0;
-const errors_1 = require("@expo/eas-build-job/dist/errors");
+const eas_build_job_1 = require("@expo/eas-build-job");
 const AscApiClient_1 = require("./AscApiClient");
 var AscApiUtils;
 (function (AscApiUtils) {
@@ -25,13 +25,13 @@ var AscApiUtils;
                 // 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. ` +
+            throw new eas_build_job_1.UserError('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}`
                     : ''), {
-                cause: error,
                 docsUrl: 'https://expo.fyi/asc-app-id',
+                cause: error,
             });
         }
     }
@@ -64,11 +64,11 @@ var AscApiUtils;
             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. ` +
+                throw new eas_build_job_1.UserError('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/steps/utils/ios/credentials/provisioningProfile.d.ts

@@ -23,11 +23,12 @@ export default class ProvisioningProfile {
     get data(): ProvisioningProfileData;
     private readonly profilePath;
     private profileData?;
+    private developerCertificates;
     constructor(profile: Buffer, keychainPath: string, target: string, certificateCommonName: string);
     init(logger: bunyan): Promise<void>;
     destroy(logger: bunyan): Promise<void>;
     verifyCertificate(fingerprint: string): void;
     private load;
     private resolveDistributionType;
-    private genDerCertFingerprint;
+    private getAllDerCertFingerprints;
 }

package/dist/steps/utils/ios/credentials/provisioningProfile.js

@@ -34,6 +34,7 @@ class ProvisioningProfile {
     }
     profilePath;
     profileData;
+    developerCertificates = [];
     constructor(profile, keychainPath, target, certificateCommonName) {
         this.profile = profile;
         this.keychainPath = keychainPath;
@@ -58,10 +59,11 @@ class ProvisioningProfile {
         await fs_extra_1.default.remove(this.profilePath);
     }
     verifyCertificate(fingerprint) {
-        const devCertFingerprint = this.genDerCertFingerprint();
-        if (devCertFingerprint !== fingerprint) {
-            throw new eas_build_job_1.errors.CredentialsDistCertMismatchError(`Provisioning profile and distribution certificate don't match.
-Profile's certificate fingerprint = ${devCertFingerprint}, distribution certificate fingerprint = ${fingerprint}`);
+        const devCertFingerprints = this.getAllDerCertFingerprints();
+        if (!devCertFingerprints.includes(fingerprint)) {
+            throw new eas_build_job_1.errors.CredentialsDistCertMismatchError(`Provisioning profile and distribution certificate don't match.\n` +
+                `Profile's certificate fingerprints = [${devCertFingerprints.join(', ')}], ` +
+                `distribution certificate fingerprint = ${fingerprint}`);
         }
     }
     async load() {
@@ -85,6 +87,7 @@ Profile's certificate fingerprint = ${devCertFingerprint}, distribution certific
         }
         const applicationIdentifier = plistData.Entitlements['application-identifier'];
         const bundleIdentifier = applicationIdentifier.replace(/^.+?\./, '');
+        this.developerCertificates = plistData.DeveloperCertificates.map((cert) => Buffer.from(cert, 'base64'));
         this.profileData = {
             path: this.profilePath,
             target: this.target,
@@ -92,7 +95,7 @@ Profile's certificate fingerprint = ${devCertFingerprint}, distribution certific
             teamId: plistData.TeamIdentifier[0],
             uuid: plistData.UUID,
             name: plistData.Name,
-            developerCertificate: Buffer.from(plistData.DeveloperCertificates[0], 'base64'),
+            developerCertificate: this.developerCertificates[0],
             certificateCommonName: this.certificateCommonName,
             distributionType: this.resolveDistributionType(plistData),
         };
@@ -108,12 +111,8 @@ Profile's certificate fingerprint = ${devCertFingerprint}, distribution certific
             return DistributionType.APP_STORE;
         }
     }
-    genDerCertFingerprint() {
-        return crypto_1.default
-            .createHash('sha1')
-            .update(new Uint8Array(this.data.developerCertificate))
-            .digest('hex')
-            .toUpperCase();
+    getAllDerCertFingerprints() {
+        return this.developerCertificates.map(cert => crypto_1.default.createHash('sha1').update(new Uint8Array(cert)).digest('hex').toUpperCase());
     }
 }
 exports.default = ProvisioningProfile;

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/dist/utils/stepMetrics.d.ts

@@ -1,9 +1,9 @@
 import { bunyan } from '@expo/logger';
-import { StepMetricsCollection } from '@expo/steps';
+import { StepMetric } from '@expo/steps';
 export declare function uploadStepMetricsToWwwAsync({ workflowJobId, robotAccessToken, expoApiV2BaseUrl, stepMetrics, logger, }: {
     workflowJobId: string;
     robotAccessToken: string;
     expoApiV2BaseUrl: string;
-    stepMetrics: StepMetricsCollection;
+    stepMetrics: StepMetric[];
     logger: bunyan;
 }): Promise<void>;

package/dist/utils/stepMetrics.js

@@ -3,22 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.uploadStepMetricsToWwwAsync = uploadStepMetricsToWwwAsync;
 const turtleFetch_1 = require("./turtleFetch");
 async function uploadStepMetricsToWwwAsync({ workflowJobId, robotAccessToken, expoApiV2BaseUrl, stepMetrics, logger, }) {
-    if (stepMetrics.length === 0) {
-        logger.debug('No step metrics to upload');
-        return;
-    }
     try {
         await (0, turtleFetch_1.turtleFetch)(new URL(`workflows/${workflowJobId}/metrics`, expoApiV2BaseUrl).toString(), 'POST', {
             json: { stepMetrics },
-            headers: {
-                Authorization: `Bearer ${robotAccessToken}`,
-            },
-            timeout: 20000,
+            headers: { Authorization: `Bearer ${robotAccessToken}` },
+            timeout: 5000,
+            retries: 2,
             logger,
         });
-        logger.info(`Uploaded ${stepMetrics.length} step metrics`);
     }
     catch {
-        // Don't display unactionable error to the user, let's send it to Sentry in the future
+        // Don't fail the build for metrics — silently give up
     }
 }