@expo/build-tools 21.0.3 → 21.1.0

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

@@ -1,3 +1,11 @@
+import { type bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
 import { type CustomBuildContext } from '../../customBuildContext';
 export declare function createStartAgentDeviceRemoteSessionBuildFunction(ctx: CustomBuildContext): BuildFunction;
+export declare function stopAgentDeviceEventCollectionSafelyAsync({ eventCollection, deviceRunSessionId, logger, }: {
+    eventCollection: {
+        stopAsync: () => Promise<void>;
+    };
+    deviceRunSessionId: string;
+    logger: bunyan;
+}): Promise<void>;

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStartAgentDeviceRemoteSessionBuildFunction = createStartAgentDeviceRemoteSessionBuildFunction;
+exports.stopAgentDeviceEventCollectionSafelyAsync = stopAgentDeviceEventCollectionSafelyAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
 const steps_1 = require("@expo/steps");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
@@ -12,11 +13,13 @@ 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 remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
 const AGENT_DEVICE_PACKAGE_NAME = 'agent-device';
 const AGENT_DEVICE_REPO_URL = 'https://github.com/callstack/agent-device.git';
 const SRC_DIR = '/tmp/agent-device-src';
-const DAEMON_JSON_PATH = node_path_1.default.join(node_os_1.default.homedir(), '.agent-device', 'daemon.json');
+const AGENT_DEVICE_STATE_DIR = node_path_1.default.join(node_os_1.default.homedir(), '.agent-device');
+const DAEMON_JSON_PATH = node_path_1.default.join(AGENT_DEVICE_STATE_DIR, 'daemon.json');
 const STARTUP_TIMEOUT_MS = 60_000;
 const AGENT_DEVICE_DAEMON_ENV = {
     AGENT_DEVICE_DAEMON_SERVER_MODE: 'http',
@@ -93,15 +96,44 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 daemonToken,
                 logger,
             });
-            await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
+            const eventCollection = await (0, deviceRunSessionEvents_1.startAgentDeviceEventCollectionAsync)({
                 ctx,
                 deviceRunSessionId,
+                stateDir: AGENT_DEVICE_STATE_DIR,
                 logger,
-                signal,
             });
+            try {
+                await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    logger,
+                    signal,
+                });
+            }
+            finally {
+                await stopAgentDeviceEventCollectionSafelyAsync({
+                    eventCollection,
+                    deviceRunSessionId,
+                    logger,
+                });
+            }
         },
     });
 }
+async function stopAgentDeviceEventCollectionSafelyAsync({ 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 agent-device session event collection', error, {
+            level: 'warning',
+            tags: { phase: 'agent-device-event-collection', operation: 'stop' },
+            extras: { deviceRunSessionId },
+        });
+        logger.warn({ err: error }, 'Could not finish agent-device session event collection.');
+    }
+}
 async function startAgentDeviceDaemonAsync({ packageVersion, env, logger, }) {
     const packageSpec = createAgentDevicePackageSpec(packageVersion);
     try {

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

@@ -0,0 +1,23 @@
+import { type bunyan } from '@expo/logger';
+import { type CustomBuildContext } from '../../customBuildContext';
+export type DeviceRunSessionEvent = {
+    v: 1;
+    eventId: string;
+    ts: string;
+    producer: string;
+    type: string;
+    operationId?: string;
+    outcome?: 'success' | 'failure';
+    durationMs?: number;
+    summary: string;
+    data?: Record<string, unknown>;
+};
+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/deviceRunSessionEvents.js

@@ -0,0 +1,311 @@
+"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 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 {
+      createEventLogUploadSession(deviceRunSessionId: $deviceRunSessionId) {
+        uploadSession {
+          url
+          headers
+        }
+      }
+    }
+  }
+`);
+async function startAgentDeviceEventCollectionAsync({ ctx, deviceRunSessionId, stateDir, logger, pollIntervalMs = POLL_INTERVAL_MS, }) {
+    let didReportEventLogFailure = false;
+    const reportEventLogFailure = (error, operation) => {
+        if (didReportEventLogFailure) {
+            return;
+        }
+        didReportEventLogFailure = true;
+        sentry_1.Sentry.capture('Could not persist device run session events', error, {
+            level: 'warning',
+            tags: { phase: 'device-run-session-event-collection', operation },
+            extras: { deviceRunSessionId },
+        });
+    };
+    let eventLogStream;
+    try {
+        const uploadSession = await createEventLogUploadSessionAsync(ctx, deviceRunSessionId);
+        eventLogStream = new RemoteLoggerStream_1.default({
+            logger,
+            uploadMethod: { signedUrl: uploadSession },
+            options: {
+                uploadIntervalMs: UPLOAD_INTERVAL_MS,
+            },
+        });
+        await eventLogStream.init();
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        logger.warn({ err: error }, 'Could not start device run session event collection.');
+        reportEventLogFailure(error, 'setup');
+        return { stopAsync: async () => { } };
+    }
+    const states = new Map();
+    const controller = new AbortController();
+    let parseFailureCount = 0;
+    const parseFailureCounts = {
+        'invalid-json': 0,
+        'invalid-event': 0,
+    };
+    let didReportCollectionFailure = false;
+    const collectAsync = async () => {
+        const eventFiles = await findAgentDeviceEventFilesAsync(stateDir);
+        await Promise.all(eventFiles.map(async (eventFile) => {
+            const state = states.get(eventFile) ?? {
+                offset: 0,
+                nextSequenceNumber: 1,
+                nextLineNumber: 1,
+                pending: '',
+                decoder: new node_string_decoder_1.StringDecoder('utf8'),
+            };
+            states.set(eventFile, state);
+            await collectEventFileAsync({
+                eventFile,
+                state,
+                deviceRunSessionId,
+                writeEvent: event => eventLogStream.write(event),
+                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', {
+                        level: 'warning',
+                        tags: { phase: 'agent-device-event-collection', reason: failure },
+                        extras: { deviceRunSessionId, lineNumber },
+                    });
+                },
+            });
+        }));
+    };
+    const collectSafelyAsync = async () => {
+        try {
+            await collectAsync();
+            didReportCollectionFailure = false;
+        }
+        catch (err) {
+            if (didReportCollectionFailure) {
+                return;
+            }
+            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, {
+                level: 'warning',
+                tags: { phase: 'agent-device-event-collection' },
+                extras: { deviceRunSessionId },
+            });
+        }
+    };
+    const pollingPromise = (async () => {
+        while (!controller.signal.aborted) {
+            await collectSafelyAsync();
+            try {
+                await (0, promises_1.setTimeout)(pollIntervalMs, undefined, { signal: controller.signal });
+            }
+            catch (err) {
+                if (!controller.signal.aborted) {
+                    throw err;
+                }
+            }
+        }
+    })()
+        .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, {
+            level: 'warning',
+            tags: { phase: 'agent-device-event-collection', operation: 'poll' },
+            extras: { deviceRunSessionId },
+        });
+    })
+        .catch(() => {
+        // A diagnostics failure must not recreate an unhandled rejection in this best-effort poller.
+    });
+    return {
+        stopAsync: async () => {
+            controller.abort();
+            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', {
+                    level: 'warning',
+                    tags: { phase: 'agent-device-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');
+            }
+        },
+    };
+}
+async function createEventLogUploadSessionAsync(ctx, deviceRunSessionId) {
+    const result = await ctx.graphqlClient
+        .mutation(CREATE_DEVICE_RUN_SESSION_EVENT_LOG_UPLOAD_SESSION_MUTATION, {
+        deviceRunSessionId,
+    })
+        .toPromise();
+    if (result.error) {
+        throw new eas_build_job_1.SystemError(`Failed to create device run session event log upload session: ${result.error.message}`, { cause: result.error });
+    }
+    const uploadSession = result.data.deviceRunSession.createEventLogUploadSession.uploadSession;
+    return {
+        url: uploadSession.url,
+        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, }) {
+    let fileSize;
+    try {
+        fileSize = (await node_fs_1.default.promises.stat(eventFile)).size;
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return;
+        }
+        throw err;
+    }
+    if (fileSize < state.offset) {
+        state.offset = 0;
+        state.pending = '';
+        state.decoder = new node_string_decoder_1.StringDecoder('utf8');
+    }
+    if (fileSize === state.offset) {
+        return;
+    }
+    const handle = await node_fs_1.default.promises.open(eventFile, 'r');
+    try {
+        const buffer = new Uint8Array(new ArrayBuffer(fileSize - state.offset));
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, state.offset);
+        state.offset += bytesRead;
+        const text = state.decoder.write(buffer.subarray(0, bytesRead));
+        const lines = `${state.pending}${text}`.split('\n');
+        state.pending = lines.pop() ?? '';
+        for (const line of lines) {
+            const lineNumber = state.nextLineNumber++;
+            const sequenceNumber = state.nextSequenceNumber++;
+            const { event, failure } = parseAgentDeviceEvent(line);
+            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);
+        }
+    }
+    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.0.3",
+  "version": "21.1.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.0.3",
+    "@expo/eas-build-job": "21.1.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.0.3",
+    "@expo/steps": "21.1.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": "62d46fece55ab5b27c2a572fc91158214b9ae96b"
+  "gitHead": "24272d8a5f080584f9688d19c2a4a4d06f9448ac"
 }