@expo/build-tools 24.4.0 → 24.5.0

package/dist/steps/functions/startSandbox.js

@@ -31,8 +31,9 @@ function createStartSandboxBuildFunction(ctx) {
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
         ],
-        fn: async (stepCtx, { inputs, signal }) => {
-            const sandboxToken = ctx.env.__EAS_SANDBOX_MCP_TOKEN;
+        fn: async (stepCtx, { inputs, signal, env }) => {
+            // The daemon needs this credential, but shell commands do not.
+            const { __EAS_SANDBOX_MCP_TOKEN: sandboxToken, ...commandEnv } = env;
             if (!sandboxToken) {
                 throw new eas_build_job_1.SystemError('__EAS_SANDBOX_MCP_TOKEN is required to start the sandbox daemon.');
             }
@@ -47,6 +48,8 @@ function createStartSandboxBuildFunction(ctx) {
                 reconnectDelayMs: RECONNECT_DELAY_MS,
                 logger: stepCtx.logger,
                 signal,
+                workingDirectory: stepCtx.workingDirectory,
+                env: commandEnv,
             });
             try {
                 await daemon.ready;

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

@@ -0,0 +1,12 @@
+import { type SandboxDaemonCommandParams, type SandboxDaemonCommandResult, type SandboxDaemonMethod } from '@expo/eas-build-job';
+export type SandboxDaemonCommandImplementations = {
+    [Method in SandboxDaemonMethod]: (params: SandboxDaemonCommandParams<Method>) => Promise<SandboxDaemonCommandResult<Method>>;
+};
+export declare function createSandboxCommandImplementations({ workingDirectory, env, signal, }: {
+    workingDirectory: string;
+    env: NodeJS.ProcessEnv;
+    signal: AbortSignal;
+}): {
+    commandImplementations: SandboxDaemonCommandImplementations;
+    stoppedPromise: Promise<void>;
+};

package/dist/steps/utils/sandboxCommandImplementations.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSandboxCommandImplementations = createSandboxCommandImplementations;
+const node_perf_hooks_1 = require("node:perf_hooks");
+const shellSessionManager_1 = require("./shellSessionManager");
+const DEFAULT_EXEC_YIELD_TIME_MS = 10_000;
+const DEFAULT_WRITE_YIELD_TIME_MS = 250;
+function createSandboxCommandImplementations({ workingDirectory, env, signal, }) {
+    const sessions = new shellSessionManager_1.ShellSessionManager({ workingDirectory, env, signal });
+    return {
+        commandImplementations: {
+            async execCommand(params) {
+                const callStartedAt = node_perf_hooks_1.performance.now();
+                const sessionId = await sessions.startAsync({
+                    cmd: params.cmd,
+                    workdir: params.workdir,
+                    tty: params.tty,
+                });
+                const result = await sessions.readAsync(sessionId, params.yieldTimeMs ?? DEFAULT_EXEC_YIELD_TIME_MS);
+                return { ...result, wallTimeSeconds: (node_perf_hooks_1.performance.now() - callStartedAt) / 1_000 };
+            },
+            async writeStdin(params) {
+                const callStartedAt = node_perf_hooks_1.performance.now();
+                if (params.chars !== undefined) {
+                    sessions.write(params.sessionId, params.chars);
+                }
+                const result = await sessions.readAsync(params.sessionId, params.yieldTimeMs ?? DEFAULT_WRITE_YIELD_TIME_MS);
+                return { ...result, wallTimeSeconds: (node_perf_hooks_1.performance.now() - callStartedAt) / 1_000 };
+            },
+        },
+        stoppedPromise: sessions.stoppedPromise,
+    };
+}

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

@@ -5,6 +5,8 @@ export interface SandboxDaemonOptions {
     reconnectDelayMs: number;
     logger: bunyan;
     signal?: AbortSignal;
+    workingDirectory: string;
+    env: NodeJS.ProcessEnv;
 }
 export interface SandboxDaemon {
     ready: Promise<void>;

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/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.4.0",
+  "version": "24.5.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -42,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",
@@ -67,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",
@@ -106,5 +107,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "e7efe143366b0c908814e61dd3fb4b207600b773"
+  "gitHead": "43068db22a079c67198fc7f7ccb5e85286ba3207"
 }