@expo/build-tools 21.8.0 → 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/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.8.0",
+  "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": "b8cff2008966a6c7202736577cd231025ee47f21"
+  "gitHead": "b92a9cc5a718f133966e27b9fedcedb569f9cd17"
 }