@expo/build-tools 18.10.0 → 18.11.0

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

@@ -39,11 +39,39 @@ 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.
- * After the maestro retry loop completes, this produces a single canonical
- * JUnit report at final_report_path matching the bash step's "cp latest
- * attempt" semantics.
+ * 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.
  */

package/dist/steps/functions/maestroResultParser.js

@@ -7,6 +7,8 @@ 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"));
@@ -26,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)) {
@@ -84,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 {
@@ -100,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(),
@@ -247,32 +253,220 @@ async function parseMaestroResults(junitDirectory, testsDirectory, projectRoot)
     }
     return results;
 }
-async function relativizePathAsync(flowFilePath, projectRoot) {
-    if (!path_1.default.isAbsolute(flowFilePath)) {
-        return flowFilePath;
-    }
-    // Resolve symlinks (e.g., /tmp -> /private/tmp on macOS) for consistent comparison
-    let resolvedRoot = projectRoot;
-    let resolvedFlow = flowFilePath;
+/**
+ * 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 {
-        resolvedRoot = await promises_1.default.realpath(projectRoot);
+        content = await promises_1.default.readFile(args.junitFile, 'utf-8');
     }
-    catch { }
+    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 {
-        resolvedFlow = await promises_1.default.realpath(flowFilePath);
+        entries = await promises_1.default.readdir(args.testsDirectory);
     }
-    catch { }
-    const relative = path_1.default.relative(resolvedRoot, resolvedFlow);
-    if (relative.startsWith('..')) {
-        return flowFilePath;
+    catch {
+        entries = [];
     }
-    return relative;
+    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.
- * After the maestro retry loop completes, this produces a single canonical
- * JUnit report at final_report_path matching the bash step's "cp latest
- * attempt" semantics.
+ * 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.
  */
@@ -283,7 +477,8 @@ async function copyLatestAttemptXml(args) {
         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.
+    // 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);
@@ -300,3 +495,24 @@ async function copyLatestAttemptXml(args) {
     }
     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;
+    }
+    // Resolve symlinks (e.g., /tmp -> /private/tmp on macOS) for consistent comparison
+    let resolvedRoot = projectRoot;
+    let resolvedFlow = flowFilePath;
+    try {
+        resolvedRoot = await promises_1.default.realpath(projectRoot);
+    }
+    catch { }
+    try {
+        resolvedFlow = await promises_1.default.realpath(flowFilePath);
+    }
+    catch { }
+    const relative = path_1.default.relative(resolvedRoot, resolvedFlow);
+    if (relative.startsWith('..')) {
+        return flowFilePath;
+    }
+    return relative;
+}

package/dist/steps/functions/maestroTests.js

@@ -22,6 +22,16 @@ function parseInput(schema, value, message) {
     }
     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.
@@ -144,6 +154,10 @@ function createMaestroTestsBuildFunction() {
             //   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'
@@ -153,7 +167,7 @@ function createMaestroTestsBuildFunction() {
                         : null;
                 try {
                     await (0, turtle_spawn_1.default)('maestro', buildMaestroArgs({
-                        flow_path: flowPaths,
+                        flow_path: flowsToRun,
                         outputPath,
                         output_format: outputFormat,
                         shards,
@@ -176,24 +190,48 @@ function createMaestroTestsBuildFunction() {
                 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);
             }
-            // Copy the latest attempt's JUnit to the final report path so downstream
-            // upload/report steps have a single canonical file.
+            // 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.copyLatestAttemptXml)({
+                    await (0, maestroResultParser_1.mergeJUnitReports)({
                         sourceDir: junitReportDirectory,
                         outputPath: finalReportPath,
                     });
                 }
-                catch (copyErr) {
-                    // Swallow: a copy failure usually means maestro itself failed early
-                    // (bad YAML wrote no *.xml). Throwing SystemError here 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}`);
+                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),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "18.10.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": "cacd48bf669342be783037607b02e5f9b1b148c0"
+  "gitHead": "4dec5b3765836aff51febd47938e0c657cf9467e"
 }