@expo/build-tools 22.5.0 → 22.6.0

package/dist/index.d.ts

@@ -6,6 +6,8 @@ export { uploadWithSignedUrl } from './storage/uploadWithSignedUrl';
 export type { SignedUrl, UploadWithSignedUrlParams } from './storage/uploadWithSignedUrl';
 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.uploadWithSignedUrl = exports.RemoteLoggerStream = exports.HttpLogStream = exports.Builders = void 0;
 const Builders = __importStar(require("./builders"));
 exports.Builders = Builders;
 const HttpLogStream_1 = __importDefault(require("./logging/HttpLogStream"));
@@ -53,6 +53,9 @@ Object.defineProperty(exports, "BuildContext", { enumerable: true, get: function
 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/utils/remoteDeviceRunSession.js

@@ -73,7 +73,7 @@ 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_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/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": "22.6.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -103,5 +103,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "3f74ea369d329a363fe16c9f90c8be74cb598777"
+  "gitHead": "89fe2cb3e1bba6e153752f1acf26b7817974b4a4"
 }