@expo/build-tools 21.4.0 → 21.5.0

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -59,50 +59,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 +112,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();
             }
         },
     });

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;