@expo/build-tools 21.8.0 → 22.2.0

package/dist/steps/functions/startAppiumRemoteSession.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStartAppiumRemoteSessionBuildFunction = createStartAppiumRemoteSessionBuildFunction;
+exports.resolveAppium3VersionSpec = resolveAppium3VersionSpec;
+exports.resolveAppiumDeviceAsync = resolveAppiumDeviceAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const semver_1 = __importDefault(require("semver"));
+const zod_1 = require("zod");
+const AndroidEmulatorUtils_1 = require("../../utils/AndroidEmulatorUtils");
+const IosSimulatorUtils_1 = require("../../utils/IosSimulatorUtils");
+const retry_1 = require("../../utils/retry");
+const turtleFetch_1 = require("../../utils/turtleFetch");
+const appiumEvents_1 = require("../utils/appiumEvents");
+const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
+const APPIUM_HOST = '127.0.0.1';
+const APPIUM_PORT = 4723;
+const APPIUM_STARTUP_TIMEOUT_MS = 120_000;
+const DEFAULT_APPIUM_VERSION = '^3';
+const AppiumInstalledDriversSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.object({ installed: zod_1.z.boolean().optional() }).passthrough());
+function createStartAppiumRemoteSessionBuildFunction(ctx) {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'start_appium_remote_session',
+        name: 'Start Appium remote session',
+        __metricsId: 'eas/start_appium_remote_session',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'package_version',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'max_idle_time_minutes',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+            }),
+        ],
+        fn: async ({ logger, global }, { inputs, env, signal }) => {
+            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 maxIdleTimeMinutes = inputs.max_idle_time_minutes.value;
+            const { runtimePlatform } = global;
+            const versionSpec = resolveAppium3VersionSpec(packageVersion);
+            logger.info(`Starting Appium remote session (version: ${versionSpec}, runtime: ${runtimePlatform}).`);
+            const device = await resolveAppiumDeviceAsync({ runtimePlatform, env, logger });
+            const { appiumHome, appiumBinPath, appiumEnv } = await installAppiumAsync({
+                versionSpec,
+                driverName: device.driverName,
+                env,
+                logger,
+            });
+            const appiumProcess = (0, remoteDeviceRunSession_1.spawnDetached)({
+                command: appiumBinPath,
+                args: [
+                    '--address',
+                    APPIUM_HOST,
+                    '--port',
+                    String(APPIUM_PORT),
+                    '--base-path',
+                    '/',
+                    '--log-level',
+                    'error',
+                    // Appium 3 gates session listing (GET /appium/sessions) behind the
+                    // session_discovery insecure feature. We rely on it to poll for
+                    // Appium Event Timings, so enable it for all drivers.
+                    '--allow-insecure',
+                    '*:session_discovery',
+                    '--default-capabilities',
+                    JSON.stringify({ 'appium:eventTimings': true }),
+                ],
+                env: appiumEnv,
+            });
+            try {
+                await waitForAppiumReadyAsync({ appiumProcess, logger });
+            }
+            catch (error) {
+                await appiumProcess.stopAsync();
+                await node_fs_1.default.promises.rm(appiumHome, { recursive: true, force: true });
+                throw error;
+            }
+            const eventCollection = await (0, appiumEvents_1.startAppiumEventCollectionAsync)({
+                ctx,
+                deviceRunSessionId,
+                appiumUrl: `http://${APPIUM_HOST}:${APPIUM_PORT}/`,
+                logger,
+            });
+            let appiumTunnel;
+            let serveSim;
+            try {
+                appiumTunnel = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
+                    port: APPIUM_PORT,
+                    subdomainPrefix: 'appium',
+                    baseDomain: ngrokTunnelDomain,
+                    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;
+                }
+                await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    remoteConfig: {
+                        appiumUrl: appiumTunnel.url,
+                        capabilities: {
+                            platformName: device.platformName,
+                            'appium:automationName': device.automationName,
+                            'appium:udid': device.udid,
+                        },
+                        ...(serveSim ? { webPreviewUrl: serveSim.previewUrl } : {}),
+                    },
+                    logger,
+                });
+                await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    logger,
+                    signal,
+                    idleTimeout: maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
+                        ? {
+                            maxIdleTimeMinutes,
+                            getLastEventObservedAt: eventCollection.getLastEventObservedAt,
+                        }
+                        : undefined,
+                });
+            }
+            finally {
+                if (serveSim) {
+                    await serveSim.stopAsync();
+                }
+                if (appiumTunnel) {
+                    await appiumTunnel.stopAsync();
+                }
+                await eventCollection.stopAsync();
+                await appiumProcess.stopAsync();
+                await node_fs_1.default.promises.rm(appiumHome, { recursive: true, force: true });
+            }
+        },
+    });
+}
+function resolveAppium3VersionSpec(packageVersion) {
+    const versionSpec = packageVersion ?? DEFAULT_APPIUM_VERSION;
+    const range = semver_1.default.validRange(versionSpec);
+    if (!range || !semver_1.default.subset(range, '>=3.0.0 <4.0.0-0')) {
+        throw new eas_build_job_1.SystemError(`Appium 3 is required for EAS Simulator sessions. Received package version "${versionSpec}".`);
+    }
+    return versionSpec;
+}
+async function resolveAppiumDeviceAsync({ runtimePlatform, env, logger, }) {
+    switch (runtimePlatform) {
+        case steps_1.BuildRuntimePlatform.DARWIN: {
+            await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
+            const [bootedDevice] = await IosSimulatorUtils_1.IosSimulatorUtils.getAvailableDevicesAsync({
+                env,
+                filter: 'booted',
+            });
+            if (!bootedDevice) {
+                throw new eas_build_job_1.SystemError('Could not find a booted iOS simulator for the Appium session.');
+            }
+            return {
+                platformName: 'iOS',
+                automationName: 'XCUITest',
+                driverName: 'xcuitest',
+                udid: bootedDevice.udid,
+            };
+        }
+        case steps_1.BuildRuntimePlatform.LINUX: {
+            const attachedDevices = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.getAttachedDevicesAsync({ env });
+            const bootedDevice = attachedDevices.find(device => device.state === 'device');
+            if (!bootedDevice) {
+                throw new eas_build_job_1.SystemError('Could not find a booted Android emulator for the Appium session.');
+            }
+            return {
+                platformName: 'Android',
+                automationName: 'UiAutomator2',
+                driverName: 'uiautomator2',
+                udid: bootedDevice.serialId,
+            };
+        }
+    }
+}
+async function installAppiumAsync({ versionSpec, driverName, env, logger, }) {
+    const appiumHome = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'eas-appium-home-'));
+    await node_fs_1.default.promises.writeFile(node_path_1.default.join(appiumHome, 'package.json'), `${JSON.stringify({ name: 'eas-appium-home', private: true })}\n`);
+    const appiumEnv = { ...env, APPIUM_HOME: appiumHome };
+    const appiumBinPath = node_path_1.default.join(appiumHome, 'node_modules', '.bin', 'appium');
+    logger.info(`Installing appium@${versionSpec}.`);
+    await (0, turtle_spawn_1.default)('npm', ['install', '--prefix', appiumHome, `appium@${versionSpec}`], {
+        env: appiumEnv,
+        logger,
+    });
+    const { stdout } = await (0, turtle_spawn_1.default)(appiumBinPath, ['driver', 'list', '--installed', '--json'], {
+        env: appiumEnv,
+        stdio: 'pipe',
+    });
+    const installedDrivers = AppiumInstalledDriversSchema.parse(JSON.parse(stdout));
+    if (installedDrivers[driverName]?.installed) {
+        logger.info(`Updating the installed Appium ${driverName} driver.`);
+        await (0, turtle_spawn_1.default)(appiumBinPath, ['driver', 'update', driverName], { env: appiumEnv, logger });
+    }
+    else {
+        logger.info(`Installing the Appium ${driverName} driver.`);
+        await (0, turtle_spawn_1.default)(appiumBinPath, ['driver', 'install', driverName], { env: appiumEnv, logger });
+    }
+    return { appiumHome, appiumBinPath, appiumEnv };
+}
+async function waitForAppiumReadyAsync({ appiumProcess, logger, }) {
+    const deadline = Date.now() + APPIUM_STARTUP_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        try {
+            const response = await (0, turtleFetch_1.turtleFetch)(`http://${APPIUM_HOST}:${APPIUM_PORT}/status`, 'GET', {
+                timeout: 2_000,
+                retries: 0,
+                logger,
+            });
+            if (response.ok) {
+                return;
+            }
+        }
+        catch { }
+        await (0, retry_1.sleepAsync)(1_000);
+    }
+    const output = appiumProcess.getOutput();
+    throw new eas_build_job_1.SystemError(`Timed out waiting for Appium to become ready.${output ? `\nAppium output:\n${output}` : ''}`);
+}

package/dist/steps/functions/startArgentRemoteSession.js

@@ -57,6 +57,11 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'max_duration_seconds',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+            }),
         ],
         fn: async ({ logger, global }, { inputs, env, signal }) => {
             // Fail fast before any expensive setup if the injected env
@@ -69,6 +74,7 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
             const packageVersion = inputs.package_version.value;
             // A missing or non-positive value disables the idle timeout (opt-in feature).
             const maxIdleTimeMinutes = inputs.max_idle_time_minutes.value;
+            const maxDurationSeconds = inputs.max_duration_seconds?.value;
             warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger });
             const versionSpec = packageVersion ?? 'latest';
             const { runtimePlatform } = global;
@@ -178,6 +184,7 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                     ctx,
                     deviceRunSessionId,
                     logger,
+                    maxDurationSeconds,
                     signal,
                     idleTimeout: maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
                         ? {

package/dist/steps/functions/startServeSimRemoteSession.js

@@ -11,9 +11,17 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
         name: 'Start serve-sim remote session',
         __metricsId: 'eas/start_serve_sim_remote_session',
         supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
-        fn: async ({ logger }, { env, signal }) => {
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'max_duration_seconds',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+            }),
+        ],
+        fn: async ({ logger }, { inputs, env, signal }) => {
             const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
             const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
+            const maxDurationSeconds = inputs.max_duration_seconds?.value;
             logger.info('Starting serve-sim remote session.');
             await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
             const serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
@@ -34,6 +42,7 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
                     ctx,
                     deviceRunSessionId,
                     logger,
+                    maxDurationSeconds,
                     signal,
                 });
             }

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

@@ -0,0 +1,10 @@
+import { type bunyan } from '@expo/logger';
+import { type CustomBuildContext } from '../../customBuildContext';
+import { type DeviceRunSessionEventCollection } from './deviceRunSessionEvents';
+export declare function startAppiumEventCollectionAsync({ ctx, deviceRunSessionId, appiumUrl, logger, pollIntervalMs, }: {
+    ctx: CustomBuildContext;
+    deviceRunSessionId: string;
+    appiumUrl: string;
+    logger: bunyan;
+    pollIntervalMs?: number;
+}): Promise<DeviceRunSessionEventCollection>;

package/dist/steps/utils/appiumEvents.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startAppiumEventCollectionAsync = startAppiumEventCollectionAsync;
+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 promises_1 = require("node:timers/promises");
+const zod_1 = require("zod");
+const turtleFetch_1 = require("../../utils/turtleFetch");
+const deviceRunSessionEvents_1 = require("./deviceRunSessionEvents");
+const APPIUM_REQUEST_TIMEOUT_MS = 10_000;
+const POLL_INTERVAL_MS = 1_000;
+const GET_LOG_EVENTS_COMMAND = 'getLogEvents';
+const AppiumSessionsResponseSchema = zod_1.z.object({
+    value: zod_1.z.array(zod_1.z.object({ id: zod_1.z.string() }).passthrough()),
+});
+const AppiumCommandSchema = zod_1.z.object({
+    appiumSessionId: zod_1.z.string(),
+    cmd: zod_1.z.string(),
+    startTime: zod_1.z.number(),
+    endTime: zod_1.z.number(),
+});
+const AppiumEventsResponseSchema = zod_1.z.object({
+    value: zod_1.z.object({
+        commands: zod_1.z.array(AppiumCommandSchema.omit({ appiumSessionId: true })),
+    }),
+});
+async function startAppiumEventCollectionAsync({ ctx, deviceRunSessionId, appiumUrl, logger, pollIntervalMs = POLL_INTERVAL_MS, }) {
+    const eventDirectory = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'eas-appium-events-'));
+    const eventFile = node_path_1.default.join(eventDirectory, 'commands.ndjson');
+    await node_fs_1.default.promises.writeFile(eventFile, '');
+    let eventCollection;
+    try {
+        eventCollection = await (0, deviceRunSessionEvents_1.startDeviceRunSessionEventCollectionAsync)({
+            ctx,
+            deviceRunSessionId,
+            logger,
+            pollIntervalMs,
+            source: createAppiumEventSource(eventFile),
+        });
+    }
+    catch (error) {
+        await node_fs_1.default.promises.rm(eventDirectory, { recursive: true, force: true });
+        throw error;
+    }
+    const observedCommandKeys = new Set();
+    const controller = new AbortController();
+    let didReportCollectionFailure = false;
+    const collectSafelyAsync = async () => {
+        try {
+            await collectAppiumCommandsAsync({
+                appiumUrl,
+                eventFile,
+                observedCommandKeys,
+                logger,
+            });
+            didReportCollectionFailure = false;
+        }
+        catch (error) {
+            if (!didReportCollectionFailure) {
+                didReportCollectionFailure = true;
+                logger.warn({ err: error }, 'Could not collect Appium events.');
+            }
+        }
+    };
+    const pollingPromise = (async () => {
+        while (!controller.signal.aborted) {
+            await collectSafelyAsync();
+            try {
+                await (0, promises_1.setTimeout)(pollIntervalMs, undefined, { signal: controller.signal });
+            }
+            catch (error) {
+                if (!controller.signal.aborted) {
+                    throw error;
+                }
+            }
+        }
+    })().catch(error => {
+        logger.warn({ err: error }, 'Appium event collection poller failed.');
+    });
+    return {
+        getLastEventObservedAt: eventCollection.getLastEventObservedAt,
+        stopAsync: async () => {
+            controller.abort();
+            await pollingPromise;
+            await collectSafelyAsync();
+            try {
+                await eventCollection.stopAsync();
+            }
+            finally {
+                await node_fs_1.default.promises.rm(eventDirectory, { recursive: true, force: true });
+            }
+        },
+    };
+}
+function createAppiumEventSource(eventFile) {
+    return {
+        producer: 'appium',
+        findEventFilesAsync: async () => [eventFile],
+        sourceKeyForFile: file => node_path_1.default.basename(file, node_path_1.default.extname(file)),
+        parseLine: ({ line, sourceKey, sequenceNumber, deviceRunSessionId }) => {
+            if (!line.trim()) {
+                return {};
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                return { failure: 'invalid-json' };
+            }
+            const result = AppiumCommandSchema.safeParse(parsed);
+            if (!result.success) {
+                return { failure: 'invalid-event' };
+            }
+            const command = result.data;
+            const operationId = `${sourceKey}:${sequenceNumber}`;
+            return {
+                event: {
+                    v: 1,
+                    eventId: `appium:${deviceRunSessionId}:${operationId}`,
+                    ts: new Date(command.endTime).toISOString(),
+                    producer: 'appium',
+                    type: 'operation.completed',
+                    operationId,
+                    durationMs: Math.max(0, command.endTime - command.startTime),
+                    summary: command.cmd,
+                    data: {
+                        command: command.cmd,
+                        appiumSessionId: command.appiumSessionId,
+                    },
+                },
+            };
+        },
+    };
+}
+async function collectAppiumCommandsAsync({ appiumUrl, eventFile, observedCommandKeys, logger, }) {
+    const response = await (0, turtleFetch_1.turtleFetch)(new URL('appium/sessions', appiumUrl).toString(), 'GET', {
+        timeout: APPIUM_REQUEST_TIMEOUT_MS,
+        retries: 0,
+        logger,
+    });
+    const sessions = AppiumSessionsResponseSchema.parse(await response.json()).value;
+    const newCommands = [];
+    const pendingCommandKeys = new Set();
+    for (const { id: appiumSessionId } of sessions) {
+        const eventsResponse = await (0, turtleFetch_1.turtleFetch)(new URL(`session/${encodeURIComponent(appiumSessionId)}/appium/events`, appiumUrl).toString(), 'POST', {
+            json: {},
+            timeout: APPIUM_REQUEST_TIMEOUT_MS,
+            retries: 0,
+            logger,
+        });
+        const commands = AppiumEventsResponseSchema.parse(await eventsResponse.json()).value.commands;
+        for (const command of commands) {
+            const key = [appiumSessionId, command.cmd, command.startTime, command.endTime].join(':');
+            if (command.cmd === GET_LOG_EVENTS_COMMAND ||
+                observedCommandKeys.has(key) ||
+                pendingCommandKeys.has(key)) {
+                continue;
+            }
+            pendingCommandKeys.add(key);
+            newCommands.push({ key, command: { appiumSessionId, ...command } });
+        }
+    }
+    if (newCommands.length === 0) {
+        return;
+    }
+    await node_fs_1.default.promises.appendFile(eventFile, `${newCommands.map(({ command }) => JSON.stringify(command)).join('\n')}\n`);
+    for (const { key } of newCommands) {
+        observedCommandKeys.add(key);
+    }
+}

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

@@ -25,10 +25,11 @@ export type DeviceRunSessionIdleTimeout = {
      */
     getLastEventObservedAt: () => Date | undefined;
 };
-export declare function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId, logger, signal, idleTimeout, }: {
+export declare function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId, logger, maxDurationSeconds, signal: cancelSignal, idleTimeout, }: {
     ctx: CustomBuildContext;
     deviceRunSessionId: string;
     logger: bunyan;
+    maxDurationSeconds?: number;
     signal?: AbortSignal;
     idleTimeout?: DeviceRunSessionIdleTimeout;
 }): Promise<void>;

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -63,6 +63,7 @@ const zod_1 = require("zod");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_net_1 = require("node:net");
+const node_timers_1 = require("node:timers");
 const promises_1 = require("node:timers/promises");
 const sentry_1 = require("../../sentry");
 const retry_1 = require("../../utils/retry");
@@ -152,58 +153,83 @@ async function selectXcodeDeveloperDirectoryAsync({ env, logger, }) {
         stdio: ['ignore', 'pipe', 'pipe'],
     });
 }
-async function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId, logger, signal, idleTimeout, }) {
-    logger.info(`Remote session is live. Polling device run session ${deviceRunSessionId} until it is stopped.`);
-    if (idleTimeout) {
-        logger.info(`The session stops automatically after ${idleTimeout.maxIdleTimeMinutes} minute(s) without activity.`);
-    }
-    let pollErrorCount = 0;
-    let lastActivityAt = new Date();
-    while (!signal?.aborted) {
+async function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId, logger, maxDurationSeconds, signal: cancelSignal, idleTimeout, }) {
+    const durationAbortController = new AbortController();
+    const signal = cancelSignal
+        ? AbortSignal.any([cancelSignal, durationAbortController.signal])
+        : durationAbortController.signal;
+    // Nothing to wait for if the step was already aborted before we started;
+    // return before logging so we don't claim to be polling a session we never poll.
+    if (signal.aborted) {
+        return;
+    }
+    const durationTimeout = maxDurationSeconds === undefined
+        ? undefined
+        : (0, node_timers_1.setTimeout)(() => {
+            logger.info(`Device run session ${deviceRunSessionId} reached its maximum duration.`);
+            durationAbortController.abort();
+        }, maxDurationSeconds * 1_000);
+    try {
+        logger.info(`Remote session is live. Polling device run session ${deviceRunSessionId} until it is stopped.`);
+        if (durationTimeout !== undefined) {
+            logger.info(`The device run session will stop automatically after ${maxDurationSeconds} seconds.`);
+        }
         if (idleTimeout) {
-            const lastEventObservedAt = idleTimeout.getLastEventObservedAt();
-            if (lastEventObservedAt && lastEventObservedAt > lastActivityAt) {
-                lastActivityAt = lastEventObservedAt;
-            }
-            if (Date.now() - lastActivityAt.getTime() >= idleTimeout.maxIdleTimeMinutes * 60_000) {
-                logger.info(`Device run session ${deviceRunSessionId} had no activity for ` +
-                    `${idleTimeout.maxIdleTimeMinutes} minute(s) (max idle time). Stopping the session.`);
-                await ensureDeviceRunSessionStoppedSafelyAsync({ ctx, deviceRunSessionId, logger });
-                return;
-            }
+            logger.info(`The session stops automatically after ${idleTimeout.maxIdleTimeMinutes} minute(s) without activity.`);
         }
-        try {
-            const result = await ctx.graphqlClient
-                .query(DEVICE_RUN_SESSION_STATUS_QUERY, { deviceRunSessionId })
-                .toPromise();
-            if (result.error) {
-                throw result.error;
-            }
-            const status = result.data?.deviceRunSessions?.byId?.status;
-            if (!status) {
-                throw new Error(`Device run session ${deviceRunSessionId} status response was missing.`);
+        let pollErrorCount = 0;
+        let lastActivityAt = new Date();
+        while (!signal.aborted) {
+            if (idleTimeout) {
+                const lastEventObservedAt = idleTimeout.getLastEventObservedAt();
+                if (lastEventObservedAt && lastEventObservedAt > lastActivityAt) {
+                    lastActivityAt = lastEventObservedAt;
+                }
+                if (Date.now() - lastActivityAt.getTime() >= idleTimeout.maxIdleTimeMinutes * 60_000) {
+                    logger.info(`Device run session ${deviceRunSessionId} had no activity for ` +
+                        `${idleTimeout.maxIdleTimeMinutes} minute(s) (max idle time). Stopping the session.`);
+                    await ensureDeviceRunSessionStoppedSafelyAsync({ ctx, deviceRunSessionId, logger });
+                    return;
+                }
             }
-            pollErrorCount = 0;
-            if (status === 'STOPPED') {
-                logger.info(`Device run session ${deviceRunSessionId} was stopped.`);
-                return;
+            try {
+                const result = await ctx.graphqlClient
+                    .query(DEVICE_RUN_SESSION_STATUS_QUERY, { deviceRunSessionId })
+                    .toPromise();
+                if (result.error) {
+                    throw result.error;
+                }
+                const status = result.data?.deviceRunSessions?.byId?.status;
+                if (!status) {
+                    throw new Error(`Device run session ${deviceRunSessionId} status response was missing.`);
+                }
+                pollErrorCount = 0;
+                if (status === 'STOPPED') {
+                    logger.info(`Device run session ${deviceRunSessionId} was stopped.`);
+                    return;
+                }
+                if (status === 'ERRORED') {
+                    throw new eas_build_job_1.SystemError(`Device run session ${deviceRunSessionId} errored.`);
+                }
             }
-            if (status === 'ERRORED') {
-                throw new eas_build_job_1.SystemError(`Device run session ${deviceRunSessionId} errored.`);
+            catch (err) {
+                if (err instanceof eas_build_job_1.SystemError) {
+                    throw err;
+                }
+                const error = err instanceof Error ? err : new Error(String(err));
+                pollErrorCount += 1;
+                if (pollErrorCount === 1 || pollErrorCount % 5 === 0) {
+                    sentry_1.Sentry.capture('Could not poll device run session status', error, { level: 'warning' });
+                    logger.warn({ err: error, failedStatusPollCount: pollErrorCount }, 'Could not poll device run session status; will retry.');
+                }
             }
+            await sleepUntilAbortedAsync(DEVICE_RUN_SESSION_STATUS_POLL_INTERVAL_MS, signal);
         }
-        catch (err) {
-            if (err instanceof eas_build_job_1.SystemError) {
-                throw err;
-            }
-            const error = err instanceof Error ? err : new Error(String(err));
-            pollErrorCount += 1;
-            if (pollErrorCount === 1 || pollErrorCount % 5 === 0) {
-                sentry_1.Sentry.capture('Could not poll device run session status', error, { level: 'warning' });
-                logger.warn({ err: error, failedStatusPollCount: pollErrorCount }, 'Could not poll device run session status; will retry.');
-            }
+    }
+    finally {
+        if (durationTimeout !== undefined) {
+            (0, node_timers_1.clearTimeout)(durationTimeout);
         }
-        await sleepUntilAbortedAsync(DEVICE_RUN_SESSION_STATUS_POLL_INTERVAL_MS, signal);
     }
 }
 // Best effort: when this fails, the caller still tears the session down and the
@@ -529,7 +555,7 @@ async function startServeSimWithTunnelAsync(ctx, { baseDomain, env, logger, time
         await waitForServeSimReadyAsync({ serveSim, port, timeoutMs });
         const tunnel = await startNgrokTunnelAsync({
             port,
-            subdomainPrefix: 'serve-sim',
+            subdomainPrefix: 'web-preview',
             baseDomain,
             authtoken: getNgrokAuthtokenOrThrow(env),
             logger,

package/dist/utils/AndroidEmulatorUtils.d.ts

@@ -42,6 +42,7 @@ export declare namespace AndroidEmulatorUtils {
         emulatorPromise: SpawnPromise<SpawnResult>;
         serialId: AndroidDeviceSerialId;
         logcatOutputPath: string;
+        emulatorOutputPath: string;
     }>;
     function waitForReadyAsync({ serialId, env, timeoutMs, logger, }: {
         serialId: AndroidDeviceSerialId;