@expo/build-tools 20.1.0 → 20.2.0

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

@@ -1,9 +1,36 @@
 import { bunyan } from '@expo/logger';
 import { BuildStepEnv } from '@expo/steps';
+import { z } from 'zod';
 import { CustomBuildContext } from '../../customBuildContext';
 export declare function getDeviceRunSessionIdOrThrow(env: BuildStepEnv): string;
 export declare function getNgrokTunnelDomainOrThrow(env: BuildStepEnv): string;
 export declare function getNgrokAuthtokenOrThrow(env: BuildStepEnv): string;
+declare const TurnIceServersSchema: z.ZodArray<z.ZodObject<{
+    urls: z.ZodArray<z.ZodString>;
+    username: z.ZodOptional<z.ZodString>;
+    credential: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export type TurnIceServers = z.infer<typeof TurnIceServersSchema>;
+/**
+ * Translate Cloudflare ICE servers into serve-sim CLI flags: `--stun-url` (the
+ * credential-less entries) and `--turn-url`/`--turn-username`/`--turn-credential`
+ * (the entry carrying the short-lived credentials).
+ */
+export declare function turnIceServersToServeSimArgs(iceServers: TurnIceServers): string[];
+/**
+ * Fetch short-lived Cloudflare TURN ICE servers for this job run from www
+ * (minted on demand, mirroring how the worker fetches project clone URLs) and
+ * translate them into serve-sim CLI flags.
+ *
+ * Best-effort: on any failure we log and return [] so serve-sim falls back to
+ * its built-in P2P/STUN behavior. The credential is passed to serve-sim as a
+ * process arg and deliberately not logged (turtle-spawn never logs argv and the
+ * worker is single-tenant).
+ */
+export declare function fetchServeSimTurnArgsAsync(ctx: CustomBuildContext, { env, logger }: {
+    env: BuildStepEnv;
+    logger: bunyan;
+}): Promise<string[]>;
 export declare function uploadRemoteSessionConfigAsync({ ctx, deviceRunSessionId, remoteConfig, logger, }: {
     ctx: CustomBuildContext;
     deviceRunSessionId: string;
@@ -19,7 +46,7 @@ export declare function spawnDetached({ command, args, cwd, env, }: {
     cwd?: string;
     env: BuildStepEnv;
 }): DetachedProcessHandle;
-export declare function startServeSimWithTunnelAsync({ baseDomain, env, logger, timeoutMs, }: {
+export declare function startServeSimWithTunnelAsync(ctx: CustomBuildContext, { baseDomain, env, logger, timeoutMs, }: {
     baseDomain: string;
     env: BuildStepEnv;
     logger: bunyan;
@@ -41,3 +68,4 @@ export declare function waitForFileAsync<T>({ filePath, timeoutMs, description,
     description: string;
     parse: (raw: string) => T;
 }): Promise<T>;
+export {};

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -39,6 +39,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDeviceRunSessionIdOrThrow = getDeviceRunSessionIdOrThrow;
 exports.getNgrokTunnelDomainOrThrow = getNgrokTunnelDomainOrThrow;
 exports.getNgrokAuthtokenOrThrow = getNgrokAuthtokenOrThrow;
+exports.turnIceServersToServeSimArgs = turnIceServersToServeSimArgs;
+exports.fetchServeSimTurnArgsAsync = fetchServeSimTurnArgsAsync;
 exports.uploadRemoteSessionConfigAsync = uploadRemoteSessionConfigAsync;
 exports.spawnDetached = spawnDetached;
 exports.startServeSimWithTunnelAsync = startServeSimWithTunnelAsync;
@@ -48,9 +50,13 @@ const eas_build_job_1 = require("@expo/eas-build-job");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
 const ngrok = __importStar(require("@ngrok/ngrok"));
 const gql_tada_1 = require("gql.tada");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const zod_1 = require("zod");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = __importDefault(require("node:fs"));
+const sentry_1 = require("../../sentry");
 const retry_1 = require("../../utils/retry");
+const turtleFetch_1 = require("../../utils/turtleFetch");
 const START_DEVICE_RUN_SESSION_MUTATION = (0, gql_tada_1.graphql)(`
   mutation StartDeviceRunSession($deviceRunSessionId: ID!, $remoteConfig: JSONObject!) {
     deviceRunSession {
@@ -91,6 +97,72 @@ function getNgrokAuthtokenOrThrow(env) {
     }
     return authtoken;
 }
+const TurnIceServersSchema = zod_1.z.array(zod_1.z.object({
+    urls: zod_1.z.array(zod_1.z.string()),
+    username: zod_1.z.string().optional(),
+    credential: zod_1.z.string().optional(),
+}));
+const TurnIceServersResponseSchema = zod_1.z.object({
+    data: zod_1.z.object({
+        iceServers: TurnIceServersSchema,
+    }),
+});
+/**
+ * Translate Cloudflare ICE servers into serve-sim CLI flags: `--stun-url` (the
+ * credential-less entries) and `--turn-url`/`--turn-username`/`--turn-credential`
+ * (the entry carrying the short-lived credentials).
+ */
+function turnIceServersToServeSimArgs(iceServers) {
+    const stunUrls = iceServers
+        .filter(server => !server.username && !server.credential)
+        .flatMap(server => server.urls);
+    const turnServer = iceServers.find(server => server.username && server.credential);
+    const args = [];
+    if (stunUrls.length > 0) {
+        args.push('--stun-url', stunUrls.join(','));
+    }
+    if (turnServer?.username && turnServer.credential && turnServer.urls.length > 0) {
+        args.push('--turn-url', turnServer.urls.join(','), '--turn-username', turnServer.username, '--turn-credential', turnServer.credential);
+    }
+    return args;
+}
+/**
+ * Fetch short-lived Cloudflare TURN ICE servers for this job run from www
+ * (minted on demand, mirroring how the worker fetches project clone URLs) and
+ * translate them into serve-sim CLI flags.
+ *
+ * Best-effort: on any failure we log and return [] so serve-sim falls back to
+ * its built-in P2P/STUN behavior. The credential is passed to serve-sim as a
+ * process arg and deliberately not logged (turtle-spawn never logs argv and the
+ * worker is single-tenant).
+ */
+async function fetchServeSimTurnArgsAsync(ctx, { env, logger }) {
+    try {
+        const deviceRunSessionId = getDeviceRunSessionIdOrThrow(env);
+        const expoApiServerUrl = (0, nullthrows_1.default)(ctx.env.__API_SERVER_URL, '__API_SERVER_URL is not set');
+        const robotAccessToken = (0, nullthrows_1.default)(ctx.job.secrets?.robotAccessToken, 'robot access token is not set');
+        const response = await (0, turtleFetch_1.turtleFetch)(new URL(`/v2/device-run-sessions/${deviceRunSessionId}/turn-ice-servers`, expoApiServerUrl).toString(), 'POST', {
+            headers: {
+                Authorization: `Bearer ${robotAccessToken}`,
+            },
+            timeout: 5000,
+            retries: 1,
+            logger,
+        });
+        const { data } = TurnIceServersResponseSchema.parse(await response.json());
+        const args = turnIceServersToServeSimArgs(data.iceServers);
+        if (args.length > 0) {
+            logger.info('Configured serve-sim with Cloudflare TURN ICE servers.');
+        }
+        return args;
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        sentry_1.Sentry.capture('Could not fetch Cloudflare TURN ICE servers', error, { level: 'warning' });
+        logger.warn({ err: error }, 'Could not fetch Cloudflare TURN ICE servers; serve-sim will fall back to P2P/STUN.');
+        return [];
+    }
+}
 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
@@ -119,8 +191,9 @@ function spawnDetached({ command, args, cwd, env, }) {
     promise.child.stderr?.on('data', appendChunk);
     return { getOutput: () => output };
 }
-async function startServeSimWithTunnelAsync({ baseDomain, env, logger, timeoutMs, }) {
+async function startServeSimWithTunnelAsync(ctx, { baseDomain, env, logger, timeoutMs, }) {
     logger.info('Launching serve-sim with tunnel.');
+    const turnArgs = await fetchServeSimTurnArgsAsync(ctx, { env, logger });
     const serveSim = spawnDetached({
         command: 'npx',
         args: [
@@ -136,6 +209,7 @@ async function startServeSimWithTunnelAsync({ baseDomain, env, logger, timeoutMs
             '0.55',
             '--codec',
             'webrtc',
+            ...turnArgs,
         ],
         env,
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "20.1.0",
+  "version": "20.2.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <support@expo.io>",
@@ -77,7 +77,7 @@
     "zod": "^4.3.5"
   },
   "devDependencies": {
-    "@expo/repack-app": "~0.4.1",
+    "@expo/repack-app": "~0.6.1",
     "@types/fs-extra": "^11.0.4",
     "@types/jest": "^29.5.12",
     "@types/lodash": "^4.17.4",
@@ -100,5 +100,5 @@
     "typescript": "^5.5.4",
     "uuid": "^9.0.1"
   },
-  "gitHead": "33225d2b73a34db5cbdfeaa537aedb6c6b4a84af"
+  "gitHead": "203e9997eebafcbddc600285f6a809afb4a93a74"
 }

package/dist/steps/utils/ios/xcpretty.d.ts

@@ -1,15 +0,0 @@
-import { bunyan } from '@expo/logger';
-export declare class XcodeBuildLogger {
-    private readonly logger;
-    private readonly projectRoot;
-    private loggerError?;
-    private flushing;
-    private logReaderPromise?;
-    private logsPath?;
-    constructor(logger: bunyan, projectRoot: string);
-    watchLogFiles(logsDirectory: string): Promise<void>;
-    flush(): Promise<void>;
-    private getBuildLogFilename;
-    private startBuildLogger;
-    private findBundlerErrors;
-}

package/dist/steps/utils/ios/xcpretty.js

@@ -1,92 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.XcodeBuildLogger = void 0;
-const spawn_async_1 = __importDefault(require("@expo/spawn-async"));
-const xcpretty_1 = require("@expo/xcpretty");
-const assert_1 = __importDefault(require("assert"));
-const fast_glob_1 = __importDefault(require("fast-glob"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const CHECK_FILE_INTERVAL_MS = 1000;
-class XcodeBuildLogger {
-    logger;
-    projectRoot;
-    loggerError;
-    flushing = false;
-    logReaderPromise;
-    logsPath;
-    constructor(logger, projectRoot) {
-        this.logger = logger;
-        this.projectRoot = projectRoot;
-    }
-    async watchLogFiles(logsDirectory) {
-        while (!this.flushing) {
-            const logsFilename = await this.getBuildLogFilename(logsDirectory);
-            if (logsFilename) {
-                this.logsPath = path_1.default.join(logsDirectory, logsFilename);
-                void this.startBuildLogger(this.logsPath);
-                return;
-            }
-            await new Promise(res => setTimeout(res, CHECK_FILE_INTERVAL_MS));
-        }
-    }
-    async flush() {
-        this.flushing = true;
-        if (this.loggerError) {
-            throw this.loggerError;
-        }
-        if (this.logReaderPromise) {
-            this.logReaderPromise.child.kill('SIGINT');
-            try {
-                await this.logReaderPromise;
-            }
-            catch { }
-        }
-        if (this.logsPath) {
-            await this.findBundlerErrors(this.logsPath);
-        }
-    }
-    async getBuildLogFilename(logsDirectory) {
-        const paths = await (0, fast_glob_1.default)('*.log', { cwd: logsDirectory });
-        return paths.length >= 1 ? paths[0] : undefined;
-    }
-    async startBuildLogger(logsPath) {
-        try {
-            const formatter = xcpretty_1.ExpoRunFormatter.create(this.projectRoot, {
-                // TODO: Can provide xcode project name for better parsing
-                isDebug: false,
-            });
-            this.logReaderPromise = (0, spawn_async_1.default)('tail', ['-n', '+0', '-f', logsPath], { stdio: 'pipe' });
-            (0, assert_1.default)(this.logReaderPromise.child.stdout, 'stdout is not available');
-            this.logReaderPromise.child.stdout.on('data', (data) => {
-                const lines = formatter.pipe(data.toString());
-                for (const line of lines) {
-                    this.logger.info(line);
-                }
-            });
-            await this.logReaderPromise;
-            this.logger.info(formatter.getBuildSummary());
-        }
-        catch (err) {
-            if (!this.flushing) {
-                this.loggerError = err;
-            }
-        }
-    }
-    async findBundlerErrors(logsPath) {
-        try {
-            const logFile = await fs_extra_1.default.readFile(logsPath, 'utf-8');
-            const match = logFile.match(/Welcome to Metro!\s* Fast - Scalable - Integrated\s*([\s\S]*)Run CLI with --verbose flag for more details.\nCommand PhaseScriptExecution failed with a nonzero exit code/);
-            if (match) {
-                this.logger.info(match[1]);
-            }
-        }
-        catch (err) {
-            this.logger.error({ err }, 'Failed to read Xcode logs');
-        }
-    }
-}
-exports.XcodeBuildLogger = XcodeBuildLogger;