@expo/build-tools 22.0.0 → 22.2.0

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,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/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';

package/dist/steps/functions/maestroScreenshots.js

@@ -5,10 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFailureScreenshotFilename = parseFailureScreenshotFilename;
 exports.harvestFailureScreenshotsAsync = harvestFailureScreenshotsAsync;
+exports.harvestMaestroRunnerFailureScreenshotsAsync = harvestMaestroRunnerFailureScreenshotsAsync;
 exports.computePureFailureFlowNames = computePureFailureFlowNames;
 exports.selectFailureScreenshots = selectFailureScreenshots;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
+const sentry_1 = require("../../sentry");
 // pre-v2.7.0 (Maestro <= 2.6.x): failure screenshots are flat files named
 // `screenshot-[shard-N-]❌-<epochMillis>-(<flowName>).png` directly in the session dir.
 // The flow name may contain parentheses, so anchor on the `-(` after the epoch and the
@@ -109,6 +112,126 @@ async function harvestFailureScreenshotsAsync(args) {
     // `<flow>-2` collision to collapse (and deduping them would change historical behavior).
     return [...legacyShots, ...dedupeBundleShotsByFlowName(bundleShots)];
 }
+const MaestroRunnerCommandSchema = zod_1.z.object({
+    status: zod_1.z.string().optional(),
+    artifacts: zod_1.z
+        .object({
+        screenshotBefore: zod_1.z.string().optional(),
+        screenshotAfter: zod_1.z.string().optional(),
+    })
+        .optional(),
+    get subCommands() {
+        return zod_1.z.array(MaestroRunnerCommandSchema).optional();
+    },
+});
+const MaestroRunnerFlowDetailSchema = zod_1.z.object({
+    commands: zod_1.z.array(MaestroRunnerCommandSchema).optional(),
+});
+const MaestroRunnerScreenshotReportSchema = zod_1.z.object({
+    flows: zod_1.z
+        .array(zod_1.z.object({
+        name: zod_1.z.string().optional(),
+        status: zod_1.z.string().optional(),
+        dataFile: zod_1.z.string().optional(),
+    }))
+        .optional(),
+});
+// maestro-runner records failure screenshot paths in its report JSON instead of using the
+// official Maestro debug-directory layout. Never throws, so screenshots cannot change the test
+// result.
+async function harvestMaestroRunnerFailureScreenshotsAsync(args) {
+    let report;
+    try {
+        report = JSON.parse(await promises_1.default.readFile(path_1.default.join(args.reportDirectory, 'report.json'), 'utf8'));
+    }
+    catch (err) {
+        args.logger.info({ err }, `Skipping maestro-runner screenshot harvest: cannot read ${args.reportDirectory}.`);
+        return [];
+    }
+    const parsedReport = MaestroRunnerScreenshotReportSchema.safeParse(report);
+    if (!parsedReport.success) {
+        args.logger.warn({ err: parsedReport.error }, `Skipping maestro-runner screenshot harvest: unexpected report.json shape in ${args.reportDirectory}.`);
+        sentry_1.Sentry.capture('maestro-runner report.json failed schema validation', parsedReport.error);
+        return [];
+    }
+    const flows = parsedReport.data.flows ?? [];
+    const shots = [];
+    for (const { name, status, dataFile } of flows) {
+        if (status !== 'failed' || !name || !dataFile) {
+            continue;
+        }
+        const flowDataPath = resolvePathInsideDirectory(args.reportDirectory, dataFile);
+        if (!flowDataPath) {
+            args.logger.info(`Skipping maestro-runner flow data outside the report directory.`);
+            continue;
+        }
+        let screenshotPath;
+        try {
+            const detail = MaestroRunnerFlowDetailSchema.safeParse(JSON.parse(await promises_1.default.readFile(flowDataPath, 'utf8')));
+            if (!detail.success) {
+                args.logger.warn({ err: detail.error }, `Skipping malformed maestro-runner flow data ${flowDataPath}.`);
+                sentry_1.Sentry.capture('maestro-runner flow data failed schema validation', detail.error);
+                continue;
+            }
+            screenshotPath = findFailedMaestroRunnerScreenshot(detail.data.commands ?? []);
+        }
+        catch (err) {
+            args.logger.info({ err }, `Skipping unreadable maestro-runner flow data ${flowDataPath}.`);
+            continue;
+        }
+        if (!screenshotPath) {
+            continue;
+        }
+        const fileAbsPath = resolvePathInsideDirectory(args.reportDirectory, screenshotPath);
+        if (!fileAbsPath) {
+            args.logger.info(`Skipping maestro-runner screenshot outside the report directory.`);
+            continue;
+        }
+        let capturedAtMs;
+        try {
+            capturedAtMs = Math.round((await promises_1.default.stat(fileAbsPath)).mtimeMs);
+        }
+        catch (err) {
+            args.logger.info({ err }, `Skipping unreadable screenshot ${fileAbsPath}.`);
+            continue;
+        }
+        if (capturedAtMs < args.capturedSinceMs) {
+            continue;
+        }
+        const flowName = normalizeFlowName(name);
+        shots.push({
+            fileAbsPath,
+            displayName: `Failure Screenshot: ${flowName} (attempt ${args.attemptIndex + 1})`,
+            metadata: {
+                kind: 'maestro-test-screenshot',
+                flowName,
+                attemptIndex: args.attemptIndex,
+                capturedAtMs,
+            },
+        });
+    }
+    return shots;
+}
+function findFailedMaestroRunnerScreenshot(commands) {
+    for (const command of commands) {
+        if (command.status !== 'failed') {
+            continue;
+        }
+        const nested = findFailedMaestroRunnerScreenshot(command.subCommands ?? []);
+        const screenshot = nested ?? command.artifacts?.screenshotAfter ?? command.artifacts?.screenshotBefore;
+        if (screenshot) {
+            return screenshot;
+        }
+    }
+    return undefined;
+}
+function resolvePathInsideDirectory(directory, relativePath) {
+    const candidate = path_1.default.resolve(directory, relativePath);
+    const relative = path_1.default.relative(directory, candidate);
+    return relative !== '..' && !relative.startsWith(`..${path_1.default.sep}`) && !path_1.default.isAbsolute(relative)
+        ? candidate
+        : null;
+}
 // Maestro >= 2.7.0: resolve a bundle dir to its owning failed flow and return that flow's failure
 // screenshot — the highest-numbered step in `screenshots/`. A required failure halts the flow, so
 // the failed step is normally the last (highest-numbered) captured step; earlier warned steps have