@expo/build-tools 20.3.0 → 20.4.0

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;

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/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/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/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/package.json

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