@expo/build-tools 18.12.0 → 18.12.3

package/dist/index.d.ts

@@ -7,3 +7,4 @@ export { PackageManager } from './utils/packageManager';
 export { findAndUploadXcodeBuildLogsAsync } from './ios/xcodeBuildLogs';
 export { Hook, runHookIfPresent } from './utils/hooks';
 export * from './generic';
+export { Sentry } from './sentry';

package/dist/index.js

@@ -39,7 +39,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runHookIfPresent = exports.Hook = exports.findAndUploadXcodeBuildLogsAsync = exports.PackageManager = exports.SkipNativeBuildError = exports.BuildContext = exports.GCSLoggerStream = exports.GCS = exports.Builders = void 0;
+exports.Sentry = exports.runHookIfPresent = exports.Hook = exports.findAndUploadXcodeBuildLogsAsync = exports.PackageManager = exports.SkipNativeBuildError = exports.BuildContext = exports.GCSLoggerStream = exports.GCS = exports.Builders = void 0;
 const Builders = __importStar(require("./builders"));
 exports.Builders = Builders;
 const LoggerStream_1 = __importDefault(require("./gcs/LoggerStream"));
@@ -57,3 +57,5 @@ var hooks_1 = require("./utils/hooks");
 Object.defineProperty(exports, "Hook", { enumerable: true, get: function () { return hooks_1.Hook; } });
 Object.defineProperty(exports, "runHookIfPresent", { enumerable: true, get: function () { return hooks_1.runHookIfPresent; } });
 __exportStar(require("./generic"), exports);
+var sentry_1 = require("./sentry");
+Object.defineProperty(exports, "Sentry", { enumerable: true, get: function () { return sentry_1.Sentry; } });

package/dist/sentry.d.ts

@@ -0,0 +1,19 @@
+import * as sentryNode from '@sentry/node';
+type CaptureOptions = {
+    tags?: Record<string, string>;
+    extras?: Record<string, unknown>;
+    level?: sentryNode.SeverityLevel;
+};
+type SentryAPI = {
+    setup(opts: {
+        dsn: string | null;
+        environment: string;
+        tags?: Record<string, string>;
+    }): void;
+    capture(msg: string, options?: CaptureOptions): void;
+    capture(msg: string, err: Error | undefined, options?: CaptureOptions): void;
+    capture(err: Error, options?: CaptureOptions): void;
+    flush(timeoutMs?: number): Promise<boolean>;
+};
+export declare const Sentry: SentryAPI;
+export {};

package/dist/sentry.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sentry = void 0;
+const sentryNode = __importStar(require("@sentry/node"));
+exports.Sentry = {
+    setup({ dsn, environment, tags }) {
+        if (dsn) {
+            sentryNode.init({
+                dsn,
+                environment,
+                ...(tags ? { initialScope: { tags } } : {}),
+            });
+        }
+    },
+    capture(arg1, arg2, arg3) {
+        let msg;
+        let err;
+        let options = {};
+        if (arg1 instanceof Error) {
+            err = arg1;
+            options = arg2 ?? {};
+        }
+        else {
+            msg = arg1;
+            if (arg3 !== undefined) {
+                // 3-arg form: arg2 unambiguously means err (null/undefined → no err)
+                options = arg3;
+                if (arg2 !== undefined && arg2 !== null) {
+                    err = arg2 instanceof Error ? arg2 : new Error(String(arg2));
+                }
+            }
+            else if (arg2 instanceof Error) {
+                err = arg2;
+            }
+            else if (arg2 !== undefined && arg2 !== null) {
+                // 2-arg form: non-Error object → options; primitive → coerced err
+                if (typeof arg2 === 'object') {
+                    options = arg2;
+                }
+                else {
+                    err = new Error(String(arg2));
+                }
+            }
+        }
+        sentryNode.withScope(scope => {
+            if (options.tags) {
+                scope.setTags(options.tags);
+            }
+            if (options.extras) {
+                scope.setExtras(options.extras);
+            }
+            if (options.level) {
+                scope.setLevel(options.level);
+            }
+            if (err) {
+                if (msg && err.message !== msg) {
+                    scope.setExtra('message', msg);
+                }
+                sentryNode.captureException(err);
+            }
+            else if (msg) {
+                sentryNode.captureMessage(msg);
+            }
+        });
+    },
+    flush(timeoutMs = 2000) {
+        return sentryNode.flush(timeoutMs);
+    },
+};

package/dist/steps/easFunctions.js

@@ -41,6 +41,7 @@ const startAgentDeviceRemoteSession_1 = require("./functions/startAgentDeviceRem
 const startAndroidEmulator_1 = require("./functions/startAndroidEmulator");
 const startCuttlefishDevice_1 = require("./functions/startCuttlefishDevice");
 const startIosSimulator_1 = require("./functions/startIosSimulator");
+const startServeSimRemoteSession_1 = require("./functions/startServeSimRemoteSession");
 const uploadArtifact_1 = require("./functions/uploadArtifact");
 const uploadToAsc_1 = require("./functions/uploadToAsc");
 const useNpmToken_1 = require("./functions/useNpmToken");
@@ -79,6 +80,7 @@ function getEasFunctions(ctx) {
         (0, startAndroidEmulator_1.createStartAndroidEmulatorBuildFunction)(),
         (0, startCuttlefishDevice_1.createStartCuttlefishDeviceBuildFunction)(),
         (0, startIosSimulator_1.createStartIosSimulatorBuildFunction)(),
+        (0, startServeSimRemoteSession_1.createStartServeSimRemoteSessionBuildFunction)(ctx),
         (0, installMaestro_1.createInstallMaestroBuildFunction)(),
         (0, installPods_1.createInstallPodsBuildFunction)(),
         (0, sendSlackMessage_1.createSendSlackMessageFunction)(),

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -4,37 +4,20 @@ 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 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 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;
-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',
@@ -52,17 +35,10 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
             // 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 deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
             const packageVersion = inputs.package_version.value;
             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 });
             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 });
@@ -83,13 +59,12 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 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({
@@ -99,31 +74,42 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
             });
             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: `${cloudflaredCommand} 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 agentDeviceRemoteSessionUrl = 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(`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(`Tunnel is ready at ${agentDeviceRemoteSessionUrl}.`);
+            // serve-sim is iOS-only — only launch it (and report a webPreviewUrl)
+            // on Darwin. Android sessions go without a preview URL.
+            let webPreviewUrl;
+            if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
+                const { previewUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)({
+                    env,
+                    logger,
+                    timeoutMs: STARTUP_TIMEOUT_MS,
+                });
+                webPreviewUrl = previewUrl;
+                logger.info(`Web preview URL: ${webPreviewUrl}`);
             }
+            await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
+                ctx,
+                deviceRunSessionId,
+                remoteConfig: {
+                    agentDeviceRemoteSessionUrl,
+                    agentDeviceRemoteSessionToken: daemonToken,
+                    ...(webPreviewUrl ? { webPreviewUrl } : {}),
+                },
+                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.
@@ -133,7 +119,7 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
 }
 async function ensureCloudflaredInstalledAsync({ runtimePlatform, env, logger, }) {
     if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
-        await ensureBrewPackageInstalledAsync({ name: 'cloudflared', env, logger });
+        await (0, remoteDeviceRunSession_1.ensureBrewPackageInstalledAsync)({ name: 'cloudflared', env, logger });
         return 'cloudflared';
     }
     if (await isCommandAvailableAsync({ command: 'cloudflared', env })) {
@@ -158,10 +144,7 @@ function cloudflaredLinuxArchForNodeArch(arch) {
     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 });
+    throw new eas_build_job_1.SystemError(`Unsupported architecture for cloudflared on Linux: "${arch}". Expected "x64" or "arm64".`);
 }
 async function isCommandAvailableAsync({ command, env, }) {
     try {
@@ -179,40 +162,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;
@@ -226,15 +185,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');
@@ -243,7 +194,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,45 @@
+"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 steps_1 = require("@expo/steps");
+const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
+const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
+const STARTUP_TIMEOUT_MS = 60_000;
+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 });
+            const { previewUrl, streamUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)({
+                env,
+                logger,
+                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(() => { });
+        },
+    });
+}

package/dist/steps/utils/ios/xcactivitylog.d.ts

@@ -1,11 +1,9 @@
 import { bunyan } from '@expo/logger';
 import { z } from 'zod';
 /**
- * Download xclogparser, parse xcactivitylog from derived data, and log a
- * compile metrics report. Never throws — all errors are logged at debug level.
- *
- * Can be called from both the step-based flow (BuildFunction) and the
- * traditional builder flow (runBuildPhase).
+ * Never throws — best-effort observability that does not affect build status.
+ * Failures route to Sentry via `Sentry.capture` for engineering triage;
+ * users see only a generic skip message.
  */
 export declare function parseAndReportXcactivitylog({ derivedDataPath, workspacePath, xclogparserVersion, logger, proxyBaseUrl, }: {
     derivedDataPath: string;

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

@@ -15,33 +15,38 @@ 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 sentry_1 = require("../../../sentry");
 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';
 /**
- * Download xclogparser, parse xcactivitylog from derived data, and log a
- * compile metrics report. Never throws — all errors are logged at debug level.
- *
- * Can be called from both the step-based flow (BuildFunction) and the
- * traditional builder flow (runBuildPhase).
+ * Never throws — best-effort observability that does not affect build status.
+ * Failures route to Sentry via `Sentry.capture` for engineering triage;
+ * users see only a generic skip message.
  */
 async function parseAndReportXcactivitylog({ derivedDataPath, workspacePath, xclogparserVersion = DEFAULT_XCLOGPARSER_VERSION, logger, proxyBaseUrl, }) {
     let tempDir;
+    let phase = 'creating_temp_directory';
     try {
         tempDir = await fs_extra_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'xclogparser-'));
+        phase = 'downloading_xclogparser';
         const xclogparserPath = await downloadXclogparser(tempDir, xclogparserVersion, logger, proxyBaseUrl);
+        phase = 'running_xclogparser';
         const jsonOutputPath = await runXclogparser({
             binaryPath: xclogparserPath,
             derivedDataPath,
             workspacePath,
             outputDir: tempDir,
         });
+        phase = 'parsing_xclogparser_output';
         const data = XcactivitylogDataSchemaZ.parse(JSON.parse(await fs_extra_1.default.readFile(jsonOutputPath, 'utf8')));
         logger.info(formatReport(data));
     }
     catch (err) {
-        logger.debug({ err }, 'Failed to analyze build performance; continuing without a report');
+        logger.info('Build performance analysis skipped.');
+        const msg = `Build performance analysis failed during "${phase}"`;
+        sentry_1.Sentry.capture(msg, err, { tags: { phase } });
     }
     finally {
         if (tempDir) {

package/dist/steps/utils/remoteDeviceRunSession.d.ts

@@ -0,0 +1,32 @@
+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;
+export declare function startServeSimWithTunnelAsync({ env, logger, timeoutMs, }: {
+    env: BuildStepEnv;
+    logger: bunyan;
+    timeoutMs: number;
+}): Promise<{
+    previewUrl: string;
+    streamUrl: string;
+}>;

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -0,0 +1,93 @@
+"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;
+exports.startServeSimWithTunnelAsync = startServeSimWithTunnelAsync;
+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 retry_1 = require("../../utils/retry");
+const TRYCLOUDFLARE_URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
+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 };
+}
+async function startServeSimWithTunnelAsync({ env, logger, timeoutMs, }) {
+    logger.info('Launching serve-sim with tunnel.');
+    const serveSim = spawnDetached({
+        command: 'npx',
+        args: ['serve-sim-szdziedzic@latest', '--tunnel'],
+        env,
+    });
+    logger.info('Waiting for serve-sim to report tunnel and stream URLs.');
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "18.12.0",
+  "version": "18.12.3",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -50,6 +50,7 @@
     "@expo/turtle-spawn": "18.5.0",
     "@expo/xcpretty": "^4.3.1",
     "@google-cloud/storage": "^7.11.2",
+    "@sentry/node": "7.77.0",
     "@urql/core": "^6.0.1",
     "bplist-parser": "0.3.2",
     "fast-glob": "^3.3.2",
@@ -98,5 +99,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "53d294330de9c63eb792f646c0603224def9a1b0"
+  "gitHead": "985cd9d52f4de333cf563cc7fe92f4e2d1e1c8e5"
 }