@expo/build-tools 19.1.0 → 20.1.0

package/dist/builders/android.js

@@ -22,6 +22,7 @@ const saveBuildCache_1 = require("../steps/functions/saveBuildCache");
 const gradleConfig_1 = require("../steps/utils/android/gradleConfig");
 const artifacts_1 = require("../utils/artifacts");
 const expoUpdates_1 = require("../utils/expoUpdates");
+const expoUpdatesEmbedded_1 = require("../utils/expoUpdatesEmbedded");
 const hooks_1 = require("../utils/hooks");
 const prepareBuildExecutable_1 = require("../utils/prepareBuildExecutable");
 async function androidBuilder(ctx) {
@@ -177,6 +178,11 @@ async function buildAsync(ctx) {
             logger: ctx.logger,
         });
     });
+    if (ctx.env.EAS_UPDATE_EXPERIMENTAL_UPLOAD_EMBEDDED_BUNDLE) {
+        await ctx.runBuildPhase(eas_build_job_1.BuildPhase.UPLOAD_EMBEDDED_BUNDLE, async () => {
+            await (0, expoUpdatesEmbedded_1.uploadEmbeddedBundleAsync)(ctx);
+        });
+    }
     await ctx.runBuildPhase(eas_build_job_1.BuildPhase.SAVE_CACHE, async () => {
         if (ctx.isLocal) {
             ctx.logger.info('Local builds do not support saving cache.');

package/dist/builders/ios.js

@@ -26,6 +26,7 @@ const restoreBuildCache_1 = require("../steps/functions/restoreBuildCache");
 const saveBuildCache_1 = require("../steps/functions/saveBuildCache");
 const artifacts_1 = require("../utils/artifacts");
 const expoUpdates_1 = require("../utils/expoUpdates");
+const expoUpdatesEmbedded_1 = require("../utils/expoUpdatesEmbedded");
 const hooks_1 = require("../utils/hooks");
 const prepareBuildExecutable_1 = require("../utils/prepareBuildExecutable");
 const processes_1 = require("../utils/processes");
@@ -166,13 +167,16 @@ async function buildAsync(ctx) {
         }
         try {
             const { derivedDataPath, workspacePath } = (0, nullthrows_1.default)(fastlaneResult);
-            await (0, xcactivitylog_1.parseAndReportXcactivitylog)({
+            const { skipped } = await (0, xcactivitylog_1.parseAndReportXcactivitylog)({
                 derivedDataPath,
                 workspacePath,
                 logger: ctx.logger,
                 proxyBaseUrl: ctx.env.EAS_BUILD_COCOAPODS_CACHE_URL,
                 env: ctx.env,
             });
+            if (skipped) {
+                ctx.markBuildPhaseSkipped();
+            }
         }
         catch (err) {
             sentry_1.Sentry.capture('Failed to parse xcactivitylog', err);
@@ -189,6 +193,11 @@ async function buildAsync(ctx) {
             logger: ctx.logger,
         });
     });
+    if (ctx.env.EAS_UPDATE_EXPERIMENTAL_UPLOAD_EMBEDDED_BUNDLE) {
+        await ctx.runBuildPhase(eas_build_job_1.BuildPhase.UPLOAD_EMBEDDED_BUNDLE, async () => {
+            await (0, expoUpdatesEmbedded_1.uploadEmbeddedBundleAsync)(ctx);
+        });
+    }
     await ctx.runBuildPhase(eas_build_job_1.BuildPhase.SAVE_CACHE, async () => {
         if (ctx.isLocal) {
             ctx.logger.info('Local builds do not support saving cache.');

package/dist/datadog.d.ts

@@ -1,11 +1,19 @@
+type MetricsTarget = {
+    kind: 'build';
+    turtleBuildId: string;
+} | {
+    kind: 'jobRun';
+    turtleJobRunId: string;
+};
 type DatadogSetupOptions = {
     expoApiV2BaseUrl: string;
-    turtleBuildId: string;
     robotAccessToken: string;
+    target: MetricsTarget;
 };
 export declare const Datadog: {
     setup(opts: DatadogSetupOptions | null): void;
     distribution(name: string, value: number, tags?: Record<string, string>): void;
+    log(message: string, tags?: Record<string, string>): void;
     flushAsync(): Promise<void>;
 };
 export {};

package/dist/datadog.js

@@ -4,7 +4,7 @@ exports.Datadog = void 0;
 const sentry_1 = require("./sentry");
 const turtleFetch_1 = require("./utils/turtleFetch");
 let setupOptions = null;
-let pendingMetricUploads = [];
+let pendingUploads = [];
 exports.Datadog = {
     setup(opts) {
         setupOptions = opts;
@@ -13,7 +13,7 @@ exports.Datadog = {
         if (!setupOptions) {
             return;
         }
-        const { expoApiV2BaseUrl, turtleBuildId, robotAccessToken } = setupOptions;
+        const { expoApiV2BaseUrl, robotAccessToken, target } = setupOptions;
         const metrics = [
             {
                 name,
@@ -22,20 +22,49 @@ exports.Datadog = {
                 tags,
             },
         ];
-        const uploadPromise = (0, turtleFetch_1.turtleFetch)(new URL(`turtle-builds/${turtleBuildId}/metrics`, expoApiV2BaseUrl).toString(), 'POST', {
+        const metricsPath = target.kind === 'build'
+            ? `turtle-builds/${target.turtleBuildId}/metrics`
+            : `turtle-job-runs/${target.turtleJobRunId}/metrics`;
+        const uploadPromise = (0, turtleFetch_1.turtleFetch)(new URL(metricsPath, expoApiV2BaseUrl).toString(), 'POST', {
             json: { metrics },
             headers: {
                 Authorization: `Bearer ${robotAccessToken}`,
             },
             retries: 2,
         }).catch(err => {
-            sentry_1.Sentry.capture('Failed to report turtle build metric', err, {
+            sentry_1.Sentry.capture(`Failed to report turtle ${target.kind} metric`, err, {
                 extras: { metrics },
             });
         });
-        pendingMetricUploads.push(uploadPromise);
+        pendingUploads.push(uploadPromise);
+    },
+    log(message, tags = {}) {
+        if (!setupOptions) {
+            return;
+        }
+        const { expoApiV2BaseUrl, robotAccessToken, target } = setupOptions;
+        const log = target.kind === 'build'
+            ? { buildId: target.turtleBuildId, message, tags }
+            : { jobRunId: target.turtleJobRunId, message, tags };
+        const logsPath = target.kind === 'build' ? 'turtle-builds/logs' : 'turtle-job-runs/logs';
+        const uploadPromise = (0, turtleFetch_1.turtleFetch)(new URL(logsPath, expoApiV2BaseUrl).toString(), 'POST', {
+            json: log,
+            headers: {
+                Authorization: `Bearer ${robotAccessToken}`,
+            },
+            shouldThrowOnNotOk: false,
+        }).catch(err => {
+            sentry_1.Sentry.capture(`Failed to report turtle ${target.kind} log`, err, {
+                extras: { log },
+            });
+        });
+        pendingUploads.push(uploadPromise);
     },
     async flushAsync() {
-        await Promise.allSettled(pendingMetricUploads);
+        // Rotate so each flush only awaits its own batch; uploads enqueued during the
+        // await land in the fresh array for a later flush.
+        const uploads = pendingUploads;
+        pendingUploads = [];
+        await Promise.allSettled(uploads);
     },
 };

package/dist/ios/pod.js

@@ -38,6 +38,10 @@ async function installPods(ctx, { infoCallbackFn }) {
     };
 }
 async function resolvePrecompiledModulesPodInstallEnvAsync(ctx) {
+    if (ctx.env.EXPO_USE_PRECOMPILED_MODULES === '0') {
+        ctx.logger.info('EXPO_USE_PRECOMPILED_MODULES=0 is set; not enabling precompiled modules use.');
+        return {};
+    }
     if (ctx.job.builderEnvironment?.env?.EAS_USE_PRECOMPILED_MODULES !== '1') {
         return {};
     }

package/dist/steps/functions/restoreBuildCache.js

@@ -18,6 +18,7 @@ const path_1 = __importDefault(require("path"));
 const ccacheStats_1 = require("./ccacheStats");
 const restoreCache_1 = require("./restoreCache");
 const cacheKey_1 = require("../../utils/cacheKey");
+const datadog_1 = require("../../datadog");
 const gradleCacheKey_1 = require("../../utils/gradleCacheKey");
 const turtleFetch_1 = require("../../utils/turtleFetch");
 function createRestoreBuildCacheFunction() {
@@ -216,23 +217,10 @@ async function restoreGradleCacheAsync({ logger, workingDirectory, env, secrets,
         });
         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 { }
+        datadog_1.Datadog.log(`Gradle cache restored (${hitType})`, {
+            event: 'gradle_cache_restored',
+            cache_hit_type: hitType,
+        });
     }
     catch (err) {
         if (err instanceof turtleFetch_1.TurtleFetchError && err.response?.status === 404) {

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -29,10 +29,13 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
             }),
         ],
         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.
+            // Fail fast before any expensive setup if the injected env
+            // vars are missing: DEVICE_RUN_SESSION_ID (to report the remote config
+            // back to the API server), EAS_SIMULATOR_NGROK_TUNNEL_DOMAIN (base domain
+            // for our ngrok tunnels), and NGROK_AUTHTOKEN (to authenticate them).
             const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
+            const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
+            const ngrokAuthtoken = (0, remoteDeviceRunSession_1.getNgrokAuthtokenOrThrow)(env);
             const packageVersion = inputs.package_version.value;
             const { runtimePlatform } = global;
             logger.info(`Starting agent-device remote session (version: ${packageVersion ?? 'latest'}, runtime: ${runtimePlatform}).`);
@@ -40,12 +43,6 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 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.');
-            const cloudflaredCommand = await (0, remoteDeviceRunSession_1.ensureCloudflaredInstalledAsync)({
-                runtimePlatform,
-                env,
-                logger,
-            });
             logger.info(packageVersion
                 ? `Cloning agent-device @ v${packageVersion} into ${SRC_DIR}.`
                 : `Cloning agent-device (latest) into ${SRC_DIR}.`);
@@ -71,18 +68,12 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 parse: parseDaemonInfo,
             });
             logger.info(`Daemon is listening on port ${daemonPort}; loaded auth token.`);
-            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.info('Waiting for a public tunnel URL.');
-            const agentDeviceRemoteSessionUrl = await (0, remoteDeviceRunSession_1.waitForMatchInOutputAsync)({
-                process: cloudflared,
-                pattern: /https:\/\/[a-z0-9-]+\.trycloudflare\.com/,
-                timeoutMs: STARTUP_TIMEOUT_MS,
-                description: 'cloudflared tunnel',
+            const agentDeviceRemoteSessionUrl = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
+                port: daemonPort,
+                subdomainPrefix: 'agent-device',
+                baseDomain: ngrokTunnelDomain,
+                authtoken: ngrokAuthtoken,
+                logger,
             });
             logger.info(`Tunnel is ready at ${agentDeviceRemoteSessionUrl}.`);
             // serve-sim is iOS-only — only launch it (and report a webPreviewUrl)
@@ -90,6 +81,7 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
             let webPreviewUrl;
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
                 const { previewUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)({
+                    baseDomain: ngrokTunnelDomain,
                     env,
                     logger,
                     timeoutMs: STARTUP_TIMEOUT_MS,

package/dist/steps/functions/startArgentRemoteSession.js

@@ -31,10 +31,13 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
             }),
         ],
         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.
+            // Fail fast before any expensive setup if the injected env
+            // vars are missing: DEVICE_RUN_SESSION_ID (to report the remote config
+            // back to the API server), EAS_SIMULATOR_NGROK_TUNNEL_DOMAIN (base domain
+            // for our ngrok tunnels), and NGROK_AUTHTOKEN (to authenticate them).
             const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
+            const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
+            const ngrokAuthtoken = (0, remoteDeviceRunSession_1.getNgrokAuthtokenOrThrow)(env);
             const packageVersion = inputs.package_version.value;
             const versionSpec = packageVersion ?? 'latest';
             const { runtimePlatform } = global;
@@ -43,12 +46,6 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 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.');
-            const cloudflaredCommand = await (0, remoteDeviceRunSession_1.ensureCloudflaredInstalledAsync)({
-                runtimePlatform,
-                env,
-                logger,
-            });
             // Stale state from a previous run would mask the new server's port.
             await node_fs_1.default.promises.rm(ARGENT_STATE_FILE, { force: true });
             logger.info(`Launching ${ARGENT_PACKAGE_NAME}@${versionSpec} via bunx.`);
@@ -69,24 +66,19 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 parse: parseArgentToolServerState,
             });
             logger.info(`Argent tool-server is listening on port ${toolServerPort}.`);
-            logger.info(`Starting cloudflared tunnel to http://localhost:${toolServerPort}.`);
-            const cloudflared = (0, remoteDeviceRunSession_1.spawnDetached)({
-                command: cloudflaredCommand,
-                args: ['tunnel', '--url', `http://localhost:${toolServerPort}`],
-                env,
-            });
-            logger.info('Waiting for a public tunnel URL.');
-            const toolsUrl = await (0, remoteDeviceRunSession_1.waitForMatchInOutputAsync)({
-                process: cloudflared,
-                pattern: /https:\/\/[a-z0-9-]+\.trycloudflare\.com/,
-                timeoutMs: STARTUP_TIMEOUT_MS,
-                description: 'cloudflared tunnel',
+            const toolsUrl = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
+                port: toolServerPort,
+                subdomainPrefix: 'argent',
+                baseDomain: ngrokTunnelDomain,
+                authtoken: ngrokAuthtoken,
+                logger,
             });
             logger.info(`Tunnel is ready at ${toolsUrl}.`);
             // serve-sim is iOS-only — Android sessions go without a preview URL.
             let webPreviewUrl;
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
                 const serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)({
+                    baseDomain: ngrokTunnelDomain,
                     env,
                     logger,
                     timeoutMs: STARTUP_TIMEOUT_MS,

package/dist/steps/functions/startIosSimulator.js

@@ -52,6 +52,12 @@ function createStartIosSimulatorBuildFunction() {
                 deviceIdentifier: originalDeviceIdentifier,
                 env,
             });
+            try {
+                await IosSimulatorUtils_1.IosSimulatorUtils.disableApsdAsync({ udid, env });
+            }
+            catch (err) {
+                logger.warn({ err }, 'Failed to disable apsd in the Simulator.');
+            }
             await IosSimulatorUtils_1.IosSimulatorUtils.waitForReadyAsync({ udid, env });
             logger.info('');
             const device = await IosSimulatorUtils_1.IosSimulatorUtils.getDeviceAsync({ udid, env });
@@ -76,6 +82,12 @@ function createStartIosSimulatorBuildFunction() {
                         deviceIdentifier: cloneDeviceName,
                         env,
                     });
+                    try {
+                        await IosSimulatorUtils_1.IosSimulatorUtils.disableApsdAsync({ udid: cloneUdid, env });
+                    }
+                    catch (err) {
+                        logger.warn({ err }, 'Failed to disable apsd in the Simulator.');
+                    }
                     await IosSimulatorUtils_1.IosSimulatorUtils.waitForReadyAsync({
                         udid: cloneUdid,
                         env,

package/dist/steps/functions/startServeSimRemoteSession.js

@@ -18,12 +18,12 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
         supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
         fn: async ({ logger }, { env }) => {
             const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
+            const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(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)({
+                baseDomain: ngrokTunnelDomain,
                 env,
                 logger,
                 timeoutMs: STARTUP_TIMEOUT_MS,

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

@@ -2,9 +2,9 @@ import { bunyan } from '@expo/logger';
 import { BuildStepEnv } from '@expo/steps';
 import { z } from 'zod';
 /**
- * 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.
+ * Catches all internal failures (logged + routed to Sentry); returns
+ * `{ skipped: true }` when analysis did not produce a report so callers can
+ * mark the build phase skipped.
  */
 export declare function parseAndReportXcactivitylog({ derivedDataPath, workspacePath, xclogparserVersion, logger, proxyBaseUrl, env, }: {
     derivedDataPath: string;
@@ -13,7 +13,9 @@ export declare function parseAndReportXcactivitylog({ derivedDataPath, workspace
     logger: bunyan;
     proxyBaseUrl?: string;
     env: BuildStepEnv;
-}): Promise<void>;
+}): Promise<{
+    skipped: boolean;
+}>;
 declare const XcactivitylogStepSchemaZ: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     detailStepType: z.ZodOptional<z.ZodString>;

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

@@ -21,14 +21,40 @@ const XCLOGPARSER_DOWNLOAD_URL = 'https://storage.googleapis.com/turtle-v2/xclog
 const XCLOGPARSER_DOWNLOAD_TIMEOUT_MS = 20_000;
 const XCLOGPARSER_OUTPUT_FILENAME = 'xcactivitylog.json';
 /**
- * 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.
+ * Catches all internal failures (logged + routed to Sentry); returns
+ * `{ skipped: true }` when analysis did not produce a report so callers can
+ * mark the build phase skipped.
  */
 async function parseAndReportXcactivitylog({ derivedDataPath, workspacePath, xclogparserVersion, logger, proxyBaseUrl, env, }) {
     let tempDir;
-    let phase = 'creating_temp_directory';
+    let phase = 'checking_xcactivitylog_existence';
     try {
+        const logsBuildDir = path_1.default.join(derivedDataPath, 'Logs', 'Build');
+        let buildLogEntries;
+        try {
+            buildLogEntries = await fs_extra_1.default.readdir(logsBuildDir);
+        }
+        catch (err) {
+            if (err?.code !== 'ENOENT') {
+                throw err;
+            }
+            buildLogEntries = [];
+        }
+        const hasActivityLog = buildLogEntries.some(entry => entry.endsWith('.xcactivitylog'));
+        if (!hasActivityLog) {
+            logger.info([
+                `Build performance analysis skipped: no .xcactivitylog files found at ${logsBuildDir}.`,
+                '',
+                'This typically happens when your project has a custom ios/Gymfile. To enable',
+                'build performance analysis, add the following lines to your Gymfile:',
+                '',
+                '    derived_data_path("./build")',
+                '    result_bundle(true)',
+                '    result_bundle_path("./build/result-bundle.xcresult")',
+            ].join('\n'));
+            return { skipped: true };
+        }
+        phase = 'creating_temp_directory';
         tempDir = await fs_extra_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'xclogparser-'));
         phase = 'resolving_xclogparser';
         const preinstalledVersion = await detectPreinstalledXclogparserVersion(env);
@@ -63,6 +89,7 @@ async function parseAndReportXcactivitylog({ derivedDataPath, workspacePath, xcl
         phase = 'parsing_xclogparser_output';
         const data = XcactivitylogDataSchemaZ.parse(JSON.parse(await fs_extra_1.default.readFile(jsonOutputPath, 'utf8')));
         logger.info(formatReport(data));
+        return { skipped: false };
     }
     catch (err) {
         logger.info('Build performance analysis skipped.');
@@ -76,6 +103,7 @@ async function parseAndReportXcactivitylog({ derivedDataPath, workspacePath, xcl
                 stdout: err?.stdout?.slice(-4000),
             },
         });
+        return { skipped: true };
     }
     finally {
         if (tempDir) {

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

@@ -1,18 +1,15 @@
 import { bunyan } from '@expo/logger';
-import { BuildRuntimePlatform, BuildStepEnv } from '@expo/steps';
+import { BuildStepEnv } from '@expo/steps';
 import { CustomBuildContext } from '../../customBuildContext';
 export declare function getDeviceRunSessionIdOrThrow(env: BuildStepEnv): string;
+export declare function getNgrokTunnelDomainOrThrow(env: BuildStepEnv): string;
+export declare function getNgrokAuthtokenOrThrow(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;
 };
@@ -22,7 +19,8 @@ export declare function spawnDetached({ command, args, cwd, env, }: {
     cwd?: string;
     env: BuildStepEnv;
 }): DetachedProcessHandle;
-export declare function startServeSimWithTunnelAsync({ env, logger, timeoutMs, }: {
+export declare function startServeSimWithTunnelAsync({ baseDomain, env, logger, timeoutMs, }: {
+    baseDomain: string;
     env: BuildStepEnv;
     logger: bunyan;
     timeoutMs: number;
@@ -30,17 +28,13 @@ export declare function startServeSimWithTunnelAsync({ env, logger, timeoutMs, }
     previewUrl: string;
     streamUrl: string;
 }>;
-export declare function ensureCloudflaredInstalledAsync({ runtimePlatform, env, logger, }: {
-    runtimePlatform: BuildRuntimePlatform;
-    env: BuildStepEnv;
+export declare function startNgrokTunnelAsync({ port, subdomainPrefix, baseDomain, authtoken, logger, }: {
+    port: number;
+    subdomainPrefix: string;
+    baseDomain: string;
+    authtoken: string;
     logger: bunyan;
 }): Promise<string>;
-export declare function waitForMatchInOutputAsync({ process, pattern, timeoutMs, description, }: {
-    process: DetachedProcessHandle;
-    pattern: RegExp;
-    timeoutMs: number;
-    description: string;
-}): Promise<string>;
 export declare function waitForFileAsync<T>({ filePath, timeoutMs, description, parse, }: {
     filePath: string;
     timeoutMs: number;

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -1,25 +1,56 @@
 "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;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDeviceRunSessionIdOrThrow = getDeviceRunSessionIdOrThrow;
+exports.getNgrokTunnelDomainOrThrow = getNgrokTunnelDomainOrThrow;
+exports.getNgrokAuthtokenOrThrow = getNgrokAuthtokenOrThrow;
 exports.uploadRemoteSessionConfigAsync = uploadRemoteSessionConfigAsync;
-exports.ensureBrewPackageInstalledAsync = ensureBrewPackageInstalledAsync;
 exports.spawnDetached = spawnDetached;
 exports.startServeSimWithTunnelAsync = startServeSimWithTunnelAsync;
-exports.ensureCloudflaredInstalledAsync = ensureCloudflaredInstalledAsync;
-exports.waitForMatchInOutputAsync = waitForMatchInOutputAsync;
+exports.startNgrokTunnelAsync = startNgrokTunnelAsync;
 exports.waitForFileAsync = waitForFileAsync;
 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 ngrok = __importStar(require("@ngrok/ngrok"));
 const gql_tada_1 = require("gql.tada");
+const node_crypto_1 = require("node:crypto");
 const node_fs_1 = __importDefault(require("node:fs"));
-const node_os_1 = __importDefault(require("node:os"));
 const retry_1 = require("../../utils/retry");
-const TRYCLOUDFLARE_URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
-const CLOUDFLARED_LINUX_INSTALL_PATH = '/usr/local/bin/cloudflared';
 const START_DEVICE_RUN_SESSION_MUTATION = (0, gql_tada_1.graphql)(`
   mutation StartDeviceRunSession($deviceRunSessionId: ID!, $remoteConfig: JSONObject!) {
     deviceRunSession {
@@ -37,11 +68,29 @@ 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, ' +
+            'This step must run as part of a device run session ' +
             'which injects DEVICE_RUN_SESSION_ID into the job environment.');
     }
     return deviceRunSessionId;
 }
+function getNgrokTunnelDomainOrThrow(env) {
+    const baseDomain = env.EAS_SIMULATOR_NGROK_TUNNEL_DOMAIN;
+    if (!baseDomain) {
+        throw new eas_build_job_1.SystemError('EAS_SIMULATOR_NGROK_TUNNEL_DOMAIN is not set. ' +
+            'This step must run as part of a device run session ' +
+            'which injects EAS_SIMULATOR_NGROK_TUNNEL_DOMAIN into the job environment.');
+    }
+    return baseDomain;
+}
+function getNgrokAuthtokenOrThrow(env) {
+    const authtoken = env.NGROK_AUTHTOKEN;
+    if (!authtoken) {
+        throw new eas_build_job_1.SystemError('NGROK_AUTHTOKEN is not set. ' +
+            'This step must run as part of a device run session ' +
+            'which injects NGROK_AUTHTOKEN into the job environment.');
+    }
+    return authtoken;
+}
 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
@@ -51,9 +100,6 @@ async function uploadRemoteSessionConfigAsync({ ctx, deviceRunSessionId, remoteC
         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,
@@ -73,19 +119,23 @@ function spawnDetached({ command, args, cwd, env, }) {
     promise.child.stderr?.on('data', appendChunk);
     return { getOutput: () => output };
 }
-async function startServeSimWithTunnelAsync({ env, logger, timeoutMs, }) {
+async function startServeSimWithTunnelAsync({ baseDomain, env, logger, timeoutMs, }) {
     logger.info('Launching serve-sim with tunnel.');
     const serveSim = spawnDetached({
         command: 'npx',
         args: [
             'serve-sim-szdziedzic@latest',
             '--tunnel',
-            '--tunnel-protocol',
-            'quic',
+            '--tunnel-provider',
+            'ngrok',
+            '--tunnel-domain',
+            baseDomain,
             '--stream-max-dimension',
             '1280',
             '--stream-quality',
             '0.55',
+            '--codec',
+            'webrtc',
         ],
         env,
     });
@@ -93,8 +143,8 @@ async function startServeSimWithTunnelAsync({ env, logger, timeoutMs, }) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
         const output = serveSim.getOutput();
-        const previewUrl = matchLabeledUrl(output, 'Tunnel');
-        const streamUrl = matchLabeledUrl(output, 'Stream');
+        const previewUrl = matchLabeledUrl({ output, label: 'Tunnel', baseDomain });
+        const streamUrl = matchLabeledUrl({ output, label: 'Stream', baseDomain });
         if (previewUrl && streamUrl) {
             return { previewUrl, streamUrl };
         }
@@ -102,59 +152,25 @@ async function startServeSimWithTunnelAsync({ env, logger, timeoutMs, }) {
     }
     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);
+function matchLabeledUrl({ output, label, baseDomain, }) {
+    const labelPattern = new RegExp(`${label}:\\s*(https:\\/\\/[a-z0-9-]+\\.${escapeRegExp(baseDomain)})`);
+    const match = labelPattern.exec(output);
     return match ? match[1] : null;
 }
-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;
-}
-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 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 startNgrokTunnelAsync({ port, subdomainPrefix, baseDomain, authtoken, logger, }) {
+    const domain = `${subdomainPrefix}-${(0, node_crypto_1.randomBytes)(8).toString('hex')}.${baseDomain}`;
+    logger.info(`Starting ngrok tunnel ${domain} -> http://localhost:${port}.`);
+    // Run the ngrok agent in-process via the SDK; it keeps the session alive until
+    // the process exits, and the step blocks forever to hold it open.
+    const listener = await ngrok.forward({ addr: port, authtoken, domain });
+    const url = listener.url();
+    if (!url) {
+        throw new eas_build_job_1.SystemError(`ngrok tunnel for ${domain} did not return a public URL.`);
     }
+    return url;
 }
-async function waitForMatchInOutputAsync({ process, pattern, timeoutMs, description, }) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const match = pattern.exec(process.getOutput());
-        if (match) {
-            return match[1] ?? match[0];
-        }
-        await (0, retry_1.sleepAsync)(1_000);
-    }
-    throw new eas_build_job_1.SystemError(`Timed out waiting for ${description} to start. Last output:\n${process.getOutput() || '<empty>'}`);
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 async function waitForFileAsync({ filePath, timeoutMs, description, parse, }) {
     const deadline = Date.now() + timeoutMs;

package/dist/utils/IosSimulatorUtils.d.ts

@@ -49,6 +49,10 @@ export declare namespace IosSimulatorUtils {
         udid: IosSimulatorUuid;
         env: NodeJS.ProcessEnv;
     }): Promise<void>;
+    export function disableApsdAsync({ udid, env, }: {
+        udid: IosSimulatorUuid;
+        env: NodeJS.ProcessEnv;
+    }): Promise<void>;
     export function collectLogsAsync({ deviceIdentifier, env, }: {
         deviceIdentifier: IosSimulatorName | IosSimulatorUuid;
         env: NodeJS.ProcessEnv;

package/dist/utils/IosSimulatorUtils.js

@@ -49,8 +49,9 @@ var IosSimulatorUtils;
     }
     IosSimulatorUtils.startAsync = startAsync;
     async function waitForReadyAsync({ udid, env, }) {
+        const readinessScreenshotPath = node_path_1.default.join(node_os_1.default.tmpdir(), 'eas-simulator-readiness.png');
         await (0, retry_1.retryAsync)(async () => {
-            await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'io', udid, 'screenshot', '/dev/null'], {
+            await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'io', udid, 'screenshot', readinessScreenshotPath], {
                 env,
             });
         }, {
@@ -60,6 +61,7 @@ var IosSimulatorUtils;
                 retryIntervalMs: 1_000,
             },
         });
+        await node_fs_1.default.promises.rm(readinessScreenshotPath, { force: true });
         // Wait for data migration to complete before declaring the simulator ready
         // Based on WebKit's approach: https://trac.webkit.org/changeset/231452/webkit
         await (0, retry_1.retryAsync)(async () => {
@@ -75,6 +77,11 @@ var IosSimulatorUtils;
         });
     }
     IosSimulatorUtils.waitForReadyAsync = waitForReadyAsync;
+    async function disableApsdAsync({ udid, env, }) {
+        await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'spawn', udid, 'launchctl', 'disable', 'system/com.apple.apsd'], { env });
+        await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'spawn', udid, 'launchctl', 'bootout', 'system/com.apple.apsd'], { env });
+    }
+    IosSimulatorUtils.disableApsdAsync = disableApsdAsync;
     async function collectLogsAsync({ deviceIdentifier, env, }) {
         const outputDir = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'ios-simulator-logs-'));
         const outputPath = node_path_1.default.join(outputDir, `${deviceIdentifier}.logarchive`);

package/dist/utils/artifacts.js

@@ -13,21 +13,15 @@ const fast_glob_1 = __importDefault(require("fast-glob"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const promise_limit_1 = __importDefault(require("promise-limit"));
-const sentry_1 = require("../sentry");
 class FindArtifactsError extends Error {
 }
 exports.FindArtifactsError = FindArtifactsError;
 async function findArtifacts({ rootDir, patternOrPath, logger, }) {
-    const files = path_1.default.isAbsolute(patternOrPath)
+    const files = path_1.default.isAbsolute(patternOrPath) && !fast_glob_1.default.isDynamicPattern(patternOrPath)
         ? (await fs_extra_1.default.pathExists(patternOrPath))
             ? [patternOrPath]
             : []
         : await (0, fast_glob_1.default)(patternOrPath, { cwd: rootDir, onlyFiles: false });
-    await maybeReportAbsoluteGlobDryRunMismatchAsync({
-        rootDir,
-        patternOrPath,
-        files,
-    });
     if (files.length === 0) {
         if (fast_glob_1.default.isDynamicPattern(patternOrPath)) {
             throw new FindArtifactsError(`There are no files matching pattern "${patternOrPath}"`);
@@ -50,60 +44,6 @@ async function findArtifacts({ rootDir, patternOrPath, logger, }) {
         return path_1.default.join(rootDir, filePath);
     });
 }
-async function findArtifactsWithAbsoluteGlobSupportDryRunAsync(rootDir, patternOrPath) {
-    return path_1.default.isAbsolute(patternOrPath) && !fast_glob_1.default.isDynamicPattern(patternOrPath)
-        ? (await fs_extra_1.default.pathExists(patternOrPath))
-            ? [patternOrPath]
-            : []
-        : await (0, fast_glob_1.default)(patternOrPath, { cwd: rootDir, onlyFiles: false });
-}
-async function maybeReportAbsoluteGlobDryRunMismatchAsync({ rootDir, patternOrPath, files, }) {
-    if (!path_1.default.isAbsolute(patternOrPath)) {
-        return;
-    }
-    try {
-        const filesWithAbsoluteGlobSupport = await findArtifactsWithAbsoluteGlobSupportDryRunAsync(rootDir, patternOrPath);
-        if (areArtifactListsEqual(files, filesWithAbsoluteGlobSupport)) {
-            return;
-        }
-        sentry_1.Sentry.capture(new Error('findArtifacts output changed for an absolute path'), {
-            tags: {
-                source: 'find-artifacts',
-                reason: 'absolute_path',
-            },
-            extras: {
-                rootDir,
-                patternOrPath,
-                currentCount: files.length,
-                dryRunCount: filesWithAbsoluteGlobSupport.length,
-                currentSample: files.slice(0, 20),
-                dryRunSample: filesWithAbsoluteGlobSupport.slice(0, 20),
-            },
-        });
-    }
-    catch (err) {
-        sentry_1.Sentry.capture(err, {
-            tags: {
-                source: 'find-artifacts',
-                reason: 'absolute_path_dry_run_failed',
-            },
-            extras: {
-                rootDir,
-                patternOrPath,
-                currentCount: files.length,
-                currentSample: files.slice(0, 20),
-            },
-        });
-    }
-}
-function areArtifactListsEqual(first, second) {
-    if (first.length !== second.length) {
-        return false;
-    }
-    const sortedFirst = [...first].sort();
-    const sortedSecond = [...second].sort();
-    return sortedFirst.every((artifactPath, index) => artifactPath === sortedSecond[index]);
-}
 async function logMissingFileError(artifactPath, buildLogger) {
     let currentPath = artifactPath;
     while (!(await fs_extra_1.default.pathExists(currentPath))) {

package/dist/utils/expoUpdatesEmbedded.d.ts

@@ -0,0 +1,3 @@
+import { BuildJob } from '@expo/eas-build-job';
+import { BuildContext } from '../context';
+export declare function uploadEmbeddedBundleAsync(ctx: BuildContext<BuildJob>): Promise<void>;

package/dist/utils/expoUpdatesEmbedded.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadEmbeddedBundleAsync = uploadEmbeddedBundleAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const logger_1 = require("@expo/logger");
+const results_1 = require("@expo/results");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const node_stream_zip_1 = __importDefault(require("node-stream-zip"));
+const artifacts_1 = require("./artifacts");
+const easCli_1 = require("./easCli");
+const resolve_1 = require("../ios/resolve");
+const expoUpdates_1 = require("./expoUpdates");
+async function uploadEmbeddedBundleAsync(ctx) {
+    if (!(await (0, expoUpdates_1.isEASUpdateConfigured)(ctx))) {
+        ctx.markBuildPhaseSkipped();
+        return;
+    }
+    const { platform } = ctx.job;
+    if (platform === eas_build_job_1.Platform.IOS && ctx.job.simulator) {
+        ctx.markBuildPhaseSkipped();
+        return;
+    }
+    const channel = ctx.job.updates?.channel;
+    if (!channel) {
+        ctx.logger.warn('Skipping embedded bundle upload: no channel configured for this build profile.');
+        ctx.markBuildPhaseHasWarnings();
+        return;
+    }
+    const projectDir = ctx.getReactNativeProjectDirectory();
+    let archivePattern;
+    if (platform === eas_build_job_1.Platform.IOS) {
+        archivePattern = (0, resolve_1.resolveArtifactPath)(ctx);
+    }
+    else if (platform === eas_build_job_1.Platform.ANDROID) {
+        archivePattern =
+            ctx.job.applicationArchivePath ??
+                'android/app/build/outputs/**/*.{apk,aab}';
+    }
+    else {
+        throw new Error(`Uploading embedded updates is not supported for the ${platform} platform.`);
+    }
+    const [archivePath] = await (0, artifacts_1.findArtifacts)({
+        rootDir: projectDir,
+        patternOrPath: archivePattern,
+        logger: null,
+    }).catch(() => []);
+    if (!archivePath) {
+        ctx.logger.warn('Skipping embedded bundle upload: build archive not found.');
+        ctx.markBuildPhaseHasWarnings();
+        return;
+    }
+    const tmpDir = await fs_extra_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'eas-embedded-bundle-'));
+    const bundleName = platform === eas_build_job_1.Platform.IOS ? 'main.jsbundle' : 'index.android.bundle';
+    const bundlePath = path_1.default.join(tmpDir, bundleName);
+    const manifestPath = path_1.default.join(tmpDir, 'app.manifest');
+    const zip = new node_stream_zip_1.default.async({ file: archivePath });
+    try {
+        const entries = Object.values(await zip.entries());
+        const bundleEntry = entries.find(e => platform === eas_build_job_1.Platform.IOS
+            ? e.name.endsWith('/main.jsbundle')
+            : e.name.endsWith('assets/index.android.bundle'));
+        const manifestEntry = entries.find(e => platform === eas_build_job_1.Platform.IOS
+            ? e.name.includes('EXUpdates.bundle/app.manifest')
+            : e.name.endsWith('assets/app.manifest'));
+        if (!bundleEntry || !manifestEntry) {
+            ctx.logger.warn('Skipping embedded bundle upload: bundle or manifest not found in archive.');
+            ctx.markBuildPhaseHasWarnings();
+            return;
+        }
+        await zip.extract(bundleEntry.name, bundlePath);
+        await zip.extract(manifestEntry.name, manifestPath);
+        const args = [
+            'update:embedded:upload',
+            '--platform',
+            platform,
+            '--bundle',
+            bundlePath,
+            '--manifest',
+            manifestPath,
+            '--channel',
+            channel,
+            '--non-interactive',
+        ];
+        if (ctx.env.EAS_BUILD_ID) {
+            args.push('--build-id', ctx.env.EAS_BUILD_ID);
+        }
+        await (0, easCli_1.runEasCliCommand)({
+            args,
+            options: {
+                cwd: projectDir,
+                env: ctx.env,
+                logger: ctx.logger,
+                mode: logger_1.PipeMode.STDERR_ONLY_AS_STDOUT,
+            },
+        });
+    }
+    catch (err) {
+        ctx.logger.warn({ err }, 'Failed to upload embedded bundle.');
+        ctx.markBuildPhaseHasWarnings();
+    }
+    finally {
+        await (0, results_1.asyncResult)(zip.close());
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "19.1.0",
+  "version": "20.1.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -37,19 +37,20 @@
   "dependencies": {
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
-    "@expo/downloader": "19.0.0",
-    "@expo/eas-build-job": "19.1.0",
+    "@expo/downloader": "20.0.0",
+    "@expo/eas-build-job": "20.1.0",
     "@expo/env": "^0.4.0",
-    "@expo/logger": "19.0.0",
+    "@expo/logger": "20.0.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": "19.1.0",
-    "@expo/template-file": "19.0.0",
-    "@expo/turtle-spawn": "19.0.0",
+    "@expo/steps": "20.1.0",
+    "@expo/template-file": "20.0.0",
+    "@expo/turtle-spawn": "20.0.0",
     "@expo/xcpretty": "^4.3.1",
     "@google-cloud/storage": "^7.11.2",
+    "@ngrok/ngrok": "1.7.0",
     "@sentry/node": "7.77.0",
     "@urql/core": "^6.0.1",
     "bplist-parser": "0.3.2",
@@ -99,5 +100,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "27a2e2abc752aa0123075958651a796fe045d601"
+  "gitHead": "33225d2b73a34db5cbdfeaa537aedb6c6b4a84af"
 }