@expo/build-tools 21.7.1 → 22.0.0

package/dist/builders/common.js

@@ -5,6 +5,7 @@ const eas_build_job_1 = require("@expo/eas-build-job");
 const xcodeBuildLogs_1 = require("../ios/xcodeBuildLogs");
 const artifacts_1 = require("../utils/artifacts");
 const hooks_1 = require("../utils/hooks");
+const sourceMaps_1 = require("../utils/sourceMaps");
 async function runBuilderWithHooksAsync(ctx, builderAsync) {
     try {
         let buildSuccess = true;
@@ -35,6 +36,9 @@ async function runBuilderWithHooksAsync(ctx, builderAsync) {
                 });
             }
             await ctx.runBuildPhase(eas_build_job_1.BuildPhase.UPLOAD_BUILD_ARTIFACTS, async () => {
+                if (buildSuccess) {
+                    await (0, sourceMaps_1.maybeUploadSourceMapAsync)(ctx);
+                }
                 await (0, artifacts_1.maybeFindAndUploadBuildArtifacts)(ctx, {
                     logger: ctx.logger,
                 });

package/dist/builders/ios.js

@@ -30,6 +30,7 @@ const expoUpdatesEmbedded_1 = require("../utils/expoUpdatesEmbedded");
 const hooks_1 = require("../utils/hooks");
 const prepareBuildExecutable_1 = require("../utils/prepareBuildExecutable");
 const processes_1 = require("../utils/processes");
+const sourceMaps_1 = require("../utils/sourceMaps");
 const INSTALL_PODS_WARN_TIMEOUT_MS = 15 * 60 * 1000; // 15 minutes
 const INSTALL_PODS_KILL_TIMEOUT_MS = 30 * 60 * 1000; // 30 minutes
 class InstallPodsTimeoutError extends Error {
@@ -151,19 +152,23 @@ async function buildInnerAsync(ctx, jobHooksRef) {
         fastlaneResult = await ctx.runBuildPhase(eas_build_job_1.BuildPhase.RUN_FASTLANE, async () => {
             const scheme = (0, resolve_1.resolveScheme)(ctx);
             const entitlements = await readEntitlementsAsync(ctx, { scheme, buildConfiguration });
+            const sourceMapPath = (0, sourceMaps_1.isSourceMapUploadEnabled)(ctx)
+                ? await (0, sourceMaps_1.resolveIosSourceMapPathAsync)(ctx)
+                : null;
             return await (0, fastlane_1.runFastlaneGym)(ctx, {
                 credentials,
                 scheme,
                 buildConfiguration,
                 entitlements,
-                ...(resolvedExpoUpdatesRuntimeVersion?.runtimeVersion
-                    ? {
-                        extraEnv: {
+                extraEnv: {
+                    ...(resolvedExpoUpdatesRuntimeVersion?.runtimeVersion
+                        ? {
                             EXPO_UPDATES_FINGERPRINT_OVERRIDE: resolvedExpoUpdatesRuntimeVersion?.runtimeVersion,
                             EXPO_UPDATES_WORKFLOW_OVERRIDE: ctx.job.type,
-                        },
-                    }
-                    : null),
+                        }
+                        : null),
+                    ...(sourceMapPath ? { SOURCEMAP_FILE: sourceMapPath } : null),
+                },
             });
         });
     }

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 maestroBackend_1 = require("./maestroBackend");
 const datadog_1 = require("../../datadog");
 function createInstallMaestroBuildFunction() {
     return new steps_1.BuildFunction({
@@ -24,6 +25,11 @@ function createInstallMaestroBuildFunction() {
                 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({
@@ -32,35 +38,43 @@ function createInstallMaestroBuildFunction() {
             }),
         ],
         fn: async ({ logger, global }, { inputs, env, outputs }) => {
-            const requestedMaestroVersion = inputs.maestro_version.value;
-            const { value: currentMaestroVersion } = await (0, results_1.asyncResult)(getMaestroVersion({ env }));
+            const backend = (0, maestroBackend_1.resolveMaestroBackend)({
+                input: inputs.backend.value,
+                env,
+            });
+            const requestedVersion = inputs.maestro_version.value;
+            const { value: currentMaestroVersion } = await (0, results_1.asyncResult)(getMaestroVersion({ env, backend }));
             // When not running in EAS Build VM, do not modify local environment.
             if (env.EAS_BUILD_RUNNER !== 'eas-build') {
-                const currentIsJavaInstalled = await isJavaInstalled({ env });
-                const currentIsIdbInstalled = await isIdbInstalled({ env });
-                if (!currentIsJavaInstalled) {
+                const needsToInstallJava = backend === 'maestro' && !(await isJavaInstalled({ env }));
+                const needsToInstallIdb = backend === 'maestro' && !(await isIdbInstalled({ env }));
+                if (needsToInstallJava) {
                     logger.warn('It seems Java is not installed. It is required to run Maestro. If the job fails, this may be the reason.');
                     logger.info('');
                 }
-                if (!currentIsIdbInstalled) {
+                if (needsToInstallIdb) {
                     logger.warn('It seems IDB is not installed. Maestro requires it to run flows on iOS Simulator. If the job fails, this may be the reason.');
                     logger.info('');
                 }
                 if (!currentMaestroVersion) {
-                    logger.warn('It seems Maestro is not installed. Please install Maestro manually and rerun the job.');
+                    logger.warn(`It seems ${backend} is not installed. Please install it manually and rerun the job.`);
                     logger.info('');
                 }
                 // Guide is helpful in these two cases, it doesn't mention Java.
-                if (!currentIsIdbInstalled || !currentMaestroVersion) {
+                if (backend === 'maestro' && (needsToInstallIdb || !currentMaestroVersion)) {
                     logger.warn('For more info, check out Maestro installation guide: https://maestro.mobile.dev/getting-started/installing-maestro');
                 }
+                else if (backend === 'maestro-runner' && !currentMaestroVersion) {
+                    logger.warn('For more info, check out maestro-runner installation guide: https://github.com/devicelab-dev/maestro-runner#install');
+                }
                 if (currentMaestroVersion) {
                     outputs.maestro_version.set(currentMaestroVersion);
-                    logger.info(`Maestro ${currentMaestroVersion} is ready.`);
+                    logger.info(`${backend} ${currentMaestroVersion} is ready.`);
                 }
                 return;
             }
-            if (!(await isJavaInstalled({ env }))) {
+            const needsToInstallJava = backend === 'maestro' && !(await isJavaInstalled({ env }));
+            if (needsToInstallJava) {
                 if (global.runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
                     logger.info('Installing Java');
                     await installJavaFromGcs({ logger, env });
@@ -73,45 +87,83 @@ function createInstallMaestroBuildFunction() {
                 }
             }
             // IDB is only a requirement on macOS.
-            if (global.runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN &&
-                !(await isIdbInstalled({ env }))) {
+            const needsToInstallIdb = backend === 'maestro' &&
+                global.runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN &&
+                !(await isIdbInstalled({ env }));
+            if (needsToInstallIdb) {
                 logger.info('Installing IDB');
                 await installIdbFromBrew({ logger, env });
             }
             // Skip installing if the input sets a specific Maestro version to install
             // and it is already installed which happens when developing on a local computer.
             if (!currentMaestroVersion ||
-                (requestedMaestroVersion && requestedMaestroVersion !== currentMaestroVersion)) {
-                await installMaestro({
-                    version: requestedMaestroVersion,
-                    global,
-                    logger,
-                    env,
-                });
+                (requestedVersion && requestedVersion !== currentMaestroVersion)) {
+                switch (backend) {
+                    case 'maestro':
+                        await installMaestro({ version: requestedVersion, global, logger, env });
+                        break;
+                    case 'maestro-runner':
+                        await installMaestroRunner({ version: requestedVersion, global, logger, env });
+                        break;
+                }
             }
-            const maestroVersionResult = await (0, results_1.asyncResult)(getMaestroVersion({ env }));
+            const maestroVersionResult = await (0, results_1.asyncResult)(getMaestroVersion({ env, backend }));
             if (!maestroVersionResult.ok) {
                 logger.error(maestroVersionResult.reason, 'Failed to get Maestro version.');
-                throw new Error('Failed to ensure Maestro is installed.');
+                throw new Error(`Failed to ensure ${backend} is installed.`);
             }
-            logger.info(`Maestro ${maestroVersionResult.value} is ready.`);
+            logger.info(`${backend} ${maestroVersionResult.value} is ready.`);
             outputs.maestro_version.set(maestroVersionResult.value);
             datadog_1.Datadog.distribution('eas.maestro.install', 1, {
                 maestro_version: maestroVersionResult.value,
+                maestro_backend: backend,
             });
         },
     });
 }
-async function getMaestroVersion({ env }) {
-    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 getMaestroVersion({ env, backend, }) {
+    switch (backend) {
+        case 'maestro': {
+            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.
+            const versions = stdout.match(/\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?/g);
+            return versions?.at(-1) ?? stdout.trim();
+        }
+        case 'maestro-runner': {
+            const { stdout } = await (0, turtle_spawn_1.default)('maestro-runner', ['--version'], { stdio: 'pipe', env });
+            // maestro-runner prints build information after its version. The Go runtime version in
+            // that output is also semver-shaped, so read only the prefixed runner version.
+            return /^maestro-runner\s+(\S+)/m.exec(stdout)?.[1] ?? stdout.trim();
+        }
+    }
+}
+async function installMaestroRunner({ global, version, logger, env, }) {
+    logger.info('Fetching maestro-runner install script');
+    const tempDirectory = await fs_1.default.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'install_maestro_runner'));
+    try {
+        const installMaestroRunnerScriptResponse = await fetch('https://open.devicelab.dev/install/maestro-runner');
+        const installMaestroRunnerScript = await installMaestroRunnerScriptResponse.text();
+        const scriptPath = path_1.default.join(tempDirectory, 'install_maestro_runner.sh');
+        await fs_1.default.promises.writeFile(scriptPath, installMaestroRunnerScript, { mode: 0o777 });
+        logger.info('Installing maestro-runner');
+        (0, assert_1.default)(env.HOME, 'Failed to infer directory to install maestro-runner in: $HOME environment variable is empty.');
+        await (0, turtle_spawn_1.default)(scriptPath, version && version !== 'latest' ? ['--version', version] : [], {
+            logger,
+            env,
+        });
+        const binDir = path_1.default.join(env.HOME, '.maestro-runner', 'bin');
+        global.updateEnv({
+            ...global.env,
+            PATH: `${global.env.PATH}:${binDir}`,
+        });
+        env.PATH = `${env.PATH}:${binDir}`;
+        process.env.PATH = `${process.env.PATH}:${binDir}`;
+    }
+    finally {
+        await fs_1.default.promises.rm(tempDirectory, { force: true, recursive: true });
+    }
 }
 async function installMaestro({ global, version, logger, env, }) {
     logger.info('Fetching install script');

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

@@ -0,0 +1,11 @@
+import { BuildStepEnv } from '@expo/steps';
+import { z } from 'zod';
+export declare const MaestroBackendSchema: z.ZodDefault<z.ZodEnum<{
+    maestro: "maestro";
+    "maestro-runner": "maestro-runner";
+}>>;
+export type MaestroBackend = z.output<typeof MaestroBackendSchema>;
+export declare function resolveMaestroBackend({ input, env, }: {
+    input: unknown;
+    env: BuildStepEnv;
+}): MaestroBackend;

package/dist/steps/functions/maestroBackend.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaestroBackendSchema = void 0;
+exports.resolveMaestroBackend = resolveMaestroBackend;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const zod_1 = require("zod");
+exports.MaestroBackendSchema = zod_1.z.enum(['maestro', 'maestro-runner']).default('maestro');
+function resolveMaestroBackend({ input, env, }) {
+    const result = exports.MaestroBackendSchema.safeParse(input || env.EAS_MAESTRO_BACKEND || undefined);
+    if (!result.success) {
+        throw new eas_build_job_1.UserError('ERR_MAESTRO_INVALID_INPUT', 'backend and EAS_MAESTRO_BACKEND must be either "maestro" or "maestro-runner".', { cause: result.error });
+    }
+    return result.data;
+}

package/dist/steps/functions/maestroTests.js

@@ -18,6 +18,7 @@ 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();
+const AndroidConnectionModeSchema = zod_1.z.enum(['adb', 'dadb']).default('adb');
 function parseInput(schema, value, message) {
     const result = schema.safeParse(value);
     if (!result.success) {
@@ -109,6 +110,11 @@ function createMaestroTestsBuildFunction(ctx) {
                 required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'android_connection_mode',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
         ],
         outputProviders: [
             steps_1.BuildStepOutput.createProvider({ id: 'junit_report_directory', required: true }),
@@ -153,6 +159,9 @@ function createMaestroTestsBuildFunction(ctx) {
             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".');
             const retryFailedOnly = inputs.retry_failed_only.value;
             try {
                 await promises_1.default.mkdir(junitReportDirectory, { recursive: true });
@@ -176,6 +185,33 @@ function createMaestroTestsBuildFunction(ctx) {
             let lastAttemptExitCode = null;
             const harvested = [];
             const totalAttempts = retries + 1;
+            if (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', {
+                        mode: 0o755,
+                    });
+                    // DADB starts an ADB server when it can find an adb binary. Stop the existing
+                    // server first, then make only the Maestro process find the failing shim.
+                    try {
+                        await (0, turtle_spawn_1.default)('adb', ['kill-server'], { env: { ...spawnEnv }, logger, signal });
+                        logger.info('Using a direct DADB connection for Android Maestro tests after stopping the ADB server.');
+                    }
+                    catch (err) {
+                        logger.warn({ err }, 'Using a direct DADB connection for Android Maestro tests, but failed to stop the ADB server.');
+                    }
+                    spawnEnv.PATH = spawnEnv.PATH
+                        ? `${adbOverrideDirectoryPath}${path_1.default.delimiter}${spawnEnv.PATH}`
+                        : adbOverrideDirectoryPath;
+                }
+                catch (err) {
+                    // Intentionally skip cleanup because the worker is disposable.
+                    throw new eas_build_job_1.SystemError('Failed to enable direct DADB connection for Maestro', {
+                        cause: err,
+                    });
+                }
+                // Do not restart ADB or remove the override. This keeps Maestro in direct DADB mode.
+            }
             for (let attempt = 0; attempt <= retries; attempt++) {
                 const outputPath = outputFormat === 'junit'
                     ? path_1.default.join(junitReportDirectory, `${platform}-maestro-junit-attempt-${attempt}.xml`)

package/dist/steps/functions/startAndroidEmulator.js

@@ -8,6 +8,9 @@ const eas_build_job_1 = require("@expo/eas-build-job");
 const results_1 = require("@expo/results");
 const steps_1 = require("@expo/steps");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
 const AndroidEmulatorUtils_1 = require("../../utils/AndroidEmulatorUtils");
 const retry_1 = require("../../utils/retry");
 const ANDROID_STARTUP_ATTEMPT_TIMEOUT_MS = [60_000, 120_000, 180_000];
@@ -43,7 +46,15 @@ function createStartAndroidEmulatorBuildFunction() {
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
             }),
         ],
-        fn: async ({ logger }, { inputs, env }) => {
+        outputProviders: [
+            steps_1.BuildStepOutput.createProvider({
+                id: 'logcat_directory',
+                required: true,
+            }),
+        ],
+        fn: async ({ logger }, { inputs, outputs, env }) => {
+            const logcatDirectory = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'eas-android-emulator-logcat-'));
+            outputs.logcat_directory.set(logcatDirectory);
             if (env.EAS_NO_EMULATOR_HOST_SUPPORT_CHECK !== '1') {
                 await assertAndroidEmulatorHostSupportAsync({ env });
             }
@@ -103,6 +114,7 @@ function createStartAndroidEmulatorBuildFunction() {
                     const startResult = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.startAsync({
                         deviceName,
                         env,
+                        logcatDirectory,
                     });
                     attemptSerialId = startResult.serialId;
                     await AndroidEmulatorUtils_1.AndroidEmulatorUtils.waitForReadyAsync({
@@ -184,6 +196,7 @@ function createStartAndroidEmulatorBuildFunction() {
                             const startResult = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.startAsync({
                                 deviceName: cloneIdentifier,
                                 env,
+                                logcatDirectory,
                             });
                             cloneSerialId = startResult.serialId;
                             logger.info('Waiting for emulator to become ready');

package/dist/utils/AndroidEmulatorUtils.d.ts

@@ -34,12 +34,14 @@ export declare namespace AndroidEmulatorUtils {
         env: NodeJS.ProcessEnv;
         logger: bunyan;
     }): Promise<void>;
-    function startAsync({ deviceName, env, }: {
+    function startAsync({ deviceName, env, logcatDirectory, }: {
         deviceName: AndroidVirtualDeviceName;
         env: NodeJS.ProcessEnv;
+        logcatDirectory: string;
     }): Promise<{
         emulatorPromise: SpawnPromise<SpawnResult>;
         serialId: AndroidDeviceSerialId;
+        logcatOutputPath: string;
     }>;
     function waitForReadyAsync({ serialId, env, timeoutMs, logger, }: {
         serialId: AndroidDeviceSerialId;

package/dist/utils/AndroidEmulatorUtils.js

@@ -4,10 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AndroidEmulatorUtils = void 0;
+const eas_build_job_1 = require("@expo/eas-build-job");
 const results_1 = require("@expo/results");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
 const assert_1 = __importDefault(require("assert"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
+const node_crypto_1 = require("node:crypto");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -212,13 +214,32 @@ var AndroidEmulatorUtils;
         }
     }
     AndroidEmulatorUtils.cloneAsync = cloneAsync;
-    async function startAsync({ deviceName, env, }) {
+    async function startAsync({ deviceName, env, logcatDirectory, }) {
+        let logcatOutputPath;
+        try {
+            await node_fs_1.default.promises.mkdir(logcatDirectory, { recursive: true });
+            const safeDeviceName = deviceName.replace(/[^a-zA-Z0-9_.-]/g, '_');
+            const timestamp = Math.floor(Date.now() / 1000)
+                .toString(16)
+                .padStart(8, '0');
+            logcatOutputPath = node_path_1.default.join(logcatDirectory, `${safeDeviceName}-${timestamp}-${(0, node_crypto_1.randomBytes)(2).toString('hex')}.log`);
+            await node_fs_1.default.promises.writeFile(logcatOutputPath, '');
+        }
+        catch (err) {
+            throw new eas_build_job_1.SystemError(`Failed to prepare Android emulator logcat output for ${deviceName}.`, {
+                cause: err,
+            });
+        }
         const emulatorPromise = (0, turtle_spawn_1.default)(`${process.env.ANDROID_HOME}/emulator/emulator`, [
             '-no-window',
             '-no-boot-anim',
             '-writable-system',
             '-noaudio',
             '-no-snapshot-save',
+            '-logcat',
+            '*:v',
+            '-logcat-output',
+            logcatOutputPath,
             '-avd',
             deviceName,
             '-accel',
@@ -255,7 +276,7 @@ var AndroidEmulatorUtils;
         });
         // We don't want to await the SpawnPromise here.
         // eslint-disable-next-line @typescript-eslint/return-await
-        return { emulatorPromise, serialId };
+        return { emulatorPromise, serialId, logcatOutputPath };
     }
     AndroidEmulatorUtils.startAsync = startAsync;
     async function waitForReadyAsync({ serialId, env, timeoutMs = 3 * 60 * 1_000, logger, }) {

package/dist/utils/sourceMaps.d.ts

@@ -0,0 +1,5 @@
+import { BuildJob } from '@expo/eas-build-job';
+import { BuildContext } from '../context';
+export declare function isSourceMapUploadEnabled(ctx: BuildContext<BuildJob>): boolean;
+export declare function resolveIosSourceMapPathAsync(ctx: BuildContext<BuildJob>): Promise<string>;
+export declare function maybeUploadSourceMapAsync(ctx: BuildContext<BuildJob>): Promise<void>;

package/dist/utils/sourceMaps.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSourceMapUploadEnabled = isSourceMapUploadEnabled;
+exports.resolveIosSourceMapPathAsync = resolveIosSourceMapPathAsync;
+exports.maybeUploadSourceMapAsync = maybeUploadSourceMapAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const ANDROID_SOURCE_MAP_PATTERN = 'android/**/build/generated/sourcemaps/react/**/*.map';
+const SOURCE_MAP_UPLOAD_DIRECTORY = 'observe-source-maps';
+function isSourceMapUploadEnabled(ctx) {
+    return !ctx.isLocal && ctx.job.experimental?.uploadSourceMaps === true;
+}
+async function resolveIosSourceMapPathAsync(ctx) {
+    const configuredPath = ctx.env.SOURCEMAP_FILE;
+    const sourceMapPath = configuredPath
+        ? path_1.default.resolve(ctx.getReactNativeProjectDirectory(), 'ios', configuredPath)
+        : path_1.default.join(ctx.workingdir, SOURCE_MAP_UPLOAD_DIRECTORY, 'main.jsbundle.map');
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(sourceMapPath));
+    return sourceMapPath;
+}
+async function maybeUploadSourceMapAsync(ctx) {
+    if (!isSourceMapUploadEnabled(ctx)) {
+        return;
+    }
+    try {
+        const sourceMapPath = await resolveSourceMapPathAsync(ctx);
+        const strippedSourceMapPath = await stripSourcesContentAsync(ctx, sourceMapPath);
+        ctx.logger.info(`Uploading source map: ${sourceMapPath}`);
+        await ctx.uploadArtifact({
+            artifact: {
+                type: eas_build_job_1.ManagedArtifactType.SOURCE_MAP,
+                paths: [strippedSourceMapPath],
+            },
+            logger: ctx.logger,
+        });
+    }
+    catch (err) {
+        ctx.logger.warn({ err }, 'Failed to upload source map.');
+        ctx.markBuildPhaseHasWarnings();
+    }
+}
+async function resolveSourceMapPathAsync(ctx) {
+    if (ctx.job.platform === eas_build_job_1.Platform.IOS) {
+        const sourceMapPath = await resolveIosSourceMapPathAsync(ctx);
+        if (!(await fs_extra_1.default.pathExists(sourceMapPath))) {
+            throw new eas_build_job_1.SystemError(`The iOS source map was not generated at ${sourceMapPath}.`);
+        }
+        return sourceMapPath;
+    }
+    if (ctx.job.platform === eas_build_job_1.Platform.ANDROID) {
+        const projectDir = ctx.getReactNativeProjectDirectory();
+        const sourceMapPaths = (await (0, fast_glob_1.default)(ANDROID_SOURCE_MAP_PATTERN, {
+            absolute: true,
+            cwd: projectDir,
+            onlyFiles: true,
+        })).filter(sourceMapPath => !isIntermediateAndroidSourceMap(sourceMapPath));
+        if (sourceMapPaths.length === 0) {
+            throw new eas_build_job_1.SystemError('The Android build did not generate a final composed source map.');
+        }
+        if (sourceMapPaths.length > 1) {
+            throw new eas_build_job_1.SystemError(`Found multiple final Android source maps: ${sourceMapPaths.join(', ')}. ` +
+                'Refusing to upload a source map that may not match the application archive.');
+        }
+        return sourceMapPaths[0];
+    }
+    throw new eas_build_job_1.SystemError('Source-map upload is not supported for this build platform.');
+}
+function isIntermediateAndroidSourceMap(sourceMapPath) {
+    return sourceMapPath.endsWith('.packager.map') || sourceMapPath.endsWith('.compiler.map');
+}
+async function stripSourcesContentAsync(ctx, sourceMapPath) {
+    const sourceMap = JSON.parse(await fs_extra_1.default.readFile(sourceMapPath, 'utf8'));
+    if (!isRecord(sourceMap) || sourceMap.version !== 3) {
+        throw new eas_build_job_1.SystemError(`Invalid source map at ${sourceMapPath}.`);
+    }
+    removeSourcesContent(sourceMap);
+    const uploadDirectory = path_1.default.join(ctx.workingdir, SOURCE_MAP_UPLOAD_DIRECTORY);
+    const uploadPath = path_1.default.join(uploadDirectory, `${ctx.job.platform}.map`);
+    await fs_extra_1.default.ensureDir(uploadDirectory);
+    await fs_extra_1.default.writeFile(uploadPath, JSON.stringify(sourceMap), 'utf8');
+    return uploadPath;
+}
+function removeSourcesContent(value) {
+    if (Array.isArray(value)) {
+        for (const child of value) {
+            removeSourcesContent(child);
+        }
+        return;
+    }
+    if (!isRecord(value)) {
+        return;
+    }
+    delete value.sourcesContent;
+    for (const child of Object.values(value)) {
+        removeSourcesContent(child);
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "21.7.1",
+  "version": "22.0.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -38,17 +38,17 @@
   "dependencies": {
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
-    "@expo/downloader": "21.0.0",
-    "@expo/eas-build-job": "21.6.0",
+    "@expo/downloader": "22.0.0",
+    "@expo/eas-build-job": "22.0.0",
     "@expo/env": "^0.4.0",
-    "@expo/logger": "21.0.0",
+    "@expo/logger": "22.0.0",
     "@expo/package-manager": "1.9.10",
     "@expo/plist": "^0.3.5",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "21.7.1",
-    "@expo/template-file": "21.0.2",
-    "@expo/turtle-spawn": "21.0.0",
+    "@expo/steps": "22.0.0",
+    "@expo/template-file": "22.0.0",
+    "@expo/turtle-spawn": "22.0.0",
     "@expo/xcpretty": "^4.3.1",
     "@ngrok/ngrok": "1.7.0",
     "@sentry/node": "7.77.0",
@@ -100,5 +100,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "60032049ec947177bbcacf8802c22e1d5f24845f"
+  "gitHead": "b92a9cc5a718f133966e27b9fedcedb569f9cd17"
 }