@expo/build-tools 21.8.0 → 22.2.0

package/dist/utils/AndroidEmulatorUtils.js

@@ -11,9 +11,11 @@ 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_net_1 = require("node:net");
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const promises_1 = require("node:timers/promises");
+const sentry_1 = require("../sentry");
 const retry_1 = require("./retry");
 var AndroidEmulatorUtils;
 (function (AndroidEmulatorUtils) {
@@ -216,17 +218,21 @@ var AndroidEmulatorUtils;
     AndroidEmulatorUtils.cloneAsync = cloneAsync;
     async function startAsync({ deviceName, env, logcatDirectory, }) {
         let logcatOutputPath;
+        let emulatorOutputPath;
         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`);
+            const outputName = `${safeDeviceName}-${timestamp}-${(0, node_crypto_1.randomBytes)(2).toString('hex')}`;
+            logcatOutputPath = node_path_1.default.join(logcatDirectory, `${outputName}-logcat.log`);
+            emulatorOutputPath = node_path_1.default.join(logcatDirectory, `${outputName}-emulator.log`);
             await node_fs_1.default.promises.writeFile(logcatOutputPath, '');
+            await node_fs_1.default.promises.writeFile(emulatorOutputPath, '');
         }
         catch (err) {
-            throw new eas_build_job_1.SystemError(`Failed to prepare Android emulator logcat output for ${deviceName}.`, {
+            throw new eas_build_job_1.SystemError(`Failed to prepare Android emulator output for ${deviceName}.`, {
                 cause: err,
             });
         }
@@ -249,13 +255,49 @@ var AndroidEmulatorUtils;
                 : []),
         ], {
             detached: true,
-            stdio: 'inherit',
+            stdio: ['ignore', 'pipe', 'pipe'],
+            ignoreStdio: true,
             env: {
                 ...env,
                 // We don't need to wait for emulator to exit gracefully.
                 ANDROID_EMULATOR_WAIT_TIME_BEFORE_KILL: '1',
             },
         });
+        const emulatorOutputStream = node_fs_1.default.createWriteStream(emulatorOutputPath, { flags: 'a' });
+        let reportedEmulatorOutputError = false;
+        emulatorOutputStream.on('error', err => {
+            process.stderr.write(`Failed to write Android emulator output to ${emulatorOutputPath}: ${err}\n`);
+            if (!reportedEmulatorOutputError) {
+                reportedEmulatorOutputError = true;
+                sentry_1.Sentry.capture('Failed to write Android emulator process output', err, {
+                    level: 'warning',
+                    tags: {
+                        errorCode: err.code ?? 'unknown',
+                    },
+                    extras: {
+                        deviceName,
+                        emulatorOutputPath,
+                    },
+                });
+            }
+        });
+        // Only into the log file -- this process' stdout/stderr is not watched or uploaded.
+        emulatorPromise.child.stdout?.pipe(emulatorOutputStream, { end: false });
+        emulatorPromise.child.stderr?.pipe(emulatorOutputStream, { end: false });
+        emulatorPromise.child.once('close', () => {
+            emulatorOutputStream.end();
+        });
+        // Piped stdio creates socket handles in this process which, unlike inherited
+        // file descriptors, keep the event loop alive for as long as the emulator runs.
+        // We never stop the emulator explicitly, so without unref-ing these the process
+        // would never exit on its own -- defeating the `detached` + `unref()` below.
+        // Output is still captured for as long as this process lives.
+        if (emulatorPromise.child.stdout instanceof node_net_1.Socket) {
+            emulatorPromise.child.stdout.unref();
+        }
+        if (emulatorPromise.child.stderr instanceof node_net_1.Socket) {
+            emulatorPromise.child.stderr.unref();
+        }
         // If emulator fails to start, throw its error.
         if (!emulatorPromise.child.pid) {
             await emulatorPromise;
@@ -276,7 +318,7 @@ var AndroidEmulatorUtils;
         });
         // We don't want to await the SpawnPromise here.
         // eslint-disable-next-line @typescript-eslint/return-await
-        return { emulatorPromise, serialId, logcatOutputPath };
+        return { emulatorPromise, serialId, logcatOutputPath, emulatorOutputPath };
     }
     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.8.0",
+  "version": "22.2.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.1.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": "5484dd607468c7711d915a2521df10531f8b9908"
 }