@expo/build-tools 20.0.0 → 20.2.0

package/dist/steps/functions/findAndUploadBuildArtifacts.js

@@ -23,14 +23,14 @@ function createFindAndUploadBuildArtifactsBuildFunction(ctx) {
                 await uploadApplicationArchivesAsync({ ctx, stepCtx });
             }
             catch (err) {
-                stepCtx.logger.error(`Failed to upload application archives.`, err);
+                stepCtx.logger.error({ err }, `Failed to upload application archives.`);
                 firstError ||= err;
             }
             try {
                 await uploadBuildArtifacts({ ctx, stepCtx });
             }
             catch (err) {
-                stepCtx.logger.error(`Failed to upload build artifacts.`, err);
+                stepCtx.logger.error({ err }, `Failed to upload build artifacts.`);
                 firstError ||= err;
             }
             if (ctx.job.platform === eas_build_job_1.Platform.IOS) {

package/dist/steps/functions/installMaestro.js

@@ -11,6 +11,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 datadog_1 = require("../../datadog");
 function createInstallMaestroBuildFunction() {
     return new steps_1.BuildFunction({
         namespace: 'eas',
@@ -95,12 +96,22 @@ function createInstallMaestroBuildFunction() {
             }
             logger.info(`Maestro ${maestroVersionResult.value} is ready.`);
             outputs.maestro_version.set(maestroVersionResult.value);
+            datadog_1.Datadog.distribution('eas.maestro.install', 1, {
+                maestro_version: maestroVersionResult.value,
+            });
         },
     });
 }
 async function getMaestroVersion({ env }) {
-    const maestroVersion = await (0, turtle_spawn_1.default)('maestro', ['--version'], { stdio: 'pipe', env });
-    return maestroVersion.stdout.trim();
+    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 installMaestro({ global, version, logger, env, }) {
     logger.info('Fetching install script');

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

@@ -10,6 +10,7 @@ export interface MaestroFlowResult {
 }
 export interface JUnitTestCaseResult {
     name: string;
+    file: string | undefined;
     status: 'passed' | 'failed';
     duration: number;
     errorMessage: string | null;
@@ -17,6 +18,23 @@ export interface JUnitTestCaseResult {
     properties: Record<string, string>;
 }
 export declare function parseJUnitTestCases(junitDirectory: string): Promise<JUnitTestCaseResult[]>;
+export declare function isFileAttrRun(testcases: JUnitTestCaseResult[]): testcases is (JUnitTestCaseResult & {
+    file: string;
+})[];
+export declare function junitFileHasFileAttrs(junitFile: string): Promise<boolean>;
+export declare function parseMaestroResultsFromFileAttrs(junitDirectory: string): Promise<MaestroFlowResult[]>;
+/**
+ * Returns the `file=` paths of the failing testcases 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; never the legacy scan).
+ *
+ * Callers verify the report carries `file=` attributes first
+ * (junitFileHasFileAttrs).
+ */
+export declare function parseFailedFlowsFromFileAttrs(args: {
+    junitFile: string;
+    workingDirectory: string;
+}): Promise<string[] | null>;
 export declare function parseMaestroResults(junitDirectory: string, nameToPath: Map<string, string> | null): Promise<MaestroFlowResult[]>;
 /**
  * Returns the subset of `inputFlowPaths` whose testcases failed in the given

package/dist/steps/functions/maestroResultParser.js

@@ -4,10 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseJUnitTestCases = parseJUnitTestCases;
+exports.isFileAttrRun = isFileAttrRun;
+exports.junitFileHasFileAttrs = junitFileHasFileAttrs;
+exports.parseMaestroResultsFromFileAttrs = parseMaestroResultsFromFileAttrs;
+exports.parseFailedFlowsFromFileAttrs = parseFailedFlowsFromFileAttrs;
 exports.parseMaestroResults = parseMaestroResults;
 exports.parseFailedFlowsFromJUnit = parseFailedFlowsFromJUnit;
 exports.mergeJUnitReports = mergeJUnitReports;
 exports.copyLatestAttemptXml = copyLatestAttemptXml;
+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"));
@@ -19,6 +24,11 @@ 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.
+function fileAttrOf(tc) {
+    const f = tc?.['@_file'];
+    return typeof f === 'string' && f.length > 0 ? f : undefined;
+}
 function parseJUnitContent(content) {
     const results = [];
     try {
@@ -37,6 +47,7 @@ function parseJUnitContent(content) {
                 if (!name) {
                     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;
@@ -70,7 +81,7 @@ function parseJUnitContent(content) {
                         .filter(Boolean)
                     : [];
                 delete properties['tags'];
-                results.push({ name, status, duration, errorMessage, tags, properties });
+                results.push({ name, file, status, duration, errorMessage, tags, properties });
             }
         }
     }
@@ -103,6 +114,119 @@ async function parseJUnitTestCases(junitDirectory) {
     const perFile = await Promise.all(xmlFiles.map(f => parseJUnitFile(path_1.default.join(junitDirectory, f))));
     return perFile.flat();
 }
+// ---------------------------------------------------------------------------
+// Maestro >= 2.6.0 code path: every <testcase> carries a `file=` attribute with
+// its flow's own path (all-or-none per run). Callers check the report first
+// (isFileAttrRun / junitFileHasFileAttrs) and route here; the legacy name→path
+// scan is then never consulted.
+// ---------------------------------------------------------------------------
+function isFileAttrRun(testcases) {
+    return testcases.length > 0 && testcases.every(tc => tc.file !== undefined);
+}
+// Unreadable or attribute-less reports ⇒ false: the caller then takes the
+// legacy path, whose own guards degrade safely.
+async function junitFileHasFileAttrs(junitFile) {
+    return isFileAttrRun(await parseJUnitFile(junitFile));
+}
+async function fileExists(absPath) {
+    return (await (0, results_1.asyncResult)(promises_1.default.stat(absPath))).ok;
+}
+// Group by `file=` so two same-named flows in different files stay separate.
+async function parseMaestroResultsFromFileAttrs(junitDirectory) {
+    let junitEntries;
+    try {
+        junitEntries = await promises_1.default.readdir(junitDirectory);
+    }
+    catch {
+        return [];
+    }
+    const xmlFiles = junitEntries.filter(f => f.endsWith('.xml')).sort();
+    const entries = [];
+    for (const xmlFile of xmlFiles) {
+        const fileResults = await parseJUnitFile(path_1.default.join(junitDirectory, xmlFile));
+        for (const result of fileResults) {
+            entries.push({ result, sourceFile: xmlFile });
+        }
+    }
+    const byPath = new Map();
+    for (const entry of entries) {
+        // Callers verify the report with isFileAttrRun/junitFileHasFileAttrs first;
+        // skip (rather than emit an undefined path) if that contract is violated.
+        const flowPath = entry.result.file;
+        if (flowPath === undefined) {
+            continue;
+        }
+        const group = byPath.get(flowPath) ?? [];
+        group.push(entry);
+        byPath.set(flowPath, group);
+    }
+    const results = [];
+    for (const [flowPath, group] of byPath) {
+        // retryCount is derived from each entry's source filename (`attempt-N`);
+        // a single entry from `report.xml` (no marker) collapses to attempt 0.
+        const sorted = group
+            .map(entry => {
+            const match = entry.sourceFile.match(ATTEMPT_PATTERN);
+            const attemptIndex = match ? parseInt(match[1], 10) : 0;
+            return { ...entry, attemptIndex };
+        })
+            .sort((a, b) => a.attemptIndex - b.attemptIndex);
+        for (const { result, attemptIndex } of sorted) {
+            results.push({
+                name: result.name,
+                path: flowPath,
+                status: result.status,
+                errorMessage: result.errorMessage,
+                duration: result.duration,
+                retryCount: attemptIndex,
+                tags: result.tags,
+                properties: result.properties,
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Returns the `file=` paths of the failing testcases 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; never the legacy scan).
+ *
+ * Callers verify the report carries `file=` attributes first
+ * (junitFileHasFileAttrs).
+ */
+async function parseFailedFlowsFromFileAttrs(args) {
+    // Same hardening as the legacy parser: fast-xml-parser is lenient — a
+    // truncated XML could drop testcases, and trusting that partial failing set
+    // would skip retries for cut-off flows.
+    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 (!isFileAttrRun(testcases)) {
+        return null;
+    }
+    const failing = testcases.filter(tc => tc.status === 'failed');
+    if (failing.length === 0) {
+        return [];
+    }
+    // Each failing testcase is self-identifying via `file=`, so duplicate flow
+    // names retry correctly. path.resolve (not join): `file=` may be absolute
+    // when the flow lives outside the working directory.
+    const paths = [...new Set(failing.map(tc => tc.file))];
+    for (const p of paths) {
+        if (!(await fileExists(path_1.default.resolve(args.workingDirectory, p)))) {
+            return null;
+        }
+    }
+    return paths;
+}
 async function parseMaestroResults(junitDirectory, nameToPath) {
     let junitEntries;
     try {
@@ -251,6 +375,10 @@ async function mergeJUnitReports(args) {
         }
         const match = filename.match(ATTEMPT_PATTERN);
         const attemptIndex = match ? parseInt(match[1], 10) : 0;
+        // Maestro >= 2.6.0 reports: key by `file=` so two same-named flows in
+        // different files merge separately. Legacy reports keep name keying.
+        const allCases = testsuites.flatMap((suite) => Array.isArray(suite?.testcase) ? suite.testcase : []);
+        const useFileKeys = allCases.length > 0 && allCases.every((tc) => fileAttrOf(tc) !== undefined);
         const testcasesByName = new Map();
         for (const suite of testsuites) {
             const cases = suite?.testcase;
@@ -262,9 +390,10 @@ async function mergeJUnitReports(args) {
                 if (typeof name !== 'string') {
                     continue;
                 }
-                const group = testcasesByName.get(name) ?? [];
+                const key = useFileKeys ? fileAttrOf(tc) : name;
+                const group = testcasesByName.get(key) ?? [];
                 group.push(tc);
-                testcasesByName.set(name, group);
+                testcasesByName.set(key, group);
             }
         }
         if (testcasesByName.size === 0) {

package/dist/steps/functions/maestroTests.js

@@ -157,20 +157,17 @@ function createMaestroTestsBuildFunction() {
             catch (err) {
                 throw new eas_build_job_1.SystemError('Failed to create JUnit report directory', { cause: err });
             }
-            // null → duplicate flow names; retry-failed-only disabled, fall through to
-            // dumb retry (re-run everything) on failure.
-            const nameToPath = await (0, maestroFlowDiscovery_1.buildFlowNameToPathMap)({
-                inputFlowPaths: flowPaths,
-                projectRoot: stepCtx.workingDirectory,
-                logger,
-            });
+            // Legacy-only (Maestro < 2.6.0 reports carry no `file=` attribute): the
+            // flow scan is built lazily in the retry branch below and memoized so
+            // retries share one scan. Never runs when the report has `file=`.
+            let nameToPathPromise;
             // 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".
             // Retry-failed-only (junit mode): after a failed attempt, subset to the failing
-            // flows. parseFailedFlowsFromJUnit returns null when the JUnit cannot be
+            // flows. The failed-flow parsers return null when the JUnit cannot be
             // trusted; we then fall through to dumb retry (re-run everything).
             let flowsToRun = flowPaths;
             let lastAttemptExitCode = null;
@@ -213,11 +210,27 @@ function createMaestroTestsBuildFunction() {
                 if (lastAttemptExitCode === 0 || attempt === retries) {
                     break;
                 }
-                if (retryFailedOnly && outputFormat === 'junit' && outputPath && nameToPath) {
-                    const failed = await (0, maestroResultParser_1.parseFailedFlowsFromJUnit)({
-                        junitFile: outputPath,
-                        nameToPath,
-                    });
+                if (retryFailedOnly && outputFormat === 'junit' && outputPath) {
+                    let failed;
+                    if (await (0, maestroResultParser_1.junitFileHasFileAttrs)(outputPath)) {
+                        failed = await (0, maestroResultParser_1.parseFailedFlowsFromFileAttrs)({
+                            junitFile: outputPath,
+                            workingDirectory: stepCtx.workingDirectory,
+                        });
+                    }
+                    else {
+                        // Legacy (Maestro < 2.6.0): map failed testcase names back to flow
+                        // paths via the flow-file scan. DELETE this arm once the fleet is
+                        // on >= 2.6.0.
+                        const nameToPath = await (nameToPathPromise ??= (0, maestroFlowDiscovery_1.buildFlowNameToPathMap)({
+                            inputFlowPaths: flowPaths,
+                            projectRoot: stepCtx.workingDirectory,
+                            logger,
+                        }));
+                        failed = nameToPath
+                            ? await (0, maestroResultParser_1.parseFailedFlowsFromJUnit)({ junitFile: outputPath, nameToPath })
+                            : null;
+                    }
                     if (failed !== null && failed.length > 0) {
                         flowsToRun = failed;
                         logger.info(`Test failed; retrying ${failed.length} failed flow(s): ${failed.join(', ')}`);

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

@@ -13,7 +13,9 @@ export declare function resolveAndroidSigningOptionsAsync({ job, tmpDir, }: {
 /**
  * Resolves iOS signing options from the job secrets.
  */
-export declare function resolveIosSigningOptionsAsync({ job, logger, }: {
+export declare function resolveIosSigningOptionsAsync({ job, logger, useAppEntitlements, entitlementsPath, }: {
     job: Job;
     logger: bunyan;
+    useAppEntitlements?: boolean;
+    entitlementsPath?: string;
 }): Promise<IosSigningOptions | undefined>;

package/dist/steps/functions/repack.js

@@ -48,6 +48,16 @@ function createRepackBuildFunction() {
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
                 required: false,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'ios_signing_use_source_app_entitlements',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'ios_signing_app_entitlements_path',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+            }),
             steps_1.BuildStepInput.createProvider({
                 id: 'repack_version',
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
@@ -116,6 +126,8 @@ function createRepackBuildFunction() {
                         iosSigningOptions: await resolveIosSigningOptionsAsync({
                             job: stepsCtx.global.staticContext.job,
                             logger: stepsCtx.logger,
+                            useAppEntitlements: inputs.ios_signing_use_source_app_entitlements.value,
+                            entitlementsPath: inputs.ios_signing_app_entitlements_path.value,
                         }),
                         logger: stepsCtx.logger,
                         spawnAsync: repackSpawnAsync,
@@ -219,7 +231,7 @@ async function resolveAndroidSigningOptionsAsync({ job, tmpDir, }) {
 /**
  * Resolves iOS signing options from the job secrets.
  */
-async function resolveIosSigningOptionsAsync({ job, logger, }) {
+async function resolveIosSigningOptionsAsync({ job, logger, useAppEntitlements, entitlementsPath, }) {
     const iosJob = job;
     const buildCredentials = iosJob.secrets?.buildCredentials;
     if (iosJob.simulator || buildCredentials == null) {
@@ -235,5 +247,7 @@ async function resolveIosSigningOptionsAsync({ job, logger, }) {
         provisioningProfile,
         keychainPath: credentials.keychainPath,
         signingIdentity: credentials.applicationTargetProvisioningProfile.data.certificateCommonName,
+        useAppEntitlements,
+        entitlementsPath,
     };
 }

package/dist/steps/functions/reportMaestroTestResults.js

@@ -57,41 +57,60 @@ function createReportMaestroTestResultsFunction(ctx) {
                 logger.info('No JUnit directory provided, skipping test results report');
                 return;
             }
-            const flowPathRaw = inputs.flow_path.value;
-            let nameToPath = null;
-            if (flowPathRaw !== undefined) {
-                const parsed = FlowPathSchema.safeParse(flowPathRaw);
-                if (parsed.success) {
-                    nameToPath = await (0, maestroFlowDiscovery_1.buildFlowNameToPathMap)({
-                        inputFlowPaths: parsed.data,
-                        projectRoot: stepsCtx.workingDirectory,
-                        logger,
-                    });
+            try {
+                // Maestro >= 2.6.0 stamps every <testcase> with its flow's path in a
+                // `file=` attribute; older reports need the legacy flow-file scan to
+                // map testcase names back to paths.
+                const usedFileAttrs = (0, maestroResultParser_1.isFileAttrRun)(await (0, maestroResultParser_1.parseJUnitTestCases)(junitDirectory));
+                let flowResults;
+                if (usedFileAttrs) {
+                    flowResults = await (0, maestroResultParser_1.parseMaestroResultsFromFileAttrs)(junitDirectory);
                 }
                 else {
-                    logger.warn('Ignoring malformed flow_path input (expected a non-empty array of non-empty strings).');
+                    // Legacy (Maestro < 2.6.0) — DELETE this arm once the fleet is on >= 2.6.0.
+                    const flowPathRaw = inputs.flow_path.value;
+                    let nameToPath = null;
+                    if (flowPathRaw !== undefined) {
+                        const parsed = FlowPathSchema.safeParse(flowPathRaw);
+                        if (parsed.success) {
+                            nameToPath = await (0, maestroFlowDiscovery_1.buildFlowNameToPathMap)({
+                                inputFlowPaths: parsed.data,
+                                projectRoot: stepsCtx.workingDirectory,
+                                logger,
+                            });
+                        }
+                        else {
+                            logger.warn('Ignoring malformed flow_path input (expected a non-empty array of non-empty strings).');
+                        }
+                    }
+                    flowResults = await (0, maestroResultParser_1.parseMaestroResults)(junitDirectory, nameToPath);
                 }
-            }
-            try {
-                const flowResults = await (0, maestroResultParser_1.parseMaestroResults)(junitDirectory, nameToPath);
                 if (flowResults.length === 0) {
                     logger.info('No maestro test results found, skipping report');
                     return;
                 }
-                // Detect truly conflicting results: same (name, retryCount) pair means different flow files
-                // share the same name (Maestro config override), which we can't disambiguate.
-                // Same name with different retryCount is expected (per-attempt results from retries).
+                // Detect truly conflicting results: the same (path, retryCount) twice means two
+                // flow files resolved to the same path, which we can't disambiguate and the API
+                // rejects as a duplicate. Same path with different retryCount is expected
+                // (per-attempt results from retries).
                 const seen = new Set();
                 const conflicting = new Set();
                 for (const r of flowResults) {
-                    const key = `${r.name}:${r.retryCount}`;
+                    const key = `${r.path}:${r.retryCount}`;
                     if (seen.has(key)) {
-                        conflicting.add(r.name);
+                        conflicting.add(r.path);
                     }
                     seen.add(key);
                 }
                 if (conflicting.size > 0) {
-                    logger.error(`Duplicate test case names found in JUnit output: ${[...conflicting].join(', ')}. Skipping report. Ensure each Maestro flow has a unique name.`);
+                    const conflictList = [...conflicting].join(', ');
+                    logger.error(usedFileAttrs
+                        ? `The same flow file was reported more than once in a single attempt: ` +
+                            `${conflictList}. Skipping report. Check for duplicate flow_path entries ` +
+                            `or leftover XML files in the JUnit report directory.`
+                        : `Duplicate Maestro flow names found: ${conflictList}. Skipping report. ` +
+                            `Give each flow a unique name, or upgrade Maestro to >= 2.6.0 (flows are ` +
+                            `then identified by file path, so duplicate names are fine).`);
                     return;
                 }
                 const testCaseResults = flowResults.flatMap(f => {

package/dist/steps/functions/restoreBuildCache.js

@@ -159,12 +159,15 @@ async function restoreGradleCacheAsync({ logger, workingDirectory, env, secrets,
         return;
     }
     try {
-        const gradlePropertiesPath = path_1.default.join(workingDirectory, 'android', 'gradle.properties');
-        const gradlePropertiesContent = await fs_1.default.promises.readFile(gradlePropertiesPath, 'utf-8');
-        await fs_1.default.promises.writeFile(gradlePropertiesPath, `${gradlePropertiesContent}\n\norg.gradle.caching=true\n`);
-        // Configure cache cleanup via init script (works with both Gradle 8 and 9,
-        // org.gradle.cache.cleanup property was removed in Gradle 9)
-        const initScriptDir = path_1.default.join(os_1.default.homedir(), '.gradle', 'init.d');
+        // Enable build cache via user-level gradle.properties.
+        // This avoids mutating android/gradle.properties which affects fingerprinting.
+        const gradleUserHome = path_1.default.join(os_1.default.homedir(), '.gradle');
+        await fs_1.default.promises.mkdir(gradleUserHome, { recursive: true });
+        const userGradlePropertiesPath = path_1.default.join(gradleUserHome, 'gradle.properties');
+        await fs_1.default.promises.appendFile(userGradlePropertiesPath, '\norg.gradle.caching=true\n');
+        // Configure cache cleanup via init script.
+        // Works with both Gradle 8 and 9 (org.gradle.cache.cleanup property was removed in Gradle 9).
+        const initScriptDir = path_1.default.join(gradleUserHome, 'init.d');
         await fs_1.default.promises.mkdir(initScriptDir, { recursive: true });
         await fs_1.default.promises.writeFile(path_1.default.join(initScriptDir, 'eas-cache-cleanup.gradle'), [
             'def cacheDir = new File(System.getProperty("user.home"), ".gradle/caches/build-cache-1")',

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

@@ -1,3 +1,3 @@
 import { BuildFunction } from '@expo/steps';
-import { CustomBuildContext } from '../../customBuildContext';
+import { type CustomBuildContext } from '../../customBuildContext';
 export declare function createStartAgentDeviceRemoteSessionBuildFunction(ctx: CustomBuildContext): BuildFunction;