@expo/build-tools 21.3.0 → 21.5.0

package/dist/steps/utils/remoteDeviceRunSession.js

@@ -41,14 +41,19 @@ exports.getNgrokTunnelDomainOrThrow = getNgrokTunnelDomainOrThrow;
 exports.getNgrokAuthtokenOrThrow = getNgrokAuthtokenOrThrow;
 exports.selectXcodeDeveloperDirectoryAsync = selectXcodeDeveloperDirectoryAsync;
 exports.waitForDeviceRunSessionStoppedAsync = waitForDeviceRunSessionStoppedAsync;
+exports.ensureFfmpegInstalledAsync = ensureFfmpegInstalledAsync;
 exports.turnIceServersToServeSimArgs = turnIceServersToServeSimArgs;
 exports.fetchServeSimTurnArgsAsync = fetchServeSimTurnArgsAsync;
 exports.uploadRemoteSessionConfigAsync = uploadRemoteSessionConfigAsync;
 exports.spawnDetached = spawnDetached;
+exports.metricsCorsOriginToServeSimArgs = metricsCorsOriginToServeSimArgs;
+exports.createServeSimArgs = createServeSimArgs;
+exports.waitForServeSimReadyAsync = waitForServeSimReadyAsync;
 exports.startServeSimWithTunnelAsync = startServeSimWithTunnelAsync;
 exports.startNgrokTunnelAsync = startNgrokTunnelAsync;
 exports.waitForFileAsync = waitForFileAsync;
 const eas_build_job_1 = require("@expo/eas-build-job");
+const results_1 = require("@expo/results");
 const steps_1 = require("@expo/steps");
 const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
 const ngrok = __importStar(require("@ngrok/ngrok"));
@@ -57,11 +62,18 @@ 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 node_net_1 = require("node:net");
 const promises_1 = require("node:timers/promises");
 const sentry_1 = require("../../sentry");
 const retry_1 = require("../../utils/retry");
 const turtleFetch_1 = require("../../utils/turtleFetch");
 const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
+const SERVE_SIM_PACKAGE_SPEC = '@expo/serve-sim@latest';
+const SERVE_SIM_HOST = '127.0.0.1';
+const SERVE_SIM_MAX_DIMENSION = '1280';
+const SERVE_SIM_MJPEG_QUALITY = '0.55';
+const SERVE_SIM_VIDEO_BITRATE = '3000000';
+const SERVE_SIM_VIDEO_FPS = '60';
 const START_DEVICE_RUN_SESSION_MUTATION = (0, gql_tada_1.graphql)(`
   mutation StartDeviceRunSession($deviceRunSessionId: ID!, $remoteConfig: JSONObject!) {
     deviceRunSession {
@@ -178,6 +190,66 @@ async function sleepUntilAbortedAsync(timeoutMs, signal) {
         }
     }
 }
+// Argent encodes screen recordings by piping simulator frames into `ffmpeg`,
+// which it resolves from PATH. The tool-server inherits this step's env, so
+// spawning ffmpeg resolves against the same PATH argent will search: it rejects
+// with ENOENT when the binary is absent, and running it also proves it works.
+async function isFfmpegAvailableAsync(env) {
+    return (await (0, results_1.asyncResult)((0, turtle_spawn_1.default)('ffmpeg', ['-version'], { env }))).ok;
+}
+async function installFfmpegWithHomebrewAsync({ env, logger, }) {
+    await (0, turtle_spawn_1.default)('brew', ['install', 'ffmpeg'], {
+        env: { ...env, HOMEBREW_NO_AUTO_UPDATE: '1' },
+        logger,
+    });
+}
+async function installFfmpegWithAptAsync({ env, logger, }) {
+    const aptEnv = { ...env, DEBIAN_FRONTEND: 'noninteractive' };
+    // The worker's package index can be older than the image it booted from, which
+    // makes the install 404 on a moved package. Refreshing first avoids that; a
+    // failed refresh is not fatal because the existing index may still resolve.
+    await (0, results_1.asyncResult)((0, turtle_spawn_1.default)('sudo', ['apt-get', 'update'], { env: aptEnv, logger }));
+    await (0, turtle_spawn_1.default)('sudo', ['apt-get', 'install', '-y', 'ffmpeg'], { env: aptEnv, logger });
+}
+/**
+ * Install ffmpeg when the runtime does not already provide it, so argent's
+ * `screen-recording-start` tool can encode a video. The worker images do not
+ * ship ffmpeg yet, so without this the tool fails with "`ffmpeg` was not found
+ * on PATH" — on macOS (iOS simulators) and Linux (Android emulators) alike.
+ *
+ * Best-effort by design: screen recording is one optional argent tool, so a
+ * failure here is logged and the session continues without it.
+ *
+ * The whole body is wrapped because the caller runs this in the background with
+ * `void`. There is no unhandledRejection handler in the worker, so a rejection
+ * escaping here would crash the process and take the live session with it.
+ * `spawn` is not an async function and can throw synchronously, which
+ * `asyncResult` cannot catch — it only wraps an already-created promise.
+ */
+async function ensureFfmpegInstalledAsync({ runtimePlatform, env, logger, }) {
+    try {
+        if (await isFfmpegAvailableAsync(env)) {
+            logger.info('ffmpeg is already installed.');
+            return;
+        }
+        const isDarwin = runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN;
+        logger.info(`ffmpeg is not installed, installing it with ${isDarwin ? 'Homebrew' : 'apt'} for argent screen recording.`);
+        if (isDarwin) {
+            await installFfmpegWithHomebrewAsync({ env, logger });
+        }
+        else {
+            await installFfmpegWithAptAsync({ env, logger });
+        }
+        logger.info('Installed ffmpeg.');
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        sentry_1.Sentry.capture('Could not install ffmpeg for argent screen recording', error, {
+            level: 'warning',
+        });
+        logger.warn({ err: error }, 'Could not install ffmpeg. Argent screen recording will not work in this session.');
+    }
+}
 const TurnIceServersResponseSchema = zod_1.z.object({
     data: zod_1.z.object({
         iceServers: TurnIceServersSchema,
@@ -248,6 +320,49 @@ async function uploadRemoteSessionConfigAsync({ ctx, deviceRunSessionId, remoteC
         throw new eas_build_job_1.SystemError(`Failed to start device run session ${deviceRunSessionId}: ${result.error.message}`);
     }
 }
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function stopDetachedProcessAsync(pid) {
+    if (pid === undefined || !isProcessRunning(pid)) {
+        return;
+    }
+    try {
+        // spawnDetached creates a dedicated process group. Signaling the group also
+        // terminates npx/bunx descendants instead of leaving the actual daemon alive.
+        process.kill(-pid, 'SIGTERM');
+    }
+    catch {
+        try {
+            process.kill(pid, 'SIGTERM');
+        }
+        catch {
+            return;
+        }
+    }
+    const deadline = Date.now() + 5_000;
+    while (Date.now() < deadline && isProcessRunning(pid)) {
+        await (0, retry_1.sleepAsync)(100);
+    }
+    if (!isProcessRunning(pid)) {
+        return;
+    }
+    try {
+        process.kill(-pid, 'SIGKILL');
+    }
+    catch {
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch { }
+    }
+}
 function spawnDetached({ command, args, cwd, env, }) {
     const promise = (0, turtle_spawn_1.default)(command, args, {
         cwd,
@@ -265,49 +380,133 @@ function spawnDetached({ command, args, cwd, env, }) {
     };
     promise.child.stdout?.on('data', appendChunk);
     promise.child.stderr?.on('data', appendChunk);
-    return { pid: promise.child.pid, getOutput: () => output };
+    const pid = promise.child.pid;
+    return {
+        pid,
+        getOutput: () => output,
+        stopAsync: async () => await stopDetachedProcessAsync(pid),
+    };
 }
-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: [
-            'serve-sim-szdziedzic@latest',
-            '--tunnel',
-            '--tunnel-provider',
-            'ngrok',
-            '--tunnel-domain',
-            baseDomain,
-            '--stream-max-dimension',
-            '1280',
-            '--stream-quality',
-            '0.55',
-            '--codec',
-            'webrtc',
-            ...turnArgs,
-        ],
-        env,
+function metricsCorsOriginToServeSimArgs(env) {
+    const origin = env.EAS_SIMULATOR_METRICS_CORS_ORIGIN;
+    if (!origin) {
+        return [];
+    }
+    const args = [];
+    for (const value of origin.split(',')) {
+        const trimmed = value.trim();
+        if (trimmed) {
+            args.push('--metrics-cors-origin', trimmed);
+        }
+    }
+    return args;
+}
+function createServeSimArgs({ port, turnArgs = [], metricsCorsArgs = [], }) {
+    return [
+        '--yes',
+        SERVE_SIM_PACKAGE_SPEC,
+        '--port',
+        String(port),
+        '--host',
+        SERVE_SIM_HOST,
+        '--transport',
+        'webrtc',
+        '--webrtc-codec',
+        'vp8',
+        '--max-dimension',
+        SERVE_SIM_MAX_DIMENSION,
+        '--mjpeg-quality',
+        SERVE_SIM_MJPEG_QUALITY,
+        '--video-bitrate',
+        SERVE_SIM_VIDEO_BITRATE,
+        '--video-fps',
+        SERVE_SIM_VIDEO_FPS,
+        ...turnArgs,
+        ...metricsCorsArgs,
+    ];
+}
+async function findAvailablePortAsync() {
+    const server = (0, node_net_1.createServer)();
+    server.unref();
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, SERVE_SIM_HOST, () => resolve());
+    });
+    const address = server.address();
+    await new Promise((resolve, reject) => {
+        server.close(err => (err ? reject(err) : resolve()));
     });
-    logger.info('Waiting for serve-sim to report tunnel URL.');
+    if (!address || typeof address === 'string') {
+        throw new eas_build_job_1.SystemError('Could not allocate a local port for serve-sim.');
+    }
+    return address.port;
+}
+const ServeSimReadyResponseSchema = zod_1.z.object({
+    status: zod_1.z.literal('ready'),
+    device: zod_1.z.string(),
+});
+async function waitForServeSimReadyAsync({ serveSim, port, timeoutMs, }) {
+    const readyUrl = `http://${SERVE_SIM_HOST}:${port}/readyz`;
     const deadline = Date.now() + timeoutMs;
+    let lastError;
     while (Date.now() < deadline) {
-        const output = serveSim.getOutput();
-        const previewUrl = matchTunnelUrl({ output, baseDomain });
-        if (previewUrl) {
-            return { previewUrl };
+        if (serveSim.pid !== undefined && !isProcessRunning(serveSim.pid)) {
+            throw new eas_build_job_1.SystemError(`serve-sim exited before becoming ready. Last output:\n${serveSim.getOutput() || '<empty>'}`);
+        }
+        try {
+            const response = await (0, turtleFetch_1.turtleFetch)(readyUrl, 'GET', {
+                retries: 0,
+                timeout: 2_000,
+            });
+            ServeSimReadyResponseSchema.parse(await response.json());
+            return;
+        }
+        catch (error) {
+            lastError = error;
         }
         await (0, retry_1.sleepAsync)(1_000);
     }
-    throw new eas_build_job_1.SystemError(`Timed out waiting for serve-sim to report Tunnel URL. Last output:\n${serveSim.getOutput() || '<empty>'}`);
+    throw new eas_build_job_1.SystemError(`Timed out waiting for serve-sim readiness at ${readyUrl}${lastError instanceof Error ? `: ${lastError.message}` : ''}. Last output:\n${serveSim.getOutput() || '<empty>'}`);
 }
-function matchTunnelUrl({ output, baseDomain, }) {
-    const labelPattern = new RegExp(`Tunnel:\\s*(https:\\/\\/[a-z0-9-]+\\.${escapeRegExp(baseDomain)})`);
-    const match = labelPattern.exec(output);
-    return match ? match[1] : null;
+async function startServeSimWithTunnelAsync(ctx, { baseDomain, env, logger, timeoutMs, }) {
+    const port = await findAvailablePortAsync();
+    logger.info(`Launching ${SERVE_SIM_PACKAGE_SPEC} on ${SERVE_SIM_HOST}:${port}.`);
+    const turnArgs = await fetchServeSimTurnArgsAsync(ctx, { env, logger });
+    const metricsCorsArgs = metricsCorsOriginToServeSimArgs(env);
+    const serveSim = spawnDetached({
+        command: 'npx',
+        args: createServeSimArgs({ port, turnArgs, metricsCorsArgs }),
+        env,
+    });
+    try {
+        logger.info('Waiting for serve-sim to become ready.');
+        await waitForServeSimReadyAsync({ serveSim, port, timeoutMs });
+        const tunnel = await startNgrokTunnelAsync({
+            port,
+            subdomainPrefix: 'serve-sim',
+            baseDomain,
+            authtoken: getNgrokAuthtokenOrThrow(env),
+            logger,
+        });
+        return {
+            previewUrl: tunnel.url,
+            stopAsync: async () => {
+                const results = await Promise.allSettled([tunnel.stopAsync(), serveSim.stopAsync()]);
+                for (const result of results) {
+                    if (result.status === 'rejected') {
+                        logger.warn({ err: result.reason }, 'Could not stop a serve-sim preview resource.');
+                    }
+                }
+            },
+        };
+    }
+    catch (error) {
+        await serveSim.stopAsync();
+        throw error;
+    }
 }
 async function startNgrokTunnelAsync({ port, subdomainPrefix, baseDomain, authtoken, rewriteHostHeader, logger, }) {
-    const domain = `${subdomainPrefix}-${(0, node_crypto_1.randomBytes)(8).toString('hex')}.${baseDomain}`;
+    const domain = `${subdomainPrefix}-${(0, node_crypto_1.randomBytes)(16).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.
@@ -319,12 +518,25 @@ async function startNgrokTunnelAsync({ port, subdomainPrefix, baseDomain, authto
     });
     const url = listener.url();
     if (!url) {
+        await listener.close();
         throw new eas_build_job_1.SystemError(`ngrok tunnel for ${domain} did not return a public URL.`);
     }
-    return url;
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    let stopped = false;
+    return {
+        url,
+        stopAsync: async () => {
+            if (stopped) {
+                return;
+            }
+            stopped = true;
+            try {
+                await listener.close();
+            }
+            catch (error) {
+                logger.warn({ err: error }, `Could not stop ngrok tunnel ${domain}.`);
+            }
+        },
+    };
 }
 async function waitForFileAsync({ filePath, timeoutMs, description, parse, }) {
     const deadline = Date.now() + timeoutMs;

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

@@ -0,0 +1,9 @@
+import { type bunyan } from '@expo/logger';
+import { CustomBuildContext } from '../../customBuildContext';
+export declare function uploadServeSimMetricsFileAsync(ctx: CustomBuildContext, { deviceRunSessionId, udid, filePath, metadata, logger, }: {
+    deviceRunSessionId: string;
+    udid: string;
+    filePath: string;
+    metadata?: Record<string, unknown>;
+    logger: bunyan;
+}): Promise<void>;

package/dist/steps/utils/serveSimMetricsArtifacts.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadServeSimMetricsFileAsync = uploadServeSimMetricsFileAsync;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const sentry_1 = require("../../sentry");
+const artifacts_1 = require("../../utils/artifacts");
+const deviceRunSessionArtifacts_1 = require("./deviceRunSessionArtifacts");
+const METRICS_ARTIFACT_FILENAME = 'metrics.ndjson';
+async function uploadServeSimMetricsFileAsync(ctx, { deviceRunSessionId, udid, filePath, metadata, logger, }) {
+    let size;
+    try {
+        ({ size } = await (0, promises_1.stat)(filePath));
+    }
+    catch {
+        logger.info(`No serve-sim metrics file was written for ${udid}; skipping upload.`);
+        return;
+    }
+    if (size === 0) {
+        logger.info(`serve-sim metrics file for ${udid} is empty; skipping upload.`);
+        return;
+    }
+    try {
+        logger.info(`Uploading serve-sim metrics for ${udid} (${(0, artifacts_1.formatBytes)(size)}).`);
+        await (0, deviceRunSessionArtifacts_1.uploadDeviceRunSessionArtifactAsync)(ctx, {
+            deviceRunSessionId,
+            artifactId: `metrics-${udid}`,
+            name: `Performance metrics (${udid.slice(0, 8)})`,
+            filename: METRICS_ARTIFACT_FILENAME,
+            kind: 'performance-metrics',
+            metadata: {
+                __eas_type: 'performance-metrics',
+                udid,
+                ...(metadata && {
+                    hostCores: metadata.hostCores,
+                    sampleIntervalMs: metadata.sampleIntervalMs,
+                    schemaVersion: metadata.schemaVersion,
+                }),
+            },
+            size,
+            stream: (0, node_fs_1.createReadStream)(filePath),
+        });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        sentry_1.Sentry.capture('Could not upload serve-sim metrics artifact', error);
+        logger.warn({ err: error }, `Could not upload serve-sim metrics artifact for ${udid}.`);
+    }
+}

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

@@ -0,0 +1,30 @@
+import { type bunyan } from '@expo/logger';
+type ServeSimServer = {
+    udid: string;
+    url: string;
+};
+export declare namespace ServeSimMetricsRecorder {
+    function startAsync({ logger, stateDir, pollIntervalMs, }: {
+        logger: bunyan;
+        stateDir?: string;
+        pollIntervalMs?: number;
+    }): Promise<void>;
+    function finishAsync({ logger, }: {
+        logger: bunyan;
+    }): Promise<{
+        udid: string;
+        filePath: string;
+        metadata: Record<string, unknown> | undefined;
+    }[]>;
+}
+export declare function readServeSimServersAsync(stateDir: string): Promise<ServeSimServer[]>;
+export declare function streamServeSimMetricsToFileAsync({ serveSimUrl, filePath, signal, logger, }: {
+    serveSimUrl: string;
+    filePath: string;
+    signal: AbortSignal;
+    logger: bunyan;
+}): Promise<{
+    receivedData: boolean;
+    metadata: Record<string, unknown> | undefined;
+}>;
+export {};

package/dist/steps/utils/serveSimMetricsRecorder.js

@@ -0,0 +1,232 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServeSimMetricsRecorder = void 0;
+exports.readServeSimServersAsync = readServeSimServersAsync;
+exports.streamServeSimMetricsToFileAsync = streamServeSimMetricsToFileAsync;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const promises_2 = require("node:timers/promises");
+const sentry_1 = require("../../sentry");
+const POLL_INTERVAL_MS = 2_000;
+// Consecutive failed connects per device; reset once a stream yields a sample.
+const MAX_CONSECUTIVE_STREAM_FAILURES_PER_DEVICE = 10;
+const END_STREAM_TIMEOUT_MS = 2_000;
+// serve-sim's own per-device registry while serving: `${tmpdir}/serve-sim/server-<udid>.json`.
+const SERVE_SIM_STATE_DIR = node_path_1.default.join(node_os_1.default.tmpdir(), 'serve-sim');
+let activeSession = null;
+var ServeSimMetricsRecorder;
+(function (ServeSimMetricsRecorder) {
+    async function startAsync({ logger, stateDir = SERVE_SIM_STATE_DIR, pollIntervalMs = POLL_INTERVAL_MS, }) {
+        if (activeSession) {
+            logger.info('serve-sim metrics polling is already running.');
+            return;
+        }
+        const outputDirectory = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), 'serve-sim-metrics-'));
+        const session = {
+            logger,
+            stateDir,
+            pollIntervalMs,
+            outputDirectory,
+            files: new Map(),
+            attempts: new Map(),
+            metadata: new Map(),
+            activeStreams: new Map(),
+            pollingPromise: Promise.resolve(),
+            abortController: new AbortController(),
+        };
+        activeSession = session;
+        logger.info('Started polling serve-sim for cpu/mem metrics.');
+        session.pollingPromise = pollServeSimMetricsAsync(session).catch(err => {
+            const error = err instanceof Error ? err : new Error(String(err));
+            sentry_1.Sentry.capture('serve-sim metrics poller failed', error);
+            logger.warn({ err: error }, 'serve-sim metrics poller failed.');
+        });
+    }
+    ServeSimMetricsRecorder.startAsync = startAsync;
+    async function finishAsync({ logger, }) {
+        const session = activeSession;
+        if (!session) {
+            logger.info('No serve-sim metrics polling is running.');
+            return [];
+        }
+        activeSession = null;
+        session.abortController.abort();
+        await session.pollingPromise;
+        await Promise.all([...session.activeStreams.values()].map(async (stream) => {
+            stream.abortController.abort();
+            await stream.donePromise;
+        }));
+        return [...session.files.entries()].map(([udid, filePath]) => ({
+            udid,
+            filePath,
+            metadata: session.metadata.get(udid),
+        }));
+    }
+    ServeSimMetricsRecorder.finishAsync = finishAsync;
+})(ServeSimMetricsRecorder || (exports.ServeSimMetricsRecorder = ServeSimMetricsRecorder = {}));
+async function pollServeSimMetricsAsync(session) {
+    const { abortController, logger } = session;
+    while (!abortController.signal.aborted) {
+        const servers = await readServeSimServersAsync(session.stateDir);
+        // Forget the failure count for a device that has left the registry, so a
+        // serve-sim that restarts for the same udid is retried (mirrors the recordings poller).
+        const present = new Set(servers.map(server => server.udid));
+        for (const udid of session.attempts.keys()) {
+            if (!present.has(udid)) {
+                session.attempts.delete(udid);
+            }
+        }
+        for (const server of servers) {
+            if (session.activeStreams.has(server.udid)) {
+                continue;
+            }
+            const failures = session.attempts.get(server.udid) ?? 0;
+            if (failures >= MAX_CONSECUTIVE_STREAM_FAILURES_PER_DEVICE) {
+                continue;
+            }
+            session.attempts.set(server.udid, failures + 1);
+            let filePath = session.files.get(server.udid);
+            if (!filePath) {
+                filePath = node_path_1.default.join(session.outputDirectory, `${server.udid}.ndjson`);
+                session.files.set(server.udid, filePath);
+            }
+            const streamAbortController = new AbortController();
+            const streamSignal = AbortSignal.any([abortController.signal, streamAbortController.signal]);
+            logger.info(`Collecting serve-sim metrics for ${server.udid}.`);
+            const donePromise = streamServeSimMetricsToFileAsync({
+                serveSimUrl: server.url,
+                filePath,
+                signal: streamSignal,
+                logger,
+            })
+                .then(({ receivedData, metadata }) => {
+                if (receivedData) {
+                    session.attempts.set(server.udid, 0);
+                }
+                if (metadata) {
+                    session.metadata.set(server.udid, metadata);
+                }
+            })
+                .finally(() => {
+                session.activeStreams.delete(server.udid);
+            });
+            session.activeStreams.set(server.udid, {
+                abortController: streamAbortController,
+                donePromise,
+            });
+        }
+        await (0, promises_2.setTimeout)(session.pollIntervalMs, undefined, { signal: abortController.signal }).catch(() => { });
+    }
+}
+async function readServeSimServersAsync(stateDir) {
+    let entries;
+    try {
+        entries = await (0, promises_1.readdir)(stateDir);
+    }
+    catch {
+        return [];
+    }
+    const servers = [];
+    for (const entry of entries) {
+        if (!/^server-.+\.json$/.test(entry)) {
+            continue;
+        }
+        try {
+            const state = JSON.parse(await (0, promises_1.readFile)(node_path_1.default.join(stateDir, entry), 'utf-8'));
+            if (typeof state.device === 'string' && typeof state.url === 'string') {
+                servers.push({ udid: state.device, url: state.url });
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return servers;
+}
+async function streamServeSimMetricsToFileAsync({ serveSimUrl, filePath, signal, logger, }) {
+    const file = (0, node_fs_1.createWriteStream)(filePath, { flags: 'a' });
+    file.on('error', err => {
+        logger.warn({ err }, `serve-sim metrics file write failed for ${filePath}.`);
+    });
+    let receivedData = false;
+    let metadata;
+    try {
+        const response = await (0, node_fetch_1.default)(new URL('/metrics', serveSimUrl).toString(), { signal });
+        if (!response.ok || !response.body) {
+            logger.warn(`serve-sim /metrics responded ${response.status} for ${serveSimUrl}.`);
+            return { receivedData, metadata };
+        }
+        // One decoder so a multi-byte character split across chunks isn't corrupted.
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let event = 'message';
+        for await (const chunk of response.body) {
+            buffer += decoder.decode(chunk, { stream: true });
+            let newline;
+            while ((newline = buffer.indexOf('\n')) !== -1) {
+                const line = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                if (line === '') {
+                    event = 'message';
+                }
+                else if (line.startsWith('event:')) {
+                    event = line.slice('event:'.length).trim();
+                }
+                else if (line.startsWith('data:')) {
+                    const payload = line.slice('data:'.length).trim();
+                    if (payload && event === 'meta') {
+                        // Keep the metadata out of the NDJSON (so it stays homogeneous and reconnects
+                        // don't re-append it) but hold onto it for the artifact metadata.
+                        try {
+                            metadata = JSON.parse(payload);
+                        }
+                        catch {
+                            // ignore a malformed metadata frame
+                        }
+                    }
+                    else if (payload) {
+                        file.write(payload + '\n');
+                        receivedData = true;
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        // Stream ends (teardown abort, serve-sim exit/restart) are expected and reconnected by the
+        // poller, so log rather than report — best-effort telemetry shouldn't page.
+        if (!signal.aborted) {
+            logger.warn({ err }, `serve-sim /metrics stream ended for ${serveSimUrl}.`);
+        }
+    }
+    finally {
+        await endWriteStreamAsync(file);
+    }
+    return { receivedData, metadata };
+}
+// An errored write stream may never fire `end`'s callback, so also settle on
+// close/error and a timeout to avoid hanging teardown.
+async function endWriteStreamAsync(file) {
+    await new Promise(resolve => {
+        let settled = false;
+        const done = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            resolve();
+        };
+        const timer = setTimeout(done, END_STREAM_TIMEOUT_MS);
+        timer.unref();
+        file.once('close', done);
+        file.once('error', done);
+        file.end(done);
+    });
+}