@expo/build-tools 18.10.0 → 18.12.0

package/dist/common/easBuildInternal.js

@@ -28,33 +28,38 @@ async function runEasBuildInternalAsync({ job, logger, env, cwd, projectRootOver
     else if (githubTriggerOptions?.autoSubmit) {
         autoSubmitArgs.push('--auto-submit');
     }
-    const result = await (0, turtle_spawn_1.default)(cmd, [
-        ...args,
-        'build:internal',
-        '--platform',
-        job.platform,
-        '--profile',
-        buildProfile,
-        ...autoSubmitArgs,
-    ], {
-        cwd,
-        env: {
-            ...env,
-            EXPO_TOKEN: (0, nullthrows_1.default)(job.secrets, 'Secrets must be defined for non-custom builds')
-                .robotAccessToken,
-            ...extraEnv,
-            EAS_PROJECT_ROOT: projectRootOverride,
-        },
-        logger,
-        // This prevents printing stdout with job secrets and credentials to logs.
-        mode: logger_1.PipeMode.STDERR_ONLY_AS_STDOUT,
-    });
-    const stdout = result.stdout.toString();
-    const parsed = JSON.parse(stdout);
-    return validateEasBuildInternalResult({
-        result: parsed,
-        oldJob: job,
-    });
+    try {
+        const result = await (0, turtle_spawn_1.default)(cmd, [
+            ...args,
+            'build:internal',
+            '--platform',
+            job.platform,
+            '--profile',
+            buildProfile,
+            ...autoSubmitArgs,
+        ], {
+            cwd,
+            env: {
+                ...env,
+                EXPO_TOKEN: (0, nullthrows_1.default)(job.secrets, 'Secrets must be defined for non-custom builds')
+                    .robotAccessToken,
+                ...extraEnv,
+                EAS_PROJECT_ROOT: projectRootOverride,
+            },
+            logger,
+            // This prevents printing stdout with job secrets and credentials to logs.
+            mode: logger_1.PipeMode.STDERR_ONLY_AS_STDOUT,
+        });
+        const stdout = result.stdout.toString();
+        const parsed = JSON.parse(stdout);
+        return validateEasBuildInternalResult({
+            result: parsed,
+            oldJob: job,
+        });
+    }
+    catch (err) {
+        throw new Error('Failed to run eas build:internal');
+    }
 }
 async function resolveEnvFromBuildProfileAsync(ctx, { cwd }) {
     const { cmd, args, extraEnv } = await (0, easCli_1.resolveEasCommandPrefixAndEnvAsync)();

package/dist/ios/pod.js

@@ -8,8 +8,8 @@ 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/';
+const MIN_PRECOMPILED_MODULES_EXPO_VERSION = '55.0.21';
+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'] : [];
@@ -58,10 +58,9 @@ async function resolvePrecompiledModulesPodInstallEnvAsync(ctx) {
         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(),
+        EXPO_PRECOMPILED_MODULES_BASE_URL: getPrecompiledModulesBaseUrl(ctx),
     };
     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}`)
@@ -77,14 +76,10 @@ async function getInstalledExpoPackageVersionAsync(ctx) {
     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}`
-//   );
-// }
+function getPrecompiledModulesBaseUrl(ctx) {
+    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

@@ -75,7 +75,7 @@ function getEasFunctions(ctx) {
         (0, generateGymfileFromTemplate_1.generateGymfileFromTemplateFunction)(),
         (0, runFastlane_1.runFastlaneFunction)(),
         (0, parseXcactivitylog_1.parseXcactivitylogFunction)(),
-        (0, startAgentDeviceRemoteSession_1.createStartAgentDeviceRemoteSessionBuildFunction)(),
+        (0, startAgentDeviceRemoteSession_1.createStartAgentDeviceRemoteSessionBuildFunction)(ctx),
         (0, startAndroidEmulator_1.createStartAndroidEmulatorBuildFunction)(),
         (0, startCuttlefishDevice_1.createStartCuttlefishDeviceBuildFunction)(),
         (0, startIosSimulator_1.createStartIosSimulatorBuildFunction)(),

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

@@ -0,0 +1,9 @@
+import type { bunyan } from '@expo/logger';
+export interface BuildFlowNameToPathMapArgs {
+    inputFlowPaths: string[];
+    projectRoot: string;
+    logger: bunyan;
+}
+export declare function buildFlowNameToPathMap(args: BuildFlowNameToPathMapArgs): Promise<Map<string, string> | null>;
+export declare function walkDir(dir: string, visited: Set<string>, out: string[], logger: bunyan): Promise<void>;
+export declare function readFlowName(absFile: string): Promise<string>;

package/dist/steps/functions/maestroFlowDiscovery.js

@@ -0,0 +1,163 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFlowNameToPathMap = buildFlowNameToPathMap;
+exports.walkDir = walkDir;
+exports.readFlowName = readFlowName;
+const results_1 = require("@expo/results");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = __importDefault(require("yaml"));
+const YAML_EXT = /\.ya?ml$/i;
+const WORKSPACE_CONFIG_BASENAME = 'config.yaml';
+async function buildFlowNameToPathMap(args) {
+    try {
+        const flows = await discoverFlows(args);
+        return dedupAndDetectDuplicates(flows, args.logger);
+    }
+    catch (err) {
+        args.logger.warn(`buildFlowNameToPathMap failed unexpectedly: ${err?.message ?? String(err)}`);
+        return null;
+    }
+}
+async function discoverFlows({ inputFlowPaths, projectRoot, logger, }) {
+    const realRootResult = await (0, results_1.asyncResult)(promises_1.default.realpath(projectRoot));
+    const realRoot = realRootResult.ok ? realRootResult.value : projectRoot;
+    const fileLists = await Promise.all(inputFlowPaths.map(async (input) => {
+        const abs = path_1.default.resolve(projectRoot, input);
+        const statResult = await (0, results_1.asyncResult)(promises_1.default.stat(abs));
+        if (!statResult.ok) {
+            logger.warn(`flow_path entry "${input}" not found, skipping`);
+            return [];
+        }
+        const stat = statResult.value;
+        if (stat.isFile() && YAML_EXT.test(abs)) {
+            return [abs];
+        }
+        if (stat.isDirectory()) {
+            const out = [];
+            await walkDir(abs, new Set(), out, logger);
+            return out;
+        }
+        return [];
+    }));
+    return Promise.all(fileLists.flat().map(absFile => makeEntry(absFile, realRoot)));
+}
+async function makeEntry(absFile, realRoot) {
+    const [name, realFileResult] = await Promise.all([
+        readFlowName(absFile),
+        (0, results_1.asyncResult)(promises_1.default.realpath(absFile)),
+    ]);
+    const realFile = realFileResult.ok ? realFileResult.value : absFile;
+    const rel = path_1.default.relative(realRoot, realFile);
+    const value = rel.startsWith('..') || path_1.default.isAbsolute(rel) ? absFile : rel;
+    return { name, path: value, realpath: realFile };
+}
+function dedupAndDetectDuplicates(flows, logger) {
+    const byKey = new Map();
+    for (const f of flows) {
+        if (!byKey.has(f.realpath)) {
+            byKey.set(f.realpath, f);
+        }
+    }
+    const unique = [...byKey.values()];
+    const nameToPath = new Map();
+    const duplicates = new Map();
+    for (const f of unique) {
+        if (nameToPath.has(f.name)) {
+            const existing = nameToPath.get(f.name);
+            const list = duplicates.get(f.name) ?? [existing];
+            list.push(f.path);
+            duplicates.set(f.name, list);
+        }
+        nameToPath.set(f.name, f.path);
+    }
+    if (duplicates.size > 0) {
+        for (const [name, paths] of duplicates) {
+            logger.warn(`Duplicate Maestro flow name "${name}" across paths: ${paths.join(', ')}.`);
+        }
+        logger.warn('Retry-failed-only is disabled for this run; will retry all flows on failure. ' +
+            'Give each Maestro flow a unique name (file basename or top-level name) to enable retry-failed-only.');
+        return null;
+    }
+    return nameToPath;
+}
+async function walkDir(dir, visited, out, logger) {
+    // Cycle protection: dedup on realpath (fall back to the original path when
+    // realpath fails so we still make progress on missing or restricted dirs).
+    const realResult = await (0, results_1.asyncResult)(promises_1.default.realpath(dir));
+    const real = realResult.ok ? realResult.value : dir;
+    if (visited.has(real)) {
+        return;
+    }
+    visited.add(real);
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        logger.warn(`readdir failed for ${dir}: ${err?.message ?? String(err)}`);
+        return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+        const full = path_1.default.join(dir, entry.name);
+        if (entry.isSymbolicLink()) {
+            const tgtResult = await (0, results_1.asyncResult)(promises_1.default.stat(full));
+            if (!tgtResult.ok) {
+                continue;
+            }
+            const tgt = tgtResult.value;
+            if (tgt.isDirectory()) {
+                await walkDir(full, visited, out, logger);
+            }
+            else if (tgt.isFile() && isYamlFile(entry.name) && !isWorkspaceConfig(entry.name)) {
+                out.push(full);
+            }
+        }
+        else if (entry.isDirectory()) {
+            await walkDir(full, visited, out, logger);
+        }
+        else if (entry.isFile()) {
+            if (isYamlFile(entry.name) && !isWorkspaceConfig(entry.name)) {
+                out.push(full);
+            }
+        }
+    }
+}
+async function readFlowName(absFile) {
+    const ext = path_1.default.extname(absFile);
+    const fallback = path_1.default.basename(absFile, ext);
+    let content;
+    try {
+        content = await promises_1.default.readFile(absFile, 'utf-8');
+    }
+    catch {
+        return fallback;
+    }
+    let firstDoc;
+    try {
+        const docs = yaml_1.default.parseAllDocuments(content);
+        firstDoc = docs[0];
+    }
+    catch {
+        return fallback;
+    }
+    if (!firstDoc || firstDoc.errors.length > 0) {
+        return fallback;
+    }
+    const parsed = firstDoc.toJS();
+    const name = parsed?.name;
+    if (typeof name === 'string' && name.length > 0) {
+        return name;
+    }
+    return fallback;
+}
+function isYamlFile(name) {
+    return YAML_EXT.test(name);
+}
+function isWorkspaceConfig(name) {
+    return name.toLowerCase() === WORKSPACE_CONFIG_BASENAME;
+}

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

@@ -1,4 +1,3 @@
-import { z } from 'zod';
 export interface MaestroFlowResult {
     name: string;
     path: string;
@@ -9,7 +8,6 @@ export interface MaestroFlowResult {
     tags: string[];
     properties: Record<string, string>;
 }
-export declare function extractFlowKey(filename: string, prefix: string): string | null;
 export interface JUnitTestCaseResult {
     name: string;
     status: 'passed' | 'failed';
@@ -19,31 +17,38 @@ export interface JUnitTestCaseResult {
     properties: Record<string, string>;
 }
 export declare function parseJUnitTestCases(junitDirectory: string): Promise<JUnitTestCaseResult[]>;
-declare const FlowMetadataFileSchema: z.ZodObject<{
-    flow_name: z.ZodString;
-    flow_file_path: z.ZodString;
-}, z.core.$strip>;
-type FlowMetadata = z.output<typeof FlowMetadataFileSchema>;
+export declare function parseMaestroResults(junitDirectory: string, nameToPath: Map<string, string> | null): Promise<MaestroFlowResult[]>;
 /**
- * Parses an `ai-*.json` file produced by Maestro's TestDebugReporter.
+ * 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).
  *
- * The file contains:
- * - `flow_name`: derived from the YAML `config.name` field if present, otherwise
- *   the flow filename without extension.
- *   See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/runner/TestRunner.kt#L70
- * - `flow_file_path`: absolute path to the original flow YAML file.
- * - `outputs`: screenshot defect data (unused here).
+ * Caller passes a precomputed `nameToPath` map built from the user's
+ * `inputFlowPaths`. We translate failed testcase names to flow paths via
+ * that map; unknown names → null.
+ */
+export declare function parseFailedFlowsFromJUnit(args: {
+    junitFile: string;
+    nameToPath: Map<string, 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.
  *
- * Filename format: `ai-(flowName).json` where `/` in flowName is replaced with `_`.
- * See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/report/TestDebugReporter.kt#L67
+ * 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 parseFlowMetadata(filePath: string): Promise<FlowMetadata | null>;
-export declare function parseMaestroResults(junitDirectory: string, testsDirectory: string, projectRoot: string): Promise<MaestroFlowResult[]>;
+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.
  */
@@ -51,4 +56,3 @@ export declare function copyLatestAttemptXml(args: {
     sourceDir: string;
     outputPath: string;
 }): Promise<void>;
-export {};

package/dist/steps/functions/maestroResultParser.js

@@ -3,34 +3,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
-}
 const xmlParser = new fast_xml_parser_1.XMLParser({
     ignoreAttributes: false,
     attributeNamePrefix: '@_',
     // 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 +75,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,41 +100,10 @@ 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(),
-    flow_file_path: zod_1.z.string(),
-});
-/**
- * Parses an `ai-*.json` file produced by Maestro's TestDebugReporter.
- *
- * The file contains:
- * - `flow_name`: derived from the YAML `config.name` field if present, otherwise
- *   the flow filename without extension.
- *   See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/runner/TestRunner.kt#L70
- * - `flow_file_path`: absolute path to the original flow YAML file.
- * - `outputs`: screenshot defect data (unused here).
- *
- * Filename format: `ai-(flowName).json` where `/` in flowName is replaced with `_`.
- * See: https://github.com/mobile-dev-inc/Maestro/blob/c0e95fd/maestro-cli/src/main/java/maestro/cli/report/TestDebugReporter.kt#L67
- */
-async function parseFlowMetadata(filePath) {
-    try {
-        const content = await promises_1.default.readFile(filePath, 'utf-8');
-        const data = JSON.parse(content);
-        return FlowMetadataFileSchema.parse(data);
-    }
-    catch {
-        return null;
-    }
-}
-async function parseMaestroResults(junitDirectory, testsDirectory, projectRoot) {
-    // 1. Parse JUnit XML files, tracking which file each result came from
+async function parseMaestroResults(junitDirectory, nameToPath) {
     let junitEntries;
     try {
         junitEntries = await promises_1.default.readdir(junitDirectory);
@@ -156,44 +125,7 @@ async function parseMaestroResults(junitDirectory, testsDirectory, projectRoot)
     if (junitResultsWithSource.length === 0) {
         return [];
     }
-    // 2. Parse ai-*.json from debug output for flow_file_path + retryCount
-    const flowPathMap = new Map(); // flowName → flowFilePath
-    const flowOccurrences = new Map(); // flowName → count
-    let entries;
-    try {
-        entries = await promises_1.default.readdir(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(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;
-            }
-            // Track latest path (last timestamp dir wins)
-            flowPathMap.set(metadata.flow_name, metadata.flow_file_path);
-            // Count occurrences for retryCount
-            flowOccurrences.set(metadata.flow_name, (flowOccurrences.get(metadata.flow_name) ?? 0) + 1);
-        }
-    }
-    // 3. Merge: JUnit results + ai-*.json metadata
     const results = [];
-    // Group results by flow name
     const resultsByName = new Map();
     for (const entry of junitResultsWithSource) {
         const group = resultsByName.get(entry.result.name) ?? [];
@@ -201,78 +133,202 @@ async function parseMaestroResults(junitDirectory, testsDirectory, projectRoot)
         resultsByName.set(entry.result.name, group);
     }
     for (const [flowName, flowEntries] of resultsByName) {
-        const flowFilePath = flowPathMap.get(flowName);
-        const relativePath = flowFilePath
-            ? await relativizePathAsync(flowFilePath, projectRoot)
-            : flowName;
-        if (flowEntries.length === 1) {
-            // Single result for this flow — use ai-*.json occurrence count for retryCount
-            // (backward compat with old-style single JUnit file that gets overwritten)
-            const { result } = flowEntries[0];
-            const occurrences = flowOccurrences.get(flowName) ?? 0;
-            const retryCount = Math.max(0, occurrences - 1);
+        const flowPath = nameToPath?.get(flowName) ?? flowName;
+        // 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 = flowEntries
+            .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: flowName,
-                path: relativePath,
+                path: flowPath,
                 status: result.status,
                 errorMessage: result.errorMessage,
                 duration: result.duration,
-                retryCount,
+                retryCount: attemptIndex,
                 tags: result.tags,
                 properties: result.properties,
             });
         }
-        else {
-            // Multiple results — per-attempt JUnit files. Sort by attempt index from filename.
-            const sorted = flowEntries
-                .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: flowName,
-                    path: relativePath,
-                    status: result.status,
-                    errorMessage: result.errorMessage,
-                    duration: result.duration,
-                    retryCount: attemptIndex,
-                    tags: result.tags,
-                    properties: result.properties,
-                });
-            }
-        }
     }
     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).
+ *
+ * Caller passes a precomputed `nameToPath` map built from the user's
+ * `inputFlowPaths`. We translate failed testcase names to flow paths via
+ * that map; unknown names → null.
+ */
+async function parseFailedFlowsFromJUnit(args) {
+    // fast-xml-parser is lenient — truncated XML can produce a partial parse
+    // with some testcases dropped. Trusting that subset for retry-failed-only 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 { }
-    try {
-        resolvedFlow = await promises_1.default.realpath(flowFilePath);
+    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. Signal "unknown".
+    // Complementary to the map-build duplicate check (which catches the case
+    // where tag filter hides duplication from JUnit).
+    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;
+        }
     }
-    catch { }
-    const relative = path_1.default.relative(resolvedRoot, resolvedFlow);
-    if (relative.startsWith('..')) {
-        return flowFilePath;
+    const matched = [];
+    for (const tc of failing) {
+        const p = args.nameToPath.get(tc.name);
+        if (p === undefined) {
+            return null;
+        }
+        matched.push(p);
+    }
+    return matched;
+}
+/**
+ * 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);
+            }
+        }
     }
-    return relative;
+    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 +339,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);

package/dist/steps/functions/maestroTests.js

@@ -10,6 +10,7 @@ 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 maestroFlowDiscovery_1 = require("./maestroFlowDiscovery");
 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);
@@ -22,6 +23,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.
@@ -63,6 +74,12 @@ function createMaestroTestsBuildFunction() {
                 defaultValue: 0,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'retry_failed_only',
+                required: false,
+                defaultValue: true,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+            }),
             steps_1.BuildStepInput.createProvider({
                 id: 'shards',
                 required: false,
@@ -133,33 +150,53 @@ function createMaestroTestsBuildFunction() {
             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.');
+            const retryFailedOnly = inputs.retry_failed_only.value;
             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 });
             }
+            // 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,
+            });
             // 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
+            // trusted; we then fall through to dumb retry (re-run everything).
+            let flowsToRun = flowPaths;
             let lastAttemptExitCode = null;
+            const totalAttempts = retries + 1;
             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;
+                const maestroArgs = buildMaestroArgs({
+                    flow_path: flowsToRun,
+                    outputPath,
+                    output_format: outputFormat,
+                    shards,
+                    include_tags: includeTags,
+                    exclude_tags: excludeTags,
+                });
+                logger.info(`Running maestro (attempt ${attempt + 1}/${totalAttempts}): maestro ${maestroArgs.join(' ')}`);
                 try {
-                    await (0, turtle_spawn_1.default)('maestro', buildMaestroArgs({
-                        flow_path: flowPaths,
-                        outputPath,
-                        output_format: outputFormat,
-                        shards,
-                        include_tags: includeTags,
-                        exclude_tags: excludeTags,
-                    }), { cwd: stepCtx.workingDirectory, env: spawnEnv, logger, signal });
+                    await (0, turtle_spawn_1.default)('maestro', maestroArgs, {
+                        cwd: stepCtx.workingDirectory,
+                        env: spawnEnv,
+                        logger,
+                        signal,
+                    });
                     lastAttemptExitCode = 0;
                 }
                 catch (err) {
@@ -176,31 +213,60 @@ function createMaestroTestsBuildFunction() {
                 if (lastAttemptExitCode === 0 || attempt === retries) {
                     break;
                 }
-                logger.info('Test failed, retrying...');
+                if (retryFailedOnly && outputFormat === 'junit' && outputPath && nameToPath) {
+                    const failed = await (0, maestroResultParser_1.parseFailedFlowsFromJUnit)({
+                        junitFile: outputPath,
+                        nameToPath,
+                    });
+                    if (failed !== null && failed.length > 0) {
+                        flowsToRun = failed;
+                        logger.info(`Test failed; retrying ${failed.length} failed flow(s): ${failed.join(', ')}`);
+                    }
+                    else {
+                        flowsToRun = flowPaths;
+                        logger.info('Test failed; could not determine failed subset, retrying all flows');
+                    }
+                }
+                else {
+                    flowsToRun = flowPaths;
+                    logger.info('Test failed, retrying all flows');
+                }
                 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),
             // 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/dist/steps/functions/reportMaestroTestResults.js

@@ -3,7 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createReportMaestroTestResultsFunction = createReportMaestroTestResultsFunction;
 const steps_1 = require("@expo/steps");
 const gql_tada_1 = require("gql.tada");
+const zod_1 = require("zod");
+const maestroFlowDiscovery_1 = require("./maestroFlowDiscovery");
 const maestroResultParser_1 = require("./maestroResultParser");
+const FlowPathSchema = zod_1.z.array(zod_1.z.string().min(1)).min(1);
 const CREATE_MUTATION = (0, gql_tada_1.graphql)(`
   mutation CreateWorkflowDeviceTestCaseResults($input: CreateWorkflowDeviceTestCaseResultsInput!) {
     workflowDeviceTestCaseResult {
@@ -36,6 +39,11 @@ function createReportMaestroTestResultsFunction(ctx) {
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
                 defaultValue: '${{ env.HOME }}/.maestro/tests',
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'flow_path',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.JSON,
+            }),
         ],
         fn: async (stepsCtx, { inputs }) => {
             const { logger } = stepsCtx;
@@ -49,9 +57,23 @@ function createReportMaestroTestResultsFunction(ctx) {
                 logger.info('No JUnit directory provided, skipping test results report');
                 return;
             }
-            const testsDirectory = inputs.tests_directory.value;
+            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).');
+                }
+            }
             try {
-                const flowResults = await (0, maestroResultParser_1.parseMaestroResults)(junitDirectory, testsDirectory, stepsCtx.workingDirectory);
+                const flowResults = await (0, maestroResultParser_1.parseMaestroResults)(junitDirectory, nameToPath);
                 if (flowResults.length === 0) {
                     logger.info('No maestro test results found, skipping report');
                     return;

package/dist/steps/functions/restoreBuildCache.js

@@ -214,7 +214,25 @@ async function restoreGradleCacheAsync({ logger, workingDirectory, env, secrets,
             verbose: env.EXPO_DEBUG === '1',
             logger,
         });
-        logger.info(`Gradle cache restored to ${gradleCachesPath} ${matchedKey === cacheKey ? '(direct hit)' : '(prefix match)'}`);
+        const hitType = matchedKey === cacheKey ? 'direct_hit' : 'prefix_match';
+        logger.info(`Gradle cache restored to ${gradleCachesPath} (${hitType === 'direct_hit' ? 'direct hit' : 'prefix match'})`);
+        try {
+            await (0, turtleFetch_1.turtleFetch)(new URL('v2/turtle-builds/logs', expoApiServerURL).toString(), 'POST', {
+                json: {
+                    buildId: jobId,
+                    message: `Gradle cache restored (${hitType})`,
+                    tags: {
+                        event: 'gradle_cache_restored',
+                        cache_hit_type: hitType,
+                    },
+                },
+                headers: {
+                    Authorization: `Bearer ${robotAccessToken}`,
+                },
+                shouldThrowOnNotOk: false,
+            });
+        }
+        catch { }
     }
     catch (err) {
         if (err instanceof turtleFetch_1.TurtleFetchError && err.response?.status === 404) {

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

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

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -6,11 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStartAgentDeviceRemoteSessionBuildFunction = createStartAgentDeviceRemoteSessionBuildFunction;
 const steps_1 = require("@expo/steps");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const gql_tada_1 = require("gql.tada");
 const node_child_process_1 = __importDefault(require("node:child_process"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const retry_1 = require("../../utils/retry");
+const eas_build_job_1 = require("@expo/eas-build-job");
 const AGENT_DEVICE_REPO_URL = 'https://github.com/callstackincubator/agent-device.git';
 const SRC_DIR = '/tmp/agent-device-src';
 const RUN_DIR = '/tmp/agent-device';
@@ -18,8 +20,22 @@ const DAEMON_LOG = node_path_1.default.join(RUN_DIR, 'daemon.log');
 const TUNNEL_LOG = node_path_1.default.join(RUN_DIR, 'cloudflared.log');
 const DAEMON_JSON_PATH = node_path_1.default.join(node_os_1.default.homedir(), '.agent-device', 'daemon.json');
 const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
+const CLOUDFLARED_LINUX_INSTALL_PATH = '/usr/local/bin/cloudflared';
 const STARTUP_TIMEOUT_MS = 60_000;
-function createStartAgentDeviceRemoteSessionBuildFunction() {
+const START_DEVICE_RUN_SESSION_MUTATION = (0, gql_tada_1.graphql)(`
+  mutation StartDeviceRunSession($deviceRunSessionId: ID!, $remoteConfig: JSONObject!) {
+    deviceRunSession {
+      startDeviceRunSession(
+        deviceRunSessionId: $deviceRunSessionId
+        remoteConfig: $remoteConfig
+      ) {
+        id
+        status
+      }
+    }
+  }
+`);
+function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
     return new steps_1.BuildFunction({
         namespace: 'eas',
         id: 'start_agent_device_remote_session',
@@ -32,17 +48,31 @@ function createStartAgentDeviceRemoteSessionBuildFunction() {
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
         ],
-        fn: async ({ logger }, { inputs, env }) => {
+        fn: async ({ logger, global }, { inputs, env }) => {
+            // Fail fast before any expensive setup if the orchestrator-injected
+            // DEVICE_RUN_SESSION_ID env var is missing — without it we cannot
+            // report the remote config back to the API server.
+            const deviceRunSessionId = env.DEVICE_RUN_SESSION_ID;
+            if (!deviceRunSessionId) {
+                throw new eas_build_job_1.SystemError('DEVICE_RUN_SESSION_ID is not set. ' +
+                    'This step must run as part of a device run session created by the API server, ' +
+                    'which injects DEVICE_RUN_SESSION_ID into the job environment.');
+            }
             const packageVersion = inputs.package_version.value;
-            logger.info(`Starting agent-device remote session (version: ${packageVersion ?? 'latest'}).`);
+            const { runtimePlatform } = global;
+            logger.info(`Starting agent-device remote session (version: ${packageVersion ?? 'latest'}, runtime: ${runtimePlatform}).`);
             logger.info(`Preparing runtime directory at ${RUN_DIR}.`);
             await node_fs_1.default.promises.mkdir(RUN_DIR, { recursive: true });
-            logger.info(`Selecting Xcode developer directory: ${XCODE_DEVELOPER_DIR}.`);
-            await (0, turtle_spawn_1.default)('sudo', ['xcode-select', '-s', XCODE_DEVELOPER_DIR], { env, logger });
+            if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
+                logger.info(`Selecting Xcode developer directory: ${XCODE_DEVELOPER_DIR}.`);
+                await (0, turtle_spawn_1.default)('sudo', ['xcode-select', '-s', XCODE_DEVELOPER_DIR], { env, logger });
+            }
             logger.info('Ensuring cloudflared is installed.');
-            await ensureCloudflaredInstalledAsync({ env, logger });
-            logger.info('Ensuring bun is installed.');
-            await ensureBunInstalledAsync({ env, logger });
+            const cloudflaredCommand = await ensureCloudflaredInstalledAsync({
+                runtimePlatform,
+                env,
+                logger,
+            });
             logger.info(packageVersion
                 ? `Cloning agent-device @ v${packageVersion} into ${SRC_DIR}.`
                 : `Cloning agent-device (latest) into ${SRC_DIR}.`);
@@ -71,7 +101,7 @@ function createStartAgentDeviceRemoteSessionBuildFunction() {
             logger.info(`Daemon is listening on port ${daemonPort}; loaded auth token.`);
             logger.info(`Starting cloudflared tunnel to http://localhost:${daemonPort} (log file: ${TUNNEL_LOG}).`);
             await spawnDetachedAsync({
-                command: `cloudflared tunnel --url "http://localhost:${daemonPort}"`,
+                command: `${cloudflaredCommand} tunnel --url "http://localhost:${daemonPort}"`,
                 logFile: TUNNEL_LOG,
                 env,
                 logger,
@@ -84,9 +114,16 @@ function createStartAgentDeviceRemoteSessionBuildFunction() {
                 description: 'cloudflared tunnel',
             });
             logger.info(`Tunnel is ready at ${tunnelUrl}.`);
-            logger.info('Emitting agent-device credentials for the CLI to pick up:');
-            logger.info(`export AGENT_DEVICE_DAEMON_BASE_URL="${tunnelUrl}"`);
-            logger.info(`export AGENT_DEVICE_DAEMON_AUTH_TOKEN="${daemonToken}"`);
+            logger.info(`Reporting agent-device remote config to the API server (device run session: ${deviceRunSessionId}).`);
+            const result = await ctx.graphqlClient
+                .mutation(START_DEVICE_RUN_SESSION_MUTATION, {
+                deviceRunSessionId,
+                remoteConfig: { url: tunnelUrl, token: daemonToken },
+            })
+                .toPromise();
+            if (result.error) {
+                throw new eas_build_job_1.SystemError(`Failed to start device run session ${deviceRunSessionId}: ${result.error.message}`);
+            }
             logger.info('Remote session is live. Keeping the job alive until the session is stopped.');
             // Keep the turtle job alive so the daemon and tunnel stay reachable
             // until stopDeviceRunSession cancels the run.
@@ -94,15 +131,47 @@ function createStartAgentDeviceRemoteSessionBuildFunction() {
         },
     });
 }
-async function ensureCloudflaredInstalledAsync({ env, logger, }) {
-    await ensureBrewPackageInstalledAsync({ name: 'cloudflared', env, logger });
+async function ensureCloudflaredInstalledAsync({ runtimePlatform, env, logger, }) {
+    if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
+        await ensureBrewPackageInstalledAsync({ name: 'cloudflared', env, logger });
+        return 'cloudflared';
+    }
+    if (await isCommandAvailableAsync({ command: 'cloudflared', env })) {
+        return 'cloudflared';
+    }
+    const cloudflaredArch = cloudflaredLinuxArchForNodeArch(node_os_1.default.arch());
+    const downloadUrl = `https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-${cloudflaredArch}`;
+    logger.info(`Downloading cloudflared from ${downloadUrl} to ${CLOUDFLARED_LINUX_INSTALL_PATH}.`);
+    await (0, turtle_spawn_1.default)('sudo', ['curl', '-fsSL', '-o', CLOUDFLARED_LINUX_INSTALL_PATH, downloadUrl], {
+        env,
+        logger,
+    });
+    await (0, turtle_spawn_1.default)('sudo', ['chmod', '+x', CLOUDFLARED_LINUX_INSTALL_PATH], { env, logger });
+    // Return the absolute install path so the tunnel command works even when
+    // /usr/local/bin is not on the step's PATH.
+    return CLOUDFLARED_LINUX_INSTALL_PATH;
 }
-async function ensureBunInstalledAsync({ env, logger, }) {
-    await ensureBrewPackageInstalledAsync({ name: 'bun', env, logger });
+function cloudflaredLinuxArchForNodeArch(arch) {
+    if (arch === 'x64') {
+        return 'amd64';
+    }
+    if (arch === 'arm64') {
+        return 'arm64';
+    }
+    throw new Error(`Unsupported architecture for cloudflared on Linux: "${arch}". Expected "x64" or "arm64".`);
 }
 async function ensureBrewPackageInstalledAsync({ name, env, logger, }) {
     await (0, turtle_spawn_1.default)('bash', ['-c', `command -v ${name} >/dev/null 2>&1 || HOMEBREW_NO_AUTO_UPDATE=1 brew install ${name}`], { env, logger });
 }
+async function isCommandAvailableAsync({ command, env, }) {
+    try {
+        await (0, turtle_spawn_1.default)('bash', ['-c', `command -v ${command}`], { env, ignoreStdio: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 async function cloneAgentDeviceAsync({ packageVersion, env, logger, }) {
     const branchArgs = packageVersion ? ['--branch', `v${packageVersion}`] : [];
     await (0, turtle_spawn_1.default)('git', ['clone', '--depth', '1', ...branchArgs, AGENT_DEVICE_REPO_URL, SRC_DIR], {

package/dist/steps/utils/ios/xcactivitylog.js

@@ -15,7 +15,7 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const zod_1 = require("zod");
-const DEFAULT_XCLOGPARSER_VERSION = 'v0.2.46';
+const DEFAULT_XCLOGPARSER_VERSION = 'v0.2.47';
 const XCLOGPARSER_DOWNLOAD_URL = 'https://storage.googleapis.com/turtle-v2/xclogparser';
 const XCLOGPARSER_DOWNLOAD_TIMEOUT_MS = 20_000;
 const XCLOGPARSER_OUTPUT_FILENAME = 'xcactivitylog.json';
@@ -228,18 +228,19 @@ function formatReport(data) {
     lines.push('');
     lines.push('Xcode Build — Compile Metrics by Module');
     lines.push(`Schema: ${typeof data.schema === 'string' ? data.schema : (data.schema?.name ?? 'unknown')}`);
-    lines.push('% Task = share of total Compile Task Seconds');
-    lines.push('Wall = first compile start to last compile end');
+    lines.push('Sum = sum of compile-step wall durations within the target; overlapping steps are counted separately');
+    lines.push('% Sum = share of total Sum');
+    lines.push('Active = merged compile-step wall time, excluding idle gaps between compile steps');
     lines.push('');
     lines.push(header);
     lines.push('│ ' +
         'Module'.padEnd(nameWidth) +
         ' │ ' +
-        'Task'.padStart(taskWidth) +
+        'Sum'.padStart(taskWidth) +
         ' │ ' +
-        '% Task'.padStart(pctWidth) +
+        '% Sum'.padStart(pctWidth) +
         ' │ ' +
-        'Wall'.padStart(wallWidth) +
+        'Active'.padStart(wallWidth) +
         ' │ ' +
         ' '.repeat(barMaxWidth) +
         ' │');
@@ -255,7 +256,7 @@ function formatReport(data) {
             ' │ ' +
             `${pct.toFixed(1)}%`.padStart(pctWidth) +
             ' │ ' +
-            formatSeconds(result.wallSpan).padStart(wallWidth) +
+            formatSeconds(result.activeWallTime).padStart(wallWidth) +
             ' │ ' +
             bar +
             ' │');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "18.10.0",
+  "version": "18.12.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -38,14 +38,14 @@
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
     "@expo/downloader": "18.5.0",
-    "@expo/eas-build-job": "18.8.0",
+    "@expo/eas-build-job": "18.12.0",
     "@expo/env": "^0.4.0",
     "@expo/logger": "18.5.0",
     "@expo/package-manager": "1.9.10",
     "@expo/plist": "^0.2.0",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "18.9.0",
+    "@expo/steps": "18.12.0",
     "@expo/template-file": "18.5.0",
     "@expo/turtle-spawn": "18.5.0",
     "@expo/xcpretty": "^4.3.1",
@@ -98,5 +98,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "cacd48bf669342be783037607b02e5f9b1b148c0"
+  "gitHead": "53d294330de9c63eb792f646c0603224def9a1b0"
 }