@expo/build-tools 18.11.0 → 18.12.1

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);
@@ -73,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,
@@ -143,37 +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".
-            // Smart retry (junit mode): after a failed attempt, subset to the failing
+            // 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: flowsToRun,
-                        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) {
@@ -190,18 +213,24 @@ function createMaestroTestsBuildFunction() {
                 if (lastAttemptExitCode === 0 || attempt === retries) {
                     break;
                 }
-                if (outputFormat === 'junit' && outputPath) {
+                if (retryFailedOnly && outputFormat === 'junit' && outputPath && nameToPath) {
                     const failed = await (0, maestroResultParser_1.parseFailedFlowsFromJUnit)({
                         junitFile: outputPath,
-                        testsDirectory,
-                        inputFlowPaths: flowsToRun,
-                        projectRoot: stepCtx.workingDirectory,
+                        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');
                 }
-                logger.info('Test failed, retrying...');
                 await (0, retry_1.sleepAsync)(2000);
             }
             // Smart merge first; on data errors (bad XML, missing input) fall back
@@ -238,7 +267,6 @@ function createMaestroTestsBuildFunction() {
             // 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

@@ -4,22 +4,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStartAgentDeviceRemoteSessionBuildFunction = createStartAgentDeviceRemoteSessionBuildFunction;
+const eas_build_job_1 = require("@expo/eas-build-job");
 const steps_1 = require("@expo/steps");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
-const 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 remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
 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';
-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() {
+function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
     return new steps_1.BuildFunction({
         namespace: 'eas',
         id: 'start_agent_device_remote_session',
@@ -32,17 +31,24 @@ 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 = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
             const packageVersion = inputs.package_version.value;
-            logger.info(`Starting agent-device remote session (version: ${packageVersion ?? 'latest'}).`);
-            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 });
+            const { runtimePlatform } = global;
+            logger.info(`Starting agent-device remote session (version: ${packageVersion ?? 'latest'}, runtime: ${runtimePlatform}).`);
+            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}.`);
@@ -53,13 +59,12 @@ function createStartAgentDeviceRemoteSessionBuildFunction() {
                 env,
                 logger,
             });
-            logger.info(`Launching agent-device daemon (log file: ${DAEMON_LOG}).`);
-            await spawnDetachedAsync({
-                command: 'bun run src/daemon.ts',
+            logger.info('Launching agent-device daemon.');
+            (0, remoteDeviceRunSession_1.spawnDetached)({
+                command: 'bun',
+                args: ['run', 'src/daemon.ts'],
                 cwd: SRC_DIR,
-                logFile: DAEMON_LOG,
                 env: { ...env, AGENT_DEVICE_DAEMON_SERVER_MODE: 'http' },
-                logger,
             });
             logger.info(`Waiting for daemon credentials at ${DAEMON_JSON_PATH}.`);
             await waitForFileAsync({
@@ -69,24 +74,26 @@ function createStartAgentDeviceRemoteSessionBuildFunction() {
             });
             const { port: daemonPort, token: daemonToken } = readDaemonInfo(DAEMON_JSON_PATH);
             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}"`,
-                logFile: TUNNEL_LOG,
+            logger.info(`Starting cloudflared tunnel to http://localhost:${daemonPort}.`);
+            const cloudflared = (0, remoteDeviceRunSession_1.spawnDetached)({
+                command: cloudflaredCommand,
+                args: ['tunnel', '--url', `http://localhost:${daemonPort}`],
                 env,
-                logger,
             });
             logger.info('Waiting for a public tunnel URL.');
-            const tunnelUrl = await waitForMatchInLogAsync({
-                logFile: TUNNEL_LOG,
+            const tunnelUrl = await waitForMatchInOutputAsync({
+                process: cloudflared,
                 pattern: /https:\/\/[a-z0-9-]+\.trycloudflare\.com/,
                 timeoutMs: STARTUP_TIMEOUT_MS,
                 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}"`);
+            await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
+                ctx,
+                deviceRunSessionId,
+                remoteConfig: { url: tunnelUrl, token: daemonToken },
+                logger,
+            });
             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,14 +101,43 @@ 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 (0, remoteDeviceRunSession_1.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 eas_build_job_1.SystemError(`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}`] : [];
@@ -110,40 +146,16 @@ async function cloneAgentDeviceAsync({ packageVersion, env, logger, }) {
         logger,
     });
 }
-async function spawnDetachedAsync({ command, cwd, logFile, env, logger, }) {
-    // Launch the process fully detached so this function returns immediately and
-    // the grandchild survives the step. Stdio goes to a log file so the daemon
-    // output can be polled, and we unref so Node doesn't wait on it.
-    const fd = node_fs_1.default.openSync(logFile, 'a');
-    try {
-        const child = node_child_process_1.default.spawn('bash', ['-c', command], {
-            cwd,
-            env,
-            detached: true,
-            stdio: ['ignore', fd, fd],
-        });
-        if (!child.pid) {
-            throw new Error(`Failed to spawn detached process: ${command}`);
-        }
-        child.unref();
-        logger.info(`Started detached process (pid ${child.pid}).`);
-    }
-    finally {
-        node_fs_1.default.closeSync(fd);
-    }
-}
-async function waitForMatchInLogAsync({ logFile, pattern, timeoutMs, description, }) {
+async function waitForMatchInOutputAsync({ process, pattern, timeoutMs, description, }) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        const content = await readFileOrEmptyAsync(logFile);
-        const match = pattern.exec(content);
+        const match = pattern.exec(process.getOutput());
         if (match) {
             return match[1] ?? match[0];
         }
         await (0, retry_1.sleepAsync)(1_000);
     }
-    const tail = await readFileOrEmptyAsync(logFile);
-    throw new Error(`Timed out waiting for ${description} to start. Last log contents:\n${tail || '<empty>'}`);
+    throw new eas_build_job_1.SystemError(`Timed out waiting for ${description} to start. Last output:\n${process.getOutput() || '<empty>'}`);
 }
 async function waitForFileAsync({ filePath, timeoutMs, description, }) {
     const deadline = Date.now() + timeoutMs;
@@ -157,15 +169,7 @@ async function waitForFileAsync({ filePath, timeoutMs, description, }) {
         }
         await (0, retry_1.sleepAsync)(1_000);
     }
-    throw new Error(`Timed out waiting for ${description} to write ${filePath}.`);
-}
-async function readFileOrEmptyAsync(filePath) {
-    try {
-        return await node_fs_1.default.promises.readFile(filePath, 'utf8');
-    }
-    catch {
-        return '';
-    }
+    throw new eas_build_job_1.SystemError(`Timed out waiting for ${description} to write ${filePath}.`);
 }
 function readDaemonInfo(filePath) {
     const raw = node_fs_1.default.readFileSync(filePath, 'utf8');
@@ -174,7 +178,7 @@ function readDaemonInfo(filePath) {
         typeof parsed !== 'object' ||
         typeof parsed.httpPort !== 'number' ||
         typeof parsed.token !== 'string') {
-        throw new Error(`Expected ${filePath} to contain { "httpPort": <number>, "token": "..." }.`);
+        throw new eas_build_job_1.SystemError(`Expected ${filePath} to contain { "httpPort": <number>, "token": "..." }.`);
     }
     const { httpPort, token } = parsed;
     return { port: httpPort, token };

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

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

package/dist/steps/functions/startServeSimRemoteSession.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStartServeSimRemoteSessionBuildFunction = createStartServeSimRemoteSessionBuildFunction;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const retry_1 = require("../../utils/retry");
+const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
+const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
+const STARTUP_TIMEOUT_MS = 60_000;
+const TRYCLOUDFLARE_URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
+function createStartServeSimRemoteSessionBuildFunction(ctx) {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'start_serve_sim_remote_session',
+        name: 'Start serve-sim remote session',
+        __metricsId: 'eas/start_serve_sim_remote_session',
+        supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
+        fn: async ({ logger }, { env }) => {
+            const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
+            logger.info('Starting serve-sim remote session.');
+            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 (0, remoteDeviceRunSession_1.ensureBrewPackageInstalledAsync)({ name: 'cloudflared', env, logger });
+            logger.info('Launching serve-sim with tunnel.');
+            const serveSim = (0, remoteDeviceRunSession_1.spawnDetached)({
+                command: 'npx',
+                args: ['serve-sim-szdziedzic@latest', '--tunnel'],
+                env,
+            });
+            logger.info('Waiting for serve-sim to report tunnel and stream URLs.');
+            const { previewUrl, streamUrl } = await waitForServeSimUrlsAsync({
+                serveSim,
+                timeoutMs: STARTUP_TIMEOUT_MS,
+            });
+            logger.info(`Preview URL: ${previewUrl}`);
+            logger.info(`Stream URL: ${streamUrl}`);
+            await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
+                ctx,
+                deviceRunSessionId,
+                remoteConfig: { previewUrl, streamUrl },
+                logger,
+            });
+            logger.info('Remote session is live. Keeping the job alive until the session is stopped.');
+            // Keep the turtle job alive so the serve-sim tunnel stays reachable
+            // until stopDeviceRunSession cancels the run.
+            await new Promise(() => { });
+        },
+    });
+}
+async function waitForServeSimUrlsAsync({ serveSim, timeoutMs, }) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const output = serveSim.getOutput();
+        const previewUrl = matchLabeledUrl(output, 'Tunnel');
+        const streamUrl = matchLabeledUrl(output, 'Stream');
+        if (previewUrl && streamUrl) {
+            return { previewUrl, streamUrl };
+        }
+        await (0, retry_1.sleepAsync)(1_000);
+    }
+    throw new eas_build_job_1.SystemError(`Timed out waiting for serve-sim to report Tunnel and Stream URLs. Last output:\n${serveSim.getOutput() || '<empty>'}`);
+}
+function matchLabeledUrl(content, label) {
+    const labelPattern = new RegExp(`${label}:\\s*(${TRYCLOUDFLARE_URL_PATTERN.source})`);
+    const match = labelPattern.exec(content);
+    return match ? match[1] : null;
+}

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/dist/steps/utils/remoteDeviceRunSession.d.ts

@@ -0,0 +1,24 @@
+import { bunyan } from '@expo/logger';
+import { BuildStepEnv } from '@expo/steps';
+import { CustomBuildContext } from '../../customBuildContext';
+export declare function getDeviceRunSessionIdOrThrow(env: BuildStepEnv): string;
+export declare function uploadRemoteSessionConfigAsync({ ctx, deviceRunSessionId, remoteConfig, logger, }: {
+    ctx: CustomBuildContext;
+    deviceRunSessionId: string;
+    remoteConfig: Record<string, unknown>;
+    logger: bunyan;
+}): Promise<void>;
+export declare function ensureBrewPackageInstalledAsync({ name, env, logger, }: {
+    name: string;
+    env: BuildStepEnv;
+    logger: bunyan;
+}): Promise<void>;
+export type DetachedProcessHandle = {
+    getOutput: () => string;
+};
+export declare function spawnDetached({ command, args, cwd, env, }: {
+    command: string;
+    args: string[];
+    cwd?: string;
+    env: BuildStepEnv;
+}): DetachedProcessHandle;

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeviceRunSessionIdOrThrow = getDeviceRunSessionIdOrThrow;
+exports.uploadRemoteSessionConfigAsync = uploadRemoteSessionConfigAsync;
+exports.ensureBrewPackageInstalledAsync = ensureBrewPackageInstalledAsync;
+exports.spawnDetached = spawnDetached;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const gql_tada_1 = require("gql.tada");
+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 getDeviceRunSessionIdOrThrow(env) {
+    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.');
+    }
+    return deviceRunSessionId;
+}
+async function uploadRemoteSessionConfigAsync({ ctx, deviceRunSessionId, remoteConfig, logger, }) {
+    logger.info(`Reporting remote config to the API server (device run session: ${deviceRunSessionId}).`);
+    const result = await ctx.graphqlClient
+        .mutation(START_DEVICE_RUN_SESSION_MUTATION, { deviceRunSessionId, remoteConfig })
+        .toPromise();
+    if (result.error) {
+        throw new eas_build_job_1.SystemError(`Failed to start device run session ${deviceRunSessionId}: ${result.error.message}`);
+    }
+}
+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 });
+}
+function spawnDetached({ command, args, cwd, env, }) {
+    const promise = (0, turtle_spawn_1.default)(command, args, {
+        cwd,
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        detached: true,
+    });
+    // We don't await the process — it should outlive this step. Failures show
+    // up in the captured output; suppress unhandled rejections here.
+    promise.catch(() => { });
+    promise.child.unref();
+    let output = '';
+    const appendChunk = (chunk) => {
+        output += chunk.toString();
+    };
+    promise.child.stdout?.on('data', appendChunk);
+    promise.child.stderr?.on('data', appendChunk);
+    return { getOutput: () => output };
+}