@expo/build-tools 22.2.0 → 22.4.0

package/dist/builders/android.js

@@ -81,7 +81,7 @@ async function buildInnerAsync(ctx, jobHooksRef) {
         await (0, restoreBuildCache_1.restoreCcacheAsync)({
             logger: ctx.logger,
             workingDirectory,
-            platform: ctx.job.platform,
+            target: { platform: ctx.job.platform },
             env: ctx.env,
             secrets: ctx.job.secrets,
         });
@@ -203,7 +203,7 @@ async function buildInnerAsync(ctx, jobHooksRef) {
         await (0, saveBuildCache_1.saveCcacheAsync)({
             logger: ctx.logger,
             workingDirectory,
-            platform: ctx.job.platform,
+            target: { platform: ctx.job.platform },
             evictUsedBefore,
             env: ctx.env,
             secrets: ctx.job.secrets,

package/dist/builders/ios.js

@@ -97,7 +97,7 @@ async function buildInnerAsync(ctx, jobHooksRef) {
             await (0, restoreBuildCache_1.restoreCcacheAsync)({
                 logger: ctx.logger,
                 workingDirectory,
-                platform: ctx.job.platform,
+                target: { platform: ctx.job.platform, simulator: ctx.job.simulator === true },
                 env: ctx.env,
                 secrets: ctx.job.secrets,
             });
@@ -224,7 +224,7 @@ async function buildInnerAsync(ctx, jobHooksRef) {
         await (0, saveBuildCache_1.saveCcacheAsync)({
             logger: ctx.logger,
             workingDirectory,
-            platform: ctx.job.platform,
+            target: { platform: ctx.job.platform, simulator: ctx.job.simulator === true },
             evictUsedBefore,
             env: ctx.env,
             secrets: ctx.job.secrets,

package/dist/ios/xcode.d.ts

@@ -0,0 +1,3 @@
+export declare function getXcodeVersionAsync({ env }: {
+    env: NodeJS.ProcessEnv;
+}): Promise<string>;

package/dist/ios/xcode.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getXcodeVersionAsync = getXcodeVersionAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+async function getXcodeVersionAsync({ env }) {
+    let stdout;
+    try {
+        ({ stdout } = await (0, turtle_spawn_1.default)('xcodebuild', ['-version'], { stdio: 'pipe', env }));
+    }
+    catch (error) {
+        throw new eas_build_job_1.SystemError('Failed to get Xcode version', { cause: error });
+    }
+    const version = /^Xcode\s+(\d+(?:\.\d+)*)$/m.exec(stdout)?.[1];
+    if (!version) {
+        throw new eas_build_job_1.SystemError(`Failed to determine Xcode version from: ${stdout.trim()}`);
+    }
+    return version;
+}

package/dist/steps/easFunctions.js

@@ -20,8 +20,10 @@ const generateGymfileFromTemplate_1 = require("./functions/generateGymfileFromTe
 const getCredentialsForBuildTriggeredByGitHubIntegration_1 = require("./functions/getCredentialsForBuildTriggeredByGitHubIntegration");
 const injectAndroidCredentials_1 = require("./functions/injectAndroidCredentials");
 const installMaestro_1 = require("./functions/installMaestro");
+const installBuild_1 = require("./functions/installBuild");
 const installNodeModules_1 = require("./functions/installNodeModules");
 const installPods_1 = require("./functions/installPods");
+const launchApplication_1 = require("./functions/launchApplication");
 const prebuild_1 = require("./functions/prebuild");
 const readAppConfig_1 = require("./functions/readAppConfig");
 const readIpaInfo_1 = require("./functions/readIpaInfo");
@@ -70,6 +72,8 @@ function getEasFunctions(ctx) {
         (0, prebuild_1.createPrebuildBuildFunction)(),
         (0, readIpaInfo_1.createReadIpaInfoBuildFunction)(),
         (0, downloadBuild_1.createDownloadBuildFunction)(ctx),
+        (0, installBuild_1.createInstallBuildFunction)(),
+        (0, launchApplication_1.createLaunchApplicationFunction)(),
         (0, export_1.createEasExportBuildFunction)(),
         (0, deploy_1.createEasDeployBuildFunction)(),
         (0, repack_1.createRepackBuildFunction)(),

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

@@ -2,13 +2,20 @@ import { bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
 import { Client } from '@urql/core';
 import { CustomBuildContext } from '../../customBuildContext';
+type DownloadBuildSource = {
+    buildId: string;
+    applicationArchiveUrl?: never;
+} | {
+    buildId?: never;
+    applicationArchiveUrl: string;
+};
 export declare function createDownloadBuildFunction(ctx: CustomBuildContext): BuildFunction;
-export declare function downloadBuildAsync({ logger, buildId, graphqlClient, robotAccessToken, extensions, }: {
+export declare function downloadBuildAsync(params: DownloadBuildSource & {
     logger: bunyan;
-    buildId: string;
     graphqlClient: Client;
     robotAccessToken: string | null;
     extensions: string[];
 }): Promise<{
     artifactPath: string;
 }>;
+export {};

package/dist/steps/functions/downloadBuild.js

@@ -8,15 +8,19 @@ exports.downloadBuildAsync = downloadBuildAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
 const results_1 = require("@expo/results");
 const steps_1 = require("@expo/steps");
+const content_disposition_1 = __importDefault(require("content-disposition"));
 const fast_glob_1 = require("fast-glob");
 const gql_tada_1 = require("gql.tada");
 const node_fetch_1 = __importDefault(require("node-fetch"));
+const node_assert_1 = __importDefault(require("node:assert"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const stream_1 = __importDefault(require("stream"));
 const util_1 = require("util");
 const zod_1 = require("zod");
+const bplist_parser_1 = __importDefault(require("bplist-parser"));
+const plist_1 = __importDefault(require("plist"));
 const artifacts_1 = require("../../utils/artifacts");
 const files_1 = require("../../utils/files");
 const retryOnDNSFailure_1 = require("../../utils/retryOnDNSFailure");
@@ -44,7 +48,12 @@ function createDownloadBuildFunction(ctx) {
         inputProviders: [
             steps_1.BuildStepInput.createProvider({
                 id: 'build_id',
-                required: true,
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'application_archive_url',
+                required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
             steps_1.BuildStepInput.createProvider({
@@ -64,11 +73,29 @@ function createDownloadBuildFunction(ctx) {
             const { logger } = stepsCtx;
             const extensions = zod_1.z.array(zod_1.z.string()).parse(inputs.extensions.value);
             logger.info(`Expected extensions: [${extensions.join(', ')}]`);
-            const buildId = zod_1.z.string().uuid().parse(inputs.build_id.value);
-            logger.info(`Downloading build ${buildId}...`);
+            const buildId = inputs.build_id.value
+                ? zod_1.z.string().uuid().parse(inputs.build_id.value)
+                : undefined;
+            const applicationArchiveUrl = inputs.application_archive_url.value
+                ? parseHttpApplicationArchiveUrl(inputs.application_archive_url.value)
+                : undefined;
+            let source;
+            if (buildId) {
+                if (applicationArchiveUrl) {
+                    throw new eas_build_job_1.UserError('EAS_DOWNLOAD_BUILD_INVALID_SOURCE', 'Pass only one of build_id or application_archive_url.');
+                }
+                source = { buildId };
+            }
+            else {
+                if (!applicationArchiveUrl) {
+                    throw new eas_build_job_1.UserError('EAS_DOWNLOAD_BUILD_INVALID_SOURCE', 'Pass build_id or application_archive_url.');
+                }
+                source = { applicationArchiveUrl };
+            }
+            logger.info(buildId ? `Downloading build ${buildId}...` : `Downloading application archive...`);
             const { artifactPath } = await downloadBuildAsync({
                 logger,
-                buildId,
+                ...source,
                 graphqlClient: ctx.graphqlClient,
                 robotAccessToken: stepsCtx.global.staticContext.job.secrets?.robotAccessToken ?? null,
                 extensions,
@@ -92,21 +119,32 @@ async function fetchApplicationArchiveUrlAsync({ buildId, graphqlClient, }) {
     }
     return applicationArchiveUrl;
 }
-async function downloadBuildAsync({ logger, buildId, graphqlClient, robotAccessToken, extensions, }) {
+async function downloadBuildAsync(params) {
+    const { logger, graphqlClient, robotAccessToken, extensions } = params;
+    let downloadUrl;
+    let headers;
+    if (params.applicationArchiveUrl) {
+        if (params.buildId) {
+            throw new eas_build_job_1.UserError('EAS_DOWNLOAD_BUILD_INVALID_SOURCE', 'Pass only one of buildId or applicationArchiveUrl.');
+        }
+        downloadUrl = parseHttpApplicationArchiveUrl(params.applicationArchiveUrl);
+        headers = undefined;
+    }
+    else if (params.buildId) {
+        const buildId = zod_1.z.string().uuid().parse(params.buildId);
+        downloadUrl = await fetchApplicationArchiveUrlAsync({ buildId, graphqlClient });
+        headers = robotAccessToken ? { Authorization: `Bearer ${robotAccessToken}` } : undefined;
+    }
+    else {
+        throw new eas_build_job_1.UserError('EAS_DOWNLOAD_BUILD_INVALID_SOURCE', 'Pass buildId or applicationArchiveUrl.');
+    }
     const downloadDestinationDirectory = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'download_build-downloaded-'));
-    const downloadUrl = await fetchApplicationArchiveUrlAsync({ buildId, graphqlClient });
-    const response = await (0, retryOnDNSFailure_1.retryOnDNSFailure)(node_fetch_1.default)(downloadUrl, {
-        headers: robotAccessToken ? { Authorization: `Bearer ${robotAccessToken}` } : undefined,
-    });
+    const response = await (0, retryOnDNSFailure_1.retryOnDNSFailure)(node_fetch_1.default)(downloadUrl, { headers });
     if (!response.ok) {
         const textResult = await (0, results_1.asyncResult)(response.text());
         throw new Error(`Unexpected response from server (${response.status}): ${textResult.value}`);
     }
-    // URL may contain percent-encoded characters, e.g. my%20file.apk
-    // this replaces all non-alphanumeric characters (excluding dot) with underscore
-    const archiveFilename = node_path_1.default
-        .basename(new URL(response.url).pathname)
-        .replace(/([^a-z0-9.-]+)/gi, '_');
+    const archiveFilename = resolveArchiveFilename({ response, extensions });
     const archivePath = node_path_1.default.join(downloadDestinationDirectory, archiveFilename);
     await streamPipeline(response.body, node_fs_1.default.createWriteStream(archivePath));
     const { size } = await node_fs_1.default.promises.stat(archivePath);
@@ -127,9 +165,64 @@ async function downloadBuildAsync({ logger, buildId, graphqlClient, robotAccessT
         onlyFiles: false,
         onlyDirectories: false,
     });
+    let matchingFilesRoot = extractionDirectory;
+    if (matchingFiles.length === 0 &&
+        extensions.includes('app') &&
+        (await isIosAppBundleAsync(extractionDirectory))) {
+        const appBundlePath = `${extractionDirectory}.app`;
+        await node_fs_1.default.promises.rename(extractionDirectory, appBundlePath);
+        matchingFiles.push(appBundlePath);
+        matchingFilesRoot = node_path_1.default.dirname(appBundlePath);
+    }
     if (matchingFiles.length === 0) {
         throw new eas_build_job_1.UserError('EAS_DOWNLOAD_BUILD_NO_MATCHING_FILES', `No ${extensions.map(ext => `.${ext}`).join(', ')} entries found in the archive.`);
     }
-    logger.info(`Found ${matchingFiles.length} matching ${(0, strings_1.pluralize)(matchingFiles.length, 'entry')}:\n${matchingFiles.map(f => `- ${node_path_1.default.relative(extractionDirectory, f)}`).join('\n')}`);
+    logger.info(`Found ${matchingFiles.length} matching ${(0, strings_1.pluralize)(matchingFiles.length, 'entry')}:\n${matchingFiles.map(f => `- ${node_path_1.default.relative(matchingFilesRoot, f)}`).join('\n')}`);
     return { artifactPath: matchingFiles[0] };
 }
+async function isIosAppBundleAsync(directory) {
+    try {
+        const infoPlist = await node_fs_1.default.promises.readFile(node_path_1.default.join(directory, 'Info.plist'));
+        const isBinaryPlist = infoPlist.subarray(0, 8).toString('ascii') === 'bplist00';
+        const parsedInfoPlist = (isBinaryPlist
+            ? bplist_parser_1.default.parseBuffer(infoPlist)[0]
+            : plist_1.default.parse(infoPlist.toString('utf8')));
+        return parsedInfoPlist?.CFBundlePackageType === 'APPL';
+    }
+    catch {
+        return false;
+    }
+}
+function parseHttpApplicationArchiveUrl(value) {
+    try {
+        const applicationArchiveUrl = zod_1.z.string().parse(value);
+        const parsedUrl = new URL(applicationArchiveUrl);
+        (0, node_assert_1.default)(parsedUrl.protocol === 'http:' || parsedUrl.protocol === 'https:');
+        return applicationArchiveUrl;
+    }
+    catch {
+        throw new eas_build_job_1.UserError('EAS_DOWNLOAD_BUILD_INVALID_APPLICATION_ARCHIVE_URL', 'application_archive_url must be a valid HTTP or HTTPS URL.');
+    }
+}
+function resolveArchiveFilename({ response, extensions, }) {
+    const contentDispositionHeader = response.headers.get('content-disposition');
+    let headerFilename;
+    if (contentDispositionHeader) {
+        try {
+            headerFilename = content_disposition_1.default.parse(contentDispositionHeader).parameters.filename;
+        }
+        catch {
+            // Ignore malformed Content-Disposition headers and fall back to the response URL.
+        }
+    }
+    const urlFilename = node_path_1.default.basename(new URL(response.url).pathname);
+    let archiveFilename = node_path_1.default.basename(headerFilename ?? urlFilename ?? '');
+    if (!archiveFilename || archiveFilename === '.' || archiveFilename === '..') {
+        archiveFilename = 'application';
+    }
+    if (!node_path_1.default.extname(archiveFilename) && extensions.length === 1) {
+        archiveFilename = `${archiveFilename}.${extensions[0]}`;
+    }
+    // URL and header filenames may contain percent-encoded or unsafe filesystem characters.
+    return archiveFilename.replace(/([^a-z0-9.-]+)/gi, '_');
+}

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

@@ -0,0 +1,12 @@
+import { bunyan } from '@expo/logger';
+import { BuildFunction, BuildRuntimePlatform, BuildStepEnv } from '@expo/steps';
+export declare function createInstallBuildFunction(): BuildFunction;
+export declare function installBuildAsync({ artifactPath, runtimePlatform, env, logger, }: {
+    artifactPath: string;
+    runtimePlatform: BuildRuntimePlatform;
+    env: BuildStepEnv;
+    logger: bunyan;
+}): Promise<{
+    applicationIdentifier: string;
+    activityName?: string;
+}>;

package/dist/steps/functions/installBuild.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInstallBuildFunction = createInstallBuildFunction;
+exports.installBuildAsync = installBuildAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+function createInstallBuildFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'install_build',
+        name: 'Install build',
+        __metricsId: 'eas/install_build',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'artifact_path',
+                required: true,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+        ],
+        outputProviders: [
+            steps_1.BuildStepOutput.createProvider({
+                id: 'application_identifier',
+                required: true,
+            }),
+            steps_1.BuildStepOutput.createProvider({
+                id: 'activity_name',
+                required: false,
+            }),
+        ],
+        fn: async ({ global, logger }, { inputs, outputs, env }) => {
+            const artifactPath = zod_1.z.string().min(1).parse(inputs.artifact_path.value);
+            const { applicationIdentifier, activityName } = await installBuildAsync({
+                artifactPath,
+                runtimePlatform: global.runtimePlatform,
+                env,
+                logger,
+            });
+            outputs.application_identifier.set(applicationIdentifier);
+            if (activityName) {
+                outputs.activity_name.set(activityName);
+            }
+        },
+    });
+}
+async function installBuildAsync({ artifactPath, runtimePlatform, env, logger, }) {
+    const artifactStat = await node_fs_1.default.promises.stat(artifactPath).catch(err => {
+        throw new eas_build_job_1.UserError('EAS_INSTALL_BUILD_INVALID_ARTIFACT', `Build artifact does not exist at ${artifactPath}.`, { cause: err });
+    });
+    if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
+        if (node_path_1.default.extname(artifactPath) !== '.app' || !artifactStat.isDirectory()) {
+            throw new eas_build_job_1.UserError('EAS_INSTALL_BUILD_INVALID_ARTIFACT', 'iOS Simulator sessions require a .app build artifact.');
+        }
+        const infoPlistPath = node_path_1.default.join(artifactPath, 'Info.plist');
+        const { stdout } = await (0, turtle_spawn_1.default)('plutil', ['-extract', 'CFBundleIdentifier', 'raw', '-o', '-', infoPlistPath], { stdio: 'pipe', env });
+        const applicationIdentifier = stdout.trim();
+        if (!applicationIdentifier) {
+            throw new eas_build_job_1.UserError('EAS_INSTALL_BUILD_MISSING_IDENTIFIER', `Could not read CFBundleIdentifier from ${infoPlistPath}.`);
+        }
+        logger.info(`Installing ${artifactPath} on the iOS Simulator.`);
+        await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'install', 'booted', artifactPath], { env, logger });
+        return { applicationIdentifier };
+    }
+    if (node_path_1.default.extname(artifactPath) !== '.apk' || !artifactStat.isFile()) {
+        throw new eas_build_job_1.UserError('EAS_INSTALL_BUILD_INVALID_ARTIFACT', 'Android Emulator sessions require an .apk build artifact.');
+    }
+    const { stdout } = await (0, turtle_spawn_1.default)('aapt2', ['dump', 'badging', artifactPath], {
+        stdio: 'pipe',
+        env,
+    });
+    const applicationIdentifier = stdout.match(/package: name='([^']+)'/)?.[1];
+    const activityName = stdout.match(/launchable-activity: name='([^']+)'/)?.[1];
+    if (!applicationIdentifier) {
+        throw new eas_build_job_1.UserError('EAS_INSTALL_BUILD_MISSING_IDENTIFIER', `Could not read an Android application identifier from ${artifactPath}.`);
+    }
+    logger.info(`Installing ${artifactPath} on the Android Emulator.`);
+    await (0, turtle_spawn_1.default)('adb', ['install', '-r', artifactPath], { env, logger });
+    return { applicationIdentifier, activityName };
+}

package/dist/steps/functions/installMaestro.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createInstallMaestroBuildFunction = createInstallMaestroBuildFunction;
 exports.installIdbFromBrew = installIdbFromBrew;
+const downloader_1 = __importDefault(require("@expo/downloader"));
 const eas_build_job_1 = require("@expo/eas-build-job");
 const results_1 = require("@expo/results");
 const steps_1 = require("@expo/steps");
@@ -16,6 +17,10 @@ const path_1 = __importDefault(require("path"));
 const semver_1 = __importDefault(require("semver"));
 const maestroBackend_1 = require("./maestroBackend");
 const datadog_1 = require("../../datadog");
+const xcode_1 = require("../../ios/xcode");
+const IosSimulatorUtils_1 = require("../../utils/IosSimulatorUtils");
+const download_1 = require("../../utils/download");
+const MAESTRO_RUNNER_WDA_CACHE_DOWNLOAD_TIMEOUT_MS = 20_000;
 function createInstallMaestroBuildFunction() {
     return new steps_1.BuildFunction({
         namespace: 'eas',
@@ -118,10 +123,12 @@ function createInstallMaestroBuildFunction() {
                             requestedVersion === 'latest' ||
                             (requestedVersion === undefined &&
                                 (!currentMaestroRunnerVersion || semver_1.default.gt(currentMaestroRunnerVersion, '1.1.15'))))) {
-                        const xcodeVersion = await getXcodeVersion({ env });
+                        // `getXcodeVersionAsync` returns the raw version (e.g. "16.4"), which
+                        // `semver.coerce` normalizes (e.g. "16.4.0") for comparison and display.
+                        const xcodeVersion = semver_1.default.coerce(await (0, xcode_1.getXcodeVersionAsync)({ env }));
                         // maestro-runner 1.1.16 added `arch` to its xcodebuild destination. Xcode versions
                         // below 26 reject that option, so use the last compatible maestro-runner version.
-                        if (semver_1.default.lt(xcodeVersion, '26.0.0')) {
+                        if (xcodeVersion && semver_1.default.lt(xcodeVersion, '26.0.0')) {
                             if (requestedMaestroRunnerVersion) {
                                 throw new eas_build_job_1.UserError('ERR_MAESTRO_INVALID_INPUT', `maestro-runner ${requestedVersion} is not compatible with Xcode ${xcodeVersion}. Use maestro-runner 1.1.15 or an Xcode 26+ image.`);
                             }
@@ -147,6 +154,12 @@ function createInstallMaestroBuildFunction() {
                 logger.error(maestroVersionResult.reason, 'Failed to get Maestro version.');
                 throw new Error(`Failed to ensure ${backend} is installed.`);
             }
+            if (backend === 'maestro-runner' && global.runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
+                await installMaestroRunnerWdaCache({
+                    logger,
+                    env,
+                });
+            }
             logger.info(`${backend} ${maestroVersionResult.value} is ready.`);
             outputs.maestro_version.set(maestroVersionResult.value);
             datadog_1.Datadog.distribution('eas.maestro.install', 1, {
@@ -156,19 +169,87 @@ function createInstallMaestroBuildFunction() {
         },
     });
 }
-async function getXcodeVersion({ env }) {
-    let stdout;
+async function installMaestroRunnerWdaCache({ logger, env, }) {
+    if (!env.HOME) {
+        logger.warn('Skipping the prebuilt WebDriverAgent cache because the $HOME environment variable is empty.');
+        return;
+    }
+    const maestroRunnerHome = path_1.default.join(env.HOME, '.maestro-runner');
     try {
-        ({ stdout } = await (0, turtle_spawn_1.default)('xcodebuild', ['-version'], { stdio: 'pipe', env }));
+        const wdaVersion = await getMaestroRunnerWdaVersion({ maestroRunnerHome });
+        if (!wdaVersion) {
+            logger.info('Skipping the prebuilt WebDriverAgent cache because the installed WDA version is unknown.');
+            return;
+        }
+        const xcodeVersion = await (0, xcode_1.getXcodeVersionAsync)({ env });
+        const iosRuntimes = await IosSimulatorUtils_1.IosSimulatorUtils.getAvailableRuntimesAsync({ env });
+        const iosRuntimeIdentifierPrefix = 'com.apple.CoreSimulator.SimRuntime.iOS-';
+        // maestro-runner derives its WDA cache key from the runtime identifier, not from the runtime
+        // version. These values can differ for patched runtimes, for example the iOS-26-3 identifier
+        // can report version 26.3.1.
+        const iosRuntimeVersions = [
+            ...new Set(iosRuntimes.map(runtime => runtime.identifier.slice(iosRuntimeIdentifierPrefix.length).replaceAll('-', '.'))),
+        ];
+        if (iosRuntimeVersions.length === 0) {
+            logger.info('Skipping the prebuilt WebDriverAgent cache because no iOS runtime is available.');
+            return;
+        }
+        const tempDirectory = await fs_1.default.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'install_maestro_runner_wda_cache'));
+        try {
+            const archivePath = path_1.default.join(tempDirectory, 'wda-cache.tar.gz');
+            const directArchiveUrl = `https://storage.googleapis.com/turtle-v2/maestro-runner-wda-cache/` +
+                `xcode-${encodeURIComponent(xcodeVersion)}-wda-${encodeURIComponent(wdaVersion)}.tar.gz`;
+            const proxiedArchiveUrl = (0, download_1.getProxiedDownloadUrl)({
+                directUrl: directArchiveUrl,
+                proxyBaseUrl: env.EAS_BUILD_COCOAPODS_CACHE_URL,
+            });
+            logger.info(`Downloading the prebuilt WebDriverAgent cache for Xcode ${xcodeVersion}`);
+            if (proxiedArchiveUrl) {
+                try {
+                    await (0, downloader_1.default)(proxiedArchiveUrl, archivePath, {
+                        retry: 3,
+                        timeout: MAESTRO_RUNNER_WDA_CACHE_DOWNLOAD_TIMEOUT_MS,
+                    });
+                }
+                catch (err) {
+                    logger.debug({ err }, 'Failed to download the prebuilt WebDriverAgent cache via the proxy; falling back to the direct URL.');
+                    await (0, downloader_1.default)(directArchiveUrl, archivePath, {
+                        retry: 3,
+                        timeout: MAESTRO_RUNNER_WDA_CACHE_DOWNLOAD_TIMEOUT_MS,
+                    });
+                }
+            }
+            else {
+                await (0, downloader_1.default)(directArchiveUrl, archivePath, {
+                    retry: 3,
+                    timeout: MAESTRO_RUNNER_WDA_CACHE_DOWNLOAD_TIMEOUT_MS,
+                });
+            }
+            await fs_1.default.promises.mkdir(maestroRunnerHome, { recursive: true });
+            await (0, turtle_spawn_1.default)('tar', ['-xzf', archivePath, '-C', maestroRunnerHome], { logger, env });
+            const genericProductsDirectory = path_1.default.join(maestroRunnerHome, 'cache', 'wda-builds', 'generic', 'DerivedData', 'Build', 'Products');
+            for (const runtimeVersion of iosRuntimeVersions) {
+                const productsDirectory = path_1.default.join(maestroRunnerHome, 'cache', 'wda-builds', `sim-ios${runtimeVersion}-iphone`, 'DerivedData', 'Build', 'Products');
+                await fs_1.default.promises.cp(genericProductsDirectory, productsDirectory, { recursive: true });
+            }
+            logger.info(`Installed the prebuilt WebDriverAgent cache for iOS ${iosRuntimeVersions.join(', ')}.`);
+        }
+        finally {
+            await fs_1.default.promises.rm(tempDirectory, { force: true, recursive: true });
+        }
     }
-    catch (error) {
-        throw new eas_build_job_1.SystemError('Failed to get Xcode version', { cause: error });
+    catch (err) {
+        logger.warn({ err }, 'Failed to install the prebuilt WebDriverAgent cache. maestro-runner will build WebDriverAgent when it is needed.');
     }
-    const xcodeVersion = semver_1.default.coerce(/^Xcode\s+(\S+)/m.exec(stdout)?.[1])?.version;
-    if (!xcodeVersion) {
-        throw new eas_build_job_1.SystemError(`Failed to parse Xcode version from xcodebuild output: ${stdout.trim()}`);
+}
+async function getMaestroRunnerWdaVersion({ maestroRunnerHome, }) {
+    try {
+        const packageJson = JSON.parse(await fs_1.default.promises.readFile(path_1.default.join(maestroRunnerHome, 'drivers', 'ios', 'WebDriverAgent', 'package.json'), 'utf8'));
+        return typeof packageJson.version === 'string' ? packageJson.version : null;
+    }
+    catch {
+        return null;
     }
-    return xcodeVersion;
 }
 async function getMaestroVersion({ env, backend, }) {
     switch (backend) {

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

@@ -0,0 +1,12 @@
+import { bunyan } from '@expo/logger';
+import { BuildFunction, BuildRuntimePlatform, BuildStepEnv } from '@expo/steps';
+export declare function createLaunchApplicationFunction(): BuildFunction;
+export declare function launchApplicationAsync({ applicationIdentifier, activityName, launchArgs, openUrl, runtimePlatform, env, logger, }: {
+    applicationIdentifier: string;
+    activityName?: string;
+    launchArgs?: string[];
+    openUrl?: string;
+    runtimePlatform: BuildRuntimePlatform;
+    env: BuildStepEnv;
+    logger: bunyan;
+}): Promise<void>;