@expo/build-tools 21.5.1 → 21.7.0

package/dist/builders/custom.js

@@ -15,7 +15,6 @@ const projectSources_1 = require("../common/projectSources");
 const customBuildContext_1 = require("../customBuildContext");
 const datadog_1 = require("../datadog");
 const xcodeBuildLogs_1 = require("../ios/xcodeBuildLogs");
-const compositeFunctions_1 = require("../steps/compositeFunctions");
 const easFunctionGroups_1 = require("../steps/easFunctionGroups");
 const easFunctions_1 = require("../steps/easFunctions");
 const retry_1 = require("../utils/retry");
@@ -55,11 +54,13 @@ async function runCustomBuildAsync(ctx) {
                     steps: ctx.job.steps,
                     hooks: ctx.job.hooks,
                     // Eager for job steps (always run), lazy loader for hooks (running anchors only).
-                    compositeFunctionCatalog: await (0, compositeFunctions_1.buildCompositeFunctionCatalogAsync)(projectRoot, {
-                        steps: ctx.job.steps,
+                    compositeFunctionCatalog: await (0, steps_1.buildLocalCompositeFunctionCatalogAsync)(projectRoot, {
+                        rootSteps: ctx.job.steps,
+                        logger: ctx.logger,
+                    }),
+                    loadCompositeFunction: (0, steps_1.createLocalCompositeFunctionLoader)(projectRoot, {
                         logger: ctx.logger,
                     }),
-                    loadCompositeFunction: (0, compositeFunctions_1.createCompositeFunctionLoader)(projectRoot, ctx.logger),
                 })
                 : new steps_1.BuildConfigParser(globalContext, {
                     externalFunctions: easFunctions,

package/dist/common/jobHooks.js

@@ -4,7 +4,6 @@ exports.parseJobHooksAsync = parseJobHooksAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
 const steps_1 = require("@expo/steps");
 const customBuildContext_1 = require("../customBuildContext");
-const compositeFunctions_1 = require("../steps/compositeFunctions");
 const easFunctionGroups_1 = require("../steps/easFunctionGroups");
 const easFunctions_1 = require("../steps/easFunctions");
 /**
@@ -60,7 +59,7 @@ async function parseJobHooksAsync(ctx, wrappedAnchors) {
     const hookEntriesByKey = {};
     const orderedSteps = [];
     const compositeFunctionCatalog = {};
-    const loadCompositeFunction = (0, compositeFunctions_1.createCompositeFunctionLoader)(ctx.getReactNativeProjectDirectory(), ctx.logger);
+    const loadCompositeFunction = (0, steps_1.createLocalCompositeFunctionLoader)(ctx.getReactNativeProjectDirectory(), { logger: ctx.logger });
     for (const anchor of wrappedAnchors) {
         for (const side of ['before', 'after']) {
             const key = `${side}_${anchor}`;

package/dist/generic.js

@@ -11,7 +11,6 @@ const promises_1 = __importDefault(require("fs/promises"));
 const nullthrows_1 = __importDefault(require("nullthrows"));
 const projectSources_1 = require("./common/projectSources");
 const customBuildContext_1 = require("./customBuildContext");
-const compositeFunctions_1 = require("./steps/compositeFunctions");
 const easFunctionGroups_1 = require("./steps/easFunctionGroups");
 const easFunctions_1 = require("./steps/easFunctions");
 const outputs_1 = require("./utils/outputs");
@@ -38,8 +37,8 @@ async function runGenericJobAsync(ctx) {
         try {
             const projectRoot = ctx.getReactNativeProjectDirectory(customBuildCtx.projectSourceDirectory);
             // Eager for job steps (always run), lazy loader for hooks (running anchors only).
-            const compositeFunctionCatalog = await (0, compositeFunctions_1.buildCompositeFunctionCatalogAsync)(projectRoot, {
-                steps: ctx.job.steps,
+            const compositeFunctionCatalog = await (0, steps_1.buildLocalCompositeFunctionCatalogAsync)(projectRoot, {
+                rootSteps: ctx.job.steps,
                 logger: ctx.logger,
             });
             const parser = new steps_1.StepsConfigParser(globalContext, {
@@ -48,7 +47,9 @@ async function runGenericJobAsync(ctx) {
                 steps: ctx.job.steps,
                 hooks: ctx.job.hooks,
                 compositeFunctionCatalog,
-                loadCompositeFunction: (0, compositeFunctions_1.createCompositeFunctionLoader)(projectRoot, ctx.logger),
+                loadCompositeFunction: (0, steps_1.createLocalCompositeFunctionLoader)(projectRoot, {
+                    logger: ctx.logger,
+                }),
             });
             return await parser.parseAsync();
         }

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

@@ -1,7 +1,6 @@
 import { type bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
 import { type CustomBuildContext } from '../../customBuildContext';
-export declare const DEFAULT_AGENT_DEVICE_VERSION = "0.20.3";
 export declare function createStartAgentDeviceRemoteSessionBuildFunction(ctx: CustomBuildContext): BuildFunction;
 export declare function stopAgentDeviceEventCollectionSafelyAsync({ eventCollection, deviceRunSessionId, logger, }: {
     eventCollection: {

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -3,7 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_AGENT_DEVICE_VERSION = void 0;
 exports.createStartAgentDeviceRemoteSessionBuildFunction = createStartAgentDeviceRemoteSessionBuildFunction;
 exports.stopAgentDeviceEventCollectionSafelyAsync = stopAgentDeviceEventCollectionSafelyAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
@@ -17,7 +16,6 @@ const agentDeviceArtifacts_1 = require("../utils/agentDeviceArtifacts");
 const agentDeviceEvents_1 = require("../utils/agentDeviceEvents");
 const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
 const AGENT_DEVICE_PACKAGE_NAME = 'agent-device';
-exports.DEFAULT_AGENT_DEVICE_VERSION = '0.20.3';
 const AGENT_DEVICE_REPO_URL = 'https://github.com/callstack/agent-device.git';
 const SRC_DIR = '/tmp/agent-device-src';
 const AGENT_DEVICE_STATE_DIR = node_path_1.default.join(node_os_1.default.homedir(), '.agent-device');
@@ -39,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
@@ -48,9 +51,11 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
             const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
             const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
             const ngrokAuthtoken = (0, remoteDeviceRunSession_1.getNgrokAuthtokenOrThrow)(env);
-            const packageVersion = inputs.package_version.value ?? exports.DEFAULT_AGENT_DEVICE_VERSION;
+            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}, runtime: ${runtimePlatform}).`);
+            logger.info(`Starting agent-device remote session (version: ${packageVersion ?? 'latest'}, runtime: ${runtimePlatform}).`);
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
                 await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
             }
@@ -111,6 +116,12 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                     deviceRunSessionId,
                     logger,
                     signal,
+                    idleTimeout: maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
+                        ? {
+                            maxIdleTimeMinutes,
+                            getLastEventObservedAt: eventCollection.getLastEventObservedAt,
+                        }
+                        : undefined,
                 });
             }
             finally {
@@ -174,7 +185,7 @@ async function startAgentDeviceDaemonAsync({ packageVersion, env, logger, }) {
             },
             extras: {
                 packageSpec,
-                packageVersion,
+                packageVersion: packageVersion ?? 'latest',
                 bunVersion,
                 bunInstallConfigured: Boolean(env.BUN_INSTALL?.trim()),
             },
@@ -184,7 +195,9 @@ async function startAgentDeviceDaemonAsync({ packageVersion, env, logger, }) {
     }
 }
 async function startAgentDeviceDaemonFromGitAsync({ packageVersion, env, logger, }) {
-    logger.info(`Cloning agent-device @ v${packageVersion} into ${SRC_DIR}.`);
+    logger.info(packageVersion
+        ? `Cloning agent-device @ v${packageVersion} into ${SRC_DIR}.`
+        : `Cloning agent-device (latest) into ${SRC_DIR}.`);
     await cloneAgentDeviceAsync({ packageVersion, env, logger });
     logger.info('Installing agent-device dependencies.');
     await (0, turtle_spawn_1.default)('bun', ['install', '--production'], {
@@ -201,7 +214,7 @@ async function startAgentDeviceDaemonFromGitAsync({ packageVersion, env, logger,
     });
 }
 async function cloneAgentDeviceAsync({ packageVersion, env, logger, }) {
-    const branchArgs = ['--branch', `v${packageVersion}`];
+    const branchArgs = packageVersion ? ['--branch', `v${packageVersion}`] : [];
     await (0, turtle_spawn_1.default)('git', ['clone', '--depth', '1', ...branchArgs, AGENT_DEVICE_REPO_URL, SRC_DIR], {
         env,
         logger,
@@ -233,7 +246,7 @@ async function getBunVersionForDiagnosticsAsync(env) {
     }
 }
 function createAgentDevicePackageSpec(packageVersion) {
-    const versionSpec = packageVersion.replace(/^v(?=\d)/, '');
+    const versionSpec = packageVersion ? packageVersion.replace(/^v(?=\d)/, '') : 'latest';
     return `${AGENT_DEVICE_PACKAGE_NAME}@${versionSpec}`;
 }
 function getGlobalAgentDeviceDaemonPath(env) {

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/dist/utils/easCli.d.ts

@@ -1,5 +1,7 @@
 import { SpawnOptions, SpawnResult } from '@expo/turtle-spawn';
 import { Env } from '@expo/eas-build-job';
+/** Test-only: clears the memoized versions promise so each test fetches fresh. */
+export declare function resetCachedEasCliVersionsForTest(): void;
 export declare function resolveEasCommandPrefixAndEnvAsync(): Promise<{
     cmd: string;
     args: string[];

package/dist/utils/easCli.js

@@ -3,11 +3,48 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetCachedEasCliVersionsForTest = resetCachedEasCliVersionsForTest;
 exports.resolveEasCommandPrefixAndEnvAsync = resolveEasCommandPrefixAndEnvAsync;
 exports.runEasCliCommand = runEasCliCommand;
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
 const eas_build_job_1 = require("@expo/eas-build-job");
 const packageManager_1 = require("./packageManager");
+const sentry_1 = require("../sentry");
+let cachedEasCliVersionsPromise;
+/**
+ * Resolves the `eas-cli` versions to install for staging/production. Prefers the
+ * versions committed to `cli-versions.json` (fetched from expo/eas-cli); on any
+ * failure (e.g. GitHub is unreachable or slow) reports to Sentry and falls back
+ * to the `latest-eas-build*` npm dist-tags so the build can still proceed.
+ *
+ * Memoized: `resolveEasCommandPrefixAndEnvAsync` runs more than once per build,
+ * so the (never-rejecting) result promise is cached to fetch GitHub at most once
+ * per process.
+ */
+async function resolveEasCliVersionsAsync() {
+    if (!cachedEasCliVersionsPromise) {
+        cachedEasCliVersionsPromise = fetchEasCliVersionsWithFallbackAsync();
+    }
+    return await cachedEasCliVersionsPromise;
+}
+async function fetchEasCliVersionsWithFallbackAsync() {
+    try {
+        return await (0, eas_build_job_1.fetchEasCliVersionsAsync)();
+    }
+    catch (error) {
+        const message = error instanceof eas_build_job_1.EasCliVersionsFetchTimeoutError
+            ? 'Timed out fetching cli-versions.json; falling back to npm dist-tags'
+            : 'Failed to fetch cli-versions.json; falling back to npm dist-tags';
+        sentry_1.Sentry.capture(message, error instanceof Error ? error : new Error(String(error)), {
+            level: 'warning',
+        });
+        return { STAGING: eas_build_job_1.EasCliNpmTags.STAGING, PRODUCTION: eas_build_job_1.EasCliNpmTags.PRODUCTION };
+    }
+}
+/** Test-only: clears the memoized versions promise so each test fetches fresh. */
+function resetCachedEasCliVersionsForTest() {
+    cachedEasCliVersionsPromise = undefined;
+}
 async function probeEasdAsync() {
     try {
         const result = await (0, turtle_spawn_1.default)('easd', ['--help'], {
@@ -25,23 +62,26 @@ async function resolveEasCommandPrefixAndEnvAsync() {
         if (await probeEasdAsync()) {
             return { cmd: 'easd', args: [], extraEnv: {} };
         }
+        const versions = await resolveEasCliVersionsAsync();
         return {
             cmd: 'npx',
-            args: [...npxArgsPrefix, `eas-cli@${eas_build_job_1.EasCliNpmTags.STAGING}`],
+            args: [...npxArgsPrefix, `eas-cli@${versions.STAGING}`],
             extraEnv: {},
         };
     }
     else if (process.env.ENVIRONMENT === 'staging') {
+        const versions = await resolveEasCliVersionsAsync();
         return {
             cmd: 'npx',
-            args: [...npxArgsPrefix, `eas-cli@${eas_build_job_1.EasCliNpmTags.STAGING}`],
+            args: [...npxArgsPrefix, `eas-cli@${versions.STAGING}`],
             extraEnv: { EXPO_STAGING: '1' },
         };
     }
     else {
+        const versions = await resolveEasCliVersionsAsync();
         return {
             cmd: 'npx',
-            args: [...npxArgsPrefix, `eas-cli@${eas_build_job_1.EasCliNpmTags.PRODUCTION}`],
+            args: [...npxArgsPrefix, `eas-cli@${versions.PRODUCTION}`],
             extraEnv: {},
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "21.5.1",
+  "version": "21.7.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.5.0",
+    "@expo/eas-build-job": "21.6.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.5.0",
+    "@expo/steps": "21.6.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": "7d7ebb27f6a9c9fccef53e6203cdeb59c7aa4ba0"
+  "gitHead": "f923181857de80919ec7ee9861c9b71c2ee5635d"
 }

package/dist/steps/compositeFunctions.d.ts

@@ -1,11 +0,0 @@
-/**
- * Loads local function.yml files from the project and builds the catalog consumed by
- * {@link StepsConfigParser}. Keeps filesystem I/O in build-tools; expansion logic lives in @expo/steps.
- */
-import { bunyan } from '@expo/logger';
-import { CompositeFunctionCatalog, CompositeFunctionConfig, Step } from '@expo/eas-build-job';
-export declare function createCompositeFunctionLoader(projectRoot: string, logger?: bunyan): (compositeFunctionPath: string) => Promise<CompositeFunctionConfig>;
-export declare function buildCompositeFunctionCatalogAsync(projectRoot: string, { steps, logger }: {
-    steps: readonly Step[];
-    logger?: bunyan;
-}): Promise<CompositeFunctionCatalog>;

package/dist/steps/compositeFunctions.js

@@ -1,62 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCompositeFunctionLoader = createCompositeFunctionLoader;
-exports.buildCompositeFunctionCatalogAsync = buildCompositeFunctionCatalogAsync;
-const eas_build_job_1 = require("@expo/eas-build-job");
-const steps_1 = require("@expo/steps");
-const promises_1 = __importDefault(require("fs/promises"));
-const path_1 = __importDefault(require("path"));
-const yaml_1 = __importDefault(require("yaml"));
-const zod_1 = require("zod");
-async function loadLocalCompositeFunctionConfigAsync(projectRoot, compositeFunctionPath, { logger } = {}) {
-    const resolvedPath = (0, steps_1.resolveLocalCompositeFunctionPath)(projectRoot, compositeFunctionPath);
-    for (const ext of ['yml', 'yaml']) {
-        const absolutePath = path_1.default.join(resolvedPath, `function.${ext}`);
-        let rawContents;
-        try {
-            rawContents = await promises_1.default.readFile(absolutePath, 'utf-8');
-        }
-        catch (err) {
-            if (err?.code === 'ENOENT') {
-                continue;
-            }
-            throw new Error(`Failed to read local composite function "${compositeFunctionPath}" from ${absolutePath}`, {
-                cause: err,
-            });
-        }
-        let parsed;
-        try {
-            parsed = yaml_1.default.parse(rawContents);
-        }
-        catch (err) {
-            throw new Error(`Failed to parse local composite function "${compositeFunctionPath}" YAML at ${absolutePath}`, {
-                cause: err,
-            });
-        }
-        let config;
-        try {
-            config = eas_build_job_1.CompositeFunctionConfigZ.parse(parsed);
-        }
-        catch (err) {
-            if (err instanceof zod_1.ZodError) {
-                throw new Error(`Invalid composite function "${compositeFunctionPath}": ${zod_1.z.prettifyError(err)}`);
-            }
-            throw err;
-        }
-        logger?.debug(`Loaded local composite function "${compositeFunctionPath}" from ${path_1.default.relative(projectRoot, absolutePath)}`);
-        return config;
-    }
-    throw new Error(`Local composite function "${compositeFunctionPath}" was referenced by a step but no such composite function exists. A local composite function is resolved from a "function.yml" (or "function.yaml") file at the referenced path relative to the EAS project root (e.g. "uses: ${compositeFunctionPath}" resolves "${compositeFunctionPath}/function.yml"). The recommended convention is to keep composite functions under ".eas/functions/<name>".`);
-}
-function createCompositeFunctionLoader(projectRoot, logger) {
-    return compositeFunctionPath => loadLocalCompositeFunctionConfigAsync(projectRoot, compositeFunctionPath, { logger });
-}
-async function buildCompositeFunctionCatalogAsync(projectRoot, { steps, logger }) {
-    return (0, steps_1.buildCompositeFunctionCatalogFromStepsAsync)({
-        rootSteps: steps,
-        loadCompositeFunction: createCompositeFunctionLoader(projectRoot, logger),
-    });
-}