@expo/build-tools 20.1.0 → 20.2.0

package/dist/builders/custom.js

@@ -13,6 +13,7 @@ const path_1 = __importDefault(require("path"));
 const easBuildInternal_1 = require("../common/easBuildInternal");
 const projectSources_1 = require("../common/projectSources");
 const customBuildContext_1 = require("../customBuildContext");
+const datadog_1 = require("../datadog");
 const xcodeBuildLogs_1 = require("../ios/xcodeBuildLogs");
 const easFunctionGroups_1 = require("../steps/easFunctionGroups");
 const easFunctions_1 = require("../steps/easFunctions");
@@ -68,6 +69,7 @@ async function runCustomBuildAsync(ctx) {
             throw parseError;
         }
     });
+    logUserProvidedCustomFunctions(workflow);
     try {
         try {
             await workflow.executeAsync();
@@ -92,3 +94,24 @@ async function runCustomBuildAsync(ctx) {
     }
     return ctx.artifacts;
 }
+function logUserProvidedCustomFunctions(workflow) {
+    for (const buildFunction of Object.values(workflow.buildFunctions)) {
+        if (!buildFunction.customFunctionModulePath) {
+            continue;
+        }
+        datadog_1.Datadog.log('Custom build saw user-provided function', {
+            event: 'custom_build_user_provided_function',
+            custom_function_id: buildFunction.getFullId(),
+            custom_function_module_path: buildFunction.customFunctionModulePath,
+            custom_function_input_count: String(buildFunction.inputProviders?.length ?? 0),
+            custom_function_output_count: String(buildFunction.outputProviders?.length ?? 0),
+            ...(buildFunction.name ? { custom_function_name: buildFunction.name } : {}),
+            ...(buildFunction.shell ? { custom_function_shell: buildFunction.shell } : {}),
+            ...(buildFunction.supportedRuntimePlatforms
+                ? {
+                    custom_function_supported_runtime_platforms: buildFunction.supportedRuntimePlatforms.join(','),
+                }
+                : {}),
+        });
+    }
+}

package/dist/common/installDependencies.d.ts

@@ -2,14 +2,23 @@ import { Job } from '@expo/eas-build-job';
 import { SpawnOptions, SpawnPromise, SpawnResult } from '@expo/turtle-spawn';
 import { BuildContext } from '../context';
 import { PackageManager } from '../utils/packageManager';
-export declare function installDependenciesAsync({ packageManager, env, logger, infoCallbackFn, cwd, useFrozenLockfile, }: {
+export declare function installDependenciesAsync({ packageManager, env, logger, infoCallbackFn, lineTransformer, cwd, useFrozenLockfile, }: {
     packageManager: PackageManager;
     env: Record<string, string | undefined>;
     cwd: string;
     logger: Exclude<SpawnOptions['logger'], undefined>;
     infoCallbackFn?: SpawnOptions['infoCallbackFn'];
+    lineTransformer?: SpawnOptions['lineTransformer'];
     useFrozenLockfile: boolean;
 }): Promise<{
     spawnPromise: SpawnPromise<SpawnResult>;
 }>;
+export declare function installDependenciesWithNpmCacheFallbackAsync({ packageManager, env, logger, infoCallbackFn, cwd, useFrozenLockfile, }: {
+    packageManager: PackageManager;
+    env: Record<string, string | undefined>;
+    cwd: string;
+    logger: Exclude<SpawnOptions['logger'], undefined>;
+    infoCallbackFn?: SpawnOptions['infoCallbackFn'];
+    useFrozenLockfile: boolean;
+}): Promise<void>;
 export declare function resolvePackagerDir(ctx: BuildContext<Job>): string;

package/dist/common/installDependencies.js

@@ -4,12 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.installDependenciesAsync = installDependenciesAsync;
+exports.installDependenciesWithNpmCacheFallbackAsync = installDependenciesWithNpmCacheFallbackAsync;
 exports.resolvePackagerDir = resolvePackagerDir;
+const eas_build_job_1 = require("@expo/eas-build-job");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
 const path_1 = __importDefault(require("path"));
+const sentry_1 = require("../sentry");
 const packageManager_1 = require("../utils/packageManager");
 const project_1 = require("../utils/project");
-async function installDependenciesAsync({ packageManager, env, logger, infoCallbackFn, cwd, useFrozenLockfile, }) {
+async function installDependenciesAsync({ packageManager, env, logger, infoCallbackFn, lineTransformer, cwd, useFrozenLockfile, }) {
     let args;
     switch (packageManager) {
         case packageManager_1.PackageManager.NPM: {
@@ -60,10 +63,67 @@ async function installDependenciesAsync({ packageManager, env, logger, infoCallb
             cwd,
             logger,
             infoCallbackFn,
+            lineTransformer,
             env,
         }),
     };
 }
+async function installDependenciesWithNpmCacheFallbackAsync({ packageManager, env, logger, infoCallbackFn, cwd, useFrozenLockfile, }) {
+    const npmCacheUrl = env.NPM_CONFIG_REGISTRY;
+    let firstErrorLine;
+    let errorLineCount = 0;
+    try {
+        await (await installDependenciesAsync({
+            packageManager,
+            env,
+            logger,
+            infoCallbackFn,
+            lineTransformer: (line) => {
+                if (isNpmCacheRegistryErrorLine(line, { env, npmCacheUrl })) {
+                    firstErrorLine ??= line;
+                    errorLineCount += 1;
+                }
+                return line;
+            },
+            cwd,
+            useFrozenLockfile,
+        })).spawnPromise;
+        if (firstErrorLine) {
+            sentry_1.Sentry.capture(new NpmCacheRegistryNonFatalError(), {
+                level: 'warning',
+                tags: { packageManager },
+                extras: { cwd, npmCacheUrl, useFrozenLockfile, firstErrorLine, errorLineCount },
+            });
+        }
+    }
+    catch (err) {
+        if (!isNpmCacheInstallFailure(err, { env, npmCacheUrl })) {
+            throw err;
+        }
+        logger.warn(`Failed to install dependencies using the npm cache registry (${npmCacheUrl}). Retrying without the npm cache registry.`);
+        sentry_1.Sentry.capture(new NpmCacheRegistryInstallError(err), {
+            level: 'warning',
+            tags: { packageManager },
+            extras: {
+                cwd,
+                npmCacheUrl,
+                useFrozenLockfile,
+                originalErrorMessage: err instanceof Error ? err.message : String(err),
+                status: err instanceof Error ? err.status : undefined,
+                signal: err instanceof Error ? err.signal : undefined,
+            },
+        });
+        const { NPM_CONFIG_REGISTRY: _NPM_CONFIG_REGISTRY, ...fallbackEnv } = env;
+        await (await installDependenciesAsync({
+            packageManager,
+            env: fallbackEnv,
+            logger,
+            infoCallbackFn,
+            cwd,
+            useFrozenLockfile,
+        })).spawnPromise;
+    }
+}
 function resolvePackagerDir(ctx) {
     const packagerRunDir = (0, packageManager_1.findPackagerRootDir)(ctx.getReactNativeProjectDirectory());
     if (packagerRunDir !== ctx.getReactNativeProjectDirectory()) {
@@ -72,3 +132,37 @@ function resolvePackagerDir(ctx) {
     }
     return packagerRunDir;
 }
+function isNpmCacheInstallFailure(err, { env, npmCacheUrl }) {
+    if (!isNpmCacheRegistryEnabled(env, npmCacheUrl)) {
+        return false;
+    }
+    const errorOutput = getErrorOutput(err);
+    return errorOutput.includes(npmCacheUrl);
+}
+function isNpmCacheRegistryErrorLine(line, { env, npmCacheUrl }) {
+    return (isNpmCacheRegistryEnabled(env, npmCacheUrl) &&
+        line.includes(npmCacheUrl) &&
+        /(?:error|failed|ENOTFOUND|ECONN|ETIMEDOUT|EAI_AGAIN|FetchError)/i.test(line));
+}
+function isNpmCacheRegistryEnabled(env, npmCacheUrl) {
+    return env.EAS_USE_NPM_CACHE === '1' && !!npmCacheUrl;
+}
+function getErrorOutput(err) {
+    if (!(err instanceof Error)) {
+        return '';
+    }
+    const { stdout, stderr } = err;
+    return [stdout, stderr].filter(Boolean).join('\n');
+}
+class NpmCacheRegistryNonFatalError extends eas_build_job_1.SystemError {
+    name = 'NpmCacheRegistryNonFatalError';
+    constructor() {
+        super('Non-fatal npm cache registry error during dependency install');
+    }
+}
+class NpmCacheRegistryInstallError extends eas_build_job_1.SystemError {
+    name = 'NpmCacheRegistryInstallError';
+    constructor(cause) {
+        super('Failed to install dependencies using npm cache registry', { cause });
+    }
+}

package/dist/common/prebuild.js

@@ -19,15 +19,14 @@ async function prebuildAsync(ctx, { logger, workingDir, options }) {
         options: spawnOptions,
         packageManager: ctx.packageManager,
     });
-    const installDependenciesSpawnPromise = (await (0, installDependencies_1.installDependenciesAsync)({
+    await (0, installDependencies_1.installDependenciesWithNpmCacheFallbackAsync)({
         packageManager: ctx.packageManager,
         env: ctx.env,
         logger,
         cwd: (0, installDependencies_1.resolvePackagerDir)(ctx),
         // prebuild sometimes modifies package.json, so we don't want to use frozen lockfile
         useFrozenLockfile: false,
-    })).spawnPromise;
-    await installDependenciesSpawnPromise;
+    });
 }
 function getPrebuildCommandArgs(ctx) {
     let prebuildCommand = ctx.job.experimental?.prebuildCommand ?? `prebuild --no-install --platform ${ctx.job.platform}`;

package/dist/{ios → common}/xcpretty.d.ts

@@ -4,6 +4,7 @@ export declare class XcodeBuildLogger {
     private readonly projectRoot;
     private loggerError?;
     private flushing;
+    private reportedFormatterError;
     private logReaderPromise?;
     private logsPath?;
     constructor(logger: bunyan, projectRoot: string);

package/dist/{ios → common}/xcpretty.js

@@ -10,12 +10,14 @@ const assert_1 = __importDefault(require("assert"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
+const sentry_1 = require("../sentry");
 const CHECK_FILE_INTERVAL_MS = 1000;
 class XcodeBuildLogger {
     logger;
     projectRoot;
     loggerError;
     flushing = false;
+    reportedFormatterError = false;
     logReaderPromise;
     logsPath;
     constructor(logger, projectRoot) {
@@ -62,9 +64,22 @@ class XcodeBuildLogger {
             this.logReaderPromise = (0, spawn_async_1.default)('tail', ['-n', '+0', '-f', logsPath], { stdio: 'pipe' });
             (0, assert_1.default)(this.logReaderPromise.child.stdout, 'stdout is not available');
             this.logReaderPromise.child.stdout.on('data', (data) => {
-                const lines = formatter.pipe(data.toString());
-                for (const line of lines) {
-                    this.logger.info(line);
+                try {
+                    const lines = formatter.pipe(data.toString());
+                    for (const line of lines) {
+                        this.logger.info(line);
+                    }
+                }
+                catch (err) {
+                    // The formatter can throw on unexpected xcodebuild output. Fall back to
+                    // raw logs instead of crashing the process with an uncaught exception.
+                    if (!this.reportedFormatterError) {
+                        this.reportedFormatterError = true;
+                        sentry_1.Sentry.capture('xcpretty formatter failed to parse xcodebuild logs', err, {
+                            extras: { data: data.toString().slice(-2000) },
+                        });
+                    }
+                    this.logger.info(data.toString());
                 }
             });
             await this.logReaderPromise;

package/dist/datadog.js

@@ -5,6 +5,9 @@ const sentry_1 = require("./sentry");
 const turtleFetch_1 = require("./utils/turtleFetch");
 let setupOptions = null;
 let pendingUploads = [];
+function withTargetTag(tags, target) {
+    return { ...tags, target: target.kind === 'build' ? 'build' : 'job_run' };
+}
 exports.Datadog = {
     setup(opts) {
         setupOptions = opts;
@@ -19,7 +22,7 @@ exports.Datadog = {
                 name,
                 type: 'distribution',
                 value,
-                tags,
+                tags: withTargetTag(tags, target),
             },
         ];
         const metricsPath = target.kind === 'build'
@@ -43,9 +46,10 @@ exports.Datadog = {
             return;
         }
         const { expoApiV2BaseUrl, robotAccessToken, target } = setupOptions;
+        const tagsWithTarget = withTargetTag(tags, target);
         const log = target.kind === 'build'
-            ? { buildId: target.turtleBuildId, message, tags }
-            : { jobRunId: target.turtleJobRunId, message, tags };
+            ? { buildId: target.turtleBuildId, message, tags: tagsWithTarget }
+            : { jobRunId: target.turtleJobRunId, message, tags: tagsWithTarget };
         const logsPath = target.kind === 'build' ? 'turtle-builds/logs' : 'turtle-job-runs/logs';
         const uploadPromise = (0, turtleFetch_1.turtleFetch)(new URL(logsPath, expoApiV2BaseUrl).toString(), 'POST', {
             json: log,

package/dist/index.d.ts

@@ -11,3 +11,4 @@ export type { GradleProfileTask } from './android/gradleProfile';
 export * from './generic';
 export { Datadog } from './datadog';
 export { Sentry } from './sentry';
+export * from './runtimeSettings';

package/dist/index.js

@@ -64,3 +64,4 @@ var datadog_1 = require("./datadog");
 Object.defineProperty(exports, "Datadog", { enumerable: true, get: function () { return datadog_1.Datadog; } });
 var sentry_1 = require("./sentry");
 Object.defineProperty(exports, "Sentry", { enumerable: true, get: function () { return sentry_1.Sentry; } });
+__exportStar(require("./runtimeSettings"), exports);

package/dist/ios/fastlane.js

@@ -14,8 +14,8 @@ const path_1 = __importDefault(require("path"));
 const fastfile_1 = require("./fastfile");
 const gymfile_1 = require("./gymfile");
 const tvos_1 = require("./tvos");
-const xcpretty_1 = require("./xcpretty");
 const fastlane_1 = require("../common/fastlane");
+const xcpretty_1 = require("../common/xcpretty");
 const context_1 = require("../context");
 async function runFastlaneGym(ctx, { scheme, buildConfiguration, credentials, entitlements, extraEnv, }) {
     const workspacePath = path_1.default.join(ctx.getReactNativeProjectDirectory(), 'ios');

package/dist/ios/pod.js

@@ -42,7 +42,7 @@ async function resolvePrecompiledModulesPodInstallEnvAsync(ctx) {
         ctx.logger.info('EXPO_USE_PRECOMPILED_MODULES=0 is set; not enabling precompiled modules use.');
         return {};
     }
-    if (ctx.job.builderEnvironment?.env?.EAS_USE_PRECOMPILED_MODULES !== '1') {
+    if (ctx.env.EAS_USE_PRECOMPILED_MODULES !== '1') {
         return {};
     }
     let expoPackageVersion;

package/dist/runtimeSettings.d.ts

@@ -0,0 +1,12 @@
+import { Env } from '@expo/eas-build-job';
+export declare namespace RuntimeSettings {
+    function loadAsync({ environment, env: nextRuntimeEnvironment, }: {
+        environment: string;
+        env?: Env;
+    }): Promise<void>;
+    function isUsingIosPrecompiledModulesEnabled(): boolean;
+    function getNpmCacheUrl(): string | null;
+    function getNodeJsCacheUrl(): string | null;
+    function getMavenCacheUrl(): string | null;
+    function getCocoapodsCacheUrl(): string | null;
+}

package/dist/runtimeSettings.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeSettings = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const zod_1 = require("zod");
+const sentry_1 = require("./sentry");
+const ENVIRONMENT_TO_RUNTIME_SETTINGS_URL = {
+    staging: 'https://storage.googleapis.com/eas-workflows-staging/runtime-settings.json',
+    production: 'https://storage.googleapis.com/eas-workflows-production/runtime-settings.json',
+};
+const RuntimeSettingsSchema = zod_1.z
+    .object({
+    caches: zod_1.z.record(zod_1.z.string(), zod_1.z
+        .object({
+        npm: zod_1.z.boolean(),
+        nodejs: zod_1.z.boolean(),
+        maven: zod_1.z.boolean(),
+        cocoapods: zod_1.z.boolean(),
+    })
+        .partial()),
+    iosPrecompiledModules: zod_1.z.boolean(),
+})
+    .partial();
+let runtimeSettings = {};
+let runtimeEnvironment = {};
+var RuntimeSettings;
+(function (RuntimeSettings) {
+    async function loadAsync({ environment, env: nextRuntimeEnvironment = {}, }) {
+        runtimeEnvironment = nextRuntimeEnvironment;
+        const url = ENVIRONMENT_TO_RUNTIME_SETTINGS_URL[environment];
+        if (!url) {
+            return;
+        }
+        try {
+            const response = await (0, node_fetch_1.default)(url, {
+                signal: AbortSignal.timeout(1000),
+            });
+            if (!response.ok) {
+                sentry_1.Sentry.capture('Failed to fetch worker runtime settings', {
+                    extras: { url, status: response.status },
+                    level: 'warning',
+                });
+                return;
+            }
+            runtimeSettings = RuntimeSettingsSchema.parse(await response.json());
+            if (runtimeSettings.caches && !runtimeSettings.caches[process.platform]) {
+                sentry_1.Sentry.capture(new Error(`Runtime settings are missing cache settings for platform "${process.platform}"`), {
+                    extras: {
+                        configuredPlatforms: Object.keys(runtimeSettings.caches),
+                        platform: process.platform,
+                    },
+                    level: 'error',
+                });
+            }
+        }
+        catch (err) {
+            sentry_1.Sentry.capture('Failed to load worker runtime settings', err instanceof Error ? err : new Error(String(err)), {
+                extras: { url },
+                level: 'warning',
+            });
+        }
+    }
+    RuntimeSettings.loadAsync = loadAsync;
+    function isUsingIosPrecompiledModulesEnabled() {
+        return runtimeSettings.iosPrecompiledModules ?? false;
+    }
+    RuntimeSettings.isUsingIosPrecompiledModulesEnabled = isUsingIosPrecompiledModulesEnabled;
+    function getNpmCacheUrl() {
+        if (runtimeEnvironment['EAS_BUILD_DISABLE_NPM_CACHE'] === '1') {
+            return null;
+        }
+        const runtimeEnabled = runtimeSettings.caches?.[process.platform]?.npm;
+        if (runtimeEnabled === false) {
+            return null;
+        }
+        const envOverride = runtimeEnvironment['EAS_USE_NPM_CACHE'];
+        const enabled = envOverride === '1' || (envOverride !== '0' && runtimeEnabled);
+        return enabled ? process.env.EAS_NPM_CACHE_URL || null : null;
+    }
+    RuntimeSettings.getNpmCacheUrl = getNpmCacheUrl;
+    function getNodeJsCacheUrl() {
+        const runtimeEnabled = runtimeSettings.caches?.[process.platform]?.nodejs;
+        if (runtimeEnabled === false) {
+            return null;
+        }
+        const envOverride = runtimeEnvironment['EAS_USE_NODEJS_CACHE'];
+        const enabled = envOverride === '1' || (envOverride !== '0' && runtimeEnabled);
+        return enabled ? process.env.EAS_NODEJS_CACHE_URL || null : null;
+    }
+    RuntimeSettings.getNodeJsCacheUrl = getNodeJsCacheUrl;
+    function getMavenCacheUrl() {
+        if (runtimeEnvironment['EAS_BUILD_DISABLE_MAVEN_CACHE'] === '1') {
+            return null;
+        }
+        const runtimeEnabled = runtimeSettings.caches?.[process.platform]?.maven;
+        if (runtimeEnabled === false) {
+            return null;
+        }
+        const envOverride = runtimeEnvironment['EAS_USE_MAVEN_CACHE'];
+        const enabled = envOverride === '1' || (envOverride !== '0' && runtimeEnabled);
+        return enabled ? process.env.EAS_MAVEN_CACHE_URL || null : null;
+    }
+    RuntimeSettings.getMavenCacheUrl = getMavenCacheUrl;
+    function getCocoapodsCacheUrl() {
+        if (runtimeEnvironment['EAS_BUILD_DISABLE_COCOAPODS_CACHE'] === '1') {
+            return null;
+        }
+        const runtimeEnabled = runtimeSettings.caches?.[process.platform]?.cocoapods;
+        if (runtimeEnabled === false) {
+            return null;
+        }
+        const envOverride = runtimeEnvironment['EAS_USE_COCOAPODS_CACHE'];
+        const enabled = envOverride === '1' || (envOverride !== '0' && runtimeEnabled);
+        return enabled ? process.env.EAS_COCOAPODS_CACHE_URL || null : null;
+    }
+    RuntimeSettings.getCocoapodsCacheUrl = getCocoapodsCacheUrl;
+})(RuntimeSettings || (exports.RuntimeSettings = RuntimeSettings = {}));

package/dist/steps/easFunctions.js

@@ -57,7 +57,7 @@ function getEasFunctions(ctx) {
         (0, installNodeModules_1.createInstallNodeModulesBuildFunction)(),
         (0, prebuild_1.createPrebuildBuildFunction)(),
         (0, readIpaInfo_1.createReadIpaInfoBuildFunction)(),
-        (0, downloadBuild_1.createDownloadBuildFunction)(),
+        (0, downloadBuild_1.createDownloadBuildFunction)(ctx),
         (0, export_1.createEasExportBuildFunction)(),
         (0, deploy_1.createEasDeployBuildFunction)(),
         (0, repack_1.createRepackBuildFunction)(),

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

@@ -1,10 +1,12 @@
 import { bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
-export declare function createDownloadBuildFunction(): BuildFunction;
-export declare function downloadBuildAsync({ logger, buildId, expoApiServerURL, robotAccessToken, extensions, }: {
+import { Client } from '@urql/core';
+import { CustomBuildContext } from '../../customBuildContext';
+export declare function createDownloadBuildFunction(ctx: CustomBuildContext): BuildFunction;
+export declare function downloadBuildAsync({ logger, buildId, graphqlClient, robotAccessToken, extensions, }: {
     logger: bunyan;
     buildId: string;
-    expoApiServerURL: string;
+    graphqlClient: Client;
     robotAccessToken: string | null;
     extensions: string[];
 }): Promise<{

package/dist/steps/functions/downloadBuild.js

@@ -9,6 +9,7 @@ const eas_build_job_1 = require("@expo/eas-build-job");
 const results_1 = require("@expo/results");
 const steps_1 = require("@expo/steps");
 const fast_glob_1 = require("fast-glob");
+const gql_tada_1 = require("gql.tada");
 const node_fetch_1 = __importDefault(require("node-fetch"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
@@ -21,7 +22,20 @@ const files_1 = require("../../utils/files");
 const retryOnDNSFailure_1 = require("../../utils/retryOnDNSFailure");
 const strings_1 = require("../../utils/strings");
 const streamPipeline = (0, util_1.promisify)(stream_1.default.pipeline);
-function createDownloadBuildFunction() {
+const BUILD_BY_ID_QUERY = (0, gql_tada_1.graphql)(`
+  query DownloadBuildByIdQuery($buildId: ID!) {
+    builds {
+      byId(buildId: $buildId) {
+        id
+        platform
+        artifacts {
+          applicationArchiveUrl
+        }
+      }
+    }
+  }
+`);
+function createDownloadBuildFunction(ctx) {
     return new steps_1.BuildFunction({
         namespace: 'eas',
         id: 'download_build',
@@ -55,7 +69,7 @@ function createDownloadBuildFunction() {
             const { artifactPath } = await downloadBuildAsync({
                 logger,
                 buildId,
-                expoApiServerURL: stepsCtx.global.staticContext.expoApiServerURL,
+                graphqlClient: ctx.graphqlClient,
                 robotAccessToken: stepsCtx.global.staticContext.job.secrets?.robotAccessToken ?? null,
                 extensions,
             });
@@ -63,9 +77,25 @@ function createDownloadBuildFunction() {
         },
     });
 }
-async function downloadBuildAsync({ logger, buildId, expoApiServerURL, robotAccessToken, extensions, }) {
+async function fetchApplicationArchiveUrlAsync({ buildId, graphqlClient, }) {
+    const result = await graphqlClient.query(BUILD_BY_ID_QUERY, { buildId }).toPromise();
+    if (result.error) {
+        const { error } = result;
+        const message = `Could not fetch build ${buildId}: ${error.message}`;
+        throw error.networkError || result.error.response?.status >= 500
+            ? new eas_build_job_1.SystemError(message, { cause: error })
+            : new eas_build_job_1.UserError('EAS_DOWNLOAD_BUILD_FETCH_FAILED', message, { cause: error });
+    }
+    const applicationArchiveUrl = result.data?.builds.byId?.artifacts?.applicationArchiveUrl;
+    if (!applicationArchiveUrl) {
+        throw new eas_build_job_1.UserError('EAS_DOWNLOAD_BUILD_NO_APPLICATION_ARCHIVE', 'Build does not have an application archive url');
+    }
+    return applicationArchiveUrl;
+}
+async function downloadBuildAsync({ logger, buildId, graphqlClient, robotAccessToken, extensions, }) {
     const downloadDestinationDirectory = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'download_build-downloaded-'));
-    const response = await (0, retryOnDNSFailure_1.retryOnDNSFailure)(node_fetch_1.default)(new URL(`/v2/artifacts/eas/${buildId}`, expoApiServerURL), {
+    const downloadUrl = await fetchApplicationArchiveUrlAsync({ buildId, graphqlClient });
+    const response = await (0, retryOnDNSFailure_1.retryOnDNSFailure)(node_fetch_1.default)(downloadUrl, {
         headers: robotAccessToken ? { Authorization: `Bearer ${robotAccessToken}` } : undefined,
     });
     if (!response.ok) {

package/dist/steps/functions/findAndUploadBuildArtifacts.js

@@ -23,14 +23,14 @@ function createFindAndUploadBuildArtifactsBuildFunction(ctx) {
                 await uploadApplicationArchivesAsync({ ctx, stepCtx });
             }
             catch (err) {
-                stepCtx.logger.error(`Failed to upload application archives.`, err);
+                stepCtx.logger.error({ err }, `Failed to upload application archives.`);
                 firstError ||= err;
             }
             try {
                 await uploadBuildArtifacts({ ctx, stepCtx });
             }
             catch (err) {
-                stepCtx.logger.error(`Failed to upload build artifacts.`, err);
+                stepCtx.logger.error({ err }, `Failed to upload build artifacts.`);
                 firstError ||= err;
             }
             if (ctx.job.platform === eas_build_job_1.Platform.IOS) {

package/dist/steps/functions/installMaestro.js

@@ -11,6 +11,7 @@ const assert_1 = __importDefault(require("assert"));
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
+const datadog_1 = require("../../datadog");
 function createInstallMaestroBuildFunction() {
     return new steps_1.BuildFunction({
         namespace: 'eas',
@@ -95,12 +96,22 @@ function createInstallMaestroBuildFunction() {
             }
             logger.info(`Maestro ${maestroVersionResult.value} is ready.`);
             outputs.maestro_version.set(maestroVersionResult.value);
+            datadog_1.Datadog.distribution('eas.maestro.install', 1, {
+                maestro_version: maestroVersionResult.value,
+            });
         },
     });
 }
 async function getMaestroVersion({ env }) {
-    const maestroVersion = await (0, turtle_spawn_1.default)('maestro', ['--version'], { stdio: 'pipe', env });
-    return maestroVersion.stdout.trim();
+    const { stdout } = await (0, turtle_spawn_1.default)('maestro', ['--version'], { stdio: 'pipe', env });
+    // `maestro --version` can print an analytics notice to stdout before the version,
+    // e.g. "Anonymous analytics enabled. To opt out, set MAESTRO_CLI_NO_ANALYTICS...\n2.0.10".
+    // Take the last version-looking token: the real version is printed after the notice, so
+    // this stays correct even if the notice itself contains a version-like string. Keeps the
+    // step output and the eas.maestro.install metric tag clean. Best-effort only: fall back to
+    // the raw output if none is found, so we never fail the build over a version string.
+    const versions = stdout.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/g);
+    return versions?.at(-1) ?? stdout.trim();
 }
 async function installMaestro({ global, version, logger, env, }) {
     logger.info('Fetching install script');

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

@@ -10,6 +10,7 @@ export interface MaestroFlowResult {
 }
 export interface JUnitTestCaseResult {
     name: string;
+    file: string | undefined;
     status: 'passed' | 'failed';
     duration: number;
     errorMessage: string | null;
@@ -17,6 +18,23 @@ export interface JUnitTestCaseResult {
     properties: Record<string, string>;
 }
 export declare function parseJUnitTestCases(junitDirectory: string): Promise<JUnitTestCaseResult[]>;
+export declare function isFileAttrRun(testcases: JUnitTestCaseResult[]): testcases is (JUnitTestCaseResult & {
+    file: string;
+})[];
+export declare function junitFileHasFileAttrs(junitFile: string): Promise<boolean>;
+export declare function parseMaestroResultsFromFileAttrs(junitDirectory: string): Promise<MaestroFlowResult[]>;
+/**
+ * Returns the `file=` paths of the failing testcases in the given attempt's
+ * JUnit file, or `null` when the result cannot be trusted (caller then falls
+ * back to dumb retry — re-run everything; never the legacy scan).
+ *
+ * Callers verify the report carries `file=` attributes first
+ * (junitFileHasFileAttrs).
+ */
+export declare function parseFailedFlowsFromFileAttrs(args: {
+    junitFile: string;
+    workingDirectory: string;
+}): Promise<string[] | null>;
 export declare function parseMaestroResults(junitDirectory: string, nameToPath: Map<string, string> | null): Promise<MaestroFlowResult[]>;
 /**
  * Returns the subset of `inputFlowPaths` whose testcases failed in the given