@expo/build-tools 22.2.0 → 22.4.0

package/dist/steps/functions/launchApplication.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLaunchApplicationFunction = createLaunchApplicationFunction;
+exports.launchApplicationAsync = launchApplicationAsync;
+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"));
+function createLaunchApplicationFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'launch_application',
+        name: 'Launch application',
+        __metricsId: 'eas/launch_application',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'application_identifier',
+                required: true,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'activity_name',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'launch_args',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.JSON,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'open_url',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+            }),
+        ],
+        fn: async ({ global, logger }, { inputs, env }) => {
+            const applicationIdentifier = parseNonEmptyStringInput(inputs.application_identifier.value, 'application_identifier');
+            const activityName = inputs.activity_name.value === undefined
+                ? undefined
+                : parseNonEmptyStringInput(inputs.activity_name.value, 'activity_name');
+            const launchArgs = parseLaunchArgsInput(inputs.launch_args.value);
+            const openUrl = inputs.open_url.value === undefined ? undefined : parseOpenUrlInput(inputs.open_url.value);
+            await launchApplicationAsync({
+                applicationIdentifier,
+                activityName,
+                launchArgs,
+                openUrl,
+                runtimePlatform: global.runtimePlatform,
+                env,
+                logger,
+            });
+        },
+    });
+}
+async function launchApplicationAsync({ applicationIdentifier, activityName, launchArgs = [], openUrl, runtimePlatform, env, logger, }) {
+    if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
+        logApplicationLaunch(logger, applicationIdentifier, launchArgs);
+        await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'launch', 'booted', applicationIdentifier, ...launchArgs], {
+            env,
+            logger,
+        });
+        if (openUrl) {
+            logger.info(`Opening ${openUrl} in ${applicationIdentifier}.`);
+            await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'openurl', 'booted', openUrl], { env, logger });
+        }
+        return;
+    }
+    if (!activityName) {
+        throw new eas_build_job_1.UserError('EAS_LAUNCH_APPLICATION_MISSING_ACTIVITY', 'Launching an Android application requires activity_name.');
+    }
+    logApplicationLaunch(logger, applicationIdentifier, launchArgs);
+    // Android does not support process arguments like iOS. Pass raw `am start` Intent
+    // arguments instead, such as `--es key value` or `--ez key true`.
+    await (0, turtle_spawn_1.default)('adb', ['shell', 'am', 'start', ...launchArgs, '-n', `${applicationIdentifier}/${activityName}`], {
+        env,
+        logger,
+    });
+    if (openUrl) {
+        logger.info(`Opening ${openUrl} in ${applicationIdentifier}.`);
+        await (0, turtle_spawn_1.default)('adb', [
+            'shell',
+            'am',
+            'start',
+            '-a',
+            'android.intent.action.VIEW',
+            '-d',
+            openUrl,
+            '-n',
+            `${applicationIdentifier}/${activityName}`,
+        ], { env, logger });
+    }
+}
+function logApplicationLaunch(logger, applicationIdentifier, launchArgs) {
+    const argumentsDescription = launchArgs.length > 0 ? ` with arguments ${JSON.stringify(launchArgs)}` : '';
+    logger.info(`Launching ${applicationIdentifier}${argumentsDescription}.`);
+}
+function parseNonEmptyStringInput(value, inputName) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new eas_build_job_1.UserError('EAS_LAUNCH_APPLICATION_INVALID_INPUT', `Input "${inputName}" must be a non-empty string. Pass the "${inputName}" output from eas/install_build.`);
+    }
+    return value;
+}
+function parseLaunchArgsInput(value) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value) || !value.every(argument => typeof argument === 'string')) {
+        throw new eas_build_job_1.UserError('EAS_LAUNCH_APPLICATION_INVALID_INPUT', 'Input "launch_args" must be an array of strings.');
+    }
+    return value;
+}
+function parseOpenUrlInput(value) {
+    const openUrl = parseNonEmptyStringInput(value, 'open_url');
+    if (!URL.canParse(openUrl)) {
+        throw new eas_build_job_1.UserError('EAS_LAUNCH_APPLICATION_INVALID_INPUT', 'Input "open_url" must be a valid URL.');
+    }
+    return openUrl;
+}

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

@@ -3,6 +3,7 @@ export type IpaInfo = {
     bundleIdentifier: string;
     bundleShortVersion: string;
     bundleVersion: string;
+    dtPlatformName: string | null;
 };
 export declare function createReadIpaInfoBuildFunction(): BuildFunction;
 export declare function readIpaInfoAsync(ipaPath: string): Promise<IpaInfo>;

package/dist/steps/functions/readIpaInfo.js

@@ -70,10 +70,12 @@ async function readIpaInfoAsync(ipaPath) {
         if (typeof bundleVersion !== 'string') {
             throw new eas_build_job_1.UserError('EAS_READ_IPA_INFO_INVALID_INFO_PLIST', 'Failed to read IPA info: Missing or invalid CFBundleVersion in Info.plist');
         }
+        const dtPlatformName = typeof infoPlist.DTPlatformName === 'string' ? infoPlist.DTPlatformName : null;
         return {
             bundleIdentifier,
             bundleShortVersion,
             bundleVersion,
+            dtPlatformName,
         };
     }
     catch (error) {

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

@@ -11,11 +11,14 @@ export declare function resolveAndroidSigningOptionsAsync({ job, tmpDir, }: {
     tmpDir: string;
 }): Promise<AndroidSigningOptions | undefined>;
 /**
- * Resolves iOS signing options from the job secrets.
+ * Resolves iOS signing options from the job secrets, dispatching on the
+ * requested signing backend.
  */
-export declare function resolveIosSigningOptionsAsync({ job, logger, useAppEntitlements, entitlementsPath, }: {
+export declare function resolveIosSigningOptionsAsync({ job, logger, backend, useAppEntitlements, entitlementsPath, tmpDir, }: {
     job: Job;
     logger: bunyan;
+    backend?: 'fastlane' | 'zsign';
     useAppEntitlements?: boolean;
     entitlementsPath?: string;
+    tmpDir: string;
 }): Promise<IosSigningOptions | undefined>;

package/dist/steps/functions/repack.js

@@ -53,6 +53,12 @@ function createRepackBuildFunction() {
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
                 required: false,
             }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'ios_signing_backend',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+                allowedValues: ['fastlane', 'zsign'],
+            }),
             steps_1.BuildStepInput.createProvider({
                 id: 'repack_version',
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
@@ -123,8 +129,10 @@ function createRepackBuildFunction() {
                         iosSigningOptions: await resolveIosSigningOptionsAsync({
                             job: stepsCtx.global.staticContext.job,
                             logger: stepsCtx.logger,
+                            backend: inputs.ios_signing_backend.value,
                             useAppEntitlements: inputs.ios_signing_use_source_app_entitlements.value,
                             entitlementsPath: inputs.ios_signing_app_entitlements_path.value,
+                            tmpDir,
                         }),
                         logger: stepsCtx.logger,
                         spawnAsync: repackSpawnAsync,
@@ -234,14 +242,26 @@ async function resolveAndroidSigningOptionsAsync({ job, tmpDir, }) {
     };
 }
 /**
- * Resolves iOS signing options from the job secrets.
+ * Resolves iOS signing options from the job secrets, dispatching on the
+ * requested signing backend.
  */
-async function resolveIosSigningOptionsAsync({ job, logger, useAppEntitlements, entitlementsPath, }) {
+async function resolveIosSigningOptionsAsync({ job, logger, backend, useAppEntitlements, entitlementsPath, tmpDir, }) {
     const iosJob = job;
     const buildCredentials = iosJob.secrets?.buildCredentials;
     if (iosJob.simulator || buildCredentials == null) {
         return undefined;
     }
+    const commonOptions = { buildCredentials, logger, useAppEntitlements, entitlementsPath };
+    return backend === 'zsign'
+        ? await createIosZsignOptionsAsync({ ...commonOptions, tmpDir })
+        : await createIosFastlaneOptionsAsync(commonOptions);
+}
+/**
+ * Creates signing options for the fastlane backend: certificates are imported
+ * into a temporary keychain and provisioning profiles are parsed with the
+ * macOS `security` tool.
+ */
+async function createIosFastlaneOptionsAsync({ buildCredentials, logger, useAppEntitlements, entitlementsPath, }) {
     const credentialsManager = new manager_1.default(buildCredentials);
     const credentials = await credentialsManager.prepare(logger);
     const provisioningProfile = {};
@@ -256,3 +276,31 @@ async function resolveIosSigningOptionsAsync({ job, logger, useAppEntitlements,
         entitlementsPath,
     };
 }
+/**
+ * Creates signing options for the zsign backend. The distribution certificate
+ * secret is already a PKCS#12 file, so it goes to disk as-is together with the
+ * provisioning profiles.
+ */
+async function createIosZsignOptionsAsync({ buildCredentials, logger, useAppEntitlements, entitlementsPath, tmpDir, }) {
+    const targets = Object.entries(buildCredentials);
+    const [targetName, targetCredentials] = targets[0];
+    logger.info(`Using the distribution certificate from target '${targetName}' for zsign`);
+    const certificatePath = node_path_1.default.join(tmpDir, `dist-cert-${(0, node_crypto_1.randomUUID)()}.p12`);
+    await node_fs_1.default.promises.writeFile(certificatePath, new Uint8Array(Buffer.from(targetCredentials.distributionCertificate.dataBase64, 'base64')));
+    // zsign matches profiles to bundles by the app-id suffix itself, so the
+    // record keys are informational only.
+    const provisioningProfile = {};
+    for (const [target, credentials] of targets) {
+        const profilePath = node_path_1.default.join(tmpDir, `profile-${target}-${(0, node_crypto_1.randomUUID)()}.mobileprovision`);
+        await node_fs_1.default.promises.writeFile(profilePath, new Uint8Array(Buffer.from(credentials.provisioningProfileBase64, 'base64')));
+        provisioningProfile[target] = profilePath;
+    }
+    return {
+        backend: 'zsign',
+        certificatePath,
+        keyPassword: targetCredentials.distributionCertificate.password,
+        provisioningProfile,
+        useAppEntitlements,
+        entitlementsPath,
+    };
+}

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

@@ -1,12 +1,12 @@
-import { Platform } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
+import { CcacheBuildTarget } from '../../utils/cacheKey';
 export declare function createRestoreBuildCacheFunction(): BuildFunction;
 export declare function createCacheStatsBuildFunction(): BuildFunction;
-export declare function restoreCcacheAsync({ logger, workingDirectory, platform, env, secrets, }: {
+export declare function restoreCcacheAsync({ logger, workingDirectory, target, env, secrets, }: {
     logger: bunyan;
     workingDirectory: string;
-    platform: Platform;
+    target: CcacheBuildTarget;
     env: Record<string, string | undefined>;
     secrets?: {
         robotAccessToken?: string;

package/dist/steps/functions/restoreBuildCache.js

@@ -33,6 +33,11 @@ function createRestoreBuildCacheFunction() {
                 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;
@@ -42,10 +47,18 @@ function createRestoreBuildCacheFunction() {
             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 restoreCcacheAsync({
                 logger,
                 workingDirectory,
-                platform,
+                target,
                 env,
                 secrets: stepCtx.global.staticContext.job.secrets,
             });
@@ -80,7 +93,7 @@ function createCacheStatsBuildFunction() {
         },
     });
 }
-async function restoreCcacheAsync({ logger, workingDirectory, platform, env, secrets, }) {
+async function restoreCcacheAsync({ logger, workingDirectory, target, env, secrets, }) {
     const enabled = env.EAS_RESTORE_CACHE === '1' || (env.EAS_USE_CACHE === '1' && env.EAS_RESTORE_CACHE !== '0');
     if (!enabled) {
         return;
@@ -103,7 +116,7 @@ async function restoreCcacheAsync({ logger, workingDirectory, platform, env, sec
             env,
             stdio: 'pipe',
         }));
-        const cacheKey = await (0, cacheKey_1.generateDefaultBuildCacheKeyAsync)(workingDirectory, platform);
+        const cacheKey = await (0, cacheKey_1.generateDefaultBuildCacheKeyAsync)(workingDirectory, target);
         logger.info(`Restoring cache key: ${cacheKey}`);
         const jobId = (0, nullthrows_1.default)(env.EAS_BUILD_ID, 'EAS_BUILD_ID is not set');
         const { archivePath, matchedKey } = await (0, restoreCache_1.downloadCacheAsync)({
@@ -113,8 +126,8 @@ async function restoreCcacheAsync({ logger, workingDirectory, platform, env, sec
             robotAccessToken,
             paths: [cachePath],
             key: cacheKey,
-            keyPrefixes: [cacheKey_1.CACHE_KEY_PREFIX_BY_PLATFORM[platform]],
-            platform,
+            keyPrefixes: [(0, cacheKey_1.getCcacheKeyPrefix)(target)],
+            platform: target.platform,
         });
         await (0, restoreCache_1.decompressCacheAsync)({
             archivePath,
@@ -139,7 +152,7 @@ async function restoreCcacheAsync({ logger, workingDirectory, platform, env, sec
                     expoApiServerURL,
                     robotAccessToken,
                     paths: [cachePath],
-                    platform,
+                    platform: target.platform,
                 });
                 await (0, restoreCache_1.decompressCacheAsync)({
                     archivePath,

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

@@ -1,11 +1,11 @@
-import { Platform } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
+import { CcacheBuildTarget } from '../../utils/cacheKey';
 export declare function createSaveBuildCacheFunction(evictUsedBefore: Date): BuildFunction;
-export declare function saveCcacheAsync({ logger, workingDirectory, platform, evictUsedBefore, env, secrets, }: {
+export declare function saveCcacheAsync({ logger, workingDirectory, target, evictUsedBefore, env, secrets, }: {
     logger: bunyan;
     workingDirectory: string;
-    platform: Platform;
+    target: CcacheBuildTarget;
     evictUsedBefore: Date;
     env: Record<string, string | undefined>;
     secrets?: {

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) {

package/dist/steps/functions/startServeSimRemoteSession.js

@@ -12,6 +12,11 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
         __metricsId: 'eas/start_serve_sim_remote_session',
         supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
         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,
@@ -22,6 +27,7 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
             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, {
@@ -29,6 +35,7 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
                 env,
                 logger,
                 timeoutMs: STARTUP_TIMEOUT_MS,
+                packageVersion,
             });
             logger.info(`Preview URL: ${serveSim.previewUrl}`);
             try {

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/ios/AscApiClient.d.ts

@@ -264,6 +264,7 @@ export type AscApiClientPostApi = {
         response: z.output<(typeof PostApi)[Path]['response']>;
     };
 };
+export type AscPlatform = AscApiClientPostApi['/v1/buildUploads']['request']['data']['attributes']['platform'];
 export type AscApiClientPatchApi = {
     [Path in keyof typeof PatchApi]: {
         request: z.input<(typeof PatchApi)[Path]['request']>;

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

@@ -1,14 +1,23 @@
-import { AscApiClient, AscApiClientGetApi, AscApiClientPostApi } from './AscApiClient';
+import { AscApiClient, AscApiClientGetApi, AscApiClientPostApi, AscPlatform } from './AscApiClient';
 export declare namespace AscApiUtils {
+    /**
+     * Maps a bundle's `DTPlatformName` (from its Info.plist) to the App Store
+     * Connect platform used for a build upload. Unknown or missing values fall
+     * back to `IOS` to preserve the previous default.
+     */
+    function ascPlatformFromDtPlatformName(dtPlatformName: string | null): AscPlatform;
+    /** The App Store Connect TestFlight URL path segment for a platform. */
+    function testFlightPlatformPathSegment(platform: AscPlatform): string;
     function getAppInfoAsync({ client, appleAppIdentifier, }: {
         client: Pick<AscApiClient, 'getAsync'>;
         appleAppIdentifier: string;
     }): Promise<AscApiClientGetApi['/v1/apps/:id']['response']>;
-    function createBuildUploadAsync({ client, appleAppIdentifier, bundleShortVersion, bundleVersion, }: {
+    function createBuildUploadAsync({ client, appleAppIdentifier, bundleShortVersion, bundleVersion, platform, }: {
         client: Pick<AscApiClient, 'postAsync'>;
         appleAppIdentifier: string;
         bundleShortVersion: string;
         bundleVersion: string;
+        platform: AscPlatform;
     }): Promise<AscApiClientPostApi['/v1/buildUploads']['response']>;
     function getAppsAsync({ client, limit, }: {
         client: Pick<AscApiClient, 'getAsync'>;

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

@@ -5,6 +5,40 @@ const eas_build_job_1 = require("@expo/eas-build-job");
 const AscApiClient_1 = require("./AscApiClient");
 var AscApiUtils;
 (function (AscApiUtils) {
+    /**
+     * Maps a bundle's `DTPlatformName` (from its Info.plist) to the App Store
+     * Connect platform used for a build upload. Unknown or missing values fall
+     * back to `IOS` to preserve the previous default.
+     */
+    function ascPlatformFromDtPlatformName(dtPlatformName) {
+        switch (dtPlatformName) {
+            case 'appletvos':
+                return 'TV_OS';
+            case 'macosx':
+                return 'MAC_OS';
+            case 'xros':
+                return 'VISION_OS';
+            case 'iphoneos':
+            default:
+                return 'IOS';
+        }
+    }
+    AscApiUtils.ascPlatformFromDtPlatformName = ascPlatformFromDtPlatformName;
+    /** The App Store Connect TestFlight URL path segment for a platform. */
+    function testFlightPlatformPathSegment(platform) {
+        switch (platform) {
+            case 'TV_OS':
+                return 'tvos';
+            case 'MAC_OS':
+                return 'macos';
+            case 'VISION_OS':
+                return 'visionos';
+            case 'IOS':
+            default:
+                return 'ios';
+        }
+    }
+    AscApiUtils.testFlightPlatformPathSegment = testFlightPlatformPathSegment;
     async function getAppInfoAsync({ client, appleAppIdentifier, }) {
         try {
             return await client.getAsync('/v1/apps/:id', { 'fields[apps]': ['bundleId', 'name'] }, { id: appleAppIdentifier });
@@ -37,13 +71,13 @@ var AscApiUtils;
         }
     }
     AscApiUtils.getAppInfoAsync = getAppInfoAsync;
-    async function createBuildUploadAsync({ client, appleAppIdentifier, bundleShortVersion, bundleVersion, }) {
+    async function createBuildUploadAsync({ client, appleAppIdentifier, bundleShortVersion, bundleVersion, platform, }) {
         try {
             return await client.postAsync('/v1/buildUploads', {
                 data: {
                     type: 'buildUploads',
                     attributes: {
-                        platform: 'IOS',
+                        platform,
                         cfBundleShortVersionString: bundleShortVersion,
                         cfBundleVersion: bundleVersion,
                     },

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

@@ -16,6 +16,7 @@ const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const zod_1 = require("zod");
 const sentry_1 = require("../../../sentry");
+const download_1 = require("../../../utils/download");
 const DEFAULT_XCLOGPARSER_VERSION = 'v0.2.47';
 const XCLOGPARSER_DOWNLOAD_URL = 'https://storage.googleapis.com/turtle-v2/xclogparser';
 const XCLOGPARSER_DOWNLOAD_TIMEOUT_MS = 20_000;
@@ -123,7 +124,7 @@ async function downloadXclogparser({ tempDir, version, logger, proxyBaseUrl, env
     const zipName = getXclogparserZipName(version);
     const zipPath = path_1.default.join(tempDir, zipName);
     const directUrl = `${XCLOGPARSER_DOWNLOAD_URL}/${zipName}`;
-    const proxiedUrl = getProxiedDownloadUrl({ directUrl, proxyBaseUrl });
+    const proxiedUrl = (0, download_1.getProxiedDownloadUrl)({ directUrl, proxyBaseUrl });
     if (proxiedUrl) {
         const proxiedDownloadResult = await (0, results_1.asyncResult)(downloadAndUnpackXclogparser({ tempDir, zipPath, sourceUrl: proxiedUrl, env }));
         if (!proxiedDownloadResult.ok) {
@@ -188,13 +189,6 @@ const COMPILE_SIGNATURE_PREFIXES = ['SwiftCompile ', 'SwiftGeneratePch '];
 function getXclogparserZipName(version) {
     return `XCLogParser-macOS-x86-64-arm64-${version}.zip`;
 }
-function getProxiedDownloadUrl({ directUrl, proxyBaseUrl, }) {
-    if (!proxyBaseUrl) {
-        return null;
-    }
-    const parsedUrl = new URL(directUrl);
-    return directUrl.replace(`${parsedUrl.protocol}//${parsedUrl.host}`, `${proxyBaseUrl}/${parsedUrl.host}`);
-}
 function isCompileStep(step) {
     const detailStepType = step.detailStepType ?? '';
     const signature = step.signature ?? '';

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

@@ -92,10 +92,11 @@ export declare function spawnDetached({ command, args, cwd, env, }: {
     env: BuildStepEnv;
 }): DetachedProcessHandle;
 export declare function metricsCorsOriginToServeSimArgs(env: BuildStepEnv): string[];
-export declare function createServeSimArgs({ port, turnArgs, metricsCorsArgs, }: {
+export declare function createServeSimArgs({ port, turnArgs, metricsCorsArgs, packageVersion, }: {
     port: number;
     turnArgs?: string[];
     metricsCorsArgs?: string[];
+    packageVersion?: string;
 }): string[];
 export declare function waitForServeSimReadyAsync({ serveSim, port, timeoutMs, }: {
     serveSim: Pick<DetachedProcessHandle, 'pid' | 'getOutput'>;
@@ -106,11 +107,12 @@ export type ServeSimPreviewHandle = {
     previewUrl: string;
     stopAsync: () => Promise<void>;
 };
-export declare function startServeSimWithTunnelAsync(ctx: CustomBuildContext, { baseDomain, env, logger, timeoutMs, }: {
+export declare function startServeSimWithTunnelAsync(ctx: CustomBuildContext, { baseDomain, env, logger, timeoutMs, packageVersion, }: {
     baseDomain: string;
     env: BuildStepEnv;
     logger: bunyan;
     timeoutMs: number;
+    packageVersion?: string;
 }): Promise<ServeSimPreviewHandle>;
 export type NgrokTunnelHandle = {
     url: string;