@expo/build-tools 21.6.0 → 21.7.0

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -37,6 +37,11 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'max_idle_time_minutes',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+            }),
         ],
         fn: async ({ logger, global }, { inputs, env, signal }) => {
             // Fail fast before any expensive setup if the injected env
@@ -47,6 +52,8 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
             const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
             const ngrokAuthtoken = (0, remoteDeviceRunSession_1.getNgrokAuthtokenOrThrow)(env);
             const packageVersion = inputs.package_version.value;
+            // A missing or non-positive value disables the idle timeout (opt-in feature).
+            const maxIdleTimeMinutes = inputs.max_idle_time_minutes.value;
             const { runtimePlatform } = global;
             logger.info(`Starting agent-device remote session (version: ${packageVersion ?? 'latest'}, runtime: ${runtimePlatform}).`);
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
@@ -109,6 +116,12 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                     deviceRunSessionId,
                     logger,
                     signal,
+                    idleTimeout: maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
+                        ? {
+                            maxIdleTimeMinutes,
+                            getLastEventObservedAt: eventCollection.getLastEventObservedAt,
+                        }
+                        : undefined,
                 });
             }
             finally {

package/dist/steps/functions/startArgentRemoteSession.js

@@ -52,6 +52,11 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'max_idle_time_minutes',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+            }),
         ],
         fn: async ({ logger, global }, { inputs, env, signal }) => {
             // Fail fast before any expensive setup if the injected env
@@ -62,6 +67,8 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
             const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
             const ngrokAuthtoken = (0, remoteDeviceRunSession_1.getNgrokAuthtokenOrThrow)(env);
             const packageVersion = inputs.package_version.value;
+            // A missing or non-positive value disables the idle timeout (opt-in feature).
+            const maxIdleTimeMinutes = inputs.max_idle_time_minutes.value;
             warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger });
             const versionSpec = packageVersion ?? 'latest';
             const { runtimePlatform } = global;
@@ -172,6 +179,12 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                     deviceRunSessionId,
                     logger,
                     signal,
+                    idleTimeout: maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
+                        ? {
+                            maxIdleTimeMinutes,
+                            getLastEventObservedAt: eventCollection.getLastEventObservedAt,
+                        }
+                        : undefined,
                 });
             }
             finally {

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

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

package/dist/steps/utils/argentArtifacts.js

@@ -21,6 +21,17 @@ const deviceRunSessionArtifacts_1 = require("./deviceRunSessionArtifacts");
 const ARGENT_ARTIFACT_UPLOAD_POLL_INTERVAL_MS = 5_000;
 const ARGENT_ARTIFACT_UPLOAD_CLEANUP_TIMEOUT_MS = 30_000;
 const ARGENT_ARTIFACT_FETCH_TIMEOUT_MS = 10_000;
+// Kinds the EAS dashboard groups device run session artifacts by. Only media types the dashboard
+// renders specially are mapped; anything else stays unclassified and lands in its "Other" group.
+// Note that these kinds only affect grouping and labelling. The dashboard gates its inline video
+// player on the `__eas_screen_recording` metadata flag, which Argent artifacts deliberately do not
+// set, so a `screen-recording` kind here does not add a player to the session page.
+const ARGENT_ARTIFACT_KIND_BY_MIME_TYPE = new Map([
+    ['image/png', 'screenshot'],
+    ['image/jpeg', 'screenshot'],
+    ['video/mp4', 'screen-recording'],
+    ['video/quicktime', 'screen-recording'],
+]);
 const ArgentArtifactSchema = zod_1.z.object({
     id: zod_1.z.string(),
     filename: zod_1.z.string(),
@@ -30,6 +41,16 @@ const ArgentArtifactSchema = zod_1.z.object({
 const ArgentArtifactsListResponseSchema = zod_1.z.object({
     artifacts: zod_1.z.array(ArgentArtifactSchema),
 });
+function getArgentArtifactKind(artifact) {
+    // Directories are repackaged as a tarball before upload, so the reported media type describes the
+    // contents rather than the file we actually store.
+    if (artifact.isDirectory) {
+        return undefined;
+    }
+    // Media types are case-insensitive and may carry parameters, e.g. `image/png; charset=binary`.
+    const mediaType = artifact.mimeType.split(';')[0].trim().toLowerCase();
+    return ARGENT_ARTIFACT_KIND_BY_MIME_TYPE.get(mediaType);
+}
 async function pollArgentArtifactsForUploadAsync(ctx, { deviceRunSessionId, toolsUrl, toolsAuthToken, logger, signal, }) {
     logger.info('Started polling Argent tool-server for artifacts.');
     const seenArtifactIds = new Set();
@@ -126,7 +147,7 @@ async function uploadArgentArtifactAsync(ctx, { deviceRunSessionId, toolsUrl, to
             artifactId: artifact.id,
             name: `${filename} (${artifact.id})`,
             filename,
-            kind: undefined,
+            kind: getArgentArtifactKind(artifact),
             size,
             stream: (0, node_fs_1.createReadStream)(temporaryArtifactPath),
         });

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

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

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

@@ -53,12 +53,20 @@ export type DeviceRunSessionEventSource = {
         deviceRunSessionId: string;
     }) => DeviceRunSessionEventParseResult;
 };
+export type DeviceRunSessionEventCollection = {
+    stopAsync: () => Promise<void>;
+    /**
+     * Local arrival time of the most recently collected event, or `undefined`
+     * when no event has been observed yet. Uses the collector's clock rather
+     * than the event's embedded timestamp so producer clock skew cannot affect
+     * idle detection.
+     */
+    getLastEventObservedAt: () => Date | undefined;
+};
 export declare function startDeviceRunSessionEventCollectionAsync({ ctx, deviceRunSessionId, source, logger, pollIntervalMs, }: {
     ctx: CustomBuildContext;
     deviceRunSessionId: string;
     source: DeviceRunSessionEventSource;
     logger: bunyan;
     pollIntervalMs?: number;
-}): Promise<{
-    stopAsync: () => Promise<void>;
-}>;
+}): Promise<DeviceRunSessionEventCollection>;

package/dist/steps/utils/deviceRunSessionEvents.js

@@ -58,7 +58,13 @@ async function startDeviceRunSessionEventCollectionAsync({ ctx, deviceRunSession
         const error = err instanceof Error ? err : new Error(String(err));
         logger.warn({ err: error }, 'Could not persist device run session events to the artifact.');
         reportEventLogFailure(error, 'setup');
-        return { stopAsync: async () => { } };
+        return {
+            stopAsync: async () => { },
+            // Collection is disabled, so session activity is invisible here. Report
+            // fresh activity so an enabled idle timeout never stops a session it
+            // cannot observe.
+            getLastEventObservedAt: () => new Date(),
+        };
     }
     let didReportRealtimeLogFailure = false;
     const reportRealtimeLogFailure = (error, operation) => {
@@ -83,6 +89,7 @@ async function startDeviceRunSessionEventCollectionAsync({ ctx, deviceRunSession
     }
     const states = new Map();
     const controller = new AbortController();
+    let lastEventObservedAt;
     let parseFailureCount = 0;
     const parseFailureCounts = {
         'invalid-json': 0,
@@ -106,6 +113,7 @@ async function startDeviceRunSessionEventCollectionAsync({ ctx, deviceRunSession
                 source,
                 deviceRunSessionId,
                 writeEvent: event => {
+                    lastEventObservedAt = new Date();
                     eventLogStream.write(event);
                     realtimeLogStream?.write({ ...event, logId: event.eventId });
                 },
@@ -170,6 +178,7 @@ async function startDeviceRunSessionEventCollectionAsync({ ctx, deviceRunSession
         // A diagnostics failure must not recreate an unhandled rejection in this best-effort poller.
     });
     return {
+        getLastEventObservedAt: () => lastEventObservedAt,
         stopAsync: async () => {
             controller.abort();
             await pollingPromise;

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

@@ -15,11 +15,22 @@ export declare function selectXcodeDeveloperDirectoryAsync({ env, logger, }: {
     env: BuildStepEnv;
     logger: bunyan;
 }): Promise<void>;
-export declare function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId, logger, signal, }: {
+export type DeviceRunSessionIdleTimeout = {
+    /** Stop the session after this many minutes without observed activity. */
+    maxIdleTimeMinutes: number;
+    /**
+     * Local arrival time of the most recent session event, or `undefined` when
+     * no event has been observed yet. The idle clock starts when the wait
+     * begins, so a session nobody ever connects to still times out.
+     */
+    getLastEventObservedAt: () => Date | undefined;
+};
+export declare function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId, logger, signal, idleTimeout, }: {
     ctx: CustomBuildContext;
     deviceRunSessionId: string;
     logger: bunyan;
     signal?: AbortSignal;
+    idleTimeout?: DeviceRunSessionIdleTimeout;
 }): Promise<void>;
 /**
  * Install ffmpeg when the runtime does not already provide it, so argent's

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -97,6 +97,16 @@ const DEVICE_RUN_SESSION_STATUS_QUERY = (0, gql_tada_1.graphql)(`
     }
   }
 `);
+const ENSURE_DEVICE_RUN_SESSION_STOPPED_MUTATION = (0, gql_tada_1.graphql)(`
+  mutation EnsureDeviceRunSessionStopped($deviceRunSessionId: ID!) {
+    deviceRunSession {
+      ensureDeviceRunSessionStopped(deviceRunSessionId: $deviceRunSessionId) {
+        id
+        status
+      }
+    }
+  }
+`);
 const DEVICE_RUN_SESSION_STATUS_POLL_INTERVAL_MS = 5_000;
 function getDeviceRunSessionIdOrThrow(env) {
     const deviceRunSessionId = env.DEVICE_RUN_SESSION_ID;
@@ -142,10 +152,26 @@ async function selectXcodeDeveloperDirectoryAsync({ env, logger, }) {
         stdio: ['ignore', 'pipe', 'pipe'],
     });
 }
-async function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId, logger, signal, }) {
+async function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId, logger, signal, idleTimeout, }) {
     logger.info(`Remote session is live. Polling device run session ${deviceRunSessionId} until it is stopped.`);
+    if (idleTimeout) {
+        logger.info(`The session stops automatically after ${idleTimeout.maxIdleTimeMinutes} minute(s) without activity.`);
+    }
     let pollErrorCount = 0;
+    let lastActivityAt = new Date();
     while (!signal?.aborted) {
+        if (idleTimeout) {
+            const lastEventObservedAt = idleTimeout.getLastEventObservedAt();
+            if (lastEventObservedAt && lastEventObservedAt > lastActivityAt) {
+                lastActivityAt = lastEventObservedAt;
+            }
+            if (Date.now() - lastActivityAt.getTime() >= idleTimeout.maxIdleTimeMinutes * 60_000) {
+                logger.info(`Device run session ${deviceRunSessionId} had no activity for ` +
+                    `${idleTimeout.maxIdleTimeMinutes} minute(s) (max idle time). Stopping the session.`);
+                await ensureDeviceRunSessionStoppedSafelyAsync({ ctx, deviceRunSessionId, logger });
+                return;
+            }
+        }
         try {
             const result = await ctx.graphqlClient
                 .query(DEVICE_RUN_SESSION_STATUS_QUERY, { deviceRunSessionId })
@@ -180,6 +206,26 @@ async function waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId, lo
         await sleepUntilAbortedAsync(DEVICE_RUN_SESSION_STATUS_POLL_INTERVAL_MS, signal);
     }
 }
+// Best effort: when this fails, the caller still tears the session down and the
+// job run finishes, which clients also treat as the session ending.
+async function ensureDeviceRunSessionStoppedSafelyAsync({ ctx, deviceRunSessionId, logger, }) {
+    try {
+        const result = await ctx.graphqlClient
+            .mutation(ENSURE_DEVICE_RUN_SESSION_STOPPED_MUTATION, { deviceRunSessionId })
+            .toPromise();
+        if (result.error) {
+            throw result.error;
+        }
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        sentry_1.Sentry.capture('Could not mark idle device run session as stopped', error, {
+            level: 'warning',
+            extras: { deviceRunSessionId },
+        });
+        logger.warn({ err: error }, `Could not mark device run session ${deviceRunSessionId} as stopped. The session job ends anyway.`);
+    }
+}
 async function sleepUntilAbortedAsync(timeoutMs, signal) {
     try {
         await (0, promises_1.setTimeout)(timeoutMs, undefined, signal ? { signal } : undefined);

package/dist/steps/utils/serveSimMetricsArtifacts.js

@@ -20,17 +20,19 @@ async function uploadServeSimMetricsFileAsync(ctx, { deviceRunSessionId, udid, f
         logger.info(`serve-sim metrics file for ${udid} is empty; skipping upload.`);
         return;
     }
+    const deviceName = typeof metadata?.deviceName === 'string' ? metadata.deviceName : undefined;
     try {
-        logger.info(`Uploading serve-sim metrics for ${udid} (${(0, artifacts_1.formatBytes)(size)}).`);
+        logger.info(`Uploading serve-sim metrics for ${deviceName ?? udid} (${(0, artifacts_1.formatBytes)(size)}).`);
         await (0, deviceRunSessionArtifacts_1.uploadDeviceRunSessionArtifactAsync)(ctx, {
             deviceRunSessionId,
             artifactId: `metrics-${udid}`,
-            name: `Performance metrics (${udid.slice(0, 8)})`,
+            name: `Performance metrics (${deviceName ?? udid.slice(0, 8)})`,
             filename: METRICS_ARTIFACT_FILENAME,
             kind: 'performance-metrics',
             metadata: {
                 __eas_type: 'performance-metrics',
                 udid,
+                ...(deviceName && { deviceName }),
                 ...(metadata && {
                     hostCores: metadata.hostCores,
                     sampleIntervalMs: metadata.sampleIntervalMs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "21.6.0",
+  "version": "21.7.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -100,5 +100,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "866febb1ba2a66e33859ae8a6c67bd845e8ce8a6"
+  "gitHead": "f923181857de80919ec7ee9861c9b71c2ee5635d"
 }