@expo/build-tools 20.5.1 → 21.0.1

package/dist/steps/functions/rolloutPosthogFlag.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRolloutPosthogFlagFunction = createRolloutPosthogFlagFunction;
+const eas_build_job_1 = require("@expo/eas-build-job");
+const steps_1 = require("@expo/steps");
+const zod_1 = require("zod");
+const PosthogClient_1 = require("../utils/PosthogClient");
+const PosthogUtils_1 = require("../utils/PosthogUtils");
+const SEARCH_LIMIT = 200;
+const FeatureFlagGroupSchema = zod_1.z.object({ properties: zod_1.z.unknown().optional() }).passthrough();
+const FeatureFlagSchema = zod_1.z
+    .object({
+    id: zod_1.z.number(),
+    key: zod_1.z.string(),
+    filters: zod_1.z
+        .object({
+        groups: zod_1.z.array(FeatureFlagGroupSchema).optional(),
+        payloads: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+    })
+        .passthrough()
+        .optional(),
+})
+    .passthrough();
+const FlagSearchResponseSchema = zod_1.z.object({ results: zod_1.z.array(zod_1.z.unknown()) });
+function isCatchAllGroup(group) {
+    const { properties } = group;
+    return (properties === undefined ||
+        properties === null ||
+        (Array.isArray(properties) && properties.length === 0));
+}
+function createRolloutPosthogFlagFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'posthog_flag_rollout',
+        name: 'Roll out a PostHog feature flag',
+        __metricsId: 'eas/posthog_flag_rollout',
+        inputProviders: [
+            steps_1.BuildStepInput.createProvider({
+                id: 'flag',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: true,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'active',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.BOOLEAN,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'rollout_percentage',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.NUMBER,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'payload',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.JSON,
+                required: false,
+            }),
+            steps_1.BuildStepInput.createProvider({
+                id: 'variant',
+                allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
+                required: false,
+            }),
+            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 flagKey = inputs.flag.value;
+            const active = inputs.active.value;
+            const rolloutPercentage = inputs.rollout_percentage.value;
+            const payload = inputs.payload.value;
+            const variant = inputs.variant.value;
+            if (active === undefined && rolloutPercentage === undefined && payload === undefined) {
+                throw new eas_build_job_1.UserError('EAS_POSTHOG_FLAG_NO_CHANGE', 'You need to provide "active", "rollout_percentage", or "payload" to change the feature flag.');
+            }
+            if (rolloutPercentage !== undefined &&
+                (!Number.isInteger(rolloutPercentage) || rolloutPercentage < 0 || rolloutPercentage > 100)) {
+                throw new eas_build_job_1.UserError('EAS_POSTHOG_FLAG_INVALID_ROLLOUT', `"rollout_percentage" must be an integer between 0 and 100, got ${rolloutPercentage}.`);
+            }
+            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;
+            await rolloutPosthogFlagAsync({
+                logger,
+                client,
+                flagKey,
+                active,
+                rolloutPercentage,
+                payload,
+                variant,
+                ignoreError,
+                signal,
+            });
+        },
+    });
+}
+async function rolloutPosthogFlagAsync({ logger, client, flagKey, active, rolloutPercentage, payload, variant, ignoreError, signal, }) {
+    let searchResponse;
+    try {
+        searchResponse = await client.requestAsync('GET', `/feature_flags/?limit=${SEARCH_LIMIT}&search=${encodeURIComponent(flagKey)}`, {
+            action: `Looking up PostHog flag "${flagKey}"`,
+            forbiddenScope: 'feature_flag:read',
+            signal,
+        });
+    }
+    catch (error) {
+        PosthogUtils_1.PosthogUtils.failOrLogError({ logger, ignoreError, error });
+        return;
+    }
+    let results;
+    try {
+        results = FlagSearchResponseSchema.parse(await searchResponse.json()).results;
+    }
+    catch (error) {
+        PosthogUtils_1.PosthogUtils.failOrLogError({
+            logger,
+            ignoreError,
+            error: new eas_build_job_1.UserError('EAS_POSTHOG_FLAG_UNEXPECTED_RESPONSE', `PostHog flag lookup for "${flagKey}" returned an unexpected response.`, { cause: error }),
+        });
+        return;
+    }
+    const flag = results
+        .flatMap(result => {
+        const parsed = FeatureFlagSchema.safeParse(result);
+        return parsed.success ? [parsed.data] : [];
+    })
+        .find(candidate => candidate.key === flagKey);
+    if (!flag) {
+        PosthogUtils_1.PosthogUtils.failOrLogError({
+            logger,
+            ignoreError,
+            error: new eas_build_job_1.UserError('EAS_POSTHOG_FLAG_NOT_FOUND', `No PostHog feature flag with key "${flagKey}" was found. Check the "flag" input.`),
+        });
+        return;
+    }
+    const patch = {};
+    if (active !== undefined) {
+        patch.active = active;
+    }
+    let filters = flag.filters;
+    if (rolloutPercentage !== undefined) {
+        filters = buildRolloutFilters({ logger, flagKey, filters, rolloutPercentage });
+    }
+    if (payload !== undefined) {
+        filters = {
+            ...filters,
+            payloads: { ...filters?.payloads, [variant ?? 'true']: JSON.stringify(payload) },
+        };
+    }
+    if (rolloutPercentage !== undefined || payload !== undefined) {
+        patch.filters = filters;
+    }
+    try {
+        await client.requestAsync('PATCH', `/feature_flags/${flag.id}/`, {
+            action: `Updating PostHog flag "${flagKey}"`,
+            forbiddenScope: 'feature_flag:write',
+            body: patch,
+            signal,
+        });
+    }
+    catch (error) {
+        PosthogUtils_1.PosthogUtils.failOrLogError({ logger, ignoreError, error });
+        return;
+    }
+    logger.info(`Updated PostHog feature flag "${flagKey}".`);
+}
+function buildRolloutFilters({ logger, flagKey, filters, rolloutPercentage, }) {
+    const groups = filters?.groups ?? [];
+    if (groups.length === 0) {
+        return { ...filters, groups: [{ properties: [], rollout_percentage: rolloutPercentage }] };
+    }
+    const catchAllIndex = groups.findIndex(isCatchAllGroup);
+    const hasCatchAll = catchAllIndex >= 0;
+    const targetIndex = hasCatchAll ? catchAllIndex : 0;
+    if (!hasCatchAll) {
+        logger.warn(`Flag "${flagKey}" has no catch-all release-condition group; setting rollout_percentage on the first group, which is condition-scoped.`);
+    }
+    else if (groups.length > 1) {
+        logger.warn(`Flag "${flagKey}" has ${groups.length} release-condition groups; setting rollout_percentage only on the catch-all group to preserve the others.`);
+    }
+    const groupsWithRollout = groups.map((group, index) => index === targetIndex ? { ...group, rollout_percentage: rolloutPercentage } : group);
+    return { ...filters, groups: groupsWithRollout };
+}

package/dist/steps/functions/startAgentDeviceRemoteSession.js

@@ -11,12 +11,17 @@ 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 sentry_1 = require("../../sentry");
+const agentDeviceArtifacts_1 = require("../utils/agentDeviceArtifacts");
 const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
 const AGENT_DEVICE_PACKAGE_NAME = 'agent-device';
-const AGENT_DEVICE_REPO_URL = 'https://github.com/callstackincubator/agent-device.git';
+const AGENT_DEVICE_REPO_URL = 'https://github.com/callstack/agent-device.git';
 const SRC_DIR = '/tmp/agent-device-src';
 const DAEMON_JSON_PATH = node_path_1.default.join(node_os_1.default.homedir(), '.agent-device', 'daemon.json');
 const STARTUP_TIMEOUT_MS = 60_000;
+const AGENT_DEVICE_DAEMON_ENV = {
+    AGENT_DEVICE_DAEMON_SERVER_MODE: 'http',
+    AGENT_DEVICE_RETAIN_ARTIFACTS: '1',
+};
 function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
     return new steps_1.BuildFunction({
         namespace: 'eas',
@@ -30,7 +35,7 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
         ],
-        fn: async ({ logger, global }, { inputs, env }) => {
+        fn: async ({ logger, global }, { inputs, env, signal }) => {
             // Fail fast before any expensive setup if the injected env
             // vars are missing: DEVICE_RUN_SESSION_ID (to report the remote config
             // back to the API server), EAS_SIMULATOR_NGROK_TUNNEL_DOMAIN (base domain
@@ -82,10 +87,18 @@ function createStartAgentDeviceRemoteSessionBuildFunction(ctx) {
                 },
                 logger,
             });
-            logger.info('Remote session is live. Keeping the job alive until the session is stopped.');
-            // Keep the turtle job alive so the daemon and tunnel stay reachable
-            // until stopDeviceRunSession cancels the run.
-            await new Promise(() => { });
+            void (0, agentDeviceArtifacts_1.pollAgentDeviceArtifactsForUploadAsync)(ctx, {
+                deviceRunSessionId,
+                daemonUrl: `http://127.0.0.1:${daemonPort}`,
+                daemonToken,
+                logger,
+            });
+            await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
+                ctx,
+                deviceRunSessionId,
+                logger,
+                signal,
+            });
         },
     });
 }
@@ -105,7 +118,7 @@ async function startAgentDeviceDaemonAsync({ packageVersion, env, logger, }) {
         return (0, remoteDeviceRunSession_1.spawnDetached)({
             command: 'node',
             args: [daemonPath],
-            env: { ...env, AGENT_DEVICE_DAEMON_SERVER_MODE: 'http' },
+            env: { ...env, ...AGENT_DEVICE_DAEMON_ENV },
         });
     }
     catch (err) {
@@ -144,7 +157,7 @@ async function startAgentDeviceDaemonFromGitAsync({ packageVersion, env, logger,
         command: 'bun',
         args: ['run', 'src/daemon.ts'],
         cwd: SRC_DIR,
-        env: { ...env, AGENT_DEVICE_DAEMON_SERVER_MODE: 'http' },
+        env: { ...env, ...AGENT_DEVICE_DAEMON_ENV },
     });
 }
 async function cloneAgentDeviceAsync({ packageVersion, env, logger, }) {

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

@@ -1,9 +1,23 @@
 import { type bunyan } from '@expo/logger';
 import { BuildFunction } from '@expo/steps';
+import { z } from 'zod';
 import { CustomBuildContext } from '../../customBuildContext';
 export declare const MIN_ARGENT_REMOTE_SESSION_VERSION = "0.12.0";
+declare const ArgentToolServerStateSchema: z.ZodObject<{
+    port: z.ZodNumber;
+    pid: z.ZodNumber;
+    token: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ArgentToolServerState = z.infer<typeof ArgentToolServerStateSchema>;
 export declare function createStartArgentRemoteSessionBuildFunction(ctx: CustomBuildContext): BuildFunction;
 export declare function warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger, }: {
     packageVersion: string | undefined;
     logger: bunyan;
 }): void;
+export declare function waitForArgentToolServerStateAsync({ stateDir, ancestorPid, timeoutMs, pollIntervalMs, }: {
+    stateDir: string;
+    ancestorPid: number;
+    timeoutMs: number;
+    pollIntervalMs?: number;
+}): Promise<ArgentToolServerState>;
+export {};

package/dist/steps/functions/startArgentRemoteSession.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MIN_ARGENT_REMOTE_SESSION_VERSION = void 0;
 exports.createStartArgentRemoteSessionBuildFunction = createStartArgentRemoteSessionBuildFunction;
 exports.warnIfArgentPackageVersionCannotBeVerified = warnIfArgentPackageVersionCannotBeVerified;
+exports.waitForArgentToolServerStateAsync = waitForArgentToolServerStateAsync;
 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"));
@@ -14,15 +15,19 @@ 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 sentry_1 = require("../../sentry");
+const processes_1 = require("../../utils/processes");
+const retry_1 = require("../../utils/retry");
 const argentArtifacts_1 = require("../utils/argentArtifacts");
 const remoteDeviceRunSession_1 = require("../utils/remoteDeviceRunSession");
 const ARGENT_PACKAGE_NAME = '@swmansion/argent';
 exports.MIN_ARGENT_REMOTE_SESSION_VERSION = '0.12.0';
 const ARGENT_ARTIFACTS_LIST_ENDPOINT_FLAG = 'artifacts-list-endpoint';
-const ARGENT_STATE_FILE = node_path_1.default.join(node_os_1.default.homedir(), '.argent', 'tool-server.json');
+const ARGENT_STATE_DIR = node_path_1.default.join(node_os_1.default.homedir(), '.argent');
 const STARTUP_TIMEOUT_MS = 60_000;
 const ArgentToolServerStateSchema = zod_1.z.object({
     port: zod_1.z.number(),
+    pid: zod_1.z.number(),
     token: zod_1.z.string().optional(),
 });
 function createStartArgentRemoteSessionBuildFunction(ctx) {
@@ -38,7 +43,7 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 allowedValueTypeName: steps_1.BuildStepInputValueTypeName.STRING,
             }),
         ],
-        fn: async ({ logger, global }, { inputs, env }) => {
+        fn: async ({ logger, global }, { inputs, env, signal }) => {
             // Fail fast before any expensive setup if the injected env
             // vars are missing: DEVICE_RUN_SESSION_ID (to report the remote config
             // back to the API server), EAS_SIMULATOR_NGROK_TUNNEL_DOMAIN (base domain
@@ -54,11 +59,11 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
             if (runtimePlatform === steps_1.BuildRuntimePlatform.DARWIN) {
                 await (0, remoteDeviceRunSession_1.selectXcodeDeveloperDirectoryAsync)({ env, logger });
             }
-            // 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('Enabling the Argent artifacts list endpoint flag.');
             await (0, turtle_spawn_1.default)('bunx', [`${ARGENT_PACKAGE_NAME}@${versionSpec}`, 'enable', ARGENT_ARTIFACTS_LIST_ENDPOINT_FLAG], { env, logger });
             logger.info(`Launching ${ARGENT_PACKAGE_NAME}@${versionSpec} tool-server via bunx.`);
+            // Keep Argent itself in foreground mode under the detached bunx process. This preserves
+            // the bunx -> Argent CLI -> tool-server ancestry used to identify the matching state file.
             const argentServer = (0, remoteDeviceRunSession_1.spawnDetached)({
                 command: 'bunx',
                 args: [
@@ -69,19 +74,21 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                     '0',
                     '--idle-timeout',
                     '0',
-                    '--detach',
+                    '--force',
                 ],
                 env,
             });
-            logger.info(`Waiting for argent tool-server state at ${ARGENT_STATE_FILE}.`);
+            if (argentServer.pid === undefined) {
+                throw new eas_build_job_1.SystemError('Failed to start Argent: could not determine the PID of the launched process.');
+            }
+            logger.info(`Waiting for argent tool-server state in ${ARGENT_STATE_DIR}.`);
             let toolServerPort;
             let toolServerToken;
             try {
-                const toolServerState = await (0, remoteDeviceRunSession_1.waitForFileAsync)({
-                    filePath: ARGENT_STATE_FILE,
+                const toolServerState = await waitForArgentToolServerStateAsync({
+                    stateDir: ARGENT_STATE_DIR,
+                    ancestorPid: argentServer.pid,
                     timeoutMs: STARTUP_TIMEOUT_MS,
-                    description: 'argent tool-server state',
-                    parse: parseArgentToolServerState,
                 });
                 toolServerPort = toolServerState.port;
                 toolServerToken = toolServerState.token;
@@ -91,47 +98,67 @@ function createStartArgentRemoteSessionBuildFunction(ctx) {
                 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}.`);
-            void (0, argentArtifacts_1.pollArgentArtifactsForUploadAsync)(ctx, {
+            const artifactPollAbortController = new AbortController();
+            const artifactPollSignal = signal
+                ? AbortSignal.any([signal, artifactPollAbortController.signal])
+                : artifactPollAbortController.signal;
+            const artifactPollingPromise = (0, argentArtifacts_1.pollArgentArtifactsForUploadAsync)(ctx, {
                 deviceRunSessionId,
                 toolsUrl: `http://127.0.0.1:${toolServerPort}`,
                 toolsAuthToken: toolServerToken,
                 logger,
+                signal: artifactPollSignal,
             });
-            const publicToolsUrl = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
-                port: toolServerPort,
-                subdomainPrefix: 'argent',
-                baseDomain: ngrokTunnelDomain,
-                authtoken: ngrokAuthtoken,
-                rewriteHostHeader: true,
-                logger,
-            });
-            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)(ctx, {
+            try {
+                const publicToolsUrl = await (0, remoteDeviceRunSession_1.startNgrokTunnelAsync)({
+                    port: toolServerPort,
+                    subdomainPrefix: 'argent',
                     baseDomain: ngrokTunnelDomain,
-                    env,
+                    authtoken: ngrokAuthtoken,
+                    rewriteHostHeader: true,
                     logger,
-                    timeoutMs: STARTUP_TIMEOUT_MS,
                 });
-                webPreviewUrl = serveSim.previewUrl;
-                logger.info(`Web preview URL: ${webPreviewUrl}`);
+                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)(ctx, {
+                        baseDomain: ngrokTunnelDomain,
+                        env,
+                        logger,
+                        timeoutMs: STARTUP_TIMEOUT_MS,
+                    });
+                    webPreviewUrl = serveSim.previewUrl;
+                    logger.info(`Web preview URL: ${webPreviewUrl}`);
+                }
+                await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    remoteConfig: {
+                        toolsUrl: publicToolsUrl,
+                        ...(toolServerToken ? { toolsAuthToken: toolServerToken } : {}),
+                        ...(webPreviewUrl ? { webPreviewUrl } : {}),
+                    },
+                    logger,
+                });
+                await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
+                    ctx,
+                    deviceRunSessionId,
+                    logger,
+                    signal,
+                });
+            }
+            finally {
+                artifactPollAbortController.abort();
+                try {
+                    await artifactPollingPromise;
+                }
+                catch (err) {
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    sentry_1.Sentry.capture('Could not finish Argent remote session artifact polling', error);
+                    logger.warn({ err: error }, 'Could not finish Argent remote session artifact polling.');
+                }
             }
-            await (0, remoteDeviceRunSession_1.uploadRemoteSessionConfigAsync)({
-                ctx,
-                deviceRunSessionId,
-                remoteConfig: {
-                    toolsUrl: publicToolsUrl,
-                    ...(toolServerToken ? { toolsAuthToken: toolServerToken } : {}),
-                    ...(webPreviewUrl ? { webPreviewUrl } : {}),
-                },
-                logger,
-            });
-            logger.info('Remote session is live. Keeping the job alive until the session is stopped.');
-            // Keep the turtle job alive so the tool-server and tunnel stay reachable
-            // until stopDeviceRunSession cancels the run.
-            await new Promise(() => { });
         },
     });
 }
@@ -153,9 +180,43 @@ function warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger, })
     }
 }
 function parseArgentToolServerState(raw) {
-    const result = ArgentToolServerStateSchema.safeParse(JSON.parse(raw));
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new eas_build_job_1.SystemError('Expected tool-server state to contain valid JSON.', { cause: err });
+    }
+    const result = ArgentToolServerStateSchema.safeParse(json);
     if (!result.success) {
-        throw new eas_build_job_1.SystemError(`Expected tool-server state to contain { "port": <number>, ... }: ${result.error.message}`);
+        throw new eas_build_job_1.SystemError(`Expected tool-server state to contain { "port": <number>, "pid": <number>, ... }: ${result.error.message}`);
     }
     return result.data;
 }
+async function waitForArgentToolServerStateAsync({ stateDir, ancestorPid, timeoutMs, pollIntervalMs = 1_000, }) {
+    const deadline = Date.now() + timeoutMs;
+    let lastError;
+    while (Date.now() < deadline) {
+        try {
+            const stateFileNames = (await node_fs_1.default.promises.readdir(stateDir)).filter(name => name.startsWith('tool-server') && name.endsWith('.json'));
+            for (const stateFileName of stateFileNames) {
+                try {
+                    const state = parseArgentToolServerState(await node_fs_1.default.promises.readFile(node_path_1.default.join(stateDir, stateFileName), 'utf8'));
+                    if (await (0, processes_1.isProcessDescendantOfAsync)(state.pid, ancestorPid)) {
+                        return state;
+                    }
+                }
+                catch (err) {
+                    if (err.code !== 'ENOENT' && !(err instanceof eas_build_job_1.SystemError)) {
+                        throw err;
+                    }
+                }
+            }
+        }
+        catch (err) {
+            lastError = err;
+        }
+        await (0, retry_1.sleepAsync)(pollIntervalMs);
+    }
+    throw new eas_build_job_1.SystemError(`Timed out waiting for an argent tool-server state file belonging to process ${ancestorPid} in ${stateDir}${lastError instanceof Error ? `: ${lastError.message}` : ''}.`);
+}

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

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

package/dist/steps/functions/startIosSimulatorRecordings.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStartIosSimulatorRecordingsBuildFunction = createStartIosSimulatorRecordingsBuildFunction;
+const steps_1 = require("@expo/steps");
+const IosSimulatorRecordingUtils_1 = require("../utils/IosSimulatorRecordingUtils");
+function createStartIosSimulatorRecordingsBuildFunction() {
+    return new steps_1.BuildFunction({
+        namespace: 'eas',
+        id: 'start_ios_simulator_recordings',
+        name: 'Start iOS Simulator recordings',
+        __metricsId: 'eas/start_ios_simulator_recordings',
+        supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
+        fn: async ({ logger }, { env }) => {
+            await IosSimulatorRecordingUtils_1.IosSimulatorRecordingUtils.startAsync({
+                env,
+                logger,
+            });
+        },
+    });
+}

package/dist/steps/functions/startServeSimRemoteSession.js

@@ -11,7 +11,7 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
         name: 'Start serve-sim remote session',
         __metricsId: 'eas/start_serve_sim_remote_session',
         supportedRuntimePlatforms: [steps_1.BuildRuntimePlatform.DARWIN],
-        fn: async ({ logger }, { env }) => {
+        fn: async ({ logger }, { env, signal }) => {
             const deviceRunSessionId = (0, remoteDeviceRunSession_1.getDeviceRunSessionIdOrThrow)(env);
             const ngrokTunnelDomain = (0, remoteDeviceRunSession_1.getNgrokTunnelDomainOrThrow)(env);
             logger.info('Starting serve-sim remote session.');
@@ -30,10 +30,12 @@ function createStartServeSimRemoteSessionBuildFunction(ctx) {
                 remoteConfig: { previewUrl, streamUrl },
                 logger,
             });
-            logger.info('Remote session is live. Keeping the job alive until the session is stopped.');
-            // Keep the turtle job alive so the serve-sim tunnel stays reachable
-            // until stopDeviceRunSession cancels the run.
-            await new Promise(() => { });
+            await (0, remoteDeviceRunSession_1.waitForDeviceRunSessionStoppedAsync)({
+                ctx,
+                deviceRunSessionId,
+                logger,
+                signal,
+            });
         },
     });
 }

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

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