@expo/build-tools 18.9.0 → 18.11.0

package/dist/ios/pod.js

@@ -5,11 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.installPods = installPods;
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
+const semver_1 = __importDefault(require("semver"));
+const MIN_PRECOMPILED_MODULES_EXPO_VERSION = '55.0.18';
+// const PRECOMPILED_MODULES_BASE_URL = 'https://storage.googleapis.com/eas-build-precompiled-modules/';
 async function installPods(ctx, { infoCallbackFn }) {
     const iosDir = path_1.default.join(ctx.getReactNativeProjectDirectory(), 'ios');
     const verboseFlag = ctx.env['EAS_VERBOSE'] === '1' ? ['--verbose'] : [];
     const cocoapodsDeploymentFlag = ctx.env['POD_INSTALL_DEPLOYMENT'] === '1' ? ['--deployment'] : [];
+    const precompiledModulesEnv = await resolvePrecompiledModulesPodInstallEnvAsync(ctx);
     return {
         spawnPromise: (0, turtle_spawn_1.default)('pod', ['install', ...verboseFlag, ...cocoapodsDeploymentFlag], {
             cwd: iosDir,
@@ -17,6 +22,7 @@ async function installPods(ctx, { infoCallbackFn }) {
             env: {
                 ...ctx.env,
                 LANG: 'en_US.UTF-8',
+                ...precompiledModulesEnv,
             },
             lineTransformer: (line) => {
                 if (!line ||
@@ -31,3 +37,54 @@ async function installPods(ctx, { infoCallbackFn }) {
         }),
     };
 }
+async function resolvePrecompiledModulesPodInstallEnvAsync(ctx) {
+    if (ctx.job.builderEnvironment?.env?.EAS_USE_PRECOMPILED_MODULES !== '1') {
+        return {};
+    }
+    let expoPackageVersion;
+    try {
+        expoPackageVersion = await getInstalledExpoPackageVersionAsync(ctx);
+    }
+    catch (err) {
+        ctx.logger.info({ err }, 'Failed to detect installed Expo package version; not enabling precompiled modules use.');
+        return {};
+    }
+    const validExpoPackageVersion = semver_1.default.valid(expoPackageVersion);
+    if (!validExpoPackageVersion) {
+        ctx.logger.info(`Detected expo=${expoPackageVersion}; not enabling precompiled modules use because the installed Expo package version is not a valid semver version.`);
+        return {};
+    }
+    if (semver_1.default.lt(validExpoPackageVersion, MIN_PRECOMPILED_MODULES_EXPO_VERSION)) {
+        ctx.logger.info(`Detected expo=${validExpoPackageVersion}; not enabling precompiled modules use because precompiled modules require expo>=${MIN_PRECOMPILED_MODULES_EXPO_VERSION}.`);
+        return {};
+    }
+    // Start rollout with Expo precompiled modules only. Add third-party modules after this is stable.
+    const env = {
+        EXPO_USE_PRECOMPILED_MODULES: '1',
+        // EXPO_PRECOMPILED_MODULES_BASE_URL: getPrecompiledModulesBaseUrl(),
+    };
+    ctx.logger.info(`Detected expo=${validExpoPackageVersion}; enabling precompiled modules use. Installing pods with additional environment variables.\n${Object.entries(env)
+        .map(([key, value]) => `${key}=${value}`)
+        .join('\n')}\nPrecompiled modules pod install environment is configured.`);
+    return env;
+}
+async function getInstalledExpoPackageVersionAsync(ctx) {
+    const { stdout } = await (0, turtle_spawn_1.default)('node', ['--print', "require.resolve('expo/package.json')"], {
+        cwd: ctx.getReactNativeProjectDirectory(),
+        env: ctx.env,
+        stdio: 'pipe',
+    });
+    const expoPackageJsonPath = stdout.toString().trim();
+    return (await fs_extra_1.default.readJson(expoPackageJsonPath)).version;
+}
+// function getPrecompiledModulesBaseUrl<TJob extends Ios.Job>(ctx: BuildContext<TJob>): string {
+//   if (!ctx.env.EAS_BUILD_COCOAPODS_CACHE_URL) {
+//     return PRECOMPILED_MODULES_BASE_URL;
+//   }
+//
+//   const parsedUrl = new URL(PRECOMPILED_MODULES_BASE_URL);
+//   return PRECOMPILED_MODULES_BASE_URL.replace(
+//     `${parsedUrl.protocol}//${parsedUrl.host}`,
+//     `${ctx.env.EAS_BUILD_COCOAPODS_CACHE_URL.replace(/\/$/, '')}/${parsedUrl.host}`
+//   );
+// }

package/dist/steps/easFunctions.js

@@ -33,6 +33,7 @@ const restoreCache_1 = require("./functions/restoreCache");
 const parseXcactivitylog_1 = require("./functions/parseXcactivitylog");
 const runFastlane_1 = require("./functions/runFastlane");
 const runGradle_1 = require("./functions/runGradle");
+const maestroTests_1 = require("./functions/maestroTests");
 const saveBuildCache_1 = require("./functions/saveBuildCache");
 const saveCache_1 = require("./functions/saveCache");
 const sendSlackMessage_1 = require("./functions/sendSlackMessage");
@@ -85,6 +86,7 @@ function getEasFunctions(ctx) {
         (0, createSubmissionEntity_1.createSubmissionEntityFunction)(),
         (0, uploadToAsc_1.createUploadToAscBuildFunction)(),
         (0, reportMaestroTestResults_1.createReportMaestroTestResultsFunction)(ctx),
+        (0, maestroTests_1.createMaestroTestsBuildFunction)(),
     ];
     if (ctx.hasBuildJob()) {
         functions.push(...[

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

@@ -39,4 +39,44 @@ type FlowMetadata = z.output<typeof FlowMetadataFileSchema>;
  */
 export declare function parseFlowMetadata(filePath: string): Promise<FlowMetadata | null>;
 export declare function parseMaestroResults(junitDirectory: string, testsDirectory: string, projectRoot: string): Promise<MaestroFlowResult[]>;
+/**
+ * Returns the subset of `inputFlowPaths` whose testcases failed in the given
+ * attempt's JUnit file, or `null` when the result cannot be trusted (caller
+ * then falls back to dumb retry — re-run everything).
+ *
+ * Mapping: <testcase> only carries `name`, so we recover `flow_file_path`
+ * from `ai-${flow_name}.json` under testsDirectory and match it back to
+ * inputFlowPaths.
+ */
+export declare function parseFailedFlowsFromJUnit(args: {
+    junitFile: string;
+    testsDirectory: string;
+    inputFlowPaths: string[];
+    projectRoot: string;
+}): Promise<string[] | null>;
+/**
+ * Reads every *.xml in sourceDir (per-attempt JUnit files), picks the latest
+ * attempt's <testcase> per unique flow name (latest determined from the
+ * filename's `attempt-(\d+)` marker; files without the marker = attempt 0),
+ * and writes a merged document to outputPath.
+ *
+ * Throws on empty/malformed/no-testcase input so the caller can fall back to
+ * copyLatestAttemptXml — silently dropping bad attempts could keep stale
+ * failure rows around and produce a misleading merged report.
+ */
+export declare function mergeJUnitReports(args: {
+    sourceDir: string;
+    outputPath: string;
+}): Promise<void>;
+/**
+ * Copies the highest-attempt-index *.xml file from sourceDir to outputPath.
+ * Used as a fallback when mergeJUnitReports fails due to data issues but the
+ * step still needs to produce final_report_path.
+ *
+ * Throws if sourceDir contains no *.xml files or if the copy fails.
+ */
+export declare function copyLatestAttemptXml(args: {
+    sourceDir: string;
+    outputPath: string;
+}): Promise<void>;
 export {};

package/dist/steps/functions/maestroResultParser.js

@@ -7,12 +7,17 @@ exports.extractFlowKey = extractFlowKey;
 exports.parseJUnitTestCases = parseJUnitTestCases;
 exports.parseFlowMetadata = parseFlowMetadata;
 exports.parseMaestroResults = parseMaestroResults;
+exports.parseFailedFlowsFromJUnit = parseFailedFlowsFromJUnit;
+exports.mergeJUnitReports = mergeJUnitReports;
+exports.copyLatestAttemptXml = copyLatestAttemptXml;
 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");
 // Maestro's TestDebugReporter creates timestamped directories, e.g. "2024-06-15_143022"
 const TIMESTAMP_DIR_PATTERN = /^\d{4}-\d{2}-\d{2}_\d{6}$/;
+// Per-attempt JUnit XML files use `*-attempt-N.xml` names; this extracts N.
+const ATTEMPT_PATTERN = /attempt-(\d+)/;
 function extractFlowKey(filename, prefix) {
     const match = filename.match(new RegExp(`^${prefix}-(.+)\\.json$`));
     return match?.[1] ?? null;
@@ -23,11 +28,9 @@ const xmlParser = new fast_xml_parser_1.XMLParser({
     // Ensure single-element arrays are always arrays
     isArray: name => ['testsuite', 'testcase', 'property'].includes(name),
 });
-// Internal helper — not exported. Parses a single JUnit XML file.
-async function parseJUnitFile(filePath) {
+function parseJUnitContent(content) {
     const results = [];
     try {
-        const content = await promises_1.default.readFile(filePath, 'utf-8');
         const parsed = xmlParser.parse(content);
         const testsuites = parsed?.testsuites?.testsuite;
         if (!Array.isArray(testsuites)) {
@@ -81,10 +84,19 @@ async function parseJUnitFile(filePath) {
         }
     }
     catch {
-        // Skip malformed XML files
+        // Malformed XML — return whatever we collected before the parser bailed.
     }
     return results;
 }
+async function parseJUnitFile(filePath) {
+    try {
+        const content = await promises_1.default.readFile(filePath, 'utf-8');
+        return parseJUnitContent(content);
+    }
+    catch {
+        return [];
+    }
+}
 async function parseJUnitTestCases(junitDirectory) {
     let entries;
     try {
@@ -97,11 +109,8 @@ async function parseJUnitTestCases(junitDirectory) {
     if (xmlFiles.length === 0) {
         return [];
     }
-    const results = [];
-    for (const xmlFile of xmlFiles) {
-        results.push(...(await parseJUnitFile(path_1.default.join(junitDirectory, xmlFile))));
-    }
-    return results;
+    const perFile = await Promise.all(xmlFiles.map(f => parseJUnitFile(path_1.default.join(junitDirectory, f))));
+    return perFile.flat();
 }
 const FlowMetadataFileSchema = zod_1.z.object({
     flow_name: zod_1.z.string(),
@@ -190,8 +199,6 @@ async function parseMaestroResults(junitDirectory, testsDirectory, projectRoot)
     }
     // 3. Merge: JUnit results + ai-*.json metadata
     const results = [];
-    // Parse attempt index from filename pattern: *-attempt-N.*
-    const ATTEMPT_PATTERN = /attempt-(\d+)/;
     // Group results by flow name
     const resultsByName = new Map();
     for (const entry of junitResultsWithSource) {
@@ -246,6 +253,248 @@ async function parseMaestroResults(junitDirectory, testsDirectory, projectRoot)
     }
     return results;
 }
+/**
+ * Returns the subset of `inputFlowPaths` whose testcases failed in the given
+ * attempt's JUnit file, or `null` when the result cannot be trusted (caller
+ * then falls back to dumb retry — re-run everything).
+ *
+ * Mapping: <testcase> only carries `name`, so we recover `flow_file_path`
+ * from `ai-${flow_name}.json` under testsDirectory and match it back to
+ * inputFlowPaths.
+ */
+async function parseFailedFlowsFromJUnit(args) {
+    // fast-xml-parser is lenient — truncated XML can produce a partial parse
+    // with some testcases dropped. Trusting that subset for smart retry would
+    // skip retries for cut-off flows; reject any malformed XML and fall back
+    // to dumb retry.
+    let content;
+    try {
+        content = await promises_1.default.readFile(args.junitFile, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    if (fast_xml_parser_1.XMLValidator.validate(content) !== true) {
+        return null;
+    }
+    const testcases = parseJUnitContent(content);
+    if (testcases.length === 0) {
+        return null;
+    }
+    const failing = testcases.filter(tc => tc.status === 'failed');
+    if (failing.length === 0) {
+        return [];
+    }
+    // Two testcases with the same name (pass+fail or fail+fail) make it
+    // impossible to map back to a single input flow_path, since the
+    // ai-*.json keyed map collapses duplicates. Signal "unknown" → dumb retry.
+    const allNameCounts = new Map();
+    for (const tc of testcases) {
+        allNameCounts.set(tc.name, (allNameCounts.get(tc.name) ?? 0) + 1);
+    }
+    for (const count of allNameCounts.values()) {
+        if (count > 1) {
+            return null;
+        }
+    }
+    // Build flow_name → flow_file_path map from ai-*.json across timestamped
+    // subdirectories (same traversal as parseMaestroResults).
+    const nameToPath = new Map();
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(args.testsDirectory);
+    }
+    catch {
+        entries = [];
+    }
+    const timestampDirs = entries.filter(name => TIMESTAMP_DIR_PATTERN.test(name)).sort();
+    for (const dir of timestampDirs) {
+        const dirPath = path_1.default.join(args.testsDirectory, dir);
+        let files;
+        try {
+            files = await promises_1.default.readdir(dirPath);
+        }
+        catch {
+            continue;
+        }
+        for (const file of files) {
+            const flowKey = extractFlowKey(file, 'ai');
+            if (!flowKey) {
+                continue;
+            }
+            const metadata = await parseFlowMetadata(path_1.default.join(dirPath, file));
+            if (!metadata) {
+                continue;
+            }
+            // Latest timestamp dir wins if the same flow appears in multiple attempts.
+            nameToPath.set(metadata.flow_name, metadata.flow_file_path);
+        }
+    }
+    const matched = [];
+    for (const tc of failing) {
+        const abs = nameToPath.get(tc.name);
+        if (!abs) {
+            return null; // unknown mapping; safer to fall back
+        }
+        const relative = await relativizePathAsync(abs, args.projectRoot);
+        // Accept exact matches and flow files discovered under an input directory
+        // (documented usage: `flow_path: ./maestro/flows` discovers nested .yml).
+        // Anything outside every input is treated as out-of-scope → dumb retry.
+        if (!args.inputFlowPaths.some(input => isPathWithinOrEqual(relative, input))) {
+            return null;
+        }
+        matched.push(relative);
+    }
+    return matched;
+}
+function isPathWithinOrEqual(child, parent) {
+    const rel = path_1.default.relative(parent, child);
+    return rel === '' || (!rel.startsWith('..') && !path_1.default.isAbsolute(rel));
+}
+/**
+ * Reads every *.xml in sourceDir (per-attempt JUnit files), picks the latest
+ * attempt's <testcase> per unique flow name (latest determined from the
+ * filename's `attempt-(\d+)` marker; files without the marker = attempt 0),
+ * and writes a merged document to outputPath.
+ *
+ * Throws on empty/malformed/no-testcase input so the caller can fall back to
+ * copyLatestAttemptXml — silently dropping bad attempts could keep stale
+ * failure rows around and produce a misleading merged report.
+ */
+async function mergeJUnitReports(args) {
+    const entries = await promises_1.default.readdir(args.sourceDir);
+    const xmlFiles = entries.filter(f => f.endsWith('.xml')).sort();
+    if (xmlFiles.length === 0) {
+        throw new Error(`mergeJUnitReports: no *.xml files found in ${args.sourceDir}`);
+    }
+    const contents = await Promise.all(xmlFiles.map(async (f) => ({
+        filename: f,
+        content: await promises_1.default.readFile(path_1.default.join(args.sourceDir, f), 'utf-8'),
+    })));
+    const fileGroups = [];
+    for (const { filename, content } of contents) {
+        if (fast_xml_parser_1.XMLValidator.validate(content) !== true) {
+            throw new Error(`mergeJUnitReports: invalid XML in ${filename}`);
+        }
+        let parsed;
+        try {
+            parsed = xmlParser.parse(content);
+        }
+        catch (err) {
+            throw new Error(`mergeJUnitReports: failed to parse ${filename}`, { cause: err });
+        }
+        const testsuites = parsed?.testsuites?.testsuite;
+        if (!Array.isArray(testsuites)) {
+            throw new Error(`mergeJUnitReports: no <testsuite> array in ${filename}`);
+        }
+        const match = filename.match(ATTEMPT_PATTERN);
+        const attemptIndex = match ? parseInt(match[1], 10) : 0;
+        const testcasesByName = new Map();
+        for (const suite of testsuites) {
+            const cases = suite?.testcase;
+            if (!Array.isArray(cases)) {
+                continue;
+            }
+            for (const tc of cases) {
+                const name = tc?.['@_name'];
+                if (typeof name !== 'string') {
+                    continue;
+                }
+                const group = testcasesByName.get(name) ?? [];
+                group.push(tc);
+                testcasesByName.set(name, group);
+            }
+        }
+        if (testcasesByName.size === 0) {
+            throw new Error(`mergeJUnitReports: no parseable testcases in ${filename}`);
+        }
+        fileGroups.push({ attemptIndex, filename, content, testcasesByName });
+    }
+    // Single attempt: copy the original XML so suite-level metadata (testsuite
+    // attributes, <system-out>, etc.) survives. The rebuild path below would
+    // collapse those to a single attribute-less <testsuite>.
+    if (fileGroups.length === 1) {
+        await promises_1.default.writeFile(args.outputPath, fileGroups[0].content);
+        return;
+    }
+    // For each unique name, pick the file with the highest attempt index that
+    // contains it (ties broken by sorted filename — later wins). Preserve every
+    // <testcase> element from the winning file for that name, so same-attempt
+    // duplicates survive.
+    const nameToWinningFile = new Map();
+    for (const group of fileGroups) {
+        for (const name of group.testcasesByName.keys()) {
+            const current = nameToWinningFile.get(name);
+            if (!current || group.attemptIndex >= current.attemptIndex) {
+                nameToWinningFile.set(name, group);
+            }
+        }
+    }
+    // Emit in first-seen order (iteration over `fileGroups` yields stable order
+    // matching the sorted filename list).
+    const testcases = [];
+    const emitted = new Set();
+    for (const group of fileGroups) {
+        for (const [name, cases] of group.testcasesByName) {
+            if (emitted.has(name)) {
+                continue;
+            }
+            const winner = nameToWinningFile.get(name);
+            if (winner === group) {
+                for (const tc of cases) {
+                    testcases.push(tc);
+                }
+                emitted.add(name);
+            }
+        }
+    }
+    const builder = new fast_xml_parser_1.XMLBuilder({
+        ignoreAttributes: false,
+        attributeNamePrefix: '@_',
+        format: true,
+        suppressEmptyNode: true,
+    });
+    const xml = builder.build({
+        testsuites: {
+            testsuite: {
+                testcase: testcases,
+            },
+        },
+    });
+    await promises_1.default.writeFile(args.outputPath, xml);
+}
+/**
+ * Copies the highest-attempt-index *.xml file from sourceDir to outputPath.
+ * Used as a fallback when mergeJUnitReports fails due to data issues but the
+ * step still needs to produce final_report_path.
+ *
+ * Throws if sourceDir contains no *.xml files or if the copy fails.
+ */
+async function copyLatestAttemptXml(args) {
+    const entries = await promises_1.default.readdir(args.sourceDir);
+    const xmlFiles = entries.filter(f => f.endsWith('.xml')).sort();
+    if (xmlFiles.length === 0) {
+        throw new Error(`No *.xml files found in ${args.sourceDir}`);
+    }
+    // Pick the file with the highest attempt index. Files without the marker are
+    // treated as attempt 0. Ties are broken by sorted filename — later wins
+    // (same rule as mergeJUnitReports).
+    let winner = xmlFiles[0];
+    let winnerAttempt = (() => {
+        const m = winner.match(ATTEMPT_PATTERN);
+        return m ? parseInt(m[1], 10) : 0;
+    })();
+    for (let i = 1; i < xmlFiles.length; i++) {
+        const candidate = xmlFiles[i];
+        const match = candidate.match(ATTEMPT_PATTERN);
+        const attempt = match ? parseInt(match[1], 10) : 0;
+        if (attempt >= winnerAttempt) {
+            winner = candidate;
+            winnerAttempt = attempt;
+        }
+    }
+    await promises_1.default.copyFile(path_1.default.join(args.sourceDir, winner), args.outputPath);
+}
 async function relativizePathAsync(flowFilePath, projectRoot) {
     if (!path_1.default.isAbsolute(flowFilePath)) {
         return flowFilePath;

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

@@ -0,0 +1,2 @@
+import { BuildFunction } from '@expo/steps';
+export declare function createMaestroTestsBuildFunction(): BuildFunction;

package/dist/steps/functions/maestroTests.js

@@ -0,0 +1,246 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMaestroTestsBuildFunction = createMaestroTestsBuildFunction;
+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 promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
+const maestroResultParser_1 = require("./maestroResultParser");
+const retry_1 = require("../../utils/retry");
+const FlowPathSchema = zod_1.z.array(zod_1.z.string().min(1)).min(1);
+const RetriesSchema = zod_1.z.number().int().min(0).default(0);
+const ShardsSchema = zod_1.z.number().int().min(1).optional();
+function parseInput(schema, value, message) {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        throw new eas_build_job_1.UserError('ERR_MAESTRO_INVALID_INPUT', message, { cause: result.error });
+    }
+    return result.data;
+}
+// ENOENT is excluded — "input XML missing" is a data issue, not a storage
+// fault, so the post-loop merge should fall through to copy-latest instead
+// of throwing.
+function isFilesystemError(err) {
+    if (!err || typeof err !== 'object') {
+        return false;
+    }
+    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}`);
+    }
+    out.push(...args.flow_path);
+    return out;
+}
+function createMaestroTestsBuildFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'maestro_tests',
+        name: 'Run Maestro Tests',
+        __metricsId: 'eas/maestro_tests',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'flow_path',
+                required: true,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.JSON,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'retries',
+                required: false,
+                defaultValue: 0,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'shards',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'include_tags',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'exclude_tags',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'output_format',
+                required: false,
+                defaultValue: 'junit',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'platform',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+        ],
+        outputProviders: [
+            steps_1.BuildStepOutput.createProvider({ id: 'junit_report_directory', required: true }),
+            steps_1.BuildStepOutput.createProvider({ id: 'final_report_path', required: false }),
+            steps_1.BuildStepOutput.createProvider({ id: 'tests_directory', required: true }),
+        ],
+        fn: async (stepCtx, { inputs, outputs, env, signal }) => {
+            const { logger, global } = stepCtx;
+            const platformInput = inputs.platform.value;
+            const outputFormat = inputs.output_format.value?.toLowerCase();
+            const includeTags = inputs.include_tags.value;
+            const excludeTags = inputs.exclude_tags.value;
+            const platform = platformInput === 'ios' || platformInput === 'android'
+                ? platformInput
+                : global.runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN
+                    ? 'ios'
+                    : 'android';
+            // Paths derive from env.HOME (not os.homedir()). Maestro is spawned with
+            // this env and writes debug output under $HOME/.maestro/tests; the step
+            // must read from the same place or stale files leak across runs.
+            const home = env.HOME;
+            if (!home) {
+                throw new eas_build_job_1.SystemError('HOME env var is not set');
+            }
+            const testsDirectory = path_1.default.join(home, '.maestro', 'tests');
+            const junitReportDirectory = path_1.default.join(testsDirectory, 'junit-reports');
+            const finalReportPath = outputFormat === 'junit'
+                ? path_1.default.join(testsDirectory, `${platform}-maestro-junit.xml`)
+                : undefined;
+            // Public docs (EAS workflows pre-packaged-jobs) document
+            // `${MAESTRO_TESTS_DIR}` for users to save screenshots/recordings into
+            // the uploaded dir.
+            const spawnEnv = { ...env, MAESTRO_TESTS_DIR: testsDirectory };
+            // Outputs are published BEFORE any throw below so downstream
+            // `if: always()` upload steps still see populated values when this
+            // step fails early.
+            outputs.tests_directory.set(testsDirectory);
+            outputs.junit_report_directory.set(junitReportDirectory);
+            if (finalReportPath !== undefined) {
+                outputs.final_report_path.set(finalReportPath);
+            }
+            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.');
+            try {
+                await promises_1.default.mkdir(junitReportDirectory, { recursive: true });
+            }
+            catch (err) {
+                throw new eas_build_job_1.SystemError('Failed to create JUnit report directory', { cause: err });
+            }
+            // Retry loop. spawn-async error shapes:
+            //   ENOENT/EACCES → infra (binary missing/not executable) → SystemError.
+            //   numeric err.status → maestro exited non-zero → retry.
+            //   else (signal-only, OOM kill, unknown) → infra → SystemError, never
+            //     downgraded to "tests failed".
+            // Smart retry (junit mode): after a failed attempt, subset to the failing
+            // flows. parseFailedFlowsFromJUnit returns null when the JUnit cannot be
+            // trusted; we then fall through to dumb retry (re-run everything).
+            let flowsToRun = flowPaths;
+            let lastAttemptExitCode = null;
+            for (let attempt = 0; attempt <= retries; attempt++) {
+                const outputPath = outputFormat === 'junit'
+                    ? path_1.default.join(junitReportDirectory, `${platform}-maestro-junit-attempt-${attempt}.xml`)
+                    : outputFormat
+                        ? path_1.default.join(testsDirectory, `${platform}-maestro-${outputFormat}.${outputFormat}`)
+                        : null;
+                try {
+                    await (0, turtle_spawn_1.default)('maestro', buildMaestroArgs({
+                        flow_path: flowsToRun,
+                        outputPath,
+                        output_format: outputFormat,
+                        shards,
+                        include_tags: includeTags,
+                        exclude_tags: excludeTags,
+                    }), { cwd: stepCtx.workingDirectory, env: spawnEnv, logger, signal });
+                    lastAttemptExitCode = 0;
+                }
+                catch (err) {
+                    if (err && (err.code === 'ENOENT' || err.code === 'EACCES')) {
+                        throw new eas_build_job_1.SystemError('Failed to invoke maestro', { 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 });
+                    }
+                }
+                if (lastAttemptExitCode === 0 || attempt === retries) {
+                    break;
+                }
+                if (outputFormat === 'junit' && outputPath) {
+                    const failed = await (0, maestroResultParser_1.parseFailedFlowsFromJUnit)({
+                        junitFile: outputPath,
+                        testsDirectory,
+                        inputFlowPaths: flowsToRun,
+                        projectRoot: stepCtx.workingDirectory,
+                    });
+                    if (failed !== null && failed.length > 0) {
+                        flowsToRun = failed;
+                    }
+                }
+                logger.info('Test failed, retrying...');
+                await (0, retry_1.sleepAsync)(2000);
+            }
+            // Smart merge first; on data errors (bad XML, missing input) fall back
+            // to copy-latest so the caller still gets a single JUnit file.
+            // Filesystem errors short-circuit straight to SystemError.
+            if (finalReportPath !== undefined) {
+                try {
+                    await (0, maestroResultParser_1.mergeJUnitReports)({
+                        sourceDir: junitReportDirectory,
+                        outputPath: finalReportPath,
+                    });
+                }
+                catch (mergeErr) {
+                    if (isFilesystemError(mergeErr)) {
+                        throw new eas_build_job_1.SystemError('Failed to write final_report_path', { cause: mergeErr });
+                    }
+                    logger.warn({ err: mergeErr }, 'Smart merge failed; falling back to copy-latest.');
+                    try {
+                        await (0, maestroResultParser_1.copyLatestAttemptXml)({
+                            sourceDir: junitReportDirectory,
+                            outputPath: finalReportPath,
+                        });
+                    }
+                    catch (copyErr) {
+                        // Swallow: a copy failure here usually means maestro itself failed
+                        // early (bad YAML wrote no *.xml). Throwing SystemError would mask
+                        // the real reason and cancel billing for a user-side failure — let
+                        // the lastAttemptExitCode check below surface ERR_MAESTRO_TESTS_FAILED.
+                        logger.warn(`Failed to produce final_report_path at ${finalReportPath}: ${copyErr?.message ?? copyErr}`);
+                    }
+                }
+            }
+            // The retry loop exits via success (0), numeric status (retryable),
+            // or throw (infra). A non-null non-zero status means the user's tests
+            // failed every attempt.
+            if (lastAttemptExitCode !== 0) {
+                const totalAttempts = retries + 1;
+                throw new eas_build_job_1.UserError('ERR_MAESTRO_TESTS_FAILED', `Maestro tests failed after ${totalAttempts} attempt${totalAttempts === 1 ? '' : 's'}.`);
+            }
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "18.9.0",
+  "version": "18.11.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -98,5 +98,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "8fdf47aa7d5d8241d8afa04924a1d0f6d00fdc5a"
+  "gitHead": "4dec5b3765836aff51febd47938e0c657cf9467e"
 }