@expo/build-tools 22.5.0 → 23.0.0

package/dist/builders/ios.js

@@ -101,6 +101,12 @@ async function buildInnerAsync(ctx, jobHooksRef) {
                 env: ctx.env,
                 secrets: ctx.job.secrets,
             });
+            await (0, restoreBuildCache_1.restoreCocoapodsCacheAsync)({
+                logger: ctx.logger,
+                workingDirectory,
+                env: ctx.env,
+                secrets: ctx.job.secrets,
+            });
         });
         await ctx.runBuildPhase(eas_build_job_1.BuildPhase.INSTALL_PODS, async () => {
             await runInstallPodsAsync(ctx);
@@ -229,6 +235,12 @@ async function buildInnerAsync(ctx, jobHooksRef) {
             env: ctx.env,
             secrets: ctx.job.secrets,
         });
+        await (0, saveBuildCache_1.saveCocoapodsCacheAsync)({
+            logger: ctx.logger,
+            workingDirectory,
+            env: ctx.env,
+            secrets: ctx.job.secrets,
+        });
     });
     await ctx.runBuildPhase(eas_build_job_1.BuildPhase.CACHE_STATS, async () => {
         await (0, restoreBuildCache_1.cacheStatsAsync)({

package/dist/common/installDependencies.js

@@ -49,7 +49,11 @@ async function installDependenciesAsync({ packageManager, env, logger, infoCallb
             break;
         }
         case packageManager_1.PackageManager.BUN:
-            args = ['install', ...(useFrozenLockfile ? ['--frozen-lockfile'] : [])];
+            args = [
+                'install',
+                ...(env['EAS_BUN_FILTER_WORKSPACE'] ? ['--filter', env['EAS_BUN_FILTER_WORKSPACE']] : []),
+                ...(useFrozenLockfile ? ['--frozen-lockfile'] : []),
+            ];
             break;
         default:
             throw new Error(`Unsupported package manager: ${packageManager}`);

package/dist/index.d.ts

@@ -4,8 +4,12 @@ import RemoteLoggerStream from './logging/RemoteLoggerStream';
 export { Builders, HttpLogStream, RemoteLoggerStream };
 export { uploadWithSignedUrl } from './storage/uploadWithSignedUrl';
 export type { SignedUrl, UploadWithSignedUrlParams } from './storage/uploadWithSignedUrl';
+export { downloadCacheAsync } from './steps/functions/restoreCache';
+export { uploadCacheAsync } from './steps/functions/saveCache';
 export { ArtifactToUpload, Artifacts, BuildContext, BuildContextOptions, CacheManager, LogBuffer, SkipNativeBuildError, } from './context';
 export { PackageManager } from './utils/packageManager';
+export * as TurtleSshSession from './utils/turtleSshSession';
+export { formatSecondsForLog } from './utils/formatDuration';
 export { findAndUploadXcodeBuildLogsAsync } from './ios/xcodeBuildLogs';
 export { Hook, runHookIfPresent } from './utils/hooks';
 export { parseGradleProfile, formatGradleProfileReport } from './android/gradleProfile';

package/dist/index.js

@@ -39,7 +39,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sentry = exports.Datadog = exports.formatGradleProfileReport = exports.parseGradleProfile = exports.runHookIfPresent = exports.Hook = exports.findAndUploadXcodeBuildLogsAsync = exports.PackageManager = exports.SkipNativeBuildError = exports.BuildContext = exports.uploadWithSignedUrl = exports.RemoteLoggerStream = exports.HttpLogStream = exports.Builders = void 0;
+exports.Sentry = exports.Datadog = exports.formatGradleProfileReport = exports.parseGradleProfile = exports.runHookIfPresent = exports.Hook = exports.findAndUploadXcodeBuildLogsAsync = exports.formatSecondsForLog = exports.TurtleSshSession = exports.PackageManager = exports.SkipNativeBuildError = exports.BuildContext = exports.uploadCacheAsync = exports.downloadCacheAsync = exports.uploadWithSignedUrl = exports.RemoteLoggerStream = exports.HttpLogStream = exports.Builders = void 0;
 const Builders = __importStar(require("./builders"));
 exports.Builders = Builders;
 const HttpLogStream_1 = __importDefault(require("./logging/HttpLogStream"));
@@ -48,11 +48,18 @@ const RemoteLoggerStream_1 = __importDefault(require("./logging/RemoteLoggerStre
 exports.RemoteLoggerStream = RemoteLoggerStream_1.default;
 var uploadWithSignedUrl_1 = require("./storage/uploadWithSignedUrl");
 Object.defineProperty(exports, "uploadWithSignedUrl", { enumerable: true, get: function () { return uploadWithSignedUrl_1.uploadWithSignedUrl; } });
+var restoreCache_1 = require("./steps/functions/restoreCache");
+Object.defineProperty(exports, "downloadCacheAsync", { enumerable: true, get: function () { return restoreCache_1.downloadCacheAsync; } });
+var saveCache_1 = require("./steps/functions/saveCache");
+Object.defineProperty(exports, "uploadCacheAsync", { enumerable: true, get: function () { return saveCache_1.uploadCacheAsync; } });
 var context_1 = require("./context");
 Object.defineProperty(exports, "BuildContext", { enumerable: true, get: function () { return context_1.BuildContext; } });
 Object.defineProperty(exports, "SkipNativeBuildError", { enumerable: true, get: function () { return context_1.SkipNativeBuildError; } });
 var packageManager_1 = require("./utils/packageManager");
 Object.defineProperty(exports, "PackageManager", { enumerable: true, get: function () { return packageManager_1.PackageManager; } });
+exports.TurtleSshSession = __importStar(require("./utils/turtleSshSession"));
+var formatDuration_1 = require("./utils/formatDuration");
+Object.defineProperty(exports, "formatSecondsForLog", { enumerable: true, get: function () { return formatDuration_1.formatSecondsForLog; } });
 var xcodeBuildLogs_1 = require("./ios/xcodeBuildLogs");
 Object.defineProperty(exports, "findAndUploadXcodeBuildLogsAsync", { enumerable: true, get: function () { return xcodeBuildLogs_1.findAndUploadXcodeBuildLogsAsync; } });
 var hooks_1 = require("./utils/hooks");

package/dist/steps/functionGroups/build.js

@@ -80,6 +80,7 @@ function createEasBuildBuildFunctionGroup(buildToolsContext) {
     });
 }
 function createStepsForIosSimulatorBuild({ globalCtx, buildToolsContext, workingDirectory, }) {
+    const evictUsedBefore = new Date();
     const calculateEASUpdateRuntimeVersion = (0, calculateEASUpdateRuntimeVersion_1.calculateEASUpdateRuntimeVersionFunction)().createBuildStepFromFunctionCall(globalCtx, {
         id: 'calculate_eas_update_runtime_version',
         workingDirectory,
@@ -87,6 +88,13 @@ function createStepsForIosSimulatorBuild({ globalCtx, buildToolsContext, working
     const installPods = (0, installPods_1.createInstallPodsBuildFunction)().createBuildStepFromFunctionCall(globalCtx, {
         workingDirectory: workingDirectory ? path_1.default.join(workingDirectory, './ios') : './ios',
     });
+    const restoreCache = (0, restoreBuildCache_1.createRestoreBuildCacheFunction)().createBuildStepFromFunctionCall(globalCtx, {
+        workingDirectory,
+        callInputs: {
+            platform: eas_build_job_1.Platform.IOS,
+            simulator: true,
+        },
+    });
     const configureEASUpdate = (0, configureEASUpdateIfInstalled_1.configureEASUpdateIfInstalledFunction)().createBuildStepFromFunctionCall(globalCtx, {
         workingDirectory,
         callInputs: {
@@ -101,6 +109,13 @@ function createStepsForIosSimulatorBuild({ globalCtx, buildToolsContext, working
             resolved_eas_update_runtime_version: '${ steps.calculate_eas_update_runtime_version.resolved_eas_update_runtime_version }',
         },
     });
+    const saveCache = (0, saveBuildCache_1.createSaveBuildCacheFunction)(evictUsedBefore).createBuildStepFromFunctionCall(globalCtx, {
+        workingDirectory,
+        callInputs: {
+            platform: eas_build_job_1.Platform.IOS,
+            simulator: true,
+        },
+    });
     return [
         (0, checkout_1.createCheckoutBuildFunction)().createBuildStepFromFunctionCall(globalCtx),
         (0, useNpmToken_1.createSetUpNpmrcBuildFunction)().createBuildStepFromFunctionCall(globalCtx, {
@@ -113,6 +128,7 @@ function createStepsForIosSimulatorBuild({ globalCtx, buildToolsContext, working
         (0, prebuild_1.createPrebuildBuildFunction)().createBuildStepFromFunctionCall(globalCtx, {
             workingDirectory,
         }),
+        restoreCache,
         calculateEASUpdateRuntimeVersion,
         installPods,
         configureEASUpdate,
@@ -131,6 +147,10 @@ function createStepsForIosSimulatorBuild({ globalCtx, buildToolsContext, working
         }),
         runFastlane,
         (0, findAndUploadBuildArtifacts_1.createFindAndUploadBuildArtifactsBuildFunction)(buildToolsContext).createBuildStepFromFunctionCall(globalCtx, { workingDirectory }),
+        saveCache,
+        (0, restoreBuildCache_1.createCacheStatsBuildFunction)().createBuildStepFromFunctionCall(globalCtx, {
+            workingDirectory,
+        }),
     ];
 }
 function createStepsForIosBuildWithCredentials({ globalCtx, buildToolsContext, workingDirectory, }) {

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

@@ -12,6 +12,14 @@ export declare function restoreCcacheAsync({ logger, workingDirectory, target, e
         robotAccessToken?: string;
     };
 }): Promise<void>;
+export declare function restoreCocoapodsCacheAsync({ logger, workingDirectory, env, secrets, }: {
+    logger: bunyan;
+    workingDirectory: string;
+    env: Record<string, string | undefined>;
+    secrets?: {
+        robotAccessToken?: string;
+    };
+}): Promise<void>;
 export declare function restoreGradleCacheAsync({ logger, workingDirectory, env, secrets, }: {
     logger: bunyan;
     workingDirectory: string;

package/dist/steps/functions/restoreBuildCache.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRestoreBuildCacheFunction = createRestoreBuildCacheFunction;
 exports.createCacheStatsBuildFunction = createCacheStatsBuildFunction;
 exports.restoreCcacheAsync = restoreCcacheAsync;
+exports.restoreCocoapodsCacheAsync = restoreCocoapodsCacheAsync;
 exports.restoreGradleCacheAsync = restoreGradleCacheAsync;
 exports.cacheStatsAsync = cacheStatsAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
@@ -18,6 +19,7 @@ const path_1 = __importDefault(require("path"));
 const ccacheStats_1 = require("./ccacheStats");
 const restoreCache_1 = require("./restoreCache");
 const cacheKey_1 = require("../../utils/cacheKey");
+const cocoapodsCache_1 = require("../../utils/cocoapodsCache");
 const datadog_1 = require("../../datadog");
 const gradleCacheKey_1 = require("../../utils/gradleCacheKey");
 const turtleFetch_1 = require("../../utils/turtleFetch");
@@ -70,6 +72,14 @@ function createRestoreBuildCacheFunction() {
                     secrets: stepCtx.global.staticContext.job.secrets,
                 });
             }
+            else {
+                await restoreCocoapodsCacheAsync({
+                    logger,
+                    workingDirectory,
+                    env,
+                    secrets: stepCtx.global.staticContext.job.secrets,
+                });
+            }
         },
     });
 }
@@ -167,6 +177,48 @@ async function restoreCcacheAsync({ logger, workingDirectory, target, env, secre
         }
     }
 }
+async function restoreCocoapodsCacheAsync({ logger, workingDirectory, env, secrets, }) {
+    if (env.EAS_PODS_CACHE !== '1') {
+        return;
+    }
+    try {
+        const { stdout } = await (0, steps_1.spawnAsync)('pod', ['--version'], {
+            env,
+            stdio: 'pipe',
+        });
+        const { key, keyPrefix } = await (0, cocoapodsCache_1.resolveCocoapodsCacheKeyAsync)(workingDirectory, stdout);
+        logger.info(`Restoring CocoaPods cache key: ${key}`);
+        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');
+        const { podsDirectory } = (0, cocoapodsCache_1.getCocoapodsCachePaths)(workingDirectory);
+        const { archivePath, matchedKey } = await (0, restoreCache_1.downloadCacheAsync)({
+            logger,
+            jobId,
+            expoApiServerURL,
+            robotAccessToken,
+            paths: [podsDirectory],
+            key,
+            keyPrefixes: [keyPrefix],
+            platform: eas_build_job_1.Platform.IOS,
+        });
+        await (0, cocoapodsCache_1.restoreCocoapodsCacheArchiveAsync)({ archivePath, workingDirectory });
+        const hitType = matchedKey === key ? 'direct_hit' : 'prefix_match';
+        logger.info(`CocoaPods cache restored to ${podsDirectory} (${hitType === 'direct_hit' ? 'direct hit' : 'prefix match'})`);
+        datadog_1.Datadog.log(`CocoaPods cache restored (${hitType})`, {
+            event: 'cocoapods_cache_restored',
+            cache_hit_type: hitType,
+        });
+    }
+    catch (err) {
+        if (err instanceof turtleFetch_1.TurtleFetchError && err.response?.status === 404) {
+            logger.info('No CocoaPods cache found for this key');
+        }
+        else {
+            logger.warn('Failed to restore CocoaPods cache: ', err);
+        }
+    }
+}
 async function restoreGradleCacheAsync({ logger, workingDirectory, env, secrets, }) {
     if (env.EAS_GRADLE_CACHE !== '1') {
         return;

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

@@ -2,6 +2,14 @@ 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 saveCocoapodsCacheAsync({ logger, workingDirectory, env, secrets, }: {
+    logger: bunyan;
+    workingDirectory: string;
+    env: Record<string, string | undefined>;
+    secrets?: {
+        robotAccessToken?: string;
+    };
+}): Promise<void>;
 export declare function saveCcacheAsync({ logger, workingDirectory, target, evictUsedBefore, env, secrets, }: {
     logger: bunyan;
     workingDirectory: string;

package/dist/steps/functions/saveBuildCache.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSaveBuildCacheFunction = createSaveBuildCacheFunction;
+exports.saveCocoapodsCacheAsync = saveCocoapodsCacheAsync;
 exports.saveCcacheAsync = saveCcacheAsync;
 exports.saveGradleCacheAsync = saveGradleCacheAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
@@ -16,6 +17,7 @@ const path_1 = __importDefault(require("path"));
 const saveCache_1 = require("./saveCache");
 const artifacts_1 = require("../../utils/artifacts");
 const cacheKey_1 = require("../../utils/cacheKey");
+const cocoapodsCache_1 = require("../../utils/cocoapodsCache");
 const gradleCacheKey_1 = require("../../utils/gradleCacheKey");
 function createSaveBuildCacheFunction(evictUsedBefore) {
     return new steps_1.BuildFunction({
@@ -67,9 +69,59 @@ function createSaveBuildCacheFunction(evictUsedBefore) {
                     secrets: stepCtx.global.staticContext.job.secrets,
                 });
             }
+            else {
+                await saveCocoapodsCacheAsync({
+                    logger,
+                    workingDirectory,
+                    env,
+                    secrets: stepCtx.global.staticContext.job.secrets,
+                });
+            }
         },
     });
 }
+async function saveCocoapodsCacheAsync({ logger, workingDirectory, env, secrets, }) {
+    if (env.EAS_PODS_CACHE !== '1') {
+        return;
+    }
+    const { podsDirectory, podfileLockPath } = (0, cocoapodsCache_1.getCocoapodsCachePaths)(workingDirectory);
+    try {
+        await Promise.all([fs_1.default.promises.access(podsDirectory), fs_1.default.promises.access(podfileLockPath)]);
+    }
+    catch {
+        logger.warn('No CocoaPods installation found, skipping cache save');
+        return;
+    }
+    try {
+        const { stdout } = await (0, steps_1.spawnAsync)('pod', ['--version'], {
+            env,
+            stdio: 'pipe',
+        });
+        const { key } = await (0, cocoapodsCache_1.resolveCocoapodsCacheKeyAsync)(workingDirectory, stdout);
+        logger.info(`Saving CocoaPods cache key: ${key}`);
+        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');
+        logger.info('Compressing CocoaPods cache...');
+        const { archivePath } = await (0, cocoapodsCache_1.compressCocoapodsCacheAsync)({ workingDirectory });
+        const { size } = await fs_1.default.promises.stat(archivePath);
+        logger.info(`CocoaPods cache archive size: ${(0, artifacts_1.formatBytes)(size)}`);
+        await (0, saveCache_1.uploadCacheAsync)({
+            logger,
+            jobId,
+            expoApiServerURL,
+            robotAccessToken,
+            archivePath,
+            key,
+            paths: [podsDirectory],
+            size,
+            platform: eas_build_job_1.Platform.IOS,
+        });
+    }
+    catch (err) {
+        logger.error({ err }, 'Failed to save CocoaPods cache');
+    }
+}
 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) {

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

@@ -2,7 +2,7 @@ import { Platform } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
 export declare function createSaveCacheFunction(): BuildFunction;
-export declare function uploadCacheAsync({ logger, jobId, expoApiServerURL, robotAccessToken, paths, key, archivePath, size, platform, }: {
+export declare function uploadCacheAsync({ logger, jobId, expoApiServerURL, robotAccessToken, paths, key, archivePath, size, platform, force, }: {
     logger: bunyan;
     jobId: string;
     expoApiServerURL: string;
@@ -12,6 +12,7 @@ export declare function uploadCacheAsync({ logger, jobId, expoApiServerURL, robo
     archivePath: string;
     size: number;
     platform: Platform | undefined;
+    force?: boolean;
 }): Promise<void>;
 export declare function uploadPublicCacheAsync({ logger, jobId, expoApiServerURL, robotAccessToken, paths, key, archivePath, size, }: {
     logger: bunyan;

package/dist/steps/functions/saveCache.js

@@ -122,7 +122,7 @@ function createSaveCacheFunction() {
         },
     });
 }
-async function uploadCacheAsync({ logger, jobId, expoApiServerURL, robotAccessToken, paths, key, archivePath, size, platform, }) {
+async function uploadCacheAsync({ logger, jobId, expoApiServerURL, robotAccessToken, paths, key, archivePath, size, platform, force = false, }) {
     const routerURL = platform
         ? 'v2/turtle-builds/caches/upload-sessions'
         : 'v2/turtle-caches/upload-sessions';
@@ -135,12 +135,14 @@ async function uploadCacheAsync({ logger, jobId, expoApiServerURL, robotAccessTo
                 key,
                 version: (0, cache_1.getCacheVersion)(paths),
                 size,
+                force,
             })
             : JSON.stringify({
                 jobRunId: jobId,
                 key,
                 version: (0, cache_1.getCacheVersion)(paths),
                 size,
+                force,
             }),
         headers: {
             Authorization: `Bearer ${robotAccessToken}`,

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -71,9 +71,9 @@ const turtleFetch_1 = require("../../utils/turtleFetch");
 const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
 const SERVE_SIM_PACKAGE_NAME = '@expo/serve-sim';
 const SERVE_SIM_HOST = '127.0.0.1';
-const SERVE_SIM_MAX_DIMENSION = '1280';
+const SERVE_SIM_MAX_DIMENSION = '960';
 const SERVE_SIM_MJPEG_QUALITY = '0.55';
-const SERVE_SIM_VIDEO_BITRATE = '3000000';
+const SERVE_SIM_VIDEO_BITRATE = '6000000';
 const SERVE_SIM_VIDEO_FPS = '60';
 const START_DEVICE_RUN_SESSION_MUTATION = (0, gql_tada_1.graphql)(`
   mutation StartDeviceRunSession($deviceRunSessionId: ID!, $remoteConfig: JSONObject!) {

package/dist/utils/cocoapodsCache.d.ts

@@ -0,0 +1,19 @@
+export declare const COCOAPODS_CACHE_KEY_PREFIX = "ios-pods-";
+export declare function getCocoapodsCachePaths(workingDirectory: string): {
+    iosDirectory: string;
+    podsDirectory: string;
+    podfileLockPath: string;
+};
+export declare function resolveCocoapodsCacheKeyAsync(workingDirectory: string, cocoapodsVersion: string): Promise<{
+    key: string;
+    keyPrefix: string;
+}>;
+export declare function compressCocoapodsCacheAsync({ workingDirectory, }: {
+    workingDirectory: string;
+}): Promise<{
+    archivePath: string;
+}>;
+export declare function restoreCocoapodsCacheArchiveAsync({ archivePath, workingDirectory, }: {
+    archivePath: string;
+    workingDirectory: string;
+}): Promise<void>;

package/dist/utils/cocoapodsCache.js

@@ -0,0 +1,111 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COCOAPODS_CACHE_KEY_PREFIX = void 0;
+exports.getCocoapodsCachePaths = getCocoapodsCachePaths;
+exports.resolveCocoapodsCacheKeyAsync = resolveCocoapodsCacheKeyAsync;
+exports.compressCocoapodsCacheAsync = compressCocoapodsCacheAsync;
+exports.restoreCocoapodsCacheArchiveAsync = restoreCocoapodsCacheArchiveAsync;
+const steps_1 = require("@expo/steps");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const tar = __importStar(require("tar"));
+exports.COCOAPODS_CACHE_KEY_PREFIX = 'ios-pods-';
+const PODS_DIRECTORY_NAME = 'Pods';
+const PODFILE_LOCK_NAME = 'Podfile.lock';
+function getCocoapodsCachePaths(workingDirectory) {
+    const iosDirectory = path_1.default.join(workingDirectory, 'ios');
+    return {
+        iosDirectory,
+        podsDirectory: path_1.default.join(iosDirectory, PODS_DIRECTORY_NAME),
+        podfileLockPath: path_1.default.join(iosDirectory, PODFILE_LOCK_NAME),
+    };
+}
+async function resolveCocoapodsCacheKeyAsync(workingDirectory, cocoapodsVersion) {
+    const normalizedVersion = cocoapodsVersion.trim();
+    if (!normalizedVersion) {
+        throw new Error('Failed to determine CocoaPods version');
+    }
+    const keyPrefix = `${exports.COCOAPODS_CACHE_KEY_PREFIX}${normalizedVersion}-`;
+    const { podfileLockPath } = getCocoapodsCachePaths(workingDirectory);
+    try {
+        await fs_1.default.promises.access(podfileLockPath);
+    }
+    catch {
+        return { key: keyPrefix, keyPrefix };
+    }
+    return {
+        key: `${keyPrefix}${(0, steps_1.hashFiles)([podfileLockPath])}`,
+        keyPrefix,
+    };
+}
+async function compressCocoapodsCacheAsync({ workingDirectory, }) {
+    const { iosDirectory, podsDirectory } = getCocoapodsCachePaths(workingDirectory);
+    await fs_1.default.promises.access(podsDirectory);
+    const archiveDestinationDirectory = await fs_1.default.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'save-cocoapods-cache-'));
+    const archivePath = path_1.default.join(archiveDestinationDirectory, 'cache.tar.gz');
+    await tar.create({
+        file: archivePath,
+        cwd: iosDirectory,
+        gzip: true,
+    }, [PODS_DIRECTORY_NAME]);
+    return { archivePath };
+}
+async function restoreCocoapodsCacheArchiveAsync({ archivePath, workingDirectory, }) {
+    const { iosDirectory, podsDirectory } = getCocoapodsCachePaths(workingDirectory);
+    await fs_1.default.promises.mkdir(iosDirectory, { recursive: true });
+    const temporaryRestoreDirectory = await fs_1.default.promises.mkdtemp(path_1.default.join(iosDirectory, '.eas-pods-cache-'));
+    try {
+        await tar.extract({
+            file: archivePath,
+            cwd: temporaryRestoreDirectory,
+            filter: entryPath => entryPath === PODS_DIRECTORY_NAME || entryPath.startsWith(`${PODS_DIRECTORY_NAME}/`),
+        });
+        const restoredPodsDirectory = path_1.default.join(temporaryRestoreDirectory, PODS_DIRECTORY_NAME);
+        const restoredPodsStat = await fs_1.default.promises.stat(restoredPodsDirectory);
+        if (!restoredPodsStat.isDirectory()) {
+            throw new Error('CocoaPods cache archive does not contain a Pods directory');
+        }
+        await fs_1.default.promises.rm(podsDirectory, { recursive: true, force: true });
+        await fs_1.default.promises.rename(restoredPodsDirectory, podsDirectory);
+    }
+    finally {
+        await fs_1.default.promises.rm(temporaryRestoreDirectory, { recursive: true, force: true });
+    }
+}

package/dist/utils/easCli.js

@@ -11,6 +11,7 @@ const eas_build_job_1 = require("@expo/eas-build-job");
 const packageManager_1 = require("./packageManager");
 const sentry_1 = require("../sentry");
 let cachedEasCliVersionsPromise;
+const NPX_ENV = { NPM_CONFIG_MIN_RELEASE_AGE: '0' };
 /**
  * Resolves the `eas-cli` versions to install for staging/production. Prefers the
  * versions committed to `cli-versions.json` (fetched from expo/eas-cli); on any
@@ -66,7 +67,7 @@ async function resolveEasCommandPrefixAndEnvAsync() {
         return {
             cmd: 'npx',
             args: [...npxArgsPrefix, `eas-cli@${versions.STAGING}`],
-            extraEnv: {},
+            extraEnv: NPX_ENV,
         };
     }
     else if (process.env.ENVIRONMENT === 'staging') {
@@ -74,7 +75,7 @@ async function resolveEasCommandPrefixAndEnvAsync() {
         return {
             cmd: 'npx',
             args: [...npxArgsPrefix, `eas-cli@${versions.STAGING}`],
-            extraEnv: { EXPO_STAGING: '1' },
+            extraEnv: { ...NPX_ENV, EXPO_STAGING: '1' },
         };
     }
     else {
@@ -82,7 +83,7 @@ async function resolveEasCommandPrefixAndEnvAsync() {
         return {
             cmd: 'npx',
             args: [...npxArgsPrefix, `eas-cli@${versions.PRODUCTION}`],
-            extraEnv: {},
+            extraEnv: NPX_ENV,
         };
     }
 }

package/dist/utils/formatDuration.d.ts

@@ -0,0 +1 @@
+export declare function formatSecondsForLog(totalSeconds: number): string;

package/dist/utils/formatDuration.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSecondsForLog = formatSecondsForLog;
+function formatSecondsForLog(totalSeconds) {
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (hours > 0) {
+        parts.push(hours === 1 ? '1 hour' : `${hours} hours`);
+    }
+    if (minutes > 0) {
+        parts.push(minutes === 1 ? '1 minute' : `${minutes} minutes`);
+    }
+    if (seconds > 0 || parts.length === 0) {
+        parts.push(seconds === 1 ? '1 second' : `${seconds} seconds`);
+    }
+    return parts.join(' ');
+}

package/dist/utils/processes.d.ts

@@ -1,2 +1,9 @@
+import { ChildProcess } from 'node:child_process';
+export declare function isChildProcessAlive(child: ChildProcess): boolean;
+/**
+ * Kill a detached spawn's process group. Negated pid targets the group so bash/sleep
+ * children cannot survive after the parent is gone (e.g. across upterm redial).
+ */
+export declare function killProcessGroup(child: ChildProcess): void;
 export declare function getParentAndDescendantProcessPidsAsync(ppid: number): Promise<number[]>;
 export declare function isProcessDescendantOfAsync(pid: number, ancestorPid: number): Promise<boolean>;

package/dist/utils/processes.js

@@ -3,9 +3,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isChildProcessAlive = isChildProcessAlive;
+exports.killProcessGroup = killProcessGroup;
 exports.getParentAndDescendantProcessPidsAsync = getParentAndDescendantProcessPidsAsync;
 exports.isProcessDescendantOfAsync = isProcessDescendantOfAsync;
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+function isChildProcessAlive(child) {
+    return child.exitCode === null && child.signalCode === null && !child.killed;
+}
+/**
+ * Kill a detached spawn's process group. Negated pid targets the group so bash/sleep
+ * children cannot survive after the parent is gone (e.g. across upterm redial).
+ */
+function killProcessGroup(child) {
+    if (child.pid == null) {
+        return;
+    }
+    try {
+        process.kill(-child.pid, 'SIGTERM');
+    }
+    catch {
+        child.kill();
+    }
+}
 async function getChildrenPidsAsync(parentPids) {
     try {
         const result = await (0, turtle_spawn_1.default)('pgrep', ['-P', parentPids.join(',')], {

package/dist/utils/turtleSshSession.d.ts

@@ -0,0 +1,28 @@
+import { Job, SshSettings } from '@expo/eas-build-job';
+import { bunyan } from '@expo/logger';
+import { BuildContext } from '../context';
+export type TurtleSshTarget = {
+    type: 'BUILD' | 'JOB_RUN';
+    id: string;
+};
+export declare function isSshEnabled(job: Pick<Job, 'ssh'>): boolean;
+export declare function getSshIdleTimeoutSeconds(job: Pick<Job, 'ssh'>): number;
+export declare function getSshRelayServerUrl(job: Pick<Job, 'ssh'>): string;
+export type SshSessionHandle = {
+    getConnectedClientCountAsync: () => Promise<number>;
+    ensureConnectedAsync: () => Promise<void>;
+    stopAsync: () => Promise<void>;
+};
+export type StartedSshSession = {
+    handle: SshSessionHandle;
+    idleTimeoutSeconds: number;
+};
+export declare function startSshSessionAsync(ctx: BuildContext, { target, relayServerUrl, idleTimeoutSeconds: requestedIdleTimeoutSeconds, }: {
+    target: TurtleSshTarget;
+} & SshSettings): Promise<StartedSshSession>;
+export declare function superviseSshSessionAsync({ handle, idleTimeoutSeconds, hasJobFinished, logger, }: {
+    handle: SshSessionHandle;
+    idleTimeoutSeconds: number;
+    hasJobFinished: () => boolean;
+    logger: bunyan;
+}): Promise<void>;

package/dist/utils/turtleSshSession.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSshEnabled = isSshEnabled;
+exports.getSshIdleTimeoutSeconds = getSshIdleTimeoutSeconds;
+exports.getSshRelayServerUrl = getSshRelayServerUrl;
+exports.startSshSessionAsync = startSshSessionAsync;
+exports.superviseSshSessionAsync = superviseSshSessionAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const gql_tada_1 = require("gql.tada");
+const formatDuration_1 = require("./formatDuration");
+const retry_1 = require("./retry");
+const upterm_1 = require("./upterm");
+const sentry_1 = require("../sentry");
+const MAX_SSH_REDIALS = 10;
+const REDIAL_BACKOFF_MS = 6_000;
+const CLIENT_COUNT_POLL_INTERVAL_MS = 5_000;
+const MAX_SSH_IDLE_TIMEOUT_SECONDS = 3600;
+const DEFAULT_SSH_IDLE_TIMEOUT_SECONDS = 0;
+const CREATE_OR_UPDATE_TURTLE_SSH_SESSION_MUTATION = (0, gql_tada_1.graphql)(`
+  mutation CreateOrUpdateTurtleSshSession(
+    $target: TurtleSshTargetInput!
+    $connectionConfig: TurtleSshConnectionConfigInput!
+    $sessionSettings: TurtleSshSessionSettingsInput!
+  ) {
+    turtleSshSession {
+      createOrUpdateTurtleSshSession(
+        target: $target
+        connectionConfig: $connectionConfig
+        sessionSettings: $sessionSettings
+      ) {
+        id
+        sessionSettings {
+          idleTimeoutSeconds
+        }
+      }
+    }
+  }
+`);
+function isSshEnabled(job) {
+    return job.ssh != null;
+}
+function getSshIdleTimeoutSeconds(job) {
+    const idleTimeoutSeconds = job.ssh?.idleTimeoutSeconds ?? DEFAULT_SSH_IDLE_TIMEOUT_SECONDS;
+    if (!Number.isInteger(idleTimeoutSeconds) ||
+        idleTimeoutSeconds < 0 ||
+        idleTimeoutSeconds > MAX_SSH_IDLE_TIMEOUT_SECONDS) {
+        throw new eas_build_job_1.SystemError(`SSH idle timeout must be an integer between 0 and ${MAX_SSH_IDLE_TIMEOUT_SECONDS} seconds, got ${idleTimeoutSeconds}.`, { trackingCode: 'SSH_IDLE_TIMEOUT_INVALID' });
+    }
+    return idleTimeoutSeconds;
+}
+function getSshRelayServerUrl(job) {
+    const relayServerUrl = job.ssh?.relayServerUrl;
+    if (!relayServerUrl) {
+        throw new eas_build_job_1.SystemError('SSH is enabled but no relay server URL was configured on the job.', {
+            trackingCode: 'SSH_RELAY_SERVER_URL_MISSING',
+        });
+    }
+    return relayServerUrl;
+}
+async function createOrUpdateSessionAsync(ctx, { target, connectionConfig, idleTimeoutSeconds, }) {
+    const result = await ctx.graphqlClient
+        .mutation(CREATE_OR_UPDATE_TURTLE_SSH_SESSION_MUTATION, {
+        target,
+        connectionConfig: {
+            ...connectionConfig,
+            type: 'UPTERM_V1',
+        },
+        sessionSettings: { idleTimeoutSeconds },
+    })
+        .toPromise();
+    if (result.error || !result.data) {
+        throw new eas_build_job_1.SystemError(`Failed to create or update the SSH session: ${result.error?.message ?? 'no data returned'}`, { cause: result.error });
+    }
+    const session = result.data.turtleSshSession.createOrUpdateTurtleSshSession;
+    return { idleTimeoutSeconds: session.sessionSettings.idleTimeoutSeconds };
+}
+async function startSshSessionAsync(ctx, { target, relayServerUrl, idleTimeoutSeconds: requestedIdleTimeoutSeconds, }) {
+    const logger = ctx.logger;
+    const host = await (0, upterm_1.startUptermHostAsync)(ctx, { relayServerUrl });
+    let idleTimeoutSeconds;
+    try {
+        ({ idleTimeoutSeconds } = await createOrUpdateSessionAsync(ctx, {
+            target,
+            connectionConfig: { ...host.connectionConfig, reconnecting: false },
+            idleTimeoutSeconds: requestedIdleTimeoutSeconds,
+        }));
+    }
+    catch (err) {
+        await host.stopAsync().catch(() => { });
+        throw err;
+    }
+    const ensureConnectedAsync = async () => {
+        if (host.isAlive()) {
+            return;
+        }
+        for (let attempt = 1; attempt <= MAX_SSH_REDIALS; attempt++) {
+            try {
+                if (!host.isAlive()) {
+                    logger.warn('The SSH relay connection dropped. Reconnecting...');
+                    await createOrUpdateSessionAsync(ctx, {
+                        target,
+                        connectionConfig: { ...host.connectionConfig, reconnecting: true },
+                        idleTimeoutSeconds: requestedIdleTimeoutSeconds,
+                    }).catch(() => { });
+                    await host.redialAsync();
+                }
+                await createOrUpdateSessionAsync(ctx, {
+                    target,
+                    connectionConfig: { ...host.connectionConfig, reconnecting: false },
+                    idleTimeoutSeconds: requestedIdleTimeoutSeconds,
+                });
+                logger.info('The SSH relay connection was restored.');
+                return;
+            }
+            catch (err) {
+                logger.warn({ err }, `SSH reconnect attempt ${attempt} of ${MAX_SSH_REDIALS} failed.`);
+                if (attempt < MAX_SSH_REDIALS) {
+                    await (0, retry_1.sleepAsync)(REDIAL_BACKOFF_MS);
+                }
+            }
+        }
+        throw new eas_build_job_1.SystemError(`The SSH relay connection dropped and could not be restored after ${MAX_SSH_REDIALS} attempts.`);
+    };
+    return {
+        handle: {
+            getConnectedClientCountAsync: () => host.getConnectedClientCountAsync(),
+            ensureConnectedAsync,
+            stopAsync: () => host.stopAsync(),
+        },
+        idleTimeoutSeconds,
+    };
+}
+async function superviseSshSessionAsync({ handle, idleTimeoutSeconds, hasJobFinished, logger, }) {
+    const idleTimeoutMs = idleTimeoutSeconds * 1_000;
+    let idleSince = null;
+    let previousClientCount = 0;
+    for (;;) {
+        try {
+            await handle.ensureConnectedAsync();
+        }
+        catch (err) {
+            logger.warn({ err }, 'Could not restore the SSH relay connection. Closing the session.');
+            sentry_1.Sentry.capture('Could not restore the SSH relay connection', err instanceof Error ? err : undefined, {
+                tags: { trackingCode: 'SSH_RELAY_RECONNECT_FAILED' },
+            });
+            return;
+        }
+        let connectedClientCount;
+        try {
+            connectedClientCount = await handle.getConnectedClientCountAsync();
+        }
+        catch (err) {
+            logger.warn({ err }, 'Could not read the SSH client count. Closing the session.');
+            sentry_1.Sentry.capture('Could not read the SSH client count', err instanceof Error ? err : undefined, {
+                tags: { trackingCode: 'SSH_CLIENT_COUNT_UNREADABLE' },
+            });
+            return;
+        }
+        if (connectedClientCount !== previousClientCount) {
+            logger.info(`SSH clients connected: ${connectedClientCount}`);
+            previousClientCount = connectedClientCount;
+        }
+        const jobHasFinished = hasJobFinished();
+        if (connectedClientCount > 0 || !jobHasFinished) {
+            idleSince = null;
+        }
+        else if (idleSince === null) {
+            idleSince = Date.now();
+        }
+        if (jobHasFinished && connectedClientCount === 0) {
+            if (idleTimeoutSeconds === 0) {
+                logger.info('The job finished and no SSH client is connected. Closing the session.');
+                return;
+            }
+            if (idleSince !== null && Date.now() - idleSince >= idleTimeoutMs) {
+                logger.info(`No SSH client connected for ${(0, formatDuration_1.formatSecondsForLog)(idleTimeoutSeconds)} after the job finished. Closing the session.`);
+                return;
+            }
+        }
+        await (0, retry_1.sleepAsync)(CLIENT_COUNT_POLL_INTERVAL_MS);
+    }
+}

package/dist/utils/upterm.d.ts

@@ -0,0 +1,38 @@
+import { Env } from '@expo/eas-build-job';
+import { z } from 'zod';
+import { BuildContext } from '../context';
+export declare function resolveUptermGcsObjectName(platform?: NodeJS.Platform, arch?: string): string;
+export type SshConnectionConfig = {
+    type: 'upterm-v1';
+    host: string;
+    secret: string;
+};
+export type UptermHost = {
+    connectionConfig: SshConnectionConfig;
+    getConnectedClientCountAsync: () => Promise<number>;
+    isAlive: () => boolean;
+    redialAsync: () => Promise<SshConnectionConfig>;
+    stopAsync: () => Promise<void>;
+};
+declare const UptermSessionJsonZ: z.ZodObject<{
+    sessionId: z.ZodString;
+    host: z.ZodString;
+    clientCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type UptermSessionJson = z.infer<typeof UptermSessionJsonZ>;
+export declare function connectionConfigFromUptermSession(parsed: Pick<UptermSessionJson, 'sessionId' | 'host'>): SshConnectionConfig | null;
+/**
+ * Strip upterm session secrets out of text before it reaches a log or an error message. upterm
+ * prints the session id as the userinfo of the connect line it advertises
+ * (`upterm proxy ws(s)://<sessionId>@host`) and repeats it bare as the ssh destination on the
+ * same line. Control characters are dropped first so they cannot split a token mid-match. The
+ * loop lifts the id out of the proxy URL and removes every occurrence of it; the final replace
+ * blanks userinfo in any other URL as a catch-all.
+ */
+export declare function redactConnectionSecrets(text: string): string;
+export declare function redactSpawnErrorForLog(err: unknown): unknown;
+export declare function resolveUptermPathAsync(env: Env): Promise<string>;
+export declare function startUptermHostAsync(ctx: BuildContext, { relayServerUrl }: {
+    relayServerUrl: string;
+}): Promise<UptermHost>;
+export {};

package/dist/utils/upterm.js

@@ -0,0 +1,257 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUptermGcsObjectName = resolveUptermGcsObjectName;
+exports.connectionConfigFromUptermSession = connectionConfigFromUptermSession;
+exports.redactConnectionSecrets = redactConnectionSecrets;
+exports.redactSpawnErrorForLog = redactSpawnErrorForLog;
+exports.resolveUptermPathAsync = resolveUptermPathAsync;
+exports.startUptermHostAsync = startUptermHostAsync;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const downloader_1 = __importDefault(require("@expo/downloader"));
+const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+const processes_1 = require("./processes");
+const retry_1 = require("./retry");
+const CONTROL_CHARACTERS = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g;
+function resolveUptermGcsObjectName(platform = process.platform, arch = process.arch) {
+    if (platform === 'darwin' && arch === 'arm64') {
+        return 'upterm-darwin-arm64';
+    }
+    if (platform === 'linux' && arch === 'x64') {
+        return 'upterm-linux-amd64';
+    }
+    throw new eas_build_job_1.SystemError(`SSH upterm is only available on darwin/arm64 and linux/x64 (got ${platform}/${arch}).`);
+}
+const UPTERM_GCS_BASE_URL = 'https://storage.googleapis.com/turtle-v2/upterm';
+const UPTERM_DOWNLOAD_TIMEOUT_MS = 60_000;
+const UPTERM_KEEPALIVE_SLEEP_SECONDS = 6 * 60 * 60;
+const CONNECTION_POLL_INTERVAL_MS = 500;
+const CONNECTION_STARTUP_TIMEOUT_MS = 60_000;
+const PROCESS_EXIT_TIMEOUT_MS = 5_000;
+const CLIENT_COUNT_READ_ATTEMPTS = 4;
+const CLIENT_COUNT_READ_RETRY_MS = 500;
+const DEFAULT_SSH_PORT = '22';
+const UptermSessionJsonZ = zod_1.z.object({
+    sessionId: zod_1.z.string().min(1),
+    host: zod_1.z.string().min(1),
+    clientCount: zod_1.z.number().optional(),
+});
+function connectionConfigFromUptermSession(parsed) {
+    let host = parsed.host;
+    if (host.includes('://')) {
+        let url;
+        try {
+            url = new URL(host);
+        }
+        catch {
+            return null;
+        }
+        host = url.port && url.port !== DEFAULT_SSH_PORT ? `${url.hostname}:${url.port}` : url.hostname;
+    }
+    if (!host) {
+        return null;
+    }
+    return { type: 'upterm-v1', host, secret: parsed.sessionId };
+}
+/**
+ * Strip upterm session secrets out of text before it reaches a log or an error message. upterm
+ * prints the session id as the userinfo of the connect line it advertises
+ * (`upterm proxy ws(s)://<sessionId>@host`) and repeats it bare as the ssh destination on the
+ * same line. Control characters are dropped first so they cannot split a token mid-match. The
+ * loop lifts the id out of the proxy URL and removes every occurrence of it; the final replace
+ * blanks userinfo in any other URL as a catch-all.
+ */
+function redactConnectionSecrets(text) {
+    let redacted = text.replace(CONTROL_CHARACTERS, '');
+    for (const [, token] of redacted.matchAll(/upterm proxy wss?:\/\/([^@\s]+)@/g)) {
+        redacted = redacted.split(token).join('<redacted>');
+    }
+    return redacted.replace(/([a-z][a-z0-9+.-]*:\/\/)[^@\s/]+@/gi, '$1<redacted>@');
+}
+function redactSpawnErrorForLog(err) {
+    if (!err || typeof err !== 'object') {
+        return err;
+    }
+    const spawnErr = err;
+    return {
+        ...spawnErr,
+        ...(typeof spawnErr.message === 'string'
+            ? { message: redactConnectionSecrets(spawnErr.message) }
+            : {}),
+        ...(typeof spawnErr.stdout === 'string'
+            ? { stdout: redactConnectionSecrets(spawnErr.stdout) }
+            : {}),
+        ...(typeof spawnErr.stderr === 'string'
+            ? { stderr: redactConnectionSecrets(spawnErr.stderr) }
+            : {}),
+    };
+}
+async function resolveUptermPathAsync(env) {
+    try {
+        await (0, turtle_spawn_1.default)('upterm', ['version'], { stdio: 'pipe', env });
+        return 'upterm';
+    }
+    catch { }
+    const objectName = resolveUptermGcsObjectName();
+    const downloadDir = await promises_1.default.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'eas-upterm-'));
+    const uptermPath = node_path_1.default.join(downloadDir, objectName);
+    const url = `${UPTERM_GCS_BASE_URL}/${objectName}`;
+    try {
+        await (0, downloader_1.default)(url, uptermPath, { retry: 3, timeout: UPTERM_DOWNLOAD_TIMEOUT_MS });
+        await promises_1.default.chmod(uptermPath, 0o755);
+    }
+    catch (err) {
+        await promises_1.default.rm(downloadDir, { recursive: true, force: true }).catch(() => { });
+        throw new eas_build_job_1.SystemError(`The upterm SSH client was not on PATH and could not be downloaded from ${url}. ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return uptermPath;
+}
+async function findAdminSocketPathAsync(uptermSocketDir) {
+    // Use this dial's own admin socket, not upterm's default, which can still point at a previous
+    // dial's session after a redial and break client-count reads.
+    const entries = await promises_1.default.readdir(uptermSocketDir).catch(() => []);
+    const socketName = entries.find(entry => entry.endsWith('.sock'));
+    return socketName ? node_path_1.default.join(uptermSocketDir, socketName) : null;
+}
+async function readCurrentSessionJsonAsync(uptermPath, adminSocketPath) {
+    try {
+        const result = await (0, turtle_spawn_1.default)(uptermPath, ['session', 'current', '--admin-socket', adminSocketPath, '--output', 'json'], { stdio: 'pipe' });
+        const parsed = UptermSessionJsonZ.safeParse(JSON.parse(result.stdout));
+        return parsed.success ? parsed.data : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function waitForConnectionConfigAsync(uptermPath, uptermSocketDir, getHostOutput) {
+    const deadline = Date.now() + CONNECTION_STARTUP_TIMEOUT_MS;
+    for (;;) {
+        const adminSocketPath = await findAdminSocketPathAsync(uptermSocketDir);
+        if (adminSocketPath) {
+            const session = await readCurrentSessionJsonAsync(uptermPath, adminSocketPath);
+            if (session) {
+                const connectionConfig = connectionConfigFromUptermSession(session);
+                if (connectionConfig) {
+                    return connectionConfig;
+                }
+            }
+        }
+        if (Date.now() >= deadline) {
+            throw new eas_build_job_1.SystemError(`The upterm client did not register with the relay within ${CONNECTION_STARTUP_TIMEOUT_MS / 1_000}s. Output:\n${redactConnectionSecrets(getHostOutput())}`);
+        }
+        await (0, retry_1.sleepAsync)(CONNECTION_POLL_INTERVAL_MS);
+    }
+}
+async function startUptermHostAsync(ctx, { relayServerUrl }) {
+    const uptermPath = await resolveUptermPathAsync(ctx.env);
+    const stateDir = await promises_1.default.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'eas-ssh-'));
+    const hostKeyPath = node_path_1.default.join(stateDir, 'id_host');
+    const forceCommandPath = node_path_1.default.join(stateDir, 'join.sh');
+    const uptermSocketDir = node_path_1.default.join(stateDir, 'upterm');
+    await (0, turtle_spawn_1.default)('ssh-keygen', ['-t', 'ed25519', '-N', '', '-f', hostKeyPath, '-q'], {
+        logger: ctx.logger,
+    });
+    await promises_1.default.writeFile(forceCommandPath, '#!/usr/bin/env bash\nexec bash -l\n', { mode: 0o755 });
+    let currentProcess = null;
+    const stopCurrentProcessAsync = async () => {
+        const previousProcess = currentProcess;
+        currentProcess = null;
+        if (!previousProcess) {
+            return;
+        }
+        (0, processes_1.killProcessGroup)(previousProcess.child);
+        await Promise.race([
+            previousProcess.catch(() => { }),
+            (0, retry_1.sleepAsync)(PROCESS_EXIT_TIMEOUT_MS).then(() => {
+                ctx.logger.debug('The previous upterm host process did not exit in time.');
+            }),
+        ]);
+    };
+    const getConnectedClientCountAsync = async () => {
+        for (let attempt = 1; attempt <= CLIENT_COUNT_READ_ATTEMPTS; attempt++) {
+            const adminSocketPath = await findAdminSocketPathAsync(uptermSocketDir);
+            const session = adminSocketPath
+                ? await readCurrentSessionJsonAsync(uptermPath, adminSocketPath)
+                : null;
+            if (session && typeof session.clientCount === 'number') {
+                return session.clientCount;
+            }
+            if (attempt < CLIENT_COUNT_READ_ATTEMPTS) {
+                await (0, retry_1.sleepAsync)(CLIENT_COUNT_READ_RETRY_MS);
+            }
+        }
+        throw new eas_build_job_1.SystemError('Could not read the SSH client count from the upterm admin socket.', {
+            trackingCode: 'SSH_CLIENT_COUNT_UNREADABLE',
+        });
+    };
+    const dialAsync = async () => {
+        await stopCurrentProcessAsync();
+        await promises_1.default.rm(uptermSocketDir, { recursive: true, force: true }).catch(err => {
+            ctx.logger.debug({ err }, 'Failed to clear the previous SSH socket directory.');
+        });
+        ctx.logger.debug('Connecting to the SSH relay.');
+        // --force-command is what each connecting SSH client runs (a login shell). The `sleep` after
+        // `--` is the host-side process that keeps `upterm host` up while nobody is connected.
+        const uptermProcess = (0, turtle_spawn_1.default)(uptermPath, [
+            'host',
+            '--server',
+            relayServerUrl,
+            '--accept',
+            '--skip-host-key-check',
+            '-i',
+            hostKeyPath,
+            '--force-command',
+            forceCommandPath,
+            '--',
+            'bash',
+            '-lc',
+            `sleep ${UPTERM_KEEPALIVE_SLEEP_SECONDS}`,
+        ], {
+            // upterm puts its admin socket under XDG_RUNTIME_DIR; point it at our state dir so we can
+            // find it for `session current` and clean it up on stop/redial.
+            env: { ...ctx.env, XDG_RUNTIME_DIR: stateDir },
+            stdio: ['ignore', 'pipe', 'pipe'],
+            detached: true,
+        });
+        uptermProcess.catch(err => ctx.logger.debug({ err: redactSpawnErrorForLog(err) }, 'The upterm host process exited.'));
+        uptermProcess.child.unref();
+        currentProcess = uptermProcess;
+        let output = '';
+        const appendChunk = (chunk) => {
+            output += chunk.toString();
+        };
+        uptermProcess.child.stdout?.on('data', appendChunk);
+        uptermProcess.child.stderr?.on('data', appendChunk);
+        return await waitForConnectionConfigAsync(uptermPath, uptermSocketDir, () => output);
+    };
+    const stopAsync = async () => {
+        await stopCurrentProcessAsync();
+        await promises_1.default.rm(stateDir, { recursive: true, force: true });
+    };
+    let connectionConfig;
+    try {
+        connectionConfig = await dialAsync();
+    }
+    catch (err) {
+        await stopAsync();
+        throw err;
+    }
+    return {
+        get connectionConfig() {
+            return connectionConfig;
+        },
+        getConnectedClientCountAsync,
+        isAlive: () => currentProcess != null && (0, processes_1.isChildProcessAlive)(currentProcess.child),
+        redialAsync: async () => {
+            connectionConfig = await dialAsync();
+            return connectionConfig;
+        },
+        stopAsync,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "22.5.0",
+  "version": "23.0.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -39,17 +39,17 @@
   "dependencies": {
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
-    "@expo/downloader": "22.0.0",
-    "@expo/eas-build-job": "22.0.0",
+    "@expo/downloader": "23.0.0",
+    "@expo/eas-build-job": "23.0.0",
     "@expo/env": "^0.4.0",
-    "@expo/logger": "22.0.0",
+    "@expo/logger": "23.0.0",
     "@expo/package-manager": "1.9.10",
     "@expo/plist": "^0.3.5",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "22.4.0",
-    "@expo/template-file": "22.0.0",
-    "@expo/turtle-spawn": "22.0.0",
+    "@expo/steps": "23.0.0",
+    "@expo/template-file": "23.0.0",
+    "@expo/turtle-spawn": "23.0.0",
     "@expo/xcpretty": "^4.3.1",
     "@ngrok/ngrok": "1.7.0",
     "@sentry/node": "7.77.0",
@@ -103,5 +103,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "3f74ea369d329a363fe16c9f90c8be74cb598777"
+  "gitHead": "2e2aaa4ac902b653934d7dccdc0c9b72cb7b9cac"
 }