@expo/build-tools 21.4.0 → 21.5.1

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_AGENT_DEVICE_VERSION = void 0;
 exports.createStartAgentDeviceRemoteSessionBuildFunction = createStartAgentDeviceRemoteSessionBuildFunction;
 exports.stopAgentDeviceEventCollectionSafelyAsync = stopAgentDeviceEventCollectionSafelyAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
@@ -16,6 +17,7 @@ const agentDeviceArtifacts_1 = require("../utils/agentDeviceArtifacts");
 const agentDeviceEvents_1 = require("../utils/agentDeviceEvents");
 const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
 const AGENT_DEVICE_PACKAGE_NAME = 'agent-device';
+exports.DEFAULT_AGENT_DEVICE_VERSION = '0.20.3';
 const AGENT_DEVICE_REPO_URL = 'https://github.com/callstack/agent-device.git';
 const SRC_DIR = '/tmp/agent-device-src';
 const AGENT_DEVICE_STATE_DIR = node_path_1.default.join(node_os_1.default.homedir(), '.agent-device');
@@ -46,9 +48,9 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
             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 packageVersion = inputs.package_version.value ?? exports.DEFAULT_AGENT_DEVICE_VERSION;
             const { runtimePlatform } = global;
-            logger.info(`Starting agent-device remote session (version: ${packageVersion ?? 'latest'}, runtime: ${runtimePlatform}).`);
+            logger.info(`Starting agent-device remote session (version: ${packageVersion}, runtime: ${runtimePlatform}).`);
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
                 await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
             }
@@ -59,50 +61,51 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 daemonProcess,
             });
             logger.info(`Daemon is listening on port ${daemonPort}; loaded auth token.`);
-            const agentDeviceRemoteSessionUrl = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
+            const agentDeviceTunnel = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
                 port: daemonPort,
                 subdomainPrefix: 'agent-device',
                 baseDomain: ngrokTunnelDomain,
                 authtoken: ngrokAuthtoken,
                 logger,
             });
+            const agentDeviceRemoteSessionUrl = agentDeviceTunnel.url;
             logger.info(`Tunnel is ready at ${agentDeviceRemoteSessionUrl}.`);
-            // serve-sim is iOS-only — only launch it (and report a webPreviewUrl)
-            // on Darwin. Android sessions go without a preview URL.
-            let webPreviewUrl;
-            if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
-                const { previewUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
-                    baseDomain: ngrokTunnelDomain,
-                    env,
+            let serveSim;
+            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}`);
+                }
+                await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    remoteConfig: {
+                        agentDeviceRemoteSessionUrl,
+                        agentDeviceRemoteSessionToken: daemonToken,
+                        ...(serveSim ? { webPreviewUrl: serveSim.previewUrl } : {}),
+                    },
+                    logger,
+                });
+                void (0, agentDeviceArtifacts_1.pollAgentDeviceArtifactsForUploadAsync)(ctx, {
+                    deviceRunSessionId,
+                    daemonUrl: `http://127.0.0.1:${daemonPort}`,
+                    daemonToken,
+                    logger,
+                });
+                eventCollection = await (0, agentDeviceEvents_1.startAgentDeviceEventCollectionAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    stateDir: AGENT_DEVICE_STATE_DIR,
                     logger,
-                    timeoutMs: STARTUP_TIMEOUT_MS,
                 });
-                webPreviewUrl = previewUrl;
-                logger.info(`Web preview URL: ${webPreviewUrl}`);
-            }
-            await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
-                ctx,
-                deviceRunSessionId,
-                remoteConfig: {
-                    agentDeviceRemoteSessionUrl,
-                    agentDeviceRemoteSessionToken: daemonToken,
-                    ...(webPreviewUrl ? { webPreviewUrl } : {}),
-                },
-                logger,
-            });
-            void (0, agentDeviceArtifacts_1.pollAgentDeviceArtifactsForUploadAsync)(ctx, {
-                deviceRunSessionId,
-                daemonUrl: `http://127.0.0.1:${daemonPort}`,
-                daemonToken,
-                logger,
-            });
-            const eventCollection = await (0, agentDeviceEvents_1.startAgentDeviceEventCollectionAsync)({
-                ctx,
-                deviceRunSessionId,
-                stateDir: AGENT_DEVICE_STATE_DIR,
-                logger,
-            });
-            try {
                 await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
                     ctx,
                     deviceRunSessionId,
@@ -111,11 +114,18 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 });
             }
             finally {
-                await stopAgentDeviceEventCollectionSafelyAsync({
-                    eventCollection,
-                    deviceRunSessionId,
-                    logger,
-                });
+                if (serveSim) {
+                    await serveSim.stopAsync();
+                }
+                await agentDeviceTunnel.stopAsync();
+                if (eventCollection) {
+                    await stopAgentDeviceEventCollectionSafelyAsync({
+                        eventCollection,
+                        deviceRunSessionId,
+                        logger,
+                    });
+                }
+                await daemonProcess.stopAsync();
             }
         },
     });
@@ -164,7 +174,7 @@ async function startAgentDeviceDaemonAsync({ packageVersion, env, logger, }) {
             },
             extras: {
                 packageSpec,
-                packageVersion: packageVersion ?? 'latest',
+                packageVersion,
                 bunVersion,
                 bunInstallConfigured: Boolean(env.BUN_INSTALL?.trim()),
             },
@@ -174,9 +184,7 @@ async function startAgentDeviceDaemonAsync({ packageVersion, env, logger, }) {
     }
 }
 async function startAgentDeviceDaemonFromGitAsync({ packageVersion, env, logger, }) {
-    logger.info(packageVersion
-        ? `Cloning agent-device @ v${packageVersion} into ${SRC_DIR}.`
-        : `Cloning agent-device (latest) into ${SRC_DIR}.`);
+    logger.info(`Cloning agent-device @ v${packageVersion} into ${SRC_DIR}.`);
     await cloneAgentDeviceAsync({ packageVersion, env, logger });
     logger.info('Installing agent-device dependencies.');
     await (0, turtle_spawn_1.default)('bun', ['install', '--production'], {
@@ -193,7 +201,7 @@ async function startAgentDeviceDaemonFromGitAsync({ packageVersion, env, logger,
     });
 }
 async function cloneAgentDeviceAsync({ packageVersion, env, logger, }) {
-    const branchArgs = packageVersion ? ['--branch', `v${packageVersion}`] : [];
+    const branchArgs = ['--branch', `v${packageVersion}`];
     await (0, turtle_spawn_1.default)('git', ['clone', '--depth', '1', ...branchArgs, AGENT_DEVICE_REPO_URL, SRC_DIR], {
         env,
         logger,
@@ -225,7 +233,7 @@ async function getBunVersionForDiagnosticsAsync(env) {
     }
 }
 function createAgentDevicePackageSpec(packageVersion) {
-    const versionSpec = packageVersion ? packageVersion.replace(/^v(?=\d)/, '') : 'latest';
+    const versionSpec = packageVersion.replace(/^v(?=\d)/, '');
     return `${AGENT_DEVICE_PACKAGE_NAME}@${versionSpec}`;
 }
 function getGlobalAgentDeviceDaemonPath(env) {

package/dist/steps/functions/startArgentRemoteSession.js

@@ -69,6 +69,11 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
                 await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
             }
+            // Argent shells out to ffmpeg to record the screen. Installing it pulls a
+            // large Homebrew dependency tree, so do not block session readiness on it:
+            // the session comes up at its usual speed and only a recording started in
+            // the first moments misses ffmpeg. Never rejects, so `void` is safe.
+            void (0, remoteDeviceRunSession_1.ensureFfmpegInstalledAsync)({ runtimePlatform, env, logger });
             logger.info('Enabling the Argent artifacts list endpoint flag.');
             await (0, turtle_spawn_1.default)('bunx', [`${ARGENT_PACKAGE_NAME}@${versionSpec}`, 'enable', ARGENT_ARTIFACTS_LIST_ENDPOINT_FLAG], { env, logger });
             logger.info('Enabling the Argent tool-server event log flag.');
@@ -127,8 +132,10 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 eventLogPath: ARGENT_EVENT_LOG_PATH,
                 logger,
             });
+            let toolsTunnel;
+            let serveSim;
             try {
-                const publicToolsUrl = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
+                toolsTunnel = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
                     port: toolServerPort,
                     subdomainPrefix: 'argent',
                     baseDomain: ngrokTunnelDomain,
@@ -136,11 +143,12 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                     rewriteHostHeader: true,
                     logger,
                 });
+                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) {
-                    const serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
+                    serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
                         baseDomain: ngrokTunnelDomain,
                         env,
                         logger,
@@ -167,6 +175,12 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 });
             }
             finally {
+                if (serveSim) {
+                    await serveSim.stopAsync();
+                }
+                if (toolsTunnel) {
+                    await toolsTunnel.stopAsync();
+                }
                 await stopArgentEventCollectionSafelyAsync({ eventCollection, deviceRunSessionId, logger });
                 artifactPollAbortController.abort();
                 try {
@@ -177,6 +191,7 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                     sentry_1.Sentry.capture('Could not finish Argent remote session artifact polling', error);
                     logger.warn({ err: error }, 'Could not finish Argent remote session artifact polling.');
                 }
+                await argentServer.stopAsync();
             }
         },
     });

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

@@ -0,0 +1,2 @@
+import { BuildFunction } from '@expo/steps';
+export declare function createStartServeSimMetricsBuildFunction(): BuildFunction;

package/dist/steps/functions/startServeSimMetrics.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStartServeSimMetricsBuildFunction = createStartServeSimMetricsBuildFunction;
+const steps_1 = require("@expo/steps");
+const serveSimMetricsRecorder_1 = require("../utils/serveSimMetricsRecorder");
+function createStartServeSimMetricsBuildFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'start_serve_sim_metrics',
+        name: 'Start serve-sim metrics',
+        __metricsId: 'eas/start_serve_sim_metrics',
+        supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
+        fn: async ({ logger }) => {
+            await serveSimMetricsRecorder_1.ServeSimMetricsRecorder.startAsync({ logger });
+        },
+    });
+}

package/dist/steps/functions/startServeSimRemoteSession.js

@@ -16,25 +16,30 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
             const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
             logger.info('Starting serve-sim remote session.');
             await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
-            const { previewUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
+            const serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
                 baseDomain: ngrokTunnelDomain,
                 env,
                 logger,
                 timeoutMs: STARTUP_TIMEOUT_MS,
             });
-            logger.info(`Preview URL: ${previewUrl}`);
-            await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
-                ctx,
-                deviceRunSessionId,
-                remoteConfig: { previewUrl },
-                logger,
-            });
-            await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
-                ctx,
-                deviceRunSessionId,
-                logger,
-                signal,
-            });
+            logger.info(`Preview URL: ${serveSim.previewUrl}`);
+            try {
+                await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    remoteConfig: { previewUrl: serveSim.previewUrl },
+                    logger,
+                });
+                await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    logger,
+                    signal,
+                });
+            }
+            finally {
+                await serveSim.stopAsync();
+            }
         },
     });
 }

package/dist/steps/utils/agentDeviceArtifacts.js

@@ -68,7 +68,7 @@ async function pollAgentDeviceArtifactsForUploadAsync(ctx, { deviceRunSessionId,
             }
             const error = err instanceof Error ? err : new Error(String(err));
             listArtifactsErrorCount += 1;
-            if (listArtifactsErrorCount === 1 || listArtifactsErrorCount % 5 === 0) {
+            if (listArtifactsErrorCount % 5 === 0) {
                 sentry_1.Sentry.capture('Could not list agent-device remote session artifacts', error);
                 logger.warn({ err: error, failedArtifactListCount: listArtifactsErrorCount }, 'Could not list agent-device remote session artifacts.');
             }

package/dist/steps/utils/argentArtifacts.js

@@ -68,7 +68,7 @@ async function pollArgentArtifactsForUploadAsync(ctx, { deviceRunSessionId, tool
             }
             const error = err instanceof Error ? err : new Error(String(err));
             listArtifactsErrorCount += 1;
-            if (listArtifactsErrorCount === 1 || listArtifactsErrorCount % 5 === 0) {
+            if (listArtifactsErrorCount % 5 === 0) {
                 sentry_1.Sentry.capture('Could not list Argent remote session artifacts', error);
                 logger.warn({ err: error, failedArtifactListCount: listArtifactsErrorCount }, 'Could not list Argent remote session artifacts.');
             }

package/dist/steps/utils/deviceRunSessionEvents.js

@@ -9,10 +9,13 @@ const gql_tada_1 = require("gql.tada");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_string_decoder_1 = require("node:string_decoder");
 const promises_1 = require("node:timers/promises");
+const HttpLogStream_1 = __importDefault(require("../../logging/HttpLogStream"));
 const RemoteLoggerStream_1 = __importDefault(require("../../logging/RemoteLoggerStream"));
 const sentry_1 = require("../../sentry");
 const POLL_INTERVAL_MS = 1_000;
 const UPLOAD_INTERVAL_MS = 5_000;
+const EAS_LOGS_THREAD = 'session-events';
+const EAS_LOGS_BUFFER_RETENTION_MS = 30_000;
 const CREATE_DEVICE_RUN_SESSION_EVENT_LOG_UPLOAD_SESSION_MUTATION = (0, gql_tada_1.graphql)(`
   mutation CreateDeviceRunSessionEventLogUploadSession($deviceRunSessionId: ID!) {
     deviceRunSession {
@@ -53,10 +56,31 @@ async function startDeviceRunSessionEventCollectionAsync({ ctx, deviceRunSession
     }
     catch (err) {
         const error = err instanceof Error ? err : new Error(String(err));
-        logger.warn({ err: error }, 'Could not start device run session event collection.');
+        logger.warn({ err: error }, 'Could not persist device run session events to the artifact.');
         reportEventLogFailure(error, 'setup');
         return { stopAsync: async () => { } };
     }
+    let didReportRealtimeLogFailure = false;
+    const reportRealtimeLogFailure = (error, operation) => {
+        if (didReportRealtimeLogFailure) {
+            return;
+        }
+        didReportRealtimeLogFailure = true;
+        sentry_1.Sentry.capture('Could not publish device run session events in real time', error, {
+            level: 'warning',
+            tags: { phase: 'device-run-session-event-collection', operation, producer },
+            extras: { deviceRunSessionId },
+        });
+    };
+    let realtimeLogStream;
+    try {
+        realtimeLogStream = createRealtimeLogStream(ctx, logger);
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        logger.warn({ err: error }, 'Could not start publishing device run session events in real time.');
+        reportRealtimeLogFailure(error, 'setup');
+    }
     const states = new Map();
     const controller = new AbortController();
     let parseFailureCount = 0;
@@ -81,7 +105,10 @@ async function startDeviceRunSessionEventCollectionAsync({ ctx, deviceRunSession
                 state,
                 source,
                 deviceRunSessionId,
-                writeEvent: event => eventLogStream.write(event),
+                writeEvent: event => {
+                    eventLogStream.write(event);
+                    realtimeLogStream?.write({ ...event, logId: event.eventId });
+                },
                 onParseFailure: ({ failure, lineNumber }) => {
                     parseFailureCount += 1;
                     parseFailureCounts[failure] += 1;
@@ -155,16 +182,47 @@ async function startDeviceRunSessionEventCollectionAsync({ ctx, deviceRunSession
                     extras: { deviceRunSessionId, parseFailureCount, parseFailureCounts },
                 });
             }
-            try {
-                await eventLogStream.cleanUp();
-            }
-            catch (err) {
-                const error = err instanceof Error ? err : new Error(String(err));
-                logger.warn({ err: error }, 'Could not finish device run session event collection.');
-                reportEventLogFailure(error, 'cleanup');
-            }
+            await Promise.all([cleanUpEventLogStreamAsync(), cleanUpRealtimeLogStreamAsync()]);
         },
     };
+    async function cleanUpEventLogStreamAsync() {
+        try {
+            await eventLogStream.cleanUp();
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            logger.warn({ err: error }, 'Could not finish persisting device run session events.');
+            reportEventLogFailure(error, 'cleanup');
+        }
+    }
+    async function cleanUpRealtimeLogStreamAsync() {
+        try {
+            await realtimeLogStream?.cleanUp();
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            logger.warn({ err: error }, 'Could not finish publishing device run session events in real time.');
+            reportRealtimeLogFailure(error, 'cleanup');
+        }
+    }
+}
+function createRealtimeLogStream(ctx, logger) {
+    const baseUrl = ctx.env.EXPO_LOCAL
+        ? 'http://localhost:4999/logs/'
+        : ctx.env.EXPO_STAGING
+            ? 'https://staging-logs.expo.dev/logs/'
+            : undefined;
+    const jobRunId = ctx.env.EAS_BUILD_ID;
+    const robotAccessToken = ctx.job.secrets?.robotAccessToken;
+    if (!baseUrl || !jobRunId || !robotAccessToken) {
+        return undefined;
+    }
+    return new HttpLogStream_1.default({
+        url: new URL(`${jobRunId}/${EAS_LOGS_THREAD}`, baseUrl).toString(),
+        headers: { Authorization: `Bearer ${robotAccessToken}` },
+        logger,
+        bufferRetentionMs: EAS_LOGS_BUFFER_RETENTION_MS,
+    });
 }
 async function createEventLogUploadSessionAsync(ctx, deviceRunSessionId) {
     const result = await ctx.graphqlClient

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

@@ -1,5 +1,5 @@
 import { bunyan } from '@expo/logger';
-import { BuildStepEnv } from '@expo/steps';
+import { BuildRuntimePlatform, BuildStepEnv } from '@expo/steps';
 import { z } from 'zod';
 import { CustomBuildContext } from '../../customBuildContext';
 export declare function getDeviceRunSessionIdOrThrow(env: BuildStepEnv): string;
@@ -21,6 +21,26 @@ export declare function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSess
     logger: bunyan;
     signal?: AbortSignal;
 }): Promise<void>;
+/**
+ * Install ffmpeg when the runtime does not already provide it, so argent's
+ * `screen-recording-start` tool can encode a video. The worker images do not
+ * ship ffmpeg yet, so without this the tool fails with "`ffmpeg` was not found
+ * on PATH" — on macOS (iOS simulators) and Linux (Android emulators) alike.
+ *
+ * Best-effort by design: screen recording is one optional argent tool, so a
+ * failure here is logged and the session continues without it.
+ *
+ * The whole body is wrapped because the caller runs this in the background with
+ * `void`. There is no unhandledRejection handler in the worker, so a rejection
+ * escaping here would crash the process and take the live session with it.
+ * `spawn` is not an async function and can throw synchronously, which
+ * `asyncResult` cannot catch — it only wraps an already-created promise.
+ */
+export declare function ensureFfmpegInstalledAsync({ runtimePlatform, env, logger, }: {
+    runtimePlatform: BuildRuntimePlatform;
+    env: BuildStepEnv;
+    logger: bunyan;
+}): Promise<void>;
 /**
  * Translate Cloudflare ICE servers into serve-sim CLI flags: `--stun-url` (the
  * credential-less entries) and `--turn-url`/`--turn-username`/`--turn-credential`
@@ -51,6 +71,7 @@ export type DetachedProcessHandle = {
     /** PID of the directly spawned process, if the OS assigned one. */
     pid: number | undefined;
     getOutput: () => string;
+    stopAsync: () => Promise<void>;
 };
 export declare function spawnDetached({ command, args, cwd, env, }: {
     command: string;
@@ -58,14 +79,31 @@ export declare function spawnDetached({ command, args, cwd, env, }: {
     cwd?: string;
     env: BuildStepEnv;
 }): DetachedProcessHandle;
+export declare function metricsCorsOriginToServeSimArgs(env: BuildStepEnv): string[];
+export declare function createServeSimArgs({ port, turnArgs, metricsCorsArgs, }: {
+    port: number;
+    turnArgs?: string[];
+    metricsCorsArgs?: string[];
+}): string[];
+export declare function waitForServeSimReadyAsync({ serveSim, port, timeoutMs, }: {
+    serveSim: Pick<DetachedProcessHandle, 'pid' | 'getOutput'>;
+    port: number;
+    timeoutMs: number;
+}): Promise<void>;
+export type ServeSimPreviewHandle = {
+    previewUrl: string;
+    stopAsync: () => Promise<void>;
+};
 export declare function startServeSimWithTunnelAsync(ctx: CustomBuildContext, { baseDomain, env, logger, timeoutMs, }: {
     baseDomain: string;
     env: BuildStepEnv;
     logger: bunyan;
     timeoutMs: number;
-}): Promise<{
-    previewUrl: string;
-}>;
+}): Promise<ServeSimPreviewHandle>;
+export type NgrokTunnelHandle = {
+    url: string;
+    stopAsync: () => Promise<void>;
+};
 export declare function startNgrokTunnelAsync({ port, subdomainPrefix, baseDomain, authtoken, rewriteHostHeader, logger, }: {
     port: number;
     subdomainPrefix: string;
@@ -73,7 +111,7 @@ export declare function startNgrokTunnelAsync({ port, subdomainPrefix, baseDomai
     authtoken: string;
     rewriteHostHeader?: boolean;
     logger: bunyan;
-}): Promise<string>;
+}): Promise<NgrokTunnelHandle>;
 export declare function waitForFileAsync<T>({ filePath, timeoutMs, description, parse, }: {
     filePath: string;
     timeoutMs: number;