@expo/build-tools 20.3.0 → 20.5.1

package/dist/common/projectSources.js

@@ -169,7 +169,7 @@ async function uploadProjectMetadataAsync(ctx, { projectDirectory }) {
           }
         }
       `), {
-        buildId: ctx.env.EAS_BUILD_ID,
+        buildId: (0, nullthrows_1.default)(ctx.env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set'),
         projectMetadataFile: {
             type: 'GCS',
             bucketKey: uploadSession.bucketKey,

package/dist/context.d.ts

@@ -19,6 +19,7 @@ export type ArtifactToUpload = {
     type: GenericArtifactType;
     name: string;
     paths: string[];
+    metadata?: Record<string, unknown>;
 };
 export interface BuildContextOptions {
     workingdir: string;
@@ -42,7 +43,7 @@ export interface BuildContextOptions {
     }>;
     reportError?: (msg: string, err?: Error, options?: {
         tags?: Record<string, string>;
-        extras?: Record<string, string>;
+        extras?: Record<string, string | undefined>;
     }) => void;
     skipNativeBuild?: boolean;
     metadata?: Metadata;
@@ -57,7 +58,7 @@ export declare class BuildContext<TJob extends Job = Job> {
     readonly cacheManager?: CacheManager;
     readonly reportError?: (msg: string, err?: Error, options?: {
         tags?: Record<string, string>;
-        extras?: Record<string, string>;
+        extras?: Record<string, string | undefined>;
     }) => void;
     readonly skipNativeBuild?: boolean;
     readonly expoApiV2BaseUrl?: string;

package/dist/ios/fastlane.d.ts

@@ -19,6 +19,6 @@ export declare function runFastlaneResign<TJob extends Ios.Job>(ctx: BuildContex
 }): Promise<void>;
 export declare function runFastlane(fastlaneArgs: string[], { logger, env, cwd, }?: {
     logger?: bunyan;
-    env?: Record<string, string>;
+    env?: Env;
     cwd?: string;
 }): Promise<SpawnResult>;

package/dist/steps/easFunctions.js

@@ -90,7 +90,7 @@ function getEasFunctions(ctx) {
         (0, createSubmissionEntity_1.createSubmissionEntityFunction)(),
         (0, uploadToAsc_1.createUploadToAscBuildFunction)(),
         (0, reportMaestroTestResults_1.createReportMaestroTestResultsFunction)(ctx),
-        (0, maestroTests_1.createMaestroTestsBuildFunction)(),
+        (0, maestroTests_1.createMaestroTestsBuildFunction)(ctx),
     ];
     if (ctx.hasBuildJob()) {
         functions.push(...[

package/dist/steps/functions/createSubmissionEntity.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSubmissionEntityFunction = createSubmissionEntityFunction;
 const results_1 = require("@expo/results");
 const steps_1 = require("@expo/steps");
+const sentry_1 = require("../../sentry");
 const retryOnDNSFailure_1 = require("../../utils/retryOnDNSFailure");
 function createSubmissionEntityFunction() {
     return new steps_1.BuildFunction({
@@ -53,16 +54,39 @@ function createSubmissionEntityFunction() {
             const robotAccessToken = stepsCtx.global.staticContext.job.secrets?.robotAccessToken;
             if (!robotAccessToken) {
                 stepsCtx.logger.error('Failed to create submission entity: no robot access token found');
+                sentry_1.Sentry.capture('Failed to create submission entity: missing robot access token');
                 return;
             }
             const buildId = inputs.build_id.value;
             if (!buildId) {
                 stepsCtx.logger.error('Failed to create submission entity: no build ID provided');
+                sentry_1.Sentry.capture('Failed to create submission entity: missing build ID', {
+                    extras: {
+                        buildId,
+                    },
+                });
                 return;
             }
             const workflowJobId = stepsCtx.global.env.__WORKFLOW_JOB_ID;
             if (!workflowJobId) {
                 stepsCtx.logger.error('Failed to create submission entity: no workflow job ID found');
+                sentry_1.Sentry.capture('Failed to create submission entity: missing workflow job ID', {
+                    extras: {
+                        buildId,
+                        workflowJobId,
+                    },
+                });
+                return;
+            }
+            const expoApiServerURL = stepsCtx.global.staticContext.expoApiServerURL;
+            if (!expoApiServerURL) {
+                stepsCtx.logger.error('Failed to create submission entity: no Expo API server URL found');
+                sentry_1.Sentry.capture('Failed to create submission entity: missing Expo API server URL', {
+                    extras: {
+                        buildId,
+                        workflowJobId,
+                    },
+                });
                 return;
             }
             // This is supposed to provide fallback for `''` -> `undefined`.
@@ -76,7 +100,7 @@ function createSubmissionEntityFunction() {
             const ascAppIdentifier = inputs.asc_app_identifier.value || undefined;
             /* eslint-enable @typescript-eslint/prefer-nullish-coalescing */
             try {
-                const response = await (0, retryOnDNSFailure_1.retryOnDNSFailure)(fetch)(new URL('/v2/app-store-submissions/', stepsCtx.global.staticContext.expoApiServerURL), {
+                const response = await (0, retryOnDNSFailure_1.retryOnDNSFailure)(fetch)(new URL('/v2/app-store-submissions/', expoApiServerURL), {
                     method: 'POST',
                     headers: {
                         Authorization: `Bearer ${robotAccessToken}`,

package/dist/steps/functions/downloadArtifact.js

@@ -52,11 +52,21 @@ function createDownloadArtifactFunction() {
             });
             const interpolationContext = stepsCtx.global.getInterpolationContext();
             if (!('workflow' in interpolationContext)) {
-                throw new eas_build_job_1.UserError('EAS_DOWNLOAD_ARTIFACT_NO_WORKFLOW', 'No workflow found in the interpolation context.');
+                throw new eas_build_job_1.SystemError('No workflow found in the interpolation context.', {
+                    trackingCode: 'EAS_DOWNLOAD_ARTIFACT_NO_WORKFLOW',
+                });
             }
             const robotAccessToken = stepsCtx.global.staticContext.job.secrets?.robotAccessToken;
             if (!robotAccessToken) {
-                throw new eas_build_job_1.UserError('EAS_DOWNLOAD_ARTIFACT_NO_ROBOT_ACCESS_TOKEN', 'No robot access token found in the job secrets.');
+                throw new eas_build_job_1.SystemError('No robot access token found in the job secrets.', {
+                    trackingCode: 'EAS_DOWNLOAD_ARTIFACT_NO_ROBOT_ACCESS_TOKEN',
+                });
+            }
+            const expoApiServerURL = stepsCtx.global.staticContext.expoApiServerURL;
+            if (!expoApiServerURL) {
+                throw new eas_build_job_1.SystemError('Missing Expo API server URL.', {
+                    trackingCode: 'EAS_DOWNLOAD_ARTIFACT_NO_EXPO_API_SERVER_URL',
+                });
             }
             const workflowRunId = interpolationContext.workflow.id;
             const { logger } = stepsCtx;
@@ -69,7 +79,7 @@ function createDownloadArtifactFunction() {
             const { artifactPath } = await downloadArtifactAsync({
                 logger,
                 workflowRunId,
-                expoApiServerURL: stepsCtx.global.staticContext.expoApiServerURL,
+                expoApiServerURL,
                 robotAccessToken,
                 params,
             });

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

@@ -0,0 +1,27 @@
+import { bunyan } from '@expo/logger';
+export interface ParsedFailureScreenshot {
+    flowName: string;
+    capturedAtMs: number;
+}
+export declare function parseFailureScreenshotFilename(filename: string): ParsedFailureScreenshot | null;
+export interface HarvestedScreenshot {
+    fileAbsPath: string;
+    displayName: string;
+    metadata: {
+        kind: 'maestro-test-screenshot';
+        flowName: string;
+        attemptIndex: number;
+        capturedAtMs: number;
+    };
+}
+export declare function harvestFailureScreenshotsAsync(args: {
+    testsDirectory: string;
+    capturedSinceMs: number;
+    attemptIndex: number;
+    logger: bunyan;
+}): Promise<HarvestedScreenshot[]>;
+export declare function computePureFailureFlowNames(testCases: readonly {
+    name: string;
+    status: 'passed' | 'failed';
+}[]): Set<string>;
+export declare function selectFailureScreenshots(harvested: readonly HarvestedScreenshot[], pureFailureFlowNames: ReadonlySet<string>): HarvestedScreenshot[];

package/dist/steps/functions/maestroScreenshots.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFailureScreenshotFilename = parseFailureScreenshotFilename;
+exports.harvestFailureScreenshotsAsync = harvestFailureScreenshotsAsync;
+exports.computePureFailureFlowNames = computePureFailureFlowNames;
+exports.selectFailureScreenshots = selectFailureScreenshots;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+// Maestro failure screenshot: `screenshot-[shard-N-]❌-<epochMillis>-(<flowName>).png`.
+// The flow name may contain parentheses, so anchor on the `-(` after the epoch and the
+// `).png` suffix rather than scanning for parens.
+const FAILURE_SCREENSHOT_PATTERN = /^screenshot-(?:shard-\d+-)?❌-(\d+)-\((.+)\)\.png$/u;
+function parseFailureScreenshotFilename(filename) {
+    const match = filename.match(FAILURE_SCREENSHOT_PATTERN);
+    if (!match) {
+        return null;
+    }
+    const capturedAtMs = Number(match[1]);
+    if (!Number.isFinite(capturedAtMs)) {
+        return null;
+    }
+    return {
+        flowName: match[2],
+        capturedAtMs,
+    };
+}
+// Scans every debug dir under testsDirectory whose mtime is recent enough (mtime-based to cover
+// the maestro <2.5.0 bug that splits one invocation across two dirs), then keeps only screenshots
+// whose own capturedAtMs is at/after capturedSinceMs. Never throws: an unreadable dir is logged
+// and skipped so a screenshot harvest can't affect the maestro step outcome.
+async function harvestFailureScreenshotsAsync(args) {
+    // Gate dirs by mtime floored to the second, so a dir created within the same second as the
+    // attempt start isn't stat'd below the baseline. The exact capturedAtMs gate below is what
+    // prevents mis-attributing an earlier attempt's screenshot.
+    const dirSinceMtimeMs = Math.floor(args.capturedSinceMs / 1000) * 1000;
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(args.testsDirectory, { withFileTypes: true });
+    }
+    catch (err) {
+        args.logger.info({ err }, `Skipping screenshot harvest: cannot read ${args.testsDirectory}.`);
+        return [];
+    }
+    const results = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const dirPath = path_1.default.join(args.testsDirectory, entry.name);
+        let filenames;
+        try {
+            if ((await promises_1.default.stat(dirPath)).mtimeMs < dirSinceMtimeMs) {
+                continue;
+            }
+            filenames = await promises_1.default.readdir(dirPath);
+        }
+        catch (err) {
+            args.logger.info({ err }, `Skipping unreadable debug dir ${dirPath}.`);
+            continue;
+        }
+        for (const filename of filenames) {
+            const parsed = parseFailureScreenshotFilename(filename);
+            // Re-check capture time per file: a dir's mtime can advance after this attempt began (or
+            // fall within the floored-second dir baseline), so the dir gate alone would re-attribute an
+            // earlier attempt's screenshot to this one.
+            if (parsed === null || parsed.capturedAtMs < args.capturedSinceMs) {
+                continue;
+            }
+            results.push({
+                fileAbsPath: path_1.default.join(dirPath, filename),
+                displayName: `Failure Screenshot: ${parsed.flowName} (attempt ${args.attemptIndex + 1})`,
+                metadata: {
+                    kind: 'maestro-test-screenshot',
+                    flowName: parsed.flowName,
+                    attemptIndex: args.attemptIndex,
+                    capturedAtMs: parsed.capturedAtMs,
+                },
+            });
+        }
+    }
+    return results;
+}
+// Maestro substitutes '/' -> '_' in screenshot filenames (so HarvestedScreenshot.flowName
+// is already in that form) but keeps '/' in the JUnit testcase name. Normalize the JUnit
+// name the same way before comparing — matching the website's own normalization.
+function normalizeFlowName(name) {
+    return name.replace(/\//g, '_');
+}
+// A flow is a "pure failure" when it failed and never passed across all attempts. The website
+// surfaces only the final screenshot for such a flow, so keeping its earlier attempts would
+// spend the per-job artifact budget on screenshots that are never shown — we keep only the final
+// one (selectFailureScreenshots). A flow that passed at least once (flaky / fail-pass-fail) is
+// NOT pure: each of its failed attempts is a distinct failure and is kept.
+function computePureFailureFlowNames(testCases) {
+    const passed = new Set();
+    const failed = new Set();
+    for (const testCase of testCases) {
+        const flowName = normalizeFlowName(testCase.name);
+        if (testCase.status === 'passed') {
+            passed.add(flowName);
+        }
+        else {
+            failed.add(flowName);
+        }
+    }
+    const pure = new Set();
+    for (const flowName of failed) {
+        if (!passed.has(flowName)) {
+            pure.add(flowName);
+        }
+    }
+    return pure;
+}
+// Keep every harvested screenshot for flaky/mixed flows; for pure-failure flows keep only
+// the final (highest attemptIndex) screenshot.
+function selectFailureScreenshots(harvested, pureFailureFlowNames) {
+    const finalAttemptByPureFlow = new Map();
+    for (const shot of harvested) {
+        if (!pureFailureFlowNames.has(shot.metadata.flowName)) {
+            continue;
+        }
+        const finalAttempt = finalAttemptByPureFlow.get(shot.metadata.flowName);
+        if (finalAttempt === undefined || shot.metadata.attemptIndex > finalAttempt) {
+            finalAttemptByPureFlow.set(shot.metadata.flowName, shot.metadata.attemptIndex);
+        }
+    }
+    return harvested.filter(shot => {
+        const finalAttempt = finalAttemptByPureFlow.get(shot.metadata.flowName);
+        return finalAttempt === undefined || shot.metadata.attemptIndex === finalAttempt;
+    });
+}

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

@@ -1,2 +1,3 @@
 import { BuildFunction } from '@expo/steps';
-export declare function createMaestroTestsBuildFunction(): BuildFunction;
+import { CustomBuildContext } from '../../customBuildContext';
+export declare function createMaestroTestsBuildFunction(ctx: CustomBuildContext): BuildFunction;

package/dist/steps/functions/maestroTests.js

@@ -8,10 +8,12 @@ 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"));
 const promises_1 = __importDefault(require("fs/promises"));
+const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const zod_1 = require("zod");
 const maestroFlowDiscovery_1 = require("./maestroFlowDiscovery");
 const maestroResultParser_1 = require("./maestroResultParser");
+const maestroScreenshots_1 = require("./maestroScreenshots");
 const retry_1 = require("../../utils/retry");
 const FlowPathSchema = zod_1.z.array(zod_1.z.string().min(1)).min(1);
 const RetriesSchema = zod_1.z.number().int().min(0).default(0);
@@ -56,7 +58,7 @@ function buildMaestroArgs(args) {
     out.push(...args.flow_path);
     return out;
 }
-function createMaestroTestsBuildFunction() {
+function createMaestroTestsBuildFunction(ctx) {
     return new steps_1.BuildFunction({
         namespace: 'eas',
         id: 'maestro_tests',
@@ -171,6 +173,7 @@ function createMaestroTestsBuildFunction() {
             // trusted; we then fall through to dumb retry (re-run everything).
             let flowsToRun = flowPaths;
             let lastAttemptExitCode = null;
+            const harvested = [];
             const totalAttempts = retries + 1;
             for (let attempt = 0; attempt <= retries; attempt++) {
                 const outputPath = outputFormat === 'junit'
@@ -187,6 +190,7 @@ function createMaestroTestsBuildFunction() {
                     exclude_tags: excludeTags,
                 });
                 logger.info(`Running maestro (attempt ${attempt + 1}/${totalAttempts}): maestro ${maestroArgs.join(' ')}`);
+                const attemptStartedAtMs = Date.now();
                 try {
                     await (0, turtle_spawn_1.default)('maestro', maestroArgs, {
                         cwd: stepCtx.workingDirectory,
@@ -207,6 +211,17 @@ function createMaestroTestsBuildFunction() {
                         throw new eas_build_job_1.SystemError('Unexpected spawn failure invoking maestro', { cause: err });
                     }
                 }
+                // Harvest this attempt's failure screenshots before any retry subsetting. Gated on
+                // junit: test-case-result rows (and therefore the summary icons) only exist for junit
+                // runs, so harvesting other formats would just create orphan artifacts the website hides.
+                if (outputFormat === 'junit') {
+                    harvested.push(...(await (0, maestroScreenshots_1.harvestFailureScreenshotsAsync)({
+                        testsDirectory,
+                        capturedSinceMs: attemptStartedAtMs,
+                        attemptIndex: attempt,
+                        logger,
+                    })));
+                }
                 if (lastAttemptExitCode === 0 || attempt === retries) {
                     break;
                 }
@@ -276,6 +291,11 @@ function createMaestroTestsBuildFunction() {
                     }
                 }
             }
+            // Upload before the ERR_MAESTRO_TESTS_FAILED throw below so fully-failed runs (which need
+            // screenshots most) still upload. Harvest only ran for junit, so guard the same way.
+            if (outputFormat === 'junit') {
+                await uploadFailureScreenshotsAsync({ harvested, junitReportDirectory, ctx, logger });
+            }
             // The retry loop exits via success (0), numeric status (retryable),
             // or throw (infra). A non-null non-zero status means the user's tests
             // failed every attempt.
@@ -285,3 +305,59 @@ function createMaestroTestsBuildFunction() {
         },
     });
 }
+// Reduce harvested failure screenshots to what's worth uploading, then upload them as workflow
+// artifacts. Best-effort and verdict-neutral: never throws, so a screenshot problem can't mask
+// the maestro test result. Caller guards on junit (harvest only runs for junit).
+async function uploadFailureScreenshotsAsync({ harvested, junitReportDirectory, ctx, logger, }) {
+    // Reduce to the attempts worth uploading — every failed attempt for flaky flows, only the final
+    // attempt for all-failed flows. See computePureFailureFlowNames / selectFailureScreenshots.
+    // Guard the JUnit re-parse so a malformed/missing report can't throw past here and mask the
+    // test verdict (the whole step is verdict-neutral for screenshots).
+    let selected;
+    try {
+        const pureFailureFlowNames = (0, maestroScreenshots_1.computePureFailureFlowNames)(await (0, maestroResultParser_1.parseJUnitTestCases)(junitReportDirectory));
+        selected = (0, maestroScreenshots_1.selectFailureScreenshots)(harvested, pureFailureFlowNames);
+    }
+    catch (err) {
+        logger.warn({ err }, 'Failed to classify failure screenshots; skipping screenshot upload.');
+        return;
+    }
+    if (selected.length === 0) {
+        return;
+    }
+    // Cap well under www's 50-artifact-per-job limit.
+    const MAX_SCREENSHOT_UPLOADS = 30;
+    const toUpload = selected.slice(0, MAX_SCREENSHOT_UPLOADS);
+    if (selected.length > toUpload.length) {
+        logger.warn(`Found ${selected.length} failure screenshots; uploading only the first ${toUpload.length}.`);
+    }
+    // Copy each shot to an ASCII-safe name outside testsDirectory (the originals contain a
+    // non-ASCII marker and testsDirectory is uploaded wholesale as the tarball).
+    let safeScreenshotDir;
+    try {
+        safeScreenshotDir = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'eas-maestro-screenshots-'));
+    }
+    catch (err) {
+        logger.warn({ err }, 'Failed to create the failure-screenshot staging dir; skipping screenshot upload.');
+        return;
+    }
+    await Promise.all(toUpload.map(async (shot, index) => {
+        try {
+            // `index` disambiguates two flows that fail within the same millisecond of an attempt.
+            const safePath = path_1.default.join(safeScreenshotDir, `failure-attempt-${shot.metadata.attemptIndex}-${index}-${shot.metadata.capturedAtMs}.png`);
+            await promises_1.default.copyFile(shot.fileAbsPath, safePath);
+            await ctx.runtimeApi.uploadArtifact({
+                artifact: {
+                    type: eas_build_job_1.GenericArtifactType.OTHER,
+                    name: shot.displayName,
+                    paths: [safePath],
+                    metadata: shot.metadata,
+                },
+                logger,
+            });
+        }
+        catch (err) {
+            logger.warn({ err }, 'Failed to upload failure screenshot.');
+        }
+    }));
+}

package/dist/steps/functions/repack.js

@@ -33,11 +33,6 @@ function createRepackBuildFunction() {
                 required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
-            steps_1.BuildStepInput.createProvider({
-                id: 'output_path',
-                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
-                required: false,
-            }),
             steps_1.BuildStepInput.createProvider({
                 id: 'embed_bundle_assets',
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
@@ -93,8 +88,10 @@ function createRepackBuildFunction() {
             await node_fs_1.default.promises.mkdir(workingDirectory);
             stepsCtx.logger.info(`Created temporary working directory: ${workingDirectory}`);
             const sourceAppPath = inputs.source_app_path.value;
-            const outputPath = inputs.output_path.value ??
-                node_path_1.default.join(tmpDir, `repacked-${(0, node_crypto_1.randomUUID)()}${node_path_1.default.extname(sourceAppPath)}`);
+            const outputPath = createOutputPath({
+                sourceAppPath,
+                tmpDir,
+            });
             const exportEmbedOptions = inputs.embed_bundle_assets.value
                 ? {
                     sourcemapOutput: undefined,
@@ -174,6 +171,14 @@ function createRepackBuildFunction() {
         },
     });
 }
+function createOutputPath({ sourceAppPath, tmpDir, }) {
+    const outputPath = node_path_1.default.join(tmpDir, `repacked-${(0, node_crypto_1.randomUUID)()}${node_path_1.default.extname(sourceAppPath)}`);
+    const extension = node_path_1.default.extname(outputPath);
+    if (extension.toLowerCase() !== '.aab') {
+        return outputPath;
+    }
+    return `${outputPath.slice(0, -extension.length)}.apk`;
+}
 /**
  * Install `@expo/repack-app` in a sandbox directory and import it.
  */

package/dist/steps/functions/restoreCache.js

@@ -99,11 +99,12 @@ function createRestoreCacheFunction() {
                     .parse((inputs.restore_keys.value ?? '').split(/[\r\n]+/))
                     .filter(key => key !== '');
                 const jobId = (0, nullthrows_1.default)(env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set');
+                const expoApiServerURL = (0, nullthrows_1.default)(stepsCtx.global.staticContext.expoApiServerURL, 'expoApiServerURL is not set');
                 const robotAccessToken = (0, nullthrows_1.default)(stepsCtx.global.staticContext.job.secrets?.robotAccessToken, 'robotAccessToken is not set');
                 const { archivePath, matchedKey } = await downloadCacheAsync({
                     logger,
                     jobId,
-                    expoApiServerURL: stepsCtx.global.staticContext.expoApiServerURL,
+                    expoApiServerURL,
                     robotAccessToken,
                     paths,
                     key,

package/dist/steps/functions/saveCache.js

@@ -80,6 +80,7 @@ function createSaveCacheFunction() {
                     .filter(path => path.length > 0);
                 const key = zod_1.default.string().parse(inputs.key.value);
                 const jobId = (0, nullthrows_1.default)(env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set');
+                const expoApiServerURL = (0, nullthrows_1.default)(stepsCtx.global.staticContext.expoApiServerURL, 'expoApiServerURL is not set');
                 const robotAccessToken = (0, nullthrows_1.default)(stepsCtx.global.staticContext.job.secrets?.robotAccessToken, 'robotAccessToken is not set');
                 const { archivePath } = await compressCacheAsync({
                     paths,
@@ -92,7 +93,7 @@ function createSaveCacheFunction() {
                     await uploadPublicCacheAsync({
                         logger,
                         jobId,
-                        expoApiServerURL: stepsCtx.global.staticContext.expoApiServerURL,
+                        expoApiServerURL,
                         robotAccessToken,
                         archivePath,
                         key,
@@ -105,7 +106,7 @@ function createSaveCacheFunction() {
                     await uploadCacheAsync({
                         logger,
                         jobId,
-                        expoApiServerURL: stepsCtx.global.staticContext.expoApiServerURL,
+                        expoApiServerURL,
                         robotAccessToken,
                         archivePath,
                         key,

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -16,7 +16,6 @@ const AGENT_DEVICE_PACKAGE_NAME = 'agent-device';
 const AGENT_DEVICE_REPO_URL = 'https://github.com/callstackincubator/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 XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
 const STARTUP_TIMEOUT_MS = 60_000;
 function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
     return new steps_1.BuildFunction({
@@ -43,8 +42,7 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
             const { runtimePlatform } = global;
             logger.info(`Starting agent-device remote session (version: ${packageVersion ?? 'latest'}, runtime: ${runtimePlatform}).`);
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
-                logger.info(`Selecting Xcode developer directory: ${XCODE_DEVELOPER_DIR}.`);
-                await (0, turtle_spawn_1.default)('sudo', ['xcode-select', '-s', XCODE_DEVELOPER_DIR], { env, logger });
+                await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
             }
             logger.info('Launching agent-device daemon.');
             const daemonProcess = await startAgentDeviceDaemonAsync({ packageVersion, env, logger });

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

@@ -1,6 +1,7 @@
 import { type bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
 import { CustomBuildContext } from '../../customBuildContext';
+export declare const MIN_ARGENT_REMOTE_SESSION_VERSION = "0.12.0";
 export declare function createStartArgentRemoteSessionBuildFunction(ctx: CustomBuildContext): BuildFunction;
 export declare function warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger, }: {
     packageVersion: string | undefined;

package/dist/steps/functions/startArgentRemoteSession.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_ARGENT_REMOTE_SESSION_VERSION = void 0;
 exports.createStartArgentRemoteSessionBuildFunction = createStartArgentRemoteSessionBuildFunction;
 exports.warnIfArgentPackageVersionCannotBeVerified = warnIfArgentPackageVersionCannotBeVerified;
 const eas_build_job_1 = require("@expo/eas-build-job");
@@ -13,11 +14,12 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const semver_1 = __importDefault(require("semver"));
 const zod_1 = require("zod");
+const argentArtifacts_1 = require("../utils/argentArtifacts");
 const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
 const ARGENT_PACKAGE_NAME = '@swmansion/argent';
-const MIN_ARGENT_REMOTE_SESSION_VERSION = '0.11.0';
+exports.MIN_ARGENT_REMOTE_SESSION_VERSION = '0.12.0';
+const ARGENT_ARTIFACTS_LIST_ENDPOINT_FLAG = 'artifacts-list-endpoint';
 const ARGENT_STATE_FILE = node_path_1.default.join(node_os_1.default.homedir(), '.argent', 'tool-server.json');
-const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
 const STARTUP_TIMEOUT_MS = 60_000;
 const ArgentToolServerStateSchema = zod_1.z.object({
     port: zod_1.z.number(),
@@ -50,11 +52,12 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
             const { runtimePlatform } = global;
             logger.info(`Starting argent remote session (version: ${versionSpec}, runtime: ${runtimePlatform}).`);
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
-                logger.info(`Selecting Xcode developer directory: ${XCODE_DEVELOPER_DIR}.`);
-                await (0, turtle_spawn_1.default)('sudo', ['xcode-select', '-s', XCODE_DEVELOPER_DIR], { env, logger });
+                await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
             }
             // Stale state from a previous run would mask the new server's port.
             await node_fs_1.default.promises.rm(ARGENT_STATE_FILE, { force: true });
+            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(`Launching ${ARGENT_PACKAGE_NAME}@${versionSpec} tool-server via bunx.`);
             const argentServer = (0, remoteDeviceRunSession_1.spawnDetached)({
                 command: 'bunx',
@@ -88,6 +91,12 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 throw new eas_build_job_1.SystemError(`${err instanceof Error ? err.message : `Timed out waiting for argent tool-server state.`}${output ? `\nArgent tool-server output:\n${output}` : ''}`);
             }
             logger.info(`Argent tool-server is listening on port ${toolServerPort}.`);
+            void (0, argentArtifacts_1.pollArgentArtifactsForUploadAsync)(ctx, {
+                deviceRunSessionId,
+                toolsUrl: `http://127.0.0.1:${toolServerPort}`,
+                toolsAuthToken: toolServerToken,
+                logger,
+            });
             const publicToolsUrl = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
                 port: toolServerPort,
                 subdomainPrefix: 'argent',
@@ -132,15 +141,15 @@ function warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger, })
     }
     const validVersion = semver_1.default.valid(packageVersion);
     if (!validVersion) {
-        logger.warn(`Argent remote simulator sessions require ${ARGENT_PACKAGE_NAME}@${MIN_ARGENT_REMOTE_SESSION_VERSION} or newer, ` +
+        logger.warn(`Argent remote simulator sessions require ${ARGENT_PACKAGE_NAME}@${exports.MIN_ARGENT_REMOTE_SESSION_VERSION} or newer, ` +
             `but package_version "${packageVersion}" is not an exact semver version that EAS can verify. ` +
             `Continuing and letting bunx resolve it.`);
         return;
     }
-    if (semver_1.default.lt(validVersion, MIN_ARGENT_REMOTE_SESSION_VERSION)) {
-        throw new eas_build_job_1.SystemError(`Argent remote simulator sessions require ${ARGENT_PACKAGE_NAME}@${MIN_ARGENT_REMOTE_SESSION_VERSION} or newer. ` +
+    if (semver_1.default.lt(validVersion, exports.MIN_ARGENT_REMOTE_SESSION_VERSION)) {
+        throw new eas_build_job_1.SystemError(`Argent remote simulator sessions require ${ARGENT_PACKAGE_NAME}@${exports.MIN_ARGENT_REMOTE_SESSION_VERSION} or newer. ` +
             `The requested package_version "${packageVersion}" is too old for the EAS remote-session API. ` +
-            `Use "latest" or pass an exact version >= ${MIN_ARGENT_REMOTE_SESSION_VERSION}.`);
+            `Use "latest" or pass an exact version >= ${exports.MIN_ARGENT_REMOTE_SESSION_VERSION}.`);
     }
 }
 function parseArgentToolServerState(raw) {

package/dist/steps/functions/startIosSimulator.js

@@ -26,6 +26,12 @@ function createStartIosSimulatorBuildFunction() {
                 defaultValue: 1,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'enable_accessibility_settings',
+                required: false,
+                defaultValue: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+            }),
         ],
         fn: async ({ logger }, { inputs, env }) => {
             try {
@@ -45,9 +51,16 @@ function createStartIosSimulatorBuildFunction() {
             }
             const deviceIdentifierInput = inputs.device_identifier.value?.toString();
             const originalDeviceIdentifier = deviceIdentifierInput ?? (await findMostGenericIphoneUuidAsync({ env }));
+            const enableAccessibilitySettings = Boolean(inputs.enable_accessibility_settings.value);
             if (!originalDeviceIdentifier) {
                 throw new Error('Could not find an iPhone among available simulator devices.');
             }
+            if (enableAccessibilitySettings) {
+                await IosSimulatorUtils_1.IosSimulatorUtils.enableAccessibilitySettingsAsync({
+                    deviceIdentifier: originalDeviceIdentifier,
+                    env,
+                });
+            }
             const { udid } = await IosSimulatorUtils_1.IosSimulatorUtils.startAsync({
                 deviceIdentifier: originalDeviceIdentifier,
                 env,
@@ -78,6 +91,12 @@ function createStartIosSimulatorBuildFunction() {
                         destinationDeviceName: cloneDeviceName,
                         env,
                     });
+                    if (enableAccessibilitySettings) {
+                        await IosSimulatorUtils_1.IosSimulatorUtils.enableAccessibilitySettingsAsync({
+                            deviceIdentifier: cloneDeviceName,
+                            env,
+                        });
+                    }
                     const { udid: cloneUdid } = await IosSimulatorUtils_1.IosSimulatorUtils.startAsync({
                         deviceIdentifier: cloneDeviceName,
                         env,

package/dist/steps/functions/startServeSimRemoteSession.js

@@ -1,13 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStartServeSimRemoteSessionBuildFunction = createStartServeSimRemoteSessionBuildFunction;
 const steps_1 = require("@expo/steps");
-const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
 const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
-const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
 const STARTUP_TIMEOUT_MS = 60_000;
 function createStartServeSimRemoteSessionBuildFunction(ctx) {
     return new steps_1.BuildFunction({
@@ -20,8 +15,7 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
             const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
             const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
             logger.info('Starting serve-sim remote session.');
-            logger.info(`Selecting Xcode developer directory: ${XCODE_DEVELOPER_DIR}.`);
-            await (0, turtle_spawn_1.default)('sudo', ['xcode-select', '-s', XCODE_DEVELOPER_DIR], { env, logger });
+            await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
             const { previewUrl, streamUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
                 baseDomain: ngrokTunnelDomain,
                 env,

package/dist/steps/functions/uploadArtifact.js

@@ -62,6 +62,11 @@ function createUploadArtifactBuildFunction(ctx) {
                 required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'metadata',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.JSON,
+            }),
         ],
         outputProviders: [
             steps_1.BuildStepOutput.createProvider({
@@ -93,7 +98,7 @@ function createUploadArtifactBuildFunction(ctx) {
                 }
                 throw result.reason;
             });
-            const artifact = {
+            const artifactSpec = {
                 type: parseArtifactTypeInput({
                     platform: ctx.job.platform,
                     inputValue: `${inputs.type.value ?? ''}`,
@@ -101,11 +106,14 @@ function createUploadArtifactBuildFunction(ctx) {
                 paths: artifactPaths,
                 name: (inputs.name.value || inputs.key.value),
             };
+            const artifact = (0, eas_build_job_1.isGenericArtifact)(artifactSpec)
+                ? {
+                    ...artifactSpec,
+                    metadata: inputs.metadata.value,
+                }
+                : artifactSpec;
             try {
-                const { artifactId } = await ctx.runtimeApi.uploadArtifact({
-                    artifact,
-                    logger,
-                });
+                const { artifactId } = await ctx.runtimeApi.uploadArtifact({ artifact, logger });
                 if (artifactId) {
                     outputs.artifact_id.set(artifactId);
                 }

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

@@ -0,0 +1,28 @@
+import { type bunyan } from '@expo/logger';
+import { z } from 'zod';
+import { CustomBuildContext } from '../../customBuildContext';
+declare const ArgentArtifactSchema: z.ZodObject<{
+    id: z.ZodString;
+    filename: z.ZodString;
+    mimeType: z.ZodString;
+    isDirectory: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type ArgentArtifact = z.infer<typeof ArgentArtifactSchema>;
+export declare function pollArgentArtifactsForUploadAsync(ctx: CustomBuildContext, { deviceRunSessionId, toolsUrl, toolsAuthToken, logger, }: {
+    deviceRunSessionId: string;
+    toolsUrl: string;
+    toolsAuthToken?: string;
+    logger: bunyan;
+}): Promise<never>;
+export declare function listArgentArtifactsAsync({ toolsUrl, toolsAuthToken, }: {
+    toolsUrl: string;
+    toolsAuthToken?: string;
+}): Promise<ArgentArtifact[]>;
+export declare function uploadArgentArtifactAsync(ctx: CustomBuildContext, { deviceRunSessionId, toolsUrl, toolsAuthToken, artifact, logger, }: {
+    deviceRunSessionId: string;
+    toolsUrl: string;
+    toolsAuthToken?: string;
+    artifact: ArgentArtifact;
+    logger: bunyan;
+}): Promise<void>;
+export {};

package/dist/steps/utils/argentArtifacts.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollArgentArtifactsForUploadAsync = pollArgentArtifactsForUploadAsync;
+exports.listArgentArtifactsAsync = listArgentArtifactsAsync;
+exports.uploadArgentArtifactAsync = uploadArgentArtifactAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const promises_2 = require("node:stream/promises");
+const zod_1 = require("zod");
+const sentry_1 = require("../../sentry");
+const artifacts_1 = require("../../utils/artifacts");
+const retry_1 = require("../../utils/retry");
+const deviceRunSessionArtifacts_1 = require("./deviceRunSessionArtifacts");
+const ARGENT_ARTIFACT_UPLOAD_POLL_INTERVAL_MS = 5_000;
+const ArgentArtifactSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    filename: zod_1.z.string(),
+    mimeType: zod_1.z.string(),
+    isDirectory: zod_1.z.boolean().optional(),
+});
+const ArgentArtifactsListResponseSchema = zod_1.z.object({
+    artifacts: zod_1.z.array(ArgentArtifactSchema),
+});
+async function pollArgentArtifactsForUploadAsync(ctx, { deviceRunSessionId, toolsUrl, toolsAuthToken, logger, }) {
+    logger.info('Started polling Argent tool-server for artifacts.');
+    const seenArtifactIds = new Set();
+    let listArtifactsErrorCount = 0;
+    for (;;) {
+        try {
+            const artifacts = await listArgentArtifactsAsync({ toolsUrl, toolsAuthToken });
+            listArtifactsErrorCount = 0;
+            for (const artifact of artifacts) {
+                if (seenArtifactIds.has(artifact.id)) {
+                    continue;
+                }
+                seenArtifactIds.add(artifact.id);
+                void uploadArgentArtifactAsync(ctx, {
+                    deviceRunSessionId,
+                    toolsUrl,
+                    toolsAuthToken,
+                    artifact,
+                    logger,
+                }).catch(err => {
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    sentry_1.Sentry.capture('Could not upload Argent remote session artifact', error);
+                    logger.warn({ err: error }, 'Could not upload Argent remote session artifact.');
+                });
+            }
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            listArtifactsErrorCount += 1;
+            if (listArtifactsErrorCount === 1 || listArtifactsErrorCount % 5 === 0) {
+                sentry_1.Sentry.capture('Could not list Argent remote session artifacts', error);
+                logger.warn({ err: error, failedArtifactListCount: listArtifactsErrorCount }, 'Could not list Argent remote session artifacts.');
+            }
+        }
+        await (0, retry_1.sleepAsync)(ARGENT_ARTIFACT_UPLOAD_POLL_INTERVAL_MS);
+    }
+}
+async function listArgentArtifactsAsync({ toolsUrl, toolsAuthToken, }) {
+    const response = await (0, node_fetch_1.default)(new URL('/artifacts', toolsUrl).toString(), {
+        headers: toolsAuthToken ? { Authorization: `Bearer ${toolsAuthToken}` } : {},
+    });
+    if (!response.ok) {
+        throw new eas_build_job_1.SystemError(`Failed to list Argent artifacts: ${response.status} ${response.statusText}`);
+    }
+    const result = ArgentArtifactsListResponseSchema.safeParse(await response.json());
+    if (!result.success) {
+        throw new eas_build_job_1.SystemError(`Invalid Argent artifacts response: ${result.error.message}`);
+    }
+    return result.data.artifacts;
+}
+async function uploadArgentArtifactAsync(ctx, { deviceRunSessionId, toolsUrl, toolsAuthToken, artifact, logger, }) {
+    const filename = artifact.isDirectory ? `${artifact.filename}.tar.gz` : artifact.filename;
+    logger.info(`Downloading artifact ${filename}.`);
+    const temporaryDirectory = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), 'argent-artifact-'));
+    try {
+        const temporaryArtifactPath = node_path_1.default.join(temporaryDirectory, node_path_1.default.basename(filename));
+        await downloadArgentArtifactToFileAsync({
+            artifact,
+            toolsUrl,
+            toolsAuthToken,
+            destinationPath: temporaryArtifactPath,
+        });
+        const { size } = await (0, promises_1.stat)(temporaryArtifactPath);
+        logger.info(`Uploading artifact ${filename} (${(0, artifacts_1.formatBytes)(size)}).`);
+        await (0, deviceRunSessionArtifacts_1.uploadDeviceRunSessionArtifactAsync)(ctx, {
+            deviceRunSessionId,
+            artifactId: artifact.id,
+            name: `${filename} (${artifact.id})`,
+            filename,
+            size,
+            stream: (0, node_fs_1.createReadStream)(temporaryArtifactPath),
+        });
+    }
+    finally {
+        await (0, promises_1.rm)(temporaryDirectory, { recursive: true, force: true });
+    }
+}
+async function downloadArgentArtifactToFileAsync({ artifact, toolsUrl, toolsAuthToken, destinationPath, }) {
+    const response = await (0, node_fetch_1.default)(new URL(`/artifacts/${artifact.id}`, toolsUrl).toString(), {
+        headers: toolsAuthToken ? { Authorization: `Bearer ${toolsAuthToken}` } : {},
+    });
+    if (!response.ok) {
+        throw new eas_build_job_1.SystemError(`Failed to download Argent artifact ${artifact.id}: ${response.status} ${response.statusText}`);
+    }
+    if (!response.body) {
+        throw new eas_build_job_1.SystemError(`Argent artifact ${artifact.id} response did not include a readable body.`);
+    }
+    await (0, promises_2.pipeline)(response.body, (0, node_fs_1.createWriteStream)(destinationPath));
+}

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

@@ -0,0 +1,9 @@
+import { CustomBuildContext } from '../../customBuildContext';
+export declare function uploadDeviceRunSessionArtifactAsync(ctx: CustomBuildContext, { deviceRunSessionId, artifactId, name, filename, size, stream, }: {
+    deviceRunSessionId: string;
+    artifactId: string;
+    name: string;
+    filename: string;
+    size: number;
+    stream: NodeJS.ReadableStream;
+}): Promise<void>;

package/dist/steps/utils/deviceRunSessionArtifacts.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadDeviceRunSessionArtifactAsync = uploadDeviceRunSessionArtifactAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const gql_tada_1 = require("gql.tada");
+const node_fetch_1 = __importStar(require("node-fetch"));
+const CREATE_DEVICE_RUN_SESSION_ARTIFACT_UPLOAD_SESSION_MUTATION = (0, gql_tada_1.graphql)(`
+  mutation CreateDeviceRunSessionArtifactUploadSession(
+    $deviceRunSessionId: ID!
+    $input: CreateDeviceRunSessionArtifactUploadSessionInput!
+  ) {
+    deviceRunSession {
+      createArtifactUploadSession(deviceRunSessionId: $deviceRunSessionId, input: $input) {
+        uploadSession {
+          url
+          headers
+        }
+      }
+    }
+  }
+`);
+async function uploadDeviceRunSessionArtifactAsync(ctx, { deviceRunSessionId, artifactId, name, filename, size, stream, }) {
+    const uploadSession = await createDeviceRunSessionArtifactUploadSessionAsync(ctx, {
+        deviceRunSessionId,
+        artifactId,
+        name,
+        filename,
+        size,
+    });
+    const response = await (0, node_fetch_1.default)(uploadSession.url, {
+        method: 'PUT',
+        headers: new node_fetch_1.Headers(uploadSession.headers),
+        body: stream,
+    });
+    if (!response.ok) {
+        throw new eas_build_job_1.SystemError(`Failed to upload device run session artifact ${artifactId}: ${response.status} ${response.statusText}`, { cause: response });
+    }
+}
+async function createDeviceRunSessionArtifactUploadSessionAsync(ctx, { deviceRunSessionId, artifactId, name, filename, size, }) {
+    const result = await ctx.graphqlClient
+        .mutation(CREATE_DEVICE_RUN_SESSION_ARTIFACT_UPLOAD_SESSION_MUTATION, {
+        deviceRunSessionId,
+        input: {
+            name,
+            filename,
+            size,
+        },
+    })
+        .toPromise();
+    if (result.error) {
+        throw new eas_build_job_1.SystemError(`Failed to create upload session for device run session artifact ${artifactId}: ${result.error.message}`, { cause: result.error });
+    }
+    return result.data.deviceRunSession.createArtifactUploadSession.uploadSession;
+}

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

@@ -11,6 +11,10 @@ declare const TurnIceServersSchema: z.ZodArray<z.ZodObject<{
     credential: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>>;
 export type TurnIceServers = z.infer<typeof TurnIceServersSchema>;
+export declare function selectXcodeDeveloperDirectoryAsync({ env, logger, }: {
+    env: BuildStepEnv;
+    logger: bunyan;
+}): Promise<void>;
 /**
  * Translate Cloudflare ICE servers into serve-sim CLI flags: `--stun-url` (the
  * credential-less entries) and `--turn-url`/`--turn-username`/`--turn-credential`

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -39,6 +39,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDeviceRunSessionIdOrThrow = getDeviceRunSessionIdOrThrow;
 exports.getNgrokTunnelDomainOrThrow = getNgrokTunnelDomainOrThrow;
 exports.getNgrokAuthtokenOrThrow = getNgrokAuthtokenOrThrow;
+exports.selectXcodeDeveloperDirectoryAsync = selectXcodeDeveloperDirectoryAsync;
 exports.turnIceServersToServeSimArgs = turnIceServersToServeSimArgs;
 exports.fetchServeSimTurnArgsAsync = fetchServeSimTurnArgsAsync;
 exports.uploadRemoteSessionConfigAsync = uploadRemoteSessionConfigAsync;
@@ -47,6 +48,7 @@ exports.startServeSimWithTunnelAsync = startServeSimWithTunnelAsync;
 exports.startNgrokTunnelAsync = startNgrokTunnelAsync;
 exports.waitForFileAsync = waitForFileAsync;
 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"));
 const ngrok = __importStar(require("@ngrok/ngrok"));
 const gql_tada_1 = require("gql.tada");
@@ -57,6 +59,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const sentry_1 = require("../../sentry");
 const retry_1 = require("../../utils/retry");
 const turtleFetch_1 = require("../../utils/turtleFetch");
+const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
 const START_DEVICE_RUN_SESSION_MUTATION = (0, gql_tada_1.graphql)(`
   mutation StartDeviceRunSession($deviceRunSessionId: ID!, $remoteConfig: JSONObject!) {
     deviceRunSession {
@@ -102,6 +105,18 @@ const TurnIceServersSchema = zod_1.z.array(zod_1.z.object({
     username: zod_1.z.string().optional(),
     credential: zod_1.z.string().optional(),
 }));
+async function selectXcodeDeveloperDirectoryAsync({ env, logger, }) {
+    if (process.env.ENVIRONMENT === 'development') {
+        logger.info('Job running outside of EAS, not selecting Xcode developer directory.');
+        return;
+    }
+    logger.info(`Selecting Xcode developer directory: ${XCODE_DEVELOPER_DIR}.`);
+    await (0, steps_1.spawnAsync)('sudo', ['xcode-select', '-s', XCODE_DEVELOPER_DIR], {
+        env,
+        logger,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+}
 const TurnIceServersResponseSchema = zod_1.z.object({
     data: zod_1.z.object({
         iceServers: TurnIceServersSchema,

package/dist/utils/IosSimulatorUtils.d.ts

@@ -39,6 +39,10 @@ export declare namespace IosSimulatorUtils {
         destinationDeviceName: IosSimulatorName;
         env: NodeJS.ProcessEnv;
     }): Promise<void>;
+    export function enableAccessibilitySettingsAsync({ deviceIdentifier, env, }: {
+        deviceIdentifier: IosSimulatorUuid | IosSimulatorName;
+        env: NodeJS.ProcessEnv;
+    }): Promise<void>;
     export function startAsync({ deviceIdentifier, env, }: {
         deviceIdentifier: IosSimulatorUuid | IosSimulatorName;
         env: NodeJS.ProcessEnv;

package/dist/utils/IosSimulatorUtils.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IosSimulatorUtils = void 0;
+const eas_build_job_1 = require("@expo/eas-build-job");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
@@ -37,6 +38,45 @@ var IosSimulatorUtils;
         });
     }
     IosSimulatorUtils.cloneAsync = cloneAsync;
+    async function enableAccessibilitySettingsAsync({ deviceIdentifier, env, }) {
+        try {
+            const devices = await getAvailableDevicesAsync({ env, filter: 'available' });
+            const device = devices.find(device => device.isAvailable &&
+                (device.udid === deviceIdentifier || device.name === deviceIdentifier));
+            if (!device) {
+                throw new eas_build_job_1.UserError('EAS_IOS_SIMULATOR_NOT_FOUND', `Failed to find available iOS Simulator "${deviceIdentifier}" to update accessibility settings.`);
+            }
+            if (device.state !== 'Shutdown') {
+                throw new eas_build_job_1.UserError('EAS_IOS_SIMULATOR_NOT_SHUTDOWN', `Expected iOS Simulator "${deviceIdentifier}" to be shutdown before updating accessibility settings, but it is ${device.state}.`);
+            }
+            const plistPath = node_path_1.default.join(device.dataPath, 'Library', 'Preferences', 'com.apple.Accessibility.plist');
+            await node_fs_1.default.promises.mkdir(node_path_1.default.dirname(plistPath), { recursive: true });
+            const plistExists = await node_fs_1.default.promises
+                .access(plistPath)
+                .then(() => true)
+                .catch(() => false);
+            if (!plistExists) {
+                await (0, turtle_spawn_1.default)('plutil', ['-create', 'binary1', plistPath], { env });
+            }
+            for (const key of [
+                'AutomationEnabled',
+                'IgnoreAXServerEntitlements',
+                'AccessibilityEnabled',
+                'ApplicationAccessibilityEnabled',
+            ]) {
+                await (0, turtle_spawn_1.default)('plutil', ['-replace', key, '-bool', 'true', plistPath], { env });
+            }
+        }
+        catch (err) {
+            if (err instanceof eas_build_job_1.ExpoError) {
+                throw err;
+            }
+            throw new eas_build_job_1.SystemError('Failed to update iOS Simulator accessibility settings.', {
+                cause: err,
+            });
+        }
+    }
+    IosSimulatorUtils.enableAccessibilitySettingsAsync = enableAccessibilitySettingsAsync;
     async function startAsync({ deviceIdentifier, env, }) {
         const bootstatusResult = await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'bootstatus', deviceIdentifier, '-b'], {
             env,

package/dist/utils/expoUpdates.js

@@ -173,6 +173,11 @@ async function isEASUpdateConfigured(ctx) {
 }
 async function logDiffFingerprints({ resolvedRuntime, ctx, }) {
     const { resolvedRuntimeVersion, resolvedFingerprintSources } = resolvedRuntime;
+    const buildId = ctx.env.EAS_BUILD_ID;
+    if (!buildId) {
+        ctx.logger.warn('Skipping fingerprint diff because EAS_BUILD_ID is not set');
+        return;
+    }
     const fingerprintInfo = await ctx.graphqlClient
         .query((0, gql_tada_1.graphql)(`
         query GetFingerprintUrl($id: ID!) {
@@ -184,7 +189,7 @@ async function logDiffFingerprints({ resolvedRuntime, ctx, }) {
             }
           }
         }
-      `), { id: ctx.env.EAS_BUILD_ID })
+      `), { id: buildId })
         .toPromise();
     if (fingerprintInfo.error) {
         ctx.logger.warn('Failed to fetch current fingerprint info', fingerprintInfo.error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "20.3.0",
+  "version": "20.5.1",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -38,14 +38,14 @@
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
     "@expo/downloader": "20.0.0",
-    "@expo/eas-build-job": "20.1.0",
+    "@expo/eas-build-job": "20.5.1",
     "@expo/env": "^0.4.0",
     "@expo/logger": "20.0.0",
     "@expo/package-manager": "1.9.10",
     "@expo/plist": "^0.2.0",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "20.1.0",
+    "@expo/steps": "20.5.1",
     "@expo/template-file": "20.0.0",
     "@expo/turtle-spawn": "20.0.0",
     "@expo/xcpretty": "^4.3.1",
@@ -100,5 +100,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "490457976c996d06447e6442fbd1aec1ace09f1b"
+  "gitHead": "cd47185f29446299b7682d52cd917eb9a01038e7"
 }