@expo/build-tools 18.12.0 → 18.12.1

package/dist/steps/easFunctions.js

@@ -41,6 +41,7 @@ const startAgentDeviceRemoteSession_1 = require("./functions/startAgentDeviceRem
 const startAndroidEmulator_1 = require("./functions/startAndroidEmulator");
 const startCuttlefishDevice_1 = require("./functions/startCuttlefishDevice");
 const startIosSimulator_1 = require("./functions/startIosSimulator");
+const startServeSimRemoteSession_1 = require("./functions/startServeSimRemoteSession");
 const uploadArtifact_1 = require("./functions/uploadArtifact");
 const uploadToAsc_1 = require("./functions/uploadToAsc");
 const useNpmToken_1 = require("./functions/useNpmToken");
@@ -79,6 +80,7 @@ function getEasFunctions(ctx) {
         (0, startAndroidEmulator_1.createStartAndroidEmulatorBuildFunction)(),
         (0, startCuttlefishDevice_1.createStartCuttlefishDeviceBuildFunction)(),
         (0, startIosSimulator_1.createStartIosSimulatorBuildFunction)(),
+        (0, startServeSimRemoteSession_1.createStartServeSimRemoteSessionBuildFunction)(ctx),
         (0, installMaestro_1.createInstallMaestroBuildFunction)(),
         (0, installPods_1.createInstallPodsBuildFunction)(),
         (0, sendSlackMessage_1.createSendSlackMessageFunction)(),

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -4,37 +4,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStartAgentDeviceRemoteSessionBuildFunction = createStartAgentDeviceRemoteSessionBuildFunction;
+const eas_build_job_1 = require("@expo/eas-build-job");
 const steps_1 = require("@expo/steps");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
-const gql_tada_1 = require("gql.tada");
-const node_child_process_1 = __importDefault(require("node:child_process"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const retry_1 = require("../../utils/retry");
-const eas_build_job_1 = require("@expo/eas-build-job");
+const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
 const AGENT_DEVICE_REPO_URL = 'https://github.com/callstackincubator/agent-device.git';
 const SRC_DIR = '/tmp/agent-device-src';
-const RUN_DIR = '/tmp/agent-device';
-const DAEMON_LOG = node_path_1.default.join(RUN_DIR, 'daemon.log');
-const TUNNEL_LOG = node_path_1.default.join(RUN_DIR, 'cloudflared.log');
 const DAEMON_JSON_PATH = node_path_1.default.join(node_os_1.default.homedir(), '.agent-device', 'daemon.json');
 const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
 const CLOUDFLARED_LINUX_INSTALL_PATH = '/usr/local/bin/cloudflared';
 const STARTUP_TIMEOUT_MS = 60_000;
-const START_DEVICE_RUN_SESSION_MUTATION = (0, gql_tada_1.graphql)(`
-  mutation StartDeviceRunSession($deviceRunSessionId: ID!, $remoteConfig: JSONObject!) {
-    deviceRunSession {
-      startDeviceRunSession(
-        deviceRunSessionId: $deviceRunSessionId
-        remoteConfig: $remoteConfig
-      ) {
-        id
-        status
-      }
-    }
-  }
-`);
 function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
     return new steps_1.BuildFunction({
         namespace: 'eas',
@@ -52,17 +35,10 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
             // Fail fast before any expensive setup if the orchestrator-injected
             // DEVICE_RUN_SESSION_ID env var is missing — without it we cannot
             // report the remote config back to the API server.
-            const deviceRunSessionId = env.DEVICE_RUN_SESSION_ID;
-            if (!deviceRunSessionId) {
-                throw new eas_build_job_1.SystemError('DEVICE_RUN_SESSION_ID is not set. ' +
-                    'This step must run as part of a device run session created by the API server, ' +
-                    'which injects DEVICE_RUN_SESSION_ID into the job environment.');
-            }
+            const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
             const packageVersion = inputs.package_version.value;
             const { runtimePlatform } = global;
             logger.info(`Starting agent-device remote session (version: ${packageVersion ?? 'latest'}, runtime: ${runtimePlatform}).`);
-            logger.info(`Preparing runtime directory at ${RUN_DIR}.`);
-            await node_fs_1.default.promises.mkdir(RUN_DIR, { recursive: true });
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
                 logger.info(`Selecting Xcode developer directory: ${XCODE_DEVELOPER_DIR}.`);
                 await (0, turtle_spawn_1.default)('sudo', ['xcode-select', '-s', XCODE_DEVELOPER_DIR], { env, logger });
@@ -83,13 +59,12 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 env,
                 logger,
             });
-            logger.info(`Launching agent-device daemon (log file: ${DAEMON_LOG}).`);
-            await spawnDetachedAsync({
-                command: 'bun run src/daemon.ts',
+            logger.info('Launching agent-device daemon.');
+            (0, remoteDeviceRunSession_1.spawnDetached)({
+                command: 'bun',
+                args: ['run', 'src/daemon.ts'],
                 cwd: SRC_DIR,
-                logFile: DAEMON_LOG,
                 env: { ...env, AGENT_DEVICE_DAEMON_SERVER_MODE: 'http' },
-                logger,
             });
             logger.info(`Waiting for daemon credentials at ${DAEMON_JSON_PATH}.`);
             await waitForFileAsync({
@@ -99,31 +74,26 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
             });
             const { port: daemonPort, token: daemonToken } = readDaemonInfo(DAEMON_JSON_PATH);
             logger.info(`Daemon is listening on port ${daemonPort}; loaded auth token.`);
-            logger.info(`Starting cloudflared tunnel to http://localhost:${daemonPort} (log file: ${TUNNEL_LOG}).`);
-            await spawnDetachedAsync({
-                command: `${cloudflaredCommand} tunnel --url "http://localhost:${daemonPort}"`,
-                logFile: TUNNEL_LOG,
+            logger.info(`Starting cloudflared tunnel to http://localhost:${daemonPort}.`);
+            const cloudflared = (0, remoteDeviceRunSession_1.spawnDetached)({
+                command: cloudflaredCommand,
+                args: ['tunnel', '--url', `http://localhost:${daemonPort}`],
                 env,
-                logger,
             });
             logger.info('Waiting for a public tunnel URL.');
-            const tunnelUrl = await waitForMatchInLogAsync({
-                logFile: TUNNEL_LOG,
+            const tunnelUrl = await waitForMatchInOutputAsync({
+                process: cloudflared,
                 pattern: /https:\/\/[a-z0-9-]+\.trycloudflare\.com/,
                 timeoutMs: STARTUP_TIMEOUT_MS,
                 description: 'cloudflared tunnel',
             });
             logger.info(`Tunnel is ready at ${tunnelUrl}.`);
-            logger.info(`Reporting agent-device remote config to the API server (device run session: ${deviceRunSessionId}).`);
-            const result = await ctx.graphqlClient
-                .mutation(START_DEVICE_RUN_SESSION_MUTATION, {
+            await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
+                ctx,
                 deviceRunSessionId,
                 remoteConfig: { url: tunnelUrl, token: daemonToken },
-            })
-                .toPromise();
-            if (result.error) {
-                throw new eas_build_job_1.SystemError(`Failed to start device run session ${deviceRunSessionId}: ${result.error.message}`);
-            }
+                logger,
+            });
             logger.info('Remote session is live. Keeping the job alive until the session is stopped.');
             // Keep the turtle job alive so the daemon and tunnel stay reachable
             // until stopDeviceRunSession cancels the run.
@@ -133,7 +103,7 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
 }
 async function ensureCloudflaredInstalledAsync({ runtimePlatform, env, logger, }) {
     if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
-        await ensureBrewPackageInstalledAsync({ name: 'cloudflared', env, logger });
+        await (0, remoteDeviceRunSession_1.ensureBrewPackageInstalledAsync)({ name: 'cloudflared', env, logger });
         return 'cloudflared';
     }
     if (await isCommandAvailableAsync({ command: 'cloudflared', env })) {
@@ -158,10 +128,7 @@ function cloudflaredLinuxArchForNodeArch(arch) {
     if (arch === 'arm64') {
         return 'arm64';
     }
-    throw new Error(`Unsupported architecture for cloudflared on Linux: "${arch}". Expected "x64" or "arm64".`);
-}
-async function ensureBrewPackageInstalledAsync({ name, env, logger, }) {
-    await (0, turtle_spawn_1.default)('bash', ['-c', `command -v ${name} >/dev/null 2>&1 || HOMEBREW_NO_AUTO_UPDATE=1 brew install ${name}`], { env, logger });
+    throw new eas_build_job_1.SystemError(`Unsupported architecture for cloudflared on Linux: "${arch}". Expected "x64" or "arm64".`);
 }
 async function isCommandAvailableAsync({ command, env, }) {
     try {
@@ -179,40 +146,16 @@ async function cloneAgentDeviceAsync({ packageVersion, env, logger, }) {
         logger,
     });
 }
-async function spawnDetachedAsync({ command, cwd, logFile, env, logger, }) {
-    // Launch the process fully detached so this function returns immediately and
-    // the grandchild survives the step. Stdio goes to a log file so the daemon
-    // output can be polled, and we unref so Node doesn't wait on it.
-    const fd = node_fs_1.default.openSync(logFile, 'a');
-    try {
-        const child = node_child_process_1.default.spawn('bash', ['-c', command], {
-            cwd,
-            env,
-            detached: true,
-            stdio: ['ignore', fd, fd],
-        });
-        if (!child.pid) {
-            throw new Error(`Failed to spawn detached process: ${command}`);
-        }
-        child.unref();
-        logger.info(`Started detached process (pid ${child.pid}).`);
-    }
-    finally {
-        node_fs_1.default.closeSync(fd);
-    }
-}
-async function waitForMatchInLogAsync({ logFile, pattern, timeoutMs, description, }) {
+async function waitForMatchInOutputAsync({ process, pattern, timeoutMs, description, }) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        const content = await readFileOrEmptyAsync(logFile);
-        const match = pattern.exec(content);
+        const match = pattern.exec(process.getOutput());
         if (match) {
             return match[1] ?? match[0];
         }
         await (0, retry_1.sleepAsync)(1_000);
     }
-    const tail = await readFileOrEmptyAsync(logFile);
-    throw new Error(`Timed out waiting for ${description} to start. Last log contents:\n${tail || '<empty>'}`);
+    throw new eas_build_job_1.SystemError(`Timed out waiting for ${description} to start. Last output:\n${process.getOutput() || '<empty>'}`);
 }
 async function waitForFileAsync({ filePath, timeoutMs, description, }) {
     const deadline = Date.now() + timeoutMs;
@@ -226,15 +169,7 @@ async function waitForFileAsync({ filePath, timeoutMs, description, }) {
         }
         await (0, retry_1.sleepAsync)(1_000);
     }
-    throw new Error(`Timed out waiting for ${description} to write ${filePath}.`);
-}
-async function readFileOrEmptyAsync(filePath) {
-    try {
-        return await node_fs_1.default.promises.readFile(filePath, 'utf8');
-    }
-    catch {
-        return '';
-    }
+    throw new eas_build_job_1.SystemError(`Timed out waiting for ${description} to write ${filePath}.`);
 }
 function readDaemonInfo(filePath) {
     const raw = node_fs_1.default.readFileSync(filePath, 'utf8');
@@ -243,7 +178,7 @@ function readDaemonInfo(filePath) {
         typeof parsed !== 'object' ||
         typeof parsed.httpPort !== 'number' ||
         typeof parsed.token !== 'string') {
-        throw new Error(`Expected ${filePath} to contain { "httpPort": <number>, "token": "..." }.`);
+        throw new eas_build_job_1.SystemError(`Expected ${filePath} to contain { "httpPort": <number>, "token": "..." }.`);
     }
     const { httpPort, token } = parsed;
     return { port: httpPort, token };

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

@@ -0,0 +1,3 @@
+import { BuildFunction } from '@expo/steps';
+import { CustomBuildContext } from '../../customBuildContext';
+export declare function createStartServeSimRemoteSessionBuildFunction(ctx: CustomBuildContext): BuildFunction;

package/dist/steps/functions/startServeSimRemoteSession.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStartServeSimRemoteSessionBuildFunction = createStartServeSimRemoteSessionBuildFunction;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const retry_1 = require("../../utils/retry");
+const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
+const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
+const STARTUP_TIMEOUT_MS = 60_000;
+const TRYCLOUDFLARE_URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
+function createStartServeSimRemoteSessionBuildFunction(ctx) {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'start_serve_sim_remote_session',
+        name: 'Start serve-sim remote session',
+        __metricsId: 'eas/start_serve_sim_remote_session',
+        supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
+        fn: async ({ logger }, { env }) => {
+            const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
+            logger.info('Starting serve-sim remote session.');
+            logger.info(`Selecting Xcode developer directory: ${XCODE_DEVELOPER_DIR}.`);
+            await (0, turtle_spawn_1.default)('sudo', ['xcode-select', '-s', XCODE_DEVELOPER_DIR], { env, logger });
+            logger.info('Ensuring cloudflared is installed.');
+            await (0, remoteDeviceRunSession_1.ensureBrewPackageInstalledAsync)({ name: 'cloudflared', env, logger });
+            logger.info('Launching serve-sim with tunnel.');
+            const serveSim = (0, remoteDeviceRunSession_1.spawnDetached)({
+                command: 'npx',
+                args: ['serve-sim-szdziedzic@latest', '--tunnel'],
+                env,
+            });
+            logger.info('Waiting for serve-sim to report tunnel and stream URLs.');
+            const { previewUrl, streamUrl } = await waitForServeSimUrlsAsync({
+                serveSim,
+                timeoutMs: STARTUP_TIMEOUT_MS,
+            });
+            logger.info(`Preview URL: ${previewUrl}`);
+            logger.info(`Stream URL: ${streamUrl}`);
+            await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
+                ctx,
+                deviceRunSessionId,
+                remoteConfig: { previewUrl, streamUrl },
+                logger,
+            });
+            logger.info('Remote session is live. Keeping the job alive until the session is stopped.');
+            // Keep the turtle job alive so the serve-sim tunnel stays reachable
+            // until stopDeviceRunSession cancels the run.
+            await new Promise(() => { });
+        },
+    });
+}
+async function waitForServeSimUrlsAsync({ serveSim, timeoutMs, }) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const output = serveSim.getOutput();
+        const previewUrl = matchLabeledUrl(output, 'Tunnel');
+        const streamUrl = matchLabeledUrl(output, 'Stream');
+        if (previewUrl && streamUrl) {
+            return { previewUrl, streamUrl };
+        }
+        await (0, retry_1.sleepAsync)(1_000);
+    }
+    throw new eas_build_job_1.SystemError(`Timed out waiting for serve-sim to report Tunnel and Stream URLs. Last output:\n${serveSim.getOutput() || '<empty>'}`);
+}
+function matchLabeledUrl(content, label) {
+    const labelPattern = new RegExp(`${label}:\\s*(${TRYCLOUDFLARE_URL_PATTERN.source})`);
+    const match = labelPattern.exec(content);
+    return match ? match[1] : null;
+}

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

@@ -0,0 +1,24 @@
+import { bunyan } from '@expo/logger';
+import { BuildStepEnv } from '@expo/steps';
+import { CustomBuildContext } from '../../customBuildContext';
+export declare function getDeviceRunSessionIdOrThrow(env: BuildStepEnv): string;
+export declare function uploadRemoteSessionConfigAsync({ ctx, deviceRunSessionId, remoteConfig, logger, }: {
+    ctx: CustomBuildContext;
+    deviceRunSessionId: string;
+    remoteConfig: Record<string, unknown>;
+    logger: bunyan;
+}): Promise<void>;
+export declare function ensureBrewPackageInstalledAsync({ name, env, logger, }: {
+    name: string;
+    env: BuildStepEnv;
+    logger: bunyan;
+}): Promise<void>;
+export type DetachedProcessHandle = {
+    getOutput: () => string;
+};
+export declare function spawnDetached({ command, args, cwd, env, }: {
+    command: string;
+    args: string[];
+    cwd?: string;
+    env: BuildStepEnv;
+}): DetachedProcessHandle;

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeviceRunSessionIdOrThrow = getDeviceRunSessionIdOrThrow;
+exports.uploadRemoteSessionConfigAsync = uploadRemoteSessionConfigAsync;
+exports.ensureBrewPackageInstalledAsync = ensureBrewPackageInstalledAsync;
+exports.spawnDetached = spawnDetached;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const gql_tada_1 = require("gql.tada");
+const START_DEVICE_RUN_SESSION_MUTATION = (0, gql_tada_1.graphql)(`
+  mutation StartDeviceRunSession($deviceRunSessionId: ID!, $remoteConfig: JSONObject!) {
+    deviceRunSession {
+      startDeviceRunSession(
+        deviceRunSessionId: $deviceRunSessionId
+        remoteConfig: $remoteConfig
+      ) {
+        id
+        status
+      }
+    }
+  }
+`);
+function getDeviceRunSessionIdOrThrow(env) {
+    const deviceRunSessionId = env.DEVICE_RUN_SESSION_ID;
+    if (!deviceRunSessionId) {
+        throw new eas_build_job_1.SystemError('DEVICE_RUN_SESSION_ID is not set. ' +
+            'This step must run as part of a device run session created by the API server, ' +
+            'which injects DEVICE_RUN_SESSION_ID into the job environment.');
+    }
+    return deviceRunSessionId;
+}
+async function uploadRemoteSessionConfigAsync({ ctx, deviceRunSessionId, remoteConfig, logger, }) {
+    logger.info(`Reporting remote config to the API server (device run session: ${deviceRunSessionId}).`);
+    const result = await ctx.graphqlClient
+        .mutation(START_DEVICE_RUN_SESSION_MUTATION, { deviceRunSessionId, remoteConfig })
+        .toPromise();
+    if (result.error) {
+        throw new eas_build_job_1.SystemError(`Failed to start device run session ${deviceRunSessionId}: ${result.error.message}`);
+    }
+}
+async function ensureBrewPackageInstalledAsync({ name, env, logger, }) {
+    await (0, turtle_spawn_1.default)('bash', ['-c', `command -v ${name} >/dev/null 2>&1 || HOMEBREW_NO_AUTO_UPDATE=1 brew install ${name}`], { env, logger });
+}
+function spawnDetached({ command, args, cwd, env, }) {
+    const promise = (0, turtle_spawn_1.default)(command, args, {
+        cwd,
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        detached: true,
+    });
+    // We don't await the process — it should outlive this step. Failures show
+    // up in the captured output; suppress unhandled rejections here.
+    promise.catch(() => { });
+    promise.child.unref();
+    let output = '';
+    const appendChunk = (chunk) => {
+        output += chunk.toString();
+    };
+    promise.child.stdout?.on('data', appendChunk);
+    promise.child.stderr?.on('data', appendChunk);
+    return { getOutput: () => output };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "18.12.0",
+  "version": "18.12.1",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -98,5 +98,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "53d294330de9c63eb792f646c0603224def9a1b0"
+  "gitHead": "f46b469267f4f87be6a6d1acff22464c8cf89b26"
 }