@expo/build-tools 22.0.0 → 22.2.0

package/dist/steps/functions/maestroTests.js

@@ -11,6 +11,7 @@ const promises_1 = __importDefault(require("fs/promises"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const zod_1 = require("zod");
+const maestroBackend_1 = require("./maestroBackend");
 const maestroFlowDiscovery_1 = require("./maestroFlowDiscovery");
 const maestroResultParser_1 = require("./maestroResultParser");
 const maestroScreenshots_1 = require("./maestroScreenshots");
@@ -36,28 +37,40 @@ function isFilesystemError(err) {
     const code = err.code;
     return (code === 'ENOSPC' || code === 'EACCES' || code === 'EROFS' || code === 'EIO' || code === 'EPERM');
 }
-// `outputPath: null` means "let maestro pick" (no --output flag). Junit and
-// other declared formats pass an explicit path so downstream upload steps
-// know where to find the result.
-function buildMaestroArgs(args) {
-    const out = ['test'];
-    if (args.output_format) {
-        out.push(`--format=${args.output_format.toUpperCase()}`);
-    }
-    if (args.outputPath) {
-        out.push(`--output=${args.outputPath}`);
-    }
-    if (args.shards !== undefined) {
-        out.push(`--shard-split=${args.shards}`);
-    }
-    if (args.include_tags) {
-        out.push(`--include-tags=${args.include_tags}`);
-    }
-    if (args.exclude_tags) {
-        out.push(`--exclude-tags=${args.exclude_tags}`);
+function buildMaestroArgs({ backend, platform, flowPaths, output, outputFormat, shards, includeTags, excludeTags, }) {
+    switch (backend) {
+        case 'maestro': {
+            const args = ['test'];
+            if (outputFormat) {
+                args.push(`--format=${outputFormat.toUpperCase()}`);
+            }
+            if (output) {
+                args.push(`--output=${output}`);
+            }
+            if (shards !== undefined) {
+                args.push(`--shard-split=${shards}`);
+            }
+            if (includeTags) {
+                args.push(`--include-tags=${includeTags}`);
+            }
+            if (excludeTags) {
+                args.push(`--exclude-tags=${excludeTags}`);
+            }
+            args.push(...flowPaths);
+            return { executable: 'maestro', args };
+        }
+        case 'maestro-runner': {
+            const args = [`--platform=${platform}`, 'test', `--output=${output}`, '--flatten'];
+            if (includeTags) {
+                args.push(`--include-tags=${includeTags}`);
+            }
+            if (excludeTags) {
+                args.push(`--exclude-tags=${excludeTags}`);
+            }
+            args.push(...flowPaths);
+            return { executable: 'maestro-runner', args };
+        }
     }
-    out.push(...args.flow_path);
-    return out;
 }
 function createMaestroTestsBuildFunction(ctx) {
     return new steps_1.BuildFunction({
@@ -115,6 +128,11 @@ function createMaestroTestsBuildFunction(ctx) {
                 required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'backend',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
         ],
         outputProviders: [
             steps_1.BuildStepOutput.createProvider({ id: 'junit_report_directory', required: true }),
@@ -156,12 +174,25 @@ function createMaestroTestsBuildFunction(ctx) {
             if (finalReportPath !== undefined) {
                 outputs.final_report_path.set(finalReportPath);
             }
+            // Resolved after the output assignments above: an invalid backend input or
+            // EAS_MAESTRO_BACKEND throws, and downstream `if: always()` upload steps still
+            // need the outputs interpolated.
+            const backend = (0, maestroBackend_1.resolveMaestroBackend)({
+                input: inputs.backend.value,
+                env,
+            });
             const flowPaths = parseInput(FlowPathSchema, inputs.flow_path.value, 'flow_path must be a non-empty array of non-empty strings.');
             const retries = parseInput(RetriesSchema, inputs.retries.value, 'retries must be a non-negative integer.');
             const shards = parseInput(ShardsSchema, inputs.shards.value, 'shards must be a positive integer.');
             const androidConnectionMode = parseInput(AndroidConnectionModeSchema, inputs.android_connection_mode.value ||
                 env.EAS_MAESTRO_ANDROID_CONNECTION_MODE ||
                 undefined, 'android_connection_mode and EAS_MAESTRO_ANDROID_CONNECTION_MODE must be either "adb" or "dadb".');
+            if (backend === 'maestro-runner' && shards !== undefined && shards > 1) {
+                throw new eas_build_job_1.UserError('ERR_MAESTRO_INVALID_INPUT', 'maestro-runner does not support EAS Maestro test sharding. Remove shards or set it to 1.');
+            }
+            if (backend === 'maestro-runner' && outputFormat !== undefined && outputFormat !== 'junit') {
+                throw new eas_build_job_1.UserError('ERR_MAESTRO_INVALID_INPUT', `maestro-runner only supports the "junit" output_format, but received "${outputFormat}".`);
+            }
             const retryFailedOnly = inputs.retry_failed_only.value;
             try {
                 await promises_1.default.mkdir(junitReportDirectory, { recursive: true });
@@ -169,7 +200,7 @@ function createMaestroTestsBuildFunction(ctx) {
             catch (err) {
                 throw new eas_build_job_1.SystemError('Failed to create JUnit report directory', { cause: err });
             }
-            // Legacy-only (Maestro < 2.6.0 reports carry no `file=` attribute): the
+            // Official Maestro legacy-only (Maestro < 2.6.0 reports carry no `file=` attribute): the
             // flow scan is built lazily in the retry branch below and memoized so
             // retries share one scan. Never runs when the report has `file=`.
             let nameToPathPromise;
@@ -178,14 +209,20 @@ function createMaestroTestsBuildFunction(ctx) {
             //   numeric err.status → maestro exited non-zero → retry.
             //   else (signal-only, OOM kill, unknown) → infra → SystemError, never
             //     downgraded to "tests failed".
-            // Retry-failed-only (junit mode): after a failed attempt, subset to the failing
-            // flows. The failed-flow parsers return null when the JUnit cannot be
-            // trusted; we then fall through to dumb retry (re-run everything).
+            // Retry-failed-only: after a failed attempt, subset to the failing flows. The
+            // failed-flow parsers return null when a report cannot be trusted; we then fall
+            // through to dumb retry (re-run everything).
             let flowsToRun = flowPaths;
             let lastAttemptExitCode = null;
             const harvested = [];
+            const reportDirectories = backend === 'maestro' ? [junitReportDirectory] : [];
             const totalAttempts = retries + 1;
-            if (platform === 'android' && androidConnectionMode === 'dadb') {
+            if (backend === 'maestro-runner' &&
+                platform === 'android' &&
+                androidConnectionMode === 'dadb') {
+                logger.info('maestro-runner does not support DADB. Using the default ADB connection.');
+            }
+            if (backend === 'maestro' && platform === 'android' && androidConnectionMode === 'dadb') {
                 try {
                     const adbOverrideDirectoryPath = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'maestro-tests-adb-override-'));
                     await promises_1.default.writeFile(path_1.default.join(adbOverrideDirectoryPath, 'adb'), '#!/bin/sh\nexit 1\n', {
@@ -213,23 +250,37 @@ function createMaestroTestsBuildFunction(ctx) {
                 // Do not restart ADB or remove the override. This keeps Maestro in direct DADB mode.
             }
             for (let attempt = 0; attempt <= retries; attempt++) {
+                // maestro-runner writes its JUnit report and screenshot metadata to this directory.
+                const runnerOutputDirectory = path_1.default.join(testsDirectory, `${platform}-maestro-runner-attempt-${attempt}`);
                 const outputPath = outputFormat === 'junit'
                     ? path_1.default.join(junitReportDirectory, `${platform}-maestro-junit-attempt-${attempt}.xml`)
-                    : outputFormat
+                    : backend === 'maestro' && outputFormat
                         ? path_1.default.join(testsDirectory, `${platform}-maestro-${outputFormat}.${outputFormat}`)
                         : null;
-                const maestroArgs = buildMaestroArgs({
-                    flow_path: flowsToRun,
-                    outputPath,
-                    output_format: outputFormat,
+                const { executable, args: maestroArgs } = buildMaestroArgs({
+                    backend,
+                    platform,
+                    flowPaths: flowsToRun,
+                    output: backend === 'maestro-runner' ? runnerOutputDirectory : outputPath,
+                    outputFormat,
                     shards,
-                    include_tags: includeTags,
-                    exclude_tags: excludeTags,
+                    includeTags,
+                    excludeTags,
                 });
-                logger.info(`Running maestro (attempt ${attempt + 1}/${totalAttempts}): maestro ${maestroArgs.join(' ')}`);
+                logger.info(`Running ${executable} (attempt ${attempt + 1}/${totalAttempts}): ${executable} ${maestroArgs.join(' ')}`);
+                // The runner output directory is deterministic and can survive a prior run; clear it
+                // best-effort so a crash before it writes fresh output can't resurrect stale results.
+                if (backend === 'maestro-runner') {
+                    try {
+                        await promises_1.default.rm(runnerOutputDirectory, { recursive: true, force: true });
+                    }
+                    catch (err) {
+                        logger.warn({ err }, `Failed to clear ${runnerOutputDirectory} before the attempt.`);
+                    }
+                }
                 const attemptStartedAtMs = Date.now();
                 try {
-                    await (0, turtle_spawn_1.default)('maestro', maestroArgs, {
+                    await (0, turtle_spawn_1.default)(executable, maestroArgs, {
                         cwd: stepCtx.workingDirectory,
                         env: spawnEnv,
                         logger,
@@ -239,53 +290,100 @@ function createMaestroTestsBuildFunction(ctx) {
                 }
                 catch (err) {
                     if (err && (err.code === 'ENOENT' || err.code === 'EACCES')) {
-                        throw new eas_build_job_1.SystemError('Failed to invoke maestro', { cause: err });
+                        throw new eas_build_job_1.SystemError(`Failed to invoke ${executable}`, { cause: err });
                     }
                     if (err && typeof err.status === 'number') {
                         lastAttemptExitCode = err.status;
                     }
                     else {
-                        throw new eas_build_job_1.SystemError('Unexpected spawn failure invoking maestro', { cause: err });
+                        throw new eas_build_job_1.SystemError(`Unexpected spawn failure invoking ${executable}`, {
+                            cause: err,
+                        });
+                    }
+                }
+                // maestro-runner writes a report directory. Copy its JUnit file into the existing
+                // per-attempt directory so retry parsing and final report merging remain shared.
+                if (backend === 'maestro-runner' && outputPath) {
+                    try {
+                        await promises_1.default.copyFile(path_1.default.join(runnerOutputDirectory, 'junit-report.xml'), outputPath);
+                    }
+                    catch (err) {
+                        logger.warn({ err }, `Failed to collect the maestro-runner JUnit report for attempt ${attempt + 1}.`);
                     }
                 }
+                if (backend === 'maestro-runner') {
+                    reportDirectories.push(runnerOutputDirectory);
+                }
                 // Harvest this attempt's failure screenshots before any retry subsetting. Gated on
                 // junit: test-case-result rows (and therefore the summary icons) only exist for junit
                 // runs, so harvesting other formats would just create orphan artifacts the website hides.
                 if (outputFormat === 'junit') {
-                    const failedFlowNames = outputPath
-                        ? await (0, maestroResultParser_1.parseFailedFlowNamesFromJUnitFile)(outputPath)
-                        : new Set();
-                    harvested.push(...(await (0, maestroScreenshots_1.harvestFailureScreenshotsAsync)({
-                        testsDirectory,
-                        capturedSinceMs: attemptStartedAtMs,
-                        attemptIndex: attempt,
-                        failedFlowNames,
-                        logger,
-                    })));
+                    let screenshots;
+                    switch (backend) {
+                        case 'maestro': {
+                            const failedFlowNames = outputPath
+                                ? await (0, maestroResultParser_1.parseFailedFlowNamesFromJUnitFile)(outputPath)
+                                : new Set();
+                            screenshots = await (0, maestroScreenshots_1.harvestFailureScreenshotsAsync)({
+                                testsDirectory,
+                                capturedSinceMs: attemptStartedAtMs,
+                                attemptIndex: attempt,
+                                failedFlowNames,
+                                logger,
+                            });
+                            break;
+                        }
+                        case 'maestro-runner':
+                            screenshots = await (0, maestroScreenshots_1.harvestMaestroRunnerFailureScreenshotsAsync)({
+                                reportDirectory: runnerOutputDirectory,
+                                capturedSinceMs: attemptStartedAtMs,
+                                attemptIndex: attempt,
+                                logger,
+                            });
+                            break;
+                    }
+                    harvested.push(...screenshots);
                 }
                 if (lastAttemptExitCode === 0 || attempt === retries) {
                     break;
                 }
-                if (retryFailedOnly && outputFormat === 'junit' && outputPath) {
+                if (retryFailedOnly &&
+                    (backend === 'maestro-runner' || (outputFormat === 'junit' && outputPath))) {
                     let failed;
-                    if (await (0, maestroResultParser_1.junitFileHasFileAttrs)(outputPath)) {
-                        failed = await (0, maestroResultParser_1.parseFailedFlowsFromFileAttrs)({
-                            junitFile: outputPath,
-                            workingDirectory: stepCtx.workingDirectory,
-                        });
-                    }
-                    else {
-                        // Legacy (Maestro < 2.6.0): map failed testcase names back to flow
-                        // paths via the flow-file scan. DELETE this arm once the fleet is
-                        // on >= 2.6.0.
-                        const nameToPath = await (nameToPathPromise ??= (0, maestroFlowDiscovery_1.buildFlowNameToPathMap)({
-                            inputFlowPaths: flowPaths,
-                            projectRoot: stepCtx.workingDirectory,
-                            logger,
-                        }));
-                        failed = nameToPath
-                            ? await (0, maestroResultParser_1.parseFailedFlowsFromJUnit)({ junitFile: outputPath, nameToPath })
-                            : null;
+                    switch (backend) {
+                        case 'maestro-runner':
+                            failed = await (0, maestroResultParser_1.parseFailedFlowsFromMaestroRunnerReport)({
+                                reportDirectory: runnerOutputDirectory,
+                                workingDirectory: stepCtx.workingDirectory,
+                            });
+                            break;
+                        case 'maestro':
+                            if (!outputPath) {
+                                failed = null;
+                                break;
+                            }
+                            if (await (0, maestroResultParser_1.junitFileHasFileAttrs)(outputPath)) {
+                                failed = await (0, maestroResultParser_1.parseFailedFlowsFromFileAttrs)({
+                                    junitFile: outputPath,
+                                    workingDirectory: stepCtx.workingDirectory,
+                                });
+                                break;
+                            }
+                            // Legacy (Maestro < 2.6.0): map failed testcase names back to flow
+                            // paths via the flow-file scan. DELETE this arm once the fleet is
+                            // on >= 2.6.0.
+                            const nameToPath = await (nameToPathPromise ??= (0, maestroFlowDiscovery_1.buildFlowNameToPathMap)({
+                                inputFlowPaths: flowPaths,
+                                projectRoot: stepCtx.workingDirectory,
+                                logger,
+                            }));
+                            failed = nameToPath
+                                ? await (0, maestroResultParser_1.parseFailedFlowsFromJUnit)({
+                                    junitFile: outputPath,
+                                    nameToPath,
+                                })
+                                : null;
+                            break;
                     }
                     if (failed !== null && failed.length > 0) {
                         flowsToRun = failed;
@@ -335,7 +433,13 @@ function createMaestroTestsBuildFunction(ctx) {
             // Upload before the ERR_MAESTRO_TESTS_FAILED throw below so fully-failed runs (which need
             // screenshots most) still upload. Harvest only ran for junit, so guard the same way.
             if (outputFormat === 'junit') {
-                await uploadFailureScreenshotsAsync({ harvested, junitReportDirectory, ctx, logger });
+                await uploadFailureScreenshotsAsync({
+                    harvested,
+                    backend,
+                    reportDirectories,
+                    ctx,
+                    logger,
+                });
             }
             // The retry loop exits via success (0), numeric status (retryable),
             // or throw (infra). A non-null non-zero status means the user's tests
@@ -349,14 +453,28 @@ function createMaestroTestsBuildFunction(ctx) {
 // Reduce harvested failure screenshots to what's worth uploading, then upload them as workflow
 // artifacts. Best-effort and verdict-neutral: never throws, so a screenshot problem can't mask
 // the maestro test result. Caller guards on junit (harvest only runs for junit).
-async function uploadFailureScreenshotsAsync({ harvested, junitReportDirectory, ctx, logger, }) {
+async function uploadFailureScreenshotsAsync({ harvested, backend, reportDirectories, ctx, logger, }) {
     // Reduce to the attempts worth uploading — every failed attempt for flaky flows, only the final
     // attempt for all-failed flows. See computePureFailureFlowNames / selectFailureScreenshots.
     // Guard the JUnit re-parse so a malformed/missing report can't throw past here and mask the
     // test verdict (the whole step is verdict-neutral for screenshots).
     let selected;
     try {
-        const pureFailureFlowNames = (0, maestroScreenshots_1.computePureFailureFlowNames)(await (0, maestroResultParser_1.parseJUnitTestCases)(junitReportDirectory));
+        let flowResults;
+        switch (backend) {
+            case 'maestro':
+                flowResults = (await Promise.all(reportDirectories.map(directory => (0, maestroResultParser_1.parseJUnitTestCases)(directory)))).flat();
+                break;
+            case 'maestro-runner': {
+                const results = await Promise.all(reportDirectories.map(directory => (0, maestroResultParser_1.parseMaestroRunnerReport)(directory)));
+                // Use whichever reports parsed. An unreadable report (e.g. a final retry that crashed
+                // before writing report.json) contributes no flows rather than discarding screenshots
+                // harvested from the attempts that did report — mirroring the maestro path above.
+                flowResults = results.flatMap(result => result?.flows ?? []);
+                break;
+            }
+        }
+        const pureFailureFlowNames = (0, maestroScreenshots_1.computePureFailureFlowNames)(flowResults);
         selected = (0, maestroScreenshots_1.selectFailureScreenshots)(harvested, pureFailureFlowNames);
     }
     catch (err) {

package/dist/steps/functions/restoreBuildCache.js

@@ -201,12 +201,13 @@ async function restoreGradleCacheAsync({ logger, workingDirectory, env, secrets,
         logger.info(`Restoring Gradle cache key: ${cacheKey}`);
         const gradleCachesPath = path_1.default.join(os_1.default.homedir(), '.gradle', 'caches');
         const buildCachePath = path_1.default.join(gradleCachesPath, 'build-cache-1');
+        const journalPath = path_1.default.join(gradleCachesPath, 'journal-1');
         const { archivePath, matchedKey } = await (0, restoreCache_1.downloadCacheAsync)({
             logger,
             jobId,
             expoApiServerURL,
             robotAccessToken,
-            paths: [buildCachePath],
+            paths: [buildCachePath, journalPath],
             key: cacheKey,
             keyPrefixes: [gradleCacheKey_1.GRADLE_CACHE_KEY_PREFIX],
             platform: eas_build_job_1.Platform.ANDROID,

package/dist/steps/functions/saveBuildCache.js

@@ -117,6 +117,7 @@ async function saveGradleCacheAsync({ logger, workingDirectory, env, secrets, })
     }
     const gradleCachesPath = path_1.default.join(os_1.default.homedir(), '.gradle', 'caches');
     const buildCachePath = path_1.default.join(gradleCachesPath, 'build-cache-1');
+    const journalPath = path_1.default.join(gradleCachesPath, 'journal-1');
     try {
         await fs_1.default.promises.access(buildCachePath);
     }
@@ -130,9 +131,10 @@ async function saveGradleCacheAsync({ logger, workingDirectory, env, secrets, })
         const jobId = (0, nullthrows_1.default)(env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set');
         const robotAccessToken = (0, nullthrows_1.default)(secrets?.robotAccessToken, 'Robot access token is required for cache operations');
         const expoApiServerURL = (0, nullthrows_1.default)(env.__API_SERVER_URL, '__API_SERVER_URL is not set');
+        await fs_1.default.promises.mkdir(journalPath, { recursive: true });
         logger.info('Compressing Gradle build cache...');
         const { archivePath } = await (0, saveCache_1.compressCacheAsync)({
-            paths: [buildCachePath],
+            paths: [buildCachePath, journalPath],
             workingDirectory: gradleCachesPath,
             verbose: env.EXPO_DEBUG === '1',
             logger,
@@ -146,7 +148,7 @@ async function saveGradleCacheAsync({ logger, workingDirectory, env, secrets, })
             robotAccessToken,
             archivePath,
             key: cacheKey,
-            paths: [buildCachePath],
+            paths: [buildCachePath, journalPath],
             size,
             platform: eas_build_job_1.Platform.ANDROID,
         });

package/dist/steps/functions/saveCache.js

@@ -303,7 +303,10 @@ async function compressCacheAsync({ paths, workingDirectory, verbose, logger, })
         for (const { absolutePath, archivePath: targetRelativePath } of allFiles) {
             const targetPath = path_1.default.join(tempDir, targetRelativePath);
             await fs_1.default.promises.mkdir(path_1.default.dirname(targetPath), { recursive: true });
+            // We want to keep source timestamps since Gradle may check them when pruning cache.
+            const { atime, mtime } = await fs_1.default.promises.stat(absolutePath);
             await fs_1.default.promises.copyFile(absolutePath, targetPath);
+            await fs_1.default.promises.utimes(targetPath, atime, mtime);
             if (verbose) {
                 logger.info(`- ${targetRelativePath}`);
             }

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -42,6 +42,11 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'max_duration_seconds',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+            }),
         ],
         fn: async ({ logger, global }, { inputs, env, signal }) => {
             // Fail fast before any expensive setup if the injected env
@@ -54,6 +59,7 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
             const packageVersion = inputs.package_version.value;
             // A missing or non-positive value disables the idle timeout (opt-in feature).
             const maxIdleTimeMinutes = inputs.max_idle_time_minutes.value;
+            const maxDurationSeconds = inputs.max_duration_seconds?.value;
             const { runtimePlatform } = global;
             logger.info(`Starting agent-device remote session (version: ${packageVersion ?? 'latest'}, runtime: ${runtimePlatform}).`);
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
@@ -115,6 +121,7 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                     ctx,
                     deviceRunSessionId,
                     logger,
+                    maxDurationSeconds,
                     signal,
                     idleTimeout: maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
                         ? {

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

@@ -0,0 +1,17 @@
+import { type bunyan } from '@expo/logger';
+import { BuildFunction, BuildRuntimePlatform, type BuildStepEnv } from '@expo/steps';
+import { type CustomBuildContext } from '../../customBuildContext';
+export declare function createStartAppiumRemoteSessionBuildFunction(ctx: CustomBuildContext): BuildFunction;
+export declare function resolveAppium3VersionSpec(packageVersion: string | undefined): string;
+type AppiumDevice = {
+    platformName: 'iOS' | 'Android';
+    automationName: 'XCUITest' | 'UiAutomator2';
+    driverName: 'xcuitest' | 'uiautomator2';
+    udid: string;
+};
+export declare function resolveAppiumDeviceAsync({ runtimePlatform, env, logger, }: {
+    runtimePlatform: BuildRuntimePlatform;
+    env: BuildStepEnv;
+    logger: bunyan;
+}): Promise<AppiumDevice>;
+export {};