@expo/build-tools 21.3.0 → 21.4.0

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -13,7 +13,7 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const sentry_1 = require("../../sentry");
 const agentDeviceArtifacts_1 = require("../utils/agentDeviceArtifacts");
-const deviceRunSessionEvents_1 = require("../utils/deviceRunSessionEvents");
+const agentDeviceEvents_1 = require("../utils/agentDeviceEvents");
 const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
 const AGENT_DEVICE_PACKAGE_NAME = 'agent-device';
 const AGENT_DEVICE_REPO_URL = 'https://github.com/callstack/agent-device.git';
@@ -96,7 +96,7 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 daemonToken,
                 logger,
             });
-            const eventCollection = await (0, deviceRunSessionEvents_1.startAgentDeviceEventCollectionAsync)({
+            const eventCollection = await (0, agentDeviceEvents_1.startAgentDeviceEventCollectionAsync)({
                 ctx,
                 deviceRunSessionId,
                 stateDir: AGENT_DEVICE_STATE_DIR,

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

@@ -2,7 +2,7 @@ import { type bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
 import { z } from 'zod';
 import { CustomBuildContext } from '../../customBuildContext';
-export declare const MIN_ARGENT_REMOTE_SESSION_VERSION = "0.12.0";
+export declare const MIN_ARGENT_REMOTE_SESSION_VERSION = "0.16.0";
 declare const ArgentToolServerStateSchema: z.ZodObject<{
     port: z.ZodNumber;
     pid: z.ZodNumber;
@@ -10,6 +10,13 @@ declare const ArgentToolServerStateSchema: z.ZodObject<{
 }, z.core.$strip>;
 type ArgentToolServerState = z.infer<typeof ArgentToolServerStateSchema>;
 export declare function createStartArgentRemoteSessionBuildFunction(ctx: CustomBuildContext): BuildFunction;
+export declare function stopArgentEventCollectionSafelyAsync({ eventCollection, deviceRunSessionId, logger, }: {
+    eventCollection: {
+        stopAsync: () => Promise<void>;
+    };
+    deviceRunSessionId: string;
+    logger: bunyan;
+}): Promise<void>;
 export declare function warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger, }: {
     packageVersion: string | undefined;
     logger: bunyan;

package/dist/steps/functions/startArgentRemoteSession.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MIN_ARGENT_REMOTE_SESSION_VERSION = void 0;
 exports.createStartArgentRemoteSessionBuildFunction = createStartArgentRemoteSessionBuildFunction;
+exports.stopArgentEventCollectionSafelyAsync = stopArgentEventCollectionSafelyAsync;
 exports.warnIfArgentPackageVersionCannotBeVerified = warnIfArgentPackageVersionCannotBeVerified;
 exports.waitForArgentToolServerStateAsync = waitForArgentToolServerStateAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
@@ -19,11 +20,20 @@ const sentry_1 = require("../../sentry");
 const processes_1 = require("../../utils/processes");
 const retry_1 = require("../../utils/retry");
 const argentArtifacts_1 = require("../utils/argentArtifacts");
+const argentEvents_1 = require("../utils/argentEvents");
 const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
 const ARGENT_PACKAGE_NAME = '@swmansion/argent';
-exports.MIN_ARGENT_REMOTE_SESSION_VERSION = '0.12.0';
+// 0.16.0 is the first version that exposes the tool-server event log flag; keeping the floor
+// here lets us enable it (and the artifacts list endpoint) unconditionally below.
+exports.MIN_ARGENT_REMOTE_SESSION_VERSION = '0.16.0';
 const ARGENT_ARTIFACTS_LIST_ENDPOINT_FLAG = 'artifacts-list-endpoint';
+// Tells the tool-server to write its structured event log so we can collect session events.
+const ARGENT_EVENT_LOG_FLAG = 'tool-server-event-log';
 const ARGENT_STATE_DIR = node_path_1.default.join(node_os_1.default.homedir(), '.argent');
+// Pin the event log path explicitly and hand the same value to the tool-server (via
+// ARGENT_EVENT_LOG) and the collector, so an ambient ARGENT_EVENT_LOG or a future change to
+// Argent's default can never make the two disagree.
+const ARGENT_EVENT_LOG_PATH = node_path_1.default.join(ARGENT_STATE_DIR, argentEvents_1.ARGENT_EVENT_LOG_FILENAME);
 const STARTUP_TIMEOUT_MS = 60_000;
 const ArgentToolServerStateSchema = zod_1.z.object({
     port: zod_1.z.number(),
@@ -61,6 +71,8 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
             }
             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.');
+            await (0, turtle_spawn_1.default)('bunx', [`${ARGENT_PACKAGE_NAME}@${versionSpec}`, 'enable', ARGENT_EVENT_LOG_FLAG], { env, logger });
             logger.info(`Launching ${ARGENT_PACKAGE_NAME}@${versionSpec} tool-server via bunx.`);
             // Keep Argent itself in foreground mode under the detached bunx process. This preserves
             // the bunx -> Argent CLI -> tool-server ancestry used to identify the matching state file.
@@ -76,7 +88,7 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                     '0',
                     '--force',
                 ],
-                env,
+                env: { ...env, ARGENT_EVENT_LOG: ARGENT_EVENT_LOG_PATH },
             });
             if (argentServer.pid === undefined) {
                 throw new eas_build_job_1.SystemError('Failed to start Argent: could not determine the PID of the launched process.');
@@ -109,6 +121,12 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 logger,
                 signal: artifactPollSignal,
             });
+            const eventCollection = await (0, argentEvents_1.startArgentEventCollectionAsync)({
+                ctx,
+                deviceRunSessionId,
+                eventLogPath: ARGENT_EVENT_LOG_PATH,
+                logger,
+            });
             try {
                 const publicToolsUrl = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
                     port: toolServerPort,
@@ -149,6 +167,7 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 });
             }
             finally {
+                await stopArgentEventCollectionSafelyAsync({ eventCollection, deviceRunSessionId, logger });
                 artifactPollAbortController.abort();
                 try {
                     await artifactPollingPromise;
@@ -162,6 +181,20 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
         },
     });
 }
+async function stopArgentEventCollectionSafelyAsync({ eventCollection, deviceRunSessionId, logger, }) {
+    try {
+        await eventCollection.stopAsync();
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        sentry_1.Sentry.capture('Could not finish argent session event collection', error, {
+            level: 'warning',
+            tags: { phase: 'argent-event-collection', operation: 'stop' },
+            extras: { deviceRunSessionId },
+        });
+        logger.warn({ err: error }, 'Could not finish argent session event collection.');
+    }
+}
 function warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger, }) {
     if (!packageVersion || packageVersion === 'latest') {
         return;

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

@@ -0,0 +1,11 @@
+import { type bunyan } from '@expo/logger';
+import { type CustomBuildContext } from '../../customBuildContext';
+export declare function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, stateDir, logger, pollIntervalMs, }: {
+    ctx: CustomBuildContext;
+    deviceRunSessionId: string;
+    stateDir: string;
+    logger: bunyan;
+    pollIntervalMs?: number;
+}): Promise<{
+    stopAsync: () => Promise<void>;
+}>;

package/dist/steps/utils/agentDeviceEvents.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startAgentDeviceEventCollectionAsync = startAgentDeviceEventCollectionAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+const deviceRunSessionEvents_1 = require("./deviceRunSessionEvents");
+const AGENT_DEVICE_PRODUCER = 'agent-device';
+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();
+async function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, stateDir, logger, pollIntervalMs, }) {
+    return (0, deviceRunSessionEvents_1.startDeviceRunSessionEventCollectionAsync)({
+        ctx,
+        deviceRunSessionId,
+        logger,
+        pollIntervalMs,
+        source: {
+            producer: AGENT_DEVICE_PRODUCER,
+            findEventFilesAsync: () => findAgentDeviceEventFilesAsync(stateDir),
+            sourceKeyForFile: eventFile => node_path_1.default.basename(node_path_1.default.dirname(eventFile)),
+            parseLine: ({ line, sourceKey, sequenceNumber, deviceRunSessionId }) => {
+                const { event, failure } = parseAgentDeviceEvent(line);
+                if (!event) {
+                    return { failure };
+                }
+                return {
+                    event: normalizeAgentDeviceEvent({
+                        event,
+                        sequenceNumber,
+                        sourceSessionDirectory: sourceKey,
+                        deviceRunSessionId,
+                    }),
+                };
+            },
+        },
+    });
+}
+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'));
+}
+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/argentEvents.d.ts

@@ -0,0 +1,12 @@
+import { type bunyan } from '@expo/logger';
+import { type CustomBuildContext } from '../../customBuildContext';
+export declare const ARGENT_EVENT_LOG_FILENAME = "tool-server-events.jsonl";
+export declare function startArgentEventCollectionAsync({ ctx, deviceRunSessionId, eventLogPath, logger, pollIntervalMs, }: {
+    ctx: CustomBuildContext;
+    deviceRunSessionId: string;
+    eventLogPath: string;
+    logger: bunyan;
+    pollIntervalMs?: number;
+}): Promise<{
+    stopAsync: () => Promise<void>;
+}>;

package/dist/steps/utils/argentEvents.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARGENT_EVENT_LOG_FILENAME = void 0;
+exports.startArgentEventCollectionAsync = startArgentEventCollectionAsync;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+const deviceRunSessionEvents_1 = require("./deviceRunSessionEvents");
+const ARGENT_PRODUCER = 'argent';
+// Argent's tool-server writes its event log to `~/.argent/tool-server-events.jsonl`
+// (its default $ARGENT_EVENT_LOG path) once the `tool-server-event-log` flag is on.
+exports.ARGENT_EVENT_LOG_FILENAME = 'tool-server-events.jsonl';
+// Argent records are bunyan log lines tagged with a `type`. Map the tool-lifecycle
+// types onto the shared operation vocabulary; anything else (service.*,
+// tool_server.*, future types) passes through unchanged, mirroring agent-device.
+const ARGENT_EVENT_TYPE_TO_TYPE = {
+    'tool.invoked': 'operation.started',
+    'tool.completed': 'operation.completed',
+    'tool.failed': 'operation.completed',
+};
+// Bunyan bookkeeping plus the fields we promote to the top level of a
+// DeviceRunSessionEvent — excluded from the free-form `data` bag so it carries
+// only the record's own context (toolId, serviceId, failureSignal, ...).
+const NON_DATA_KEYS = new Set([
+    'name',
+    'hostname',
+    'pid',
+    'v',
+    'time',
+    'msg',
+    'level',
+    'type',
+    'toolInvocationId',
+    'durationMs',
+]);
+const ArgentEventSchema = zod_1.z
+    .object({
+    time: zod_1.z.string(),
+    type: zod_1.z.string(),
+    // Argent's EventLogRecord requires `msg` and every emit site sets it to the
+    // human-readable description of the event, so it is our summary verbatim.
+    msg: zod_1.z.string(),
+    level: zod_1.z.number().optional().catch(undefined),
+    toolId: zod_1.z.string().optional().catch(undefined),
+    toolInvocationId: zod_1.z.string().optional().catch(undefined),
+    durationMs: zod_1.z.number().optional().catch(undefined),
+})
+    .passthrough();
+async function startArgentEventCollectionAsync({ ctx, deviceRunSessionId, eventLogPath, logger, pollIntervalMs, }) {
+    return (0, deviceRunSessionEvents_1.startDeviceRunSessionEventCollectionAsync)({
+        ctx,
+        deviceRunSessionId,
+        logger,
+        pollIntervalMs,
+        source: {
+            producer: ARGENT_PRODUCER,
+            findEventFilesAsync: () => findArgentEventFilesAsync(eventLogPath),
+            sourceKeyForFile: eventFile => node_path_1.default.basename(eventFile, node_path_1.default.extname(eventFile)),
+            parseLine: ({ line, sourceKey, sequenceNumber, deviceRunSessionId }) => {
+                const { event, failure } = parseArgentEvent(line);
+                if (!event) {
+                    return { failure };
+                }
+                return {
+                    event: normalizeArgentEvent({ event, sequenceNumber, sourceKey, deviceRunSessionId }),
+                };
+            },
+        },
+    });
+}
+async function findArgentEventFilesAsync(eventLogPath) {
+    try {
+        await node_fs_1.default.promises.access(eventLogPath);
+        return [eventLogPath];
+    }
+    catch (err) {
+        // The tool-server has not created the file yet — expected until the first event is written.
+        // Surface any other error (permissions, I/O) to the engine so it reaches Sentry.
+        if (err.code === 'ENOENT') {
+            return [];
+        }
+        throw err;
+    }
+}
+function parseArgentEvent(line) {
+    if (!line.trim()) {
+        return {};
+    }
+    try {
+        const result = ArgentEventSchema.safeParse(JSON.parse(line));
+        return result.success ? { event: result.data } : { failure: 'invalid-event' };
+    }
+    catch {
+        return { failure: 'invalid-json' };
+    }
+}
+function normalizeArgentEvent({ event, sequenceNumber, sourceKey, deviceRunSessionId, }) {
+    const type = ARGENT_EVENT_TYPE_TO_TYPE[event.type] ?? event.type;
+    const outcome = event.type === 'tool.completed'
+        ? 'success'
+        : event.type === 'tool.failed'
+            ? 'failure'
+            : undefined;
+    const data = {};
+    for (const [key, value] of Object.entries(event)) {
+        if (!NON_DATA_KEYS.has(key) && value !== undefined) {
+            data[key] = value;
+        }
+    }
+    data.sourceType = event.type;
+    if (typeof event.level === 'number') {
+        data.sourceLevel = event.level;
+    }
+    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: `argent:${deviceRunSessionId}:${sourceKey}:${sequenceNumber}`,
+        ts: event.time,
+        producer: 'argent',
+        type,
+        ...(event.toolInvocationId ? { operationId: event.toolInvocationId } : {}),
+        ...(outcome ? { outcome } : {}),
+        ...(typeof event.durationMs === 'number' ? { durationMs: event.durationMs } : {}),
+        summary: event.msg,
+        data,
+    };
+}

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,16 @@ 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 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 CREATE_DEVICE_RUN_SESSION_EVENT_LOG_UPLOAD_SESSION_MUTATION = (0, gql_tada_1.graphql)(`
   mutation CreateDeviceRunSessionEventLogUploadSession($deviceRunSessionId: ID!) {
     deviceRunSession {
@@ -45,7 +25,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 +35,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 },
         });
     };
@@ -85,7 +66,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,6 +79,7 @@ async function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, s
             await collectEventFileAsync({
                 eventFile,
                 state,
+                source,
                 deviceRunSessionId,
                 writeEvent: event => eventLogStream.write(event),
                 onParseFailure: ({ failure, lineNumber }) => {
@@ -106,10 +88,10 @@ async function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, s
                     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 +109,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 +132,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,10 +148,10 @@ 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 },
                 });
             }
@@ -199,23 +181,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 +200,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 +212,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "21.3.0",
+  "version": "21.4.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -39,14 +39,14 @@
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
     "@expo/downloader": "21.0.0",
-    "@expo/eas-build-job": "21.3.0",
+    "@expo/eas-build-job": "21.4.0",
     "@expo/env": "^0.4.0",
     "@expo/logger": "21.0.0",
     "@expo/package-manager": "1.9.10",
     "@expo/plist": "^0.3.5",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "21.3.0",
+    "@expo/steps": "21.4.0",
     "@expo/template-file": "21.0.2",
     "@expo/turtle-spawn": "21.0.0",
     "@expo/xcpretty": "^4.3.1",
@@ -100,5 +100,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "3784a503997fe6100c26034b9484295b09646214"
+  "gitHead": "dcc7201ca87cb28535990e28856409e91baa41fe"
 }