@expo/build-tools 20.4.0 → 21.0.0

package/dist/steps/functions/uploadDeviceRunSessionScreenRecordings.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUploadDeviceRunSessionScreenRecordingsBuildFunction = createUploadDeviceRunSessionScreenRecordingsBuildFunction;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const promise_limit_1 = __importDefault(require("promise-limit"));
+const zod_1 = require("zod");
+const sentry_1 = require("../../sentry");
+const artifacts_1 = require("../../utils/artifacts");
+const deviceRunSessionArtifacts_1 = require("../utils/deviceRunSessionArtifacts");
+const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
+const RecordingsSchema = zod_1.z.array(zod_1.z.object({
+    udid: zod_1.z.string(),
+    deviceName: zod_1.z.string(),
+    runtimeDisplayName: zod_1.z.string(),
+    directory: zod_1.z.string(),
+}));
+const RecordingManifestSchema = zod_1.z.object({
+    firstFrameWallClock: zod_1.z.object({
+        iso8601: zod_1.z.string(),
+    }),
+    recording: zod_1.z.string(),
+});
+function createUploadDeviceRunSessionScreenRecordingsBuildFunction(ctx) {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'upload_device_run_session_screen_recordings',
+        name: 'Upload device run session screen recordings',
+        __metricsId: 'eas/upload_device_run_session_screen_recordings',
+        supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'recordings_json',
+                required: false,
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.JSON,
+            }),
+        ],
+        fn: async ({ logger }, { env, inputs }) => {
+            const result = RecordingsSchema.safeParse(inputs.recordings_json.value ?? []);
+            if (!result.success) {
+                throw new eas_build_job_1.SystemError('Invalid iOS Simulator recordings input.', {
+                    cause: result.error,
+                });
+            }
+            const recordings = result.data;
+            if (recordings.length === 0) {
+                logger.info('No iOS Simulator recordings found; skipping uploads.');
+                return;
+            }
+            const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
+            const limit = (0, promise_limit_1.default)(5);
+            await Promise.all(recordings.map(recording => limit(async () => {
+                const displayName = `${recording.deviceName} screen recording`;
+                try {
+                    const metadata = RecordingManifestSchema.parse(JSON.parse(await (0, promises_1.readFile)(node_path_1.default.join(recording.directory, 'session.json'), 'utf-8')));
+                    const recordingPath = node_path_1.default.join(recording.directory, metadata.recording);
+                    const { size } = await (0, promises_1.stat)(recordingPath);
+                    const recordingId = node_path_1.default.basename(recording.directory);
+                    logger.info(`Uploading screen recording for ${recording.deviceName} (${(0, artifacts_1.formatBytes)(size)}).`);
+                    await (0, deviceRunSessionArtifacts_1.uploadDeviceRunSessionArtifactAsync)(ctx, {
+                        deviceRunSessionId,
+                        artifactId: recordingId,
+                        name: displayName,
+                        filename: `${recordingId}.mp4`,
+                        kind: 'screen-recording',
+                        metadata: {
+                            __eas_screen_recording: '1',
+                            udid: recording.udid,
+                            deviceName: recording.deviceName,
+                            runtimeDisplayName: recording.runtimeDisplayName,
+                            firstFrameAt: metadata.firstFrameWallClock.iso8601,
+                        },
+                        size,
+                        stream: (0, node_fs_1.createReadStream)(recordingPath),
+                    });
+                }
+                catch (err) {
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    sentry_1.Sentry.capture('Could not upload iOS Simulator screen recording', error);
+                    logger.warn({ err: error }, `Could not upload screen recording for ${recording.deviceName}.`);
+                }
+            })));
+        },
+    });
+}

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

@@ -0,0 +1,2 @@
+import { BuildFunction } from '@expo/steps';
+export declare function createUploadPosthogSourcemapsFunction(): BuildFunction;

package/dist/steps/functions/uploadPosthogSourcemaps.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUploadPosthogSourcemapsFunction = createUploadPosthogSourcemapsFunction;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const logger_1 = require("@expo/logger");
+const steps_1 = require("@expo/steps");
+const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const PosthogClient_1 = require("../utils/PosthogClient");
+const PosthogUtils_1 = require("../utils/PosthogUtils");
+function createUploadPosthogSourcemapsFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'posthog_upload_sourcemaps',
+        name: 'Upload source maps to PostHog',
+        __metricsId: 'eas/posthog_upload_sourcemaps',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'directory',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+                defaultValue: 'dist',
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'api_key',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'project_id',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'ignore_error',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+        ],
+        fn: async (stepCtx, { inputs, env, signal }) => {
+            const { logger } = stepCtx;
+            const ignoreError = Boolean(inputs.ignore_error.value);
+            const result = PosthogClient_1.PosthogClient.fromEnv({
+                apiKeyOverride: inputs.api_key.value,
+                projectIdOverride: inputs.project_id.value,
+                env,
+            });
+            if (!result.client) {
+                PosthogUtils_1.PosthogUtils.failOrLogError({
+                    logger,
+                    ignoreError,
+                    error: PosthogUtils_1.PosthogUtils.missingCredentialsError(result.missing),
+                });
+                return;
+            }
+            const client = result.client;
+            const directory = inputs.directory.value;
+            const { host, env: cliEnv } = client.cliConfig();
+            logger.info(`Uploading source maps from "${directory}" to PostHog`);
+            try {
+                await (0, turtle_spawn_1.default)('npx', ['-y', '@posthog/cli', '--host', host, 'hermes', 'upload', '--directory', directory], {
+                    logger,
+                    // @posthog/cli writes all its logs, progress and success included, to stderr; tag them as stdout so they don't surface as build errors.
+                    mode: logger_1.PipeMode.COMBINED_AS_STDOUT,
+                    cwd: stepCtx.workingDirectory,
+                    env: { ...env, ...cliEnv },
+                    signal,
+                });
+            }
+            catch (error) {
+                PosthogUtils_1.PosthogUtils.failOrLogError({
+                    logger,
+                    ignoreError,
+                    error: new eas_build_job_1.UserError('EAS_POSTHOG_SOURCEMAPS_FAILED', 'Uploading source maps to PostHog failed.', { cause: error }),
+                });
+                return;
+            }
+            logger.info('Uploaded source maps to PostHog');
+        },
+    });
+}

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

@@ -0,0 +1,2 @@
+import { BuildFunction } from '@expo/steps';
+export declare function createWaitForPosthogMetricFunction(): BuildFunction;

package/dist/steps/functions/waitForPosthogMetric.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWaitForPosthogMetricFunction = createWaitForPosthogMetricFunction;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+const PosthogClient_1 = require("../utils/PosthogClient");
+const PosthogUtils_1 = require("../utils/PosthogUtils");
+const OPERATORS = {
+    lt: { symbol: '<', test: (value, threshold) => value < threshold },
+    lte: { symbol: '<=', test: (value, threshold) => value <= threshold },
+    gt: { symbol: '>', test: (value, threshold) => value > threshold },
+    gte: { symbol: '>=', test: (value, threshold) => value >= threshold },
+    eq: { symbol: '=', test: (value, threshold) => value === threshold },
+};
+function createWaitForPosthogMetricFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'posthog_wait_for_metric',
+        name: 'Wait for a PostHog metric',
+        __metricsId: 'eas/posthog_wait_for_metric',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'query',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: true,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'operator',
+                allowedValues: Object.keys(OPERATORS),
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: true,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'threshold',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+                required: true,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'timeout_seconds',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+                required: false,
+                defaultValue: PosthogUtils_1.PosthogUtils.DEFAULT_POLL_TIMEOUT_SECONDS,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'interval_seconds',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+                required: false,
+                defaultValue: PosthogUtils_1.PosthogUtils.DEFAULT_POLL_INTERVAL_SECONDS,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'api_key',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'project_id',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+            }),
+        ],
+        outputProviders: [steps_1.BuildStepOutput.createProvider({ id: 'value', required: false })],
+        fn: async (stepCtx, { inputs, outputs, env, signal }) => {
+            const { logger } = stepCtx;
+            const operator = inputs.operator.value;
+            if (!Object.keys(OPERATORS).includes(operator)) {
+                throw new eas_build_job_1.UserError('EAS_POSTHOG_METRIC_INVALID_OPERATOR', `Invalid "operator" "${operator}". Must be one of: ${Object.keys(OPERATORS).join(', ')}.`);
+            }
+            const timeoutSeconds = inputs.timeout_seconds.value;
+            const intervalSeconds = inputs.interval_seconds.value;
+            PosthogUtils_1.PosthogUtils.assertPollBoundsPositive({
+                timeoutSeconds,
+                intervalSeconds,
+                errorCode: 'EAS_POSTHOG_METRIC_INVALID_INTERVAL',
+            });
+            const result = PosthogClient_1.PosthogClient.fromEnv({
+                apiKeyOverride: inputs.api_key.value,
+                projectIdOverride: inputs.project_id.value,
+                env,
+            });
+            if (!result.client) {
+                throw PosthogUtils_1.PosthogUtils.missingCredentialsError(result.missing);
+            }
+            const client = result.client;
+            const value = await waitForPosthogMetricAsync({
+                logger,
+                client,
+                query: inputs.query.value,
+                operator: operator,
+                threshold: inputs.threshold.value,
+                timeoutSeconds,
+                intervalSeconds,
+                signal,
+            });
+            outputs.value.set(String(value));
+        },
+    });
+}
+async function waitForPosthogMetricAsync({ logger, client, query, operator, threshold, timeoutSeconds, intervalSeconds, signal, }) {
+    const deadline = Date.now() + timeoutSeconds * 1000;
+    const { symbol, test } = OPERATORS[operator];
+    const target = `${symbol} ${threshold}`;
+    let lastValue;
+    logger.info(`Waiting for the PostHog metric to reach ${target}. Checking every ${intervalSeconds}s for up to ${timeoutSeconds}s.`);
+    for (;;) {
+        let value = undefined;
+        try {
+            value = await queryMetricAsync({ logger, client, query, signal });
+        }
+        catch (error) {
+            if (!(error instanceof PosthogClient_1.PosthogRetryableError)) {
+                throw error;
+            }
+        }
+        if (value !== undefined) {
+            lastValue = value;
+            if (test(value, threshold)) {
+                logger.info(`Metric is ${value}. Target ${target} met.`);
+                return value;
+            }
+            logger.info(`Metric is ${value}. Still waiting for ${target}.`);
+        }
+        else {
+            logger.info('The query has not returned a numeric value yet. Still waiting.');
+        }
+        if (!(await PosthogUtils_1.PosthogUtils.waitForNextPollAsync({ intervalSeconds, deadline, signal }))) {
+            throw new eas_build_job_1.UserError('EAS_POSTHOG_METRIC_TIMEOUT', lastValue !== undefined
+                ? `The PostHog metric did not reach ${target} within ${timeoutSeconds}s (last value: ${lastValue}).`
+                : `The PostHog query never returned a numeric value within ${timeoutSeconds}s. Check that the query returns a single number and that PostHog is reachable.`);
+        }
+    }
+}
+async function queryMetricAsync({ logger, client, query, signal, }) {
+    const cell = await client.runQueryAsync(query, logger, signal);
+    return typeof cell === 'number' && Number.isFinite(cell) ? cell : undefined;
+}

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

@@ -0,0 +1,2 @@
+import { BuildFunction } from '@expo/steps';
+export declare function createWaitForPosthogQueryFunction(): BuildFunction;

package/dist/steps/functions/waitForPosthogQuery.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWaitForPosthogQueryFunction = createWaitForPosthogQueryFunction;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+const PosthogClient_1 = require("../utils/PosthogClient");
+const PosthogUtils_1 = require("../utils/PosthogUtils");
+function createWaitForPosthogQueryFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'posthog_wait_for_query',
+        name: 'Wait for a PostHog query',
+        __metricsId: 'eas/posthog_wait_for_query',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'query',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: true,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'timeout_seconds',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+                required: false,
+                defaultValue: PosthogUtils_1.PosthogUtils.DEFAULT_POLL_TIMEOUT_SECONDS,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'interval_seconds',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+                required: false,
+                defaultValue: PosthogUtils_1.PosthogUtils.DEFAULT_POLL_INTERVAL_SECONDS,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'api_key',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'project_id',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+            }),
+        ],
+        fn: async (stepCtx, { inputs, env, signal }) => {
+            const { logger } = stepCtx;
+            const timeoutSeconds = inputs.timeout_seconds.value;
+            const intervalSeconds = inputs.interval_seconds.value;
+            PosthogUtils_1.PosthogUtils.assertPollBoundsPositive({
+                timeoutSeconds,
+                intervalSeconds,
+                errorCode: 'EAS_POSTHOG_QUERY_INVALID_INTERVAL',
+            });
+            const result = PosthogClient_1.PosthogClient.fromEnv({
+                apiKeyOverride: inputs.api_key.value,
+                projectIdOverride: inputs.project_id.value,
+                env,
+            });
+            if (!result.client) {
+                throw PosthogUtils_1.PosthogUtils.missingCredentialsError(result.missing);
+            }
+            const client = result.client;
+            await waitForPosthogQueryAsync({
+                logger,
+                client,
+                query: inputs.query.value,
+                timeoutSeconds,
+                intervalSeconds,
+                signal,
+            });
+        },
+    });
+}
+async function waitForPosthogQueryAsync({ logger, client, query, timeoutSeconds, intervalSeconds, signal, }) {
+    const deadline = Date.now() + timeoutSeconds * 1000;
+    logger.info(`Waiting for the PostHog query to return true. Checking every ${intervalSeconds}s for up to ${timeoutSeconds}s.`);
+    for (;;) {
+        let cell;
+        try {
+            cell = await client.runQueryAsync(query, logger, signal);
+        }
+        catch (error) {
+            if (!(error instanceof PosthogClient_1.PosthogRetryableError)) {
+                throw error;
+            }
+            cell = undefined;
+        }
+        if (cell === true || (typeof cell === 'number' && cell !== 0)) {
+            logger.info('Query returned true.');
+            return;
+        }
+        logger.info('Query is not true yet. Still waiting.');
+        if (!(await PosthogUtils_1.PosthogUtils.waitForNextPollAsync({ intervalSeconds, deadline, signal }))) {
+            throw new eas_build_job_1.UserError('EAS_POSTHOG_QUERY_TIMEOUT', `The PostHog query did not return true within ${timeoutSeconds}s. It must select a single boolean, e.g. "SELECT count() > 100 FROM events".`);
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import { type Env } from '@expo/eas-build-job';
+import { type bunyan } from '@expo/logger';
+import { type IosSimulatorUuid } from '../../utils/IosSimulatorUtils';
+export declare namespace IosSimulatorRecordingUtils {
+    function startAsync({ env, logger }: {
+        env: Env;
+        logger: bunyan;
+    }): Promise<void>;
+    function finishAsync({ logger }: {
+        logger: bunyan;
+    }): Promise<{
+        udid: IosSimulatorUuid;
+        deviceName: string;
+        runtimeDisplayName: string;
+        directory: string;
+    }[]>;
+}

package/dist/steps/utils/IosSimulatorRecordingUtils.js

@@ -0,0 +1,218 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IosSimulatorRecordingUtils = void 0;
+const turtle_spawn_1 = __importDefault(require("@expo/turtle-spawn"));
+const node_crypto_1 = require("node:crypto");
+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 IosSimulatorUtils_1 = require("../../utils/IosSimulatorUtils");
+const IOS_SIMULATOR_RECORDING_POLL_INTERVAL_MS = 2_000;
+const RECORD_SIM_FINISH_TIMEOUT_MS = 30_000;
+const RECORD_SIM_FORCE_STOP_TIMEOUT_MS = 5_000;
+const RECORD_SIM_MAX_ATTEMPTS_PER_BOOT = 3;
+const RECORD_SIM_COMMAND = 'record-sim';
+let activeIosSimulatorRecordingSession = null;
+var IosSimulatorRecordingUtils;
+(function (IosSimulatorRecordingUtils) {
+    async function startAsync({ env, logger }) {
+        if (activeIosSimulatorRecordingSession) {
+            logger.info('iOS Simulator screen recording polling is already running.');
+            return;
+        }
+        const recordSimCommand = await resolveRecordSimCommandAsync({ env });
+        if (!recordSimCommand) {
+            logger.warn('record-sim binary is not available; iOS Simulator screen recordings are disabled.');
+            return;
+        }
+        const recordingsRootDirectory = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), 'ios-simulator-recordings-'));
+        const session = {
+            env,
+            logger,
+            recordSimCommand,
+            recordingsRootDirectory,
+            activeRecordings: new Map(),
+            completedRecordings: [],
+            recordingFailureCounts: new Map(),
+            pollingPromise: Promise.resolve(),
+            abortController: new AbortController(),
+        };
+        activeIosSimulatorRecordingSession = session;
+        logger.info('Started polling iOS Simulators for screen recordings.');
+        session.pollingPromise = pollIosSimulatorRecordingsAsync(session).catch(err => {
+            const error = err instanceof Error ? err : new Error(String(err));
+            sentry_1.Sentry.capture('iOS Simulator screen recording poller failed', error);
+            logger.warn({ err: error }, 'iOS Simulator screen recording poller failed.');
+        });
+    }
+    IosSimulatorRecordingUtils.startAsync = startAsync;
+    async function finishAsync({ logger }) {
+        const session = activeIosSimulatorRecordingSession;
+        if (!session) {
+            logger.info('No iOS Simulator screen recordings are running.');
+            return [];
+        }
+        activeIosSimulatorRecordingSession = null;
+        session.abortController.abort();
+        await session.pollingPromise;
+        await Promise.all([...session.activeRecordings.values()].map(async (recording) => {
+            logger.info(`Stopping screen recording for ${recording.deviceName}.`);
+            recording.recordingProcess.kill('SIGINT');
+            const finished = await Promise.race([
+                recording.completionPromise.then(() => true),
+                (0, promises_2.setTimeout)(RECORD_SIM_FINISH_TIMEOUT_MS, false, { ref: false }),
+            ]);
+            if (finished) {
+                return;
+            }
+            logger.warn(`Forcing iOS Simulator recording process for ${recording.deviceName} to stop.`);
+            recording.recordingProcess.kill('SIGKILL');
+            const killed = await Promise.race([
+                recording.completionPromise.then(() => true),
+                (0, promises_2.setTimeout)(RECORD_SIM_FORCE_STOP_TIMEOUT_MS, false, { ref: false }),
+            ]);
+            if (!killed) {
+                logger.warn(`iOS Simulator recording process for ${recording.deviceName} did not exit after SIGKILL.`);
+                sentry_1.Sentry.capture(`iOS Simulator recording process for ${recording.deviceName} did not exit after SIGKILL.`, {
+                    extras: {
+                        output: recording.getOutput(),
+                    },
+                });
+            }
+        }));
+        const completedRecordings = [...session.completedRecordings].sort((a, b) => a.startedAt.getTime() - b.startedAt.getTime());
+        return completedRecordings.map(recording => ({
+            udid: recording.udid,
+            deviceName: recording.deviceName,
+            runtimeDisplayName: recording.runtimeDisplayName,
+            directory: recording.outputDirectory,
+        }));
+    }
+    IosSimulatorRecordingUtils.finishAsync = finishAsync;
+})(IosSimulatorRecordingUtils || (exports.IosSimulatorRecordingUtils = IosSimulatorRecordingUtils = {}));
+async function pollIosSimulatorRecordingsAsync(session) {
+    let listDevicesErrorCount = 0;
+    const signal = session.abortController.signal;
+    while (!signal.aborted) {
+        try {
+            const bootedDevices = await IosSimulatorUtils_1.IosSimulatorUtils.getAvailableDevicesAsync({
+                env: session.env,
+                filter: 'booted',
+            });
+            if (signal.aborted) {
+                break;
+            }
+            listDevicesErrorCount = 0;
+            const bootedUdids = new Set(bootedDevices.map(device => device.udid));
+            for (const udid of session.recordingFailureCounts.keys()) {
+                if (!bootedUdids.has(udid)) {
+                    session.recordingFailureCounts.delete(udid);
+                }
+            }
+            for (const device of bootedDevices) {
+                if (session.activeRecordings.has(device.udid) ||
+                    (session.recordingFailureCounts.get(device.udid) ?? 0) >= RECORD_SIM_MAX_ATTEMPTS_PER_BOOT) {
+                    continue;
+                }
+                await startIosSimulatorRecordingAsync(session, {
+                    udid: device.udid,
+                    deviceName: device.name,
+                    runtimeDisplayName: device.runtimeDisplayName,
+                });
+            }
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            listDevicesErrorCount += 1;
+            if (listDevicesErrorCount === 1 || listDevicesErrorCount % 5 === 0) {
+                sentry_1.Sentry.capture('Could not poll iOS Simulators for screen recordings', error);
+                session.logger.warn({ err: error, failedSimulatorListCount: listDevicesErrorCount }, 'Could not poll iOS Simulators for screen recordings.');
+            }
+        }
+        if (!signal.aborted) {
+            try {
+                await (0, promises_2.setTimeout)(IOS_SIMULATOR_RECORDING_POLL_INTERVAL_MS, undefined, {
+                    signal,
+                });
+            }
+            catch (err) {
+                if (!signal.aborted) {
+                    throw err;
+                }
+            }
+        }
+    }
+}
+async function startIosSimulatorRecordingAsync(session, { udid, deviceName, runtimeDisplayName, }) {
+    const startedAt = new Date();
+    const recordingId = (0, node_crypto_1.randomUUID)();
+    const outputDirectory = node_path_1.default.join(session.recordingsRootDirectory, recordingId);
+    await (0, promises_1.mkdir)(outputDirectory, { recursive: true });
+    session.logger.info(`Starting screen recording for ${deviceName}.`);
+    const recordingSpawn = (0, turtle_spawn_1.default)(session.recordSimCommand, ['--udid', udid, '--output', outputDirectory, '--segment-duration', '0'], {
+        env: session.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const getOutput = captureProcessOutput(recordingSpawn.child);
+    const completionPromise = recordingSpawn
+        .then(() => undefined)
+        .catch((err) => {
+        session.recordingFailureCounts.set(udid, (session.recordingFailureCounts.get(udid) ?? 0) + 1);
+        const error = err instanceof Error ? err : new Error(String(err));
+        sentry_1.Sentry.capture('iOS Simulator screen recording process failed', error);
+        session.logger.warn({ err: error, recordSimOutput: getOutput() }, `Screen recording process failed for ${deviceName}.`);
+    })
+        .finally(() => {
+        session.activeRecordings.delete(udid);
+        session.completedRecordings.push({
+            id: recordingId,
+            udid,
+            deviceName,
+            runtimeDisplayName,
+            outputDirectory,
+            startedAt,
+            getOutput,
+        });
+    });
+    session.activeRecordings.set(udid, {
+        id: recordingId,
+        udid,
+        deviceName,
+        runtimeDisplayName,
+        outputDirectory,
+        recordingProcess: recordingSpawn.child,
+        completionPromise,
+        startedAt,
+        getOutput,
+    });
+}
+async function resolveRecordSimCommandAsync({ env }) {
+    try {
+        await (0, turtle_spawn_1.default)('which', [RECORD_SIM_COMMAND], { env });
+        return RECORD_SIM_COMMAND;
+    }
+    catch { }
+    const packagedRecordSimPath = node_path_1.default.join(__dirname, '..', '..', '..', 'bin', RECORD_SIM_COMMAND);
+    try {
+        await (0, promises_1.access)(packagedRecordSimPath);
+        return packagedRecordSimPath;
+    }
+    catch {
+        return null;
+    }
+}
+function captureProcessOutput(recordingProcess) {
+    let output = '';
+    const appendChunk = (chunk) => {
+        // Keep enough recorder stderr/stdout for diagnostics without retaining unbounded output.
+        output = `${output}${chunk.toString()}`.slice(-16_384);
+    };
+    recordingProcess.stdout?.on('data', appendChunk);
+    recordingProcess.stderr?.on('data', appendChunk);
+    return () => output;
+}