@expo/build-tools 20.1.0 → 20.3.0

package/dist/steps/functions/startArgentRemoteSession.js

@@ -4,19 +4,25 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStartArgentRemoteSessionBuildFunction = createStartArgentRemoteSessionBuildFunction;
+exports.warnIfArgentPackageVersionCannotBeVerified = warnIfArgentPackageVersionCannotBeVerified;
 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 node_fs_1 = __importDefault(require("node:fs"));
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
+const semver_1 = __importDefault(require("semver"));
 const zod_1 = require("zod");
 const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
 const ARGENT_PACKAGE_NAME = '@swmansion/argent';
+const MIN_ARGENT_REMOTE_SESSION_VERSION = '0.11.0';
 const ARGENT_STATE_FILE = node_path_1.default.join(node_os_1.default.homedir(), '.argent', 'tool-server.json');
 const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
 const STARTUP_TIMEOUT_MS = 60_000;
-const ArgentToolServerStateSchema = zod_1.z.object({ port: zod_1.z.number() });
+const ArgentToolServerStateSchema = zod_1.z.object({
+    port: zod_1.z.number(),
+    token: zod_1.z.string().optional(),
+});
 function createStartArgentRemoteSessionBuildFunction(ctx) {
     return new steps_1.BuildFunction({
         namespace: 'eas',
@@ -39,6 +45,7 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
             const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
             const ngrokAuthtoken = (0, remoteDeviceRunSession_1.getNgrokAuthtokenOrThrow)(env);
             const packageVersion = inputs.package_version.value;
+            warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger });
             const versionSpec = packageVersion ?? 'latest';
             const { runtimePlatform } = global;
             logger.info(`Starting argent remote session (version: ${versionSpec}, runtime: ${runtimePlatform}).`);
@@ -48,36 +55,52 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
             }
             // Stale state from a previous run would mask the new server's port.
             await node_fs_1.default.promises.rm(ARGENT_STATE_FILE, { force: true });
-            logger.info(`Launching ${ARGENT_PACKAGE_NAME}@${versionSpec} via bunx.`);
-            // `argent mcp` is the public entry that triggers @argent/tools-client
-            // to spawn the tool-server detached + unref'd, so the tool-server
-            // outlives this MCP process. ARGENT_IDLE_TIMEOUT_MINUTES=0 disables the
-            // 30-min idle shutdown that would otherwise tear the tunnel down.
-            (0, remoteDeviceRunSession_1.spawnDetached)({
+            logger.info(`Launching ${ARGENT_PACKAGE_NAME}@${versionSpec} tool-server via bunx.`);
+            const argentServer = (0, remoteDeviceRunSession_1.spawnDetached)({
                 command: 'bunx',
-                args: [`${ARGENT_PACKAGE_NAME}@${versionSpec}`, 'mcp'],
-                env: { ...env, ARGENT_IDLE_TIMEOUT_MINUTES: '0' },
+                args: [
+                    `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
+                    'server',
+                    'start',
+                    '--port',
+                    '0',
+                    '--idle-timeout',
+                    '0',
+                    '--detach',
+                ],
+                env,
             });
             logger.info(`Waiting for argent tool-server state at ${ARGENT_STATE_FILE}.`);
-            const { port: toolServerPort } = await (0, remoteDeviceRunSession_1.waitForFileAsync)({
-                filePath: ARGENT_STATE_FILE,
-                timeoutMs: STARTUP_TIMEOUT_MS,
-                description: 'argent tool-server state',
-                parse: parseArgentToolServerState,
-            });
+            let toolServerPort;
+            let toolServerToken;
+            try {
+                const toolServerState = await (0, remoteDeviceRunSession_1.waitForFileAsync)({
+                    filePath: ARGENT_STATE_FILE,
+                    timeoutMs: STARTUP_TIMEOUT_MS,
+                    description: 'argent tool-server state',
+                    parse: parseArgentToolServerState,
+                });
+                toolServerPort = toolServerState.port;
+                toolServerToken = toolServerState.token;
+            }
+            catch (err) {
+                const output = argentServer.getOutput();
+                throw new eas_build_job_1.SystemError(`${err instanceof Error ? err.message : `Timed out waiting for argent tool-server state.`}${output ? `\nArgent tool-server output:\n${output}` : ''}`);
+            }
             logger.info(`Argent tool-server is listening on port ${toolServerPort}.`);
-            const toolsUrl = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
+            const publicToolsUrl = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
                 port: toolServerPort,
                 subdomainPrefix: 'argent',
                 baseDomain: ngrokTunnelDomain,
                 authtoken: ngrokAuthtoken,
+                rewriteHostHeader: true,
                 logger,
             });
-            logger.info(`Tunnel is ready at ${toolsUrl}.`);
+            logger.info(`Tunnel is ready at ${publicToolsUrl}.`);
             // serve-sim is iOS-only — Android sessions go without a preview URL.
             let webPreviewUrl;
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
-                const serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)({
+                const serveSim = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
                     baseDomain: ngrokTunnelDomain,
                     env,
                     logger,
@@ -90,7 +113,8 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 ctx,
                 deviceRunSessionId,
                 remoteConfig: {
-                    toolsUrl,
+                    toolsUrl: publicToolsUrl,
+                    ...(toolServerToken ? { toolsAuthToken: toolServerToken } : {}),
                     ...(webPreviewUrl ? { webPreviewUrl } : {}),
                 },
                 logger,
@@ -102,6 +126,23 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
         },
     });
 }
+function warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger, }) {
+    if (!packageVersion || packageVersion === 'latest') {
+        return;
+    }
+    const validVersion = semver_1.default.valid(packageVersion);
+    if (!validVersion) {
+        logger.warn(`Argent remote simulator sessions require ${ARGENT_PACKAGE_NAME}@${MIN_ARGENT_REMOTE_SESSION_VERSION} or newer, ` +
+            `but package_version "${packageVersion}" is not an exact semver version that EAS can verify. ` +
+            `Continuing and letting bunx resolve it.`);
+        return;
+    }
+    if (semver_1.default.lt(validVersion, MIN_ARGENT_REMOTE_SESSION_VERSION)) {
+        throw new eas_build_job_1.SystemError(`Argent remote simulator sessions require ${ARGENT_PACKAGE_NAME}@${MIN_ARGENT_REMOTE_SESSION_VERSION} or newer. ` +
+            `The requested package_version "${packageVersion}" is too old for the EAS remote-session API. ` +
+            `Use "latest" or pass an exact version >= ${MIN_ARGENT_REMOTE_SESSION_VERSION}.`);
+    }
+}
 function parseArgentToolServerState(raw) {
     const result = ArgentToolServerStateSchema.safeParse(JSON.parse(raw));
     if (!result.success) {

package/dist/steps/functions/startServeSimRemoteSession.js

@@ -22,7 +22,7 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
             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 });
-            const { previewUrl, streamUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)({
+            const { previewUrl, streamUrl } = await (0, remoteDeviceRunSession_1.startServeSimWithTunnelAsync)(ctx, {
                 baseDomain: ngrokTunnelDomain,
                 env,
                 logger,

package/dist/steps/functions/uploadArtifact.js

@@ -112,7 +112,7 @@ function createUploadArtifactBuildFunction(ctx) {
             }
             catch (error) {
                 if (inputs.ignore_error.value) {
-                    logger.error(`Failed to upload ${artifact.type}. Ignoring error.`, error);
+                    logger.error({ err: error }, `Failed to upload ${artifact.type}. Ignoring error.`);
                     // Ignoring error.
                     return;
                 }

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

@@ -7,8 +7,8 @@ exports.runFastlaneGym = runFastlaneGym;
 exports.runFastlane = runFastlane;
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
 const path_1 = __importDefault(require("path"));
-const xcpretty_1 = require("./xcpretty");
 const fastlane_1 = require("../../../common/fastlane");
+const xcpretty_1 = require("../../../common/xcpretty");
 async function runFastlaneGym({ workingDir, logger, buildLogsDirectory, env, extraEnv, }) {
     const buildLogger = new xcpretty_1.XcodeBuildLogger(logger, workingDir);
     void buildLogger.watchLogFiles(buildLogsDirectory);

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;
@@ -28,11 +55,12 @@ export declare function startServeSimWithTunnelAsync({ baseDomain, env, logger,
     previewUrl: string;
     streamUrl: string;
 }>;
-export declare function startNgrokTunnelAsync({ port, subdomainPrefix, baseDomain, authtoken, logger, }: {
+export declare function startNgrokTunnelAsync({ port, subdomainPrefix, baseDomain, authtoken, rewriteHostHeader, logger, }: {
     port: number;
     subdomainPrefix: string;
     baseDomain: string;
     authtoken: string;
+    rewriteHostHeader?: boolean;
     logger: bunyan;
 }): Promise<string>;
 export declare function waitForFileAsync<T>({ filePath, timeoutMs, description, parse, }: {
@@ -41,3 +69,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,
     });
@@ -157,12 +231,17 @@ function matchLabeledUrl({ output, label, baseDomain, }) {
     const match = labelPattern.exec(output);
     return match ? match[1] : null;
 }
-async function startNgrokTunnelAsync({ port, subdomainPrefix, baseDomain, authtoken, logger, }) {
+async function startNgrokTunnelAsync({ port, subdomainPrefix, baseDomain, authtoken, rewriteHostHeader, logger, }) {
     const domain = `${subdomainPrefix}-${(0, node_crypto_1.randomBytes)(8).toString('hex')}.${baseDomain}`;
     logger.info(`Starting ngrok tunnel ${domain} -> http://localhost:${port}.`);
     // Run the ngrok agent in-process via the SDK; it keeps the session alive until
     // the process exits, and the step blocks forever to hold it open.
-    const listener = await ngrok.forward({ addr: port, authtoken, domain });
+    const listener = await ngrok.forward({
+        addr: port,
+        authtoken,
+        domain,
+        ...(rewriteHostHeader ? { request_header_add: [`Host:localhost:${port}`] } : {}),
+    });
     const url = listener.url();
     if (!url) {
         throw new eas_build_job_1.SystemError(`ngrok tunnel for ${domain} did not return a public URL.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "20.1.0",
+  "version": "20.3.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": "490457976c996d06447e6442fbd1aec1ace09f1b"
 }

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;