@expo/build-tools 22.0.0 → 22.3.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/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");
@@ -43,6 +45,7 @@ const sendSlackMessage_1 = require("./functions/sendSlackMessage");
 const startAgentDeviceRemoteSession_1 = require("./functions/startAgentDeviceRemoteSession");
 const startAndroidEmulator_1 = require("./functions/startAndroidEmulator");
 const startArgentRemoteSession_1 = require("./functions/startArgentRemoteSession");
+const startAppiumRemoteSession_1 = require("./functions/startAppiumRemoteSession");
 const startCuttlefishDevice_1 = require("./functions/startCuttlefishDevice");
 const startIosSimulator_1 = require("./functions/startIosSimulator");
 const startIosSimulatorRecordings_1 = require("./functions/startIosSimulatorRecordings");
@@ -69,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)(),
@@ -90,6 +95,7 @@ function getEasFunctions(ctx) {
         (0, parseXcactivitylog_1.parseXcactivitylogFunction)(),
         (0, startAgentDeviceRemoteSession_1.createStartAgentDeviceRemoteSessionBuildFunction)(ctx),
         (0, startArgentRemoteSession_1.createStartArgentRemoteSessionBuildFunction)(ctx),
+        (0, startAppiumRemoteSession_1.createStartAppiumRemoteSessionBuildFunction)(ctx),
         (0, startAndroidEmulator_1.createStartAndroidEmulatorBuildFunction)(),
         (0, startCuttlefishDevice_1.createStartCuttlefishDeviceBuildFunction)(),
         (0, startIosSimulator_1.createStartIosSimulatorBuildFunction)(),

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,9 +8,11 @@ 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"));
@@ -44,7 +46,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 +71,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 +117,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);
@@ -133,3 +169,36 @@ async function downloadBuildAsync({ logger, buildId, graphqlClient, robotAccessT
     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')}`);
     return { artifactPath: matchingFiles[0] };
 }
+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.d.ts

@@ -1,2 +1,7 @@
-import { BuildFunction } from '@expo/steps';
+import { bunyan } from '@expo/logger';
+import { BuildFunction, BuildStepEnv } from '@expo/steps';
 export declare function createInstallMaestroBuildFunction(): BuildFunction;
+export declare function installIdbFromBrew({ logger, env, }: {
+    logger: bunyan;
+    env: BuildStepEnv;
+}): Promise<void>;

package/dist/steps/functions/installMaestro.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createInstallMaestroBuildFunction = createInstallMaestroBuildFunction;
+exports.installIdbFromBrew = installIdbFromBrew;
+const eas_build_job_1 = require("@expo/eas-build-job");
 const results_1 = require("@expo/results");
 const steps_1 = require("@expo/steps");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
@@ -11,6 +13,7 @@ const assert_1 = __importDefault(require("assert"));
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
+const semver_1 = __importDefault(require("semver"));
 const maestroBackend_1 = require("./maestroBackend");
 const datadog_1 = require("../../datadog");
 function createInstallMaestroBuildFunction() {
@@ -94,17 +97,49 @@ function createInstallMaestroBuildFunction() {
                 logger.info('Installing IDB');
                 await installIdbFromBrew({ logger, env });
             }
-            // Skip installing if the input sets a specific Maestro version to install
-            // and it is already installed which happens when developing on a local computer.
-            if (!currentMaestroVersion ||
-                (requestedVersion && requestedVersion !== currentMaestroVersion)) {
-                switch (backend) {
-                    case 'maestro':
+            switch (backend) {
+                case 'maestro':
+                    // Skip installing if the input sets a specific Maestro version to install
+                    // and it is already installed, either on a build image or a local computer.
+                    if (!currentMaestroVersion ||
+                        (requestedVersion && requestedVersion !== currentMaestroVersion)) {
                         await installMaestro({ version: requestedVersion, global, logger, env });
-                        break;
-                    case 'maestro-runner':
-                        await installMaestroRunner({ version: requestedVersion, global, logger, env });
-                        break;
+                    }
+                    break;
+                case 'maestro-runner': {
+                    let maestroRunnerVersionToInstall = requestedVersion;
+                    const currentMaestroRunnerVersion = semver_1.default.coerce(currentMaestroVersion)?.version;
+                    const requestedMaestroRunnerVersion = requestedVersion && requestedVersion !== 'latest'
+                        ? semver_1.default.valid(requestedVersion)
+                        : null;
+                    if (global.runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN &&
+                        ((requestedMaestroRunnerVersion &&
+                            semver_1.default.gte(requestedMaestroRunnerVersion, '1.1.16')) ||
+                            requestedVersion === 'latest' ||
+                            (requestedVersion === undefined &&
+                                (!currentMaestroRunnerVersion || semver_1.default.gt(currentMaestroRunnerVersion, '1.1.15'))))) {
+                        const xcodeVersion = await getXcodeVersion({ 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 (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.`);
+                            }
+                            maestroRunnerVersionToInstall = '1.1.15';
+                            logger.info(`Xcode ${xcodeVersion} requires maestro-runner ${maestroRunnerVersionToInstall}.`);
+                        }
+                    }
+                    if (!currentMaestroVersion ||
+                        (maestroRunnerVersionToInstall &&
+                            maestroRunnerVersionToInstall !== currentMaestroVersion)) {
+                        await installMaestroRunner({
+                            version: maestroRunnerVersionToInstall,
+                            global,
+                            logger,
+                            env,
+                        });
+                    }
+                    break;
                 }
             }
             const maestroVersionResult = await (0, results_1.asyncResult)(getMaestroVersion({ env, backend }));
@@ -121,6 +156,20 @@ function createInstallMaestroBuildFunction() {
         },
     });
 }
+async function getXcodeVersion({ 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 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()}`);
+    }
+    return xcodeVersion;
+}
 async function getMaestroVersion({ env, backend, }) {
     switch (backend) {
         case 'maestro': {
@@ -156,10 +205,10 @@ async function installMaestroRunner({ global, version, logger, env, }) {
         const binDir = path_1.default.join(env.HOME, '.maestro-runner', 'bin');
         global.updateEnv({
             ...global.env,
-            PATH: `${global.env.PATH}:${binDir}`,
+            PATH: `${binDir}:${global.env.PATH}`,
         });
-        env.PATH = `${env.PATH}:${binDir}`;
-        process.env.PATH = `${process.env.PATH}:${binDir}`;
+        env.PATH = `${binDir}:${env.PATH}`;
+        process.env.PATH = `${binDir}:${process.env.PATH}`;
     }
     finally {
         await fs_1.default.promises.rm(tempDirectory, { force: true, recursive: true });
@@ -193,10 +242,10 @@ async function installMaestro({ global, version, logger, env, }) {
         const maestroBinDir = path_1.default.join(maestroDir, 'bin');
         global.updateEnv({
             ...global.env,
-            PATH: `${global.env.PATH}:${maestroBinDir}`,
+            PATH: `${maestroBinDir}:${global.env.PATH}`,
         });
-        env.PATH = `${env.PATH}:${maestroBinDir}`;
-        process.env.PATH = `${process.env.PATH}:${maestroBinDir}`;
+        env.PATH = `${maestroBinDir}:${env.PATH}`;
+        process.env.PATH = `${maestroBinDir}:${process.env.PATH}`;
     }
     finally {
         await fs_1.default.promises.rm(tempDirectory, { force: true, recursive: true });
@@ -204,7 +253,7 @@ async function installMaestro({ global, version, logger, env, }) {
 }
 async function isIdbInstalled({ env }) {
     try {
-        await (0, turtle_spawn_1.default)('idb', ['-h'], { ignoreStdio: true, env });
+        await (0, turtle_spawn_1.default)('idb_companion', ['--version'], { ignoreStdio: true, env });
         return true;
     }
     catch {
@@ -212,22 +261,47 @@ async function isIdbInstalled({ env }) {
     }
 }
 async function installIdbFromBrew({ logger, env, }) {
-    // Unfortunately our Mac images sometimes have two Homebrew
-    // installations. We should use the ARM64 one, located in /opt/homebrew.
-    const brewPath = '/opt/homebrew/bin/brew';
-    const localEnv = {
-        ...env,
-        HOMEBREW_NO_AUTO_UPDATE: '1',
-        HOMEBREW_NO_INSTALL_CLEANUP: '1',
-    };
-    await (0, turtle_spawn_1.default)(brewPath, ['tap', 'facebook/fb'], {
-        env: localEnv,
-        logger,
-    });
-    await (0, turtle_spawn_1.default)(brewPath, ['install', 'idb-companion'], {
-        env: localEnv,
-        logger,
-    });
+    try {
+        // Unfortunately our Mac images sometimes have two Homebrew
+        // installations. We should use the ARM64 one, located in /opt/homebrew.
+        const brewPath = '/opt/homebrew/bin/brew';
+        const localEnv = {
+            ...env,
+            HOMEBREW_NO_AUTO_UPDATE: '1',
+            HOMEBREW_NO_INSTALL_CLEANUP: '1',
+        };
+        logger.info('Tapping facebook/fb...');
+        await (0, turtle_spawn_1.default)(brewPath, ['tap', 'facebook/fb'], {
+            env: localEnv,
+            logger,
+        });
+        const brewRepo = await (0, turtle_spawn_1.default)(brewPath, ['--repo', 'facebook/fb'], {
+            env: localEnv,
+        });
+        const tapPath = brewRepo.stdout.trim();
+        // c0386793f59da10c619787f2aa18d938ef1d69c9 is hash for 1.1.8 release,
+        // last known compatible version + post_install fix.
+        const gitSha = 'c0386793f59da10c619787f2aa18d938ef1d69c9';
+        logger.info('Checking out facebook/fb at idb_companion@1.1.8...');
+        await (0, turtle_spawn_1.default)('git', ['fetch', 'origin', gitSha], {
+            cwd: tapPath,
+            logger,
+        });
+        await (0, turtle_spawn_1.default)('git', ['checkout', gitSha], {
+            cwd: tapPath,
+            logger,
+        });
+        logger.info('Installing idb_companion v1.1.8...');
+        await (0, turtle_spawn_1.default)(brewPath, ['install', 'facebook/fb/idb-companion'], {
+            env: localEnv,
+            logger,
+        });
+    }
+    catch (err) {
+        throw new eas_build_job_1.SystemError('Failed to install idb-companion required for Maestro to run.', {
+            cause: err,
+        });
+    }
 }
 async function isJavaInstalled({ env }) {
     try {

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

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

package/dist/steps/functions/launchApplication.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLaunchApplicationFunction = createLaunchApplicationFunction;
+exports.launchApplicationAsync = launchApplicationAsync;
+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"));
+function createLaunchApplicationFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'launch_application',
+        name: 'Launch application',
+        __metricsId: 'eas/launch_application',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'application_identifier',
+                required: true,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'activity_name',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+        ],
+        fn: async ({ global, logger }, { inputs, env }) => {
+            const applicationIdentifier = parseNonEmptyStringInput(inputs.application_identifier.value, 'application_identifier');
+            const activityName = inputs.activity_name.value === undefined
+                ? undefined
+                : parseNonEmptyStringInput(inputs.activity_name.value, 'activity_name');
+            await launchApplicationAsync({
+                applicationIdentifier,
+                activityName,
+                runtimePlatform: global.runtimePlatform,
+                env,
+                logger,
+            });
+        },
+    });
+}
+async function launchApplicationAsync({ applicationIdentifier, activityName, runtimePlatform, env, logger, }) {
+    if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
+        logger.info(`Launching ${applicationIdentifier}.`);
+        await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'launch', 'booted', applicationIdentifier], {
+            env,
+            logger,
+        });
+        return;
+    }
+    if (!activityName) {
+        throw new eas_build_job_1.UserError('EAS_LAUNCH_APPLICATION_MISSING_ACTIVITY', 'Launching an Android application requires activity_name.');
+    }
+    logger.info(`Launching ${applicationIdentifier}.`);
+    await (0, turtle_spawn_1.default)('adb', ['shell', 'am', 'start', '-n', `${applicationIdentifier}/${activityName}`], {
+        env,
+        logger,
+    });
+}
+function parseNonEmptyStringInput(value, inputName) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new eas_build_job_1.UserError('EAS_LAUNCH_APPLICATION_INVALID_INPUT', `Input "${inputName}" must be a non-empty string. Pass the "${inputName}" output from eas/install_build.`);
+    }
+    return value;
+}