@expo/build-tools 21.0.2 → 21.1.0

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/dist/{gcs → storage}/retry.d.ts

@@ -5,7 +5,7 @@ type RetryOptions = {
     shouldRetryOnError: (error: unknown) => boolean;
     shouldRetryOnResponse: (response: Response) => boolean;
 };
-export declare function retryOnGCSUploadFailure(fn: (attemptCount: number) => Promise<Response>, { retries, retryIntervalMs, }: {
+export declare function retryOnUploadFailure(fn: (attemptCount: number) => Promise<Response>, { retries, retryIntervalMs, }: {
     retries: RetryOptions['retries'];
     retryIntervalMs: RetryOptions['retryIntervalMs'];
 }): Promise<Response>;

package/dist/{gcs → storage}/retry.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.retryOnGCSUploadFailure = retryOnGCSUploadFailure;
+exports.retryOnUploadFailure = retryOnUploadFailure;
 // based on https://github.com/googleapis/nodejs-storage/blob/8ab50804fc7bae3bbd159bbb4adf65c02215b11b/src/storage.ts#L284-L320
-async function retryOnGCSUploadFailure(fn, { retries, retryIntervalMs, }) {
+async function retryOnUploadFailure(fn, { retries, retryIntervalMs, }) {
     return await retry(fn, {
         retries,
         retryIntervalMs,

package/dist/storage/uploadWithSignedUrl.d.ts

@@ -0,0 +1,12 @@
+import { Readable } from 'stream';
+export type SignedUrl = {
+    url: string;
+    headers: Record<string, string>;
+};
+export type UploadWithSignedUrlParams = {
+    signedUrl: SignedUrl;
+    srcGeneratorAsync: () => Promise<Readable>;
+    retryIntervalMs?: number;
+    retries?: number;
+};
+export declare function uploadWithSignedUrl({ signedUrl, srcGeneratorAsync, retries, retryIntervalMs, }: UploadWithSignedUrlParams): Promise<string>;

package/dist/{gcs/client.js → storage/uploadWithSignedUrl.js}

@@ -33,40 +33,36 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GCS = void 0;
+exports.uploadWithSignedUrl = uploadWithSignedUrl;
 const node_fetch_1 = __importStar(require("node-fetch"));
 const url_1 = require("url");
 const retry_1 = require("./retry");
-var GCS;
-(function (GCS) {
-    async function uploadWithSignedUrl({ signedUrl, srcGeneratorAsync, retries = 2, retryIntervalMs = 30_000, }) {
-        let resp;
-        try {
-            resp = await (0, retry_1.retryOnGCSUploadFailure)(async () => {
-                const src = await srcGeneratorAsync();
-                return await (0, node_fetch_1.default)(signedUrl.url, {
-                    method: 'PUT',
-                    headers: signedUrl.headers,
-                    body: src,
-                });
-            }, { retries, retryIntervalMs });
-        }
-        catch (err) {
-            if (err instanceof node_fetch_1.FetchError) {
-                throw new Error(`Failed to upload the file, reason: ${err.code}`);
-            }
-            throw err;
+async function uploadWithSignedUrl({ signedUrl, srcGeneratorAsync, retries = 2, retryIntervalMs = 30_000, }) {
+    let resp;
+    try {
+        resp = await (0, retry_1.retryOnUploadFailure)(async () => {
+            const src = await srcGeneratorAsync();
+            return await (0, node_fetch_1.default)(signedUrl.url, {
+                method: 'PUT',
+                headers: signedUrl.headers,
+                body: src,
+            });
+        }, { retries, retryIntervalMs });
+    }
+    catch (err) {
+        if (err instanceof node_fetch_1.FetchError) {
+            throw new Error(`Failed to upload the file, reason: ${err.code}`);
         }
-        if (!resp.ok) {
-            let body;
-            try {
-                body = await resp.text();
-            }
-            catch { }
-            throw new Error(`Failed to upload file: status: ${resp.status} status text: ${resp.statusText}, body: ${body}`);
+        throw err;
+    }
+    if (!resp.ok) {
+        let body;
+        try {
+            body = await resp.text();
         }
-        const url = new url_1.URL(signedUrl.url);
-        return `${url.protocol}//${url.host}${url.pathname}`;
+        catch { }
+        throw new Error(`Failed to upload file: status: ${resp.status} status text: ${resp.statusText}, body: ${body}`);
     }
-    GCS.uploadWithSignedUrl = uploadWithSignedUrl;
-})(GCS || (exports.GCS = GCS = {}));
+    const url = new url_1.URL(signedUrl.url);
+    return `${url.protocol}//${url.host}${url.pathname}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "21.0.2",
+  "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.2",
+    "@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.2",
+    "@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": "e9ebc41413ae2b5c7b4b92e91f45e9f65e3dbd23"
+  "gitHead": "24272d8a5f080584f9688d19c2a4a4d06f9448ac"
 }

package/dist/gcs/client.d.ts

@@ -1,15 +0,0 @@
-import { Readable } from 'stream';
-interface UploadWithSignedUrlParams {
-    signedUrl: GCS.SignedUrl;
-    srcGeneratorAsync: () => Promise<Readable>;
-    retryIntervalMs?: number;
-    retries?: number;
-}
-export declare namespace GCS {
-    type SignedUrl = {
-        url: string;
-        headers: Record<string, string>;
-    };
-    function uploadWithSignedUrl({ signedUrl, srcGeneratorAsync, retries, retryIntervalMs, }: UploadWithSignedUrlParams): Promise<string>;
-}
-export {};