@expo/build-tools 22.0.0 → 22.3.0

package/dist/steps/functions/maestroTests.js

@@ -11,6 +11,7 @@ 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 maestroBackend_1 = require("./maestroBackend");
 const maestroFlowDiscovery_1 = require("./maestroFlowDiscovery");
 const maestroResultParser_1 = require("./maestroResultParser");
 const maestroScreenshots_1 = require("./maestroScreenshots");
@@ -36,28 +37,40 @@ function isFilesystemError(err) {
     const code = err.code;
     return (code === 'ENOSPC' || code === 'EACCES' || code === 'EROFS' || code === 'EIO' || code === 'EPERM');
 }
-// `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}`);
+function buildMaestroArgs({ backend, platform, flowPaths, output, outputFormat, shards, includeTags, excludeTags, }) {
+    switch (backend) {
+        case 'maestro': {
+            const args = ['test'];
+            if (outputFormat) {
+                args.push(`--format=${outputFormat.toUpperCase()}`);
+            }
+            if (output) {
+                args.push(`--output=${output}`);
+            }
+            if (shards !== undefined) {
+                args.push(`--shard-split=${shards}`);
+            }
+            if (includeTags) {
+                args.push(`--include-tags=${includeTags}`);
+            }
+            if (excludeTags) {
+                args.push(`--exclude-tags=${excludeTags}`);
+            }
+            args.push(...flowPaths);
+            return { executable: 'maestro', args };
+        }
+        case 'maestro-runner': {
+            const args = [`--platform=${platform}`, 'test', `--output=${output}`, '--flatten'];
+            if (includeTags) {
+                args.push(`--include-tags=${includeTags}`);
+            }
+            if (excludeTags) {
+                args.push(`--exclude-tags=${excludeTags}`);
+            }
+            args.push(...flowPaths);
+            return { executable: 'maestro-runner', args };
+        }
     }
-    out.push(...args.flow_path);
-    return out;
 }
 function createMaestroTestsBuildFunction(ctx) {
     return new steps_1.BuildFunction({
@@ -115,6 +128,11 @@ function createMaestroTestsBuildFunction(ctx) {
                 required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'backend',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
         ],
         outputProviders: [
             steps_1.BuildStepOutput.createProvider({ id: 'junit_report_directory', required: true }),
@@ -156,12 +174,25 @@ function createMaestroTestsBuildFunction(ctx) {
             if (finalReportPath !== undefined) {
                 outputs.final_report_path.set(finalReportPath);
             }
+            // Resolved after the output assignments above: an invalid backend input or
+            // EAS_MAESTRO_BACKEND throws, and downstream `if: always()` upload steps still
+            // need the outputs interpolated.
+            const backend = (0, maestroBackend_1.resolveMaestroBackend)({
+                input: inputs.backend.value,
+                env,
+            });
             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.');
             const androidConnectionMode = parseInput(AndroidConnectionModeSchema, inputs.android_connection_mode.value ||
                 env.EAS_MAESTRO_ANDROID_CONNECTION_MODE ||
                 undefined, 'android_connection_mode and EAS_MAESTRO_ANDROID_CONNECTION_MODE must be either "adb" or "dadb".');
+            if (backend === 'maestro-runner' && shards !== undefined && shards > 1) {
+                throw new eas_build_job_1.UserError('ERR_MAESTRO_INVALID_INPUT', 'maestro-runner does not support EAS Maestro test sharding. Remove shards or set it to 1.');
+            }
+            if (backend === 'maestro-runner' && outputFormat !== undefined && outputFormat !== 'junit') {
+                throw new eas_build_job_1.UserError('ERR_MAESTRO_INVALID_INPUT', `maestro-runner only supports the "junit" output_format, but received "${outputFormat}".`);
+            }
             const retryFailedOnly = inputs.retry_failed_only.value;
             try {
                 await promises_1.default.mkdir(junitReportDirectory, { recursive: true });
@@ -169,7 +200,7 @@ function createMaestroTestsBuildFunction(ctx) {
             catch (err) {
                 throw new eas_build_job_1.SystemError('Failed to create JUnit report directory', { cause: err });
             }
-            // Legacy-only (Maestro < 2.6.0 reports carry no `file=` attribute): the
+            // Official Maestro legacy-only (Maestro < 2.6.0 reports carry no `file=` attribute): the
             // flow scan is built lazily in the retry branch below and memoized so
             // retries share one scan. Never runs when the report has `file=`.
             let nameToPathPromise;
@@ -178,14 +209,20 @@ function createMaestroTestsBuildFunction(ctx) {
             //   numeric err.status → maestro exited non-zero → retry.
             //   else (signal-only, OOM kill, unknown) → infra → SystemError, never
             //     downgraded to "tests failed".
-            // Retry-failed-only (junit mode): after a failed attempt, subset to the failing
-            // flows. The failed-flow parsers return null when the JUnit cannot be
-            // trusted; we then fall through to dumb retry (re-run everything).
+            // Retry-failed-only: after a failed attempt, subset to the failing flows. The
+            // failed-flow parsers return null when a report cannot be trusted; we then fall
+            // through to dumb retry (re-run everything).
             let flowsToRun = flowPaths;
             let lastAttemptExitCode = null;
             const harvested = [];
+            const reportDirectories = backend === 'maestro' ? [junitReportDirectory] : [];
             const totalAttempts = retries + 1;
-            if (platform === 'android' && androidConnectionMode === 'dadb') {
+            if (backend === 'maestro-runner' &&
+                platform === 'android' &&
+                androidConnectionMode === 'dadb') {
+                logger.info('maestro-runner does not support DADB. Using the default ADB connection.');
+            }
+            if (backend === 'maestro' && platform === 'android' && androidConnectionMode === 'dadb') {
                 try {
                     const adbOverrideDirectoryPath = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'maestro-tests-adb-override-'));
                     await promises_1.default.writeFile(path_1.default.join(adbOverrideDirectoryPath, 'adb'), '#!/bin/sh\nexit 1\n', {
@@ -213,23 +250,37 @@ function createMaestroTestsBuildFunction(ctx) {
                 // Do not restart ADB or remove the override. This keeps Maestro in direct DADB mode.
             }
             for (let attempt = 0; attempt <= retries; attempt++) {
+                // maestro-runner writes its JUnit report and screenshot metadata to this directory.
+                const runnerOutputDirectory = path_1.default.join(testsDirectory, `${platform}-maestro-runner-attempt-${attempt}`);
                 const outputPath = outputFormat === 'junit'
                     ? path_1.default.join(junitReportDirectory, `${platform}-maestro-junit-attempt-${attempt}.xml`)
-                    : outputFormat
+                    : backend === 'maestro' && outputFormat
                         ? path_1.default.join(testsDirectory, `${platform}-maestro-${outputFormat}.${outputFormat}`)
                         : null;
-                const maestroArgs = buildMaestroArgs({
-                    flow_path: flowsToRun,
-                    outputPath,
-                    output_format: outputFormat,
+                const { executable, args: maestroArgs } = buildMaestroArgs({
+                    backend,
+                    platform,
+                    flowPaths: flowsToRun,
+                    output: backend === 'maestro-runner' ? runnerOutputDirectory : outputPath,
+                    outputFormat,
                     shards,
-                    include_tags: includeTags,
-                    exclude_tags: excludeTags,
+                    includeTags,
+                    excludeTags,
                 });
-                logger.info(`Running maestro (attempt ${attempt + 1}/${totalAttempts}): maestro ${maestroArgs.join(' ')}`);
+                logger.info(`Running ${executable} (attempt ${attempt + 1}/${totalAttempts}): ${executable} ${maestroArgs.join(' ')}`);
+                // The runner output directory is deterministic and can survive a prior run; clear it
+                // best-effort so a crash before it writes fresh output can't resurrect stale results.
+                if (backend === 'maestro-runner') {
+                    try {
+                        await promises_1.default.rm(runnerOutputDirectory, { recursive: true, force: true });
+                    }
+                    catch (err) {
+                        logger.warn({ err }, `Failed to clear ${runnerOutputDirectory} before the attempt.`);
+                    }
+                }
                 const attemptStartedAtMs = Date.now();
                 try {
-                    await (0, turtle_spawn_1.default)('maestro', maestroArgs, {
+                    await (0, turtle_spawn_1.default)(executable, maestroArgs, {
                         cwd: stepCtx.workingDirectory,
                         env: spawnEnv,
                         logger,
@@ -239,53 +290,100 @@ function createMaestroTestsBuildFunction(ctx) {
                 }
                 catch (err) {
                     if (err && (err.code === 'ENOENT' || err.code === 'EACCES')) {
-                        throw new eas_build_job_1.SystemError('Failed to invoke maestro', { cause: err });
+                        throw new eas_build_job_1.SystemError(`Failed to invoke ${executable}`, { 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 });
+                        throw new eas_build_job_1.SystemError(`Unexpected spawn failure invoking ${executable}`, {
+                            cause: err,
+                        });
+                    }
+                }
+                // maestro-runner writes a report directory. Copy its JUnit file into the existing
+                // per-attempt directory so retry parsing and final report merging remain shared.
+                if (backend === 'maestro-runner' && outputPath) {
+                    try {
+                        await promises_1.default.copyFile(path_1.default.join(runnerOutputDirectory, 'junit-report.xml'), outputPath);
+                    }
+                    catch (err) {
+                        logger.warn({ err }, `Failed to collect the maestro-runner JUnit report for attempt ${attempt + 1}.`);
                     }
                 }
+                if (backend === 'maestro-runner') {
+                    reportDirectories.push(runnerOutputDirectory);
+                }
                 // 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') {
-                    const failedFlowNames = outputPath
-                        ? await (0, maestroResultParser_1.parseFailedFlowNamesFromJUnitFile)(outputPath)
-                        : new Set();
-                    harvested.push(...(await (0, maestroScreenshots_1.harvestFailureScreenshotsAsync)({
-                        testsDirectory,
-                        capturedSinceMs: attemptStartedAtMs,
-                        attemptIndex: attempt,
-                        failedFlowNames,
-                        logger,
-                    })));
+                    let screenshots;
+                    switch (backend) {
+                        case 'maestro': {
+                            const failedFlowNames = outputPath
+                                ? await (0, maestroResultParser_1.parseFailedFlowNamesFromJUnitFile)(outputPath)
+                                : new Set();
+                            screenshots = await (0, maestroScreenshots_1.harvestFailureScreenshotsAsync)({
+                                testsDirectory,
+                                capturedSinceMs: attemptStartedAtMs,
+                                attemptIndex: attempt,
+                                failedFlowNames,
+                                logger,
+                            });
+                            break;
+                        }
+                        case 'maestro-runner':
+                            screenshots = await (0, maestroScreenshots_1.harvestMaestroRunnerFailureScreenshotsAsync)({
+                                reportDirectory: runnerOutputDirectory,
+                                capturedSinceMs: attemptStartedAtMs,
+                                attemptIndex: attempt,
+                                logger,
+                            });
+                            break;
+                    }
+                    harvested.push(...screenshots);
                 }
                 if (lastAttemptExitCode === 0 || attempt === retries) {
                     break;
                 }
-                if (retryFailedOnly && outputFormat === 'junit' && outputPath) {
+                if (retryFailedOnly &&
+                    (backend === 'maestro-runner' || (outputFormat === 'junit' && outputPath))) {
                     let failed;
-                    if (await (0, maestroResultParser_1.junitFileHasFileAttrs)(outputPath)) {
-                        failed = await (0, maestroResultParser_1.parseFailedFlowsFromFileAttrs)({
-                            junitFile: outputPath,
-                            workingDirectory: stepCtx.workingDirectory,
-                        });
-                    }
-                    else {
-                        // Legacy (Maestro < 2.6.0): map failed testcase names back to flow
-                        // paths via the flow-file scan. DELETE this arm once the fleet is
-                        // on >= 2.6.0.
-                        const nameToPath = await (nameToPathPromise ??= (0, maestroFlowDiscovery_1.buildFlowNameToPathMap)({
-                            inputFlowPaths: flowPaths,
-                            projectRoot: stepCtx.workingDirectory,
-                            logger,
-                        }));
-                        failed = nameToPath
-                            ? await (0, maestroResultParser_1.parseFailedFlowsFromJUnit)({ junitFile: outputPath, nameToPath })
-                            : null;
+                    switch (backend) {
+                        case 'maestro-runner':
+                            failed = await (0, maestroResultParser_1.parseFailedFlowsFromMaestroRunnerReport)({
+                                reportDirectory: runnerOutputDirectory,
+                                workingDirectory: stepCtx.workingDirectory,
+                            });
+                            break;
+                        case 'maestro':
+                            if (!outputPath) {
+                                failed = null;
+                                break;
+                            }
+                            if (await (0, maestroResultParser_1.junitFileHasFileAttrs)(outputPath)) {
+                                failed = await (0, maestroResultParser_1.parseFailedFlowsFromFileAttrs)({
+                                    junitFile: outputPath,
+                                    workingDirectory: stepCtx.workingDirectory,
+                                });
+                                break;
+                            }
+                            // Legacy (Maestro < 2.6.0): map failed testcase names back to flow
+                            // paths via the flow-file scan. DELETE this arm once the fleet is
+                            // on >= 2.6.0.
+                            const nameToPath = await (nameToPathPromise ??= (0, maestroFlowDiscovery_1.buildFlowNameToPathMap)({
+                                inputFlowPaths: flowPaths,
+                                projectRoot: stepCtx.workingDirectory,
+                                logger,
+                            }));
+                            failed = nameToPath
+                                ? await (0, maestroResultParser_1.parseFailedFlowsFromJUnit)({
+                                    junitFile: outputPath,
+                                    nameToPath,
+                                })
+                                : null;
+                            break;
                     }
                     if (failed !== null && failed.length > 0) {
                         flowsToRun = failed;
@@ -335,7 +433,13 @@ function createMaestroTestsBuildFunction(ctx) {
             // 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 });
+                await uploadFailureScreenshotsAsync({
+                    harvested,
+                    backend,
+                    reportDirectories,
+                    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
@@ -349,14 +453,28 @@ function createMaestroTestsBuildFunction(ctx) {
 // 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, }) {
+async function uploadFailureScreenshotsAsync({ harvested, backend, reportDirectories, 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));
+        let flowResults;
+        switch (backend) {
+            case 'maestro':
+                flowResults = (await Promise.all(reportDirectories.map(directory => (0, maestroResultParser_1.parseJUnitTestCases)(directory)))).flat();
+                break;
+            case 'maestro-runner': {
+                const results = await Promise.all(reportDirectories.map(directory => (0, maestroResultParser_1.parseMaestroRunnerReport)(directory)));
+                // Use whichever reports parsed. An unreadable report (e.g. a final retry that crashed
+                // before writing report.json) contributes no flows rather than discarding screenshots
+                // harvested from the attempts that did report — mirroring the maestro path above.
+                flowResults = results.flatMap(result => result?.flows ?? []);
+                break;
+            }
+        }
+        const pureFailureFlowNames = (0, maestroScreenshots_1.computePureFailureFlowNames)(flowResults);
         selected = (0, maestroScreenshots_1.selectFailureScreenshots)(harvested, pureFailureFlowNames);
     }
     catch (err) {

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

@@ -3,6 +3,7 @@ export type IpaInfo = {
     bundleIdentifier: string;
     bundleShortVersion: string;
     bundleVersion: string;
+    dtPlatformName: string | null;
 };
 export declare function createReadIpaInfoBuildFunction(): BuildFunction;
 export declare function readIpaInfoAsync(ipaPath: string): Promise<IpaInfo>;

package/dist/steps/functions/readIpaInfo.js

@@ -70,10 +70,12 @@ async function readIpaInfoAsync(ipaPath) {
         if (typeof bundleVersion !== 'string') {
             throw new eas_build_job_1.UserError('EAS_READ_IPA_INFO_INVALID_INFO_PLIST', 'Failed to read IPA info: Missing or invalid CFBundleVersion in Info.plist');
         }
+        const dtPlatformName = typeof infoPlist.DTPlatformName === 'string' ? infoPlist.DTPlatformName : null;
         return {
             bundleIdentifier,
             bundleShortVersion,
             bundleVersion,
+            dtPlatformName,
         };
     }
     catch (error) {

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

@@ -11,11 +11,14 @@ export declare function resolveAndroidSigningOptionsAsync({ job, tmpDir, }: {
     tmpDir: string;
 }): Promise<AndroidSigningOptions | undefined>;
 /**
- * Resolves iOS signing options from the job secrets.
+ * Resolves iOS signing options from the job secrets, dispatching on the
+ * requested signing backend.
  */
-export declare function resolveIosSigningOptionsAsync({ job, logger, useAppEntitlements, entitlementsPath, }: {
+export declare function resolveIosSigningOptionsAsync({ job, logger, backend, useAppEntitlements, entitlementsPath, tmpDir, }: {
     job: Job;
     logger: bunyan;
+    backend?: 'fastlane' | 'zsign';
     useAppEntitlements?: boolean;
     entitlementsPath?: string;
+    tmpDir: string;
 }): Promise<IosSigningOptions | undefined>;

package/dist/steps/functions/repack.js

@@ -53,6 +53,12 @@ function createRepackBuildFunction() {
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
                 required: false,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'ios_signing_backend',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+                allowedValues: ['fastlane', 'zsign'],
+            }),
             steps_1.BuildStepInput.createProvider({
                 id: 'repack_version',
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
@@ -123,8 +129,10 @@ function createRepackBuildFunction() {
                         iosSigningOptions: await resolveIosSigningOptionsAsync({
                             job: stepsCtx.global.staticContext.job,
                             logger: stepsCtx.logger,
+                            backend: inputs.ios_signing_backend.value,
                             useAppEntitlements: inputs.ios_signing_use_source_app_entitlements.value,
                             entitlementsPath: inputs.ios_signing_app_entitlements_path.value,
+                            tmpDir,
                         }),
                         logger: stepsCtx.logger,
                         spawnAsync: repackSpawnAsync,
@@ -234,14 +242,26 @@ async function resolveAndroidSigningOptionsAsync({ job, tmpDir, }) {
     };
 }
 /**
- * Resolves iOS signing options from the job secrets.
+ * Resolves iOS signing options from the job secrets, dispatching on the
+ * requested signing backend.
  */
-async function resolveIosSigningOptionsAsync({ job, logger, useAppEntitlements, entitlementsPath, }) {
+async function resolveIosSigningOptionsAsync({ job, logger, backend, useAppEntitlements, entitlementsPath, tmpDir, }) {
     const iosJob = job;
     const buildCredentials = iosJob.secrets?.buildCredentials;
     if (iosJob.simulator || buildCredentials == null) {
         return undefined;
     }
+    const commonOptions = { buildCredentials, logger, useAppEntitlements, entitlementsPath };
+    return backend === 'zsign'
+        ? await createIosZsignOptionsAsync({ ...commonOptions, tmpDir })
+        : await createIosFastlaneOptionsAsync(commonOptions);
+}
+/**
+ * Creates signing options for the fastlane backend: certificates are imported
+ * into a temporary keychain and provisioning profiles are parsed with the
+ * macOS `security` tool.
+ */
+async function createIosFastlaneOptionsAsync({ buildCredentials, logger, useAppEntitlements, entitlementsPath, }) {
     const credentialsManager = new manager_1.default(buildCredentials);
     const credentials = await credentialsManager.prepare(logger);
     const provisioningProfile = {};
@@ -256,3 +276,31 @@ async function resolveIosSigningOptionsAsync({ job, logger, useAppEntitlements,
         entitlementsPath,
     };
 }
+/**
+ * Creates signing options for the zsign backend. The distribution certificate
+ * secret is already a PKCS#12 file, so it goes to disk as-is together with the
+ * provisioning profiles.
+ */
+async function createIosZsignOptionsAsync({ buildCredentials, logger, useAppEntitlements, entitlementsPath, tmpDir, }) {
+    const targets = Object.entries(buildCredentials);
+    const [targetName, targetCredentials] = targets[0];
+    logger.info(`Using the distribution certificate from target '${targetName}' for zsign`);
+    const certificatePath = node_path_1.default.join(tmpDir, `dist-cert-${(0, node_crypto_1.randomUUID)()}.p12`);
+    await node_fs_1.default.promises.writeFile(certificatePath, new Uint8Array(Buffer.from(targetCredentials.distributionCertificate.dataBase64, 'base64')));
+    // zsign matches profiles to bundles by the app-id suffix itself, so the
+    // record keys are informational only.
+    const provisioningProfile = {};
+    for (const [target, credentials] of targets) {
+        const profilePath = node_path_1.default.join(tmpDir, `profile-${target}-${(0, node_crypto_1.randomUUID)()}.mobileprovision`);
+        await node_fs_1.default.promises.writeFile(profilePath, new Uint8Array(Buffer.from(credentials.provisioningProfileBase64, 'base64')));
+        provisioningProfile[target] = profilePath;
+    }
+    return {
+        backend: 'zsign',
+        certificatePath,
+        keyPassword: targetCredentials.distributionCertificate.password,
+        provisioningProfile,
+        useAppEntitlements,
+        entitlementsPath,
+    };
+}

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

@@ -1,12 +1,12 @@
-import { Platform } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
+import { CcacheBuildTarget } from '../../utils/cacheKey';
 export declare function createRestoreBuildCacheFunction(): BuildFunction;
 export declare function createCacheStatsBuildFunction(): BuildFunction;
-export declare function restoreCcacheAsync({ logger, workingDirectory, platform, env, secrets, }: {
+export declare function restoreCcacheAsync({ logger, workingDirectory, target, env, secrets, }: {
     logger: bunyan;
     workingDirectory: string;
-    platform: Platform;
+    target: CcacheBuildTarget;
     env: Record<string, string | undefined>;
     secrets?: {
         robotAccessToken?: string;

package/dist/steps/functions/restoreBuildCache.js

@@ -33,6 +33,11 @@ function createRestoreBuildCacheFunction() {
                 required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'simulator',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+            }),
         ],
         fn: async (stepCtx, { env, inputs }) => {
             const { logger } = stepCtx;
@@ -42,10 +47,18 @@ function createRestoreBuildCacheFunction() {
             if (!platform || ![eas_build_job_1.Platform.ANDROID, eas_build_job_1.Platform.IOS].includes(platform)) {
                 throw new Error(`Unsupported platform: ${platform}. Platform must be "${eas_build_job_1.Platform.ANDROID}" or "${eas_build_job_1.Platform.IOS}"`);
             }
+            const target = platform === eas_build_job_1.Platform.IOS
+                ? {
+                    platform,
+                    simulator: inputs.simulator.value ??
+                        (stepCtx.global.staticContext.job.platform === eas_build_job_1.Platform.IOS &&
+                            stepCtx.global.staticContext.job.simulator === true),
+                }
+                : { platform };
             await restoreCcacheAsync({
                 logger,
                 workingDirectory,
-                platform,
+                target,
                 env,
                 secrets: stepCtx.global.staticContext.job.secrets,
             });
@@ -80,7 +93,7 @@ function createCacheStatsBuildFunction() {
         },
     });
 }
-async function restoreCcacheAsync({ logger, workingDirectory, platform, env, secrets, }) {
+async function restoreCcacheAsync({ logger, workingDirectory, target, env, secrets, }) {
     const enabled = env.EAS_RESTORE_CACHE === '1' || (env.EAS_USE_CACHE === '1' && env.EAS_RESTORE_CACHE !== '0');
     if (!enabled) {
         return;
@@ -103,7 +116,7 @@ async function restoreCcacheAsync({ logger, workingDirectory, platform, env, sec
             env,
             stdio: 'pipe',
         }));
-        const cacheKey = await (0, cacheKey_1.generateDefaultBuildCacheKeyAsync)(workingDirectory, platform);
+        const cacheKey = await (0, cacheKey_1.generateDefaultBuildCacheKeyAsync)(workingDirectory, target);
         logger.info(`Restoring cache key: ${cacheKey}`);
         const jobId = (0, nullthrows_1.default)(env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set');
         const { archivePath, matchedKey } = await (0, restoreCache_1.downloadCacheAsync)({
@@ -113,8 +126,8 @@ async function restoreCcacheAsync({ logger, workingDirectory, platform, env, sec
             robotAccessToken,
             paths: [cachePath],
             key: cacheKey,
-            keyPrefixes: [cacheKey_1.CACHE_KEY_PREFIX_BY_PLATFORM[platform]],
-            platform,
+            keyPrefixes: [(0, cacheKey_1.getCcacheKeyPrefix)(target)],
+            platform: target.platform,
         });
         await (0, restoreCache_1.decompressCacheAsync)({
             archivePath,
@@ -139,7 +152,7 @@ async function restoreCcacheAsync({ logger, workingDirectory, platform, env, sec
                     expoApiServerURL,
                     robotAccessToken,
                     paths: [cachePath],
-                    platform,
+                    platform: target.platform,
                 });
                 await (0, restoreCache_1.decompressCacheAsync)({
                     archivePath,
@@ -201,12 +214,13 @@ async function restoreGradleCacheAsync({ logger, workingDirectory, env, secrets,
         logger.info(`Restoring Gradle cache key: ${cacheKey}`);
         const gradleCachesPath = path_1.default.join(os_1.default.homedir(), '.gradle', 'caches');
         const buildCachePath = path_1.default.join(gradleCachesPath, 'build-cache-1');
+        const journalPath = path_1.default.join(gradleCachesPath, 'journal-1');
         const { archivePath, matchedKey } = await (0, restoreCache_1.downloadCacheAsync)({
             logger,
             jobId,
             expoApiServerURL,
             robotAccessToken,
-            paths: [buildCachePath],
+            paths: [buildCachePath, journalPath],
             key: cacheKey,
             keyPrefixes: [gradleCacheKey_1.GRADLE_CACHE_KEY_PREFIX],
             platform: eas_build_job_1.Platform.ANDROID,

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

@@ -1,11 +1,11 @@
-import { Platform } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
+import { CcacheBuildTarget } from '../../utils/cacheKey';
 export declare function createSaveBuildCacheFunction(evictUsedBefore: Date): BuildFunction;
-export declare function saveCcacheAsync({ logger, workingDirectory, platform, evictUsedBefore, env, secrets, }: {
+export declare function saveCcacheAsync({ logger, workingDirectory, target, evictUsedBefore, env, secrets, }: {
     logger: bunyan;
     workingDirectory: string;
-    platform: Platform;
+    target: CcacheBuildTarget;
     evictUsedBefore: Date;
     env: Record<string, string | undefined>;
     secrets?: {