@expo/build-tools 23.1.0 → 23.2.0

package/dist/steps/easFunctions.js

@@ -49,7 +49,7 @@ const startAppiumRemoteSession_1 = require("./functions/startAppiumRemoteSession
 const startCuttlefishDevice_1 = require("./functions/startCuttlefishDevice");
 const startIosSimulator_1 = require("./functions/startIosSimulator");
 const startIosSimulatorRecordings_1 = require("./functions/startIosSimulatorRecordings");
-const startServeSimRemoteSession_1 = require("./functions/startServeSimRemoteSession");
+const startWebPreviewRemoteSession_1 = require("./functions/startWebPreviewRemoteSession");
 const startServeSimMetrics_1 = require("./functions/startServeSimMetrics");
 const collectServeSimMetrics_1 = require("./functions/collectServeSimMetrics");
 const uploadArtifact_1 = require("./functions/uploadArtifact");
@@ -102,7 +102,7 @@ function getEasFunctions(ctx) {
         (0, startIosSimulatorRecordings_1.createStartIosSimulatorRecordingsBuildFunction)(),
         (0, finishIosSimulatorRecordings_1.createFinishIosSimulatorRecordingsBuildFunction)(),
         (0, uploadDeviceRunSessionScreenRecordings_1.createUploadDeviceRunSessionScreenRecordingsBuildFunction)(ctx),
-        (0, startServeSimRemoteSession_1.createStartServeSimRemoteSessionBuildFunction)(ctx),
+        (0, startWebPreviewRemoteSession_1.createStartWebPreviewRemoteSessionBuildFunction)(ctx),
         (0, startServeSimMetrics_1.createStartServeSimMetricsBuildFunction)(),
         (0, collectServeSimMetrics_1.createCollectServeSimMetricsBuildFunction)(ctx),
         (0, installMaestro_1.createInstallMaestroBuildFunction)(),

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -81,27 +81,24 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
             });
             const agentDeviceRemoteSessionUrl = agentDeviceTunnel.url;
             logger.info(`Tunnel is ready at ${agentDeviceRemoteSessionUrl}.`);
-            let serveSim;
+            let webPreview;
             let eventCollection;
             try {
-                // serve-sim is iOS-only — only launch it (and report a webPreviewUrl)
-                // on Darwin. Android sessions go without a preview URL.
-                if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
-                    serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
-                        baseDomain: ngrokTunnelDomain,
-                        env,
-                        logger,
-                        timeoutMs: STARTUP_TIMEOUT_MS,
-                    });
-                    logger.info(`Web preview URL: ${serveSim.previewUrl}`);
-                }
+                webPreview = await (0, remoteDeviceRunSession_1.startDeviceWebPreviewWithTunnelAsync)(ctx, {
+                    runtimePlatform,
+                    baseDomain: ngrokTunnelDomain,
+                    env,
+                    logger,
+                    timeoutMs: STARTUP_TIMEOUT_MS,
+                });
+                logger.info(`Web preview URL: ${webPreview.previewUrl}`);
                 await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
                     ctx,
                     deviceRunSessionId,
                     remoteConfig: {
                         agentDeviceRemoteSessionUrl,
                         agentDeviceRemoteSessionToken: daemonToken,
-                        ...(serveSim ? { webPreviewUrl: serveSim.previewUrl } : {}),
+                        webPreviewUrl: webPreview.previewUrl,
                     },
                     logger,
                 });
@@ -132,8 +129,8 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 });
             }
             finally {
-                if (serveSim) {
-                    await serveSim.stopAsync();
+                if (webPreview) {
+                    await webPreview.stopAsync();
                 }
                 await agentDeviceTunnel.stopAsync();
                 if (eventCollection) {

package/dist/steps/functions/startAppiumRemoteSession.js

@@ -95,7 +95,7 @@ function createStartAppiumRemoteSessionBuildFunction(ctx) {
                 logger,
             });
             let appiumTunnel;
-            let serveSim;
+            let webPreview;
             try {
                 appiumTunnel = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
                     port: APPIUM_PORT,
@@ -104,18 +104,15 @@ function createStartAppiumRemoteSessionBuildFunction(ctx) {
                     authtoken: ngrokAuthtoken,
                     logger,
                 });
-                switch (runtimePlatform) {
-                    case steps_1.BuildRuntimePlatform.DARWIN:
-                        serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
-                            baseDomain: ngrokTunnelDomain,
-                            env,
-                            logger,
-                            timeoutMs: APPIUM_STARTUP_TIMEOUT_MS,
-                        });
-                        break;
-                    case steps_1.BuildRuntimePlatform.LINUX:
-                        break;
-                }
+                // expo-device-hub has no serial-selection flag. Device run session workflows must expose
+                // a single booted Android emulator so the Hub and Appium resolve the same device.
+                webPreview = await (0, remoteDeviceRunSession_1.startDeviceWebPreviewWithTunnelAsync)(ctx, {
+                    runtimePlatform,
+                    baseDomain: ngrokTunnelDomain,
+                    env,
+                    logger,
+                    timeoutMs: APPIUM_STARTUP_TIMEOUT_MS,
+                });
                 await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
                     ctx,
                     deviceRunSessionId,
@@ -126,7 +123,7 @@ function createStartAppiumRemoteSessionBuildFunction(ctx) {
                             'appium:automationName': device.automationName,
                             'appium:udid': device.udid,
                         },
-                        ...(serveSim ? { webPreviewUrl: serveSim.previewUrl } : {}),
+                        webPreviewUrl: webPreview.previewUrl,
                     },
                     logger,
                 });
@@ -144,8 +141,8 @@ function createStartAppiumRemoteSessionBuildFunction(ctx) {
                 });
             }
             finally {
-                if (serveSim) {
-                    await serveSim.stopAsync();
+                if (webPreview) {
+                    await webPreview.stopAsync();
                 }
                 if (appiumTunnel) {
                     await appiumTunnel.stopAsync();

package/dist/steps/functions/startArgentRemoteSession.js

@@ -146,7 +146,7 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 logger,
             });
             let toolsTunnel;
-            let serveSim;
+            let webPreview;
             try {
                 toolsTunnel = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
                     port: toolServerPort,
@@ -158,25 +158,21 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 });
                 const publicToolsUrl = toolsTunnel.url;
                 logger.info(`Tunnel is ready at ${publicToolsUrl}.`);
-                // serve-sim is iOS-only — Android sessions go without a preview URL.
-                let webPreviewUrl;
-                if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
-                    serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
-                        baseDomain: ngrokTunnelDomain,
-                        env,
-                        logger,
-                        timeoutMs: STARTUP_TIMEOUT_MS,
-                    });
-                    webPreviewUrl = serveSim.previewUrl;
-                    logger.info(`Web preview URL: ${webPreviewUrl}`);
-                }
+                webPreview = await (0, remoteDeviceRunSession_1.startDeviceWebPreviewWithTunnelAsync)(ctx, {
+                    runtimePlatform,
+                    baseDomain: ngrokTunnelDomain,
+                    env,
+                    logger,
+                    timeoutMs: STARTUP_TIMEOUT_MS,
+                });
+                logger.info(`Web preview URL: ${webPreview.previewUrl}`);
                 await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
                     ctx,
                     deviceRunSessionId,
                     remoteConfig: {
                         toolsUrl: publicToolsUrl,
                         ...(toolServerToken ? { toolsAuthToken: toolServerToken } : {}),
-                        ...(webPreviewUrl ? { webPreviewUrl } : {}),
+                        webPreviewUrl: webPreview.previewUrl,
                     },
                     logger,
                 });
@@ -195,8 +191,8 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 });
             }
             finally {
-                if (serveSim) {
-                    await serveSim.stopAsync();
+                if (webPreview) {
+                    await webPreview.stopAsync();
                 }
                 if (toolsTunnel) {
                     await toolsTunnel.stopAsync();

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

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

package/dist/steps/functions/{startServeSimRemoteSession.js → startWebPreviewRemoteSession.js}

@@ -1,16 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStartServeSimRemoteSessionBuildFunction = createStartServeSimRemoteSessionBuildFunction;
+exports.createStartWebPreviewRemoteSessionBuildFunction = createStartWebPreviewRemoteSessionBuildFunction;
 const steps_1 = require("@expo/steps");
 const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
 const STARTUP_TIMEOUT_MS = 60_000;
-function createStartServeSimRemoteSessionBuildFunction(ctx) {
+function createStartWebPreviewRemoteSessionBuildFunction(ctx) {
     return new steps_1.BuildFunction({
         namespace: 'eas',
         id: 'start_serve_sim_remote_session',
-        name: 'Start serve-sim remote session',
+        name: 'Start web preview remote session',
         __metricsId: 'eas/start_serve_sim_remote_session',
-        supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
         inputProviders: [
             steps_1.BuildStepInput.createProvider({
                 id: 'package_version',
@@ -23,26 +22,30 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
             }),
         ],
-        fn: async ({ logger }, { inputs, env, signal }) => {
+        fn: async ({ logger, global }, { inputs, env, signal }) => {
             const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
             const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
             const maxDurationSeconds = inputs.max_duration_seconds?.value;
             const packageVersion = inputs.package_version?.value;
-            logger.info('Starting serve-sim remote session.');
-            await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
-            const serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
+            const { runtimePlatform } = global;
+            logger.info(`Starting web preview remote session (runtime: ${runtimePlatform}).`);
+            if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
+                await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
+            }
+            const webPreview = await (0, remoteDeviceRunSession_1.startDeviceWebPreviewWithTunnelAsync)(ctx, {
+                runtimePlatform,
                 baseDomain: ngrokTunnelDomain,
                 env,
                 logger,
                 timeoutMs: STARTUP_TIMEOUT_MS,
                 packageVersion,
             });
-            logger.info(`Preview URL: ${serveSim.previewUrl}`);
+            logger.info(`Preview URL: ${webPreview.previewUrl}`);
             try {
                 await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
                     ctx,
                     deviceRunSessionId,
-                    remoteConfig: { previewUrl: serveSim.previewUrl },
+                    remoteConfig: { previewUrl: webPreview.previewUrl },
                     logger,
                 });
                 await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
@@ -54,7 +57,7 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
                 });
             }
             finally {
-                await serveSim.stopAsync();
+                await webPreview.stopAsync();
             }
         },
     });

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

@@ -54,22 +54,23 @@ export declare function ensureFfmpegInstalledAsync({ runtimePlatform, env, logge
     logger: bunyan;
 }): Promise<void>;
 /**
- * Translate Cloudflare ICE servers into serve-sim CLI flags: `--stun-url` (the
+ * Translate Cloudflare ICE servers into web preview CLI flags: `--stun-url` (the
  * credential-less entries) and `--turn-url`/`--turn-username`/`--turn-credential`
- * (the entry carrying the short-lived credentials).
+ * (the entry carrying the short-lived credentials). serve-sim and expo-device-hub
+ * intentionally expose the same ICE flag contract.
  */
-export declare function turnIceServersToServeSimArgs(iceServers: TurnIceServers): string[];
+export declare function turnIceServersToWebPreviewArgs(iceServers: TurnIceServers): string[];
 /**
  * Fetch short-lived Cloudflare TURN ICE servers for this job run from www
  * (minted on demand, mirroring how the worker fetches project clone URLs) and
- * translate them into serve-sim CLI flags.
+ * translate them into web preview CLI flags.
  *
- * Best-effort: on any failure we log and return [] so serve-sim falls back to
- * its built-in P2P/STUN behavior. The credential is passed to serve-sim as a
- * process arg and deliberately not logged (turtle-spawn never logs argv and the
- * worker is single-tenant).
+ * Best-effort: on any failure we log and return [] so the preview server falls
+ * back to its built-in P2P/STUN behavior. The credential is passed as a process
+ * arg and deliberately not logged (turtle-spawn never logs argv and the worker
+ * is single-tenant).
  */
-export declare function fetchServeSimTurnArgsAsync(ctx: CustomBuildContext, { env, logger }: {
+export declare function fetchWebPreviewTurnArgsAsync(ctx: CustomBuildContext, { env, logger }: {
     env: BuildStepEnv;
     logger: bunyan;
 }): Promise<string[]>;
@@ -98,15 +99,22 @@ export declare function createServeSimArgs({ port, turnArgs, metricsCorsArgs, pa
     metricsCorsArgs?: string[];
     packageVersion?: string;
 }): string[];
-export declare function waitForServeSimReadyAsync({ serveSim, port, timeoutMs, }: {
-    serveSim: Pick<DetachedProcessHandle, 'pid' | 'getOutput'>;
+export declare function createExpoDeviceHubArgs({ port, turnArgs, packageVersion, }: {
+    port: number;
+    turnArgs?: string[];
+    packageVersion?: string;
+}): string[];
+export declare function waitForWebPreviewReadyAsync({ previewServer, serverName, port, timeoutMs, }: {
+    previewServer: Pick<DetachedProcessHandle, 'pid' | 'getOutput'>;
+    serverName: string;
     port: number;
     timeoutMs: number;
 }): Promise<void>;
-export type ServeSimPreviewHandle = {
+export type DeviceWebPreviewHandle = {
     previewUrl: string;
     stopAsync: () => Promise<void>;
 };
+export type ServeSimPreviewHandle = DeviceWebPreviewHandle;
 export declare function startServeSimWithTunnelAsync(ctx: CustomBuildContext, { baseDomain, env, logger, timeoutMs, packageVersion, }: {
     baseDomain: string;
     env: BuildStepEnv;
@@ -114,6 +122,21 @@ export declare function startServeSimWithTunnelAsync(ctx: CustomBuildContext, {
     timeoutMs: number;
     packageVersion?: string;
 }): Promise<ServeSimPreviewHandle>;
+export declare function startExpoDeviceHubWithTunnelAsync(ctx: CustomBuildContext, { baseDomain, env, logger, timeoutMs, packageVersion, }: {
+    baseDomain: string;
+    env: BuildStepEnv;
+    logger: bunyan;
+    timeoutMs: number;
+    packageVersion?: string;
+}): Promise<DeviceWebPreviewHandle>;
+export declare function startDeviceWebPreviewWithTunnelAsync(ctx: CustomBuildContext, { runtimePlatform, ...options }: {
+    runtimePlatform: BuildRuntimePlatform;
+    baseDomain: string;
+    env: BuildStepEnv;
+    logger: bunyan;
+    timeoutMs: number;
+    packageVersion?: string;
+}): Promise<DeviceWebPreviewHandle>;
 export type NgrokTunnelHandle = {
     url: string;
     stopAsync: () => Promise<void>;

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -42,14 +42,17 @@ exports.getNgrokAuthtokenOrThrow = getNgrokAuthtokenOrThrow;
 exports.selectXcodeDeveloperDirectoryAsync = selectXcodeDeveloperDirectoryAsync;
 exports.waitForDeviceRunSessionStoppedAsync = waitForDeviceRunSessionStoppedAsync;
 exports.ensureFfmpegInstalledAsync = ensureFfmpegInstalledAsync;
-exports.turnIceServersToServeSimArgs = turnIceServersToServeSimArgs;
-exports.fetchServeSimTurnArgsAsync = fetchServeSimTurnArgsAsync;
+exports.turnIceServersToWebPreviewArgs = turnIceServersToWebPreviewArgs;
+exports.fetchWebPreviewTurnArgsAsync = fetchWebPreviewTurnArgsAsync;
 exports.uploadRemoteSessionConfigAsync = uploadRemoteSessionConfigAsync;
 exports.spawnDetached = spawnDetached;
 exports.metricsCorsOriginToServeSimArgs = metricsCorsOriginToServeSimArgs;
 exports.createServeSimArgs = createServeSimArgs;
-exports.waitForServeSimReadyAsync = waitForServeSimReadyAsync;
+exports.createExpoDeviceHubArgs = createExpoDeviceHubArgs;
+exports.waitForWebPreviewReadyAsync = waitForWebPreviewReadyAsync;
 exports.startServeSimWithTunnelAsync = startServeSimWithTunnelAsync;
+exports.startExpoDeviceHubWithTunnelAsync = startExpoDeviceHubWithTunnelAsync;
+exports.startDeviceWebPreviewWithTunnelAsync = startDeviceWebPreviewWithTunnelAsync;
 exports.startNgrokTunnelAsync = startNgrokTunnelAsync;
 exports.waitForFileAsync = waitForFileAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
@@ -69,12 +72,16 @@ const sentry_1 = require("../../sentry");
 const retry_1 = require("../../utils/retry");
 const turtleFetch_1 = require("../../utils/turtleFetch");
 const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
+const WEB_PREVIEW_HOST = '127.0.0.1';
 const SERVE_SIM_PACKAGE_NAME = '@expo/serve-sim';
-const SERVE_SIM_HOST = '127.0.0.1';
 const SERVE_SIM_MAX_DIMENSION = '960';
 const SERVE_SIM_MJPEG_QUALITY = '0.55';
 const SERVE_SIM_VIDEO_BITRATE = '6000000';
 const SERVE_SIM_VIDEO_FPS = '60';
+const EXPO_DEVICE_HUB_PACKAGE_NAME = 'expo-device-hub';
+const EXPO_DEVICE_HUB_MAX_DIMENSION = '1280';
+const EXPO_DEVICE_HUB_VIDEO_BITRATE = '6000000';
+const EXPO_DEVICE_HUB_VIDEO_FPS = '60';
 const START_DEVICE_RUN_SESSION_MUTATION = (0, gql_tada_1.graphql)(`
   mutation StartDeviceRunSession($deviceRunSessionId: ID!, $remoteConfig: JSONObject!) {
     deviceRunSession {
@@ -328,11 +335,12 @@ const TurnIceServersResponseSchema = zod_1.z.object({
     }),
 });
 /**
- * Translate Cloudflare ICE servers into serve-sim CLI flags: `--stun-url` (the
+ * Translate Cloudflare ICE servers into web preview CLI flags: `--stun-url` (the
  * credential-less entries) and `--turn-url`/`--turn-username`/`--turn-credential`
- * (the entry carrying the short-lived credentials).
+ * (the entry carrying the short-lived credentials). serve-sim and expo-device-hub
+ * intentionally expose the same ICE flag contract.
  */
-function turnIceServersToServeSimArgs(iceServers) {
+function turnIceServersToWebPreviewArgs(iceServers) {
     const stunUrls = iceServers
         .filter(server => !server.username && !server.credential)
         .flatMap(server => server.urls);
@@ -349,14 +357,14 @@ function turnIceServersToServeSimArgs(iceServers) {
 /**
  * Fetch short-lived Cloudflare TURN ICE servers for this job run from www
  * (minted on demand, mirroring how the worker fetches project clone URLs) and
- * translate them into serve-sim CLI flags.
+ * translate them into web preview CLI flags.
  *
- * Best-effort: on any failure we log and return [] so serve-sim falls back to
- * its built-in P2P/STUN behavior. The credential is passed to serve-sim as a
- * process arg and deliberately not logged (turtle-spawn never logs argv and the
- * worker is single-tenant).
+ * Best-effort: on any failure we log and return [] so the preview server falls
+ * back to its built-in P2P/STUN behavior. The credential is passed as a process
+ * arg and deliberately not logged (turtle-spawn never logs argv and the worker
+ * is single-tenant).
  */
-async function fetchServeSimTurnArgsAsync(ctx, { env, logger }) {
+async function fetchWebPreviewTurnArgsAsync(ctx, { env, logger }) {
     try {
         const deviceRunSessionId = getDeviceRunSessionIdOrThrow(env);
         const expoApiServerUrl = (0, nullthrows_1.default)(ctx.env.__API_SERVER_URL, '__API_SERVER_URL is not set');
@@ -370,16 +378,16 @@ async function fetchServeSimTurnArgsAsync(ctx, { env, logger }) {
             logger,
         });
         const { data } = TurnIceServersResponseSchema.parse(await response.json());
-        const args = turnIceServersToServeSimArgs(data.iceServers);
+        const args = turnIceServersToWebPreviewArgs(data.iceServers);
         if (args.length > 0) {
-            logger.info('Configured serve-sim with Cloudflare TURN ICE servers.');
+            logger.info('Configured the web preview with Cloudflare TURN ICE servers.');
         }
         return args;
     }
     catch (err) {
         const error = err instanceof Error ? err : new Error(String(err));
         sentry_1.Sentry.capture('Could not fetch Cloudflare TURN ICE servers', error, { level: 'warning' });
-        logger.warn({ err: error }, 'Could not fetch Cloudflare TURN ICE servers; serve-sim will fall back to P2P/STUN.');
+        logger.warn({ err: error }, 'Could not fetch Cloudflare TURN ICE servers; the web preview will fall back to P2P/STUN.');
         return [];
     }
 }
@@ -476,6 +484,9 @@ function metricsCorsOriginToServeSimArgs(env) {
 function createServeSimPackageSpec(packageVersion) {
     return `${SERVE_SIM_PACKAGE_NAME}@${packageVersion ?? 'latest'}`;
 }
+function createExpoDeviceHubPackageSpec(packageVersion) {
+    return `${EXPO_DEVICE_HUB_PACKAGE_NAME}@${packageVersion ?? 'latest'}`;
+}
 function createServeSimArgs({ port, turnArgs = [], metricsCorsArgs = [], packageVersion, }) {
     return [
         '--yes',
@@ -483,7 +494,7 @@ function createServeSimArgs({ port, turnArgs = [], metricsCorsArgs = [], package
         '--port',
         String(port),
         '--host',
-        SERVE_SIM_HOST,
+        WEB_PREVIEW_HOST,
         '--transport',
         'webrtc',
         '--webrtc-codec',
@@ -500,40 +511,67 @@ function createServeSimArgs({ port, turnArgs = [], metricsCorsArgs = [], package
         ...metricsCorsArgs,
     ];
 }
+function createExpoDeviceHubArgs({ port, turnArgs = [], packageVersion, }) {
+    return [
+        '--yes',
+        createExpoDeviceHubPackageSpec(packageVersion),
+        '--port',
+        String(port),
+        '--host',
+        WEB_PREVIEW_HOST,
+        '--platform',
+        'android',
+        '--transport',
+        'webrtc',
+        '--webrtc-codec',
+        'h264',
+        '--webrtc-ice-policy',
+        'all',
+        '--max-dimension',
+        EXPO_DEVICE_HUB_MAX_DIMENSION,
+        '--video-bitrate',
+        EXPO_DEVICE_HUB_VIDEO_BITRATE,
+        '--video-fps',
+        EXPO_DEVICE_HUB_VIDEO_FPS,
+        '--hide-sidebar',
+        '--hide-boot-device',
+        ...turnArgs,
+    ];
+}
 async function findAvailablePortAsync() {
     const server = (0, node_net_1.createServer)();
     server.unref();
     await new Promise((resolve, reject) => {
         server.once('error', reject);
-        server.listen(0, SERVE_SIM_HOST, () => resolve());
+        server.listen(0, WEB_PREVIEW_HOST, () => resolve());
     });
     const address = server.address();
     await new Promise((resolve, reject) => {
         server.close(err => (err ? reject(err) : resolve()));
     });
     if (!address || typeof address === 'string') {
-        throw new eas_build_job_1.SystemError('Could not allocate a local port for serve-sim.');
+        throw new eas_build_job_1.SystemError('Could not allocate a local port for the web preview.');
     }
     return address.port;
 }
-const ServeSimReadyResponseSchema = zod_1.z.object({
+const WebPreviewReadyResponseSchema = zod_1.z.object({
     status: zod_1.z.literal('ready'),
     device: zod_1.z.string(),
 });
-async function waitForServeSimReadyAsync({ serveSim, port, timeoutMs, }) {
-    const readyUrl = `http://${SERVE_SIM_HOST}:${port}/readyz`;
+async function waitForWebPreviewReadyAsync({ previewServer, serverName, port, timeoutMs, }) {
+    const readyUrl = `http://${WEB_PREVIEW_HOST}:${port}/readyz`;
     const deadline = Date.now() + timeoutMs;
     let lastError;
     while (Date.now() < deadline) {
-        if (serveSim.pid !== undefined && !isProcessRunning(serveSim.pid)) {
-            throw new eas_build_job_1.SystemError(`serve-sim exited before becoming ready. Last output:\n${serveSim.getOutput() || '<empty>'}`);
+        if (previewServer.pid !== undefined && !isProcessRunning(previewServer.pid)) {
+            throw new eas_build_job_1.SystemError(`${serverName} exited before becoming ready. Last output:\n${previewServer.getOutput() || '<empty>'}`);
         }
         try {
             const response = await (0, turtleFetch_1.turtleFetch)(readyUrl, 'GET', {
                 retries: 0,
                 timeout: 2_000,
             });
-            ServeSimReadyResponseSchema.parse(await response.json());
+            WebPreviewReadyResponseSchema.parse(await response.json());
             return;
         }
         catch (error) {
@@ -541,21 +579,20 @@ async function waitForServeSimReadyAsync({ serveSim, port, timeoutMs, }) {
         }
         await (0, retry_1.sleepAsync)(1_000);
     }
-    throw new eas_build_job_1.SystemError(`Timed out waiting for serve-sim readiness at ${readyUrl}${lastError instanceof Error ? `: ${lastError.message}` : ''}. Last output:\n${serveSim.getOutput() || '<empty>'}`);
+    throw new eas_build_job_1.SystemError(`Timed out waiting for ${serverName} readiness at ${readyUrl}${lastError instanceof Error ? `: ${lastError.message}` : ''}. Last output:\n${previewServer.getOutput() || '<empty>'}`);
 }
-async function startServeSimWithTunnelAsync(ctx, { baseDomain, env, logger, timeoutMs, packageVersion, }) {
+async function startWebPreviewWithTunnelAsync(ctx, { baseDomain, env, logger, timeoutMs, serverName, packageSpec, createArgs, }) {
     const port = await findAvailablePortAsync();
-    logger.info(`Launching ${createServeSimPackageSpec(packageVersion)} on ${SERVE_SIM_HOST}:${port}.`);
-    const turnArgs = await fetchServeSimTurnArgsAsync(ctx, { env, logger });
-    const metricsCorsArgs = metricsCorsOriginToServeSimArgs(env);
-    const serveSim = spawnDetached({
+    logger.info(`Launching ${packageSpec} on ${WEB_PREVIEW_HOST}:${port}.`);
+    const turnArgs = await fetchWebPreviewTurnArgsAsync(ctx, { env, logger });
+    const previewServer = spawnDetached({
         command: 'npx',
-        args: createServeSimArgs({ port, turnArgs, metricsCorsArgs, packageVersion }),
+        args: createArgs(port, turnArgs),
         env,
     });
     try {
-        logger.info('Waiting for serve-sim to become ready.');
-        await waitForServeSimReadyAsync({ serveSim, port, timeoutMs });
+        logger.info(`Waiting for ${serverName} to become ready.`);
+        await waitForWebPreviewReadyAsync({ previewServer, serverName, port, timeoutMs });
         const tunnel = await startNgrokTunnelAsync({
             port,
             subdomainPrefix: 'web-preview',
@@ -566,20 +603,51 @@ async function startServeSimWithTunnelAsync(ctx, { baseDomain, env, logger, time
         return {
             previewUrl: tunnel.url,
             stopAsync: async () => {
-                const results = await Promise.allSettled([tunnel.stopAsync(), serveSim.stopAsync()]);
+                const results = await Promise.allSettled([tunnel.stopAsync(), previewServer.stopAsync()]);
                 for (const result of results) {
                     if (result.status === 'rejected') {
-                        logger.warn({ err: result.reason }, 'Could not stop a serve-sim preview resource.');
+                        logger.warn({ err: result.reason }, `Could not stop a ${serverName} preview resource.`);
                     }
                 }
             },
         };
     }
     catch (error) {
-        await serveSim.stopAsync();
+        await previewServer.stopAsync();
         throw error;
     }
 }
+async function startServeSimWithTunnelAsync(ctx, { baseDomain, env, logger, timeoutMs, packageVersion, }) {
+    const metricsCorsArgs = metricsCorsOriginToServeSimArgs(env);
+    return await startWebPreviewWithTunnelAsync(ctx, {
+        baseDomain,
+        env,
+        logger,
+        timeoutMs,
+        serverName: 'serve-sim',
+        packageSpec: createServeSimPackageSpec(packageVersion),
+        createArgs: (port, turnArgs) => createServeSimArgs({ port, turnArgs, metricsCorsArgs, packageVersion }),
+    });
+}
+async function startExpoDeviceHubWithTunnelAsync(ctx, { baseDomain, env, logger, timeoutMs, packageVersion, }) {
+    return await startWebPreviewWithTunnelAsync(ctx, {
+        baseDomain,
+        env,
+        logger,
+        timeoutMs,
+        serverName: 'expo-device-hub',
+        packageSpec: createExpoDeviceHubPackageSpec(packageVersion),
+        createArgs: (port, turnArgs) => createExpoDeviceHubArgs({ port, turnArgs, packageVersion }),
+    });
+}
+async function startDeviceWebPreviewWithTunnelAsync(ctx, { runtimePlatform, ...options }) {
+    switch (runtimePlatform) {
+        case steps_1.BuildRuntimePlatform.DARWIN:
+            return await startServeSimWithTunnelAsync(ctx, options);
+        case steps_1.BuildRuntimePlatform.LINUX:
+            return await startExpoDeviceHubWithTunnelAsync(ctx, options);
+    }
+}
 async function startNgrokTunnelAsync({ port, subdomainPrefix, baseDomain, authtoken, rewriteHostHeader, logger, }) {
     const domain = `${subdomainPrefix}-${(0, node_crypto_1.randomBytes)(16).toString('hex')}.${baseDomain}`;
     logger.info(`Starting ngrok tunnel ${domain} -> http://localhost:${port}.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "23.1.0",
+  "version": "23.2.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -102,5 +102,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "0658d58efdbf614f6920e3b4142223ac198bc003"
+  "gitHead": "74292d2ace404759ab8936d5aa1369e15d4b4f9d"
 }

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

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