@expo/build-tools 22.0.0 → 22.3.0

package/dist/steps/functions/saveBuildCache.js

@@ -29,6 +29,11 @@ function createSaveBuildCacheFunction(evictUsedBefore) {
                 required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'simulator',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+            }),
         ],
         fn: async (stepCtx, { env, inputs }) => {
             const { logger } = stepCtx;
@@ -38,10 +43,18 @@ function createSaveBuildCacheFunction(evictUsedBefore) {
             if (!platform || ![eas_build_job_1.Platform.ANDROID, eas_build_job_1.Platform.IOS].includes(platform)) {
                 throw new Error(`Unsupported platform: ${platform}. Platform must be "${eas_build_job_1.Platform.ANDROID}" or "${eas_build_job_1.Platform.IOS}"`);
             }
+            const target = platform === eas_build_job_1.Platform.IOS
+                ? {
+                    platform,
+                    simulator: inputs.simulator.value ??
+                        (stepCtx.global.staticContext.job.platform === eas_build_job_1.Platform.IOS &&
+                            stepCtx.global.staticContext.job.simulator === true),
+                }
+                : { platform };
             await saveCcacheAsync({
                 logger,
                 workingDirectory,
-                platform,
+                target,
                 evictUsedBefore,
                 env,
                 secrets: stepCtx.global.staticContext.job.secrets,
@@ -57,7 +70,7 @@ function createSaveBuildCacheFunction(evictUsedBefore) {
         },
     });
 }
-async function saveCcacheAsync({ logger, workingDirectory, platform, evictUsedBefore, env, secrets, }) {
+async function saveCcacheAsync({ logger, workingDirectory, target, evictUsedBefore, env, secrets, }) {
     const enabled = env.EAS_SAVE_CACHE === '1' || (env.EAS_USE_CACHE === '1' && env.EAS_SAVE_CACHE !== '0');
     if (!enabled) {
         return;
@@ -72,7 +85,7 @@ async function saveCcacheAsync({ logger, workingDirectory, platform, evictUsedBe
         return;
     }
     try {
-        const cacheKey = await (0, cacheKey_1.generateDefaultBuildCacheKeyAsync)(workingDirectory, platform);
+        const cacheKey = await (0, cacheKey_1.generateDefaultBuildCacheKeyAsync)(workingDirectory, target);
         logger.info(`Saving cache key: ${cacheKey}`);
         const jobId = (0, nullthrows_1.default)(env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set');
         const robotAccessToken = (0, nullthrows_1.default)(secrets?.robotAccessToken, 'Robot access token is required for cache operations');
@@ -104,7 +117,7 @@ async function saveCcacheAsync({ logger, workingDirectory, platform, evictUsedBe
             key: cacheKey,
             paths: [cachePath],
             size,
-            platform,
+            platform: target.platform,
         });
     }
     catch (err) {
@@ -117,6 +130,7 @@ async function saveGradleCacheAsync({ logger, workingDirectory, env, secrets, })
     }
     const gradleCachesPath = path_1.default.join(os_1.default.homedir(), '.gradle', 'caches');
     const buildCachePath = path_1.default.join(gradleCachesPath, 'build-cache-1');
+    const journalPath = path_1.default.join(gradleCachesPath, 'journal-1');
     try {
         await fs_1.default.promises.access(buildCachePath);
     }
@@ -130,9 +144,10 @@ async function saveGradleCacheAsync({ logger, workingDirectory, env, secrets, })
         const jobId = (0, nullthrows_1.default)(env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set');
         const robotAccessToken = (0, nullthrows_1.default)(secrets?.robotAccessToken, 'Robot access token is required for cache operations');
         const expoApiServerURL = (0, nullthrows_1.default)(env.__API_SERVER_URL, '__API_SERVER_URL is not set');
+        await fs_1.default.promises.mkdir(journalPath, { recursive: true });
         logger.info('Compressing Gradle build cache...');
         const { archivePath } = await (0, saveCache_1.compressCacheAsync)({
-            paths: [buildCachePath],
+            paths: [buildCachePath, journalPath],
             workingDirectory: gradleCachesPath,
             verbose: env.EXPO_DEBUG === '1',
             logger,
@@ -146,7 +161,7 @@ async function saveGradleCacheAsync({ logger, workingDirectory, env, secrets, })
             robotAccessToken,
             archivePath,
             key: cacheKey,
-            paths: [buildCachePath],
+            paths: [buildCachePath, journalPath],
             size,
             platform: eas_build_job_1.Platform.ANDROID,
         });

package/dist/steps/functions/saveCache.js

@@ -303,7 +303,10 @@ async function compressCacheAsync({ paths, workingDirectory, verbose, logger, })
         for (const { absolutePath, archivePath: targetRelativePath } of allFiles) {
             const targetPath = path_1.default.join(tempDir, targetRelativePath);
             await fs_1.default.promises.mkdir(path_1.default.dirname(targetPath), { recursive: true });
+            // We want to keep source timestamps since Gradle may check them when pruning cache.
+            const { atime, mtime } = await fs_1.default.promises.stat(absolutePath);
             await fs_1.default.promises.copyFile(absolutePath, targetPath);
+            await fs_1.default.promises.utimes(targetPath, atime, mtime);
             if (verbose) {
                 logger.info(`- ${targetRelativePath}`);
             }

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -42,6 +42,11 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'max_duration_seconds',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+            }),
         ],
         fn: async ({ logger, global }, { inputs, env, signal }) => {
             // Fail fast before any expensive setup if the injected env
@@ -54,6 +59,7 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
             const packageVersion = inputs.package_version.value;
             // A missing or non-positive value disables the idle timeout (opt-in feature).
             const maxIdleTimeMinutes = inputs.max_idle_time_minutes.value;
+            const maxDurationSeconds = inputs.max_duration_seconds?.value;
             const { runtimePlatform } = global;
             logger.info(`Starting agent-device remote session (version: ${packageVersion ?? 'latest'}, runtime: ${runtimePlatform}).`);
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
@@ -115,6 +121,7 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                     ctx,
                     deviceRunSessionId,
                     logger,
+                    maxDurationSeconds,
                     signal,
                     idleTimeout: maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
                         ? {

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

@@ -0,0 +1,17 @@
+import { type bunyan } from '@expo/logger';
+import { BuildFunction, BuildRuntimePlatform, type BuildStepEnv } from '@expo/steps';
+import { type CustomBuildContext } from '../../customBuildContext';
+export declare function createStartAppiumRemoteSessionBuildFunction(ctx: CustomBuildContext): BuildFunction;
+export declare function resolveAppium3VersionSpec(packageVersion: string | undefined): string;
+type AppiumDevice = {
+    platformName: 'iOS' | 'Android';
+    automationName: 'XCUITest' | 'UiAutomator2';
+    driverName: 'xcuitest' | 'uiautomator2';
+    udid: string;
+};
+export declare function resolveAppiumDeviceAsync({ runtimePlatform, env, logger, }: {
+    runtimePlatform: BuildRuntimePlatform;
+    env: BuildStepEnv;
+    logger: bunyan;
+}): Promise<AppiumDevice>;
+export {};

package/dist/steps/functions/startAppiumRemoteSession.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStartAppiumRemoteSessionBuildFunction = createStartAppiumRemoteSessionBuildFunction;
+exports.resolveAppium3VersionSpec = resolveAppium3VersionSpec;
+exports.resolveAppiumDeviceAsync = resolveAppiumDeviceAsync;
+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 semver_1 = __importDefault(require("semver"));
+const zod_1 = require("zod");
+const AndroidEmulatorUtils_1 = require("../../utils/AndroidEmulatorUtils");
+const IosSimulatorUtils_1 = require("../../utils/IosSimulatorUtils");
+const retry_1 = require("../../utils/retry");
+const turtleFetch_1 = require("../../utils/turtleFetch");
+const appiumEvents_1 = require("../utils/appiumEvents");
+const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
+const APPIUM_HOST = '127.0.0.1';
+const APPIUM_PORT = 4723;
+const APPIUM_STARTUP_TIMEOUT_MS = 120_000;
+const DEFAULT_APPIUM_VERSION = '^3';
+const AppiumInstalledDriversSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.object({ installed: zod_1.z.boolean().optional() }).passthrough());
+function createStartAppiumRemoteSessionBuildFunction(ctx) {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'start_appium_remote_session',
+        name: 'Start Appium remote session',
+        __metricsId: 'eas/start_appium_remote_session',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'package_version',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'max_idle_time_minutes',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+            }),
+        ],
+        fn: async ({ logger, global }, { inputs, env, signal }) => {
+            const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
+            const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
+            const ngrokAuthtoken = (0, remoteDeviceRunSession_1.getNgrokAuthtokenOrThrow)(env);
+            const packageVersion = inputs.package_version.value;
+            const maxIdleTimeMinutes = inputs.max_idle_time_minutes.value;
+            const { runtimePlatform } = global;
+            const versionSpec = resolveAppium3VersionSpec(packageVersion);
+            logger.info(`Starting Appium remote session (version: ${versionSpec}, runtime: ${runtimePlatform}).`);
+            const device = await resolveAppiumDeviceAsync({ runtimePlatform, env, logger });
+            const { appiumHome, appiumBinPath, appiumEnv } = await installAppiumAsync({
+                versionSpec,
+                driverName: device.driverName,
+                env,
+                logger,
+            });
+            const appiumProcess = (0, remoteDeviceRunSession_1.spawnDetached)({
+                command: appiumBinPath,
+                args: [
+                    '--address',
+                    APPIUM_HOST,
+                    '--port',
+                    String(APPIUM_PORT),
+                    '--base-path',
+                    '/',
+                    '--log-level',
+                    'error',
+                    // Appium 3 gates session listing (GET /appium/sessions) behind the
+                    // session_discovery insecure feature. We rely on it to poll for
+                    // Appium Event Timings, so enable it for all drivers.
+                    '--allow-insecure',
+                    '*:session_discovery',
+                    '--default-capabilities',
+                    JSON.stringify({ 'appium:eventTimings': true }),
+                ],
+                env: appiumEnv,
+            });
+            try {
+                await waitForAppiumReadyAsync({ appiumProcess, logger });
+            }
+            catch (error) {
+                await appiumProcess.stopAsync();
+                await node_fs_1.default.promises.rm(appiumHome, { recursive: true, force: true });
+                throw error;
+            }
+            const eventCollection = await (0, appiumEvents_1.startAppiumEventCollectionAsync)({
+                ctx,
+                deviceRunSessionId,
+                appiumUrl: `http://${APPIUM_HOST}:${APPIUM_PORT}/`,
+                logger,
+            });
+            let appiumTunnel;
+            let serveSim;
+            try {
+                appiumTunnel = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
+                    port: APPIUM_PORT,
+                    subdomainPrefix: 'appium',
+                    baseDomain: ngrokTunnelDomain,
+                    authtoken: ngrokAuthtoken,
+                    logger,
+                });
+                switch (runtimePlatform) {
+                    case steps_1.BuildRuntimePlatform.DARWIN:
+                        serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
+                            baseDomain: ngrokTunnelDomain,
+                            env,
+                            logger,
+                            timeoutMs: APPIUM_STARTUP_TIMEOUT_MS,
+                        });
+                        break;
+                    case steps_1.BuildRuntimePlatform.LINUX:
+                        break;
+                }
+                await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    remoteConfig: {
+                        appiumUrl: appiumTunnel.url,
+                        capabilities: {
+                            platformName: device.platformName,
+                            'appium:automationName': device.automationName,
+                            'appium:udid': device.udid,
+                        },
+                        ...(serveSim ? { webPreviewUrl: serveSim.previewUrl } : {}),
+                    },
+                    logger,
+                });
+                await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    logger,
+                    signal,
+                    idleTimeout: maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
+                        ? {
+                            maxIdleTimeMinutes,
+                            getLastEventObservedAt: eventCollection.getLastEventObservedAt,
+                        }
+                        : undefined,
+                });
+            }
+            finally {
+                if (serveSim) {
+                    await serveSim.stopAsync();
+                }
+                if (appiumTunnel) {
+                    await appiumTunnel.stopAsync();
+                }
+                await eventCollection.stopAsync();
+                await appiumProcess.stopAsync();
+                await node_fs_1.default.promises.rm(appiumHome, { recursive: true, force: true });
+            }
+        },
+    });
+}
+function resolveAppium3VersionSpec(packageVersion) {
+    const versionSpec = packageVersion ?? DEFAULT_APPIUM_VERSION;
+    const range = semver_1.default.validRange(versionSpec);
+    if (!range || !semver_1.default.subset(range, '>=3.0.0 <4.0.0-0')) {
+        throw new eas_build_job_1.SystemError(`Appium 3 is required for EAS Simulator sessions. Received package version "${versionSpec}".`);
+    }
+    return versionSpec;
+}
+async function resolveAppiumDeviceAsync({ runtimePlatform, env, logger, }) {
+    switch (runtimePlatform) {
+        case steps_1.BuildRuntimePlatform.DARWIN: {
+            await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
+            const [bootedDevice] = await IosSimulatorUtils_1.IosSimulatorUtils.getAvailableDevicesAsync({
+                env,
+                filter: 'booted',
+            });
+            if (!bootedDevice) {
+                throw new eas_build_job_1.SystemError('Could not find a booted iOS simulator for the Appium session.');
+            }
+            return {
+                platformName: 'iOS',
+                automationName: 'XCUITest',
+                driverName: 'xcuitest',
+                udid: bootedDevice.udid,
+            };
+        }
+        case steps_1.BuildRuntimePlatform.LINUX: {
+            const attachedDevices = await AndroidEmulatorUtils_1.AndroidEmulatorUtils.getAttachedDevicesAsync({ env });
+            const bootedDevice = attachedDevices.find(device => device.state === 'device');
+            if (!bootedDevice) {
+                throw new eas_build_job_1.SystemError('Could not find a booted Android emulator for the Appium session.');
+            }
+            return {
+                platformName: 'Android',
+                automationName: 'UiAutomator2',
+                driverName: 'uiautomator2',
+                udid: bootedDevice.serialId,
+            };
+        }
+    }
+}
+async function installAppiumAsync({ versionSpec, driverName, env, logger, }) {
+    const appiumHome = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'eas-appium-home-'));
+    await node_fs_1.default.promises.writeFile(node_path_1.default.join(appiumHome, 'package.json'), `${JSON.stringify({ name: 'eas-appium-home', private: true })}\n`);
+    const appiumEnv = { ...env, APPIUM_HOME: appiumHome };
+    const appiumBinPath = node_path_1.default.join(appiumHome, 'node_modules', '.bin', 'appium');
+    logger.info(`Installing appium@${versionSpec}.`);
+    await (0, turtle_spawn_1.default)('npm', ['install', '--prefix', appiumHome, `appium@${versionSpec}`], {
+        env: appiumEnv,
+        logger,
+    });
+    const { stdout } = await (0, turtle_spawn_1.default)(appiumBinPath, ['driver', 'list', '--installed', '--json'], {
+        env: appiumEnv,
+        stdio: 'pipe',
+    });
+    const installedDrivers = AppiumInstalledDriversSchema.parse(JSON.parse(stdout));
+    if (installedDrivers[driverName]?.installed) {
+        logger.info(`Updating the installed Appium ${driverName} driver.`);
+        await (0, turtle_spawn_1.default)(appiumBinPath, ['driver', 'update', driverName], { env: appiumEnv, logger });
+    }
+    else {
+        logger.info(`Installing the Appium ${driverName} driver.`);
+        await (0, turtle_spawn_1.default)(appiumBinPath, ['driver', 'install', driverName], { env: appiumEnv, logger });
+    }
+    return { appiumHome, appiumBinPath, appiumEnv };
+}
+async function waitForAppiumReadyAsync({ appiumProcess, logger, }) {
+    const deadline = Date.now() + APPIUM_STARTUP_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        try {
+            const response = await (0, turtleFetch_1.turtleFetch)(`http://${APPIUM_HOST}:${APPIUM_PORT}/status`, 'GET', {
+                timeout: 2_000,
+                retries: 0,
+                logger,
+            });
+            if (response.ok) {
+                return;
+            }
+        }
+        catch { }
+        await (0, retry_1.sleepAsync)(1_000);
+    }
+    const output = appiumProcess.getOutput();
+    throw new eas_build_job_1.SystemError(`Timed out waiting for Appium to become ready.${output ? `\nAppium output:\n${output}` : ''}`);
+}

package/dist/steps/functions/startArgentRemoteSession.js

@@ -57,6 +57,11 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 required: false,
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'max_duration_seconds',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+            }),
         ],
         fn: async ({ logger, global }, { inputs, env, signal }) => {
             // Fail fast before any expensive setup if the injected env
@@ -69,6 +74,7 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
             const packageVersion = inputs.package_version.value;
             // A missing or non-positive value disables the idle timeout (opt-in feature).
             const maxIdleTimeMinutes = inputs.max_idle_time_minutes.value;
+            const maxDurationSeconds = inputs.max_duration_seconds?.value;
             warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger });
             const versionSpec = packageVersion ?? 'latest';
             const { runtimePlatform } = global;
@@ -178,6 +184,7 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                     ctx,
                     deviceRunSessionId,
                     logger,
+                    maxDurationSeconds,
                     signal,
                     idleTimeout: maxIdleTimeMinutes !== undefined && maxIdleTimeMinutes > 0
                         ? {

package/dist/steps/functions/startServeSimRemoteSession.js

@@ -11,9 +11,23 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
         name: 'Start serve-sim remote session',
         __metricsId: 'eas/start_serve_sim_remote_session',
         supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
-        fn: async ({ logger }, { env, signal }) => {
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'package_version',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'max_duration_seconds',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+            }),
+        ],
+        fn: async ({ logger }, { inputs, env, signal }) => {
             const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
             const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
+            const maxDurationSeconds = inputs.max_duration_seconds?.value;
+            const packageVersion = inputs.package_version?.value;
             logger.info('Starting serve-sim remote session.');
             await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
             const serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
@@ -21,6 +35,7 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
                 env,
                 logger,
                 timeoutMs: STARTUP_TIMEOUT_MS,
+                packageVersion,
             });
             logger.info(`Preview URL: ${serveSim.previewUrl}`);
             try {
@@ -34,6 +49,7 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
                     ctx,
                     deviceRunSessionId,
                     logger,
+                    maxDurationSeconds,
                     signal,
                 });
             }

package/dist/steps/functions/uploadToAsc.js

@@ -141,15 +141,25 @@ function createUploadToAscBuildFunction() {
             const appResponse = await AscApiUtils_1.AscApiUtils.getAppInfoAsync({ client, appleAppIdentifier });
             const ascAppBundleIdentifier = appResponse.data.attributes.bundleId;
             stepsCtx.logger.info(`Uploading Build to "${appResponse.data.attributes.name}" (${ascAppBundleIdentifier})...`);
+            // Derive the App Store Connect platform from the IPA itself so tvOS (and
+            // other) binaries are uploaded to the correct version train instead of the
+            // iOS one. Falls back to `IOS` if the platform cannot be read.
+            const ipaInfoResult = await (0, results_1.asyncResult)((0, readIpaInfo_1.readIpaInfoAsync)(ipaPath));
+            const platform = ipaInfoResult.ok
+                ? AscApiUtils_1.AscApiUtils.ascPlatformFromDtPlatformName(ipaInfoResult.value.dtPlatformName)
+                : 'IOS';
+            stepsCtx.logger.info(`Detected App Store Connect platform: ${platform}`);
             stepsCtx.logger.info('Creating Build Upload...');
             const buildUploadResponse = await AscApiUtils_1.AscApiUtils.createBuildUploadAsync({
                 client,
                 appleAppIdentifier,
                 bundleShortVersion,
                 bundleVersion,
+                platform,
             });
             const buildUploadId = buildUploadResponse.data.id;
-            const buildUploadUrl = `https://appstoreconnect.apple.com/apps/${appleAppIdentifier}/testflight/ios/${buildUploadId}`;
+            const platformPathSegment = AscApiUtils_1.AscApiUtils.testFlightPlatformPathSegment(platform);
+            const buildUploadUrl = `https://appstoreconnect.apple.com/apps/${appleAppIdentifier}/testflight/${platformPathSegment}/${buildUploadId}`;
             outputs.build_upload_id.set(buildUploadId);
             outputs.build_upload_url.set(buildUploadUrl);
             stepsCtx.logger.info(`Build Upload initialized (ID: ${buildUploadId}). Preparing IPA upload...`);

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

@@ -0,0 +1,10 @@
+import { type bunyan } from '@expo/logger';
+import { type CustomBuildContext } from '../../customBuildContext';
+import { type DeviceRunSessionEventCollection } from './deviceRunSessionEvents';
+export declare function startAppiumEventCollectionAsync({ ctx, deviceRunSessionId, appiumUrl, logger, pollIntervalMs, }: {
+    ctx: CustomBuildContext;
+    deviceRunSessionId: string;
+    appiumUrl: string;
+    logger: bunyan;
+    pollIntervalMs?: number;
+}): Promise<DeviceRunSessionEventCollection>;

package/dist/steps/utils/appiumEvents.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startAppiumEventCollectionAsync = startAppiumEventCollectionAsync;
+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 promises_1 = require("node:timers/promises");
+const zod_1 = require("zod");
+const turtleFetch_1 = require("../../utils/turtleFetch");
+const deviceRunSessionEvents_1 = require("./deviceRunSessionEvents");
+const APPIUM_REQUEST_TIMEOUT_MS = 10_000;
+const POLL_INTERVAL_MS = 1_000;
+const GET_LOG_EVENTS_COMMAND = 'getLogEvents';
+const AppiumSessionsResponseSchema = zod_1.z.object({
+    value: zod_1.z.array(zod_1.z.object({ id: zod_1.z.string() }).passthrough()),
+});
+const AppiumCommandSchema = zod_1.z.object({
+    appiumSessionId: zod_1.z.string(),
+    cmd: zod_1.z.string(),
+    startTime: zod_1.z.number(),
+    endTime: zod_1.z.number(),
+});
+const AppiumEventsResponseSchema = zod_1.z.object({
+    value: zod_1.z.object({
+        commands: zod_1.z.array(AppiumCommandSchema.omit({ appiumSessionId: true })),
+    }),
+});
+async function startAppiumEventCollectionAsync({ ctx, deviceRunSessionId, appiumUrl, logger, pollIntervalMs = POLL_INTERVAL_MS, }) {
+    const eventDirectory = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'eas-appium-events-'));
+    const eventFile = node_path_1.default.join(eventDirectory, 'commands.ndjson');
+    await node_fs_1.default.promises.writeFile(eventFile, '');
+    let eventCollection;
+    try {
+        eventCollection = await (0, deviceRunSessionEvents_1.startDeviceRunSessionEventCollectionAsync)({
+            ctx,
+            deviceRunSessionId,
+            logger,
+            pollIntervalMs,
+            source: createAppiumEventSource(eventFile),
+        });
+    }
+    catch (error) {
+        await node_fs_1.default.promises.rm(eventDirectory, { recursive: true, force: true });
+        throw error;
+    }
+    const observedCommandKeys = new Set();
+    const controller = new AbortController();
+    let didReportCollectionFailure = false;
+    const collectSafelyAsync = async () => {
+        try {
+            await collectAppiumCommandsAsync({
+                appiumUrl,
+                eventFile,
+                observedCommandKeys,
+                logger,
+            });
+            didReportCollectionFailure = false;
+        }
+        catch (error) {
+            if (!didReportCollectionFailure) {
+                didReportCollectionFailure = true;
+                logger.warn({ err: error }, 'Could not collect Appium events.');
+            }
+        }
+    };
+    const pollingPromise = (async () => {
+        while (!controller.signal.aborted) {
+            await collectSafelyAsync();
+            try {
+                await (0, promises_1.setTimeout)(pollIntervalMs, undefined, { signal: controller.signal });
+            }
+            catch (error) {
+                if (!controller.signal.aborted) {
+                    throw error;
+                }
+            }
+        }
+    })().catch(error => {
+        logger.warn({ err: error }, 'Appium event collection poller failed.');
+    });
+    return {
+        getLastEventObservedAt: eventCollection.getLastEventObservedAt,
+        stopAsync: async () => {
+            controller.abort();
+            await pollingPromise;
+            await collectSafelyAsync();
+            try {
+                await eventCollection.stopAsync();
+            }
+            finally {
+                await node_fs_1.default.promises.rm(eventDirectory, { recursive: true, force: true });
+            }
+        },
+    };
+}
+function createAppiumEventSource(eventFile) {
+    return {
+        producer: 'appium',
+        findEventFilesAsync: async () => [eventFile],
+        sourceKeyForFile: file => node_path_1.default.basename(file, node_path_1.default.extname(file)),
+        parseLine: ({ line, sourceKey, sequenceNumber, deviceRunSessionId }) => {
+            if (!line.trim()) {
+                return {};
+            }
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                return { failure: 'invalid-json' };
+            }
+            const result = AppiumCommandSchema.safeParse(parsed);
+            if (!result.success) {
+                return { failure: 'invalid-event' };
+            }
+            const command = result.data;
+            const operationId = `${sourceKey}:${sequenceNumber}`;
+            return {
+                event: {
+                    v: 1,
+                    eventId: `appium:${deviceRunSessionId}:${operationId}`,
+                    ts: new Date(command.endTime).toISOString(),
+                    producer: 'appium',
+                    type: 'operation.completed',
+                    operationId,
+                    durationMs: Math.max(0, command.endTime - command.startTime),
+                    summary: command.cmd,
+                    data: {
+                        command: command.cmd,
+                        appiumSessionId: command.appiumSessionId,
+                    },
+                },
+            };
+        },
+    };
+}
+async function collectAppiumCommandsAsync({ appiumUrl, eventFile, observedCommandKeys, logger, }) {
+    const response = await (0, turtleFetch_1.turtleFetch)(new URL('appium/sessions', appiumUrl).toString(), 'GET', {
+        timeout: APPIUM_REQUEST_TIMEOUT_MS,
+        retries: 0,
+        logger,
+    });
+    const sessions = AppiumSessionsResponseSchema.parse(await response.json()).value;
+    const newCommands = [];
+    const pendingCommandKeys = new Set();
+    for (const { id: appiumSessionId } of sessions) {
+        const eventsResponse = await (0, turtleFetch_1.turtleFetch)(new URL(`session/${encodeURIComponent(appiumSessionId)}/appium/events`, appiumUrl).toString(), 'POST', {
+            json: {},
+            timeout: APPIUM_REQUEST_TIMEOUT_MS,
+            retries: 0,
+            logger,
+        });
+        const commands = AppiumEventsResponseSchema.parse(await eventsResponse.json()).value.commands;
+        for (const command of commands) {
+            const key = [appiumSessionId, command.cmd, command.startTime, command.endTime].join(':');
+            if (command.cmd === GET_LOG_EVENTS_COMMAND ||
+                observedCommandKeys.has(key) ||
+                pendingCommandKeys.has(key)) {
+                continue;
+            }
+            pendingCommandKeys.add(key);
+            newCommands.push({ key, command: { appiumSessionId, ...command } });
+        }
+    }
+    if (newCommands.length === 0) {
+        return;
+    }
+    await node_fs_1.default.promises.appendFile(eventFile, `${newCommands.map(({ command }) => JSON.stringify(command)).join('\n')}\n`);
+    for (const { key } of newCommands) {
+        observedCommandKeys.add(key);
+    }
+}