@expo/build-tools 24.3.0 → 24.5.0

package/dist/steps/utils/sandboxDaemon.js

@@ -7,6 +7,7 @@ exports.startSandboxDaemonAsync = startSandboxDaemonAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
 const promises_1 = require("node:timers/promises");
 const ws_1 = __importDefault(require("ws"));
+const sandboxCommandImplementations_1 = require("./sandboxCommandImplementations");
 async function startSandboxDaemonAsync(options) {
     options.signal?.throwIfAborted();
     let socket;
@@ -14,6 +15,11 @@ async function startSandboxDaemonAsync(options) {
     let hasConnected = false;
     let resolveConnected;
     let rejectConnected;
+    const { commandImplementations, stoppedPromise: commandsStoppedPromise } = (0, sandboxCommandImplementations_1.createSandboxCommandImplementations)({
+        workingDirectory: options.workingDirectory,
+        env: options.env,
+        signal: abortController.signal,
+    });
     const connected = new Promise((resolve, reject) => {
         resolveConnected = resolve;
         rejectConnected = reject;
@@ -26,15 +32,39 @@ async function startSandboxDaemonAsync(options) {
     const connectionLoop = (async () => {
         while (!abortController.signal.aborted) {
             try {
-                socket = new ws_1.default(new URL('/sandbox/connect', options.serverUrl), {
+                const connectedSocket = new ws_1.default(new URL('/sandbox/connect', options.serverUrl), {
                     handshakeTimeout: 10_000,
                     headers: { Authorization: `Bearer ${options.credential}` },
                 });
-                await waitForOpen(socket);
+                socket = connectedSocket;
+                await waitForOpen(connectedSocket);
                 options.logger.info('Sandbox MCP server connected.');
+                connectedSocket.on('message', async (message) => {
+                    try {
+                        const response = await handleMessageAsync(commandImplementations, message.toString());
+                        // MCP fails pending calls on disconnect. Responses belong to this socket only.
+                        if (connectedSocket.readyState !== ws_1.default.OPEN) {
+                            options.logger.warn('Sandbox command response was lost after disconnect. The command may have run and output may have been consumed.');
+                            return;
+                        }
+                        await new Promise((resolve, reject) => {
+                            connectedSocket.send(JSON.stringify(response), error => {
+                                if (error) {
+                                    reject(error);
+                                }
+                                else {
+                                    resolve();
+                                }
+                            });
+                        });
+                    }
+                    catch (error) {
+                        options.logger.warn({ err: error }, 'Could not send sandbox command response.');
+                    }
+                });
                 hasConnected = true;
                 resolveConnected();
-                await waitForClose(socket);
+                await waitForClose(connectedSocket);
             }
             catch (error) {
                 if (!hasConnected) {
@@ -68,6 +98,7 @@ async function startSandboxDaemonAsync(options) {
         async stopAsync() {
             options.signal?.removeEventListener('abort', stop);
             stop();
+            await commandsStoppedPromise;
             await connectionLoop;
         },
     };
@@ -88,3 +119,39 @@ function waitForClose(socket) {
         socket.once('error', reject);
     });
 }
+async function handleMessageAsync(commandImplementations, message) {
+    let rawRequest;
+    try {
+        rawRequest = JSON.parse(message);
+    }
+    catch {
+        return { jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } };
+    }
+    const request = eas_build_job_1.SandboxDaemonRequestZ.safeParse(rawRequest);
+    if (!request.success) {
+        return { jsonrpc: '2.0', id: null, error: { code: -32600, message: 'Invalid request' } };
+    }
+    const { id, method, params } = request.data;
+    if (!Object.hasOwn(eas_build_job_1.SandboxDaemonCommands, method)) {
+        return { jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } };
+    }
+    const commandMethod = method;
+    const parsedParams = eas_build_job_1.SandboxDaemonCommands[commandMethod].params.safeParse(params);
+    if (!parsedParams.success) {
+        return { jsonrpc: '2.0', id, error: { code: -32602, message: 'Invalid params' } };
+    }
+    try {
+        return {
+            jsonrpc: '2.0',
+            id,
+            result: await commandImplementations[commandMethod](parsedParams.data),
+        };
+    }
+    catch (error) {
+        return {
+            jsonrpc: '2.0',
+            id,
+            error: { code: -32603, message: error instanceof Error ? error.message : 'Internal error' },
+        };
+    }
+}

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

@@ -0,0 +1,29 @@
+export declare class ShellSessionManager {
+    private readonly options;
+    private readonly sessions;
+    private nextSessionId;
+    readonly stoppedPromise: Promise<void>;
+    constructor(options: {
+        workingDirectory: string;
+        env: NodeJS.ProcessEnv;
+        signal: AbortSignal;
+    });
+    startAsync({ cmd, workdir, tty, }: {
+        cmd: string;
+        workdir?: string;
+        tty?: boolean;
+    }): Promise<number>;
+    write(sessionId: number, chars: string): void;
+    readAsync(sessionId: number, yieldTimeMs: number): Promise<{
+        output: string;
+    } & ({
+        exitCode: number;
+    } | {
+        terminationSignal: string;
+    } | {
+        sessionId: number;
+    })>;
+    private stopAsync;
+    private throwIfStopped;
+    private getSession;
+}

package/dist/steps/utils/shellSessionManager.js

@@ -0,0 +1,269 @@
+"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.ShellSessionManager = void 0;
+const pty = __importStar(require("node-pty"));
+const node_child_process_1 = require("node:child_process");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const processes_1 = require("../../utils/processes");
+const PROCESS_STOP_GRACE_PERIOD_MS = 1_000;
+const SIGNAL_NAMES = new Map(Object.entries(node_os_1.constants.signals)
+    .reverse()
+    .map(([name, number]) => [number, name]));
+class ShellSessionManager {
+    options;
+    // Keep completed sessions so callers can still read their output and exit status.
+    sessions = new Map();
+    nextSessionId = 1;
+    stoppedPromise;
+    constructor(options) {
+        this.options = options;
+        this.stoppedPromise = (async () => {
+            if (!options.signal.aborted) {
+                await new Promise(resolve => {
+                    options.signal.addEventListener('abort', () => resolve(), { once: true });
+                });
+            }
+            await this.stopAsync();
+        })();
+        // Cleanup can fail before the owner awaits it.
+        this.stoppedPromise.catch(() => { });
+    }
+    async startAsync({ cmd, workdir, tty, }) {
+        this.throwIfStopped();
+        const workingDirectory = workdir
+            ? node_path_1.default.resolve(this.options.workingDirectory, workdir)
+            : this.options.workingDirectory;
+        await validateWorkingDirectoryAsync(workingDirectory);
+        this.throwIfStopped();
+        const sessionId = this.nextSessionId++;
+        const session = tty
+            ? startPtyCommand({ command: cmd, workingDirectory, env: this.options.env })
+            : startPipeCommand({ command: cmd, workingDirectory, env: this.options.env });
+        this.sessions.set(sessionId, session);
+        return sessionId;
+    }
+    write(sessionId, chars) {
+        this.throwIfStopped();
+        const session = this.getSession(sessionId);
+        if (!session.isCompleted && !session.error) {
+            session.write(chars);
+        }
+    }
+    async readAsync(sessionId, yieldTimeMs) {
+        this.throwIfStopped();
+        const session = this.getSession(sessionId);
+        await waitForSessionsAsync([session], yieldTimeMs);
+        if (session.error) {
+            throw session.error;
+        }
+        const output = session.output;
+        session.output = '';
+        const result = {
+            output,
+        };
+        if (session.terminationSignal !== undefined) {
+            return { ...result, terminationSignal: session.terminationSignal };
+        }
+        if (session.exitCode !== undefined) {
+            return { ...result, exitCode: session.exitCode };
+        }
+        return { ...result, sessionId };
+    }
+    async stopAsync() {
+        const sessions = [...this.sessions.values()];
+        // Only signal groups while their leaders are alive. After a leader exits, its PID may
+        // be reused. Any surviving descendants are left to VM teardown.
+        for (const session of sessions) {
+            if (!session.hasLeaderExited) {
+                (0, processes_1.killProcessGroup)(session.process, 'SIGTERM');
+            }
+        }
+        await waitForSessionsAsync(sessions, PROCESS_STOP_GRACE_PERIOD_MS);
+        for (const session of sessions) {
+            if (!session.hasLeaderExited) {
+                (0, processes_1.killProcessGroup)(session.process, 'SIGKILL');
+            }
+        }
+        await waitForSessionsAsync(sessions, PROCESS_STOP_GRACE_PERIOD_MS);
+        this.sessions.clear();
+    }
+    throwIfStopped() {
+        this.options.signal.throwIfAborted();
+    }
+    getSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Command session ${sessionId} does not exist.`);
+        }
+        return session;
+    }
+}
+exports.ShellSessionManager = ShellSessionManager;
+function startPipeCommand({ command, workingDirectory, env, }) {
+    const child = (0, node_child_process_1.spawn)(command, {
+        cwd: workingDirectory,
+        env,
+        shell: env.SHELL ?? true,
+        detached: true,
+    });
+    const session = createSession(child);
+    session.write = (chars) => {
+        child.stdin.write(chars);
+    };
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    child.stdout.on('data', data => {
+        session.output += data;
+    });
+    child.stderr.on('data', data => {
+        session.output += data;
+    });
+    child.stdin.on('error', () => { });
+    child.once('exit', () => {
+        session.hasLeaderExited = true;
+    });
+    child.once('error', error => {
+        if (!session.isCompleted) {
+            session.hasLeaderExited = true;
+            session.isCompleted = true;
+            session.error = error;
+            session.resolveCompleted();
+        }
+    });
+    child.once('close', (exitCode, signal) => {
+        if (!session.isCompleted) {
+            session.isCompleted = true;
+            if (signal) {
+                session.terminationSignal = signal;
+            }
+            else {
+                session.exitCode = exitCode ?? 1;
+            }
+            session.resolveCompleted();
+        }
+    });
+    return session;
+}
+function startPtyCommand({ command, workingDirectory, env, }) {
+    const shell = env.SHELL ?? '/bin/sh';
+    const terminal = pty.spawn(shell, ['-c', command], {
+        cwd: workingDirectory,
+        env,
+        name: 'xterm-256color',
+        cols: 80,
+        rows: 24,
+    });
+    const session = createSession(terminal);
+    session.write = (chars) => {
+        terminal.write(chars);
+    };
+    terminal.onData(data => {
+        session.output += data;
+    });
+    terminal.onExit(({ exitCode, signal }) => {
+        session.hasLeaderExited = true;
+        session.isCompleted = true;
+        if (signal) {
+            session.terminationSignal = SIGNAL_NAMES.get(signal) ?? `SIGNAL_${signal}`;
+        }
+        else {
+            session.exitCode = exitCode;
+        }
+        session.resolveCompleted();
+    });
+    return session;
+}
+function createSession(process) {
+    let resolveCompleted;
+    const completed = new Promise(resolve => {
+        resolveCompleted = resolve;
+    });
+    return {
+        process,
+        completed,
+        resolveCompleted,
+        isCompleted: false,
+        hasLeaderExited: false,
+        output: '',
+        write: () => { },
+    };
+}
+async function validateWorkingDirectoryAsync(workingDirectory) {
+    let stats;
+    try {
+        stats = await promises_1.default.stat(workingDirectory);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT') {
+            throw new Error(`Working directory does not exist: ${workingDirectory}`);
+        }
+        if (error?.code === 'EACCES') {
+            throw new Error(`Working directory is not accessible: ${workingDirectory}`);
+        }
+        throw error;
+    }
+    if (!stats.isDirectory()) {
+        throw new Error(`Working directory is not a directory: ${workingDirectory}`);
+    }
+    try {
+        await promises_1.default.access(workingDirectory, promises_1.default.constants.R_OK | promises_1.default.constants.X_OK);
+    }
+    catch (error) {
+        if (error?.code === 'EACCES') {
+            throw new Error(`Working directory is not accessible: ${workingDirectory}`);
+        }
+        throw error;
+    }
+}
+async function waitForSessionsAsync(sessions, timeoutMs) {
+    let timer;
+    try {
+        await Promise.race([
+            Promise.all(sessions.map(session => session.completed)),
+            new Promise(resolve => {
+                timer = setTimeout(resolve, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/utils/IosSimulatorUtils.d.ts

@@ -52,6 +52,29 @@ export declare namespace IosSimulatorUtils {
         deviceIdentifier: IosSimulatorUuid | IosSimulatorName;
         env: NodeJS.ProcessEnv;
     }): Promise<void>;
+    /**
+     * The UDID for a device name or UDID. A name picks the first available
+     * device with that name, as `simctl` itself does.
+     */
+    export function resolveUdidAsync({ deviceIdentifier, env, }: {
+        deviceIdentifier: IosSimulatorUuid | IosSimulatorName;
+        env: NodeJS.ProcessEnv;
+    }): Promise<IosSimulatorUuid>;
+    /**
+     * Start booting without waiting for boot to complete; follow with
+     * `startAsync` to wait for it. `launchdEnvironment` is handed to the
+     * simulator's launchd before it spawns anything: `simctl` forwards every
+     * `SIMCTL_CHILD_`-prefixed variable of its own environment to the process
+     * it starts, and for `boot` that process is launchd itself. This is the only
+     * way to give the first processes of a boot an environment; `launchctl
+     * setenv` after boot only reaches processes started later. A device that is
+     * already booted keeps its environment.
+     */
+    export function bootAsync({ deviceIdentifier, env, launchdEnvironment, }: {
+        deviceIdentifier: IosSimulatorUuid | IosSimulatorName;
+        env: NodeJS.ProcessEnv;
+        launchdEnvironment?: Record<string, string>;
+    }): Promise<void>;
     export function startAsync({ deviceIdentifier, env, }: {
         deviceIdentifier: IosSimulatorUuid | IosSimulatorName;
         env: NodeJS.ProcessEnv;
@@ -66,6 +89,17 @@ export declare namespace IosSimulatorUtils {
         udid: IosSimulatorUuid;
         env: NodeJS.ProcessEnv;
     }): Promise<void>;
+    /**
+     * Set environment variables in the Simulator's launchd. Every process that
+     * launchd spawns afterwards inherits them: apps launched by SpringBoard
+     * (deep links, taps, WebDriverAgent) as well as by `simctl launch`.
+     * Processes that are already running keep their environment.
+     */
+    export function setLaunchdEnvironmentAsync({ udid, env, variables, }: {
+        udid: IosSimulatorUuid;
+        env: NodeJS.ProcessEnv;
+        variables: Record<string, string>;
+    }): Promise<void>;
     export function collectLogsAsync({ deviceIdentifier, env, }: {
         deviceIdentifier: IosSimulatorName | IosSimulatorUuid;
         env: NodeJS.ProcessEnv;

package/dist/utils/IosSimulatorUtils.js

@@ -87,6 +87,50 @@ var IosSimulatorUtils;
         }
     }
     IosSimulatorUtils.enableAccessibilitySettingsAsync = enableAccessibilitySettingsAsync;
+    const UDID_PATTERN = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
+    /**
+     * The UDID for a device name or UDID. A name picks the first available
+     * device with that name, as `simctl` itself does.
+     */
+    async function resolveUdidAsync({ deviceIdentifier, env, }) {
+        if (UDID_PATTERN.test(deviceIdentifier)) {
+            return deviceIdentifier;
+        }
+        const devices = await getAvailableDevicesAsync({ env, filter: 'available' });
+        const device = devices.find(candidate => candidate.name === deviceIdentifier);
+        if (!device) {
+            throw new eas_build_job_1.UserError('EAS_IOS_SIMULATOR_NOT_FOUND', `No available iOS Simulator is named "${deviceIdentifier}". Run \`xcrun simctl list devices available\` on the device host to see the devices it offers.`);
+        }
+        return device.udid;
+    }
+    IosSimulatorUtils.resolveUdidAsync = resolveUdidAsync;
+    /**
+     * Start booting without waiting for boot to complete; follow with
+     * `startAsync` to wait for it. `launchdEnvironment` is handed to the
+     * simulator's launchd before it spawns anything: `simctl` forwards every
+     * `SIMCTL_CHILD_`-prefixed variable of its own environment to the process
+     * it starts, and for `boot` that process is launchd itself. This is the only
+     * way to give the first processes of a boot an environment; `launchctl
+     * setenv` after boot only reaches processes started later. A device that is
+     * already booted keeps its environment.
+     */
+    async function bootAsync({ deviceIdentifier, env, launchdEnvironment = {}, }) {
+        const bootEnv = { ...env };
+        for (const [name, value] of Object.entries(launchdEnvironment)) {
+            bootEnv[`SIMCTL_CHILD_${name}`] = value;
+        }
+        try {
+            await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'boot', deviceIdentifier], { env: bootEnv, stdio: 'pipe' });
+        }
+        catch (err) {
+            const failed = err;
+            if (/current state: Booted/.test(failed.stderr ?? '')) {
+                return;
+            }
+            throw err;
+        }
+    }
+    IosSimulatorUtils.bootAsync = bootAsync;
     async function startAsync({ deviceIdentifier, env, }) {
         const bootstatusResult = await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'bootstatus', deviceIdentifier, '-b'], {
             env,
@@ -154,6 +198,24 @@ var IosSimulatorUtils;
         throw lastError ?? new eas_build_job_1.SystemError('Unable to disable apsd in the Simulator.');
     }
     IosSimulatorUtils.disableApsdAsync = disableApsdAsync;
+    /**
+     * Set environment variables in the Simulator's launchd. Every process that
+     * launchd spawns afterwards inherits them: apps launched by SpringBoard
+     * (deep links, taps, WebDriverAgent) as well as by `simctl launch`.
+     * Processes that are already running keep their environment.
+     */
+    async function setLaunchdEnvironmentAsync({ udid, env, variables, }) {
+        // One invocation for every variable: each `simctl spawn` costs a few
+        // hundred milliseconds on a device host, and this runs in the window
+        // between `simctl boot` returning and launchd spawning the boot's
+        // processes, which must inherit these.
+        const pairs = Object.entries(variables).flat();
+        if (pairs.length === 0) {
+            return;
+        }
+        await (0, turtle_spawn_1.default)('xcrun', ['simctl', 'spawn', udid, 'launchctl', 'setenv', ...pairs], { env });
+    }
+    IosSimulatorUtils.setLaunchdEnvironmentAsync = setLaunchdEnvironmentAsync;
     async function collectLogsAsync({ deviceIdentifier, env, }) {
         const outputDir = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'ios-simulator-logs-'));
         const outputPath = node_path_1.default.join(outputDir, `${deviceIdentifier}.logarchive`);

package/dist/utils/processes.d.ts

@@ -4,6 +4,9 @@ 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 killProcessGroup(child: {
+    pid?: number;
+    kill(signal?: NodeJS.Signals): void;
+}, signal?: NodeJS.Signals): void;
 export declare function getParentAndDescendantProcessPidsAsync(ppid: number): Promise<number[]>;
 export declare function isProcessDescendantOfAsync(pid: number, ancestorPid: number): Promise<boolean>;

package/dist/utils/processes.js

@@ -15,15 +15,18 @@ function isChildProcessAlive(child) {
  * 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) {
+function killProcessGroup(child, signal = 'SIGTERM') {
     if (child.pid == null) {
         return;
     }
     try {
-        process.kill(-child.pid, 'SIGTERM');
+        process.kill(-child.pid, signal);
     }
-    catch {
-        child.kill();
+    catch (error) {
+        // ESRCH means the process group no longer exists, so there is nothing left to stop.
+        if (error?.code !== 'ESRCH') {
+            child.kill(signal);
+        }
     }
 }
 async function getChildrenPidsAsync(parentPids) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "24.3.0",
+  "version": "24.5.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -24,6 +24,8 @@
     "prebuild": "yarn gql",
     "build": "tsc",
     "build:record-sim": "mkdir -p bin && record_sim_bin_path=$(swift build -c release --package-path resources/record-sim --build-path resources/record-sim/.build --show-bin-path) && swift build -c release --package-path resources/record-sim --build-path resources/record-sim/.build && cp \"$record_sim_bin_path/record-sim\" bin/record-sim && chmod +x bin/record-sim",
+    "build:egress-guard": "resources/egress-guard/build.sh",
+    "test:egress-guard": "resources/egress-guard/tests/run-policy-tests.sh && resources/egress-guard/tests/run-guard-tests.sh",
     "typecheck": "tsc",
     "generate-appium-commands": "mise exec node@22.22.0 -- node scripts/generate-appium-commands.js",
     "prepack": "rimraf dist \"*.tsbuildinfo\" && yarn gql && tsc -p tsconfig.build.json",
@@ -40,14 +42,14 @@
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
     "@expo/downloader": "24.0.0",
-    "@expo/eas-build-job": "24.3.0",
+    "@expo/eas-build-job": "24.5.0",
     "@expo/env": "^0.4.0",
     "@expo/logger": "24.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": "24.3.0",
+    "@expo/steps": "24.5.0",
     "@expo/template-file": "24.0.0",
     "@expo/turtle-spawn": "24.0.0",
     "@expo/xcpretty": "^4.3.1",
@@ -65,6 +67,7 @@
     "lodash": "^4.18.1",
     "node-fetch": "^2.7.0",
     "node-forge": "^1.3.1",
+    "node-pty": "1.2.0-beta.15",
     "node-stream-zip": "1.15.0",
     "nullthrows": "^1.1.1",
     "plist": "^3.1.0",
@@ -104,5 +107,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "66cdccb0e7c3ec47054c3f093c25b9799d60ff36"
+  "gitHead": "43068db22a079c67198fc7f7ccb5e85286ba3207"
 }