@expo/build-tools 18.8.1 → 18.10.0

package/dist/ios/pod.js

@@ -5,11 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.installPods = installPods;
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
+const semver_1 = __importDefault(require("semver"));
+const MIN_PRECOMPILED_MODULES_EXPO_VERSION = '55.0.18';
+// const PRECOMPILED_MODULES_BASE_URL = 'https://storage.googleapis.com/eas-build-precompiled-modules/';
 async function installPods(ctx, { infoCallbackFn }) {
     const iosDir = path_1.default.join(ctx.getReactNativeProjectDirectory(), 'ios');
     const verboseFlag = ctx.env['EAS_VERBOSE'] === '1' ? ['--verbose'] : [];
     const cocoapodsDeploymentFlag = ctx.env['POD_INSTALL_DEPLOYMENT'] === '1' ? ['--deployment'] : [];
+    const precompiledModulesEnv = await resolvePrecompiledModulesPodInstallEnvAsync(ctx);
     return {
         spawnPromise: (0, turtle_spawn_1.default)('pod', ['install', ...verboseFlag, ...cocoapodsDeploymentFlag], {
             cwd: iosDir,
@@ -17,6 +22,7 @@ async function installPods(ctx, { infoCallbackFn }) {
             env: {
                 ...ctx.env,
                 LANG: 'en_US.UTF-8',
+                ...precompiledModulesEnv,
             },
             lineTransformer: (line) => {
                 if (!line ||
@@ -31,3 +37,54 @@ async function installPods(ctx, { infoCallbackFn }) {
         }),
     };
 }
+async function resolvePrecompiledModulesPodInstallEnvAsync(ctx) {
+    if (ctx.job.builderEnvironment?.env?.EAS_USE_PRECOMPILED_MODULES !== '1') {
+        return {};
+    }
+    let expoPackageVersion;
+    try {
+        expoPackageVersion = await getInstalledExpoPackageVersionAsync(ctx);
+    }
+    catch (err) {
+        ctx.logger.info({ err }, 'Failed to detect installed Expo package version; not enabling precompiled modules use.');
+        return {};
+    }
+    const validExpoPackageVersion = semver_1.default.valid(expoPackageVersion);
+    if (!validExpoPackageVersion) {
+        ctx.logger.info(`Detected expo=${expoPackageVersion}; not enabling precompiled modules use because the installed Expo package version is not a valid semver version.`);
+        return {};
+    }
+    if (semver_1.default.lt(validExpoPackageVersion, MIN_PRECOMPILED_MODULES_EXPO_VERSION)) {
+        ctx.logger.info(`Detected expo=${validExpoPackageVersion}; not enabling precompiled modules use because precompiled modules require expo>=${MIN_PRECOMPILED_MODULES_EXPO_VERSION}.`);
+        return {};
+    }
+    // Start rollout with Expo precompiled modules only. Add third-party modules after this is stable.
+    const env = {
+        EXPO_USE_PRECOMPILED_MODULES: '1',
+        // EXPO_PRECOMPILED_MODULES_BASE_URL: getPrecompiledModulesBaseUrl(),
+    };
+    ctx.logger.info(`Detected expo=${validExpoPackageVersion}; enabling precompiled modules use. Installing pods with additional environment variables.\n${Object.entries(env)
+        .map(([key, value]) => `${key}=${value}`)
+        .join('\n')}\nPrecompiled modules pod install environment is configured.`);
+    return env;
+}
+async function getInstalledExpoPackageVersionAsync(ctx) {
+    const { stdout } = await (0, turtle_spawn_1.default)('node', ['--print', "require.resolve('expo/package.json')"], {
+        cwd: ctx.getReactNativeProjectDirectory(),
+        env: ctx.env,
+        stdio: 'pipe',
+    });
+    const expoPackageJsonPath = stdout.toString().trim();
+    return (await fs_extra_1.default.readJson(expoPackageJsonPath)).version;
+}
+// function getPrecompiledModulesBaseUrl<TJob extends Ios.Job>(ctx: BuildContext<TJob>): string {
+//   if (!ctx.env.EAS_BUILD_COCOAPODS_CACHE_URL) {
+//     return PRECOMPILED_MODULES_BASE_URL;
+//   }
+//
+//   const parsedUrl = new URL(PRECOMPILED_MODULES_BASE_URL);
+//   return PRECOMPILED_MODULES_BASE_URL.replace(
+//     `${parsedUrl.protocol}//${parsedUrl.host}`,
+//     `${ctx.env.EAS_BUILD_COCOAPODS_CACHE_URL.replace(/\/$/, '')}/${parsedUrl.host}`
+//   );
+// }

package/dist/steps/easFunctions.js

@@ -33,6 +33,7 @@ const restoreCache_1 = require("./functions/restoreCache");
 const parseXcactivitylog_1 = require("./functions/parseXcactivitylog");
 const runFastlane_1 = require("./functions/runFastlane");
 const runGradle_1 = require("./functions/runGradle");
+const maestroTests_1 = require("./functions/maestroTests");
 const saveBuildCache_1 = require("./functions/saveBuildCache");
 const saveCache_1 = require("./functions/saveCache");
 const sendSlackMessage_1 = require("./functions/sendSlackMessage");
@@ -85,6 +86,7 @@ function getEasFunctions(ctx) {
         (0, createSubmissionEntity_1.createSubmissionEntityFunction)(),
         (0, uploadToAsc_1.createUploadToAscBuildFunction)(),
         (0, reportMaestroTestResults_1.createReportMaestroTestResultsFunction)(ctx),
+        (0, maestroTests_1.createMaestroTestsBuildFunction)(),
     ];
     if (ctx.hasBuildJob()) {
         functions.push(...[

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

@@ -39,4 +39,16 @@ type FlowMetadata = z.output<typeof FlowMetadataFileSchema>;
  */
 export declare function parseFlowMetadata(filePath: string): Promise<FlowMetadata | null>;
 export declare function parseMaestroResults(junitDirectory: string, testsDirectory: string, projectRoot: string): Promise<MaestroFlowResult[]>;
+/**
+ * Copies the highest-attempt-index *.xml file from sourceDir to outputPath.
+ * After the maestro retry loop completes, this produces a single canonical
+ * JUnit report at final_report_path matching the bash step's "cp latest
+ * attempt" semantics.
+ *
+ * Throws if sourceDir contains no *.xml files or if the copy fails.
+ */
+export declare function copyLatestAttemptXml(args: {
+    sourceDir: string;
+    outputPath: string;
+}): Promise<void>;
 export {};

package/dist/steps/functions/maestroResultParser.js

@@ -7,12 +7,15 @@ exports.extractFlowKey = extractFlowKey;
 exports.parseJUnitTestCases = parseJUnitTestCases;
 exports.parseFlowMetadata = parseFlowMetadata;
 exports.parseMaestroResults = parseMaestroResults;
+exports.copyLatestAttemptXml = copyLatestAttemptXml;
 const fast_xml_parser_1 = require("fast-xml-parser");
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const zod_1 = require("zod");
 // Maestro's TestDebugReporter creates timestamped directories, e.g. "2024-06-15_143022"
 const TIMESTAMP_DIR_PATTERN = /^\d{4}-\d{2}-\d{2}_\d{6}$/;
+// Per-attempt JUnit XML files use `*-attempt-N.xml` names; this extracts N.
+const ATTEMPT_PATTERN = /attempt-(\d+)/;
 function extractFlowKey(filename, prefix) {
     const match = filename.match(new RegExp(`^${prefix}-(.+)\\.json$`));
     return match?.[1] ?? null;
@@ -190,8 +193,6 @@ async function parseMaestroResults(junitDirectory, testsDirectory, projectRoot)
     }
     // 3. Merge: JUnit results + ai-*.json metadata
     const results = [];
-    // Parse attempt index from filename pattern: *-attempt-N.*
-    const ATTEMPT_PATTERN = /attempt-(\d+)/;
     // Group results by flow name
     const resultsByName = new Map();
     for (const entry of junitResultsWithSource) {
@@ -267,3 +268,35 @@ async function relativizePathAsync(flowFilePath, projectRoot) {
     }
     return relative;
 }
+/**
+ * Copies the highest-attempt-index *.xml file from sourceDir to outputPath.
+ * After the maestro retry loop completes, this produces a single canonical
+ * JUnit report at final_report_path matching the bash step's "cp latest
+ * attempt" semantics.
+ *
+ * Throws if sourceDir contains no *.xml files or if the copy fails.
+ */
+async function copyLatestAttemptXml(args) {
+    const entries = await promises_1.default.readdir(args.sourceDir);
+    const xmlFiles = entries.filter(f => f.endsWith('.xml')).sort();
+    if (xmlFiles.length === 0) {
+        throw new Error(`No *.xml files found in ${args.sourceDir}`);
+    }
+    // Pick the file with the highest attempt index. Files without the marker are
+    // treated as attempt 0. Ties are broken by sorted filename — later wins.
+    let winner = xmlFiles[0];
+    let winnerAttempt = (() => {
+        const m = winner.match(ATTEMPT_PATTERN);
+        return m ? parseInt(m[1], 10) : 0;
+    })();
+    for (let i = 1; i < xmlFiles.length; i++) {
+        const candidate = xmlFiles[i];
+        const match = candidate.match(ATTEMPT_PATTERN);
+        const attempt = match ? parseInt(match[1], 10) : 0;
+        if (attempt >= winnerAttempt) {
+            winner = candidate;
+            winnerAttempt = attempt;
+        }
+    }
+    await promises_1.default.copyFile(path_1.default.join(args.sourceDir, winner), args.outputPath);
+}

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

@@ -0,0 +1,2 @@
+import { BuildFunction } from '@expo/steps';
+export declare function createMaestroTestsBuildFunction(): BuildFunction;

package/dist/steps/functions/maestroTests.js

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMaestroTestsBuildFunction = createMaestroTestsBuildFunction;
+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 path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
+const maestroResultParser_1 = require("./maestroResultParser");
+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);
+const ShardsSchema = zod_1.z.number().int().min(1).optional();
+function parseInput(schema, value, message) {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        throw new eas_build_job_1.UserError('ERR_MAESTRO_INVALID_INPUT', message, { cause: result.error });
+    }
+    return result.data;
+}
+// `outputPath: null` means "let maestro pick" (no --output flag). Junit and
+// other declared formats pass an explicit path so downstream upload steps
+// know where to find the result.
+function buildMaestroArgs(args) {
+    const out = ['test'];
+    if (args.output_format) {
+        out.push(`--format=${args.output_format.toUpperCase()}`);
+    }
+    if (args.outputPath) {
+        out.push(`--output=${args.outputPath}`);
+    }
+    if (args.shards !== undefined) {
+        out.push(`--shard-split=${args.shards}`);
+    }
+    if (args.include_tags) {
+        out.push(`--include-tags=${args.include_tags}`);
+    }
+    if (args.exclude_tags) {
+        out.push(`--exclude-tags=${args.exclude_tags}`);
+    }
+    out.push(...args.flow_path);
+    return out;
+}
+function createMaestroTestsBuildFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'maestro_tests',
+        name: 'Run Maestro Tests',
+        __metricsId: 'eas/maestro_tests',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'flow_path',
+                required: true,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.JSON,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'retries',
+                required: false,
+                defaultValue: 0,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'shards',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'include_tags',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'exclude_tags',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'output_format',
+                required: false,
+                defaultValue: 'junit',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'platform',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+        ],
+        outputProviders: [
+            steps_1.BuildStepOutput.createProvider({ id: 'junit_report_directory', required: true }),
+            steps_1.BuildStepOutput.createProvider({ id: 'final_report_path', required: false }),
+            steps_1.BuildStepOutput.createProvider({ id: 'tests_directory', required: true }),
+        ],
+        fn: async (stepCtx, { inputs, outputs, env, signal }) => {
+            const { logger, global } = stepCtx;
+            const platformInput = inputs.platform.value;
+            const outputFormat = inputs.output_format.value?.toLowerCase();
+            const includeTags = inputs.include_tags.value;
+            const excludeTags = inputs.exclude_tags.value;
+            const platform = platformInput === 'ios' || platformInput === 'android'
+                ? platformInput
+                : global.runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN
+                    ? 'ios'
+                    : 'android';
+            // Paths derive from env.HOME (not os.homedir()). Maestro is spawned with
+            // this env and writes debug output under $HOME/.maestro/tests; the step
+            // must read from the same place or stale files leak across runs.
+            const home = env.HOME;
+            if (!home) {
+                throw new eas_build_job_1.SystemError('HOME env var is not set');
+            }
+            const testsDirectory = path_1.default.join(home, '.maestro', 'tests');
+            const junitReportDirectory = path_1.default.join(testsDirectory, 'junit-reports');
+            const finalReportPath = outputFormat === 'junit'
+                ? path_1.default.join(testsDirectory, `${platform}-maestro-junit.xml`)
+                : undefined;
+            // Public docs (EAS workflows pre-packaged-jobs) document
+            // `${MAESTRO_TESTS_DIR}` for users to save screenshots/recordings into
+            // the uploaded dir.
+            const spawnEnv = { ...env, MAESTRO_TESTS_DIR: testsDirectory };
+            // Outputs are published BEFORE any throw below so downstream
+            // `if: always()` upload steps still see populated values when this
+            // step fails early.
+            outputs.tests_directory.set(testsDirectory);
+            outputs.junit_report_directory.set(junitReportDirectory);
+            if (finalReportPath !== undefined) {
+                outputs.final_report_path.set(finalReportPath);
+            }
+            const flowPaths = parseInput(FlowPathSchema, inputs.flow_path.value, 'flow_path must be a non-empty array of non-empty strings.');
+            const retries = parseInput(RetriesSchema, inputs.retries.value, 'retries must be a non-negative integer.');
+            const shards = parseInput(ShardsSchema, inputs.shards.value, 'shards must be a positive integer.');
+            try {
+                await promises_1.default.mkdir(junitReportDirectory, { recursive: true });
+            }
+            catch (err) {
+                throw new eas_build_job_1.SystemError('Failed to create JUnit report directory', { cause: err });
+            }
+            // Retry loop. spawn-async error shapes:
+            //   ENOENT/EACCES → infra (binary missing/not executable) → SystemError.
+            //   numeric err.status → maestro exited non-zero → retry.
+            //   else (signal-only, OOM kill, unknown) → infra → SystemError, never
+            //     downgraded to "tests failed".
+            let lastAttemptExitCode = null;
+            for (let attempt = 0; attempt <= retries; attempt++) {
+                const outputPath = outputFormat === 'junit'
+                    ? path_1.default.join(junitReportDirectory, `${platform}-maestro-junit-attempt-${attempt}.xml`)
+                    : outputFormat
+                        ? path_1.default.join(testsDirectory, `${platform}-maestro-${outputFormat}.${outputFormat}`)
+                        : null;
+                try {
+                    await (0, turtle_spawn_1.default)('maestro', buildMaestroArgs({
+                        flow_path: flowPaths,
+                        outputPath,
+                        output_format: outputFormat,
+                        shards,
+                        include_tags: includeTags,
+                        exclude_tags: excludeTags,
+                    }), { cwd: stepCtx.workingDirectory, env: spawnEnv, logger, signal });
+                    lastAttemptExitCode = 0;
+                }
+                catch (err) {
+                    if (err && (err.code === 'ENOENT' || err.code === 'EACCES')) {
+                        throw new eas_build_job_1.SystemError('Failed to invoke maestro', { cause: err });
+                    }
+                    if (err && typeof err.status === 'number') {
+                        lastAttemptExitCode = err.status;
+                    }
+                    else {
+                        throw new eas_build_job_1.SystemError('Unexpected spawn failure invoking maestro', { cause: err });
+                    }
+                }
+                if (lastAttemptExitCode === 0 || attempt === retries) {
+                    break;
+                }
+                logger.info('Test failed, retrying...');
+                await (0, retry_1.sleepAsync)(2000);
+            }
+            // Copy the latest attempt's JUnit to the final report path so downstream
+            // upload/report steps have a single canonical file.
+            if (finalReportPath !== undefined) {
+                try {
+                    await (0, maestroResultParser_1.copyLatestAttemptXml)({
+                        sourceDir: junitReportDirectory,
+                        outputPath: finalReportPath,
+                    });
+                }
+                catch (copyErr) {
+                    // Swallow: a copy failure usually means maestro itself failed early
+                    // (bad YAML wrote no *.xml). Throwing SystemError here would mask
+                    // the real reason and cancel billing for a user-side failure — let
+                    // the lastAttemptExitCode check below surface ERR_MAESTRO_TESTS_FAILED.
+                    logger.warn(`Failed to produce final_report_path at ${finalReportPath}: ${copyErr?.message ?? copyErr}`);
+                }
+            }
+            // 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.
+            if (lastAttemptExitCode !== 0) {
+                const totalAttempts = retries + 1;
+                throw new eas_build_job_1.UserError('ERR_MAESTRO_TESTS_FAILED', `Maestro tests failed after ${totalAttempts} attempt${totalAttempts === 1 ? '' : 's'}.`);
+            }
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "18.8.1",
+  "version": "18.10.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -45,7 +45,7 @@
     "@expo/plist": "^0.2.0",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "18.8.0",
+    "@expo/steps": "18.9.0",
     "@expo/template-file": "18.5.0",
     "@expo/turtle-spawn": "18.5.0",
     "@expo/xcpretty": "^4.3.1",
@@ -98,5 +98,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "714aec69c79af71e68b0212cb3e511f6ccef2ae0"
+  "gitHead": "cacd48bf669342be783037607b02e5f9b1b148c0"
 }