@expo/build-tools 20.0.0 → 20.2.0

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -7,9 +7,12 @@ exports.createStartAgentDeviceRemoteSessionBuildFunction = createStartAgentDevic
 const eas_build_job_1 = require("@expo/eas-build-job");
 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 sentry_1 = require("../../sentry");
 const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
+const AGENT_DEVICE_PACKAGE_NAME = 'agent-device';
 const AGENT_DEVICE_REPO_URL = 'https://github.com/callstackincubator/agent-device.git';
 const SRC_DIR = '/tmp/agent-device-src';
 const DAEMON_JSON_PATH = node_path_1.default.join(node_os_1.default.homedir(), '.agent-device', 'daemon.json');
@@ -43,29 +46,11 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 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(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.');
-            (0, remoteDeviceRunSession_1.spawnDetached)({
-                command: 'bun',
-                args: ['run', 'src/daemon.ts'],
-                cwd: SRC_DIR,
-                env: { ...env, AGENT_DEVICE_DAEMON_SERVER_MODE: 'http' },
-            });
+            const daemonProcess = await startAgentDeviceDaemonAsync({ packageVersion, env, logger });
             logger.info(`Waiting for daemon credentials at ${DAEMON_JSON_PATH}.`);
-            const { port: daemonPort, token: daemonToken } = await (0, remoteDeviceRunSession_1.waitForFileAsync)({
-                filePath: DAEMON_JSON_PATH,
-                timeoutMs: STARTUP_TIMEOUT_MS,
-                description: 'agent-device daemon credentials',
-                parse: parseDaemonInfo,
+            const { port: daemonPort, token: daemonToken } = await waitForDaemonInfoAsync({
+                daemonProcess,
             });
             logger.info(`Daemon is listening on port ${daemonPort}; loaded auth token.`);
             const agentDeviceRemoteSessionUrl = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
@@ -80,7 +65,7 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
             // on Darwin. Android sessions go without a preview URL.
             let webPreviewUrl;
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
-                const { previewUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)({
+                const { previewUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
                     baseDomain: ngrokTunnelDomain,
                     env,
                     logger,
@@ -106,6 +91,64 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
         },
     });
 }
+async function startAgentDeviceDaemonAsync({ packageVersion, env, logger, }) {
+    const packageSpec = createAgentDevicePackageSpec(packageVersion);
+    try {
+        logger.info(`Installing ${packageSpec} globally with Bun.`);
+        await (0, turtle_spawn_1.default)('bun', ['add', '--global', packageSpec], {
+            env,
+            logger,
+        });
+        const daemonPath = getGlobalAgentDeviceDaemonPath(env);
+        if (!node_fs_1.default.existsSync(daemonPath)) {
+            throw new eas_build_job_1.SystemError(`Expected agent-device daemon entry at ${daemonPath}.`);
+        }
+        logger.info(`Launching daemon from ${daemonPath}.`);
+        return (0, remoteDeviceRunSession_1.spawnDetached)({
+            command: 'node',
+            args: [daemonPath],
+            env: { ...env, AGENT_DEVICE_DAEMON_SERVER_MODE: 'http' },
+        });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        const bunVersion = await getBunVersionForDiagnosticsAsync(env);
+        sentry_1.Sentry.capture('Failed to start agent-device daemon from global Bun package; falling back to git clone', error, {
+            level: 'warning',
+            tags: {
+                phase: 'agent-device-daemon-start',
+                fallback: 'git-clone',
+            },
+            extras: {
+                packageSpec,
+                packageVersion: packageVersion ?? 'latest',
+                bunVersion,
+                bunInstallConfigured: Boolean(env.BUN_INSTALL?.trim()),
+            },
+        });
+        logger.warn(`Failed to start daemon from global ${packageSpec}; falling back to git clone: ${error.message}`);
+        return await startAgentDeviceDaemonFromGitAsync({ packageVersion, env, logger });
+    }
+}
+async function startAgentDeviceDaemonFromGitAsync({ packageVersion, 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 daemon from cloned agent-device source.');
+    return (0, remoteDeviceRunSession_1.spawnDetached)({
+        command: 'bun',
+        args: ['run', 'src/daemon.ts'],
+        cwd: SRC_DIR,
+        env: { ...env, AGENT_DEVICE_DAEMON_SERVER_MODE: 'http' },
+    });
+}
 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], {
@@ -113,6 +156,42 @@ async function cloneAgentDeviceAsync({ packageVersion, env, logger, }) {
         logger,
     });
 }
+async function waitForDaemonInfoAsync({ daemonProcess, }) {
+    try {
+        return await (0, remoteDeviceRunSession_1.waitForFileAsync)({
+            filePath: DAEMON_JSON_PATH,
+            timeoutMs: STARTUP_TIMEOUT_MS,
+            description: 'agent-device daemon credentials',
+            parse: parseDaemonInfo,
+        });
+    }
+    catch (err) {
+        const output = daemonProcess.getOutput();
+        throw new eas_build_job_1.SystemError(`${err instanceof Error
+            ? err.message
+            : `Timed out waiting for agent-device daemon credentials.`}${output ? `\nagent-device daemon output:\n${output}` : ''}`);
+    }
+}
+async function getBunVersionForDiagnosticsAsync(env) {
+    try {
+        const result = await (0, turtle_spawn_1.default)('bun', ['--version'], { stdio: 'pipe', env, cwd: node_os_1.default.tmpdir() });
+        return result.stdout.trim() || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function createAgentDevicePackageSpec(packageVersion) {
+    const versionSpec = packageVersion ? packageVersion.replace(/^v(?=\d)/, '') : 'latest';
+    return `${AGENT_DEVICE_PACKAGE_NAME}@${versionSpec}`;
+}
+function getGlobalAgentDeviceDaemonPath(env) {
+    return node_path_1.default.join(getBunInstallDirectory(env), 'install', 'global', 'node_modules', AGENT_DEVICE_PACKAGE_NAME, 'dist', 'src', 'internal', 'daemon.js');
+}
+function getBunInstallDirectory(env) {
+    const bunInstall = env.BUN_INSTALL?.trim();
+    return bunInstall ? bunInstall : node_path_1.default.join(node_os_1.default.homedir(), '.bun');
+}
 function parseDaemonInfo(raw) {
     const parsed = JSON.parse(raw);
     if (!parsed ||

package/dist/steps/functions/startArgentRemoteSession.js

@@ -77,7 +77,7 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
             // serve-sim is iOS-only — Android sessions go without a preview URL.
             let webPreviewUrl;
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
-                const serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)({
+                const serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
                     baseDomain: ngrokTunnelDomain,
                     env,
                     logger,

package/dist/steps/functions/startIosSimulator.js

@@ -52,6 +52,12 @@ function createStartIosSimulatorBuildFunction() {
                 deviceIdentifier: originalDeviceIdentifier,
                 env,
             });
+            try {
+                await IosSimulatorUtils_1.IosSimulatorUtils.disableApsdAsync({ udid, env });
+            }
+            catch (err) {
+                logger.warn({ err }, 'Failed to disable apsd in the Simulator.');
+            }
             await IosSimulatorUtils_1.IosSimulatorUtils.waitForReadyAsync({ udid, env });
             logger.info('');
             const device = await IosSimulatorUtils_1.IosSimulatorUtils.getDeviceAsync({ udid, env });
@@ -76,6 +82,12 @@ function createStartIosSimulatorBuildFunction() {
                         deviceIdentifier: cloneDeviceName,
                         env,
                     });
+                    try {
+                        await IosSimulatorUtils_1.IosSimulatorUtils.disableApsdAsync({ udid: cloneUdid, env });
+                    }
+                    catch (err) {
+                        logger.warn({ err }, 'Failed to disable apsd in the Simulator.');
+                    }
                     await IosSimulatorUtils_1.IosSimulatorUtils.waitForReadyAsync({
                         udid: cloneUdid,
                         env,

package/dist/steps/functions/startServeSimRemoteSession.js

@@ -22,7 +22,7 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
             logger.info('Starting serve-sim remote session.');
             logger.info(`Selecting Xcode developer directory: ${XCODE_DEVELOPER_DIR}.`);
             await (0, turtle_spawn_1.default)('sudo', ['xcode-select', '-s', XCODE_DEVELOPER_DIR], { env, logger });
-            const { previewUrl, streamUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)({
+            const { previewUrl, streamUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
                 baseDomain: ngrokTunnelDomain,
                 env,
                 logger,

package/dist/steps/functions/uploadArtifact.js

@@ -112,7 +112,7 @@ function createUploadArtifactBuildFunction(ctx) {
             }
             catch (error) {
                 if (inputs.ignore_error.value) {
-                    logger.error(`Failed to upload ${artifact.type}. Ignoring error.`, error);
+                    logger.error({ err: error }, `Failed to upload ${artifact.type}. Ignoring error.`);
                     // Ignoring error.
                     return;
                 }

package/dist/steps/utils/ios/fastlane.js

@@ -7,8 +7,8 @@ exports.runFastlaneGym = runFastlaneGym;
 exports.runFastlane = runFastlane;
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
 const path_1 = __importDefault(require("path"));
-const xcpretty_1 = require("./xcpretty");
 const fastlane_1 = require("../../../common/fastlane");
+const xcpretty_1 = require("../../../common/xcpretty");
 async function runFastlaneGym({ workingDir, logger, buildLogsDirectory, env, extraEnv, }) {
     const buildLogger = new xcpretty_1.XcodeBuildLogger(logger, workingDir);
     void buildLogger.watchLogFiles(buildLogsDirectory);

package/dist/steps/utils/remoteDeviceRunSession.d.ts

@@ -1,9 +1,36 @@
 import { bunyan } from '@expo/logger';
 import { BuildStepEnv } from '@expo/steps';
+import { z } from 'zod';
 import { CustomBuildContext } from '../../customBuildContext';
 export declare function getDeviceRunSessionIdOrThrow(env: BuildStepEnv): string;
 export declare function getNgrokTunnelDomainOrThrow(env: BuildStepEnv): string;
 export declare function getNgrokAuthtokenOrThrow(env: BuildStepEnv): string;
+declare const TurnIceServersSchema: z.ZodArray<z.ZodObject<{
+    urls: z.ZodArray<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    credential: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export type TurnIceServers = z.infer<typeof TurnIceServersSchema>;
+/**
+ * Translate Cloudflare ICE servers into serve-sim CLI flags: `--stun-url` (the
+ * credential-less entries) and `--turn-url`/`--turn-username`/`--turn-credential`
+ * (the entry carrying the short-lived credentials).
+ */
+export declare function turnIceServersToServeSimArgs(iceServers: TurnIceServers): string[];
+/**
+ * Fetch short-lived Cloudflare TURN ICE servers for this job run from www
+ * (minted on demand, mirroring how the worker fetches project clone URLs) and
+ * translate them into serve-sim CLI flags.
+ *
+ * Best-effort: on any failure we log and return [] so serve-sim falls back to
+ * its built-in P2P/STUN behavior. The credential is passed to serve-sim as a
+ * process arg and deliberately not logged (turtle-spawn never logs argv and the
+ * worker is single-tenant).
+ */
+export declare function fetchServeSimTurnArgsAsync(ctx: CustomBuildContext, { env, logger }: {
+    env: BuildStepEnv;
+    logger: bunyan;
+}): Promise<string[]>;
 export declare function uploadRemoteSessionConfigAsync({ ctx, deviceRunSessionId, remoteConfig, logger, }: {
     ctx: CustomBuildContext;
     deviceRunSessionId: string;
@@ -19,7 +46,7 @@ export declare function spawnDetached({ command, args, cwd, env, }: {
     cwd?: string;
     env: BuildStepEnv;
 }): DetachedProcessHandle;
-export declare function startServeSimWithTunnelAsync({ baseDomain, env, logger, timeoutMs, }: {
+export declare function startServeSimWithTunnelAsync(ctx: CustomBuildContext, { baseDomain, env, logger, timeoutMs, }: {
     baseDomain: string;
     env: BuildStepEnv;
     logger: bunyan;
@@ -41,3 +68,4 @@ export declare function waitForFileAsync<T>({ filePath, timeoutMs, description,
     description: string;
     parse: (raw: string) => T;
 }): Promise<T>;
+export {};

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -39,6 +39,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDeviceRunSessionIdOrThrow = getDeviceRunSessionIdOrThrow;
 exports.getNgrokTunnelDomainOrThrow = getNgrokTunnelDomainOrThrow;
 exports.getNgrokAuthtokenOrThrow = getNgrokAuthtokenOrThrow;
+exports.turnIceServersToServeSimArgs = turnIceServersToServeSimArgs;
+exports.fetchServeSimTurnArgsAsync = fetchServeSimTurnArgsAsync;
 exports.uploadRemoteSessionConfigAsync = uploadRemoteSessionConfigAsync;
 exports.spawnDetached = spawnDetached;
 exports.startServeSimWithTunnelAsync = startServeSimWithTunnelAsync;
@@ -48,9 +50,13 @@ const eas_build_job_1 = require("@expo/eas-build-job");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
 const ngrok = __importStar(require("@ngrok/ngrok"));
 const gql_tada_1 = require("gql.tada");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const zod_1 = require("zod");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = __importDefault(require("node:fs"));
+const sentry_1 = require("../../sentry");
 const retry_1 = require("../../utils/retry");
+const turtleFetch_1 = require("../../utils/turtleFetch");
 const START_DEVICE_RUN_SESSION_MUTATION = (0, gql_tada_1.graphql)(`
   mutation StartDeviceRunSession($deviceRunSessionId: ID!, $remoteConfig: JSONObject!) {
     deviceRunSession {
@@ -91,6 +97,72 @@ function getNgrokAuthtokenOrThrow(env) {
     }
     return authtoken;
 }
+const TurnIceServersSchema = zod_1.z.array(zod_1.z.object({
+    urls: zod_1.z.array(zod_1.z.string()),
+    username: zod_1.z.string().optional(),
+    credential: zod_1.z.string().optional(),
+}));
+const TurnIceServersResponseSchema = zod_1.z.object({
+    data: zod_1.z.object({
+        iceServers: TurnIceServersSchema,
+    }),
+});
+/**
+ * Translate Cloudflare ICE servers into serve-sim CLI flags: `--stun-url` (the
+ * credential-less entries) and `--turn-url`/`--turn-username`/`--turn-credential`
+ * (the entry carrying the short-lived credentials).
+ */
+function turnIceServersToServeSimArgs(iceServers) {
+    const stunUrls = iceServers
+        .filter(server => !server.username && !server.credential)
+        .flatMap(server => server.urls);
+    const turnServer = iceServers.find(server => server.username && server.credential);
+    const args = [];
+    if (stunUrls.length > 0) {
+        args.push('--stun-url', stunUrls.join(','));
+    }
+    if (turnServer?.username && turnServer.credential && turnServer.urls.length > 0) {
+        args.push('--turn-url', turnServer.urls.join(','), '--turn-username', turnServer.username, '--turn-credential', turnServer.credential);
+    }
+    return args;
+}
+/**
+ * Fetch short-lived Cloudflare TURN ICE servers for this job run from www
+ * (minted on demand, mirroring how the worker fetches project clone URLs) and
+ * translate them into serve-sim CLI flags.
+ *
+ * Best-effort: on any failure we log and return [] so serve-sim falls back to
+ * its built-in P2P/STUN behavior. The credential is passed to serve-sim as a
+ * process arg and deliberately not logged (turtle-spawn never logs argv and the
+ * worker is single-tenant).
+ */
+async function fetchServeSimTurnArgsAsync(ctx, { env, logger }) {
+    try {
+        const deviceRunSessionId = getDeviceRunSessionIdOrThrow(env);
+        const expoApiServerUrl = (0, nullthrows_1.default)(ctx.env.__API_SERVER_URL, '__API_SERVER_URL is not set');
+        const robotAccessToken = (0, nullthrows_1.default)(ctx.job.secrets?.robotAccessToken, 'robot access token is not set');
+        const response = await (0, turtleFetch_1.turtleFetch)(new URL(`/v2/device-run-sessions/${deviceRunSessionId}/turn-ice-servers`, expoApiServerUrl).toString(), 'POST', {
+            headers: {
+                Authorization: `Bearer ${robotAccessToken}`,
+            },
+            timeout: 5000,
+            retries: 1,
+            logger,
+        });
+        const { data } = TurnIceServersResponseSchema.parse(await response.json());
+        const args = turnIceServersToServeSimArgs(data.iceServers);
+        if (args.length > 0) {
+            logger.info('Configured serve-sim with Cloudflare TURN ICE servers.');
+        }
+        return args;
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        sentry_1.Sentry.capture('Could not fetch Cloudflare TURN ICE servers', error, { level: 'warning' });
+        logger.warn({ err: error }, 'Could not fetch Cloudflare TURN ICE servers; serve-sim will fall back to P2P/STUN.');
+        return [];
+    }
+}
 async function uploadRemoteSessionConfigAsync({ ctx, deviceRunSessionId, remoteConfig, logger, }) {
     logger.info(`Reporting remote config to the API server (device run session: ${deviceRunSessionId}).`);
     const result = await ctx.graphqlClient
@@ -119,8 +191,9 @@ function spawnDetached({ command, args, cwd, env, }) {
     promise.child.stderr?.on('data', appendChunk);
     return { getOutput: () => output };
 }
-async function startServeSimWithTunnelAsync({ baseDomain, env, logger, timeoutMs, }) {
+async function startServeSimWithTunnelAsync(ctx, { baseDomain, env, logger, timeoutMs, }) {
     logger.info('Launching serve-sim with tunnel.');
+    const turnArgs = await fetchServeSimTurnArgsAsync(ctx, { env, logger });
     const serveSim = spawnDetached({
         command: 'npx',
         args: [
@@ -135,7 +208,8 @@ async function startServeSimWithTunnelAsync({ baseDomain, env, logger, timeoutMs
             '--stream-quality',
             '0.55',
             '--codec',
-            'h264',
+            'webrtc',
+            ...turnArgs,
         ],
         env,
     });

package/dist/utils/IosSimulatorUtils.d.ts

@@ -49,6 +49,10 @@ export declare namespace IosSimulatorUtils {
         udid: IosSimulatorUuid;
         env: NodeJS.ProcessEnv;
     }): Promise<void>;
+    export function disableApsdAsync({ udid, env, }: {
+        udid: IosSimulatorUuid;
+        env: NodeJS.ProcessEnv;
+    }): Promise<void>;
     export function collectLogsAsync({ deviceIdentifier, env, }: {
         deviceIdentifier: IosSimulatorName | IosSimulatorUuid;
         env: NodeJS.ProcessEnv;

package/dist/utils/IosSimulatorUtils.js

@@ -77,6 +77,11 @@ var IosSimulatorUtils;
         });
     }
     IosSimulatorUtils.waitForReadyAsync = waitForReadyAsync;
+    async function disableApsdAsync({ udid, env, }) {
+        await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'spawn', udid, 'launchctl', 'disable', 'system/com.apple.apsd'], { env });
+        await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'spawn', udid, 'launchctl', 'bootout', 'system/com.apple.apsd'], { env });
+    }
+    IosSimulatorUtils.disableApsdAsync = disableApsdAsync;
     async function collectLogsAsync({ deviceIdentifier, env, }) {
         const outputDir = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'ios-simulator-logs-'));
         const outputPath = node_path_1.default.join(outputDir, `${deviceIdentifier}.logarchive`);

package/dist/utils/expoUpdatesEmbedded.d.ts

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

package/dist/utils/expoUpdatesEmbedded.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadEmbeddedBundleAsync = uploadEmbeddedBundleAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const logger_1 = require("@expo/logger");
+const results_1 = require("@expo/results");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const node_stream_zip_1 = __importDefault(require("node-stream-zip"));
+const artifacts_1 = require("./artifacts");
+const easCli_1 = require("./easCli");
+const resolve_1 = require("../ios/resolve");
+const expoUpdates_1 = require("./expoUpdates");
+async function uploadEmbeddedBundleAsync(ctx) {
+    if (!(await (0, expoUpdates_1.isEASUpdateConfigured)(ctx))) {
+        ctx.markBuildPhaseSkipped();
+        return;
+    }
+    const { platform } = ctx.job;
+    if (platform === eas_build_job_1.Platform.IOS && ctx.job.simulator) {
+        ctx.markBuildPhaseSkipped();
+        return;
+    }
+    const channel = ctx.job.updates?.channel;
+    if (!channel) {
+        ctx.logger.warn('Skipping embedded bundle upload: no channel configured for this build profile.');
+        ctx.markBuildPhaseHasWarnings();
+        return;
+    }
+    const projectDir = ctx.getReactNativeProjectDirectory();
+    let archivePattern;
+    if (platform === eas_build_job_1.Platform.IOS) {
+        archivePattern = (0, resolve_1.resolveArtifactPath)(ctx);
+    }
+    else if (platform === eas_build_job_1.Platform.ANDROID) {
+        archivePattern =
+            ctx.job.applicationArchivePath ??
+                'android/app/build/outputs/**/*.{apk,aab}';
+    }
+    else {
+        throw new Error(`Uploading embedded updates is not supported for the ${platform} platform.`);
+    }
+    const [archivePath] = await (0, artifacts_1.findArtifacts)({
+        rootDir: projectDir,
+        patternOrPath: archivePattern,
+        logger: null,
+    }).catch(() => []);
+    if (!archivePath) {
+        ctx.logger.warn('Skipping embedded bundle upload: build archive not found.');
+        ctx.markBuildPhaseHasWarnings();
+        return;
+    }
+    const tmpDir = await fs_extra_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'eas-embedded-bundle-'));
+    const bundleName = platform === eas_build_job_1.Platform.IOS ? 'main.jsbundle' : 'index.android.bundle';
+    const bundlePath = path_1.default.join(tmpDir, bundleName);
+    const manifestPath = path_1.default.join(tmpDir, 'app.manifest');
+    const zip = new node_stream_zip_1.default.async({ file: archivePath });
+    try {
+        const entries = Object.values(await zip.entries());
+        const bundleEntry = entries.find(e => platform === eas_build_job_1.Platform.IOS
+            ? e.name.endsWith('/main.jsbundle')
+            : e.name.endsWith('assets/index.android.bundle'));
+        const manifestEntry = entries.find(e => platform === eas_build_job_1.Platform.IOS
+            ? e.name.includes('EXUpdates.bundle/app.manifest')
+            : e.name.endsWith('assets/app.manifest'));
+        if (!bundleEntry || !manifestEntry) {
+            ctx.logger.warn('Skipping embedded bundle upload: bundle or manifest not found in archive.');
+            ctx.markBuildPhaseHasWarnings();
+            return;
+        }
+        await zip.extract(bundleEntry.name, bundlePath);
+        await zip.extract(manifestEntry.name, manifestPath);
+        const args = [
+            'update:embedded:upload',
+            '--platform',
+            platform,
+            '--bundle',
+            bundlePath,
+            '--manifest',
+            manifestPath,
+            '--channel',
+            channel,
+            '--non-interactive',
+        ];
+        if (ctx.env.EAS_BUILD_ID) {
+            args.push('--build-id', ctx.env.EAS_BUILD_ID);
+        }
+        await (0, easCli_1.runEasCliCommand)({
+            args,
+            options: {
+                cwd: projectDir,
+                env: ctx.env,
+                logger: ctx.logger,
+                mode: logger_1.PipeMode.STDERR_ONLY_AS_STDOUT,
+            },
+        });
+    }
+    catch (err) {
+        ctx.logger.warn({ err }, 'Failed to upload embedded bundle.');
+        ctx.markBuildPhaseHasWarnings();
+    }
+    finally {
+        await (0, results_1.asyncResult)(zip.close());
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "20.0.0",
+  "version": "20.2.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -38,14 +38,14 @@
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
     "@expo/downloader": "20.0.0",
-    "@expo/eas-build-job": "20.0.0",
+    "@expo/eas-build-job": "20.1.0",
     "@expo/env": "^0.4.0",
     "@expo/logger": "20.0.0",
     "@expo/package-manager": "1.9.10",
     "@expo/plist": "^0.2.0",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "20.0.0",
+    "@expo/steps": "20.1.0",
     "@expo/template-file": "20.0.0",
     "@expo/turtle-spawn": "20.0.0",
     "@expo/xcpretty": "^4.3.1",
@@ -77,7 +77,7 @@
     "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@expo/repack-app": "~0.4.1",
+    "@expo/repack-app": "~0.6.1",
     "@types/fs-extra": "^11.0.4",
     "@types/jest": "^29.5.12",
     "@types/lodash": "^4.17.4",
@@ -100,5 +100,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "890387b3b62c2ed2a946ec0e1197ff69f3e29342"
+  "gitHead": "203e9997eebafcbddc600285f6a809afb4a93a74"
 }

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

@@ -1,15 +0,0 @@
-import { bunyan } from '@expo/logger';
-export declare class XcodeBuildLogger {
-    private readonly logger;
-    private readonly projectRoot;
-    private loggerError?;
-    private flushing;
-    private logReaderPromise?;
-    private logsPath?;
-    constructor(logger: bunyan, projectRoot: string);
-    watchLogFiles(logsDirectory: string): Promise<void>;
-    flush(): Promise<void>;
-    private getBuildLogFilename;
-    private startBuildLogger;
-    private findBundlerErrors;
-}