@expo/build-tools 18.7.0 → 18.8.1

package/dist/steps/functions/export.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEasExportBuildFunction = createEasExportBuildFunction;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+const packageManager_1 = require("../../utils/packageManager");
+const project_1 = require("../../utils/project");
+function createEasExportBuildFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'export',
+        name: 'Export',
+        __metricsId: 'eas/export',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'output_dir',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+                defaultValue: 'dist',
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'dev',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'minify',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'dump_assetmap',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'ssg',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'api_only',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'platform',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+                defaultValue: 'web',
+            }),
+        ],
+        outputProviders: [
+            steps_1.BuildStepOutput.createProvider({
+                id: 'export_dir',
+                required: true,
+            }),
+        ],
+        fn: async (stepsCtx, { inputs, outputs, env }) => {
+            const outputDir = inputs.output_dir.value;
+            const dev = inputs.dev.value;
+            const minify = inputs.minify.value;
+            const dumpAssetmap = inputs.dump_assetmap.value;
+            const ssg = inputs.ssg.value;
+            const apiOnly = inputs.api_only.value;
+            const platform = inputs.platform.value;
+            const packageManager = (0, packageManager_1.resolvePackageManager)(stepsCtx.workingDirectory, { env });
+            const exportCommand = getExportCommand({
+                outputDir,
+                dev,
+                minify,
+                dumpAssetmap,
+                ssg,
+                apiOnly,
+                platform,
+            });
+            stepsCtx.logger.info(`Running export command: expo ${exportCommand.join(' ')}`);
+            try {
+                await (0, project_1.runExpoCliCommand)({
+                    packageManager,
+                    args: exportCommand,
+                    options: {
+                        cwd: stepsCtx.workingDirectory,
+                        env,
+                        logger: stepsCtx.logger,
+                        stdio: 'pipe',
+                    },
+                });
+                outputs.export_dir.set(outputDir);
+            }
+            catch (error) {
+                throw new eas_build_job_1.UserError('EXPO_EXPORT_FAILED', `Export command failed: ${error instanceof Error ? error.message : 'unknown error'}`);
+            }
+        },
+    });
+}
+function getExportCommand({ outputDir, dev, minify, dumpAssetmap, ssg, apiOnly, platform, }) {
+    const exportCommand = ['export', '--output-dir', outputDir, '--platform', platform];
+    if (dev) {
+        exportCommand.push('--dev');
+    }
+    if (minify === false) {
+        exportCommand.push('--no-minify');
+    }
+    if (dumpAssetmap) {
+        exportCommand.push('--dump-assetmap');
+    }
+    if (ssg === false) {
+        exportCommand.push('--no-ssg');
+    }
+    if (apiOnly) {
+        exportCommand.push('--api-only');
+    }
+    return exportCommand;
+}

package/dist/steps/functions/generateGymfileFromTemplate.js

@@ -10,6 +10,7 @@ const steps_1 = require("@expo/steps");
 const template_file_1 = require("@expo/template-file");
 const assert_1 = __importDefault(require("assert"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const credentials_1 = require("../utils/ios/credentials/credentials");
 const manager_1 = __importDefault(require("../utils/ios/credentials/manager"));
@@ -38,6 +39,10 @@ const DEFAULT_CREDENTIALS_TEMPLATE = `
     disable_xcpretty(true)
     buildlog_path("<%- LOGS_DIRECTORY %>")
 
+    derived_data_path("<%- DERIVED_DATA_PATH %>")
+    result_bundle(true)
+    result_bundle_path("<%- RESULT_BUNDLE_PATH %>")
+
     output_directory("<%- OUTPUT_DIRECTORY %>")
 `;
 const DEFAULT_SIMULATOR_TEMPLATE = `
@@ -56,6 +61,9 @@ const DEFAULT_SIMULATOR_TEMPLATE = `
 
     disable_xcpretty(true)
     buildlog_path("<%- LOGS_DIRECTORY %>")
+
+    result_bundle(true)
+    result_bundle_path("<%- RESULT_BUNDLE_PATH %>")
 `;
 function generateGymfileFromTemplateFunction() {
     return new steps_1.BuildFunction({
@@ -158,6 +166,7 @@ function generateGymfileFromTemplateFunction() {
                     ICLOUD_CONTAINER_ENVIRONMENT,
                     SCHEME_SIMULATOR_DESTINATION: simulatorDestination,
                     DERIVED_DATA_PATH: './build',
+                    RESULT_BUNDLE_PATH: path_1.default.join(os_1.default.tmpdir(), `result-bundle-${Date.now()}.xcresult`),
                     ...(PROFILES ? { PROFILES } : {}),
                     ...(credentials
                         ? {

package/dist/steps/functions/installNodeModules.js

@@ -23,7 +23,7 @@ function createInstallNodeModulesBuildFunction() {
 }
 async function installNodeModules(stepCtx, env) {
     const { logger } = stepCtx;
-    const packageManager = (0, packageManager_1.resolvePackageManager)(stepCtx.workingDirectory);
+    const packageManager = (0, packageManager_1.resolvePackageManager)(stepCtx.workingDirectory, { env });
     const packagerRunDir = (0, packageManager_1.findPackagerRootDir)(stepCtx.workingDirectory);
     if (packagerRunDir !== stepCtx.workingDirectory) {
         const relativeReactNativeProjectDirectory = path_1.default.relative(stepCtx.global.projectTargetDirectory, stepCtx.workingDirectory);

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

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

package/dist/steps/functions/parseXcactivitylog.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseXcactivitylogFunction = parseXcactivitylogFunction;
+const steps_1 = require("@expo/steps");
+const path_1 = __importDefault(require("path"));
+const xcactivitylog_1 = require("../utils/ios/xcactivitylog");
+function parseXcactivitylogFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'parse_xcactivitylog',
+        name: 'Analyze build performance',
+        __metricsId: 'eas/parse_xcactivitylog',
+        supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'derived_data_path',
+                required: false,
+                defaultValue: 'ios/build',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'workspace_path',
+                required: false,
+                defaultValue: 'ios',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'xclogparser_version',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+        ],
+        fn: async (stepCtx, { inputs, env }) => {
+            const derivedDataPath = inputs.derived_data_path.value;
+            const workspacePath = inputs.workspace_path.value;
+            const version = inputs.xclogparser_version.value;
+            await (0, xcactivitylog_1.parseAndReportXcactivitylog)({
+                derivedDataPath: path_1.default.resolve(stepCtx.workingDirectory, derivedDataPath),
+                workspacePath: path_1.default.resolve(stepCtx.workingDirectory, workspacePath),
+                xclogparserVersion: version,
+                logger: stepCtx.logger,
+                proxyBaseUrl: env.EAS_BUILD_COCOAPODS_CACHE_URL,
+            });
+        },
+    });
+}

package/dist/steps/functions/prebuild.js

@@ -35,7 +35,7 @@ function createPrebuildBuildFunction() {
         fn: async (stepCtx, { inputs, env }) => {
             const { logger } = stepCtx;
             const appleTeamId = inputs.apple_team_id.value;
-            const packageManager = (0, packageManager_1.resolvePackageManager)(stepCtx.workingDirectory);
+            const packageManager = (0, packageManager_1.resolvePackageManager)(stepCtx.workingDirectory, { env });
             const defaultPlatform = process.platform === 'darwin' ? 'ios' : 'android';
             const job = stepCtx.global.staticContext.job;
             const prebuildCommandArgs = getPrebuildCommandArgs({

package/dist/steps/functions/restoreBuildCache.js

@@ -154,7 +154,7 @@ async function restoreCcacheAsync({ logger, workingDirectory, platform, env, sec
     }
 }
 async function restoreGradleCacheAsync({ logger, workingDirectory, env, secrets, }) {
-    if (env.EXPERIMENTAL_EAS_GRADLE_CACHE !== '1') {
+    if (env.EAS_GRADLE_CACHE !== '1') {
         return;
     }
     try {

package/dist/steps/functions/saveBuildCache.js

@@ -112,7 +112,7 @@ async function saveCcacheAsync({ logger, workingDirectory, platform, evictUsedBe
     }
 }
 async function saveGradleCacheAsync({ logger, workingDirectory, env, secrets, }) {
-    if (env.EXPERIMENTAL_EAS_GRADLE_CACHE !== '1') {
+    if (env.EAS_GRADLE_CACHE !== '1') {
         return;
     }
     const gradleCachesPath = path_1.default.join(os_1.default.homedir(), '.gradle', 'caches');

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

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

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStartAgentDeviceRemoteSessionBuildFunction = createStartAgentDeviceRemoteSessionBuildFunction;
+const steps_1 = require("@expo/steps");
+const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const node_child_process_1 = __importDefault(require("node:child_process"));
+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 retry_1 = require("../../utils/retry");
+const AGENT_DEVICE_REPO_URL = 'https://github.com/callstackincubator/agent-device.git';
+const SRC_DIR = '/tmp/agent-device-src';
+const RUN_DIR = '/tmp/agent-device';
+const DAEMON_LOG = node_path_1.default.join(RUN_DIR, 'daemon.log');
+const TUNNEL_LOG = node_path_1.default.join(RUN_DIR, 'cloudflared.log');
+const DAEMON_JSON_PATH = node_path_1.default.join(node_os_1.default.homedir(), '.agent-device', 'daemon.json');
+const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
+const STARTUP_TIMEOUT_MS = 60_000;
+function createStartAgentDeviceRemoteSessionBuildFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'start_agent_device_remote_session',
+        name: 'Start agent device remote session',
+        __metricsId: 'eas/start_agent_device_remote_session',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'package_version',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+        ],
+        fn: async ({ logger }, { inputs, env }) => {
+            const packageVersion = inputs.package_version.value;
+            logger.info(`Starting agent-device remote session (version: ${packageVersion ?? 'latest'}).`);
+            logger.info(`Preparing runtime directory at ${RUN_DIR}.`);
+            await node_fs_1.default.promises.mkdir(RUN_DIR, { recursive: true });
+            logger.info(`Selecting Xcode developer directory: ${XCODE_DEVELOPER_DIR}.`);
+            await (0, turtle_spawn_1.default)('sudo', ['xcode-select', '-s', XCODE_DEVELOPER_DIR], { env, logger });
+            logger.info('Ensuring cloudflared is installed.');
+            await ensureCloudflaredInstalledAsync({ env, logger });
+            logger.info('Ensuring bun is installed.');
+            await ensureBunInstalledAsync({ env, logger });
+            logger.info(packageVersion
+                ? `Cloning agent-device @ v${packageVersion} into ${SRC_DIR}.`
+                : `Cloning agent-device (latest) into ${SRC_DIR}.`);
+            await cloneAgentDeviceAsync({ packageVersion, env, logger });
+            logger.info('Installing agent-device dependencies.');
+            await (0, turtle_spawn_1.default)('bun', ['install', '--production'], {
+                cwd: SRC_DIR,
+                env,
+                logger,
+            });
+            logger.info(`Launching agent-device daemon (log file: ${DAEMON_LOG}).`);
+            await spawnDetachedAsync({
+                command: 'bun run src/daemon.ts',
+                cwd: SRC_DIR,
+                logFile: DAEMON_LOG,
+                env: { ...env, AGENT_DEVICE_DAEMON_SERVER_MODE: 'http' },
+                logger,
+            });
+            logger.info(`Waiting for daemon credentials at ${DAEMON_JSON_PATH}.`);
+            await waitForFileAsync({
+                filePath: DAEMON_JSON_PATH,
+                timeoutMs: STARTUP_TIMEOUT_MS,
+                description: 'agent-device daemon',
+            });
+            const { port: daemonPort, token: daemonToken } = readDaemonInfo(DAEMON_JSON_PATH);
+            logger.info(`Daemon is listening on port ${daemonPort}; loaded auth token.`);
+            logger.info(`Starting cloudflared tunnel to http://localhost:${daemonPort} (log file: ${TUNNEL_LOG}).`);
+            await spawnDetachedAsync({
+                command: `cloudflared tunnel --url "http://localhost:${daemonPort}"`,
+                logFile: TUNNEL_LOG,
+                env,
+                logger,
+            });
+            logger.info('Waiting for a public tunnel URL.');
+            const tunnelUrl = await waitForMatchInLogAsync({
+                logFile: TUNNEL_LOG,
+                pattern: /https:\/\/[a-z0-9-]+\.trycloudflare\.com/,
+                timeoutMs: STARTUP_TIMEOUT_MS,
+                description: 'cloudflared tunnel',
+            });
+            logger.info(`Tunnel is ready at ${tunnelUrl}.`);
+            logger.info('Emitting agent-device credentials for the CLI to pick up:');
+            logger.info(`export AGENT_DEVICE_DAEMON_BASE_URL="${tunnelUrl}"`);
+            logger.info(`export AGENT_DEVICE_DAEMON_AUTH_TOKEN="${daemonToken}"`);
+            logger.info('Remote session is live. Keeping the job alive until the session is stopped.');
+            // Keep the turtle job alive so the daemon and tunnel stay reachable
+            // until stopDeviceRunSession cancels the run.
+            await new Promise(() => { });
+        },
+    });
+}
+async function ensureCloudflaredInstalledAsync({ env, logger, }) {
+    await ensureBrewPackageInstalledAsync({ name: 'cloudflared', env, logger });
+}
+async function ensureBunInstalledAsync({ env, logger, }) {
+    await ensureBrewPackageInstalledAsync({ name: 'bun', env, logger });
+}
+async function ensureBrewPackageInstalledAsync({ name, env, logger, }) {
+    await (0, turtle_spawn_1.default)('bash', ['-c', `command -v ${name} >/dev/null 2>&1 || HOMEBREW_NO_AUTO_UPDATE=1 brew install ${name}`], { env, logger });
+}
+async function cloneAgentDeviceAsync({ packageVersion, env, logger, }) {
+    const branchArgs = packageVersion ? ['--branch', `v${packageVersion}`] : [];
+    await (0, turtle_spawn_1.default)('git', ['clone', '--depth', '1', ...branchArgs, AGENT_DEVICE_REPO_URL, SRC_DIR], {
+        env,
+        logger,
+    });
+}
+async function spawnDetachedAsync({ command, cwd, logFile, env, logger, }) {
+    // Launch the process fully detached so this function returns immediately and
+    // the grandchild survives the step. Stdio goes to a log file so the daemon
+    // output can be polled, and we unref so Node doesn't wait on it.
+    const fd = node_fs_1.default.openSync(logFile, 'a');
+    try {
+        const child = node_child_process_1.default.spawn('bash', ['-c', command], {
+            cwd,
+            env,
+            detached: true,
+            stdio: ['ignore', fd, fd],
+        });
+        if (!child.pid) {
+            throw new Error(`Failed to spawn detached process: ${command}`);
+        }
+        child.unref();
+        logger.info(`Started detached process (pid ${child.pid}).`);
+    }
+    finally {
+        node_fs_1.default.closeSync(fd);
+    }
+}
+async function waitForMatchInLogAsync({ logFile, pattern, timeoutMs, description, }) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const content = await readFileOrEmptyAsync(logFile);
+        const match = pattern.exec(content);
+        if (match) {
+            return match[1] ?? match[0];
+        }
+        await (0, retry_1.sleepAsync)(1_000);
+    }
+    const tail = await readFileOrEmptyAsync(logFile);
+    throw new Error(`Timed out waiting for ${description} to start. Last log contents:\n${tail || '<empty>'}`);
+}
+async function waitForFileAsync({ filePath, timeoutMs, description, }) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            await node_fs_1.default.promises.access(filePath);
+            return;
+        }
+        catch {
+            // not yet; keep polling
+        }
+        await (0, retry_1.sleepAsync)(1_000);
+    }
+    throw new Error(`Timed out waiting for ${description} to write ${filePath}.`);
+}
+async function readFileOrEmptyAsync(filePath) {
+    try {
+        return await node_fs_1.default.promises.readFile(filePath, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function readDaemonInfo(filePath) {
+    const raw = node_fs_1.default.readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed ||
+        typeof parsed !== 'object' ||
+        typeof parsed.httpPort !== 'number' ||
+        typeof parsed.token !== 'string') {
+        throw new Error(`Expected ${filePath} to contain { "httpPort": <number>, "token": "..." }.`);
+    }
+    const { httpPort, token } = parsed;
+    return { port: httpPort, token };
+}

package/dist/steps/utils/ios/xcactivitylog.d.ts

@@ -0,0 +1,57 @@
+import { bunyan } from '@expo/logger';
+import { z } from 'zod';
+/**
+ * Download xclogparser, parse xcactivitylog from derived data, and log a
+ * compile metrics report. Never throws — all errors are logged at debug level.
+ *
+ * Can be called from both the step-based flow (BuildFunction) and the
+ * traditional builder flow (runBuildPhase).
+ */
+export declare function parseAndReportXcactivitylog({ derivedDataPath, workspacePath, xclogparserVersion, logger, proxyBaseUrl, }: {
+    derivedDataPath: string;
+    workspacePath: string;
+    xclogparserVersion?: string;
+    logger: bunyan;
+    proxyBaseUrl?: string;
+}): Promise<void>;
+declare const XcactivitylogStepSchemaZ: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    detailStepType: z.ZodOptional<z.ZodString>;
+    signature: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    startTimestamp: z.ZodOptional<z.ZodNumber>;
+    endTimestamp: z.ZodOptional<z.ZodNumber>;
+    subSteps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const XcactivitylogDataSchemaZ: z.ZodObject<{
+    schema: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    subSteps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        detailStepType: z.ZodOptional<z.ZodString>;
+        signature: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        startTimestamp: z.ZodOptional<z.ZodNumber>;
+        endTimestamp: z.ZodOptional<z.ZodNumber>;
+        subSteps: z.ZodOptional<z.ZodArray<z.ZodObject</*elided*/ any, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type XcactivitylogStep = z.infer<typeof XcactivitylogStepSchemaZ>;
+type XcactivitylogData = z.infer<typeof XcactivitylogDataSchemaZ>;
+interface TargetMetric {
+    moduleName: string;
+    taskSeconds: number;
+    wallSpan: number;
+    activeWallTime: number;
+}
+export declare function isCompileStep(step: Partial<XcactivitylogStep>): boolean;
+export declare function collectTopLevelCompileSteps(step: XcactivitylogStep, results?: XcactivitylogStep[]): XcactivitylogStep[];
+export declare function buildTargetMetrics(data: XcactivitylogData, { minTaskSeconds }?: {
+    minTaskSeconds?: number;
+}): {
+    results: TargetMetric[];
+    totalTaskSeconds: number;
+};
+export declare function formatReport(data: XcactivitylogData): string;
+export {};