@expo/build-tools 21.8.0 → 22.2.0

package/dist/builders/common.js

@@ -5,6 +5,7 @@ const eas_build_job_1 = require("@expo/eas-build-job");
 const xcodeBuildLogs_1 = require("../ios/xcodeBuildLogs");
 const artifacts_1 = require("../utils/artifacts");
 const hooks_1 = require("../utils/hooks");
+const sourceMaps_1 = require("../utils/sourceMaps");
 async function runBuilderWithHooksAsync(ctx, builderAsync) {
     try {
         let buildSuccess = true;
@@ -35,6 +36,9 @@ async function runBuilderWithHooksAsync(ctx, builderAsync) {
                 });
             }
             await ctx.runBuildPhase(eas_build_job_1.BuildPhase.UPLOAD_BUILD_ARTIFACTS, async () => {
+                if (buildSuccess) {
+                    await (0, sourceMaps_1.maybeUploadSourceMapAsync)(ctx);
+                }
                 await (0, artifacts_1.maybeFindAndUploadBuildArtifacts)(ctx, {
                     logger: ctx.logger,
                 });

package/dist/builders/ios.js

@@ -30,6 +30,7 @@ const expoUpdatesEmbedded_1 = require("../utils/expoUpdatesEmbedded");
 const hooks_1 = require("../utils/hooks");
 const prepareBuildExecutable_1 = require("../utils/prepareBuildExecutable");
 const processes_1 = require("../utils/processes");
+const sourceMaps_1 = require("../utils/sourceMaps");
 const INSTALL_PODS_WARN_TIMEOUT_MS = 15 * 60 * 1000; // 15 minutes
 const INSTALL_PODS_KILL_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
 class InstallPodsTimeoutError extends Error {
@@ -151,19 +152,23 @@ async function buildInnerAsync(ctx, jobHooksRef) {
         fastlaneResult = await ctx.runBuildPhase(eas_build_job_1.BuildPhase.RUN_FASTLANE, async () => {
             const scheme = (0, resolve_1.resolveScheme)(ctx);
             const entitlements = await readEntitlementsAsync(ctx, { scheme, buildConfiguration });
+            const sourceMapPath = (0, sourceMaps_1.isSourceMapUploadEnabled)(ctx)
+                ? await (0, sourceMaps_1.resolveIosSourceMapPathAsync)(ctx)
+                : null;
             return await (0, fastlane_1.runFastlaneGym)(ctx, {
                 credentials,
                 scheme,
                 buildConfiguration,
                 entitlements,
-                ...(resolvedExpoUpdatesRuntimeVersion?.runtimeVersion
-                    ? {
-                        extraEnv: {
+                extraEnv: {
+                    ...(resolvedExpoUpdatesRuntimeVersion?.runtimeVersion
+                        ? {
                             EXPO_UPDATES_FINGERPRINT_OVERRIDE: resolvedExpoUpdatesRuntimeVersion?.runtimeVersion,
                             EXPO_UPDATES_WORKFLOW_OVERRIDE: ctx.job.type,
-                        },
-                    }
-                    : null),
+                        }
+                        : null),
+                    ...(sourceMapPath ? { SOURCEMAP_FILE: sourceMapPath } : null),
+                },
             });
         });
     }

package/dist/steps/easFunctions.js

@@ -43,6 +43,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");
@@ -90,6 +91,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/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,8 @@ 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() {
     return new steps_1.BuildFunction({
@@ -24,6 +28,11 @@ function createInstallMaestroBuildFunction() {
                 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({
@@ -32,35 +41,43 @@ function createInstallMaestroBuildFunction() {
             }),
         ],
         fn: async ({ logger, global }, { inputs, env, outputs }) => {
-            const requestedMaestroVersion = inputs.maestro_version.value;
-            const { value: currentMaestroVersion } = await (0, results_1.asyncResult)(getMaestroVersion({ env }));
+            const backend = (0, maestroBackend_1.resolveMaestroBackend)({
+                input: inputs.backend.value,
+                env,
+            });
+            const requestedVersion = inputs.maestro_version.value;
+            const { value: currentMaestroVersion } = await (0, results_1.asyncResult)(getMaestroVersion({ env, backend }));
             // When not running in EAS Build VM, do not modify local environment.
             if (env.EAS_BUILD_RUNNER !== 'eas-build') {
-                const currentIsJavaInstalled = await isJavaInstalled({ env });
-                const currentIsIdbInstalled = await isIdbInstalled({ env });
-                if (!currentIsJavaInstalled) {
+                const needsToInstallJava = backend === 'maestro' && !(await isJavaInstalled({ env }));
+                const needsToInstallIdb = backend === 'maestro' && !(await isIdbInstalled({ env }));
+                if (needsToInstallJava) {
                     logger.warn('It seems Java is not installed. It is required to run Maestro. If the job fails, this may be the reason.');
                     logger.info('');
                 }
-                if (!currentIsIdbInstalled) {
+                if (needsToInstallIdb) {
                     logger.warn('It seems IDB is not installed. Maestro requires it to run flows on iOS Simulator. If the job fails, this may be the reason.');
                     logger.info('');
                 }
                 if (!currentMaestroVersion) {
-                    logger.warn('It seems Maestro is not installed. Please install Maestro manually and rerun the job.');
+                    logger.warn(`It seems ${backend} is not installed. Please install it manually and rerun the job.`);
                     logger.info('');
                 }
                 // Guide is helpful in these two cases, it doesn't mention Java.
-                if (!currentIsIdbInstalled || !currentMaestroVersion) {
+                if (backend === 'maestro' && (needsToInstallIdb || !currentMaestroVersion)) {
                     logger.warn('For more info, check out Maestro installation guide: https://maestro.mobile.dev/getting-started/installing-maestro');
                 }
+                else if (backend === 'maestro-runner' && !currentMaestroVersion) {
+                    logger.warn('For more info, check out maestro-runner installation guide: https://github.com/devicelab-dev/maestro-runner#install');
+                }
                 if (currentMaestroVersion) {
                     outputs.maestro_version.set(currentMaestroVersion);
-                    logger.info(`Maestro ${currentMaestroVersion} is ready.`);
+                    logger.info(`${backend} ${currentMaestroVersion} is ready.`);
                 }
                 return;
             }
-            if (!(await isJavaInstalled({ env }))) {
+            const needsToInstallJava = backend === 'maestro' && !(await isJavaInstalled({ env }));
+            if (needsToInstallJava) {
                 if (global.runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
                     logger.info('Installing Java');
                     await installJavaFromGcs({ logger, env });
@@ -73,45 +90,129 @@ function createInstallMaestroBuildFunction() {
                 }
             }
             // IDB is only a requirement on macOS.
-            if (global.runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN &&
-                !(await isIdbInstalled({ env }))) {
+            const needsToInstallIdb = backend === 'maestro' &&
+                global.runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN &&
+                !(await isIdbInstalled({ env }));
+            if (needsToInstallIdb) {
                 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 ||
-                (requestedMaestroVersion && requestedMaestroVersion !== currentMaestroVersion)) {
-                await installMaestro({
-                    version: requestedMaestroVersion,
-                    global,
-                    logger,
-                    env,
-                });
+            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': {
+                    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 }));
+            const maestroVersionResult = await (0, results_1.asyncResult)(getMaestroVersion({ env, backend }));
             if (!maestroVersionResult.ok) {
                 logger.error(maestroVersionResult.reason, 'Failed to get Maestro version.');
-                throw new Error('Failed to ensure Maestro is installed.');
+                throw new Error(`Failed to ensure ${backend} is installed.`);
             }
-            logger.info(`Maestro ${maestroVersionResult.value} is ready.`);
+            logger.info(`${backend} ${maestroVersionResult.value} is ready.`);
             outputs.maestro_version.set(maestroVersionResult.value);
             datadog_1.Datadog.distribution('eas.maestro.install', 1, {
                 maestro_version: maestroVersionResult.value,
+                maestro_backend: backend,
             });
         },
     });
 }
-async function getMaestroVersion({ env }) {
-    const { stdout } = await (0, turtle_spawn_1.default)('maestro', ['--version'], { stdio: 'pipe', env });
-    // `maestro --version` can print an analytics notice to stdout before the version,
-    // e.g. "Anonymous analytics enabled. To opt out, set MAESTRO_CLI_NO_ANALYTICS...\n2.0.10".
-    // Take the last version-looking token: the real version is printed after the notice, so
-    // this stays correct even if the notice itself contains a version-like string. Keeps the
-    // step output and the eas.maestro.install metric tag clean. Best-effort only: fall back to
-    // the raw output if none is found, so we never fail the build over a version string.
-    const versions = stdout.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/g);
-    return versions?.at(-1) ?? stdout.trim();
+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': {
+            const { stdout } = await (0, turtle_spawn_1.default)('maestro', ['--version'], { stdio: 'pipe', env });
+            // `maestro --version` can print an analytics notice to stdout before the version,
+            // e.g. "Anonymous analytics enabled. To opt out, set MAESTRO_CLI_NO_ANALYTICS...\n2.0.10".
+            // Take the last version-looking token: the real version is printed after the notice.
+            const versions = stdout.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/g);
+            return versions?.at(-1) ?? stdout.trim();
+        }
+        case 'maestro-runner': {
+            const { stdout } = await (0, turtle_spawn_1.default)('maestro-runner', ['--version'], { stdio: 'pipe', env });
+            // maestro-runner prints build information after its version. The Go runtime version in
+            // that output is also semver-shaped, so read only the prefixed runner version.
+            return /^maestro-runner\s+(\S+)/m.exec(stdout)?.[1] ?? stdout.trim();
+        }
+    }
+}
+async function installMaestroRunner({ global, version, logger, env, }) {
+    logger.info('Fetching maestro-runner install script');
+    const tempDirectory = await fs_1.default.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'install_maestro_runner'));
+    try {
+        const installMaestroRunnerScriptResponse = await fetch('https://open.devicelab.dev/install/maestro-runner');
+        const installMaestroRunnerScript = await installMaestroRunnerScriptResponse.text();
+        const scriptPath = path_1.default.join(tempDirectory, 'install_maestro_runner.sh');
+        await fs_1.default.promises.writeFile(scriptPath, installMaestroRunnerScript, { mode: 0o777 });
+        logger.info('Installing maestro-runner');
+        (0, assert_1.default)(env.HOME, 'Failed to infer directory to install maestro-runner in: $HOME environment variable is empty.');
+        await (0, turtle_spawn_1.default)(scriptPath, version && version !== 'latest' ? ['--version', version] : [], {
+            logger,
+            env,
+        });
+        const binDir = path_1.default.join(env.HOME, '.maestro-runner', 'bin');
+        global.updateEnv({
+            ...global.env,
+            PATH: `${binDir}:${global.env.PATH}`,
+        });
+        env.PATH = `${binDir}:${env.PATH}`;
+        process.env.PATH = `${binDir}:${process.env.PATH}`;
+    }
+    finally {
+        await fs_1.default.promises.rm(tempDirectory, { force: true, recursive: true });
+    }
 }
 async function installMaestro({ global, version, logger, env, }) {
     logger.info('Fetching install script');
@@ -141,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 });
@@ -152,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 {
@@ -160,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/maestroBackend.d.ts

@@ -0,0 +1,11 @@
+import { BuildStepEnv } from '@expo/steps';
+import { z } from 'zod';
+export declare const MaestroBackendSchema: z.ZodDefault<z.ZodEnum<{
+    maestro: "maestro";
+    "maestro-runner": "maestro-runner";
+}>>;
+export type MaestroBackend = z.output<typeof MaestroBackendSchema>;
+export declare function resolveMaestroBackend({ input, env, }: {
+    input: unknown;
+    env: BuildStepEnv;
+}): MaestroBackend;

package/dist/steps/functions/maestroBackend.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaestroBackendSchema = void 0;
+exports.resolveMaestroBackend = resolveMaestroBackend;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const zod_1 = require("zod");
+exports.MaestroBackendSchema = zod_1.z.enum(['maestro', 'maestro-runner']).default('maestro');
+function resolveMaestroBackend({ input, env, }) {
+    const result = exports.MaestroBackendSchema.safeParse(input || env.EAS_MAESTRO_BACKEND || undefined);
+    if (!result.success) {
+        throw new eas_build_job_1.UserError('ERR_MAESTRO_INVALID_INPUT', 'backend and EAS_MAESTRO_BACKEND must be either "maestro" or "maestro-runner".', { cause: result.error });
+    }
+    return result.data;
+}

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

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 export interface MaestroFlowResult {
     name: string;
     path: string;
@@ -23,6 +24,34 @@ export declare function isFileAttrRun(testcases: JUnitTestCaseResult[]): testcas
     file: string;
 })[];
 export declare function junitFileHasFileAttrs(junitFile: string): Promise<boolean>;
+declare const MaestroRunnerReportSchema: z.ZodObject<{
+    flows: z.ZodPipe<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        name: z.ZodString;
+        sourceFile: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"skipped">;
+    }, z.core.$strip>], "status">>, z.ZodTransform<{
+        name: string;
+        sourceFile: string;
+        status: "failed" | "passed";
+    }[], ({
+        name: string;
+        sourceFile: string;
+        status: "failed" | "passed";
+    } | {
+        status: "skipped";
+    })[]>>;
+}, z.core.$strip>;
+type MaestroRunnerReport = z.infer<typeof MaestroRunnerReportSchema>;
+export declare function parseFailedFlowsFromMaestroRunnerReport(args: {
+    reportDirectory: string;
+    workingDirectory: string;
+}): Promise<string[] | null>;
+export declare function parseMaestroRunnerReport(reportDirectory: string): Promise<MaestroRunnerReport | null>;
 export declare function parseMaestroResultsFromFileAttrs(junitDirectory: string): Promise<MaestroFlowResult[]>;
 /**
  * Returns the `file=` paths of the failing testcases in the given attempt's
@@ -75,3 +104,4 @@ export declare function copyLatestAttemptXml(args: {
     sourceDir: string;
     outputPath: string;
 }): Promise<void>;
+export {};

package/dist/steps/functions/maestroResultParser.js

@@ -7,6 +7,8 @@ exports.parseFailedFlowNamesFromJUnitFile = parseFailedFlowNamesFromJUnitFile;
 exports.parseJUnitTestCases = parseJUnitTestCases;
 exports.isFileAttrRun = isFileAttrRun;
 exports.junitFileHasFileAttrs = junitFileHasFileAttrs;
+exports.parseFailedFlowsFromMaestroRunnerReport = parseFailedFlowsFromMaestroRunnerReport;
+exports.parseMaestroRunnerReport = parseMaestroRunnerReport;
 exports.parseMaestroResultsFromFileAttrs = parseMaestroResultsFromFileAttrs;
 exports.parseFailedFlowsFromFileAttrs = parseFailedFlowsFromFileAttrs;
 exports.parseMaestroResults = parseMaestroResults;
@@ -17,6 +19,7 @@ const results_1 = require("@expo/results");
 const fast_xml_parser_1 = require("fast-xml-parser");
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
 // Per-attempt JUnit XML files use `*-attempt-N.xml` names; this extracts N.
 const ATTEMPT_PATTERN = /attempt-(\d+)/;
 const xmlParser = new fast_xml_parser_1.XMLParser({
@@ -25,10 +28,16 @@ const xmlParser = new fast_xml_parser_1.XMLParser({
     // Ensure single-element arrays are always arrays
     isArray: name => ['testsuite', 'testcase', 'property'].includes(name),
 });
-// A `file=` attribute counts as present only when it is a non-empty string.
+// Official Maestro writes the flow path as a `file=` testcase attribute. maestro-runner writes
+// the same value as a `<property name="file" value="..."/>` child.
 function fileAttrOf(tc) {
     const f = tc?.['@_file'];
-    return typeof f === 'string' && f.length > 0 ? f : undefined;
+    if (typeof f === 'string' && f.length > 0) {
+        return f;
+    }
+    const properties = tc?.properties?.property ?? [];
+    const fileProperty = properties.find(property => property['@_name'] === 'file')?.['@_value'];
+    return typeof fileProperty === 'string' && fileProperty.length > 0 ? fileProperty : undefined;
 }
 function parseJUnitContent(content) {
     const results = [];
@@ -48,22 +57,40 @@ function parseJUnitContent(content) {
                 if (!name) {
                     continue;
                 }
+                // Standard JUnit marks skipped tests with a <skipped/> child (no failure/error). Exclude
+                // them so they aren't miscounted as passed, matching the report.json path which drops
+                // skipped flows.
+                if (tc.skipped != null) {
+                    continue;
+                }
                 const file = fileAttrOf(tc);
                 const timeStr = tc['@_time'];
                 const timeSeconds = timeStr ? parseFloat(timeStr) : 0;
                 const duration = Number.isFinite(timeSeconds) ? Math.round(timeSeconds * 1000) : 0;
-                const status = tc['@_status'] === 'SUCCESS' ? 'passed' : 'failed';
+                // maestro-runner puts the real error in the `message` attribute and the command
+                // label (e.g. `tapOn`) in the body; official Maestro only writes the body. Prefer
+                // `@_message` and fall back to `#text` so both stay correct.
                 const failureText = tc.failure != null
                     ? typeof tc.failure === 'string'
                         ? tc.failure
-                        : (tc.failure?.['#text'] ?? null)
+                        : (tc.failure?.['@_message'] ?? tc.failure?.['#text'] ?? null)
                     : null;
                 const errorText = tc.error != null
                     ? typeof tc.error === 'string'
                         ? tc.error
-                        : (tc.error?.['#text'] ?? null)
+                        : (tc.error?.['@_message'] ?? tc.error?.['#text'] ?? null)
                     : null;
                 const errorMessage = failureText ?? errorText ?? null;
+                // Official Maestro uses status="SUCCESS". maestro-runner uses standard JUnit semantics:
+                // a testcase passes when it has no failure or error child.
+                const statusAttribute = tc['@_status'];
+                const status = typeof statusAttribute === 'string'
+                    ? statusAttribute === 'SUCCESS'
+                        ? 'passed'
+                        : 'failed'
+                    : tc.failure == null && tc.error == null
+                        ? 'passed'
+                        : 'failed';
                 const rawProperties = tc.properties?.property ?? [];
                 const properties = {};
                 for (const prop of rawProperties) {
@@ -143,6 +170,52 @@ async function junitFileHasFileAttrs(junitFile) {
 async function fileExists(absPath) {
     return (await (0, results_1.asyncResult)(promises_1.default.stat(absPath))).ok;
 }
+// maestro-runner writes report.json as the source of truth for a run. Use it for runner control
+// flow because sourceFile preserves the exact flow path, while older runner JUnit reports flatten
+// it to a basename. Keep only passed and failed flows so the result matches Maestro JUnit reports,
+// which do not include skipped flows.
+const MaestroRunnerRecordedFlowSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1),
+    sourceFile: zod_1.z.string().min(1),
+    status: zod_1.z.enum(['passed', 'failed']),
+});
+const MaestroRunnerReportSchema = zod_1.z.object({
+    flows: zod_1.z
+        .array(zod_1.z.discriminatedUnion('status', [
+        MaestroRunnerRecordedFlowSchema,
+        zod_1.z.object({ status: zod_1.z.literal('skipped') }),
+    ]))
+        .transform(flows => flows.filter((flow) => flow.status !== 'skipped')),
+});
+async function parseFailedFlowsFromMaestroRunnerReport(args) {
+    const report = await parseMaestroRunnerReport(args.reportDirectory);
+    if (report === null) {
+        return null;
+    }
+    const failedPaths = [
+        ...new Set(report.flows.filter(flow => flow.status === 'failed').map(flow => flow.sourceFile)),
+    ];
+    if (failedPaths.length === 0) {
+        return null;
+    }
+    for (const flowPath of failedPaths) {
+        if (!(await fileExists(path_1.default.resolve(args.workingDirectory, flowPath)))) {
+            return null;
+        }
+    }
+    return failedPaths;
+}
+async function parseMaestroRunnerReport(reportDirectory) {
+    let report;
+    try {
+        report = JSON.parse(await promises_1.default.readFile(path_1.default.join(reportDirectory, 'report.json'), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+    const result = MaestroRunnerReportSchema.safeParse(report);
+    return result.success ? result.data : null;
+}
 // Group by `file=` so two same-named flows in different files stay separate.
 async function parseMaestroResultsFromFileAttrs(junitDirectory) {
     let junitEntries;

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

@@ -21,6 +21,12 @@ export declare function harvestFailureScreenshotsAsync(args: {
     failedFlowNames: ReadonlySet<string>;
     logger: bunyan;
 }): Promise<HarvestedScreenshot[]>;
+export declare function harvestMaestroRunnerFailureScreenshotsAsync(args: {
+    reportDirectory: string;
+    capturedSinceMs: number;
+    attemptIndex: number;
+    logger: bunyan;
+}): Promise<HarvestedScreenshot[]>;
 export declare function computePureFailureFlowNames(testCases: readonly {
     name: string;
     status: 'passed' | 'failed';