@expo/build-tools 21.3.0 → 21.5.0

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

@@ -1,5 +1,11 @@
 import { type bunyan } from '@expo/logger';
 import { type CustomBuildContext } from '../../customBuildContext';
+/**
+ * The normalized, producer-agnostic event shape uploaded to the API server.
+ * Every remote-session producer (agent-device, argent, ...) tails its own
+ * event log and maps its records onto this common contract so consumers render
+ * a single unified session timeline.
+ */
 export type DeviceRunSessionEvent = {
     v: 1;
     eventId: string;
@@ -12,10 +18,45 @@ export type DeviceRunSessionEvent = {
     summary: string;
     data?: Record<string, unknown>;
 };
-export declare function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, stateDir, logger, pollIntervalMs, }: {
+export type DeviceRunSessionEventParseFailure = 'invalid-json' | 'invalid-event';
+export type DeviceRunSessionEventParseResult = {
+    event?: DeviceRunSessionEvent;
+    failure?: DeviceRunSessionEventParseFailure;
+};
+/**
+ * Producer-specific adapter plugged into the generic collection engine. It only
+ * has to say where its event files live and how to turn one raw NDJSON line
+ * into a {@link DeviceRunSessionEvent}; the engine owns tailing, upload, polling
+ * and failure reporting.
+ */
+export type DeviceRunSessionEventSource = {
+    /**
+     * Stable producer identifier, e.g. `agent-device` or `argent`. Also used
+     * verbatim in diagnostic messages, which are phrased so it never needs
+     * recasing.
+     */
+    producer: string;
+    /** Discover the NDJSON event files to tail (absolute paths). */
+    findEventFilesAsync: () => Promise<string[]>;
+    /** Namespace component of the event ID derived from a tailed file path. */
+    sourceKeyForFile: (eventFile: string) => string;
+    /**
+     * Parse one raw NDJSON line. `sequenceNumber` is monotonic per file (kept
+     * stable across truncations) and `sourceKey` namespaces the event ID so an ID
+     * is never reused during collection. Blank lines should return an empty
+     * result so they neither emit an event nor count as a parse failure.
+     */
+    parseLine: (args: {
+        line: string;
+        sourceKey: string;
+        sequenceNumber: number;
+        deviceRunSessionId: string;
+    }) => DeviceRunSessionEventParseResult;
+};
+export declare function startDeviceRunSessionEventCollectionAsync({ ctx, deviceRunSessionId, source, logger, pollIntervalMs, }: {
     ctx: CustomBuildContext;
     deviceRunSessionId: string;
-    stateDir: string;
+    source: DeviceRunSessionEventSource;
     logger: bunyan;
     pollIntervalMs?: number;
 }): Promise<{

package/dist/steps/utils/deviceRunSessionEvents.js

@@ -3,36 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startAgentDeviceEventCollectionAsync = startAgentDeviceEventCollectionAsync;
+exports.startDeviceRunSessionEventCollectionAsync = startDeviceRunSessionEventCollectionAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
 const gql_tada_1 = require("gql.tada");
 const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
 const node_string_decoder_1 = require("node:string_decoder");
 const promises_1 = require("node:timers/promises");
-const zod_1 = require("zod");
+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 AGENT_DEVICE_EVENT_KIND_TO_TYPE = {
-    'request.started': 'operation.started',
-    'request.finished': 'operation.completed',
-    'action.recorded': 'interaction.recorded',
-};
-const AgentDeviceEventSchema = zod_1.z
-    .object({
-    version: zod_1.z.number(),
-    ts: zod_1.z.string(),
-    session: zod_1.z.string(),
-    kind: zod_1.z.string(),
-    requestId: zod_1.z.string().optional().catch(undefined),
-    command: zod_1.z.string().optional().catch(undefined),
-    status: zod_1.z.string().optional().catch(undefined),
-    summary: zod_1.z.string().optional().catch(undefined),
-    details: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional().catch(undefined),
-})
-    .passthrough();
+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 {
@@ -45,7 +28,8 @@ const CREATE_DEVICE_RUN_SESSION_EVENT_LOG_UPLOAD_SESSION_MUTATION = (0, gql_tada
     }
   }
 `);
-async function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, stateDir, logger, pollIntervalMs = POLL_INTERVAL_MS, }) {
+async function startDeviceRunSessionEventCollectionAsync({ ctx, deviceRunSessionId, source, logger, pollIntervalMs = POLL_INTERVAL_MS, }) {
+    const { producer } = source;
     let didReportEventLogFailure = false;
     const reportEventLogFailure = (error, operation) => {
         if (didReportEventLogFailure) {
@@ -54,7 +38,7 @@ async function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, s
         didReportEventLogFailure = true;
         sentry_1.Sentry.capture('Could not persist device run session events', error, {
             level: 'warning',
-            tags: { phase: 'device-run-session-event-collection', operation },
+            tags: { phase: 'device-run-session-event-collection', operation, producer },
             extras: { deviceRunSessionId },
         });
     };
@@ -72,10 +56,31 @@ async function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, s
     }
     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;
@@ -85,7 +90,7 @@ async function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, s
     };
     let didReportCollectionFailure = false;
     const collectAsync = async () => {
-        const eventFiles = await findAgentDeviceEventFilesAsync(stateDir);
+        const eventFiles = await source.findEventFilesAsync();
         await Promise.all(eventFiles.map(async (eventFile) => {
             const state = states.get(eventFile) ?? {
                 offset: 0,
@@ -98,18 +103,22 @@ async function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, s
             await collectEventFileAsync({
                 eventFile,
                 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;
                     if (parseFailureCount !== 1) {
                         return;
                     }
-                    logger.warn({ agentDeviceEventParseFailure: failure, lineNumber }, 'Could not parse an agent-device event log record.');
-                    sentry_1.Sentry.capture('Could not parse an agent-device event log record', {
+                    logger.warn({ producer, eventParseFailure: failure, lineNumber }, `Could not parse an ${producer} event log record.`);
+                    sentry_1.Sentry.capture(`Could not parse an ${producer} event log record`, {
                         level: 'warning',
-                        tags: { phase: 'agent-device-event-collection', reason: failure },
+                        tags: { phase: `${producer}-event-collection`, reason: failure },
                         extras: { deviceRunSessionId, lineNumber },
                     });
                 },
@@ -127,10 +136,10 @@ async function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, s
             }
             didReportCollectionFailure = true;
             const error = err instanceof Error ? err : new Error(String(err));
-            logger.warn({ err: error }, 'Could not collect agent-device events.');
-            sentry_1.Sentry.capture('Could not collect agent-device events', error, {
+            logger.warn({ err: error }, `Could not collect ${producer} events.`);
+            sentry_1.Sentry.capture(`Could not collect ${producer} events`, error, {
                 level: 'warning',
-                tags: { phase: 'agent-device-event-collection' },
+                tags: { phase: `${producer}-event-collection` },
                 extras: { deviceRunSessionId },
             });
         }
@@ -150,10 +159,10 @@ async function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, s
     })()
         .catch(err => {
         const error = err instanceof Error ? err : new Error(String(err));
-        logger.warn({ err: error }, 'Agent-device event collection poller failed.');
-        sentry_1.Sentry.capture('Agent-device event collection poller failed', error, {
+        logger.warn({ err: error }, `Event collection poller for ${producer} failed.`);
+        sentry_1.Sentry.capture(`Event collection poller for ${producer} failed`, error, {
             level: 'warning',
-            tags: { phase: 'agent-device-event-collection', operation: 'poll' },
+            tags: { phase: `${producer}-event-collection`, operation: 'poll' },
             extras: { deviceRunSessionId },
         });
     })
@@ -166,23 +175,54 @@ async function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, s
             await pollingPromise;
             await collectSafelyAsync();
             if (parseFailureCount > 1) {
-                logger.warn({ agentDeviceEventParseFailures: parseFailureCounts, parseFailureCount }, `Could not parse ${parseFailureCount} agent-device event log records.`);
-                sentry_1.Sentry.capture('Could not parse multiple agent-device event log records', {
+                logger.warn({ producer, eventParseFailures: parseFailureCounts, parseFailureCount }, `Could not parse ${parseFailureCount} ${producer} event log records.`);
+                sentry_1.Sentry.capture(`Could not parse multiple ${producer} event log records`, {
                     level: 'warning',
-                    tags: { phase: 'agent-device-event-collection' },
+                    tags: { phase: `${producer}-event-collection` },
                     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
@@ -199,23 +239,7 @@ async function createEventLogUploadSessionAsync(ctx, deviceRunSessionId) {
         headers: uploadSession.headers,
     };
 }
-async function findAgentDeviceEventFilesAsync(stateDir) {
-    const sessionsDir = node_path_1.default.join(stateDir, 'sessions');
-    let entries;
-    try {
-        entries = await node_fs_1.default.promises.readdir(sessionsDir, { withFileTypes: true });
-    }
-    catch (err) {
-        if (err.code === 'ENOENT') {
-            return [];
-        }
-        throw err;
-    }
-    return entries
-        .filter(entry => entry.isDirectory())
-        .map(entry => node_path_1.default.join(sessionsDir, entry.name, 'events.ndjson'));
-}
-async function collectEventFileAsync({ eventFile, state, deviceRunSessionId, writeEvent, onParseFailure, }) {
+async function collectEventFileAsync({ eventFile, state, source, deviceRunSessionId, writeEvent, onParseFailure, }) {
     let fileSize;
     try {
         fileSize = (await node_fs_1.default.promises.stat(eventFile)).size;
@@ -234,6 +258,7 @@ async function collectEventFileAsync({ eventFile, state, deviceRunSessionId, wri
     if (fileSize === state.offset) {
         return;
     }
+    const sourceKey = source.sourceKeyForFile(eventFile);
     const handle = await node_fs_1.default.promises.open(eventFile, 'r');
     try {
         const buffer = new Uint8Array(new ArrayBuffer(fileSize - state.offset));
@@ -245,67 +270,22 @@ async function collectEventFileAsync({ eventFile, state, deviceRunSessionId, wri
         for (const line of lines) {
             const lineNumber = state.nextLineNumber++;
             const sequenceNumber = state.nextSequenceNumber++;
-            const { event, failure } = parseAgentDeviceEvent(line);
+            const { event, failure } = source.parseLine({
+                line,
+                sourceKey,
+                sequenceNumber,
+                deviceRunSessionId,
+            });
             if (failure) {
                 onParseFailure({ failure, lineNumber });
             }
             if (!event) {
                 continue;
             }
-            const deviceRunSessionEvent = normalizeAgentDeviceEvent({
-                event,
-                sequenceNumber,
-                sourceSessionDirectory: node_path_1.default.basename(node_path_1.default.dirname(eventFile)),
-                deviceRunSessionId,
-            });
-            writeEvent(deviceRunSessionEvent);
+            writeEvent(event);
         }
     }
     finally {
         await handle.close();
     }
 }
-function parseAgentDeviceEvent(line) {
-    if (!line.trim()) {
-        return {};
-    }
-    try {
-        const result = AgentDeviceEventSchema.safeParse(JSON.parse(line));
-        return result.success ? { event: result.data } : { failure: 'invalid-event' };
-    }
-    catch {
-        return { failure: 'invalid-json' };
-    }
-}
-function normalizeAgentDeviceEvent({ event, sequenceNumber, sourceSessionDirectory, deviceRunSessionId, }) {
-    const type = AGENT_DEVICE_EVENT_KIND_TO_TYPE[event.kind] ?? event.kind;
-    const durationMs = event.details?.durationMs;
-    const outcome = event.status === 'ok' ? 'success' : event.status === 'error' ? 'failure' : undefined;
-    const summary = event.summary ??
-        (event.kind === 'request.started'
-            ? `Started ${event.command ?? 'activity'}`
-            : event.kind === 'request.finished'
-                ? `Finished ${event.command ?? 'activity'}`
-                : event.kind === 'action.recorded'
-                    ? `Recorded ${event.command ?? 'activity'}`
-                    : `${event.kind}${event.command ? `: ${event.command}` : ''}`);
-    return {
-        v: 1,
-        // Consumers use eventId to deduplicate events across polls. Keep the per-file sequence
-        // monotonic across source-file truncations so an ID is never reused during collection.
-        eventId: `agent-device:${deviceRunSessionId}:${sourceSessionDirectory}:${sequenceNumber}`,
-        ts: event.ts,
-        producer: 'agent-device',
-        type,
-        ...(event.requestId ? { operationId: event.requestId } : {}),
-        ...(outcome ? { outcome } : {}),
-        ...(typeof durationMs === 'number' ? { durationMs } : {}),
-        summary,
-        data: {
-            ...event.details,
-            session: event.session,
-            sourceVersion: event.version,
-            ...(event.status ? { sourceStatus: event.status } : {}),
-        },
-    };
-}

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;