[build-tools] retain Google Play response diagnostics in logs

.changeset/afraid-beds-invite.md

@@ -1,5 +0,0 @@
----
-'eas-cli': patch
----
-
-Regenerate graphql code

.changeset/android-35-adb-memory.md

@@ -1,5 +0,0 @@
----
-'@expo/build-tools': patch
----
-
-Default Android emulators to 4 GiB of RAM to reduce ADB disconnects during large transfers. Retain the 2 GiB default for API 34 and below outside interactive device sessions, and preserve explicit emulator configuration overrides.

.changeset/android-launch-arg-early-validation.md

@@ -1,6 +0,0 @@
----
-'@expo/eas-build-job': minor
-'@expo/build-tools': patch
----
-
-Export `validateAndroidLaunchOptions` and `quoteAndroidShellCommand` from `@expo/eas-build-job`, so Android launch arguments can be checked for NUL characters and length before a simulator session starts, and check them before the emulator boots in agent-device sessions.

.changeset/android-session-memory.md

@@ -0,0 +1,5 @@
+---
+'@expo/build-tools': patch
+---
+
+Allocate 4 GiB of guest RAM to Android emulators in EAS Simulator sessions.

.changeset/build-profile-expo-token-role.md

@@ -1,5 +0,0 @@
----
-'@expo/eas-json': minor
----
-
-Add `permissions.account.role` to build profiles to request a role for the build's `EXPO_TOKEN`.

.changeset/device-session-request-retries.md

@@ -1,5 +0,0 @@
----
-'@expo/build-tools': patch
----
-
-Retry transient failures when reporting that a device run session has started.

.changeset/download-build-network-retries.md

@@ -1,5 +0,0 @@
----
-'@expo/build-tools': patch
----
-
-Retry the build lookup and the archive download of `eas/download_build` on transient failures, and name the failure cause in the build log.

.changeset/eas-simulator-usage.md

@@ -0,0 +1,5 @@
+---
+'eas-cli': minor
+---
+
+Show EAS Simulator minutes in `eas account:usage`.

.changeset/fewer-app-config-reads.md

@@ -1,5 +0,0 @@
----
-'eas-cli': patch
----
-
-Read the app config fewer times in `eas build` and other project commands. An iOS build now runs `expo config` 2 times instead of 6.

.changeset/google-play-request-retries.md

@@ -0,0 +1,5 @@
+---
+'@expo/build-tools': patch
+---
+
+Retry transient Google Play API failures with exponential backoff while keeping uncertain commit results explicit.

.changeset/help-description-style.md

@@ -1,5 +0,0 @@
----
-'eas-cli': none
----
-
-Make command descriptions in `eas --help` consistently lowercase without trailing periods.

.changeset/native-hooks-log-group.md

@@ -1,6 +0,0 @@
----
-'@expo/build-tools': patch
-'@expo/steps': patch
----
-
-Stop printing workflow hook parsing messages in build logs: native builds showed them under an "Unknown build phase" group, and custom builds warned about unknown hook keys and hooks on steps that never run.

.changeset/node-22-23-4.md

@@ -1,6 +0,0 @@
----
-'eas-cli': none
-'@expo/build-tools': none
----
-
-Bump Node.js to 22.23.4 to fix the CVEs in the [October 2026 Node.js security releases](https://nodejs.org/en/blog/vulnerability/october-2026-security-releases).

.changeset/node-install-mirror-fallback.md

@@ -1,5 +0,0 @@
----
-'@expo/worker': patch
----
-
-Retry Node.js installation without the internal Node.js cache mirror when the first attempt fails, while preserving other configured mirrors.

.changeset/sandbox-duration.md

@@ -1,5 +0,0 @@
----
-'@expo/build-tools': minor
----
-
-Stop sandboxes after an optional maximum duration measured from readiness.

.changeset/shared-graphql-client.md

@@ -1,5 +0,0 @@
----
-'eas-cli': patch
----
-
-Share one GraphQL client between the project ID check and the command, so commands send one fewer app query.

.changeset/simulator-get-job-run-errors.md

@@ -1,5 +0,0 @@
----
-'eas-cli': patch
----
-
-Show why a simulator session failed in `eas simulator:get`, and add an `errors` array to its `--json` output. For an unknown error, `simulator:start` and `simulator:get` now show the failed step's error from the session logs.

.changeset/simulator-start-job-run-errors.md

@@ -1,5 +0,0 @@
----
-'eas-cli': patch
----
-
-Show why a simulator session failed in `eas simulator:start`, such as an unknown `--device` name, instead of only the session status.

.changeset/tidy-plays-explain.md

@@ -0,0 +1,7 @@
+---
+'@expo/build-tools': patch
+---
+
+Name the failed Google Play submission phase and include Google's error details in submission errors.
+
+Keep bounded, redacted Google Play error responses in structured warning logs and error metadata for diagnostics.

.changeset/unify-signed-url-uploads.md

@@ -1,5 +0,0 @@
----
-'@expo/build-tools': minor
----
-
-Unify signed URL uploading to a single implementation and use it everywhere

.changeset/worker-mask-logged-errors.md

@@ -1,5 +0,0 @@
----
-'@expo/worker': patch
----
-
-Mask secrets in every field of uploaded job log records, such as logged errors, not only in log messages.

.changeset/workflow-artifact-types.md

@@ -1,6 +0,0 @@
----
-'@expo/eas-build-job': major
-'@expo/build-tools': major
----
-
-Remove legacy artifact type exports and route workflow uploads through workflow storage without file-type categories. Preserve workflow uploads and Maestro reports.

.changeset/workflow-github-context.md

@@ -1,5 +0,0 @@
----
-'@expo/eas-build-job': patch
----
-
-Add types and validation for documented GitHub workflow context fields.

.github/workflows/test-graphql.yml

@@ -22,3 +22,4 @@ jobs:
         uses: ./.github/actions/setup-mise
       - run: yarn install --immutable
       - run: yarn verify-graphql-code
+        working-directory: packages/eas-cli

CHANGELOG.md

@@ -2,59 +2,6 @@
 
 This is the log of notable changes to EAS CLI and related packages.
 
-## [25.3.0](https://github.com/expo/eas-cli/releases/tag/v25.3.0) - 2026-10-20
-
-### 🎉 New features
-
-- [eas-cli] Add a Free plan build limit checkout experiment to `eas build` that offers to open the Starter plan checkout. ([#4633](https://github.com/expo/eas-cli/pull/4633) by [@williamgrosset](https://github.com/williamgrosset))
-- [build-tools] Let serve-sim boot, install and launch Argent iOS sessions. ([#4602](https://github.com/expo/eas-cli/pull/4602) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Let serve-sim boot, install and launch Appium iOS sessions. ([#4603](https://github.com/expo/eas-cli/pull/4603) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Upload the screen recording session manifest as a JSON artifact alongside each video. ([#4689](https://github.com/expo/eas-cli/pull/4689) by [@gwdp](https://github.com/gwdp))
-- [eas-cli] Add a `--system-image` flag to `eas simulator:start` to select the Android SDK system image for the emulator. ([#4500](https://github.com/expo/eas-cli/pull/4500) by [@krystofwoldrich](https://github.com/krystofwoldrich))
-
-### 🐛 Bug fixes
-
-- [build-tools] Quote Android launch arguments and URLs for the device shell in simulator sessions, so values with spaces or shell characters reach `am start` as one argument; pass raw values and remove any shell quoting added as a workaround. ([#4695](https://github.com/expo/eas-cli/pull/4695) by [@brentvatne](https://github.com/brentvatne))
-- [build-tools] Wait up to five minutes for Google Play to finish processing an uploaded bundle before giving up on the edit commit. ([#4700](https://github.com/expo/eas-cli/pull/4700) by [@hSATAC](https://github.com/hSATAC))
-- [build-tools] Reset the device run session idle timer on iOS Simulator preview input. ([#4691](https://github.com/expo/eas-cli/pull/4691) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Forward captured Simulator traffic through the local egress proxy. ([#4598](https://github.com/expo/eas-cli/pull/4598) by [@gwdp](https://github.com/gwdp))
-
-## [25.2.0](https://github.com/expo/eas-cli/releases/tag/v25.2.0) - 2026-10-17
-
-### 🎉 New features
-
-- [eas-cli] Add experimentation client. ([#4558](https://github.com/expo/eas-cli/pull/4558) by [@williamgrosset](https://github.com/williamgrosset))
-- [eas-cli] Add a Free plan build limit guidance experiment for coding agents to `eas build`. ([#4631](https://github.com/expo/eas-cli/pull/4631) by [@williamgrosset](https://github.com/williamgrosset))
-- [build-tools] Let serve-sim boot, install and launch agent-device iOS sessions with the local-egress guard. ([#4544](https://github.com/expo/eas-cli/pull/4544) by [@gwdp](https://github.com/gwdp))
-- [eas-cli] Add `eas simulator:control` to run serve-sim actions, with file upload and download, on a remote iOS simulator session. ([#4641](https://github.com/expo/eas-cli/pull/4641) by [@gwdp](https://github.com/gwdp))
-
-### 🧹 Chores
-
-- [eas-cli] Prepare authenticated simulator action transport and file transfers. ([#4642](https://github.com/expo/eas-cli/pull/4642) by [@gwdp](https://github.com/gwdp))
-
-## [25.1.1](https://github.com/expo/eas-cli/releases/tag/v25.1.1) - 2026-10-16
-
-### 🐛 Bug fixes
-
-- [build-tools] Call www only through the device run session worker API in device run session jobs, and remove their GraphQL fallbacks. ([#4638](https://github.com/expo/eas-cli/pull/4638) by [@szdziedzic](https://github.com/szdziedzic))
-
-## [25.1.0](https://github.com/expo/eas-cli/releases/tag/v25.1.0) - 2026-10-16
-
-### 🎉 New features
-
-- [eas-cli] Show EAS Simulator minutes in `eas account:usage`. ([#4583](https://github.com/expo/eas-cli/pull/4583) by [@LipLoody](https://github.com/LipLoody))
-- [build-tools] Pass the `cors_origins` session input to serve-sim and expo-device-hub as `--cors-origin` origins, so a third party page can call the preview host API, for example with `@expo/hub-client`. ([#4657](https://github.com/expo/eas-cli/pull/4657) by [@krystofwoldrich](https://github.com/krystofwoldrich))
-- [build-tools] Pass the `frame_ancestors` session input to serve-sim and expo-device-hub as `--frame-ancestor` origins, so a third party can embed the preview host. ([#4655](https://github.com/expo/eas-cli/pull/4655) by [@krystofwoldrich](https://github.com/krystofwoldrich))
-- [eas-cli] Add `--cors-origin` to `eas simulator:start`, so a third party page can call the simulator preview API, for example with `@expo/hub-client`. ([#4658](https://github.com/expo/eas-cli/pull/4658) by [@krystofwoldrich](https://github.com/krystofwoldrich))
-- [eas-cli] Add `--frame-ancestor` to `eas simulator:start`, so a third party site can embed the simulator preview, and print the embeddable preview URL. ([#4656](https://github.com/expo/eas-cli/pull/4656) by [@krystofwoldrich](https://github.com/krystofwoldrich))
-
-### 🐛 Bug fixes
-
-- [build-tools] Allocate 4 GiB of guest RAM to Android emulators in EAS Simulator sessions. ([#4640](https://github.com/expo/eas-cli/pull/4640) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Retry transient Google Play API failures with exponential backoff while keeping uncertain commit results explicit. ([#4629](https://github.com/expo/eas-cli/pull/4629) by [@sjchmiela](https://github.com/sjchmiela))
-- [build-tools] Retry Google Play edit commits when an uploaded Android App Bundle is still processing, with bounded retries and progress warnings. ([#4651](https://github.com/expo/eas-cli/pull/4651) by [@sjchmiela](https://github.com/sjchmiela))
-- [build-tools] Report Google Play error responses to Sentry so unexplained submission failures can be classified. ([#4652](https://github.com/expo/eas-cli/pull/4652) by [@sjchmiela](https://github.com/sjchmiela))
-
 ## [25.0.0](https://github.com/expo/eas-cli/releases/tag/v25.0.0) - 2026-10-15
 
 ### 🛠 Breaking changes

CLAUDE.md

@@ -215,7 +215,7 @@ if: ${{ steps.previous_step.outputs.success == 'true' && env.ENVIRONMENT == 'pro
 Artifacts tracked as `ArtifactToUpload`:
 
 - Managed artifacts (APK, IPA, AAB) with specific handling
-- Workflow artifacts for any file
+- Generic artifacts for any file
 - Upload via `ctx.uploadArtifact()` or `upload-artifact` step
 
 ## Package Interdependencies

cli-versions.json

@@ -1,4 +1,4 @@
 {
-  "STAGING": "25.3.0",
-  "PRODUCTION": "25.3.0"
+  "STAGING": "25.0.0",
+  "PRODUCTION": "25.0.0"
 }

lerna.json

@@ -1,5 +1,5 @@
 {
   "npmClient": "yarn",
-  "version": "25.3.0",
+  "version": "25.0.0",
   "$schema": "node_modules/lerna/schemas/lerna-schema.json"
 }

mise.toml

@@ -6,4 +6,4 @@ MISE_NODE_COREPACK = "true"
 actionlint = "1.7.12"
 gcloud = "570.0.0"
 jq = "1.8.1"
-node = "22.23.4"
+node = "22.23.3"

package.json

@@ -7,7 +7,6 @@
   "scripts": {
     "build": "lerna run build",
     "typecheck": "lerna run typecheck",
-    "verify-graphql-code": "lerna run verify-graphql-code --concurrency 1",
     "start": "lerna run watch --stream --parallel",
     "start-allow-unused": "lerna run watch-allow-unused --stream --parallel",
     "watch": "yarn start",

packages/build-tools/CHANGELOG.md

@@ -1,46 +1,5 @@
 # @expo/build-tools
 
-## 25.3.0
-
-### Minor Changes
-
-- Let serve-sim boot, install and launch Argent iOS sessions. ([#4602](https://github.com/expo/eas-cli/pull/4602) by [@gwdp](https://github.com/gwdp))
-- Let serve-sim boot, install and launch Appium iOS sessions. ([#4603](https://github.com/expo/eas-cli/pull/4603) by [@gwdp](https://github.com/gwdp))
-- Upload the screen recording session manifest as a JSON artifact alongside each video. ([#4689](https://github.com/expo/eas-cli/pull/4689) by [@gwdp](https://github.com/gwdp))
-
-### Patch Changes
-
-- Quote Android launch arguments and URLs for the device shell in simulator sessions, so values with spaces or shell characters reach `am start` as one argument; pass raw values and remove any shell quoting added as a workaround. ([#4695](https://github.com/expo/eas-cli/pull/4695) by [@brentvatne](https://github.com/brentvatne))
-- Wait up to five minutes for Google Play to finish processing an uploaded bundle before giving up on the edit commit. ([#4700](https://github.com/expo/eas-cli/pull/4700) by [@hSATAC](https://github.com/hSATAC))
-- Reset the device run session idle timer on iOS Simulator preview input. ([#4691](https://github.com/expo/eas-cli/pull/4691) by [@gwdp](https://github.com/gwdp))
-- Forward captured Simulator traffic through the local egress proxy. ([#4598](https://github.com/expo/eas-cli/pull/4598) by [@gwdp](https://github.com/gwdp))
-
-## 25.2.0
-
-### Minor Changes
-
-- Let serve-sim boot, install and launch agent-device iOS sessions with the local-egress guard. ([#4544](https://github.com/expo/eas-cli/pull/4544) by [@gwdp](https://github.com/gwdp))
-
-## 25.1.1
-
-### Patch Changes
-
-- Call www only through the device run session worker API in device run session jobs, and remove their GraphQL fallbacks. ([#4638](https://github.com/expo/eas-cli/pull/4638) by [@szdziedzic](https://github.com/szdziedzic))
-
-## 25.1.0
-
-### Minor Changes
-
-- Pass the `cors_origins` session input to serve-sim and expo-device-hub as `--cors-origin` origins, so a third party page can call the preview host API, for example with `@expo/hub-client`. ([#4657](https://github.com/expo/eas-cli/pull/4657) by [@krystofwoldrich](https://github.com/krystofwoldrich))
-- Pass the `frame_ancestors` session input to serve-sim and expo-device-hub as `--frame-ancestor` origins, so a third party can embed the preview host. ([#4655](https://github.com/expo/eas-cli/pull/4655) by [@krystofwoldrich](https://github.com/krystofwoldrich))
-
-### Patch Changes
-
-- Allocate 4 GiB of guest RAM to Android emulators in EAS Simulator sessions. ([#4640](https://github.com/expo/eas-cli/pull/4640) by [@gwdp](https://github.com/gwdp))
-- Retry transient Google Play API failures with exponential backoff while keeping uncertain commit results explicit. ([#4629](https://github.com/expo/eas-cli/pull/4629) by [@sjchmiela](https://github.com/sjchmiela))
-- Retry Google Play edit commits when an uploaded Android App Bundle is still processing, with bounded retries and progress warnings. ([#4651](https://github.com/expo/eas-cli/pull/4651) by [@sjchmiela](https://github.com/sjchmiela))
-- Report Google Play error responses to Sentry so unexplained submission failures can be classified. ([#4652](https://github.com/expo/eas-cli/pull/4652) by [@sjchmiela](https://github.com/sjchmiela))
-
 ## 25.0.0
 
 ### Minor Changes

packages/build-tools/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "25.3.0",
+  "version": "25.0.0",
   "bugs": "https://github.com/expo/eas-cli/issues",
   "license": "BUSL-1.1",
   "author": "Expo <[email protected]>",
@@ -26,7 +26,7 @@
     "build:egress-guard": "resources/egress-guard/build.sh",
     "test:egress-guard": "resources/egress-guard/tests/run-policy-tests.sh && resources/egress-guard/tests/run-guard-tests.sh",
     "typecheck": "tsc",
-    "generate-appium-commands": "mise exec [email protected]3.4 -- node scripts/generate-appium-commands.js",
+    "generate-appium-commands": "mise exec [email protected]2.0 -- node scripts/generate-appium-commands.js",
     "prepack": "rimraf dist \"*.tsbuildinfo\" && yarn gql && tsc -p tsconfig.build.json",
     "jest-unit": "jest --config jest/unit-config.ts",
     "jest-integration": "jest --config jest/integration-config.ts",
@@ -36,23 +36,22 @@
     "clean": "rimraf node_modules dist coverage \"*.tsbuildinfo\"",
     "gql": "gql.tada generate-schema ${API_SERVER_URL:-https://api.expo.dev}/graphql --output ./schema.graphql && gql.tada generate-output",
     "gql:local": "API_SERVER_URL=http://api.expo.test yarn gql",
-    "verify-graphql-code": "./scripts/verify-graphql.sh",
     "test": "yarn jest-unit"
   },
   "dependencies": {
     "@expo/config": "55.0.10",
     "@expo/config-plugins": "55.0.7",
-    "@expo/downloader": "25.3.0",
-    "@expo/eas-build-job": "25.3.0",
+    "@expo/downloader": "25.0.0",
+    "@expo/eas-build-job": "25.0.0",
     "@expo/env": "^0.4.0",
-    "@expo/logger": "25.3.0",
+    "@expo/logger": "25.0.0",
     "@expo/package-manager": "1.9.10",
     "@expo/plist": "^0.3.5",
     "@expo/results": "^1.0.0",
     "@expo/spawn-async": "1.7.2",
-    "@expo/steps": "25.3.0",
-    "@expo/template-file": "25.3.0",
-    "@expo/turtle-spawn": "25.3.0",
+    "@expo/steps": "25.0.0",
+    "@expo/template-file": "25.0.0",
+    "@expo/turtle-spawn": "25.0.0",
     "@expo/xcpretty": "^4.3.1",
     "@ngrok/ngrok": "1.7.0",
     "@sentry/node": "7.77.0",

packages/build-tools/scripts/verify-graphql.sh

@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-
-set -eox pipefail
-
-# Generated GraphQL files are untracked, so always regenerate and check compatibility.
-yarn gql
-yarn run -T lerna run build --scope @expo/build-tools --include-dependencies

packages/build-tools/src/common/__tests__/jobHooks.test.ts

@@ -16,13 +16,11 @@ function createCtx(
   { workingdir = '/tmp/wd' }: { workingdir?: string } = {}
 ): {
   ctx: BuildContext<Ios.Job>;
-  info: jest.Mock;
   warn: jest.Mock;
 } {
-  const info = jest.fn();
   const warn = jest.fn();
   const logger = {
-    info,
+    info: jest.fn(),
     debug: jest.fn(),
     error: jest.fn(),
     warn,
@@ -38,7 +36,7 @@ function createCtx(
       workingdir,
     }
   );
-  return { ctx, info, warn };
+  return { ctx, warn };
 }
 
 // Project checkout lives at <workingdir>/build (job projectRootDirectory is '.').
@@ -81,31 +79,22 @@ describe(parseJobHooksAsync, () => {
     });
   });
 
-  it('writes nothing to the build log while parsing', async () => {
-    const { ctx, info, warn } = createCtx({
-      before_install_node_modules: [{ run: 'echo hi' }],
-      before_submit: [{ run: 'echo hi' }],
-      before_bogus: [{ run: 'echo hi' }],
-    });
-    await parseJobHooksAsync(ctx, INSTALL);
-    expect(info).not.toHaveBeenCalled();
-    expect(warn).not.toHaveBeenCalled();
-  });
-
-  it('treats an unknown hook key as inert', async () => {
-    const { ctx } = createCtx({
+  it('treats an unknown hook key as inert and warns', async () => {
+    const { ctx, warn } = createCtx({
       before_bogus: [{ run: 'echo hi' }],
     });
     const parsed = await parseJobHooksAsync(ctx, INSTALL);
     expect(parsed!.hookEntriesByKey).toEqual({});
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('unknown hook key "before_bogus"'));
   });
 
-  it('shape-checks a registered-but-unwrapped key, then skips it', async () => {
-    const { ctx } = createCtx({
+  it('shape-checks a registered-but-unwrapped key, then warns and skips it', async () => {
+    const { ctx, warn } = createCtx({
       before_submit: [{ run: 'echo hi' }],
     });
     const parsed = await parseJobHooksAsync(ctx, INSTALL);
     expect(parsed!.hookEntriesByKey.before_submit).toBeUndefined();
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('hooks.before_submit'));
   });
 
   it('shape-validates a registered-but-unwrapped key even though it is skipped', async () => {
@@ -203,9 +192,10 @@ describe(parseJobHooksAsync, () => {
   });
 
   it('never loads a composite function referenced under a registered-but-unwrapped key', async () => {
-    const { ctx } = createCtx({ before_submit: [{ uses: './.eas/functions/missing' }] });
+    const { ctx, warn } = createCtx({ before_submit: [{ uses: './.eas/functions/missing' }] });
     const parsed = await parseJobHooksAsync(ctx, INSTALL);
     expect(parsed!.hookEntriesByKey).toEqual({});
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('hooks.before_submit'));
   });
 
   it('wraps a cross-key duplicate step id in the aggregate error', async () => {

packages/build-tools/src/common/__tests__/projectSources.test.ts

@@ -12,7 +12,6 @@ import spawn from '@expo/turtle-spawn';
 import { randomBytes, randomUUID } from 'crypto';
 import { vol } from 'memfs';
 import fetch, { Response } from 'node-fetch';
-import { Readable } from 'stream';
 import { setTimeout } from 'timers/promises';
 
 import { createMockLogger } from '../../__tests__/utils/logger';
@@ -391,13 +390,7 @@ describe('projectSources', () => {
       ctx.graphqlClient.mutation = mockGraphqlMutation as any;
 
       const fetchMock = jest.mocked(fetch);
-      let uploadedBody = '';
-      fetchMock.mockImplementation(async (_url, request) => {
-        for await (const chunk of request!.body as Readable) {
-          uploadedBody += chunk;
-        }
-        return { ok: true } as Response;
-      });
+      fetchMock.mockImplementation(async () => ({ ok: true }) as Response);
       fetchMock.mockResolvedValueOnce({
         ok: true,
         json: async () => ({ data: ctx.job.projectArchive }),
@@ -421,14 +414,10 @@ describe('projectSources', () => {
         'https://storage.example.com/upload',
         expect.objectContaining({
           method: 'PUT',
-          headers: {
-            'x-custom-header': 'value',
-            'content-length': '63',
-            'content-type': 'text/plain;charset=UTF-8',
-          },
+          headers: { 'x-custom-header': 'value' },
+          body: '{"archiveContent":["project/README.md","project/package.json"]}',
         })
       );
-      expect(uploadedBody).toBe('{"archiveContent":["project/README.md","project/package.json"]}');
 
       // Verify build metadata was updated
       expect(mockGraphqlMutation).toHaveBeenNthCalledWith(

packages/build-tools/src/common/hookableBuildPhase.ts

@@ -44,8 +44,9 @@ export async function runHookableBuildPhaseAsync<TJob extends BuildJob, T>({
     if (hooks) {
       try {
         await runHookEntriesAsync({ ctx, hooks, timing: 'after', anchor, anchorFailed: true });
-      } catch {
-        // The phase error wins.
+      } catch (hookError) {
+        // The phase error wins; still surface the after-hook failure in the log.
+        ctx.logger.error({ err: hookError }, `after_${anchor} hook failed`);
       }
     }
     throw phaseError;

packages/build-tools/src/common/jobHooks.ts

@@ -53,17 +53,19 @@ export async function parseJobHooksAsync<TJob extends BuildJob>(
   const globalContext = new BuildStepGlobalContext(customBuildContext, false);
   // Hook steps run in the checked-out project directory, not the pre-checkout
   // target directory the global context defaults to.
-  globalContext.markAsCheckedOut();
+  globalContext.markAsCheckedOut(ctx.logger);
 
   const externalFunctions = getEasFunctions(customBuildContext);
   const externalFunctionGroups = getEasFunctionGroups(customBuildContext);
 
   // Shape-validate every REGISTERED key, reachable or not (steps-world parity:
-  // a malformed `before_submit` fails a steps build, so it fails here too). An
-  // unknown key is inert — a key newer than this worker must be ignored, never
-  // fail the job.
+  // a malformed `before_submit` fails a steps build, so it fails here too), and
+  // warn on keys this build won't run. An unknown key is inert — a key newer
+  // than this worker must be ignored, never fail the job.
   for (const [key, steps] of Object.entries(hooks)) {
-    if (parseHookKey(key) === null) {
+    const parsed = parseHookKey(key);
+    if (parsed === null) {
+      ctx.logger.warn(`Ignoring unknown hook key "${key}".`);
       continue;
     }
     if (Array.isArray(steps) && steps.length === 0) {
@@ -79,6 +81,15 @@ export async function parseJobHooksAsync<TJob extends BuildJob>(
         { cause: err }
       );
     }
+    // Registered but not wrapped by this build: shape-checked above, then
+    // skipped. Function existence is deliberately NOT checked (that happens only
+    // during construction) — an unknown `uses:` under an unwrapped key warns
+    // rather than failing the build.
+    if (!wrappedAnchors.includes(parsed.anchorId)) {
+      ctx.logger.warn(
+        `Ignoring "hooks.${key}": this build does not run the "${parsed.anchorId}" step.`
+      );
+    }
   }
 
   // Construct entries for the wrapped anchors in EXECUTION order (per anchor,

packages/build-tools/src/common/projectSources.ts

@@ -5,13 +5,13 @@ import { asyncResult } from '@expo/results';
 import spawn from '@expo/turtle-spawn';
 import fs from 'fs/promises';
 import { graphql } from 'gql.tada';
+import fetch from 'node-fetch';
 import nullthrows from 'nullthrows';
 import path from 'path';
 import { z } from 'zod';
 
 import { shallowCloneRepositoryAsync } from './git';
 import { BuildContext } from '../context';
-import { uploadContentWithSignedUrl } from '../storage/uploadWithSignedUrl';
 import { turtleFetch } from '../utils/turtleFetch';
 
 export async function prepareProjectSourcesAsync<TJob extends Job>(
@@ -208,9 +208,10 @@ async function uploadProjectMetadataAsync(
     headers: Record<string, string>;
   };
 
-  await uploadContentWithSignedUrl({
-    signedUrl: uploadSession,
-    content: JSON.stringify({ archiveContent: sortedFiles }),
+  await fetch(uploadSession.url, {
+    method: 'PUT',
+    body: JSON.stringify({ archiveContent: sortedFiles }),
+    headers: uploadSession.headers,
   });
 
   const updateMetadataResult = await ctx.graphqlClient

packages/build-tools/src/context.ts

@@ -4,11 +4,13 @@ import {
   BuildPhaseResult,
   Env,
   EnvironmentSecretType,
+  GenericArtifactType,
   Job,
   LogMarker,
   ManagedArtifactType,
   Metadata,
   errors,
+  isGenericArtifact,
 } from '@expo/eas-build-job';
 import { BuildTrigger } from '@expo/eas-build-job/dist/common';
 import { bunyan } from '@expo/logger';
@@ -40,7 +42,7 @@ export type ArtifactToUpload =
       paths: string[];
     }
   | {
-      type: null;
+      type: GenericArtifactType;
       name: string;
       paths: string[];
       metadata?: Record<string, unknown>;
@@ -239,7 +241,7 @@ export class BuildContext<TJob extends Job = Job> {
     logger: bunyan;
   }): Promise<{ artifactId: string | null }> {
     const result = await this._uploadArtifact({ artifact, logger });
-    if (result.filename && artifact.type !== null) {
+    if (result.filename && !isGenericArtifact(artifact)) {
       this.artifacts[artifact.type] = result.filename;
     }
     return { artifactId: result.artifactId ?? null };

packages/build-tools/src/index.ts

@@ -3,16 +3,8 @@ import HttpLogStream from './logging/HttpLogStream';
 import RemoteLoggerStream from './logging/RemoteLoggerStream';
 
 export { Builders, HttpLogStream, RemoteLoggerStream };
-export {
-  SignedUrlUploadApiError,
-  SignedUrlUploadNetworkError,
-  uploadWithSignedUrl,
-} from './storage/uploadWithSignedUrl';
-export type {
-  SignedUrl,
-  UploadWithSignedUrlOptions,
-  UploadWithSignedUrlParams,
-} from './storage/uploadWithSignedUrl';
+export { uploadWithSignedUrl } from './storage/uploadWithSignedUrl';
+export type { SignedUrl, UploadWithSignedUrlParams } from './storage/uploadWithSignedUrl';
 export { downloadCacheAsync } from './steps/functions/restoreCache';
 export { uploadCacheAsync } from './steps/functions/saveCache';
 

packages/build-tools/src/logging/RemoteLoggerStream.ts

@@ -56,10 +56,10 @@ class RemoteLoggerStream extends Writable {
     return null;
   }
 
-  public async init(): Promise<void> {
+  public async init(): Promise<string> {
     this.fileHandle = await fs.open(this.temporaryLogsPath, 'w+', 0o660);
     this.flushInterval = setInterval(() => this.flush(), this.options.uploadIntervalMs);
-    await this.flush(true);
+    return (await this.flush(true)) as string;
   }
 
   public async cleanUp(): Promise<void> {
@@ -121,18 +121,17 @@ class RemoteLoggerStream extends Writable {
     }
   }
 
-  private async flush(force = false): Promise<void> {
+  private async flush(force = false): Promise<string | void> {
     if (force || this.hasChangesToUpload) {
       if (this.uploadingPromise) {
         await this.uploadingPromise;
-        await this.flush(force);
-        return;
+        return await this.flush(force);
       }
-      await this.flushInternal();
+      return await this.flushInternal();
     }
   }
 
-  private async flushInternal(): Promise<void> {
+  private async flushInternal(): Promise<string | void> {
     await this.safeWriteToFile();
 
     let resolveFn: PromiseResolveFn;
@@ -140,17 +139,21 @@ class RemoteLoggerStream extends Writable {
     this.uploadingPromise = new Promise(res => {
       resolveFn = res;
     });
-    await this.upload()
+    return await this.upload()
+      .then(result => {
+        return result;
+      })
       .catch(err => {
         this.logger.error({ err }, 'Failed to upload logs file');
       })
-      .then(() => {
+      .then(result => {
         this.uploadingPromise = undefined;
         resolveFn();
+        return result;
       });
   }
 
-  private async upload(): Promise<void> {
+  private async upload(): Promise<string | void> {
     if (!this.uploadMethod) {
       return;
     }
@@ -162,7 +165,7 @@ class RemoteLoggerStream extends Writable {
       );
     };
 
-    await uploadWithSignedUrl({
+    return await uploadWithSignedUrl({
       signedUrl: this.uploadMethod.signedUrl,
       srcGeneratorAsync,
     });

packages/build-tools/src/steps/functions/__tests__/checkout.test.ts

@@ -48,10 +48,7 @@ describe(createCheckoutBuildFunction, () => {
   });
 
   it('moves project sources to the target directory when no inputs are given', async () => {
-    const logger = createMockLogger();
-    jest.mocked(logger.child).mockReturnValue(logger);
     const { globalCtx, executeAsync } = createCheckoutStep({
-      logger,
       projectArchive: GIT_PROJECT_ARCHIVE,
     });
 
@@ -59,9 +56,6 @@ describe(createCheckoutBuildFunction, () => {
 
     expect(await vol.promises.readFile(`${projectTargetDirectory}/app.json`, 'utf8')).toBe('{}');
     expect(globalCtx.wasCheckedOut()).toBe(true);
-    expect(logger.info).toHaveBeenCalledWith(
-      expect.stringContaining('Changing default working directory to')
-    );
     expect(fetchAndCheckoutRefAsync).not.toHaveBeenCalled();
   });
 
@@ -102,11 +96,14 @@ describe(createCheckoutBuildFunction, () => {
   });
 
   it('rejects the ref input when the project is already checked out', async () => {
+    const logger = createMockLogger();
+    jest.mocked(logger.child).mockReturnValue(logger);
     const { globalCtx, executeAsync } = createCheckoutStep({
+      logger,
       projectArchive: GIT_PROJECT_ARCHIVE,
       callInputs: { ref: 'feature/add-icon' },
     });
-    globalCtx.markAsCheckedOut();
+    globalCtx.markAsCheckedOut(logger);
 
     await expect(executeAsync()).rejects.toMatchObject({
       errorCode: 'EAS_CHECKOUT_REF_AFTER_CHECKOUT',

packages/build-tools/src/steps/functions/__tests__/deviceSessionHost-orchestration.test.ts

@@ -79,11 +79,9 @@ beforeEach(() => {
     apiUrl: 'https://preview.example.test',
     closeAsync: closePreview,
   });
-  jest.mocked(startDeviceSessionHostAsync).mockResolvedValue({
-    openPreviewAsync: openPreview,
-    getLastPreviewActivityAt: jest.fn(),
-    finishAsync: finishHost,
-  });
+  jest
+    .mocked(startDeviceSessionHostAsync)
+    .mockResolvedValue({ openPreviewAsync: openPreview, finishAsync: finishHost });
   jest.mocked(spawnDetached).mockReturnValue({
     pid: undefined,
     getOutput: () => '',
@@ -110,11 +108,7 @@ describe.each([
   ['Appium', createStartAppiumRemoteSessionBuildFunction],
   ['Agent Device', createStartAgentDeviceSessionBuildFunction],
 ] as const)('%s host ownership', (name, createFunction) => {
-  async function runAsync(
-    publicPreview?: boolean,
-    frameAncestors?: string[],
-    corsOrigins?: string[]
-  ) {
+  async function runAsync(publicPreview?: boolean) {
     const fn = createFunction({} as CustomBuildContext);
     await fn.fn!(
       {
@@ -124,11 +118,7 @@ describe.each([
       {
         // Inputs a step does not get default to undefined, like in a real step call.
         inputs: new Proxy(
-          {
-            public_preview: { value: publicPreview },
-            frame_ancestors: { value: frameAncestors },
-            cors_origins: { value: corsOrigins },
-          } as Record<string, { value: unknown }>,
+          { public_preview: { value: publicPreview } } as Record<string, { value: unknown }>,
           {
             get: (target, id: string) => target[id] ?? { value: undefined },
           }
@@ -189,34 +179,6 @@ describe.each([
     );
   });
 
-  it('maps frame_ancestors to the host and defaults to none', async () => {
-    await runAsync(undefined, ['https://embed.example.test']);
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({ frameAncestors: ['https://embed.example.test'] })
-    );
-    jest.mocked(startDeviceSessionHostAsync).mockClear();
-    await runAsync();
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({ frameAncestors: [] })
-    );
-  });
-
-  it('maps cors_origins to the host and defaults to none', async () => {
-    await runAsync(undefined, undefined, ['https://app.example.test']);
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({ corsOrigins: ['https://app.example.test'] })
-    );
-    jest.mocked(startDeviceSessionHostAsync).mockClear();
-    await runAsync();
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({ corsOrigins: [] })
-    );
-  });
-
   it('stops automation while recording finalization or upload is pending', async () => {
     let release!: () => void;
     let stopped!: () => void;

packages/build-tools/src/steps/functions/__tests__/downloadBuild.test.ts

@@ -11,7 +11,6 @@ import * as tar from 'tar';
 
 import { createGlobalContextMock } from '../../../__tests__/utils/context';
 import { createMockLogger } from '../../../__tests__/utils/logger';
-import { Datadog } from '../../../datadog';
 import * as files from '../../../utils/files';
 import { createDownloadBuildFunction, downloadBuildAsync } from '../downloadBuild';
 
@@ -31,17 +30,11 @@ const APPLICATION_ARCHIVE_URL = `https://expo.dev/artifacts/eas/${randomUUID()}.
 function createMockGraphqlClient({
   applicationArchiveUrl,
   error,
-  transientError,
 }: {
   applicationArchiveUrl?: string | null;
   error?: Error;
-  transientError?: Error;
 }): Client {
-  const toPromise = jest.fn();
-  if (transientError) {
-    toPromise.mockResolvedValueOnce({ error: transientError, data: undefined });
-  }
-  toPromise.mockResolvedValue(
+  const toPromise = jest.fn().mockResolvedValue(
     error
       ? { error, data: undefined }
       : {
@@ -69,7 +62,7 @@ function createSuccessfulResponse({
   url,
   headers,
 }: {
-  body: Buffer | Readable;
+  body: Buffer;
   url: string;
   headers?: Record<string, string>;
 }): Response {
@@ -79,7 +72,7 @@ function createSuccessfulResponse({
 
   return {
     ok: true,
-    body: body instanceof Readable ? body : Readable.from(body),
+    body: Readable.from(body),
     url,
     headers: {
       get: (name: string): string | null => normalizedHeaders[name.toLowerCase()] ?? null,
@@ -87,47 +80,6 @@ function createSuccessfulResponse({
   } as unknown as Response;
 }
 
-function createUndiciNetworkError(code: string): CombinedError {
-  return new CombinedError({
-    networkError: Object.assign(new TypeError('fetch failed'), {
-      cause: Object.assign(new Error(`read ${code}`), { code }),
-    }),
-  });
-}
-
-const { FetchError: ActualFetchError } = jest.requireActual(
-  'node-fetch'
-) as typeof import('node-fetch');
-
-function createSocketFetchError(url: string, code: string): Error {
-  return new ActualFetchError(`request to ${url} failed, reason: connect ${code}`, 'system', {
-    code,
-  } as any);
-}
-
-function useFakeBackoffTimers(): void {
-  // Streams and fs callbacks need the real nextTick and setImmediate; only the backoff timers are faked.
-  jest.useFakeTimers({ doNotFake: ['nextTick', 'setImmediate', 'queueMicrotask'] });
-}
-
-const MAX_IO_TURNS_BEFORE_BACKOFF = 1000;
-
-async function waitForBackoffTimerAsync(): Promise<void> {
-  for (let turns = 0; jest.getTimerCount() === 0; turns++) {
-    if (turns === MAX_IO_TURNS_BEFORE_BACKOFF) {
-      throw new Error('No backoff timer was scheduled.');
-    }
-    await new Promise(resolve => setImmediate(resolve));
-  }
-}
-
-async function fireBackoffTimersAsync(count: number): Promise<void> {
-  for (let i = 0; i < count; i++) {
-    await waitForBackoffTimerAsync();
-    await jest.advanceTimersToNextTimerAsync();
-  }
-}
-
 async function createFlatAppTarGzBufferAsync(): Promise<Buffer> {
   const sourceDirectory = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'flat-app-source-'));
   const archivePath = path.join(os.tmpdir(), `${randomUUID()}.tar.gz`);
@@ -156,11 +108,6 @@ async function createFlatAppTarGzBufferAsync(): Promise<Buffer> {
   }
 }
 
-afterEach(() => {
-  jest.useRealTimers();
-  jest.restoreAllMocks();
-});
-
 describe('downloadBuild', () => {
   it('downloads from applicationArchiveUrl returned by GraphQL', async () => {
     const buildId = randomUUID();
@@ -518,13 +465,13 @@ describe('downloadBuild', () => {
     expect(jest.mocked(fetch)).not.toHaveBeenCalled();
   });
 
-  it('throws SystemError with the cause code after retrying a failing build lookup', async () => {
-    useFakeBackoffTimers();
+  it('throws SystemError when GraphQL request fails with a network error', async () => {
     const buildId = randomUUID();
     const graphqlClient = createMockGraphqlClient({
-      error: createUndiciNetworkError('ECONNRESET'),
+      error: new CombinedError({
+        networkError: new Error('Network request failed'),
+      }),
     });
-    const datadogLog = jest.spyOn(Datadog, 'log');
 
     const promise = downloadBuildAsync({
       logger: createLogger({ name: 'test' }),
@@ -533,81 +480,19 @@ describe('downloadBuild', () => {
       robotAccessToken: null,
       extensions: ['app'],
     });
-    const rejection = expect(promise).rejects.toBeInstanceOf(SystemError);
-    await fireBackoffTimersAsync(5);
 
-    await rejection;
+    await expect(promise).rejects.toBeInstanceOf(SystemError);
     await expect(promise).rejects.toMatchObject({
-      message: `Could not fetch build ${buildId}: [Network] fetch failed (ECONNRESET)`,
-    });
-    expect(graphqlClient.query).toHaveBeenCalledTimes(6);
-    expect(datadogLog).toHaveBeenCalledWith('download_build.build_lookup failed on attempt 6', {
-      event: 'network_retry',
-      operation: 'download_build.build_lookup',
-      outcome: 'failed',
-      attempts: '6',
-      code: 'ECONNRESET',
+      message: `Could not fetch build ${buildId}: [Network] Network request failed`,
     });
+
     expect(jest.mocked(fetch)).not.toHaveBeenCalled();
   });
 
-  it.each([
-    ['a network error', createUndiciNetworkError('ECONNRESET'), 'ECONNRESET'],
-    [
-      'a transient GraphQL error',
-      new CombinedError({
-        graphQLErrors: [
-          {
-            message: 'Too many requests',
-            extensions: { isTransient: true, errorCode: 'TOO_MANY_REQUESTS' },
-          },
-        ],
-        response: { status: 200 },
-      }),
-      'TOO_MANY_REQUESTS',
-    ],
-  ])('downloads after a build lookup that failed once with %s', async (_, transientError, code) => {
-    useFakeBackoffTimers();
-    const buildId = randomUUID();
-    const graphqlClient = createMockGraphqlClient({
-      applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
-      transientError,
-    });
-    jest
-      .mocked(fetch)
-      .mockResolvedValue(
-        createSuccessfulResponse({ body: Buffer.from('hello'), url: 'https://cdn.test/app.apk' })
-      );
-
-    const datadogLog = jest.spyOn(Datadog, 'log');
-
-    const promise = downloadBuildAsync({
-      logger: createLogger({ name: 'test' }),
-      buildId,
-      graphqlClient,
-      robotAccessToken: null,
-      extensions: ['apk'],
-    });
-    await fireBackoffTimersAsync(1);
-
-    const { artifactPath } = await promise;
-    expect(path.basename(artifactPath)).toBe('app.apk');
-    expect(graphqlClient.query).toHaveBeenCalledTimes(2);
-    expect(datadogLog).toHaveBeenCalledWith('download_build.build_lookup recovered on attempt 2', {
-      event: 'network_retry',
-      operation: 'download_build.build_lookup',
-      outcome: 'recovered',
-      attempts: '2',
-      code,
-    });
-  });
-
   it('throws SystemError when GraphQL request returns 5xx', async () => {
-    useFakeBackoffTimers();
     const buildId = randomUUID();
     const graphqlClient = createMockGraphqlClient({
-      error: new CombinedError({
-        graphQLErrors: [{ message: 'Internal Server Error' }],
+      error: Object.assign(new Error('Internal Server Error'), {
         response: { status: 500 },
       }),
     });
@@ -619,14 +504,12 @@ describe('downloadBuild', () => {
       robotAccessToken: null,
       extensions: ['app'],
     });
-    const rejection = expect(promise).rejects.toBeInstanceOf(SystemError);
-    await fireBackoffTimersAsync(5);
 
-    await rejection;
+    await expect(promise).rejects.toBeInstanceOf(SystemError);
     await expect(promise).rejects.toMatchObject({
-      message: `Could not fetch build ${buildId}: [GraphQL] Internal Server Error`,
+      message: `Could not fetch build ${buildId}: Internal Server Error`,
     });
-    expect(graphqlClient.query).toHaveBeenCalledTimes(6);
+
     expect(jest.mocked(fetch)).not.toHaveBeenCalled();
   });
 
@@ -651,193 +534,10 @@ describe('downloadBuild', () => {
       errorCode: 'EAS_DOWNLOAD_BUILD_FETCH_FAILED',
       message: `Could not fetch build ${buildId}: [GraphQL] Build not found`,
     });
-    expect(graphqlClient.query).toHaveBeenCalledTimes(1);
+
     expect(jest.mocked(fetch)).not.toHaveBeenCalled();
   });
 
-  it('downloads after an archive request that failed once with a socket error', async () => {
-    useFakeBackoffTimers();
-    const graphqlClient = createMockGraphqlClient({});
-    jest
-      .mocked(fetch)
-      .mockRejectedValueOnce(createSocketFetchError(APPLICATION_ARCHIVE_URL, 'ECONNRESET'))
-      .mockResolvedValueOnce(
-        createSuccessfulResponse({ body: Buffer.from('hello'), url: 'https://cdn.test/app.apk' })
-      );
-
-    const promise = downloadBuildAsync({
-      logger: createLogger({ name: 'test' }),
-      applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
-      graphqlClient,
-      robotAccessToken: null,
-      extensions: ['apk'],
-    });
-    await fireBackoffTimersAsync(1);
-
-    const { artifactPath } = await promise;
-    expect(path.basename(artifactPath)).toBe('app.apk');
-    expect(jest.mocked(fetch)).toHaveBeenCalledTimes(2);
-  });
-
-  it('throws SystemError with the cause code after retrying a failing build archive request', async () => {
-    useFakeBackoffTimers();
-    const graphqlClient = createMockGraphqlClient({
-      applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
-    });
-    jest
-      .mocked(fetch)
-      .mockRejectedValue(createSocketFetchError(APPLICATION_ARCHIVE_URL, 'ETIMEDOUT'));
-    const datadogLog = jest.spyOn(Datadog, 'log');
-
-    const promise = downloadBuildAsync({
-      logger: createLogger({ name: 'test' }),
-      buildId: randomUUID(),
-      graphqlClient,
-      robotAccessToken: null,
-      extensions: ['apk'],
-    });
-    const rejection = expect(promise).rejects.toBeInstanceOf(SystemError);
-    await fireBackoffTimersAsync(5);
-
-    await rejection;
-    await expect(promise).rejects.toMatchObject({
-      message: `Could not download the application archive: request to ${APPLICATION_ARCHIVE_URL} failed, reason: connect ETIMEDOUT`,
-    });
-    expect(jest.mocked(fetch)).toHaveBeenCalledTimes(6);
-    expect(datadogLog).toHaveBeenCalledWith('download_build.archive_download failed on attempt 6', {
-      event: 'network_retry',
-      operation: 'download_build.archive_download',
-      outcome: 'failed',
-      attempts: '6',
-      code: 'ETIMEDOUT',
-    });
-  });
-
-  function createBrokenBody(code: string): Readable {
-    return Readable.from(
-      (async function* () {
-        yield Buffer.from('he');
-        throw Object.assign(new Error(`body failed with ${code}`), { code });
-      })()
-    );
-  }
-
-  it.each(['ERR_STREAM_PREMATURE_CLOSE', 'ECONNRESET'])(
-    'downloads again when the archive body breaks off with %s after the headers arrived',
-    async code => {
-      useFakeBackoffTimers();
-      const graphqlClient = createMockGraphqlClient({});
-      const brokenBody = createBrokenBody(code);
-      jest
-        .mocked(fetch)
-        .mockResolvedValueOnce(
-          createSuccessfulResponse({ body: brokenBody, url: 'https://cdn.test/app.apk' })
-        )
-        .mockResolvedValueOnce(
-          createSuccessfulResponse({ body: Buffer.from('hello'), url: 'https://cdn.test/app.apk' })
-        );
-      const datadogLog = jest.spyOn(Datadog, 'log');
-
-      const promise = downloadBuildAsync({
-        logger: createLogger({ name: 'test' }),
-        applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
-        graphqlClient,
-        robotAccessToken: null,
-        extensions: ['apk'],
-      });
-      await fireBackoffTimersAsync(1);
-
-      const { artifactPath } = await promise;
-      expect(await fs.promises.readFile(artifactPath, 'utf-8')).toBe('hello');
-      expect(jest.mocked(fetch)).toHaveBeenCalledTimes(2);
-      expect(datadogLog).toHaveBeenCalledWith(
-        'download_build.archive_download recovered on attempt 2',
-        expect.objectContaining({ outcome: 'recovered', code })
-      );
-    }
-  );
-
-  it('throws SystemError when the build archive body keeps breaking off', async () => {
-    useFakeBackoffTimers();
-    const graphqlClient = createMockGraphqlClient({
-      applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
-    });
-    jest.mocked(fetch).mockImplementation(async () =>
-      createSuccessfulResponse({
-        body: createBrokenBody('ECONNRESET'),
-        url: 'https://cdn.test/app.apk',
-      })
-    );
-    const datadogLog = jest.spyOn(Datadog, 'log');
-
-    const promise = downloadBuildAsync({
-      logger: createLogger({ name: 'test' }),
-      buildId: randomUUID(),
-      graphqlClient,
-      robotAccessToken: null,
-      extensions: ['apk'],
-    });
-    const rejection = expect(promise).rejects.toBeInstanceOf(SystemError);
-    await fireBackoffTimersAsync(5);
-
-    await rejection;
-    await expect(promise).rejects.toMatchObject({
-      message: 'Could not download the application archive: body failed with ECONNRESET',
-    });
-    expect(jest.mocked(fetch)).toHaveBeenCalledTimes(6);
-    expect(datadogLog).toHaveBeenCalledWith(
-      'download_build.archive_download failed on attempt 6',
-      expect.objectContaining({ outcome: 'failed', code: 'ECONNRESET' })
-    );
-  });
-
-  it('does not start another archive attempt after an abort during the backoff', async () => {
-    useFakeBackoffTimers();
-    const graphqlClient = createMockGraphqlClient({});
-    jest
-      .mocked(fetch)
-      .mockRejectedValueOnce(createSocketFetchError(APPLICATION_ARCHIVE_URL, 'ECONNRESET'));
-    const controller = new AbortController();
-    const reason = new Error('step timed out');
-
-    const promise = downloadBuildAsync({
-      logger: createLogger({ name: 'test' }),
-      applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
-      graphqlClient,
-      robotAccessToken: null,
-      extensions: ['apk'],
-      signal: controller.signal,
-    });
-    const rejection = expect(promise).rejects.toBe(reason);
-    await waitForBackoffTimerAsync();
-    controller.abort(reason);
-    await jest.advanceTimersToNextTimerAsync();
-
-    await rejection;
-    expect(jest.mocked(fetch)).toHaveBeenCalledTimes(1);
-  });
-
-  it('rethrows the raw error of a failing user-supplied archive URL after the retries', async () => {
-    useFakeBackoffTimers();
-    const graphqlClient = createMockGraphqlClient({});
-    jest
-      .mocked(fetch)
-      .mockRejectedValue(createSocketFetchError(APPLICATION_ARCHIVE_URL, 'ENOTFOUND'));
-
-    const promise = downloadBuildAsync({
-      logger: createLogger({ name: 'test' }),
-      applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
-      graphqlClient,
-      robotAccessToken: null,
-      extensions: ['apk'],
-    });
-    const rejection = expect(promise).rejects.toBeInstanceOf(ActualFetchError);
-    await fireBackoffTimersAsync(5);
-
-    await rejection;
-    expect(jest.mocked(fetch)).toHaveBeenCalledTimes(6);
-  });
-
   it('should throw an error if no matching files are found', async () => {
     const graphqlClient = createMockGraphqlClient({
       applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
@@ -905,21 +605,6 @@ describe('createDownloadBuildFunction', () => {
       };
     }
 
-    function createApplicationResponse(buildId: string): Response {
-      return new ActualResponse(
-        JSON.stringify({
-          data: {
-            build: {
-              id: buildId,
-              gitCommitHash: null,
-              applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
-            },
-          },
-        }),
-        { status: 200 }
-      );
-    }
-
     function createStep(ctx: any, callInputs: Record<string, unknown>) {
       return createDownloadBuildFunction(ctx).createBuildStepFromFunctionCall(
         createGlobalContextMock({
@@ -935,7 +620,18 @@ describe('createDownloadBuildFunction', () => {
       const graphqlClient = createMockGraphqlClient({});
       jest.mocked(fetch).mockImplementation(async url => {
         if (url === workerApiUrl) {
-          return createApplicationResponse(buildId);
+          return new ActualResponse(
+            JSON.stringify({
+              data: {
+                build: {
+                  id: buildId,
+                  gitCommitHash: null,
+                  applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
+                },
+              },
+            }),
+            { status: 200 }
+          );
         }
         return {
           ok: false,
@@ -965,33 +661,6 @@ describe('createDownloadBuildFunction', () => {
       expect(graphqlClient.query).not.toHaveBeenCalled();
     });
 
-    it('retries the worker API lookup after a 5xx response', async () => {
-      useFakeBackoffTimers();
-      const buildId = randomUUID();
-      const graphqlClient = createMockGraphqlClient({});
-      jest
-        .mocked(fetch)
-        .mockResolvedValueOnce(new ActualResponse('Service Unavailable', { status: 503 }))
-        .mockResolvedValueOnce(createApplicationResponse(buildId))
-        .mockResolvedValueOnce(
-          createSuccessfulResponse({ body: Buffer.from('hello'), url: 'https://cdn.test/app.apk' })
-        );
-
-      const execution = createStep(createSessionCtx(graphqlClient), {
-        build_id: buildId,
-        extensions: ['apk'],
-      }).executeAsync();
-      await fireBackoffTimersAsync(1);
-
-      await execution;
-      expect(jest.mocked(fetch)).toHaveBeenCalledTimes(3);
-      expect(jest.mocked(fetch).mock.calls.map(([url]) => url)).toEqual([
-        workerApiUrl,
-        workerApiUrl,
-        APPLICATION_ARCHIVE_URL,
-      ]);
-    });
-
     it('does not call the worker API for an application_archive_url input', async () => {
       const graphqlClient = createMockGraphqlClient({});
       jest.mocked(fetch).mockResolvedValue({

packages/build-tools/src/steps/functions/__tests__/launchApplication.test.ts

@@ -1,6 +1,5 @@
 import { BuildRuntimePlatform } from '@expo/steps';
 import spawn from '@expo/turtle-spawn';
-import { spawnSync } from 'node:child_process';
 
 import { createGlobalContextMock } from '../../../__tests__/utils/context';
 import { createMockLogger } from '../../../__tests__/utils/logger';
@@ -202,263 +201,6 @@ describe(launchApplicationAsync, () => {
     expect(mockedSpawn).not.toHaveBeenCalled();
   });
 
-  it('quotes Android launch arguments and URLs for the device shell', async () => {
-    const logger = createMockLogger();
-
-    await launchApplicationAsync({
-      applicationIdentifier: 'dev.example.app',
-      activityName: 'dev.example.app.MainActivity',
-      launchArgs: ['-d', 'euxy://tempo', '--es', 'probe', 'hello world', '--es', 'quote', "it's"],
-      openUrl: 'exp://example.test/path?a=1&b=2',
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-      env: {},
-      logger,
-    });
-
-    expect(mockedSpawn).toHaveBeenNthCalledWith(
-      1,
-      'adb',
-      [
-        'shell',
-        'am',
-        'start',
-        '-d',
-        'euxy://tempo',
-        '--es',
-        'probe',
-        "'hello world'",
-        '--es',
-        'quote',
-        "'it'\\''s'",
-        '-n',
-        'dev.example.app/dev.example.app.MainActivity',
-      ],
-      { env: {}, logger }
-    );
-    expect(mockedSpawn).toHaveBeenNthCalledWith(
-      2,
-      'adb',
-      [
-        'shell',
-        'am',
-        'start',
-        '-a',
-        'android.intent.action.VIEW',
-        '-d',
-        "'exp://example.test/path?a=1&b=2'",
-      ],
-      { env: {}, logger }
-    );
-    expect(logger.info).toHaveBeenNthCalledWith(
-      1,
-      `Launching dev.example.app with arguments ${JSON.stringify(['-d', 'euxy://tempo', '--es', 'probe', 'hello world', '--es', 'quote', "it's"])}.`
-    );
-  });
-
-  it('passes iOS launch arguments with spaces unquoted', async () => {
-    await launchApplicationAsync({
-      applicationIdentifier: 'com.example.app',
-      launchArgs: ['-name', 'hello world'],
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-      env: {},
-      logger: createMockLogger(),
-    });
-
-    expect(mockedSpawn).toHaveBeenCalledWith(
-      'xcrun',
-      ['simctl', 'launch', 'booted', 'com.example.app', '-name', 'hello world'],
-      expect.any(Object)
-    );
-  });
-
-  it('round-trips quoted Android arguments through a POSIX shell', async () => {
-    const component = 'dev.example.app/dev.example.app.MainActivity$Inner';
-    const launchArgs = [
-      '--es',
-      'text',
-      'hello world',
-      '--es',
-      'json',
-      '{"a":1,"b":2}',
-      '--es',
-      'shell',
-      '$(printf injected) `printf injected` $HOME ; & | < >',
-      '--es',
-      'glob',
-      '*',
-      '--es',
-      'home',
-      '~',
-      '--esa',
-      'list',
-      'a\\,b,c',
-      '--es',
-      'whitespace',
-      'one\ntwo\tthree',
-      '--es',
-      'unicode',
-      'héllo 🌍',
-      '--es',
-      'empty',
-      '',
-    ];
-    const openUrl = 'exp://example.test/path?a=1&b=2#fragment';
-
-    await launchApplicationAsync({
-      applicationIdentifier: 'dev.example.app',
-      activityName: 'dev.example.app.MainActivity$Inner',
-      launchArgs,
-      openUrl,
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-      env: {},
-      logger: createMockLogger(),
-    });
-
-    // adb joins the words after `shell` with spaces and the device shell parses the result.
-    const parsedCommands = mockedSpawn.mock.calls.map(([, args]) => {
-      const { stdout } = spawnSync(
-        '/bin/sh',
-        ['-c', `am() { printf '%s\\0' "$@"; }; ${(args as string[]).slice(1).join(' ')}`],
-        { encoding: 'utf8' }
-      );
-      return stdout.split('\0').slice(0, -1);
-    });
-    expect(parsedCommands).toEqual([
-      ['start', ...launchArgs, '-n', component],
-      ['start', '-a', 'android.intent.action.VIEW', '-d', openUrl],
-    ]);
-  });
-
-  it.each([[['--es', 'key', '']], [['-e', 'key', '']], [['-d', '']]])(
-    'passes empty Android option values as empty arguments (%j)',
-    async launchArgs => {
-      await launchApplicationAsync({
-        applicationIdentifier: 'com.example.app',
-        activityName: 'com.example.app.MainActivity',
-        launchArgs,
-        runtimePlatform: BuildRuntimePlatform.LINUX,
-        env: {},
-        logger: createMockLogger(),
-      });
-
-      expect(mockedSpawn).toHaveBeenCalledWith(
-        'adb',
-        [
-          'shell',
-          'am',
-          'start',
-          ...launchArgs.map(argument => (argument === '' ? "''" : argument)),
-          '-n',
-          'com.example.app/com.example.app.MainActivity',
-        ],
-        expect.any(Object)
-      );
-    }
-  );
-
-  it('explains an Android launch failure when a launch argument is empty', async () => {
-    const launchError = new Error('adb shell am start exited with non-zero code: 1');
-    mockedSpawn.mockRejectedValueOnce(launchError);
-
-    await expect(
-      launchApplicationAsync({
-        applicationIdentifier: 'com.example.app',
-        activityName: 'com.example.app.MainActivity',
-        launchArgs: ['--ez', 'isTest', 'true', ''],
-        runtimePlatform: BuildRuntimePlatform.LINUX,
-        env: {},
-        logger: createMockLogger(),
-      })
-    ).rejects.toMatchObject({
-      errorCode: 'EAS_LAUNCH_APPLICATION_FAILED',
-      message: expect.stringContaining('empty argument at position 4'),
-      cause: launchError,
-    });
-  });
-
-  it('rethrows an Android launch failure unchanged when no launch argument is empty', async () => {
-    const launchError = new Error('adb shell am start exited with non-zero code: 1');
-    mockedSpawn.mockRejectedValueOnce(launchError);
-
-    await expect(
-      launchApplicationAsync({
-        applicationIdentifier: 'com.example.app',
-        activityName: 'com.example.app.MainActivity',
-        launchArgs: ['--ez', 'isTest', 'true'],
-        runtimePlatform: BuildRuntimePlatform.LINUX,
-        env: {},
-        logger: createMockLogger(),
-      })
-    ).rejects.toBe(launchError);
-  });
-
-  it.each([
-    { launchArgs: ['--es', 'key', 'a\0b'] },
-    { launchArgs: [], openUrl: 'exp://example.test/a\0b' },
-  ])('rejects NUL characters on Android (%j)', async ({ launchArgs, openUrl }) => {
-    await expect(
-      launchApplicationAsync({
-        applicationIdentifier: 'com.example.app',
-        activityName: 'com.example.app.MainActivity',
-        launchArgs,
-        openUrl,
-        runtimePlatform: BuildRuntimePlatform.LINUX,
-        env: {},
-        logger: createMockLogger(),
-      })
-    ).rejects.toMatchObject({ errorCode: 'EAS_LAUNCH_APPLICATION_INVALID_INPUT' });
-    expect(mockedSpawn).not.toHaveBeenCalledWith(
-      'adb',
-      expect.arrayContaining([expect.stringContaining('\0')]),
-      expect.any(Object)
-    );
-  });
-
-  it('accepts an Android launch command of exactly 65,000 bytes', async () => {
-    const fixedLength = 'am start --es key  -n com.example.app/com.example.app.MainActivity'.length;
-
-    await launchApplicationAsync({
-      applicationIdentifier: 'com.example.app',
-      activityName: 'com.example.app.MainActivity',
-      launchArgs: ['--es', 'key', 'a'.repeat(65_000 - fixedLength)],
-      runtimePlatform: BuildRuntimePlatform.LINUX,
-      env: {},
-      logger: createMockLogger(),
-    });
-
-    expect(mockedSpawn).toHaveBeenCalledTimes(1);
-  });
-
-  it('rejects an Android URL command of 65,001 bytes', async () => {
-    const fixedLength = 'am start -a android.intent.action.VIEW -d exp://example.test/'.length;
-
-    await expect(
-      launchApplicationAsync({
-        applicationIdentifier: 'com.example.app',
-        activityName: 'com.example.app.MainActivity',
-        openUrl: `exp://example.test/${'a'.repeat(65_001 - fixedLength)}`,
-        runtimePlatform: BuildRuntimePlatform.LINUX,
-        env: {},
-        logger: createMockLogger(),
-      })
-    ).rejects.toMatchObject({ errorCode: 'EAS_LAUNCH_APPLICATION_INVALID_INPUT' });
-    expect(mockedSpawn).toHaveBeenCalledTimes(1);
-  });
-
-  it('rejects an Android launch command that is too long after quoting', async () => {
-    await expect(
-      launchApplicationAsync({
-        applicationIdentifier: 'com.example.app',
-        activityName: 'com.example.app.MainActivity',
-        launchArgs: ['--es', 'quotes', "'".repeat(20_000)],
-        runtimePlatform: BuildRuntimePlatform.LINUX,
-        env: {},
-        logger: createMockLogger(),
-      })
-    ).rejects.toMatchObject({ errorCode: 'EAS_LAUNCH_APPLICATION_INVALID_INPUT' });
-    expect(mockedSpawn).not.toHaveBeenCalled();
-  });
-
   it('launches using application metadata passed to the build step', async () => {
     const launchApplication = createLaunchApplicationFunction();
     const buildStep = launchApplication.createBuildStepFromFunctionCall(
@@ -495,36 +237,6 @@ describe(launchApplicationAsync, () => {
     );
   });
 
-  it('quotes Android launch arguments passed to the build step', async () => {
-    const launchApplication = createLaunchApplicationFunction();
-    const buildStep = launchApplication.createBuildStepFromFunctionCall(
-      createGlobalContextMock({ runtimePlatform: BuildRuntimePlatform.LINUX }),
-      {
-        callInputs: {
-          application_identifier: 'com.example.app',
-          activity_name: 'com.example.app.MainActivity',
-          launch_args: ['--es', 'probe', 'hello world'],
-        },
-      }
-    );
-    await buildStep.executeAsync();
-
-    expect(mockedSpawn).toHaveBeenCalledWith(
-      'adb',
-      [
-        'shell',
-        'am',
-        'start',
-        '--es',
-        'probe',
-        "'hello world'",
-        '-n',
-        'com.example.app/com.example.app.MainActivity',
-      ],
-      expect.any(Object)
-    );
-  });
-
   it.each([{}, ['valid', 42]])('rejects invalid launch arguments (%j)', async launchArgs => {
     const launchApplication = createLaunchApplicationFunction();
     const buildStep = launchApplication.createBuildStepFromFunctionCall(

packages/build-tools/src/steps/functions/__tests__/maestroTests.test.ts

@@ -1,4 +1,4 @@
-import { SystemError, UserError } from '@expo/eas-build-job';
+import { GenericArtifactType, SystemError, UserError } from '@expo/eas-build-job';
 import spawn from '@expo/turtle-spawn';
 import fs from 'fs/promises';
 import os from 'os';
@@ -305,6 +305,7 @@ describe('createMaestroTestsBuildFunction', () => {
       expect(mockUploadArtifact).toHaveBeenCalledWith(
         expect.objectContaining({
           artifact: expect.objectContaining({
+            type: GenericArtifactType.OTHER,
             name:
               format === 'html' ? 'Maestro Runner HTML Report' : 'Maestro Runner Allure Results',
             paths: [
@@ -1090,6 +1091,7 @@ describe('createMaestroTestsBuildFunction', () => {
     expect(mockUploadArtifact).toHaveBeenCalledWith(
       expect.objectContaining({
         artifact: expect.objectContaining({
+          type: GenericArtifactType.OTHER,
           name: 'Maestro HTML Report',
           paths: ['/home/expo/.maestro/tests/android-maestro-html.html'],
         }),
@@ -1418,6 +1420,7 @@ describe('createMaestroTestsBuildFunction', () => {
     expect(mockUploadArtifact).toHaveBeenCalledWith(
       expect.objectContaining({
         artifact: expect.objectContaining({
+          type: GenericArtifactType.OTHER,
           name: shot.displayName,
           metadata: shot.metadata,
         }),

packages/build-tools/src/steps/functions/__tests__/remoteSessionLocalEgress.test.ts

@@ -14,12 +14,6 @@ import {
   registerLocalEgressResources,
   stopLocalEgressResourcesAsync,
 } from '../../utils/localEgress';
-import {
-  reportLocalEgressGuardCoverageAsync,
-  resolveLocalEgressServeSimBootEnvironmentAsync,
-  startLocalEgressGuardRelayAsync,
-  verifyLocalEgressGuardAsync,
-} from '../../utils/localEgressGuard';
 import {
   uploadRemoteSessionConfigAsync,
   waitForDeviceRunSessionStoppedAsync,
@@ -57,13 +51,6 @@ jest.mock('../../utils/localEgress', () => ({
   readLocalEgressHandoffAsync: jest.fn(),
   monitorLocalEgressAsync: jest.fn(),
 }));
-jest.mock('../../utils/localEgressGuard', () => ({
-  ...jest.requireActual('../../utils/localEgressGuard'),
-  resolveLocalEgressServeSimBootEnvironmentAsync: jest.fn(),
-  startLocalEgressGuardRelayAsync: jest.fn(),
-  reportLocalEgressGuardCoverageAsync: jest.fn(),
-  verifyLocalEgressGuardAsync: jest.fn(),
-}));
 jest.mock('../../utils/remoteDeviceRunSession', () => ({
   ...jest.requireActual('../../utils/remoteDeviceRunSession'),
   getDeviceRunSessionIdOrThrow: () => 'session-id',
@@ -139,20 +126,9 @@ describe.each(controllers)('%s local egress', (_name, createFunction, controller
     jest.mocked(isProcessDescendantOfAsync).mockResolvedValue(true);
     jest
       .mocked(IosSimulatorUtils.getAvailableDevicesAsync)
-      .mockResolvedValue([{ udid: 'sim', name: 'iPhone 17' }] as never);
-    jest.mocked(IosSimulatorUtils.resolveUdidAsync).mockResolvedValue('sim' as never);
+      .mockResolvedValue([{ udid: 'sim' }] as never);
     jest.mocked(turtleFetch).mockResolvedValue({ ok: true } as never);
     jest.mocked(readLocalEgressHandoffAsync).mockResolvedValue(handoff);
-    jest
-      .mocked(resolveLocalEgressServeSimBootEnvironmentAsync)
-      .mockImplementation(async () =>
-        (await readLocalEgressHandoffAsync())
-          ? { SERVE_SIM_ADDITIONAL_DYLIBS: '/test/egress-guard.dylib' }
-          : null
-      );
-    jest.mocked(startLocalEgressGuardRelayAsync).mockResolvedValue(undefined);
-    jest.mocked(reportLocalEgressGuardCoverageAsync).mockResolvedValue(null);
-    jest.mocked(verifyLocalEgressGuardAsync).mockResolvedValue(undefined);
     jest.mocked(monitorLocalEgressAsync).mockResolvedValue(undefined);
     openPreview.mockResolvedValue({
       previewPageUrl: 'https://expo.dev/simulator-preview/preview-id',
@@ -162,7 +138,6 @@ describe.each(controllers)('%s local egress', (_name, createFunction, controller
     });
     jest.mocked(startDeviceSessionHostAsync).mockResolvedValue({
       openPreviewAsync: openPreview,
-      getLastPreviewActivityAt: jest.fn(),
       finishAsync: stopPreview,
     });
     jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue(undefined);

packages/build-tools/src/steps/functions/__tests__/startAgentDeviceRemoteSession-orchestration.test.ts

@@ -70,14 +70,13 @@ const mockEventCollectionStopAsync = jest.fn();
 type CaptureInputs = Parameters<typeof runAgentDeviceRemoteSessionAsync>[1]['capture'];
 const NO_CAPTURE: CaptureInputs = { networkCapture: false, networkCaptureFields: [] };
 
-/** Runs an Android session that is ready, or an iOS session with no application preparation. */
+/** Runs the session for a device that is already booted, with the app (if any) launched. */
 async function runAsync(
   logger: { info: jest.Mock; warn: jest.Mock; child: jest.Mock },
   runtimePlatform: BuildRuntimePlatform,
   capture: CaptureInputs = NO_CAPTURE,
   disableShare = false,
-  privatePreviewUrl?: string,
-  maxIdleTimeMinutes?: number
+  privatePreviewUrl?: string
 ): Promise<void> {
   await runAgentDeviceRemoteSessionAsync(ctx, {
     env: {},
@@ -89,16 +88,13 @@ async function runAsync(
       ngrokAuthtoken: 'ngrok-token',
     },
     packageVersion: undefined,
-    maxIdleTimeMinutes,
+    maxIdleTimeMinutes: undefined,
     maxDurationSeconds: undefined,
     capture,
     disableShare,
     privatePreviewUrl,
     tasks: createStartupTasks(logger as never),
-    device:
-      runtimePlatform === BuildRuntimePlatform.DARWIN
-        ? { iosSimulatorUdid: 'selected-udid', application: Promise.resolve() }
-        : { booted: Promise.resolve(), ready: Promise.resolve() },
+    device: { booted: Promise.resolve(), ready: Promise.resolve() },
   });
 }
 
@@ -128,24 +124,13 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
       subdomainId: 'agent-device-abc',
       stopAsync: mockTunnelStopAsync,
     });
-    const host = {
+    jest.mocked(startDeviceSessionHostAsync).mockResolvedValue({
       openPreviewAsync: jest.fn().mockResolvedValue({
         previewPageUrl: 'https://expo.dev/simulator-preview/preview-id',
         apiUrl: 'https://web-preview.tunnel.example.com',
         closeAsync: jest.fn(),
       }),
-      getLastPreviewActivityAt: jest.fn(),
       finishAsync: mockPreviewStopAsync,
-    };
-    jest.mocked(startDeviceSessionHostAsync).mockImplementation(async (_ctx, options) => {
-      try {
-        await options.application;
-        options.signal?.throwIfAborted();
-      } catch (error) {
-        await mockPreviewStopAsync();
-        throw error;
-      }
-      return host;
     });
     jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue(undefined);
     jest.mocked(waitForDeviceRunSessionStoppedAsync).mockResolvedValue(undefined);
@@ -165,7 +150,7 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
 
     expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
       ctx,
-      expect.objectContaining({ runtimePlatform: BuildRuntimePlatform.LINUX, timeoutMs: 60_000 })
+      expect.objectContaining({ runtimePlatform: BuildRuntimePlatform.LINUX })
     );
     expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -204,21 +189,6 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
     expect(JSON.stringify(logger.info.mock.calls)).not.toContain(encodeURIComponent(token));
   });
 
-  it('resets the idle timer on preview input from the session host', async () => {
-    const previewInputAt = new Date('2026-10-19T12:00:00Z');
-    const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
-    const host = await jest.mocked(startDeviceSessionHostAsync).getMockImplementation()!(ctx, {
-      application: Promise.resolve(),
-    } as never);
-    jest.mocked(host.getLastPreviewActivityAt).mockReturnValue(previewInputAt);
-
-    await runAsync(logger, BuildRuntimePlatform.LINUX, NO_CAPTURE, false, undefined, 5);
-
-    const { idleTimeout } = jest.mocked(waitForDeviceRunSessionStoppedAsync).mock.calls[0][0];
-    expect(idleTimeout?.maxIdleTimeMinutes).toBe(5);
-    expect(idleTimeout?.getLastPreviewActivityAt?.()).toBe(previewInputAt);
-  });
-
   it('hands network capture to serve-sim', async () => {
     const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
 
@@ -319,14 +289,14 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
   });
 
   describe('runAgentDeviceRemoteSessionAsync with a device that is still starting', () => {
-    function deferred<T = void>(): {
-      promise: Promise<T>;
-      resolve: (value: T) => void;
+    function deferred(): {
+      promise: Promise<void>;
+      resolve: () => void;
       reject: (e: Error) => void;
     } {
-      let resolve!: (value: T) => void;
+      let resolve!: () => void;
       let reject!: (e: Error) => void;
-      const promise = new Promise<T>((res, rej) => {
+      const promise = new Promise<void>((res, rej) => {
         resolve = res;
         reject = rej;
       });
@@ -334,26 +304,18 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
       return { promise, resolve, reject };
     }
 
-    type Device = Parameters<typeof runAgentDeviceRemoteSessionAsync>[1]['device'];
-    function startSession(
-      device: Device | ((tasks: StartupTasks) => Device),
-      signal?: AbortSignal
-    ) {
+    type Device = { booted: Promise<unknown>; ready: Promise<unknown> };
+    function startSession(device: Device | ((tasks: StartupTasks) => Device)) {
       const logger = {
         info: jest.fn(),
         warn: jest.fn(),
         child: jest.fn().mockReturnThis(),
       } as never;
-      const tasks = createStartupTasks(logger, signal);
-      const sessionDevice = typeof device === 'function' ? device(tasks) : device;
+      const tasks = createStartupTasks(logger);
       return runAgentDeviceRemoteSessionAsync(ctx, {
         env: {},
         logger,
-        signal,
-        runtimePlatform:
-          'iosSimulatorUdid' in sessionDevice
-            ? BuildRuntimePlatform.DARWIN
-            : BuildRuntimePlatform.LINUX,
+        runtimePlatform: BuildRuntimePlatform.DARWIN,
         sessionEnv: {
           deviceRunSessionId: 'device-run-session-id',
           ngrokTunnelDomain: 'tunnel.example.com',
@@ -364,7 +326,7 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
         maxDurationSeconds: undefined,
         capture: NO_CAPTURE,
         tasks,
-        device: sessionDevice,
+        device: typeof device === 'function' ? device(tasks) : device,
       });
     }
 
@@ -374,31 +336,7 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
       }
     }
 
-    it('aborts parallel startup before host failure cleanup finishes', async () => {
-      const failure = new Error('guard refused startup');
-      const cleanup = deferred();
-      const notified = deferred();
-      let startupTasks!: StartupTasks;
-      jest.mocked(startDeviceSessionHostAsync).mockImplementation(async (_ctx, options) => {
-        options.onStartupError?.(failure);
-        notified.resolve();
-        await cleanup.promise;
-        throw failure;
-      });
-      const session = startSession(tasks => {
-        startupTasks = tasks;
-        return { iosSimulatorUdid: 'selected-udid' };
-      });
-      const rejected = expect(session).rejects.toBe(failure);
-      await notified.promise;
-      expect(startupTasks.signal.aborted).toBe(true);
-      expect(startupTasks.signal.reason).toBe(failure);
-      expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-      cleanup.resolve();
-      await rejected;
-    });
-
-    it('starts the daemon during the Android boot and the session host after it', async () => {
+    it('starts the daemon during the boot and the session host after it', async () => {
       const booted = deferred();
       const session = startSession({ booted: booted.promise, ready: booted.promise });
       await flushAsync();
@@ -410,237 +348,10 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
       booted.resolve();
       await session;
       expect(startDeviceSessionHostAsync).toHaveBeenCalledTimes(1);
-      expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-        ctx,
-        expect.objectContaining({
-          runtimePlatform: BuildRuntimePlatform.LINUX,
-          timeoutMs: 60_000,
-          iosSimulatorUdid: undefined,
-        })
-      );
       expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledTimes(1);
     });
 
-    it('preserves a failed download when aborting daemon installation rejects first', async () => {
-      const failure = new Error('download failed: build not found');
-      const installStarted = deferred();
-      jest.mocked(spawn).mockImplementation((async (_command, _args, options) => {
-        return await new Promise((_resolve, reject) => {
-          options!.signal!.addEventListener(
-            'abort',
-            () => {
-              const error = new Error('The operation was aborted');
-              error.name = 'AbortError';
-              reject(error);
-            },
-            { once: true }
-          );
-          installStarted.resolve();
-        });
-      }) as typeof spawn);
-      jest.mocked(startDeviceSessionHostAsync).mockImplementation(async (_ctx, { signal }) => {
-        return await new Promise((_resolve, reject) => {
-          signal!.addEventListener(
-            'abort',
-            () => {
-              setTimeout(() => reject(signal!.reason), 20);
-            },
-            { once: true }
-          );
-        });
-      });
-      const applicationReady = Promise.resolve();
-      const session = startSession(tasks => {
-        void tasks.run('build download', async () => {
-          await installStarted.promise;
-          throw failure;
-        });
-        return { iosSimulatorUdid: 'selected-udid', application: applicationReady };
-      });
-      await expect(session).rejects.toBe(failure);
-      expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-    });
-
-    it('boots the host during download and releases startup only after preparation', async () => {
-      const hostReady = deferred();
-      const application = deferred<{
-        installAppPath: string;
-        launchAppIdentifier: string;
-        launchArgs: string[];
-        openUrl: string;
-      }>();
-      const host = await jest.mocked(startDeviceSessionHostAsync).getMockImplementation()!(
-        ctx,
-        {} as never
-      );
-      const release = jest.fn();
-      jest
-        .mocked(startDeviceSessionHostAsync)
-        .mockClear()
-        .mockImplementation(async (_ctx, options) => {
-          release(await options.application);
-          await hostReady.promise;
-          return host;
-        });
-      const applicationReady = application.promise;
-      const session = startSession({
-        iosSimulatorUdid: 'selected-udid',
-        application: applicationReady,
-      });
-      await flushAsync();
-      expect(startDeviceSessionHostAsync).toHaveBeenCalledTimes(1);
-      expect(release).not.toHaveBeenCalled();
-      expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-      const startup = {
-        installAppPath: '/tmp/App.app',
-        launchAppIdentifier: 'dev.example.app',
-        launchArgs: ['--flag'],
-        openUrl: 'example://screen',
-      };
-      application.resolve(startup);
-      await flushAsync();
-      expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-        ctx,
-        expect.objectContaining({
-          application: applicationReady,
-          iosSimulatorUdid: 'selected-udid',
-          timeoutMs: 60_000,
-          signal: expect.any(AbortSignal),
-        })
-      );
-      expect(release).toHaveBeenCalledWith(startup);
-      expect(host.openPreviewAsync).not.toHaveBeenCalled();
-      hostReady.resolve();
-      await session;
-      expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledTimes(1);
-      expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
-    });
-
-    it('passes the guard boot environment with the startup installation and launch', async () => {
-      const startup = {
-        installAppPath: '/tmp/App.app',
-        launchAppIdentifier: 'dev.example.app',
-        launchArgs: ['--flag'],
-        openUrl: 'example://screen',
-      };
-      const bootEnv = {
-        SERVE_SIM_ADDITIONAL_DYLIBS: '/w/bin/egress-guard.dylib',
-        SIMCTL_CHILD_EAS_EGRESS_GUARD_MODE: 'block',
-        SIMCTL_CHILD_EAS_EGRESS_GUARD_LOG: '/tmp/egress-guard.log',
-        SIMCTL_CHILD_HTTP_PROXY: 'http://127.0.0.1:8899',
-      };
-      await startSession({
-        iosSimulatorUdid: 'guarded-udid',
-        bootEnv,
-        application: Promise.resolve(startup),
-      });
-      expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-        ctx,
-        expect.objectContaining({
-          application: expect.any(Promise),
-          bootEnv,
-          iosSimulatorUdid: 'guarded-udid',
-        })
-      );
-      const hostOptions = jest.mocked(startDeviceSessionHostAsync).mock.calls[0][1];
-      expect(hostOptions.bootEnv).toBe(bootEnv);
-      expect(hostOptions.bootEnv).not.toHaveProperty('DYLD_INSERT_LIBRARIES');
-      expect(hostOptions.bootEnv).not.toHaveProperty('SIMCTL_CHILD_DYLD_INSERT_LIBRARIES');
-    });
-
-    it('cleans up a host returned after cancellation without configuring the device', async () => {
-      const hostReady = deferred();
-      const controller = new AbortController();
-      const host = await jest.mocked(startDeviceSessionHostAsync).getMockImplementation()!(
-        ctx,
-        {} as never
-      );
-      jest.mocked(startDeviceSessionHostAsync).mockImplementation(async () => {
-        await hostReady.promise;
-        return host;
-      });
-      const applicationReady = Promise.resolve();
-      const session = startSession(
-        { iosSimulatorUdid: 'selected-udid', application: applicationReady },
-        controller.signal
-      );
-      const failure = expect(session).rejects.toThrow('cancelled');
-      await flushAsync();
-      controller.abort(new Error('cancelled'));
-      hostReady.resolve();
-
-      await failure;
-      expect(host.openPreviewAsync).not.toHaveBeenCalled();
-      expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
-      expect(mockDaemonStopAsync).toHaveBeenCalledTimes(1);
-      expect(mockTunnelStopAsync).toHaveBeenCalledTimes(1);
-      expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-    });
-
-    it('drains in-flight application preparation and stops the waiting host after cancellation', async () => {
-      const controller = new AbortController();
-      const appReady = deferred();
-      const session = startSession(
-        { iosSimulatorUdid: 'selected-udid', application: appReady.promise },
-        controller.signal
-      );
-      const failure = expect(session).rejects.toThrow('cancelled');
-      await flushAsync();
-      controller.abort(new Error('cancelled'));
-      await flushAsync();
-      expect(mockPreviewStopAsync).not.toHaveBeenCalled();
-
-      appReady.resolve();
-      await failure;
-      expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
-      expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-    });
-
-    it('does not report readiness when cancellation arrives during preview startup', async () => {
-      const controller = new AbortController();
-      const previewReady = deferred();
-      const host = await jest.mocked(startDeviceSessionHostAsync).getMockImplementation()!(
-        ctx,
-        {} as never
-      );
-      const preview = await host.openPreviewAsync({
-        baseDomain: 'tunnel.example.com',
-        authtoken: 'ngrok-token',
-      });
-      jest.mocked(host.openPreviewAsync).mockImplementation(async () => {
-        await previewReady.promise;
-        return preview;
-      });
-      const session = startSession(
-        { iosSimulatorUdid: 'selected-udid', application: Promise.resolve() },
-        controller.signal
-      );
-      const failure = expect(session).rejects.toThrow('cancelled');
-      await flushAsync();
-      controller.abort(new Error('cancelled'));
-      previewReady.resolve();
-
-      await failure;
-      expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
-      expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-    });
-
-    it('does not start resources for an already cancelled session', async () => {
-      const controller = new AbortController();
-      controller.abort(new Error('cancelled'));
-      const applicationReady = Promise.resolve();
-
-      await expect(
-        startSession(
-          { iosSimulatorUdid: 'selected-udid', application: applicationReady },
-          controller.signal
-        )
-      ).rejects.toThrow('cancelled');
-      expect(spawn).not.toHaveBeenCalled();
-      expect(startDeviceSessionHostAsync).not.toHaveBeenCalled();
-    });
-
-    it('starts the Android host before application readiness and waits before reporting ready', async () => {
+    it('reports the session as ready only after the app is launched', async () => {
       const ready = deferred();
       const session = startSession({ booted: Promise.resolve(), ready: ready.promise });
       await flushAsync();
@@ -650,11 +361,10 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
 
       ready.resolve();
       await session;
-      expect(startDeviceSessionHostAsync).toHaveBeenCalledTimes(1);
       expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledTimes(1);
     });
 
-    it('stops waiting for the Android boot when the daemon fails', async () => {
+    it('stops waiting for the boot when the daemon fails', async () => {
       jest.mocked(waitForFileAsync).mockRejectedValue(new Error('no daemon credentials'));
       const neverBooted = new Promise<void>(() => {});
 
@@ -668,7 +378,7 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
       expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
     });
 
-    it('cancels daemon installation and stops the Android host when the download fails', async () => {
+    it('stops the session host when the app fails while the daemon install hangs', async () => {
       jest.mocked(spawn).mockImplementation(((
         command: string,
         args: string[],
@@ -684,22 +394,21 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
       await flushAsync();
       expect(startDeviceSessionHostAsync).toHaveBeenCalledTimes(1);
 
-      ready.reject(new Error('download failed'));
+      ready.reject(new Error('simctl install failed'));
 
-      await expect(session).rejects.toThrow('download failed');
+      await expect(session).rejects.toThrow('simctl install failed');
       expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
       expect(spawnDetached).not.toHaveBeenCalled();
       expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
     });
 
-    it('stops the Android host, daemon and tunnel when the download fails', async () => {
+    it('stops everything it started when the app install fails', async () => {
       const ready = deferred();
       const session = startSession({ booted: Promise.resolve(), ready: ready.promise });
       await flushAsync();
-      expect(startDeviceSessionHostAsync).toHaveBeenCalledTimes(1);
-      ready.reject(new Error('download failed'));
+      ready.reject(new Error('simctl install failed'));
 
-      await expect(session).rejects.toThrow('download failed');
+      await expect(session).rejects.toThrow('simctl install failed');
       expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
       expect(mockDaemonStopAsync).toHaveBeenCalledTimes(1);
       expect(mockTunnelStopAsync).toHaveBeenCalledTimes(1);

packages/build-tools/src/steps/functions/__tests__/startAgentDeviceSession.test.ts

@@ -1,20 +1,11 @@
 import { BuildRuntimePlatform, type BuildStepContext } from '@expo/steps';
-import { UserError } from '@expo/eas-build-job';
-import spawn from '@expo/turtle-spawn';
 
 import { createGlobalContextMock } from '../../../__tests__/utils/context';
 import { type CustomBuildContext } from '../../../customBuildContext';
 import { DeviceRunSessionWorkerApi } from '../../utils/deviceRunSessionWorkerApi';
-import { IosSimulatorUtils } from '../../../utils/IosSimulatorUtils';
-import { stopLocalEgressResourcesAsync } from '../../utils/localEgress';
-import {
-  resolveLocalEgressServeSimBootEnvironmentAsync,
-  startLocalEgressGuardRelayAsync,
-} from '../../utils/localEgressGuard';
 import { selectXcodeDeveloperDirectoryAsync } from '../../utils/remoteDeviceRunSession';
 import { downloadBuildAsync } from '../downloadBuild';
 import { installBuildAsync } from '../installBuild';
-import { readIosApplicationIdentifierAsync } from '../../utils/iosAppArtifact';
 import { launchApplicationAsync } from '../launchApplication';
 import {
   getAgentDeviceRemoteSessionEnvOrThrow,
@@ -24,30 +15,17 @@ import { createStartAgentDeviceSessionBuildFunction } from '../startAgentDeviceS
 import { startAndroidEmulatorAsync } from '../startAndroidEmulator';
 import { bootIosSimulatorAsync } from '../startIosSimulator';
 
-jest.mock('../../utils/localEgress', () => ({
-  stopLocalEgressResourcesAsync: jest.fn().mockResolvedValue(undefined),
+jest.mock('../../utils/localEgressSession', () => ({
+  withLocalEgressSession: (fn: unknown) => fn,
 }));
-jest.mock('../../utils/localEgressGuard', () => ({
-  resolveLocalEgressServeSimBootEnvironmentAsync: jest.fn(),
-  startLocalEgressGuardRelayAsync: jest.fn(),
-}));
-jest.mock('@expo/turtle-spawn');
-jest.mock('../../../utils/IosSimulatorUtils');
 jest.mock('../../utils/remoteDeviceRunSession', () => ({
   ...jest.requireActual('../../utils/remoteDeviceRunSession'),
   selectXcodeDeveloperDirectoryAsync: jest.fn(),
 }));
-jest.mock('../startIosSimulator', () => ({
-  ...jest.requireActual('../startIosSimulator'),
-  bootIosSimulatorAsync: jest.fn(),
-}));
+jest.mock('../startIosSimulator', () => ({ bootIosSimulatorAsync: jest.fn() }));
 jest.mock('../startAndroidEmulator', () => ({ startAndroidEmulatorAsync: jest.fn() }));
 jest.mock('../downloadBuild', () => ({ downloadBuildAsync: jest.fn() }));
 jest.mock('../installBuild', () => ({ installBuildAsync: jest.fn() }));
-jest.mock('../../utils/iosAppArtifact', () => ({
-  ...jest.requireActual('../../utils/iosAppArtifact'),
-  readIosApplicationIdentifierAsync: jest.fn(),
-}));
 jest.mock('../launchApplication', () => ({
   ...jest.requireActual('../launchApplication'),
   launchApplicationAsync: jest.fn(),
@@ -65,17 +43,7 @@ const sessionEnv = {
   ngrokAuthtoken: 'ngrok-token',
 };
 
-type Device = Parameters<typeof runAgentDeviceRemoteSessionAsync>[1]['device'];
-let deviceLaunch: unknown;
-
-function runDevicePreparationAsync(device: Device): Promise<unknown> {
-  return (
-    'iosSimulatorUdid' in device ? (device.application ?? Promise.resolve()) : device.ready
-  ).then(async launch => {
-    deviceLaunch = launch;
-    return launch;
-  });
-}
+type Device = { booted: Promise<unknown>; ready: Promise<unknown> };
 
 function deferred<T = void>(): {
   promise: Promise<T>;
@@ -101,7 +69,6 @@ async function flushAsync(): Promise<void> {
 function runStep(
   runtimePlatform: BuildRuntimePlatform,
   inputValues: Record<string, unknown> = {},
-  signal?: AbortSignal,
   stepCtx: CustomBuildContext = ctx
 ): Promise<void> {
   const buildFunction = createStartAgentDeviceSessionBuildFunction(stepCtx);
@@ -121,8 +88,6 @@ function runStep(
       'network_capture_fields',
       'public_preview',
       'private_preview_url',
-      'frame_ancestors',
-      'cors_origins',
       'package_version',
       'max_idle_time_minutes',
       'max_duration_seconds',
@@ -136,32 +101,22 @@ function runStep(
         staticContext: { job: { secrets: { robotAccessToken: 'robot-token' } } },
       },
     } as unknown as BuildStepContext,
-    { inputs, outputs: {}, env: {}, signal } as never
+    { inputs, outputs: {}, env: {}, signal: undefined } as never
   ) as Promise<void>;
 }
 
+/** The `device` promises handed to the shared agent-device session code. */
 function sessionDevice(): Device {
   return jest.mocked(runAgentDeviceRemoteSessionAsync).mock.calls[0][1].device;
 }
 
 describe(createStartAgentDeviceSessionBuildFunction, () => {
   beforeEach(() => {
-    deviceLaunch = undefined;
     jest.clearAllMocks();
-    jest.mocked(resolveLocalEgressServeSimBootEnvironmentAsync).mockResolvedValue(null);
-    jest.mocked(startLocalEgressGuardRelayAsync).mockResolvedValue(undefined);
-    jest.mocked(IosSimulatorUtils.getDeviceAsync).mockResolvedValue({ state: 'Shutdown' } as never);
-    jest.mocked(spawn).mockResolvedValue({ stdout: '' } as never);
-    jest.mocked(IosSimulatorUtils.resolveUdidAsync).mockResolvedValue('selected-udid' as never);
-    jest
-      .mocked(IosSimulatorUtils.getAvailableDevicesAsync)
-      .mockResolvedValue([{ name: 'iPhone 17', udid: 'SELECTED-UDID' }] as never);
     jest.mocked(getAgentDeviceRemoteSessionEnvOrThrow).mockReturnValue(sessionEnv);
-    jest
-      .mocked(runAgentDeviceRemoteSessionAsync)
-      .mockImplementation(async (_ctx, { device, tasks }) => {
-        await tasks.untilAborted(runDevicePreparationAsync(device));
-      });
+    jest.mocked(runAgentDeviceRemoteSessionAsync).mockImplementation(async (_ctx, { device }) => {
+      await device.ready;
+    });
     jest.mocked(bootIosSimulatorAsync).mockResolvedValue({
       deviceIdentifier: 'iPhone 17' as never,
       udid: 'udid' as never,
@@ -177,31 +132,22 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
       .mocked(installBuildAsync)
       .mockResolvedValue({ applicationIdentifier: 'dev.example.app', activityName: '.Main' });
     jest.mocked(launchApplicationAsync).mockResolvedValue(undefined);
-    jest.mocked(readIosApplicationIdentifierAsync).mockResolvedValue('dev.example.app');
   });
 
-  it('hands guarded iOS boot to serve-sim and starts reporting before host startup', async () => {
-    const bootEnv = {
-      SERVE_SIM_ADDITIONAL_DYLIBS: '/w/bin/egress-guard.dylib',
-      SIMCTL_CHILD_EAS_EGRESS_GUARD_MODE: 'block',
-      SIMCTL_CHILD_http_proxy: 'http://127.0.0.1:8899',
-    };
-    jest.mocked(resolveLocalEgressServeSimBootEnvironmentAsync).mockResolvedValue(bootEnv);
-    await runStep(BuildRuntimePlatform.DARWIN, {
+  it('downloads the build and starts the session while the iOS Simulator boots', async () => {
+    const boot = deferred<Awaited<ReturnType<typeof bootIosSimulatorAsync>>>();
+    jest.mocked(bootIosSimulatorAsync).mockReturnValue(boot.promise);
+
+    const step = runStep(BuildRuntimePlatform.DARWIN, {
       build_id: 'build-id',
       launch_args: ['-flag'],
       open_url: 'exp://example.test',
     });
+    await flushAsync();
+
     expect(
       jest.mocked(selectXcodeDeveloperDirectoryAsync).mock.invocationCallOrder[0]
-    ).toBeLessThan(
-      jest.mocked(resolveLocalEgressServeSimBootEnvironmentAsync).mock.invocationCallOrder[0]
-    );
-    expect(startLocalEgressGuardRelayAsync).toHaveBeenCalledTimes(1);
-    expect(jest.mocked(startLocalEgressGuardRelayAsync).mock.invocationCallOrder[0]).toBeLessThan(
-      jest.mocked(runAgentDeviceRemoteSessionAsync).mock.invocationCallOrder[0]
-    );
-    expect(bootIosSimulatorAsync).not.toHaveBeenCalled();
+    ).toBeLessThan(jest.mocked(bootIosSimulatorAsync).mock.invocationCallOrder[0]);
     expect(downloadBuildAsync).toHaveBeenCalledWith(
       expect.objectContaining({
         buildId: 'build-id',
@@ -211,45 +157,28 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
       })
     );
     expect(runAgentDeviceRemoteSessionAsync).toHaveBeenCalledTimes(1);
-    const device = sessionDevice();
-    expect(device).toEqual({
-      iosSimulatorUdid: 'SELECTED-UDID',
-      bootEnv,
-      application: expect.any(Promise),
-    });
-    expect(spawn).not.toHaveBeenCalled();
-    expect(readIosApplicationIdentifierAsync).toHaveBeenCalledWith({
-      artifactPath: '/tmp/App.app',
-      env: {},
-    });
+    // The install needs the booted Simulator.
     expect(installBuildAsync).not.toHaveBeenCalled();
-    expect(launchApplicationAsync).not.toHaveBeenCalled();
-    expect(deviceLaunch).toEqual({
-      installAppPath: '/tmp/App.app',
-      launchAppIdentifier: 'dev.example.app',
-      launchArgs: ['-flag'],
-      openUrl: 'exp://example.test',
-    });
-  });
 
-  it('shuts down only the selected guarded Booted device before host startup', async () => {
-    jest.mocked(resolveLocalEgressServeSimBootEnvironmentAsync).mockResolvedValue({
-      SERVE_SIM_ADDITIONAL_DYLIBS: '/w/bin/egress-guard.dylib',
+    boot.resolve({
+      deviceIdentifier: 'iPhone 17' as never,
+      udid: 'udid' as never,
+      displayName: '',
     });
-    jest.mocked(IosSimulatorUtils.getDeviceAsync).mockResolvedValue({ state: 'Booted' } as never);
-    await runStep(BuildRuntimePlatform.DARWIN);
-    expect(IosSimulatorUtils.getDeviceAsync).toHaveBeenCalledWith({
-      udid: 'SELECTED-UDID',
-      env: {},
-    });
-    expect(spawn).toHaveBeenCalledTimes(1);
-    expect(spawn).toHaveBeenCalledWith('xcrun', ['simctl', 'shutdown', 'SELECTED-UDID'], {
-      env: {},
-      logger: expect.any(Object),
-      signal: expect.any(AbortSignal),
-    });
-    expect(jest.mocked(spawn).mock.invocationCallOrder[0]).toBeLessThan(
-      jest.mocked(runAgentDeviceRemoteSessionAsync).mock.invocationCallOrder[0]
+    await step;
+
+    expect(installBuildAsync).toHaveBeenCalledWith(
+      expect.objectContaining({ artifactPath: '/tmp/App.app' })
+    );
+    expect(launchApplicationAsync).toHaveBeenCalledWith(
+      expect.objectContaining({
+        applicationIdentifier: 'dev.example.app',
+        launchArgs: ['-flag'],
+        openUrl: 'exp://example.test',
+      })
+    );
+    expect(jest.mocked(installBuildAsync).mock.invocationCallOrder[0]).toBeLessThan(
+      jest.mocked(launchApplicationAsync).mock.invocationCallOrder[0]
     );
   });
 
@@ -260,7 +189,7 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
       expoApiV2BaseUrl: 'https://api.expo.test/v2/',
     } as unknown as CustomBuildContext;
 
-    await runStep(BuildRuntimePlatform.LINUX, { build_id: 'build-id' }, undefined, sessionCtx);
+    await runStep(BuildRuntimePlatform.LINUX, { build_id: 'build-id' }, sessionCtx);
 
     expect(downloadBuildAsync).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -284,7 +213,6 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     await runStep(
       BuildRuntimePlatform.LINUX,
       { application_archive_url: 'https://example.test/app.tar.gz' },
-      undefined,
       sessionCtx
     );
     expect(downloadBuildAsync).toHaveBeenLastCalledWith(
@@ -295,96 +223,7 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     );
   });
 
-  it('fails before download or host startup when guarded device shutdown fails', async () => {
-    jest.mocked(resolveLocalEgressServeSimBootEnvironmentAsync).mockResolvedValue({
-      SERVE_SIM_ADDITIONAL_DYLIBS: '/w/bin/egress-guard.dylib',
-    });
-    jest.mocked(IosSimulatorUtils.getDeviceAsync).mockResolvedValue({ state: 'Booted' } as never);
-    jest.mocked(spawn).mockRejectedValue(new Error('shutdown failed'));
-    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).rejects.toThrow(
-      'shutdown failed'
-    );
-    expect(downloadBuildAsync).not.toHaveBeenCalled();
-    expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
-    expect(stopLocalEgressResourcesAsync).toHaveBeenCalledTimes(1);
-  });
-
-  it('provides Simulator preparation and downloaded startup options to the remote session', async () => {
-    const hostReady = deferred();
-    jest.mocked(resolveLocalEgressServeSimBootEnvironmentAsync).mockResolvedValue({
-      SERVE_SIM_ADDITIONAL_DYLIBS: '/w/bin/egress-guard.dylib',
-    });
-    jest.mocked(runAgentDeviceRemoteSessionAsync).mockImplementation(async (_ctx, { device }) => {
-      expect('iosSimulatorUdid' in device).toBe(true);
-      if (!('iosSimulatorUdid' in device)) {
-        return;
-      }
-      await hostReady.promise;
-      deviceLaunch = await device.application;
-    });
-    const step = runStep(BuildRuntimePlatform.DARWIN, {
-      device_identifier: 'iPhone 17',
-      build_id: 'build-id',
-      launch_args: ['-flag'],
-      open_url: 'exp://example.test',
-    });
-    await flushAsync();
-    expect(IosSimulatorUtils.resolveUdidAsync).toHaveBeenCalledWith({
-      deviceIdentifier: 'iPhone 17',
-      env: {},
-    });
-    expect(bootIosSimulatorAsync).not.toHaveBeenCalled();
-    expect(downloadBuildAsync).toHaveBeenCalledTimes(1);
-    expect(readIosApplicationIdentifierAsync).toHaveBeenCalledWith({
-      artifactPath: '/tmp/App.app',
-      env: {},
-    });
-    expect(installBuildAsync).not.toHaveBeenCalled();
-    expect(launchApplicationAsync).not.toHaveBeenCalled();
-    expect(deviceLaunch).toBeUndefined();
-    hostReady.resolve();
-    await step;
-    expect(deviceLaunch).toEqual({
-      installAppPath: '/tmp/App.app',
-      launchAppIdentifier: 'dev.example.app',
-      launchArgs: ['-flag'],
-      openUrl: 'exp://example.test',
-    });
-  });
-
-  it('fails a guarded session before download or host startup if its boot files are missing', async () => {
-    jest
-      .mocked(resolveLocalEgressServeSimBootEnvironmentAsync)
-      .mockRejectedValue(new Error('missing bin/egress-guard-check'));
-    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).rejects.toThrow(
-      'missing bin/egress-guard-check'
-    );
-    expect(startLocalEgressGuardRelayAsync).not.toHaveBeenCalled();
-    expect(downloadBuildAsync).not.toHaveBeenCalled();
-    expect(bootIosSimulatorAsync).not.toHaveBeenCalled();
-    expect(IosSimulatorUtils.getDeviceAsync).not.toHaveBeenCalled();
-    expect(spawn).not.toHaveBeenCalled();
-    expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
-    expect(stopLocalEgressResourcesAsync).toHaveBeenCalledTimes(1);
-  });
-
-  it('releases guard reporting and egress resources when host startup fails', async () => {
-    jest.mocked(resolveLocalEgressServeSimBootEnvironmentAsync).mockResolvedValue({
-      SERVE_SIM_ADDITIONAL_DYLIBS: '/w/bin/egress-guard.dylib',
-    });
-    jest
-      .mocked(runAgentDeviceRemoteSessionAsync)
-      .mockRejectedValueOnce(new Error('guard check failed'));
-    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).rejects.toThrow(
-      'guard check failed'
-    );
-    expect(startLocalEgressGuardRelayAsync).toHaveBeenCalledTimes(1);
-    expect(stopLocalEgressResourcesAsync).toHaveBeenCalledTimes(1);
-    expect(installBuildAsync).not.toHaveBeenCalled();
-    expect(launchApplicationAsync).not.toHaveBeenCalled();
-  });
-
-  it('waits for the download before handing the app to the host', async () => {
+  it('waits for the download when the Simulator boots first', async () => {
     const download = deferred<{ artifactPath: string }>();
     jest.mocked(downloadBuildAsync).mockReturnValue(download.promise);
 
@@ -396,21 +235,16 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
 
     download.resolve({ artifactPath: '/tmp/App.app' });
     await step;
-    expect(readIosApplicationIdentifierAsync).toHaveBeenCalledTimes(1);
-    expect(installBuildAsync).not.toHaveBeenCalled();
+    expect(installBuildAsync).toHaveBeenCalledTimes(1);
   });
 
-  it('passes the selected Simulator to the host even when there is no app', async () => {
+  it('makes the session ready when the device boots if there is no app', async () => {
     await runStep(BuildRuntimePlatform.DARWIN);
 
     expect(downloadBuildAsync).not.toHaveBeenCalled();
     expect(installBuildAsync).not.toHaveBeenCalled();
     expect(launchApplicationAsync).not.toHaveBeenCalled();
-    expect(sessionDevice()).toEqual({
-      iosSimulatorUdid: 'SELECTED-UDID',
-      bootEnv: undefined,
-      application: undefined,
-    });
+    await expect(sessionDevice().ready).resolves.toBeUndefined();
   });
 
   it('boots the Android Emulator with the device inputs', async () => {
@@ -442,10 +276,23 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
   });
 
   it('fails the session when the download fails, without an unhandled rejection', async () => {
+    const boot = deferred<Awaited<ReturnType<typeof bootIosSimulatorAsync>>>();
+    jest.mocked(bootIosSimulatorAsync).mockReturnValue(boot.promise);
     jest.mocked(downloadBuildAsync).mockRejectedValue(new Error('download failed'));
-    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).rejects.toThrow(
-      'download failed'
-    );
+
+    const stepFailure = expect(
+      runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })
+    ).rejects.toThrow('download failed');
+    // The download fails while the boot still runs. Nothing inside the step may leave
+    // that rejection unhandled; Jest fails the test if it does.
+    await flushAsync();
+    boot.resolve({
+      deviceIdentifier: 'iPhone 17' as never,
+      udid: 'udid' as never,
+      displayName: '',
+    });
+
+    await stepFailure;
     expect(installBuildAsync).not.toHaveBeenCalled();
   });
 
@@ -474,24 +321,23 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     jest
       .mocked(runAgentDeviceRemoteSessionAsync)
       .mockImplementation(async (_ctx, { tasks, device }) => {
-        const ready = runDevicePreparationAsync(device);
         await beforeFailure?.();
         const daemon = tasks.run('agent-device daemon', async () => {
           throw new Error('daemon failed');
         });
         try {
-          await Promise.all([daemon, ready]);
+          await Promise.all([daemon, device.ready]);
         } finally {
-          await Promise.allSettled([daemon, ready]);
+          await Promise.allSettled([daemon, device.ready]);
         }
       });
   }
 
-  it('stops the download and waits for it when Android boot fails', async () => {
+  it('stops the download and waits for it when the boot fails', async () => {
     const download = mockStalledDownload();
-    jest.mocked(startAndroidEmulatorAsync).mockRejectedValue(new Error('boot failed'));
+    jest.mocked(bootIosSimulatorAsync).mockRejectedValue(new Error('boot failed'));
 
-    await expect(runStep(BuildRuntimePlatform.LINUX, { build_id: 'build-id' })).rejects.toThrow(
+    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).rejects.toThrow(
       'boot failed'
     );
 
@@ -515,79 +361,25 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     expect(launchApplicationAsync).not.toHaveBeenCalled();
   });
 
-  it('drains the download when host startup fails before app preparation', async () => {
-    const download = mockStalledDownload();
-    jest.mocked(runAgentDeviceRemoteSessionAsync).mockRejectedValue(new Error('host failed'));
-
-    await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).rejects.toThrow(
-      'host failed'
-    );
-    expect(download.aborted()).toBe(true);
-    expect(download.settled()).toBe(true);
-    expect(installBuildAsync).not.toHaveBeenCalled();
-  });
-
-  it('does not start work for an already cancelled step', async () => {
-    const controller = new AbortController();
-    controller.abort(new Error('cancelled'));
-
-    await expect(
-      runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' }, controller.signal)
-    ).rejects.toThrow('cancelled');
-    expect(selectXcodeDeveloperDirectoryAsync).not.toHaveBeenCalled();
-    expect(downloadBuildAsync).not.toHaveBeenCalled();
-    expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
-  });
-
-  it('cancels and drains a pending download through the external signal', async () => {
-    const controller = new AbortController();
-    const download = mockStalledDownload();
-    const step = runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' }, controller.signal);
-    const failure = expect(step).rejects.toThrow('cancelled');
-    await flushAsync();
-    controller.abort(new Error('cancelled'));
-
-    await failure;
-    expect(download.aborted()).toBe(true);
-    expect(download.settled()).toBe(true);
-    expect(installBuildAsync).not.toHaveBeenCalled();
-  });
-
-  it('does not start device or download work after cancellation during Xcode selection', async () => {
-    const controller = new AbortController();
-    const selected = deferred();
-    jest.mocked(selectXcodeDeveloperDirectoryAsync).mockReturnValue(selected.promise);
-    const step = runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' }, controller.signal);
-    const failure = expect(step).rejects.toThrow('cancelled');
-    await flushAsync();
-    controller.abort(new Error('cancelled'));
-    selected.resolve();
-
-    await failure;
-    expect(IosSimulatorUtils.resolveUdidAsync).not.toHaveBeenCalled();
-    expect(bootIosSimulatorAsync).not.toHaveBeenCalled();
-    expect(downloadBuildAsync).not.toHaveBeenCalled();
-    expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
-  });
-
-  it('drains app preparation when the daemon fails', async () => {
-    const metadata = deferred<string>();
-    const metadataStarted = deferred();
-    jest.mocked(readIosApplicationIdentifierAsync).mockImplementation(() => {
-      metadataStarted.resolve();
-      return metadata.promise;
+  it('does not launch the app when startup fails during the install', async () => {
+    const install = deferred<Awaited<ReturnType<typeof installBuildAsync>>>();
+    const installStarted = deferred();
+    jest.mocked(installBuildAsync).mockImplementation(() => {
+      installStarted.resolve();
+      return install.promise;
     });
     mockSessionWithFailingDaemon(async () => {
-      await metadataStarted.promise;
-      setImmediate(() => metadata.resolve('dev.example.app'));
+      await installStarted.promise;
+      // The install finishes only after the daemon failed.
+      setImmediate(() => install.resolve({ applicationIdentifier: 'dev.example.app' }));
     });
+
     await expect(runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id' })).rejects.toThrow(
       'daemon failed'
     );
-    expect(readIosApplicationIdentifierAsync).toHaveBeenCalledTimes(1);
-    expect(installBuildAsync).not.toHaveBeenCalled();
+
+    expect(installBuildAsync).toHaveBeenCalledTimes(1);
     expect(launchApplicationAsync).not.toHaveBeenCalled();
-    expect(deviceLaunch).toBeUndefined();
   });
 
   it('rejects conflicting application inputs before it boots anything', async () => {
@@ -625,8 +417,6 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
       'network_capture_fields',
       'public_preview',
       'private_preview_url',
-      'frame_ancestors',
-      'cors_origins',
       'package_version',
       'max_idle_time_minutes',
       'max_duration_seconds',
@@ -650,63 +440,6 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
     }
   );
 
-  it('passes frame_ancestors to the session host', async () => {
-    await runStep(BuildRuntimePlatform.DARWIN, {
-      frame_ancestors: ['https://embed.example.test'],
-    });
-    expect(runAgentDeviceRemoteSessionAsync).toHaveBeenCalledWith(
-      ctx,
-      expect.objectContaining({ frameAncestors: ['https://embed.example.test'] })
-    );
-  });
-
-  it('passes cors_origins to the session host', async () => {
-    await runStep(BuildRuntimePlatform.DARWIN, {
-      cors_origins: ['https://app.example.test'],
-    });
-    expect(runAgentDeviceRemoteSessionAsync).toHaveBeenCalledWith(
-      ctx,
-      expect.objectContaining({ corsOrigins: ['https://app.example.test'] })
-    );
-  });
-
-  it.each([
-    ['argument count', { launch_args: Array(257).fill('a') }],
-    ['argument length', { launch_args: ['a'.repeat(9000)] }],
-    ['NUL argument', { launch_args: ['a\u0000b'] }],
-    ['total UTF-8 bytes', { launch_args: Array(8).fill('😃'.repeat(4096)) }],
-    ['NUL URL', { open_url: 'example:\u0000screen' }],
-    ['URL length', { open_url: `example://${'a'.repeat(8192)}` }],
-  ])('rejects iOS launch %s before startup work', async (_name, inputs) => {
-    const step = runStep(BuildRuntimePlatform.DARWIN, { build_id: 'build-id', ...inputs });
-    await expect(step).rejects.toBeInstanceOf(UserError);
-    expect(selectXcodeDeveloperDirectoryAsync).not.toHaveBeenCalled();
-    expect(IosSimulatorUtils.resolveUdidAsync).not.toHaveBeenCalled();
-    expect(bootIosSimulatorAsync).not.toHaveBeenCalled();
-    expect(downloadBuildAsync).not.toHaveBeenCalled();
-    expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
-  });
-
-  it.each([
-    ['NUL argument', { launch_args: ['a\u0000b'] }],
-    ['command length', { launch_args: ['--es', 'quotes', "'".repeat(20_000)] }],
-    ['NUL URL', { open_url: 'example:\u0000screen' }],
-  ])('rejects Android launch %s before startup work', async (_name, inputs) => {
-    const step = runStep(BuildRuntimePlatform.LINUX, { build_id: 'build-id', ...inputs });
-    await expect(step).rejects.toMatchObject({ errorCode: 'EAS_LAUNCH_APPLICATION_INVALID_INPUT' });
-    expect(startAndroidEmulatorAsync).not.toHaveBeenCalled();
-    expect(downloadBuildAsync).not.toHaveBeenCalled();
-    expect(runAgentDeviceRemoteSessionAsync).not.toHaveBeenCalled();
-  });
-
-  it('keeps Android launch inputs on its existing direct path', async () => {
-    const launchArgs = ['a'.repeat(9000)];
-    await runStep(BuildRuntimePlatform.LINUX, { build_id: 'build-id', launch_args: launchArgs });
-    expect(launchApplicationAsync).toHaveBeenCalledWith(
-      expect.objectContaining({ runtimePlatform: BuildRuntimePlatform.LINUX, launchArgs })
-    );
-  });
-
   it('passes network capture to the session', async () => {
     await runStep(BuildRuntimePlatform.DARWIN, {
       network_capture: true,

packages/build-tools/src/steps/functions/__tests__/startAppiumRemoteSession.test.ts

@@ -6,18 +6,14 @@ import { createGlobalContextMock } from '../../../__tests__/utils/context';
 import { type CustomBuildContext } from '../../../customBuildContext';
 import { AndroidEmulatorUtils } from '../../../utils/AndroidEmulatorUtils';
 import { IosSimulatorUtils } from '../../../utils/IosSimulatorUtils';
-import * as processes from '../../../utils/processes';
 import { sleepAsync } from '../../../utils/retry';
 import { turtleFetch } from '../../../utils/turtleFetch';
 import { startAppiumEventCollectionAsync } from '../../utils/appiumEvents';
 import { startDeviceSessionHostAsync } from '../../utils/deviceSessionHost';
-import { preparePreinstalledWdaAsync } from '../../utils/preinstalledWda';
 import {
-  ensureFfmpegInstalledOnceAsync,
   selectXcodeDeveloperDirectoryAsync,
   spawnDetached,
   startNgrokTunnelAsync,
-  waitForDeviceRunSessionStoppedAsync,
 } from '../../utils/remoteDeviceRunSession';
 
 import {
@@ -31,16 +27,11 @@ jest.mock('../../../utils/AndroidEmulatorUtils', () => ({
   AndroidEmulatorUtils: { getAttachedDevicesAsync: jest.fn() },
 }));
 jest.mock('../../../utils/IosSimulatorUtils', () => ({
-  IosSimulatorUtils: {
-    getAvailableDevicesAsync: jest.fn(),
-    getDeviceAsync: jest.fn(),
-    resolveUdidAsync: jest.fn().mockResolvedValue('chosen-ios-udid'),
-  },
+  IosSimulatorUtils: { getAvailableDevicesAsync: jest.fn() },
 }));
 jest.mock('../../utils/remoteDeviceRunSession', () => ({
   ...jest.requireActual('../../utils/remoteDeviceRunSession'),
   selectXcodeDeveloperDirectoryAsync: jest.fn(),
-  ensureFfmpegInstalledOnceAsync: jest.fn(),
   spawnDetached: jest.fn(),
   startNgrokTunnelAsync: jest.fn(),
   waitForDeviceRunSessionStoppedAsync: jest.fn(),
@@ -57,15 +48,6 @@ jest.mock('../../../utils/turtleFetch', () => ({
 }));
 jest.mock('../../utils/appiumEvents', () => ({ startAppiumEventCollectionAsync: jest.fn() }));
 jest.mock('../../utils/deviceSessionHost');
-jest.mock('../../utils/preinstalledWda', () => ({ preparePreinstalledWdaAsync: jest.fn() }));
-jest.mock('../../utils/iosAppArtifact', () => ({
-  ...jest.requireActual('../../utils/iosAppArtifact'),
-  readIosApplicationIdentifierAsync: jest.fn().mockResolvedValue('dev.example.app'),
-}));
-jest.mock('../../utils/localEgressGuard', () => ({
-  resolveLocalEgressServeSimBootEnvironmentAsync: jest.fn().mockResolvedValue(null),
-}));
-
 jest.mock('../../utils/localEgressSession', () => ({
   ...jest.requireActual('../../utils/localEgressSession'),
   uploadRemoteSessionConfigWithLocalEgressAsync: jest.fn(),
@@ -106,6 +88,7 @@ describe(resolveAppiumDeviceAsync, () => {
       resolveAppiumDeviceAsync({
         runtimePlatform: BuildRuntimePlatform.DARWIN,
         env: {},
+        logger,
       })
     ).resolves.toEqual({
       platformName: 'iOS',
@@ -114,6 +97,7 @@ describe(resolveAppiumDeviceAsync, () => {
       udid: 'ios-simulator-id',
       runtimeIdentifier: 'com.apple.CoreSimulator.SimRuntime.iOS-26-5',
     });
+    expect(selectXcodeDeveloperDirectoryAsync).toHaveBeenCalledWith({ env: {}, logger });
     expect(IosSimulatorUtils.getAvailableDevicesAsync).toHaveBeenCalledWith({
       env: {},
       filter: 'booted',
@@ -129,6 +113,7 @@ describe(resolveAppiumDeviceAsync, () => {
       resolveAppiumDeviceAsync({
         runtimePlatform: BuildRuntimePlatform.LINUX,
         env: {},
+        logger,
       })
     ).resolves.toEqual({
       platformName: 'Android',
@@ -227,13 +212,6 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
   const stopEventCollection = jest.fn();
 
   beforeEach(() => {
-    jest.mocked(ensureFfmpegInstalledOnceAsync).mockResolvedValue(undefined);
-    jest.mocked(preparePreinstalledWdaAsync).mockResolvedValue({});
-    jest.mocked(IosSimulatorUtils.getDeviceAsync).mockResolvedValue({
-      udid: 'CHOSEN-IOS-UDID',
-      runtime: 'com.apple.CoreSimulator.SimRuntime.iOS-26-5',
-      state: 'Shutdown',
-    } as never);
     jest.mocked(spawn).mockImplementation((async (_command: string, args: string[]) => ({
       stdout: args.includes('--json') ? '{}' : '',
     })) as never);
@@ -264,7 +242,6 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
         apiUrl: 'https://web-preview.tunnel.example.com',
         closeAsync: jest.fn(),
       }),
-      getLastPreviewActivityAt: jest.fn(),
       finishAsync: jest.fn(),
     });
   });
@@ -273,22 +250,16 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
     jest.restoreAllMocks();
   });
 
-  async function runSessionAsync(
-    logger: { info: jest.Mock; warn: jest.Mock },
-    maxIdleTimeMinutes?: number,
-    runtimePlatform = BuildRuntimePlatform.LINUX,
-    startupInputs: Record<string, { value: unknown }> = {}
-  ): Promise<void> {
+  async function runSessionAsync(logger: { info: jest.Mock; warn: jest.Mock }): Promise<void> {
     await createStartAppiumRemoteSessionBuildFunction({} as CustomBuildContext).fn!(
       {
         logger,
-        global: { runtimePlatform },
+        global: { runtimePlatform: BuildRuntimePlatform.LINUX },
       } as unknown as BuildStepContext,
       {
         inputs: {
           package_version: { value: undefined },
-          max_idle_time_minutes: { value: maxIdleTimeMinutes },
-          ...startupInputs,
+          max_idle_time_minutes: { value: undefined },
         },
         outputs: {},
         env: {
@@ -309,345 +280,6 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
     );
   }
 
-  it.each([false, true])(
-    'preserves preview settings with Simulator startup %s',
-    async bootSimulator => {
-      stopAppium.mockResolvedValue(undefined);
-      jest
-        .mocked(IosSimulatorUtils.getAvailableDevicesAsync)
-        .mockResolvedValue([{ udid: 'chosen-ios-udid' } as never]);
-      await runSessionAsync(logger, undefined, BuildRuntimePlatform.DARWIN, {
-        ...(bootSimulator
-          ? { boot_simulator: { value: true }, device_identifier: { value: 'chosen-device' } }
-          : {}),
-        public_preview: { value: false },
-        private_preview_url: { value: 'https://expo.dev/private-preview' },
-        frame_ancestors: { value: ['https://preview.example.com'] },
-        cors_origins: { value: ['https://api.example.com'] },
-      });
-      expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-        expect.anything(),
-        expect.objectContaining({
-          disableShare: true,
-          privatePreviewUrl: 'https://expo.dev/private-preview',
-          frameAncestors: ['https://preview.example.com'],
-          corsOrigins: ['https://api.example.com'],
-        })
-      );
-    }
-  );
-
-  it('selects Xcode only once for an already-prepared iOS session', async () => {
-    stopAppium.mockResolvedValue(undefined);
-    jest.mocked(selectXcodeDeveloperDirectoryAsync).mockClear();
-    jest.mocked(IosSimulatorUtils.getAvailableDevicesAsync).mockResolvedValue([
-      {
-        udid: 'chosen-ios-udid',
-        runtime: 'com.apple.CoreSimulator.SimRuntime.iOS-26-4',
-      } as never,
-    ]);
-    jest.mocked(preparePreinstalledWdaAsync).mockResolvedValue({
-      'appium:usePreinstalledWDA': true,
-      'appium:prebuiltWDAPath': '/tmp/legacy-wda.app',
-    });
-    await runSessionAsync(
-      { info: jest.fn(), warn: jest.fn() },
-      undefined,
-      BuildRuntimePlatform.DARWIN
-    );
-    expect(preparePreinstalledWdaAsync).toHaveBeenCalledWith(
-      expect.objectContaining({ runtimeIdentifier: 'com.apple.CoreSimulator.SimRuntime.iOS-26-4' })
-    );
-    expect(IosSimulatorUtils.getDeviceAsync).not.toHaveBeenCalled();
-    expect(JSON.parse(jest.mocked(spawnDetached).mock.calls[0][0].args.at(-1)!)).toEqual({
-      'appium:eventTimings': true,
-      'appium:usePreinstalledWDA': true,
-      'appium:prebuiltWDAPath': '/tmp/legacy-wda.app',
-    });
-    expect(selectXcodeDeveloperDirectoryAsync).toHaveBeenCalledTimes(1);
-    expect(
-      jest.mocked(selectXcodeDeveloperDirectoryAsync).mock.invocationCallOrder[0]
-    ).toBeLessThan(
-      jest.mocked(IosSimulatorUtils.getAvailableDevicesAsync).mock.invocationCallOrder[0]
-    );
-  });
-
-  it('starts serve-sim on the selected iOS device while Appium installation is pending', async () => {
-    stopAppium.mockResolvedValue(undefined);
-    jest.mocked(selectXcodeDeveloperDirectoryAsync).mockClear();
-    jest.mocked(IosSimulatorUtils.getAvailableDevicesAsync).mockClear();
-    jest.mocked(preparePreinstalledWdaAsync).mockResolvedValue({
-      'appium:usePreinstalledWDA': true,
-      'appium:prebuiltWDAPath': '/tmp/selected-wda.app',
-    });
-    let releaseInstall!: (value: unknown) => void;
-    let enteredInstall!: () => void;
-    const installEntered = new Promise<void>(resolve => {
-      enteredInstall = resolve;
-    });
-    jest.mocked(spawn).mockImplementationOnce(() => {
-      enteredInstall();
-      return new Promise(resolve => {
-        releaseInstall = resolve;
-      }) as never;
-    });
-    const running = createStartAppiumRemoteSessionBuildFunction({} as CustomBuildContext).fn!(
-      {
-        logger: { info: jest.fn(), warn: jest.fn() },
-        global: { runtimePlatform: BuildRuntimePlatform.DARWIN },
-      } as unknown as BuildStepContext,
-      {
-        inputs: {
-          package_version: { value: undefined },
-          max_idle_time_minutes: { value: undefined },
-          device_identifier: { value: 'chosen-device' },
-          install_app_path: { value: '/tmp/App.app' },
-          launch_args: { value: ['--literal'] },
-          open_url: { value: 'example://home' },
-        },
-        outputs: {},
-        env: {
-          DEVICE_RUN_SESSION_ID: 'device-run-session-id',
-          EAS_SIMULATOR_NGROK_TUNNEL_DOMAIN: 'tunnel.example.com',
-          NGROK_AUTHTOKEN: 'ngrok-token',
-        },
-      } as never
-    );
-    await installEntered;
-    expect(
-      jest.mocked(selectXcodeDeveloperDirectoryAsync).mock.invocationCallOrder[0]
-    ).toBeLessThan(jest.mocked(IosSimulatorUtils.resolveUdidAsync).mock.invocationCallOrder[0]);
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({
-        iosSimulatorUdid: 'CHOSEN-IOS-UDID',
-        installAppPath: '/tmp/App.app',
-        launchAppIdentifier: 'dev.example.app',
-        launchArgs: ['--literal'],
-        openUrl: 'example://home',
-      })
-    );
-    expect(IosSimulatorUtils.getAvailableDevicesAsync).not.toHaveBeenCalled();
-    expect(preparePreinstalledWdaAsync).not.toHaveBeenCalled();
-    const readyHost = await jest.mocked(startDeviceSessionHostAsync).mock.results[0].value;
-    expect(readyHost.finishAsync).not.toHaveBeenCalled();
-    expect(jest.mocked(startDeviceSessionHostAsync).mock.calls[0][1].signal?.aborted).toBe(false);
-    releaseInstall({ stdout: '' });
-    await running;
-    expect(readyHost.finishAsync).toHaveBeenCalledTimes(1);
-    expect(IosSimulatorUtils.getDeviceAsync).toHaveBeenCalledWith({
-      udid: 'CHOSEN-IOS-UDID',
-      env: expect.objectContaining({ DEVICE_RUN_SESSION_ID: 'device-run-session-id' }),
-    });
-    expect(preparePreinstalledWdaAsync).toHaveBeenCalledWith(
-      expect.objectContaining({
-        runtimeIdentifier: 'com.apple.CoreSimulator.SimRuntime.iOS-26-5',
-        appiumHome: jest.mocked(spawnDetached).mock.calls[0][0].env.APPIUM_HOME,
-      })
-    );
-    expect(JSON.parse(jest.mocked(spawnDetached).mock.calls[0][0].args.at(-1)!)).toEqual({
-      'appium:eventTimings': true,
-      'appium:usePreinstalledWDA': true,
-      'appium:prebuiltWDAPath': '/tmp/selected-wda.app',
-    });
-    expect(selectXcodeDeveloperDirectoryAsync).toHaveBeenCalledTimes(1);
-    expect(stopAppium).toHaveBeenCalledTimes(1);
-  });
-
-  it('drains a failed Simulator startup installer before removing its Appium home', async () => {
-    const hostError = new Error('Simulator boot failed');
-    let failHost!: (error: Error) => void;
-    jest.mocked(startDeviceSessionHostAsync).mockReturnValueOnce(
-      new Promise((_resolve, reject) => {
-        failHost = reject;
-      })
-    );
-    let enteredInstall!: () => void;
-    const installEntered = new Promise<void>(resolve => {
-      enteredInstall = resolve;
-    });
-    let closeInstaller!: (error: Error) => void;
-    const child = { pid: 12345, kill: jest.fn() };
-    jest.mocked(spawn).mockImplementationOnce(() => {
-      enteredInstall();
-      return Object.assign(
-        new Promise((_resolve, reject) => {
-          closeInstaller = reject;
-        }),
-        { child }
-      ) as never;
-    });
-    const killGroup = jest.spyOn(processes, 'killProcessGroup').mockImplementation(() => {});
-    const running = runSessionAsync(logger, undefined, BuildRuntimePlatform.DARWIN, {
-      boot_simulator: { value: true },
-      device_identifier: { value: 'chosen-device' },
-    });
-    const settled = jest.fn();
-    const observed = running.then(settled, settled);
-    try {
-      await installEntered;
-      const home = jest.mocked(spawn).mock.calls[0][2]?.cwd as string;
-      const hostOptions = jest.mocked(startDeviceSessionHostAsync).mock.calls[0][1];
-      hostOptions.onStartupError?.(hostError);
-      failHost(hostError);
-      await Promise.resolve();
-      expect(killGroup).toHaveBeenCalledWith(child, 'SIGKILL');
-      expect(settled).not.toHaveBeenCalled();
-      expect(fs.existsSync(home)).toBe(true);
-      closeInstaller(new Error('installer interrupted'));
-      await expect(running).rejects.toBe(hostError);
-      expect(fs.existsSync(home)).toBe(false);
-      expect(preparePreinstalledWdaAsync).not.toHaveBeenCalled();
-      expect(startNgrokTunnelAsync).not.toHaveBeenCalled();
-    } finally {
-      closeInstaller?.(new Error('test cleanup'));
-      await observed;
-    }
-  });
-
-  it('removes a completed Appium install when Simulator failure interrupts FFmpeg setup', async () => {
-    const hostError = new Error('Simulator startup failed');
-    let failHost!: (error: Error) => void;
-    jest.mocked(startDeviceSessionHostAsync).mockReturnValueOnce(
-      new Promise((_resolve, reject) => {
-        failHost = reject;
-      })
-    );
-    jest
-      .mocked(ensureFfmpegInstalledOnceAsync)
-      .mockImplementationOnce(
-        ({ signal }) =>
-          new Promise(resolve => signal?.addEventListener('abort', () => resolve(), { once: true }))
-      );
-    let installed!: () => void;
-    const installationFinished = new Promise<void>(resolve => {
-      installed = resolve;
-    });
-    jest.mocked(spawn).mockImplementation((async (_command: string, args: string[]) => {
-      if (args[0] === 'driver' && args[1] === 'install') {
-        installed();
-      }
-      return { stdout: args.includes('--json') ? '{}' : '' };
-    }) as never);
-    const running = runSessionAsync(logger, undefined, BuildRuntimePlatform.DARWIN, {
-      boot_simulator: { value: true },
-      device_identifier: { value: 'chosen-device' },
-    });
-    await installationFinished;
-    await new Promise<void>(resolve => setImmediate(resolve));
-    jest.mocked(startDeviceSessionHostAsync).mock.calls[0][1].onStartupError?.(hostError);
-    failHost(hostError);
-    await expect(running).rejects.toBe(hostError);
-    const home = jest.mocked(spawn).mock.calls[0][2]?.cwd as string;
-    expect(fs.existsSync(home)).toBe(false);
-    expect(preparePreinstalledWdaAsync).not.toHaveBeenCalled();
-  });
-
-  it('preserves an installer failure before a later host failure during home cleanup', async () => {
-    const installError = new Error('npm install failed');
-    const hostError = new Error('later Simulator failure');
-    let failHost!: (error: Error) => void;
-    jest.mocked(startDeviceSessionHostAsync).mockReturnValueOnce(
-      new Promise((_resolve, reject) => {
-        failHost = reject;
-      })
-    );
-    jest.mocked(spawn).mockRejectedValueOnce(installError);
-    const remove = fs.promises.rm.bind(fs.promises);
-    let enteredCleanup!: () => void;
-    const cleanupEntered = new Promise<void>(resolve => {
-      enteredCleanup = resolve;
-    });
-    let releaseCleanup!: () => void;
-    const cleanupGate = new Promise<void>(resolve => {
-      releaseCleanup = resolve;
-    });
-    jest.spyOn(fs.promises, 'rm').mockImplementationOnce(async (directory, options) => {
-      enteredCleanup();
-      await cleanupGate;
-      await remove(directory, options);
-    });
-    const running = runSessionAsync(logger, undefined, BuildRuntimePlatform.DARWIN, {
-      boot_simulator: { value: true },
-      device_identifier: { value: 'chosen-device' },
-    });
-    const observed = running.catch(() => {});
-    try {
-      await cleanupEntered;
-      const options = jest.mocked(startDeviceSessionHostAsync).mock.calls[0][1];
-      expect(options.signal?.reason).toBe(installError);
-      options.onStartupError?.(hostError);
-      failHost(hostError);
-      releaseCleanup();
-      await expect(running).rejects.toBe(installError);
-      expect(startNgrokTunnelAsync).not.toHaveBeenCalled();
-    } finally {
-      failHost(hostError);
-      releaseCleanup();
-      await observed;
-    }
-  });
-
-  it.each(['WDA download', 'Appium readiness'])(
-    'keeps the Simulator error when it interrupts %s',
-    async stage => {
-      stopAppium.mockResolvedValue(undefined);
-      const hostError = new Error('Simulator launch failed');
-      const laterError = new Error(`${stage} interrupted`);
-      let failHost!: (error: Error) => void;
-      jest.mocked(startDeviceSessionHostAsync).mockReturnValueOnce(
-        new Promise((_resolve, reject) => {
-          failHost = reject;
-        })
-      );
-      let enteredStage!: () => void;
-      const stageEntered = new Promise<void>(resolve => {
-        enteredStage = resolve;
-      });
-      let rejectStage!: (error: Error) => void;
-      let setupSignal: AbortSignal | undefined;
-      const waitForStage = (signal?: AbortSignal): Promise<never> => {
-        setupSignal = signal;
-        enteredStage();
-        return new Promise((_resolve, reject) => {
-          rejectStage = reject;
-          signal?.addEventListener('abort', () => reject(laterError), { once: true });
-        });
-      };
-      if (stage === 'WDA download') {
-        jest
-          .mocked(preparePreinstalledWdaAsync)
-          .mockImplementationOnce(({ signal }) => waitForStage(signal));
-      } else {
-        jest
-          .mocked(turtleFetch)
-          .mockImplementationOnce((_url, _method, options) =>
-            waitForStage(options?.signal ?? undefined)
-          );
-      }
-      const running = runSessionAsync(logger, undefined, BuildRuntimePlatform.DARWIN, {
-        boot_simulator: { value: true },
-        device_identifier: { value: 'chosen-device' },
-      });
-      const observed = running.catch(() => {});
-      try {
-        await stageEntered;
-        jest.mocked(startDeviceSessionHostAsync).mock.calls[0][1].onStartupError?.(hostError);
-        failHost(hostError);
-        await Promise.resolve();
-        expect(setupSignal?.aborted).toBe(true);
-        await expect(running).rejects.toBe(hostError);
-        const home = jest.mocked(spawn).mock.calls[0][2]?.cwd as string;
-        expect(fs.existsSync(home)).toBe(false);
-        expect(startAppiumEventCollectionAsync).not.toHaveBeenCalled();
-        expect(startNgrokTunnelAsync).not.toHaveBeenCalled();
-      } finally {
-        rejectStage?.(laterError);
-        await observed;
-      }
-    }
-  );
-
   it('keeps the readiness error when Appium cannot be stopped', async () => {
     let now = Date.now();
     jest.spyOn(Date, 'now').mockImplementation(() => now);
@@ -675,32 +307,10 @@ describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () =>
     expect(startNgrokTunnelAsync).not.toHaveBeenCalled();
   });
 
-  it('resets the idle timer on preview input from the session host', async () => {
-    const previewInputAt = new Date('2026-10-19T12:00:00Z');
-    const host = await jest.mocked(startDeviceSessionHostAsync).getMockImplementation()!(
-      {} as never,
-      {} as never
-    );
-    jest.mocked(host.getLastPreviewActivityAt).mockReturnValue(previewInputAt);
-
-    await expect(runSessionAsync({ info: jest.fn(), warn: jest.fn() }, 5)).rejects.toBe(stopError);
-
-    const { idleTimeout } = jest.mocked(waitForDeviceRunSessionStoppedAsync).mock.calls[0][0];
-    expect(idleTimeout?.maxIdleTimeMinutes).toBe(5);
-    expect(idleTimeout?.getLastPreviewActivityAt?.()).toBe(previewInputAt);
-  });
-
   it('fails a finished session when Appium cannot be stopped', async () => {
     const logger = { info: jest.fn(), warn: jest.fn() };
 
     await expect(runSessionAsync(logger)).rejects.toBe(stopError);
-    expect(preparePreinstalledWdaAsync).toHaveBeenCalledWith(
-      expect.objectContaining({ runtimeIdentifier: undefined })
-    );
-    expect(IosSimulatorUtils.getDeviceAsync).not.toHaveBeenCalled();
-    expect(JSON.parse(jest.mocked(spawnDetached).mock.calls[0][0].args.at(-1)!)).toEqual({
-      'appium:eventTimings': true,
-    });
     expectAppiumStoppedAndHomeRemoved(logger);
     expect(stopEventCollection.mock.invocationCallOrder[0]).toBeLessThan(
       stopAppium.mock.invocationCallOrder[0]

packages/build-tools/src/steps/functions/__tests__/startArgentRemoteSession-orchestration.test.ts

@@ -7,9 +7,8 @@ import path from 'node:path';
 import { createGlobalContextMock } from '../../../__tests__/utils/context';
 import { type CustomBuildContext } from '../../../customBuildContext';
 import { Sentry } from '../../../sentry';
-import { IosSimulatorUtils } from '../../../utils/IosSimulatorUtils';
 import { startDeviceSessionHostAsync } from '../../utils/deviceSessionHost';
-import { isProcessDescendantOfAsync, killProcessGroup } from '../../../utils/processes';
+import { isProcessDescendantOfAsync } from '../../../utils/processes';
 import { pollArgentArtifactsForUploadAsync } from '../../utils/argentArtifacts';
 import { startArgentEventCollectionAsync } from '../../utils/argentEvents';
 import { createProcessOutput } from '../../utils/processOutput';
@@ -25,7 +24,6 @@ import {
   waitForDeviceRunSessionStoppedAsync,
 } from '../../utils/remoteDeviceRunSession';
 import { createStartArgentRemoteSessionBuildFunction } from '../startArgentRemoteSession';
-import { readIosApplicationIdentifierAsync } from '../../utils/iosAppArtifact';
 
 // Redirect ~/.argent (where the tool-server writes its state file and event log) to a temp
 // home so waitForArgentToolServerStateAsync — which lives in the module under test and cannot
@@ -40,32 +38,13 @@ jest.mock('node:os', () => {
 });
 jest.mock('@expo/turtle-spawn', () => ({ __esModule: true, default: jest.fn() }));
 jest.mock('../../../sentry');
-jest.mock('../../../utils/processes', () => ({
-  isProcessDescendantOfAsync: jest.fn(),
-  killProcessGroup: jest.fn(),
-}));
+jest.mock('../../../utils/processes', () => ({ isProcessDescendantOfAsync: jest.fn() }));
 jest.mock('../../utils/argentArtifacts', () => ({ pollArgentArtifactsForUploadAsync: jest.fn() }));
 jest.mock('../../utils/argentEvents', () => ({
   ...jest.requireActual('../../utils/argentEvents'),
   startArgentEventCollectionAsync: jest.fn(),
 }));
 jest.mock('../../utils/deviceSessionHost');
-jest.mock('../../utils/iosAppArtifact', () => ({
-  ...jest.requireActual('../../utils/iosAppArtifact'),
-  readIosApplicationIdentifierAsync: jest.fn().mockResolvedValue('dev.example.app'),
-}));
-jest.mock('../../../utils/IosSimulatorUtils', () => ({
-  IosSimulatorUtils: {
-    resolveUdidAsync: jest.fn().mockResolvedValue('selected-ios-udid'),
-    getAvailableDevicesAsync: jest
-      .fn()
-      .mockResolvedValue([{ name: 'iPhone 17', udid: 'selected-ios-udid' }]),
-  },
-}));
-jest.mock('../../utils/localEgressGuard', () => ({
-  resolveLocalEgressServeSimBootEnvironmentAsync: jest.fn().mockResolvedValue(null),
-}));
-
 jest.mock('../../utils/remoteDeviceRunSession', () => ({
   ...jest.requireActual('../../utils/remoteDeviceRunSession'),
   ensureFfmpegInstalledOnceAsync: jest.fn(),
@@ -125,7 +104,6 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
         apiUrl: 'https://web-preview.tunnel.example.com',
         closeAsync: jest.fn(),
       }),
-      getLastPreviewActivityAt: jest.fn(),
       finishAsync: mockPreviewStopAsync,
     });
     jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue(undefined);
@@ -239,7 +217,6 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
       if (phase === 'preview') {
         jest.mocked(startDeviceSessionHostAsync).mockResolvedValueOnce({
           openPreviewAsync: jest.fn().mockRejectedValue(error),
-          getLastPreviewActivityAt: jest.fn(),
           finishAsync: mockPreviewStopAsync,
         });
       } else if (phase === 'config') {
@@ -445,54 +422,6 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
     );
   });
 
-  it('passes frame_ancestors to the session host', async () => {
-    const ctx = {} as CustomBuildContext;
-    const buildFunction = createStartArgentRemoteSessionBuildFunction(ctx);
-    await buildFunction.fn!(
-      {
-        logger: { info: jest.fn(), warn: jest.fn() },
-        global: { runtimePlatform: BuildRuntimePlatform.LINUX },
-      } as unknown as BuildStepContext,
-      {
-        inputs: {
-          package_version: { value: undefined },
-          max_idle_time_minutes: { value: undefined },
-          frame_ancestors: { value: ['https://embed.example.test'] },
-        },
-        outputs: {},
-        env: {},
-      } as never
-    );
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      ctx,
-      expect.objectContaining({ frameAncestors: ['https://embed.example.test'] })
-    );
-  });
-
-  it('passes cors_origins to the session host', async () => {
-    const ctx = {} as CustomBuildContext;
-    const buildFunction = createStartArgentRemoteSessionBuildFunction(ctx);
-    await buildFunction.fn!(
-      {
-        logger: { info: jest.fn(), warn: jest.fn() },
-        global: { runtimePlatform: BuildRuntimePlatform.LINUX },
-      } as unknown as BuildStepContext,
-      {
-        inputs: {
-          package_version: { value: undefined },
-          max_idle_time_minutes: { value: undefined },
-          cors_origins: { value: ['https://app.example.test'] },
-        },
-        outputs: {},
-        env: {},
-      } as never
-    );
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      ctx,
-      expect.objectContaining({ corsOrigins: ['https://app.example.test'] })
-    );
-  });
-
   it('continues the session when disabling the video watermark fails', async () => {
     const error = new Error('bun x failed');
     jest
@@ -530,35 +459,6 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
     expect(waitForDeviceRunSessionStoppedAsync).toHaveBeenCalledTimes(1);
   });
 
-  it('resets the idle timer on preview input from the session host', async () => {
-    const previewInputAt = new Date('2026-10-19T12:00:00Z');
-    const host = await jest.mocked(startDeviceSessionHostAsync).getMockImplementation()!(
-      {} as never,
-      {} as never
-    );
-    jest.mocked(host.getLastPreviewActivityAt).mockReturnValue(previewInputAt);
-    const buildFunction = createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext);
-
-    await buildFunction.fn!(
-      {
-        logger: { info: jest.fn(), warn: jest.fn() },
-        global: { runtimePlatform: BuildRuntimePlatform.LINUX },
-      } as unknown as BuildStepContext,
-      {
-        inputs: {
-          package_version: { value: undefined },
-          max_idle_time_minutes: { value: 5 },
-        },
-        outputs: {},
-        env: {},
-      } as never
-    );
-
-    const { idleTimeout } = jest.mocked(waitForDeviceRunSessionStoppedAsync).mock.calls[0][0];
-    expect(idleTimeout?.maxIdleTimeMinutes).toBe(5);
-    expect(idleTimeout?.getLastPreviewActivityAt?.()).toBe(previewInputAt);
-  });
-
   it('redacts startup credentials and registers the state token for later output', async () => {
     const token = 'tool/server "secret"';
     await fs.promises.writeFile(
@@ -644,280 +544,6 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
     );
   });
 
-  it('boots and prepares the downloaded app while Argent installation is pending, and closes the host if installation fails', async () => {
-    let rejectInstall!: (error: Error) => void;
-    let enteredInstall!: () => void;
-    const installEntered = new Promise<void>(resolve => {
-      enteredInstall = resolve;
-    });
-    jest.mocked(spawn).mockImplementationOnce(() => {
-      enteredInstall();
-      return new Promise((_resolve, reject) => {
-        rejectInstall = reject;
-      }) as never;
-    });
-    const buildFunction = createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext);
-    const running = buildFunction.fn!(
-      {
-        logger: { info: jest.fn(), warn: jest.fn() },
-        global: { runtimePlatform: BuildRuntimePlatform.DARWIN },
-      } as unknown as BuildStepContext,
-      {
-        inputs: {
-          package_version: { value: undefined },
-          max_idle_time_minutes: { value: undefined },
-          device_identifier: { value: 'chosen-device' },
-          install_app_path: { value: '/tmp/App.app' },
-          launch_args: { value: ['--literal'] },
-        },
-        outputs: {},
-        env: {},
-      } as never
-    );
-    await installEntered;
-    expect(
-      jest.mocked(selectXcodeDeveloperDirectoryAsync).mock.invocationCallOrder[0]
-    ).toBeLessThan(jest.mocked(IosSimulatorUtils.resolveUdidAsync).mock.invocationCallOrder[0]);
-    expect(readIosApplicationIdentifierAsync).toHaveBeenCalledWith({
-      artifactPath: '/tmp/App.app',
-      env: {},
-    });
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({
-        iosSimulatorUdid: 'SELECTED-IOS-UDID',
-        installAppPath: '/tmp/App.app',
-        launchAppIdentifier: 'dev.example.app',
-        launchArgs: ['--literal'],
-      })
-    );
-    const error = new Error('Argent install failed');
-    rejectInstall(error);
-    await expect(running).rejects.toBe(error);
-    expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
-    expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-  });
-
-  it.each(['artifacts-list-endpoint', 'tool-server-event-log', 'video-watermark'])(
-    'stops and drains the pending %s command when the concurrent host fails',
-    async flag => {
-      const hostError = new Error('serve-sim startup failed');
-      const commandError = new Error('Argent command exited after cancellation');
-      let failHost!: (error: Error) => void;
-      let finishHostCleanup!: () => void;
-      jest.mocked(startDeviceSessionHostAsync).mockImplementationOnce(
-        async (_ctx, options) =>
-          await new Promise((_resolve, reject) => {
-            failHost = error => {
-              options.onStartupError?.(error);
-              finishHostCleanup = () => reject(error);
-            };
-          })
-      );
-      let failCommand!: (error: Error) => void;
-      let commandStarted!: () => void;
-      const commandEntered = new Promise<void>(resolve => {
-        commandStarted = resolve;
-      });
-      const child = { pid: 4242, kill: jest.fn() };
-      jest.mocked(spawn).mockImplementation((_command, args) => {
-        if (!args.includes(flag)) {
-          return Promise.resolve(undefined) as never;
-        }
-        const pending = new Promise((_resolve, reject) => {
-          failCommand = reject;
-        });
-        commandStarted();
-        return Object.assign(pending, { child }) as never;
-      });
-      const buildFunction = createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext);
-      const running = Promise.resolve(
-        buildFunction.fn!(
-          {
-            logger: { info: jest.fn(), warn: jest.fn() },
-            global: { runtimePlatform: BuildRuntimePlatform.DARWIN },
-          } as unknown as BuildStepContext,
-          {
-            inputs: {
-              package_version: { value: undefined },
-              max_idle_time_minutes: { value: undefined },
-              boot_simulator: { value: true },
-            },
-            outputs: {},
-            env: {},
-          } as never
-        )
-      );
-      let settled = false;
-      void running
-        .finally(() => {
-          settled = true;
-        })
-        .catch(() => {});
-      try {
-        await commandEntered;
-        failHost(hostError);
-        await new Promise(resolve => setImmediate(resolve));
-        expect(killProcessGroup).toHaveBeenCalledWith(child, 'SIGKILL');
-        expect(settled).toBe(false);
-        expect(spawnDetached).not.toHaveBeenCalled();
-        failCommand(commandError);
-        await new Promise(resolve => setImmediate(resolve));
-        expect(settled).toBe(false);
-        finishHostCleanup();
-        await expect(running).rejects.toBe(hostError);
-        expect(spawnDetached).not.toHaveBeenCalled();
-        expect(startNgrokTunnelAsync).not.toHaveBeenCalled();
-        expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-      } finally {
-        failCommand?.(commandError);
-        finishHostCleanup?.();
-        await running.catch(() => {});
-      }
-    }
-  );
-
-  it('interrupts tool-server state polling and retains the original host error', async () => {
-    await fs.promises.rm(path.join(ARGENT_STATE_DIR, 'tool-server-orchestration.json'));
-    const hostError = new Error('serve-sim startup failed');
-    let failHost!: (error: Error) => void;
-    jest.mocked(startDeviceSessionHostAsync).mockImplementationOnce(
-      async () =>
-        await new Promise((_resolve, reject) => {
-          failHost = reject;
-        })
-    );
-    let pollingStarted!: () => void;
-    const pollingEntered = new Promise<void>(resolve => {
-      pollingStarted = resolve;
-    });
-    const getExitError = jest.fn<Error | undefined, []>(() => {
-      pollingStarted();
-      return undefined;
-    });
-    const stopServer = jest.fn().mockResolvedValue(undefined);
-    jest.mocked(spawnDetached).mockReturnValueOnce({
-      pid: 4242,
-      getOutput: () => 'later controller diagnostic',
-      getExitError,
-      stopAsync: stopServer,
-    });
-    const buildFunction = createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext);
-    const running = Promise.resolve(
-      buildFunction.fn!(
-        {
-          logger: { info: jest.fn(), warn: jest.fn() },
-          global: { runtimePlatform: BuildRuntimePlatform.DARWIN },
-        } as unknown as BuildStepContext,
-        {
-          inputs: {
-            package_version: { value: undefined },
-            max_idle_time_minutes: { value: undefined },
-            boot_simulator: { value: true },
-          },
-          outputs: {},
-          env: {},
-        } as never
-      )
-    );
-    void running.catch(() => {});
-    try {
-      await pollingEntered;
-      failHost(hostError);
-      await new Promise(resolve => setImmediate(resolve));
-      const options = jest.mocked(startDeviceSessionHostAsync).mock.calls[0][1];
-      expect(options.signal?.aborted).toBe(true);
-      getExitError.mockReturnValue(new Error('later Argent exit'));
-      await expect(running).rejects.toBe(hostError);
-      expect(stopServer).toHaveBeenCalledTimes(1);
-      expect(startArgentEventCollectionAsync).not.toHaveBeenCalled();
-      expect(startNgrokTunnelAsync).not.toHaveBeenCalled();
-      expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-    } finally {
-      getExitError.mockReturnValue(new Error('stop pending state poll'));
-      await running.catch(() => {});
-    }
-  });
-
-  it('keeps Argent setup concurrent but waits for the iOS host before opening tools', async () => {
-    const host = await jest.mocked(startDeviceSessionHostAsync).getMockImplementation()!(
-      {} as CustomBuildContext,
-      {} as never
-    );
-    let releaseHost!: () => void;
-    jest.mocked(startDeviceSessionHostAsync).mockReturnValueOnce(
-      new Promise(resolve => {
-        releaseHost = () => resolve(host);
-      })
-    );
-    let stateReady!: () => void;
-    const stateRead = new Promise<void>(resolve => {
-      stateReady = resolve;
-    });
-    jest.mocked(isProcessDescendantOfAsync).mockImplementationOnce(async () => {
-      stateReady();
-      return true;
-    });
-    const buildFunction = createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext);
-    const running = Promise.resolve(
-      buildFunction.fn!(
-        {
-          logger: { info: jest.fn(), warn: jest.fn() },
-          global: { runtimePlatform: BuildRuntimePlatform.DARWIN },
-        } as unknown as BuildStepContext,
-        {
-          inputs: {
-            package_version: { value: undefined },
-            max_idle_time_minutes: { value: undefined },
-            boot_simulator: { value: true },
-          },
-          outputs: {},
-          env: {},
-        } as never
-      )
-    );
-    try {
-      await stateRead;
-      await new Promise(resolve => setImmediate(resolve));
-      expect(spawnDetached).toHaveBeenCalledTimes(1);
-      expect(startArgentEventCollectionAsync).not.toHaveBeenCalled();
-      expect(startNgrokTunnelAsync).not.toHaveBeenCalled();
-      expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
-    } finally {
-      releaseHost();
-      await running;
-    }
-    expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledTimes(1);
-    expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
-  });
-
-  it.each([BuildRuntimePlatform.DARWIN, BuildRuntimePlatform.LINUX])(
-    'keeps %s prepared setup commands outside the new cancellation path',
-    async runtimePlatform => {
-      const buildFunction = createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext);
-      await buildFunction.fn!(
-        {
-          logger: { info: jest.fn(), warn: jest.fn() },
-          global: { runtimePlatform },
-        } as unknown as BuildStepContext,
-        {
-          inputs: {
-            package_version: { value: undefined },
-            max_idle_time_minutes: { value: undefined },
-          },
-          outputs: {},
-          env: {},
-        } as never
-      );
-      expect(spawn).toHaveBeenCalledTimes(3);
-      for (const [, , options] of jest.mocked(spawn).mock.calls) {
-        expect(options).not.toHaveProperty('detached');
-        expect(options).not.toHaveProperty('signal');
-      }
-      expect(killProcessGroup).not.toHaveBeenCalled();
-    }
-  );
-
   it('fails before starting anything when a launch is asked for on Android', async () => {
     const ctx = {} as unknown as CustomBuildContext;
     const logger = { info: jest.fn(), warn: jest.fn() };

packages/build-tools/src/steps/functions/__tests__/startSandbox.test.ts

@@ -1,4 +1,4 @@
-import { SystemError, UserError } from '@expo/eas-build-job';
+import { SystemError } from '@expo/eas-build-job';
 import { Client, fetchExchange } from '@urql/core';
 
 import * as sandboxDaemon from '../../utils/sandboxDaemon';
@@ -6,90 +6,6 @@ import * as sandboxDaemon from '../../utils/sandboxDaemon';
 import { createStartSandboxBuildFunction, markSandboxReadyAsync } from '../startSandbox';
 
 describe('sandbox build functions', () => {
-  it.each([
-    { completion: 'duration', duration: 0.02 },
-    { completion: 'cancellation', duration: 60 },
-    { completion: 'duration', duration: 0.0001 },
-  ])(
-    'stops after $completion with $duration seconds only after readiness',
-    async ({ completion, duration }) => {
-      const controller = new AbortController();
-      let ready!: () => void;
-      const stopAsync = jest.fn(async () => {});
-      const start = jest.spyOn(sandboxDaemon, 'startSandboxDaemonAsync').mockResolvedValue({
-        ready: new Promise<void>(resolve => {
-          ready = resolve;
-        }),
-        stopAsync,
-      });
-      const mutation = jest.fn(() => ({ toPromise: async () => ({ data: {} }) }));
-      const logger = { info: jest.fn(), child: jest.fn() };
-      logger.child.mockReturnValue(logger);
-      const fn = createStartSandboxBuildFunction({
-        mcpServerUrl: 'ws://localhost:8787',
-        graphqlClient: { mutation },
-      } as any);
-      try {
-        const pending = fn.fn!({ logger } as any, {
-          inputs: {
-            sandbox_id: { value: 'sandbox-id' },
-            max_duration_seconds: { value: duration },
-          },
-          outputs: {},
-          env: { __EAS_SANDBOX_MCP_TOKEN: 'token' },
-          signal: controller.signal,
-        });
-        await new Promise(resolve => setTimeout(resolve, 40));
-        expect(mutation).not.toHaveBeenCalled();
-        expect(stopAsync).not.toHaveBeenCalled();
-        ready();
-        if (completion === 'cancellation') {
-          await new Promise(resolve => setImmediate(resolve));
-          expect(stopAsync).not.toHaveBeenCalled();
-          controller.abort();
-        }
-        await pending;
-        expect(mutation).toHaveBeenCalledTimes(1);
-        expect(stopAsync).toHaveBeenCalledTimes(1);
-        const timeoutMessage = `Sandbox reached its maximum runtime of ${duration} seconds. Stopping.`;
-        if (completion === 'duration') {
-          expect(logger.info).toHaveBeenCalledWith(timeoutMessage);
-        } else {
-          expect(logger.info).not.toHaveBeenCalledWith(timeoutMessage);
-        }
-      } finally {
-        start.mockRestore();
-      }
-    }
-  );
-
-  it.each([0, -1, Infinity, NaN])(
-    'rejects invalid maximum duration %s before starting the daemon',
-    async duration => {
-      const start = jest.spyOn(sandboxDaemon, 'startSandboxDaemonAsync');
-      const fn = createStartSandboxBuildFunction({
-        mcpServerUrl: 'ws://localhost:8787',
-      } as any);
-      try {
-        const result = fn.fn!({} as any, {
-          inputs: {
-            sandbox_id: { value: 'sandbox-id' },
-            max_duration_seconds: { value: duration },
-          },
-          outputs: {},
-          env: { __EAS_SANDBOX_MCP_TOKEN: 'token' },
-        });
-        await expect(result).rejects.toBeInstanceOf(UserError);
-        await expect(result).rejects.toThrow(
-          `Invalid sandbox maximum duration: ${duration}. Provide a finite number greater than zero, or omit max_duration_seconds.`
-        );
-        expect(start).not.toHaveBeenCalled();
-      } finally {
-        start.mockRestore();
-      }
-    }
-  );
-
   it('aborts an active ready request and keeps its authentication headers', async () => {
     const controller = new AbortController();
     let requestStarted!: () => void;

packages/build-tools/src/steps/functions/__tests__/startWebPreviewRemoteSession.test.ts

@@ -81,7 +81,6 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
         apiUrl: 'https://web-preview.example.test',
         closeAsync: jest.fn(),
       }),
-      getLastPreviewActivityAt: jest.fn(),
       finishAsync: stopAsync,
     });
     jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue(undefined);
@@ -98,7 +97,6 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
         previewToken: 'tok-1',
         closeAsync: jest.fn(),
       }),
-      getLastPreviewActivityAt: jest.fn(),
       finishAsync: stopAsync,
     });
 
@@ -126,7 +124,6 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
         apiUrl: 'https://web-preview.example.test',
         closeAsync: jest.fn(),
       }),
-      getLastPreviewActivityAt: jest.fn(),
       finishAsync: stopAsync,
     });
 
@@ -154,7 +151,6 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
         apiUrl: 'https://web-preview.example.test',
         closeAsync: jest.fn(),
       }),
-      getLastPreviewActivityAt: jest.fn(),
       finishAsync: stopAsync,
     });
     await runAsync(BuildRuntimePlatform.DARWIN, { public_preview: { value: false } });
@@ -172,7 +168,6 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
     if (phase === 'preview') {
       jest.mocked(startDeviceSessionHostAsync).mockResolvedValueOnce({
         openPreviewAsync: jest.fn().mockRejectedValue(error),
-        getLastPreviewActivityAt: jest.fn(),
         finishAsync: stopAsync,
       });
     } else if (phase === 'config') {
@@ -215,8 +210,6 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
         : {}),
       packageVersion: '1.2.3',
       disableShare: false,
-      frameAncestors: [],
-      corsOrigins: [],
       launchAppIdentifier: undefined,
       launchArgs: [],
       openUrl: undefined,
@@ -265,8 +258,6 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
       'network_capture_fields',
       'public_preview',
       'private_preview_url',
-      'frame_ancestors',
-      'cors_origins',
       'package_version',
       'max_duration_seconds',
     ]);
@@ -331,26 +322,6 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
     }
   );
 
-  it('hands frame_ancestors to the session host', async () => {
-    await runAsync(BuildRuntimePlatform.DARWIN, {
-      frame_ancestors: { value: ['https://embed.example.test'] },
-    });
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      ctx,
-      expect.objectContaining({ frameAncestors: ['https://embed.example.test'] })
-    );
-  });
-
-  it('hands cors_origins to the session host', async () => {
-    await runAsync(BuildRuntimePlatform.DARWIN, {
-      cors_origins: { value: ['https://app.example.test'] },
-    });
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      ctx,
-      expect.objectContaining({ corsOrigins: ['https://app.example.test'] })
-    );
-  });
-
   it('hands network capture to the session host', async () => {
     await runAsync(BuildRuntimePlatform.DARWIN, {
       network_capture: { value: true },

packages/build-tools/src/steps/functions/__tests__/submitToGooglePlay.test.ts

@@ -1,8 +1,10 @@
 import { SystemError, UserError } from '@expo/eas-build-job';
+import { createLogger } from '@expo/logger';
 import nock from 'nock';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import { Writable } from 'node:stream';
 
 import { createGlobalContextMock } from '../../../__tests__/utils/context';
 import {
@@ -15,6 +17,7 @@ import {
 import { createSubmitToGooglePlayBuildFunction } from '../submitToGooglePlay';
 
 jest.unmock('node-fetch');
+jest.unmock('@expo/logger');
 jest.mock('promise-retry', () => {
   const actual = jest.requireActual('promise-retry');
   return (fn: Parameters<typeof actual>[0], options: object) =>
@@ -145,11 +148,18 @@ it('runs the step with a string rollout and validates its required output', asyn
   await step.executeAsync();
   expect(step.outputs[0].value).toBe('145');
 });
-it.each(['upload', 'track', 'abort'] as const)(
+it.each([
+  ['upload', 'Could not upload the AAB. '],
+  ['track', 'Could not update track "internal". '],
+  ['commit', 'Could not commit the Google Play edit. '],
+  ['abort', undefined],
+] as const)(
   'deletes the edit after %s failure and leaves outputs unset',
-  async failure => {
+  async (failure, phase) => {
     const controller = new AbortController();
+    const abortReason = new Error('step timed out');
     const task = submission({}, controller.signal);
+    const rejected = { error: { message: 'rejected' } };
     mockToken();
     api().post(createPath).reply(200, { id: 'edit' });
     api()
@@ -157,20 +167,30 @@ it.each(['upload', 'track', 'abort'] as const)(
       .query({ uploadType: 'resumable' })
       .reply(() => {
         if (failure === 'abort') {
-          controller.abort(new Error('step timed out'));
+          controller.abort(abortReason);
         }
         return failure === 'upload'
-          ? [400, { error: { message: 'rejected binary' } }]
+          ? [400, rejected]
           : [200, '', { Location: `https://androidpublisher.googleapis.com${session}` }];
       });
     if (failure === 'track') {
       nock('https://androidpublisher.googleapis.com').put(session).reply(200, { versionCode: 145 });
-      api()
-        .put(`${editPath}/tracks/internal`)
-        .reply(400, { error: { message: 'unknown track' } });
+      api().put(`${editPath}/tracks/internal`).reply(400, rejected);
+    }
+    if (failure === 'commit') {
+      nock('https://androidpublisher.googleapis.com').put(session).reply(200, { versionCode: 145 });
+      api().put(`${editPath}/tracks/internal`).reply(200, { track: 'internal' });
+      api().post(`${editPath}:commit`).query({}).reply(400, rejected);
     }
     api().delete(editPath).reply(204);
-    await expect(task.run()).rejects.toThrow();
+    if (phase) {
+      await expect(task.run()).rejects.toMatchObject({
+        errorCode: 'EAS_GOOGLE_PLAY_INVALID_RELEASE',
+        message: expect.stringContaining(phase),
+      });
+    } else {
+      await expect(task.run()).rejects.toBe(abortReason);
+    }
     expect(task.setters.every(set => set.mock.calls.length === 0)).toBe(true);
   }
 );
@@ -184,11 +204,62 @@ it('preserves the original failure when cleanup fails', async () => {
     cause: expect.objectContaining({ apiMessage: 'unknown track' }),
   });
 });
+
+it('logs structured response diagnostics at warning level and includes them in Sentry metadata only', async () => {
+  upload();
+  const task = submission();
+  const records: Record<string, unknown>[] = [];
+  const logger = createLogger({
+    name: 'submission-test',
+    streams: [
+      {
+        level: 'info',
+        stream: new Writable({
+          write(chunk, _encoding, callback) {
+            records.push(JSON.parse(chunk.toString()));
+            callback();
+          },
+        }),
+      },
+    ],
+  });
+  jest.spyOn(task.step.ctx.logger, 'warn').mockImplementation(logger.warn.bind(logger));
+  api()
+    .put(`${editPath}/tracks/internal`)
+    .reply(400, {
+      error: {
+        message: 'Rejected',
+        status: 'FAILED_PRECONDITION',
+        details: [{ '@type': 'unknown', diagnostic: 'DIAGNOSTIC_ONLY', access_token: 'SECRET' }],
+      },
+    });
+  api().delete(editPath).reply(204);
+  const error = await task.run().catch(error => error);
+  expect(error).toBeInstanceOf(UserError);
+  if (!(error instanceof UserError)) {
+    throw error;
+  }
+  expect(records).toEqual([
+    expect.objectContaining({
+      level: 40,
+      msg: 'Google Play submission failed.',
+      googlePlayHttpStatus: 400,
+      googlePlayErrorResponse: expect.any(Object),
+    }),
+  ]);
+  expect(records[0].googlePlayErrorResponse).toEqual(error.metadata?.googlePlayErrorResponse);
+  expect(JSON.stringify(error.metadata)).toContain('DIAGNOSTIC_ONLY');
+  expect(JSON.stringify(error.metadata)).not.toContain('SECRET');
+  expect(JSON.stringify(error.toExternalExpoError())).not.toContain('DIAGNOSTIC_ONLY');
+});
 it('does not delete the edit or publish outputs when commit outcome is unknown', async () => {
   upload();
   api().put(`${editPath}/tracks/internal`).reply(200, { track: 'internal' });
   api().post(`${editPath}:commit`).query(true).reply(503);
-  api().post(`${editPath}:commit`).query(true).reply(404);
+  api()
+    .post(`${editPath}:commit`)
+    .query(true)
+    .reply(404, { error: { message: 'Edit missing', status: 'NOT_FOUND' } });
   let deleted = false;
   api()
     .delete(editPath)
@@ -198,7 +269,14 @@ it('does not delete the edit or publish outputs when commit outcome is unknown',
       return [204];
     });
   const task = submission();
-  await expect(task.run()).rejects.toBeInstanceOf(SystemError);
+  const error = await task.run().catch(error => error);
+  expect(error).toBeInstanceOf(SystemError);
+  expect(error).toMatchObject({
+    metadata: {
+      googlePlayHttpStatus: 404,
+      googlePlayErrorResponse: { error: { message: 'Edit missing', status: 'NOT_FOUND' } },
+    },
+  });
   expect(deleted).toBe(false);
   expect(task.setters.every(set => set.mock.calls.length === 0)).toBe(true);
 });

packages/build-tools/src/steps/functions/__tests__/uploadArtifact.test.ts

@@ -121,32 +121,26 @@ describe(createUploadArtifactBuildFunction, () => {
     expect(typeInput.isRawValueOneOfAllowedValues()).toBe(false);
   });
 
-  it.each(['other', 'android-apk', 'android-aab', 'ios-simulator-app', 'ios-ipa'])(
-    'uploads %s as a workflow artifact with metadata',
-    async type => {
-      contextUploadArtifact.mockClear();
-      const metadata = { kind: 'screen-recording', startedAtMs: '123', device: 'emulator-5554' };
-      const buildStep = uploadArtifact.createBuildStepFromFunctionCall(
-        createGlobalContextMock({}),
-        {
-          callInputs: {
-            type,
-            key: 'Screen Recording',
-            path: '/',
-            metadata,
-          },
-        }
-      );
+  it('passes the metadata input through to runtimeApi.uploadArtifact', async () => {
+    contextUploadArtifact.mockClear();
+    const metadata = { kind: 'screen-recording', startedAtMs: '123', device: 'emulator-5554' };
+    const buildStep = uploadArtifact.createBuildStepFromFunctionCall(createGlobalContextMock({}), {
+      callInputs: {
+        // Generic ('other') artifact: only generic artifacts persist metadata in the worker
+        // (the managed-type upload paths drop it), so that's the type metadata is meant for.
+        type: 'other',
+        key: 'Screen Recording',
+        path: '/',
+        metadata,
+      },
+    });
 
-      await buildStep.executeAsync();
+    await buildStep.executeAsync();
 
-      expect(contextUploadArtifact).toHaveBeenCalledWith(
-        expect.objectContaining({
-          artifact: expect.objectContaining({ type: null, metadata }),
-        })
-      );
-    }
-  );
+    expect(contextUploadArtifact).toHaveBeenCalledWith(
+      expect.objectContaining({ artifact: expect.objectContaining({ metadata }) })
+    );
+  });
 
   it('does not attach metadata to managed artifact types (the worker drops it)', async () => {
     contextUploadArtifact.mockClear();

packages/build-tools/src/steps/functions/__tests__/uploadDeviceRunSessionScreenRecordings.test.ts

@@ -140,12 +140,9 @@ describe(createUploadDeviceRunSessionScreenRecordingsBuildFunction, () => {
 
       await buildStep.executeAsync();
 
-      const uploads = jest
+      const names = jest
         .mocked(uploadDeviceRunSessionArtifactAsync)
-        .mock.calls.map(([, options]) => options);
-      const names = uploads
-        .filter(options => options.kind === 'screen-recording')
-        .map(options => options.name);
+        .mock.calls.map(([, options]) => options.name);
       expect(names).toEqual(
         expect.arrayContaining([
           'iPhone 16 screen recording (01234567-…, started at Jul 10, 2026, 10:00:00.000 UTC)',
@@ -154,12 +151,6 @@ describe(createUploadDeviceRunSessionScreenRecordingsBuildFunction, () => {
         ])
       );
       expect(new Set(names).size).toBe(3);
-      const metadata = uploads.filter(options => options.kind === 'screen-recording-metadata');
-      expect(metadata.map(options => options.name)).toEqual(
-        expect.arrayContaining(names.map(name => `${name} metadata`))
-      );
-      expect(metadata).toHaveLength(3);
-      expect(uploads).toHaveLength(6);
     } finally {
       await Promise.all(
         recordingDirectories.map(directory => fs.rm(directory, { recursive: true, force: true }))

packages/build-tools/src/steps/functions/checkout.ts

@@ -58,11 +58,7 @@ export function createCheckoutBuildFunction(): BuildFunction {
         });
       }
 
-      const previousWorkingDirectory = stepsCtx.global.defaultWorkingDirectory;
-      stepsCtx.global.markAsCheckedOut();
-      stepsCtx.logger.info(
-        `Changing default working directory to ${stepsCtx.global.defaultWorkingDirectory} (was ${previousWorkingDirectory})`
-      );
+      stepsCtx.global.markAsCheckedOut(stepsCtx.logger);
     },
   });
 }

packages/build-tools/src/steps/functions/downloadBuild.ts

@@ -7,7 +7,7 @@ import {
   BuildStepInputValueTypeName,
   BuildStepOutput,
 } from '@expo/steps';
-import { Client, CombinedError } from '@urql/core';
+import { Client } from '@urql/core';
 import contentDisposition from 'content-disposition';
 import { glob } from 'fast-glob';
 import { graphql } from 'gql.tada';
@@ -26,16 +26,10 @@ import { CustomBuildContext } from '../../customBuildContext';
 import { formatBytes } from '../../utils/artifacts';
 import { decompressTarAsync, isFileTarGzAsync } from '../../utils/files';
 import { graphqlAbortContext } from '../../utils/graphqlAbort';
-import {
-  describeError,
-  isTransferFailure,
-  isTransientGraphqlError,
-} from '../../utils/networkErrors';
-import { retryOnNetworkFailureAsync } from '../../utils/retryOnNetworkFailure';
+import { retryOnDNSFailure } from '../../utils/retryOnDNSFailure';
 import { pluralize } from '../../utils/strings';
 import {
   type DeviceRunSessionWorkerApi,
-  DeviceRunSessionWorkerApiError,
   getDeviceRunSessionWorkerApi,
 } from '../utils/deviceRunSessionWorkerApi';
 
@@ -158,34 +152,21 @@ async function fetchApplicationArchiveUrlAsync({
       signal,
     });
   }
-  let data;
-  try {
-    data = await retryOnNetworkFailureAsync(
-      async () => {
-        const queryResult = await graphqlClient
-          .query(BUILD_BY_ID_QUERY, { buildId }, graphqlAbortContext(signal))
-          .toPromise();
-        if (queryResult.error) {
-          throw queryResult.error;
-        }
-        return queryResult.data;
-      },
-      {
-        operation: 'download_build.build_lookup',
-        signal,
-        isRetryable: error => error instanceof CombinedError && isTransientGraphqlError(error),
-      }
-    );
-  } catch (error) {
-    signal?.throwIfAborted();
-    const message = `Could not fetch build ${buildId}: ${describeError(error)}`;
-    throw error instanceof CombinedError && !isTransientGraphqlError(error)
-      ? new UserError('EAS_DOWNLOAD_BUILD_FETCH_FAILED', message, { cause: error })
-      : new SystemError(message, { cause: error });
-  }
+  const result = await graphqlClient
+    .query(BUILD_BY_ID_QUERY, { buildId }, graphqlAbortContext(signal))
+    .toPromise();
   signal?.throwIfAborted();
 
-  const applicationArchiveUrl = data?.builds.byId?.artifacts?.applicationArchiveUrl;
+  if (result.error) {
+    const { error } = result;
+    const message = `Could not fetch build ${buildId}: ${error.message}`;
+
+    throw error.networkError || result.error.response?.status >= 500
+      ? new SystemError(message, { cause: error })
+      : new UserError('EAS_DOWNLOAD_BUILD_FETCH_FAILED', message, { cause: error });
+  }
+
+  const applicationArchiveUrl = result.data?.builds.byId?.artifacts?.applicationArchiveUrl;
   if (!applicationArchiveUrl) {
     throw new UserError(
       'EAS_DOWNLOAD_BUILD_NO_APPLICATION_ARCHIVE',
@@ -214,18 +195,13 @@ async function fetchDeviceRunSessionApplicationArchiveUrlAsync({
 }): Promise<string> {
   let application;
   try {
-    application = await retryOnNetworkFailureAsync(
-      () => deviceRunSessionWorkerApi.getApplicationAsync({ signal }),
-      {
-        operation: 'download_build.session_build_lookup',
-        signal,
-        isRetryable: error => error instanceof DeviceRunSessionWorkerApiError && error.isTransient,
-      }
-    );
+    application = await deviceRunSessionWorkerApi.getApplicationAsync({ signal });
   } catch (err) {
     signal?.throwIfAborted();
     throw new SystemError(
-      `Could not fetch build ${buildId} for this device run session: ${describeError(err)}`,
+      `Could not fetch build ${buildId} for this device run session: ${
+        err instanceof Error ? err.message : String(err)
+      }`,
       { cause: err }
     );
   }
@@ -305,34 +281,18 @@ export async function downloadBuildAsync(
   );
 
   signal?.throwIfAborted();
-  let archivePath: string;
-  try {
-    archivePath = await retryOnNetworkFailureAsync(
-      async () => {
-        const response = await fetch(downloadUrl, { headers, signal });
-        if (!response.ok) {
-          const textResult = await asyncResult(response.text());
-          throw new Error(
-            `Unexpected response from server (${response.status}): ${textResult.value}`
-          );
-        }
-        const archiveFilename = resolveArchiveFilename({ response, extensions });
-        const attemptArchivePath = path.join(downloadDestinationDirectory, archiveFilename);
-        // On abort, node-fetch emits an error on the body stream, which fails the pipeline.
-        await streamPipeline(response.body, fs.createWriteStream(attemptArchivePath));
-        return attemptArchivePath;
-      },
-      { operation: 'download_build.archive_download', signal, isRetryable: isTransferFailure }
-    );
-  } catch (error) {
-    signal?.throwIfAborted();
-    if (params.buildId && isTransferFailure(error)) {
-      throw new SystemError(`Could not download the application archive: ${describeError(error)}`, {
-        cause: error,
-      });
-    }
-    throw error;
+  const response = await retryOnDNSFailure(fetch)(downloadUrl, { headers, signal });
+
+  if (!response.ok) {
+    const textResult = await asyncResult(response.text());
+    throw new Error(`Unexpected response from server (${response.status}): ${textResult.value}`);
   }
+
+  const archiveFilename = resolveArchiveFilename({ response, extensions });
+  const archivePath = path.join(downloadDestinationDirectory, archiveFilename);
+
+  // On abort, node-fetch emits an error on the body stream, which fails the pipeline.
+  await streamPipeline(response.body, fs.createWriteStream(archivePath));
   signal?.throwIfAborted();
 
   const { size } = await fs.promises.stat(archivePath);

packages/build-tools/src/steps/functions/launchApplication.ts

@@ -1,4 +1,4 @@
-import { UserError, quoteAndroidShellCommand } from '@expo/eas-build-job';
+import { UserError } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
 import {
   BuildFunction,
@@ -106,40 +106,24 @@ export async function launchApplicationAsync({
   logApplicationLaunch(logger, applicationIdentifier, launchArgs);
   // Android does not support process arguments like iOS. Pass raw `am start` Intent
   // arguments instead, such as `--es key value` or `--ez key true`.
-  try {
-    await spawnAndroidShellCommandAsync(
-      ['am', 'start', ...launchArgs, '-n', `${applicationIdentifier}/${activityName}`],
-      { env, logger }
-    );
-  } catch (err) {
-    // An empty argument that is not an option value reaches `am start` as an empty package, and
-    // `am start` then fails to resolve the Intent without saying why.
-    const emptyArgumentIndex = launchArgs.indexOf('');
-    if (emptyArgumentIndex === -1 || err instanceof UserError) {
-      throw err;
+  await spawn(
+    'adb',
+    ['shell', 'am', 'start', ...launchArgs, '-n', `${applicationIdentifier}/${activityName}`],
+    {
+      env,
+      logger,
     }
-    throw new UserError(
-      'EAS_LAUNCH_APPLICATION_FAILED',
-      `Launching ${applicationIdentifier} failed. Input "launch_args" has an empty argument at position ${emptyArgumentIndex + 1}, which Android passes to "am start" as an empty argument. Remove it unless it is an option value, such as "--es", "key", "".`,
-      { cause: err }
-    );
-  }
+  );
   if (openUrl) {
     logger.info(`Opening ${openUrl} in ${applicationIdentifier}.`);
-    await spawnAndroidShellCommandAsync(
-      ['am', 'start', '-a', 'android.intent.action.VIEW', '-d', openUrl],
+    await spawn(
+      'adb',
+      ['shell', 'am', 'start', '-a', 'android.intent.action.VIEW', '-d', openUrl],
       { env, logger }
     );
   }
 }
 
-async function spawnAndroidShellCommandAsync(
-  command: string[],
-  { env, logger }: { env: BuildStepEnv; logger: bunyan }
-): Promise<void> {
-  await spawn('adb', ['shell', ...quoteAndroidShellCommand(command)], { env, logger });
-}
-
 async function preapproveIosUrlSchemeAsync({
   applicationIdentifier,
   openUrl,

packages/build-tools/src/steps/functions/maestroTests.ts

@@ -1,4 +1,4 @@
-import { SystemError, UserError } from '@expo/eas-build-job';
+import { GenericArtifactType, SystemError, UserError } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
 import {
   BuildFunction,
@@ -631,7 +631,7 @@ export function createMaestroTestsBuildFunction(ctx: CustomBuildContext): BuildF
         try {
           await ctx.runtimeApi.uploadArtifact({
             artifact: {
-              type: null,
+              type: GenericArtifactType.OTHER,
               name: selectedReport.name,
               paths: [selectedReport.artifactPath],
             },
@@ -738,7 +738,7 @@ async function uploadFailureScreenshotsAsync({
         await fs.copyFile(shot.fileAbsPath, safePath);
         await ctx.runtimeApi.uploadArtifact({
           artifact: {
-            type: null,
+            type: GenericArtifactType.OTHER,
             name: shot.displayName,
             paths: [safePath],
             metadata: shot.metadata,

packages/build-tools/src/steps/functions/saveCache.ts

@@ -11,7 +11,6 @@ import path from 'path';
 import * as tar from 'tar';
 import z from 'zod';
 
-import { uploadWithSignedUrl } from '../../storage/uploadWithSignedUrl';
 import { formatBytes } from '../../utils/artifacts';
 import { retryOnDNSFailure } from '../../utils/retryOnDNSFailure';
 import { getCacheVersion } from '../utils/cache';
@@ -162,13 +161,16 @@ export async function uploadCacheAsync({
 
   logger.info(`Uploading cache...`);
 
-  await uploadWithSignedUrl(
-    {
-      signedUrl: { url, headers },
-      srcGeneratorAsync: async () => fs.createReadStream(archivePath),
-    },
-    { retries: 3, retryIntervalMs: 100 }
-  );
+  const uploadResponse = await retryOnDNSFailure(fetch)(new URL(url), {
+    method: 'PUT',
+    headers,
+    body: fs.createReadStream(archivePath),
+  });
+  if (!uploadResponse.ok) {
+    throw new Error(
+      `Unexpected response from cache server (${uploadResponse.status}): ${uploadResponse.statusText}`
+    );
+  }
   logger.info(`Uploaded cache archive to ${archivePath} (${formatBytes(size)}).`);
 }
 
@@ -224,13 +226,16 @@ export async function uploadPublicCacheAsync({
 
   logger.info(`Uploading public cache...`);
 
-  await uploadWithSignedUrl(
-    {
-      signedUrl: { url, headers },
-      srcGeneratorAsync: async () => fs.createReadStream(archivePath),
-    },
-    { retries: 3, retryIntervalMs: 100 }
-  );
+  const uploadResponse = await retryOnDNSFailure(fetch)(new URL(url), {
+    method: 'PUT',
+    headers,
+    body: fs.createReadStream(archivePath),
+  });
+  if (!uploadResponse.ok) {
+    throw new Error(
+      `Unexpected response from cache server (${uploadResponse.status}): ${uploadResponse.statusText}`
+    );
+  }
   logger.info(`Uploaded cache archive to ${archivePath} (${formatBytes(size)}).`);
 }
 

packages/build-tools/src/steps/functions/startAgentDeviceRemoteSession.ts

@@ -1,6 +1,6 @@
 import { SystemError } from '@expo/eas-build-job';
 import { type bunyan } from '@expo/logger';
-import { BuildRuntimePlatform, type BuildStepEnv } from '@expo/steps';
+import { type BuildRuntimePlatform, type BuildStepEnv } from '@expo/steps';
 import spawn from '@expo/turtle-spawn';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -19,7 +19,6 @@ import {
 import { pollAgentDeviceArtifactsForUploadAsync } from '../utils/agentDeviceArtifacts';
 import { type parseNetworkCaptureInputs } from '../utils/networkCaptureFields';
 import { startAgentDeviceEventCollectionAsync } from '../utils/agentDeviceEvents';
-import { type ServeSimApplicationOptions } from '../utils/remoteDeviceRunSession';
 import { type StartupTasks } from '../utils/startupTasks';
 import {
   type DetachedProcessHandle,
@@ -77,9 +76,13 @@ export function getAgentDeviceRemoteSessionEnvOrThrow(
  * Starts the agent-device daemon, its tunnel, the session host and the web preview,
  * reports the session as ready, and keeps it alive until it stops.
  *
- * Serve-sim boots while the iOS download runs. After device preparation verifies
- * any egress guard, its control API installs and launches the app.
- * Startup failures abort the other tasks; teardown drains them before stopping acquired resources.
+ * The daemon does not need the device, so it starts at once. The session host starts
+ * when `device.booted` resolves. The session is reported as ready only when both are
+ * up and `device.ready` (the app is installed and launched) resolved too.
+ *
+ * The first failure aborts `tasks.signal`: each part stops before its next stage, and
+ * the teardown then stops whatever was started. `device.ready` must settle soon after
+ * an abort, because the teardown waits for it.
  */
 export async function runAgentDeviceRemoteSessionAsync(
   ctx: CustomBuildContext,
@@ -95,8 +98,6 @@ export async function runAgentDeviceRemoteSessionAsync(
     capture,
     disableShare = false,
     privatePreviewUrl,
-    frameAncestors,
-    corsOrigins,
     tasks,
     device,
   }: {
@@ -111,24 +112,10 @@ export async function runAgentDeviceRemoteSessionAsync(
     capture: ReturnType<typeof parseNetworkCaptureInputs>;
     disableShare?: boolean;
     privatePreviewUrl?: string;
-    frameAncestors?: string[];
-    corsOrigins?: string[];
     tasks: StartupTasks;
-    device:
-      | {
-          booted: Promise<unknown>;
-          ready: Promise<unknown>;
-        }
-      | {
-          iosSimulatorUdid: string;
-          bootEnv?: Record<string, string>;
-          application?: Promise<ServeSimApplicationOptions | void>;
-        };
+    device: { booted: Promise<unknown>; ready: Promise<unknown> };
   }
 ): Promise<void> {
-  signal?.throwIfAborted();
-  tasks.signal.throwIfAborted();
-
   logger.info(
     `Starting agent-device remote session (version: ${packageVersion ?? 'latest'}, runtime: ${runtimePlatform}).`
   );
@@ -139,8 +126,6 @@ export async function runAgentDeviceRemoteSessionAsync(
   let eventCollection: Awaited<ReturnType<typeof startAgentDeviceEventCollectionAsync>> | undefined;
   let sessionFailed = false;
   const daemonSecrets = [ngrokAuthtoken];
-  const hostBootedDevice = 'iosSimulatorUdid' in device ? device : undefined;
-  const externallyBootedDevice = 'booted' in device ? device : undefined;
 
   // Each task stores what it started, so the teardown below can stop it even when
   // another task failed first.
@@ -169,14 +154,12 @@ export async function runAgentDeviceRemoteSessionAsync(
       authtoken: ngrokAuthtoken,
       logger: taskLogger,
     });
-    tasks.signal.throwIfAborted();
     taskLogger.info(`Tunnel is ready at ${agentDeviceTunnel.url}.`);
     return { ...daemonInfo, remoteSessionUrl: agentDeviceTunnel.url };
   });
   const sessionHostStartup = tasks.run('session host', async taskLogger => {
-    if (externallyBootedDevice) {
-      await tasks.untilAborted(externallyBootedDevice.booted);
-    }
+    // A boot cannot be cancelled, so stop waiting for it when startup is aborted.
+    await tasks.untilAborted(device.booted);
     tasks.signal.throwIfAborted();
     sessionHost = await startDeviceSessionHostAsync(ctx, {
       separateLogPhase: true,
@@ -186,22 +169,14 @@ export async function runAgentDeviceRemoteSessionAsync(
       timeoutMs: STARTUP_TIMEOUT_MS,
       disableShare,
       privatePreviewUrl,
-      frameAncestors,
-      corsOrigins,
-      signal: tasks.signal,
-      onStartupError: tasks.abort,
       networkCapture: capture.networkCapture,
       networkCaptureFields: capture.networkCaptureFields,
-      iosSimulatorUdid: hostBootedDevice?.iosSimulatorUdid,
-      bootEnv: hostBootedDevice?.bootEnv,
-      application: hostBootedDevice?.application,
     });
     tasks.signal.throwIfAborted();
     const webPreview = await sessionHost.openPreviewAsync({
       baseDomain: ngrokTunnelDomain,
       authtoken: ngrokAuthtoken,
     });
-    tasks.signal.throwIfAborted();
     taskLogger.info(
       webPreview.sharePageUrl
         ? `Web preview URL: ${webPreview.sharePageUrl} (server: ${webPreview.apiUrl}).`
@@ -209,20 +184,18 @@ export async function runAgentDeviceRemoteSessionAsync(
     );
     return webPreview;
   });
-  const deviceReady = externallyBootedDevice?.ready;
 
   try {
     const [
       { port: daemonPort, token: daemonToken, remoteSessionUrl: agentDeviceRemoteSessionUrl },
       webPreview,
-    ] = await Promise.all([agentDeviceStartup, sessionHostStartup, deviceReady]).catch(
+    ] = await Promise.all([agentDeviceStartup, sessionHostStartup, device.ready]).catch(
       (err: unknown) => {
         // Also aborts for a `device.ready` that does not come from `tasks.run`.
         tasks.abort(err);
-        throw tasks.signal.reason;
+        throw err;
       }
     );
-    tasks.signal.throwIfAborted();
     logger.info(tasks.summary());
 
     await uploadRemoteSessionConfigWithLocalEgressAsync({
@@ -239,7 +212,6 @@ export async function runAgentDeviceRemoteSessionAsync(
       },
       logger,
     });
-    tasks.signal.throwIfAborted();
     void pollAgentDeviceArtifactsForUploadAsync(ctx, {
       deviceRunSessionId,
       daemonUrl: `http://127.0.0.1:${daemonPort}`,
@@ -265,7 +237,6 @@ export async function runAgentDeviceRemoteSessionAsync(
           ? {
               maxIdleTimeMinutes,
               getLastEventObservedAt: eventCollection.getLastEventObservedAt,
-              getLastPreviewActivityAt: () => sessionHost?.getLastPreviewActivityAt(),
             }
           : undefined,
     });
@@ -276,7 +247,7 @@ export async function runAgentDeviceRemoteSessionAsync(
     // Promise.all rejects on the first failure while other tasks can still be starting.
     // They stop at their next abort check. Wait for all of them, so the teardown sees
     // everything that was started.
-    await Promise.allSettled([agentDeviceStartup, sessionHostStartup, deviceReady]);
+    await Promise.allSettled([agentDeviceStartup, sessionHostStartup, device.ready]);
     const startedDaemon = daemonProcess;
     await finishRemoteSessionAsync({
       logger,
@@ -320,7 +291,6 @@ export async function startAgentDeviceDaemonAsync({
   signal?: AbortSignal;
   secrets?: string[];
 }): Promise<DetachedProcessHandle> {
-  signal?.throwIfAborted();
   const packageSpec = createAgentDevicePackageSpec(packageVersion);
   const packageManager = resolveConfiguredPackageManager(env, PackageManager.BUN);
   const installDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'eas-agent-device-'));
@@ -330,7 +300,6 @@ export async function startAgentDeviceDaemonAsync({
   );
 
   try {
-    signal?.throwIfAborted();
     const add = resolvePackageAdd(packageManager, packageSpec);
     logger.info(`Installing ${packageSpec} with ${add.command}.`);
     await spawn(add.command, add.args, { cwd: installDir, env, logger, signal });

packages/build-tools/src/steps/functions/startAgentDeviceSession.ts

@@ -1,4 +1,4 @@
-import { UserError, validateAndroidLaunchOptions } from '@expo/eas-build-job';
+import { UserError } from '@expo/eas-build-job';
 import {
   BuildFunction,
   BuildRuntimePlatform,
@@ -15,16 +15,13 @@ import {
   AndroidEmulatorUtils,
   AndroidVirtualDeviceName,
 } from '../../utils/AndroidEmulatorUtils';
+import { IosSimulatorName, IosSimulatorUuid } from '../../utils/IosSimulatorUtils';
 import { getDeviceRunSessionWorkerApi } from '../utils/deviceRunSessionWorkerApi';
 import { withLocalEgressSession } from '../utils/localEgressSession';
 import {
-  createCorsOriginsInputProvider,
-  createFrameAncestorsInputProvider,
   createPrivatePreviewUrlInputProvider,
   createPublicPreviewInputProvider,
   omitNgrokAuthtoken,
-  parseCorsOriginsInput,
-  parseFrameAncestorsInput,
   selectXcodeDeveloperDirectoryAsync,
 } from '../utils/remoteDeviceRunSession';
 import {
@@ -32,10 +29,6 @@ import {
   parseNetworkCaptureInputs,
 } from '../utils/networkCaptureFields';
 import { createStartupTasks } from '../utils/startupTasks';
-import {
-  type ServeSimApplicationOptions,
-  validateServeSimLaunchOptions,
-} from '../utils/remoteDeviceRunSession';
 
 import { downloadBuildAsync } from './downloadBuild';
 import { installBuildAsync } from './installBuild';
@@ -49,15 +42,26 @@ import {
   runAgentDeviceRemoteSessionAsync,
 } from './startAgentDeviceRemoteSession';
 import { startAndroidEmulatorAsync } from './startAndroidEmulator';
-import { resolveIosSessionStartupAsync } from '../utils/iosSimulatorSession';
-import { readIosApplicationIdentifierAsync } from '../utils/iosAppArtifact';
+import { bootIosSimulatorAsync } from './startIosSimulator';
 
 const ANDROID_DEVICE_NAME = 'EasAndroidDevice01' as AndroidVirtualDeviceName;
 
 /**
- * Starts a device session, downloading the app alongside daemon startup.
- * On iOS, serve-sim boots the selected Simulator, then installs and launches
- * the downloaded app. Build-tools verifies any egress guard before install and launch.
+ * One step for a whole agent-device session: boot the device, download, install and
+ * launch the app, and start the agent-device daemon and the web preview.
+ *
+ * It does the work of eas/start_ios_simulator or eas/start_android_emulator,
+ * eas/download_build, eas/install_build and eas/launch_application, plus the agent-device
+ * session, so the parts that do not depend on each other can run at the same time:
+ *
+ *   boot ─────────────┬─► install ─► launch ─┐
+ *   download ─────────┘                      │
+ *   boot ─► session host ─► web preview ─────┼─► ready
+ *   agent-device daemon ─► tunnel ───────────┘
+ *
+ * The first failure aborts the rest: the download stops, and nothing installs, launches
+ * or starts after it. A boot cannot be cancelled, so it can still run when a failed
+ * step returns.
  */
 export function createStartAgentDeviceSessionBuildFunction(ctx: CustomBuildContext): BuildFunction {
   return new BuildFunction({
@@ -118,8 +122,6 @@ export function createStartAgentDeviceSessionBuildFunction(ctx: CustomBuildConte
       ...createNetworkCaptureInputProviders(),
       createPublicPreviewInputProvider(),
       createPrivatePreviewUrlInputProvider(),
-      createFrameAncestorsInputProvider(),
-      createCorsOriginsInputProvider(),
       BuildStepInput.createProvider({
         id: 'package_version',
         required: false,
@@ -162,11 +164,6 @@ export function createStartAgentDeviceSessionBuildFunction(ctx: CustomBuildConte
           'launch_args and open_url need an application: pass build_id or application_archive_url.'
         );
       }
-      if (isIos) {
-        validateServeSimLaunchOptions({ launchArgs, openUrl });
-      } else {
-        validateAndroidLaunchOptions({ launchArgs, openUrl });
-      }
       const deviceIdentifier = inputs.device_identifier.value as string | undefined;
       const capture = parseNetworkCaptureInputs(
         {
@@ -176,137 +173,107 @@ export function createStartAgentDeviceSessionBuildFunction(ctx: CustomBuildConte
         { runtimePlatform }
       );
 
-      const tasks = createStartupTasks(logger, signal);
-      let downloaded: Promise<string> | undefined;
-      let applicationReady: Promise<ServeSimApplicationOptions | void> | undefined;
-
-      try {
-        if (isIos) {
-          // Select Xcode before serve-sim boots the device or any Simulator tools run.
-          await selectXcodeDeveloperDirectoryAsync({ env, logger });
-        }
-        tasks.signal.throwIfAborted();
-        const { iosStartup } = isIos
-          ? await resolveIosSessionStartupAsync({
-              runtimePlatform,
-              bootSimulator: true,
-              deviceIdentifier,
-              env,
-              logger,
-              signal: tasks.signal,
-            })
-          : {};
-        const iosSimulatorUdid = iosStartup?.iosSimulatorUdid;
-        if (iosSimulatorUdid) {
-          logger.info(`Selected iOS Simulator: ${iosSimulatorUdid}.`);
-        }
-
-        const booted = iosSimulatorUdid
-          ? undefined
-          : tasks.run('Android Emulator boot', async taskLogger => {
-              const logcatDirectory = await fs.promises.mkdtemp(
-                path.join(os.tmpdir(), 'eas-android-emulator-logcat-')
-              );
-              tasks.signal.throwIfAborted();
-              await startAndroidEmulatorAsync({
-                deviceName: ANDROID_DEVICE_NAME,
-                systemImagePackage: `${inputs.system_image_package.value}`,
-                deviceIdentifier: deviceIdentifier as AndroidDeviceName | undefined,
-                lcdWidth: inputs.lcd_width.value as number | undefined,
-                lcdHeight: inputs.lcd_height.value as number | undefined,
-                lcdDensity: inputs.lcd_density.value as number | undefined,
-                logcatDirectory,
-                env,
-                logger: taskLogger,
-              });
-            });
-
-        downloaded = hasApplication
-          ? tasks.run('build download', async taskLogger => {
-              const { artifactPath } = await downloadBuildAsync({
-                logger: taskLogger,
-                ...(buildId ? { buildId } : { applicationArchiveUrl: applicationArchiveUrl! }),
-                graphqlClient: ctx.graphqlClient,
-                deviceRunSessionWorkerApi: buildId ? getDeviceRunSessionWorkerApi(ctx) : null,
-                robotAccessToken: global.staticContext.job.secrets?.robotAccessToken ?? null,
-                extensions: isIos ? ['app'] : ['apk'],
-                signal: tasks.signal,
-              });
-              return artifactPath;
-            })
-          : undefined;
-
-        const download = downloaded;
-        applicationReady = download
-          ? tasks.run(isIos ? 'app preparation' : 'app install and launch', async taskLogger => {
-              if (booted) {
-                await tasks.untilAborted(booted);
-              }
-              const artifactPath = await download;
-              tasks.signal.throwIfAborted();
-              if (isIos) {
-                const applicationIdentifier = await readIosApplicationIdentifierAsync({
-                  artifactPath,
-                  env,
-                });
-                tasks.signal.throwIfAborted();
-                return {
-                  installAppPath: artifactPath,
-                  launchAppIdentifier: applicationIdentifier,
-                  launchArgs,
-                  openUrl,
-                };
-              }
-              const { applicationIdentifier, activityName } = await installBuildAsync({
-                artifactPath,
-                runtimePlatform,
-                env,
-                logger: taskLogger,
-              });
-              tasks.signal.throwIfAborted();
-              await launchApplicationAsync({
-                applicationIdentifier,
-                activityName,
-                launchArgs,
-                openUrl,
-                runtimePlatform,
-                env,
-                logger: taskLogger,
-              });
-            })
-          : undefined;
-
-        await runAgentDeviceRemoteSessionAsync(ctx, {
-          env,
-          logger,
-          signal,
-          runtimePlatform,
-          sessionEnv,
-          packageVersion: inputs.package_version.value as string | undefined,
-          // A missing or non-positive value disables the idle timeout (opt-in feature).
-          maxIdleTimeMinutes: inputs.max_idle_time_minutes.value as number | undefined,
-          maxDurationSeconds: inputs.max_duration_seconds.value as number | undefined,
-          capture,
-          disableShare: inputs.public_preview?.value === false,
-          privatePreviewUrl: inputs.private_preview_url?.value as string | undefined,
-          frameAncestors: parseFrameAncestorsInput(inputs.frame_ancestors?.value),
-          corsOrigins: parseCorsOriginsInput(inputs.cors_origins?.value),
-          tasks,
-          device: iosSimulatorUdid
-            ? {
-                ...iosStartup,
-                iosSimulatorUdid,
-                application: applicationReady,
-              }
-            : {
-                booted: booted!,
-                ready: applicationReady ?? tasks.untilAborted(booted!),
-              },
-        });
-      } finally {
-        tasks.abort(new Error('Agent-device session ended.'));
-        await Promise.allSettled([downloaded, applicationReady]);
+      if (isIos) {
+        // Before the boot, so every Xcode tool below uses the same developer directory.
+        await selectXcodeDeveloperDirectoryAsync({ env, logger });
       }
+
+      const tasks = createStartupTasks(logger);
+
+      const booted = tasks.run(
+        isIos ? 'iOS Simulator boot' : 'Android Emulator boot',
+        async taskLogger => {
+          if (isIos) {
+            await bootIosSimulatorAsync({
+              deviceIdentifier: deviceIdentifier as IosSimulatorUuid | IosSimulatorName | undefined,
+              env,
+              logger: taskLogger,
+            });
+            return;
+          }
+          await startAndroidEmulatorAsync({
+            deviceName: ANDROID_DEVICE_NAME,
+            systemImagePackage: `${inputs.system_image_package.value}`,
+            deviceIdentifier: deviceIdentifier as AndroidDeviceName | undefined,
+            lcdWidth: inputs.lcd_width.value as number | undefined,
+            lcdHeight: inputs.lcd_height.value as number | undefined,
+            lcdDensity: inputs.lcd_density.value as number | undefined,
+            logcatDirectory: await fs.promises.mkdtemp(
+              path.join(os.tmpdir(), 'eas-android-emulator-logcat-')
+            ),
+            env,
+            logger: taskLogger,
+          });
+        }
+      );
+
+      const downloaded = hasApplication
+        ? tasks.run('build download', async taskLogger => {
+            const { artifactPath } = await downloadBuildAsync({
+              logger: taskLogger,
+              ...(buildId ? { buildId } : { applicationArchiveUrl: applicationArchiveUrl! }),
+              graphqlClient: ctx.graphqlClient,
+              deviceRunSessionWorkerApi: buildId ? getDeviceRunSessionWorkerApi(ctx) : null,
+              robotAccessToken: global.staticContext.job.secrets?.robotAccessToken ?? null,
+              extensions: isIos ? ['app'] : ['apk'],
+              signal: tasks.signal,
+            });
+            return artifactPath;
+          })
+        : undefined;
+
+      // `ready` settles only after everything it started has settled, so the session
+      // teardown, which waits for it, never leaves a download running. It must also settle
+      // soon after an abort: it stops waiting for the boot then, and the download stops.
+      const ready = downloaded
+        ? tasks.run('app install and launch', async taskLogger => {
+            const [download, boot] = await Promise.allSettled([
+              downloaded,
+              tasks.untilAborted(booted),
+            ]);
+            // After a failure elsewhere, report that failure, not the abort it caused here.
+            tasks.signal.throwIfAborted();
+            if (download.status === 'rejected') {
+              throw download.reason;
+            }
+            if (boot.status === 'rejected') {
+              throw boot.reason;
+            }
+            const { applicationIdentifier, activityName } = await installBuildAsync({
+              artifactPath: download.value,
+              runtimePlatform,
+              env,
+              logger: taskLogger,
+            });
+            tasks.signal.throwIfAborted();
+            await launchApplicationAsync({
+              applicationIdentifier,
+              activityName,
+              launchArgs,
+              openUrl,
+              runtimePlatform,
+              env,
+              logger: taskLogger,
+            });
+          })
+        : tasks.untilAborted(booted);
+
+      await runAgentDeviceRemoteSessionAsync(ctx, {
+        env,
+        logger,
+        signal,
+        runtimePlatform,
+        sessionEnv,
+        packageVersion: inputs.package_version.value as string | undefined,
+        // A missing or non-positive value disables the idle timeout (opt-in feature).
+        maxIdleTimeMinutes: inputs.max_idle_time_minutes.value as number | undefined,
+        maxDurationSeconds: inputs.max_duration_seconds.value as number | undefined,
+        capture,
+        disableShare: inputs.public_preview?.value === false,
+        privatePreviewUrl: inputs.private_preview_url?.value as string | undefined,
+        tasks,
+        device: { booted, ready },
+      });
     }),
   });
 }

packages/build-tools/src/steps/functions/startAppiumRemoteSession.ts

@@ -1,6 +1,6 @@
 import { SystemError } from '@expo/eas-build-job';
 import { type bunyan } from '@expo/logger';
-import { type Result, asyncResult } from '@expo/results';
+import { asyncResult } from '@expo/results';
 import {
   BuildFunction,
   BuildRuntimePlatform,
@@ -8,11 +8,10 @@ import {
   BuildStepInput,
   BuildStepInputValueTypeName,
 } from '@expo/steps';
-import spawn, { type SpawnOptions, type SpawnResult } from '@expo/turtle-spawn';
+import spawn from '@expo/turtle-spawn';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { setTimeout as setTimeoutAsync } from 'node:timers/promises';
 import semver from 'semver';
 import { z } from 'zod';
 
@@ -22,27 +21,22 @@ import {
   withLocalEgressSession,
 } from '../utils/localEgressSession';
 import { type DeviceSessionHost, startDeviceSessionHostAsync } from '../utils/deviceSessionHost';
-import { resolveIosSessionStartupAsync } from '../utils/iosSimulatorSession';
 import {
   createNetworkCaptureInputProviders,
   parseNetworkCaptureInputs,
 } from '../utils/networkCaptureFields';
 import { AndroidEmulatorUtils } from '../../utils/AndroidEmulatorUtils';
-import { IosSimulatorUtils, type IosSimulatorUuid } from '../../utils/IosSimulatorUtils';
+import { IosSimulatorUtils } from '../../utils/IosSimulatorUtils';
 import {
   PackageManager,
   resolveConfiguredPackageManager,
   resolvePackageAdd,
 } from '../../utils/packageManager';
-import { killProcessGroup } from '../../utils/processes';
 import { sleepAsync } from '../../utils/retry';
 import { turtleFetch } from '../../utils/turtleFetch';
 import { startAppiumEventCollectionAsync } from '../utils/appiumEvents';
 import { preparePreinstalledWdaAsync } from '../utils/preinstalledWda';
 import {
-  createCorsOriginsInputProvider,
-  createFrameAncestorsInputProvider,
-  createIosSessionStartupInputProviders,
   createPrivatePreviewUrlInputProvider,
   createPublicPreviewInputProvider,
   createServeSimLaunchInputProviders,
@@ -53,8 +47,7 @@ import {
   getNgrokAuthtokenOrThrow,
   getNgrokTunnelDomainOrThrow,
   omitNgrokAuthtoken,
-  parseCorsOriginsInput,
-  parseFrameAncestorsInput,
+  parseServeSimLaunchInputs,
   selectXcodeDeveloperDirectoryAsync,
   spawnDetached,
   startNgrokTunnelAsync,
@@ -81,12 +74,9 @@ export function createStartAppiumRemoteSessionBuildFunction(
     __metricsId: 'eas/start_appium_remote_session',
     inputProviders: [
       ...createServeSimLaunchInputProviders(),
-      ...createIosSessionStartupInputProviders(),
       ...createNetworkCaptureInputProviders(),
       createPublicPreviewInputProvider(),
       createPrivatePreviewUrlInputProvider(),
-      createFrameAncestorsInputProvider(),
-      createCorsOriginsInputProvider(),
       BuildStepInput.createProvider({
         id: 'package_version',
         required: false,
@@ -106,21 +96,14 @@ export function createStartAppiumRemoteSessionBuildFunction(
       const packageVersion = inputs.package_version.value as string | undefined;
       const maxIdleTimeMinutes = inputs.max_idle_time_minutes.value as number | undefined;
       const { runtimePlatform } = global;
-      if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
-        await selectXcodeDeveloperDirectoryAsync({ env, logger });
-      }
-      const { launch, iosStartup } = await resolveIosSessionStartupAsync({
-        runtimePlatform,
-        bootSimulator: inputs.boot_simulator?.value as boolean | undefined,
-        deviceIdentifier: inputs.device_identifier?.value as string | undefined,
-        installAppPath: inputs.install_app_path?.value as string | undefined,
-        launchAppIdentifier: inputs.launch_app_identifier?.value,
-        launchArgs: inputs.launch_args?.value,
-        openUrl: inputs.open_url?.value,
-        env,
-        logger,
-        signal,
-      });
+      const launch = parseServeSimLaunchInputs(
+        {
+          launchAppIdentifier: inputs.launch_app_identifier?.value,
+          launchArgs: inputs.launch_args?.value,
+          openUrl: inputs.open_url?.value,
+        },
+        { runtimePlatform }
+      );
       const { networkCapture, networkCaptureFields } = parseNetworkCaptureInputs(
         {
           networkCapture: inputs.network_capture?.value,
@@ -133,125 +116,54 @@ export function createStartAppiumRemoteSessionBuildFunction(
       logger.info(
         `Starting Appium remote session (version: ${versionSpec}, runtime: ${runtimePlatform}).`
       );
-      const device: AppiumDevice = iosStartup
-        ? {
-            platformName: 'iOS',
-            automationName: 'XCUITest',
-            driverName: 'xcuitest',
-            udid: iosStartup.iosSimulatorUdid,
-          }
-        : await resolveAppiumDeviceAsync({ runtimePlatform, env });
-      const startupAbortController = new AbortController();
-      const startupSignal = signal
-        ? AbortSignal.any([signal, startupAbortController.signal])
-        : startupAbortController.signal;
-      const setupSignal = iosStartup ? startupSignal : undefined;
-      let hostStartup: Promise<Result<DeviceSessionHost>> | undefined;
-      let sessionHost: DeviceSessionHost | undefined;
-      let appiumProcess: ReturnType<typeof spawnDetached> | undefined;
-      let appiumHome: string | undefined;
+      const device = await resolveAppiumDeviceAsync({ runtimePlatform, env, logger });
+      // Appium's startRecordingScreen runs ffmpeg on this host: XCUITest encodes the
+      // simulator stream with it, and UiAutomator2 merges long recordings with it. The
+      // macOS session image does not ship ffmpeg, so install it concurrently with Appium.
+      // Both installs settle before the step continues or fails, so no install outlives it.
+      const [appiumInstall] = await Promise.all([
+        asyncResult(
+          installAppiumAsync({ versionSpec, driverName: device.driverName, env, logger })
+        ),
+        ensureFfmpegInstalledOnceAsync({ runtimePlatform, env, logger }),
+      ]);
+      const { appiumHome, appiumBinPath, appiumEnv } = appiumInstall.enforceValue();
+      const wdaCapabilities = await preparePreinstalledWdaAsync({
+        runtimeIdentifier: device.runtimeIdentifier,
+        appiumHome,
+        appiumBinPath,
+        appiumEnv,
+        logger,
+      });
+
+      const appiumProcess = spawnDetached({
+        command: appiumBinPath,
+        args: [
+          '--address',
+          APPIUM_HOST,
+          '--port',
+          String(APPIUM_PORT),
+          '--base-path',
+          '/',
+          '--log-level',
+          'error',
+          // Appium 3 gates session listing (GET /appium/sessions) behind the
+          // session_discovery insecure feature. We rely on it to poll for
+          // Appium Event Timings, so enable it for all drivers.
+          '--allow-insecure',
+          '*:session_discovery',
+          '--default-capabilities',
+          JSON.stringify({ 'appium:eventTimings': true, ...wdaCapabilities }),
+        ],
+        env: appiumEnv,
+        logger,
+      });
       let eventCollection: Awaited<ReturnType<typeof startAppiumEventCollectionAsync>> | undefined;
       let appiumTunnel: Awaited<ReturnType<typeof startNgrokTunnelAsync>> | undefined;
+      let sessionHost: DeviceSessionHost | undefined;
       let sessionFailed = false;
-      const startHost = () =>
-        startDeviceSessionHostAsync(ctx, {
-          ...iosStartup,
-          separateLogPhase: true,
-          runtimePlatform,
-          env,
-          logger,
-          timeoutMs: APPIUM_STARTUP_TIMEOUT_MS,
-          disableShare: inputs.public_preview?.value === false,
-          privatePreviewUrl: inputs.private_preview_url?.value as string | undefined,
-          frameAncestors: parseFrameAncestorsInput(inputs.frame_ancestors?.value),
-          corsOrigins: parseCorsOriginsInput(inputs.cors_origins?.value),
-          signal: startupSignal,
-          onStartupError: iosStartup ? error => startupAbortController.abort(error) : undefined,
-          ...launch,
-          networkCapture,
-          networkCaptureFields,
-        }).catch(error => {
-          if (iosStartup) {
-            startupAbortController.abort(error);
-          }
-          throw error;
-        });
       try {
-        if (iosStartup) {
-          hostStartup = asyncResult(startHost());
-        }
-        // Appium's startRecordingScreen runs ffmpeg on this host: XCUITest encodes the
-        // simulator stream with it, and UiAutomator2 merges long recordings with it. The
-        // macOS session image does not ship ffmpeg, so install it concurrently with Appium.
-        // Both owned installs settle before proceeding; a shared FFmpeg install keeps its owner.
-        const [appiumInstall] = await Promise.all([
-          asyncResult(
-            installAppiumAsync({
-              versionSpec,
-              driverName: device.driverName,
-              env,
-              logger,
-              signal: setupSignal,
-              onError: iosStartup ? error => startupAbortController.abort(error) : undefined,
-            }).catch(error => {
-              if (iosStartup) {
-                startupAbortController.abort(error);
-              }
-              throw error;
-            })
-          ),
-          asyncResult(
-            ensureFfmpegInstalledOnceAsync({ runtimePlatform, env, logger, signal: setupSignal })
-          ),
-        ]);
-        const installation = appiumInstall.enforceValue();
-        appiumHome = installation.appiumHome;
-        setupSignal?.throwIfAborted();
-        const { appiumBinPath, appiumEnv } = installation;
-        const wdaCapabilities = await preparePreinstalledWdaAsync({
-          runtimeIdentifier: iosStartup
-            ? (
-                await IosSimulatorUtils.getDeviceAsync({
-                  udid: iosStartup.iosSimulatorUdid as IosSimulatorUuid,
-                  env,
-                })
-              )?.runtime
-            : device.runtimeIdentifier,
-          appiumHome,
-          appiumBinPath,
-          appiumEnv,
-          logger,
-          signal: setupSignal,
-        });
-
-        setupSignal?.throwIfAborted();
-        appiumProcess = spawnDetached({
-          command: appiumBinPath,
-          args: [
-            '--address',
-            APPIUM_HOST,
-            '--port',
-            String(APPIUM_PORT),
-            '--base-path',
-            '/',
-            '--log-level',
-            'error',
-            // Appium 3 gates session listing (GET /appium/sessions) behind the
-            // session_discovery insecure feature. We rely on it to poll for
-            // Appium Event Timings, so enable it for all drivers.
-            '--allow-insecure',
-            '*:session_discovery',
-            '--default-capabilities',
-            JSON.stringify({ 'appium:eventTimings': true, ...wdaCapabilities }),
-          ],
-          env: appiumEnv,
-          logger,
-        });
-        await waitForAppiumReadyAsync({ appiumProcess, logger, signal: setupSignal });
-        if (hostStartup) {
-          sessionHost = (await hostStartup).enforceValue();
-        }
-        setupSignal?.throwIfAborted();
+        await waitForAppiumReadyAsync({ appiumProcess, logger });
         eventCollection = await startAppiumEventCollectionAsync({
           ctx,
           deviceRunSessionId,
@@ -272,7 +184,20 @@ export function createStartAppiumRemoteSessionBuildFunction(
         if (launchDescription) {
           logger.info(launchDescription);
         }
-        sessionHost ??= (await (hostStartup ??= asyncResult(startHost()))).enforceValue();
+        sessionHost = await startDeviceSessionHostAsync(ctx, {
+          separateLogPhase: true,
+          runtimePlatform,
+          env,
+          logger,
+          timeoutMs: APPIUM_STARTUP_TIMEOUT_MS,
+          disableShare: inputs.public_preview?.value === false,
+          privatePreviewUrl: inputs.private_preview_url?.value as string | undefined,
+          launchAppIdentifier: launch.launchAppIdentifier,
+          launchArgs: launch.launchArgs,
+          openUrl: launch.openUrl,
+          networkCapture,
+          networkCaptureFields,
+        });
         const webPreview = await sessionHost.openPreviewAsync({
           baseDomain: ngrokTunnelDomain,
           authtoken: ngrokAuthtoken,
@@ -307,15 +232,13 @@ export function createStartAppiumRemoteSessionBuildFunction(
               ? {
                   maxIdleTimeMinutes,
                   getLastEventObservedAt: eventCollection.getLastEventObservedAt,
-                  getLastPreviewActivityAt: () => sessionHost?.getLastPreviewActivityAt(),
                 }
               : undefined,
         });
       } catch (error) {
         sessionFailed = true;
-        throw setupSignal?.aborted ? setupSignal.reason : error;
+        throw error;
       } finally {
-        startupAbortController.abort(new Error('Appium session ended.'));
         await finishRemoteSessionAsync({
           logger,
           sessionFailed,
@@ -328,16 +251,14 @@ export function createStartAppiumRemoteSessionBuildFunction(
                   await eventCollection?.stopAsync();
                 } finally {
                   try {
-                    await appiumProcess?.stopAsync();
+                    await appiumProcess.stopAsync();
                   } finally {
-                    if (appiumHome) {
-                      await fs.promises.rm(appiumHome, { recursive: true, force: true });
-                    }
+                    await fs.promises.rm(appiumHome, { recursive: true, force: true });
                   }
                 }
               })(),
             ],
-            ['session host', hostStartup?.then(result => result.value?.finishAsync())],
+            ['session host', sessionHost?.finishAsync()],
           ],
         });
       }
@@ -367,12 +288,15 @@ export type AppiumDevice = {
 export async function resolveAppiumDeviceAsync({
   runtimePlatform,
   env,
+  logger,
 }: {
   runtimePlatform: BuildRuntimePlatform;
   env: BuildStepEnv;
+  logger: bunyan;
 }): Promise<AppiumDevice> {
   switch (runtimePlatform) {
     case BuildRuntimePlatform.DARWIN: {
+      await selectXcodeDeveloperDirectoryAsync({ env, logger });
       const [bootedDevice] = await IosSimulatorUtils.getAvailableDevicesAsync({
         env,
         filter: 'booted',
@@ -409,135 +333,65 @@ export async function installAppiumAsync({
   driverName,
   env,
   logger,
-  signal,
-  onError,
 }: {
   versionSpec: string;
   driverName: AppiumDevice['driverName'];
   env: BuildStepEnv;
   logger: bunyan;
-  signal?: AbortSignal;
-  onError?: (error: unknown) => void;
 }): Promise<{ appiumHome: string; appiumBinPath: string; appiumEnv: BuildStepEnv }> {
-  signal?.throwIfAborted();
   const appiumHome = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'eas-appium-home-'));
-  try {
-    signal?.throwIfAborted();
-    await fs.promises.writeFile(
-      path.join(appiumHome, 'package.json'),
-      `${JSON.stringify({ name: 'eas-appium-home', private: true })}\n`
-    );
-    const appiumEnv: BuildStepEnv = { ...env, APPIUM_HOME: appiumHome };
-    const appiumBinPath = path.join(appiumHome, 'node_modules', '.bin', 'appium');
-    const add = resolvePackageAdd(
-      resolveConfiguredPackageManager(env, PackageManager.NPM),
-      `appium@${versionSpec}`
-    );
+  await fs.promises.writeFile(
+    path.join(appiumHome, 'package.json'),
+    `${JSON.stringify({ name: 'eas-appium-home', private: true })}\n`
+  );
+  const appiumEnv: BuildStepEnv = { ...env, APPIUM_HOME: appiumHome };
+  const appiumBinPath = path.join(appiumHome, 'node_modules', '.bin', 'appium');
+  const add = resolvePackageAdd(
+    resolveConfiguredPackageManager(env, PackageManager.NPM),
+    `appium@${versionSpec}`
+  );
 
-    logger.info(`Installing appium@${versionSpec} with ${add.command}.`);
-    await runAppiumSetupCommandAsync(
-      add.command,
-      add.args,
-      {
-        cwd: appiumHome,
-        env: appiumEnv,
-        logger,
-      },
-      signal
-    );
-    const { stdout } = await runAppiumSetupCommandAsync(
-      appiumBinPath,
-      ['driver', 'list', '--installed', '--json'],
-      {
-        env: appiumEnv,
-        stdio: 'pipe',
-      },
-      signal
-    );
-    const installedDrivers = AppiumInstalledDriversSchema.parse(JSON.parse(stdout));
-    if (installedDrivers[driverName]?.installed) {
-      logger.info(`Updating the installed Appium ${driverName} driver.`);
-      await runAppiumSetupCommandAsync(
-        appiumBinPath,
-        ['driver', 'update', driverName],
-        { env: appiumEnv, logger },
-        signal
-      );
-    } else {
-      logger.info(`Installing the Appium ${driverName} driver.`);
-      await runAppiumSetupCommandAsync(
-        appiumBinPath,
-        ['driver', 'install', driverName],
-        { env: appiumEnv, logger },
-        signal
-      );
-    }
-    return { appiumHome, appiumBinPath, appiumEnv };
-  } catch (error) {
-    onError?.(error);
-    if (signal) {
-      await fs.promises.rm(appiumHome, { recursive: true, force: true });
-      signal.throwIfAborted();
-    }
-    throw error;
-  }
-}
-
-async function runAppiumSetupCommandAsync(
-  command: string,
-  args: string[],
-  options: SpawnOptions,
-  signal?: AbortSignal
-): Promise<SpawnResult> {
-  if (!signal) {
-    return await spawn(command, args, options);
-  }
-  signal.throwIfAborted();
-  const task = spawn(command, args, { ...options, detached: true });
-  const abort = (): void => killProcessGroup(task.child, 'SIGKILL');
-  signal.addEventListener('abort', abort, { once: true });
-  if (signal.aborted) {
-    abort();
-  }
-  try {
-    const result = await task;
-    signal.throwIfAborted();
-    return result;
-  } finally {
-    signal.removeEventListener('abort', abort);
+  logger.info(`Installing appium@${versionSpec} with ${add.command}.`);
+  await spawn(add.command, add.args, {
+    cwd: appiumHome,
+    env: appiumEnv,
+    logger,
+  });
+  const { stdout } = await spawn(appiumBinPath, ['driver', 'list', '--installed', '--json'], {
+    env: appiumEnv,
+    stdio: 'pipe',
+  });
+  const installedDrivers = AppiumInstalledDriversSchema.parse(JSON.parse(stdout));
+  if (installedDrivers[driverName]?.installed) {
+    logger.info(`Updating the installed Appium ${driverName} driver.`);
+    await spawn(appiumBinPath, ['driver', 'update', driverName], { env: appiumEnv, logger });
+  } else {
+    logger.info(`Installing the Appium ${driverName} driver.`);
+    await spawn(appiumBinPath, ['driver', 'install', driverName], { env: appiumEnv, logger });
   }
+  return { appiumHome, appiumBinPath, appiumEnv };
 }
 
 async function waitForAppiumReadyAsync({
   appiumProcess,
   logger,
-  signal,
 }: {
   appiumProcess: { getOutput: () => string };
   logger: bunyan;
-  signal?: AbortSignal;
 }): Promise<void> {
   const deadline = Date.now() + APPIUM_STARTUP_TIMEOUT_MS;
   while (Date.now() < deadline) {
-    signal?.throwIfAborted();
     try {
       const response = await turtleFetch(`http://${APPIUM_HOST}:${APPIUM_PORT}/status`, 'GET', {
         timeout: 2_000,
         retries: 0,
         logger,
-        signal,
       });
-      signal?.throwIfAborted();
       if (response.ok) {
         return;
       }
     } catch {}
-    signal?.throwIfAborted();
-    if (signal) {
-      await setTimeoutAsync(1_000, undefined, { signal });
-    } else {
-      await sleepAsync(1_000);
-    }
+    await sleepAsync(1_000);
   }
   const output = appiumProcess.getOutput();
   throw new SystemError(

packages/build-tools/src/steps/functions/startArgentRemoteSession.ts

@@ -1,17 +1,15 @@
 import { SystemError } from '@expo/eas-build-job';
 import { type bunyan } from '@expo/logger';
-import { type Result, asyncResult } from '@expo/results';
 import {
   BuildFunction,
   BuildRuntimePlatform,
   BuildStepInput,
   BuildStepInputValueTypeName,
 } from '@expo/steps';
-import spawn, { type SpawnOptions } from '@expo/turtle-spawn';
+import spawn from '@expo/turtle-spawn';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { setTimeout as setTimeoutAsync } from 'node:timers/promises';
 import semver from 'semver';
 import { z } from 'zod';
 
@@ -21,7 +19,6 @@ import {
   withLocalEgressSession,
 } from '../utils/localEgressSession';
 import { type DeviceSessionHost, startDeviceSessionHostAsync } from '../utils/deviceSessionHost';
-import { resolveIosSessionStartupAsync } from '../utils/iosSimulatorSession';
 import {
   createNetworkCaptureInputProviders,
   parseNetworkCaptureInputs,
@@ -32,14 +29,11 @@ import {
   resolveConfiguredPackageManager,
   resolvePackageExec,
 } from '../../utils/packageManager';
-import { isProcessDescendantOfAsync, killProcessGroup } from '../../utils/processes';
+import { isProcessDescendantOfAsync } from '../../utils/processes';
 import { sleepAsync } from '../../utils/retry';
 import { pollArgentArtifactsForUploadAsync } from '../utils/argentArtifacts';
 import { ARGENT_EVENT_LOG_FILENAME, startArgentEventCollectionAsync } from '../utils/argentEvents';
 import {
-  createCorsOriginsInputProvider,
-  createFrameAncestorsInputProvider,
-  createIosSessionStartupInputProviders,
   createPrivatePreviewUrlInputProvider,
   createPublicPreviewInputProvider,
   createServeSimLaunchInputProviders,
@@ -50,8 +44,7 @@ import {
   getNgrokAuthtokenOrThrow,
   getNgrokTunnelDomainOrThrow,
   omitNgrokAuthtoken,
-  parseCorsOriginsInput,
-  parseFrameAncestorsInput,
+  parseServeSimLaunchInputs,
   selectXcodeDeveloperDirectoryAsync,
   spawnDetached,
   startNgrokTunnelAsync,
@@ -93,12 +86,9 @@ export function createStartArgentRemoteSessionBuildFunction(
     __metricsId: 'eas/start_argent_remote_session',
     inputProviders: [
       ...createServeSimLaunchInputProviders(),
-      ...createIosSessionStartupInputProviders(),
       ...createNetworkCaptureInputProviders(),
       createPublicPreviewInputProvider(),
       createPrivatePreviewUrlInputProvider(),
-      createFrameAncestorsInputProvider(),
-      createCorsOriginsInputProvider(),
       BuildStepInput.createProvider({
         id: 'package_version',
         required: false,
@@ -132,21 +122,14 @@ export function createStartArgentRemoteSessionBuildFunction(
       warnIfArgentPackageVersionCannotBeVerified({ packageVersion, logger });
       const versionSpec = packageVersion ?? 'latest';
       const { runtimePlatform } = global;
-      if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
-        await selectXcodeDeveloperDirectoryAsync({ env, logger });
-      }
-      const { launch, iosStartup } = await resolveIosSessionStartupAsync({
-        runtimePlatform,
-        bootSimulator: inputs.boot_simulator?.value as boolean | undefined,
-        deviceIdentifier: inputs.device_identifier?.value as string | undefined,
-        installAppPath: inputs.install_app_path?.value as string | undefined,
-        launchAppIdentifier: inputs.launch_app_identifier?.value,
-        launchArgs: inputs.launch_args?.value,
-        openUrl: inputs.open_url?.value,
-        env,
-        logger,
-        signal,
-      });
+      const launch = parseServeSimLaunchInputs(
+        {
+          launchAppIdentifier: inputs.launch_app_identifier?.value as string | undefined,
+          launchArgs: inputs.launch_args?.value,
+          openUrl: inputs.open_url?.value as string | undefined,
+        },
+        { runtimePlatform }
+      );
       const { networkCapture, networkCaptureFields } = parseNetworkCaptureInputs(
         {
           networkCapture: inputs.network_capture?.value,
@@ -158,6 +141,10 @@ export function createStartArgentRemoteSessionBuildFunction(
         `Starting argent remote session (version: ${versionSpec}, runtime: ${runtimePlatform}).`
       );
 
+      if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
+        await selectXcodeDeveloperDirectoryAsync({ env, logger });
+      }
+
       // Start the potentially slow installation while Argent is being prepared.
       // On Linux expo-device-hub calls this again and awaits the same in-flight
       // setup before launching. On macOS this remains non-blocking, so only a
@@ -169,124 +156,74 @@ export function createStartArgentRemoteSessionBuildFunction(
       const argentExec = (args: string[]): { command: string; args: string[] } =>
         resolvePackageExec(packageManager, args);
 
-      const startupAbortController = new AbortController();
-      const startupSignal = signal
-        ? AbortSignal.any([signal, startupAbortController.signal])
-        : startupAbortController.signal;
-      const setupSignal = iosStartup ? startupSignal : undefined;
+      logger.info('Enabling the Argent artifacts list endpoint flag.');
+      const enableArtifacts = argentExec([
+        `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
+        'enable',
+        ARGENT_ARTIFACTS_LIST_ENDPOINT_FLAG,
+      ]);
+      await spawn(enableArtifacts.command, enableArtifacts.args, { env, logger });
+
+      logger.info('Enabling the Argent tool-server event log flag.');
+      const enableEventLog = argentExec([
+        `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
+        'enable',
+        ARGENT_EVENT_LOG_FLAG,
+      ]);
+      await spawn(enableEventLog.command, enableEventLog.args, { env, logger });
+
+      logger.info('Disabling the Argent video watermark flag.');
+      const disableVideoWatermark = argentExec([
+        `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
+        'disable',
+        ARGENT_VIDEO_WATERMARK_FLAG,
+      ]);
+      // The watermark is cosmetic, so a failure here must not fail the session.
+      try {
+        await spawn(disableVideoWatermark.command, disableVideoWatermark.args, { env, logger });
+      } catch (err) {
+        logger.warn(
+          { err },
+          'Could not disable the Argent video watermark, so recorded videos may include it. Continuing the session.'
+        );
+      }
+
+      const startServer = argentExec([
+        `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
+        'server',
+        'start',
+        '--port',
+        '0',
+        '--idle-timeout',
+        '0',
+        '--force',
+      ]);
+      logger.info(
+        `Launching ${ARGENT_PACKAGE_NAME}@${versionSpec} tool-server via ${startServer.command}.`
+      );
+      // Keep Argent itself in foreground mode under the detached process. This preserves
+      // the npx/bun -> Argent CLI -> tool-server ancestry used to identify the matching state file.
+      const secrets: string[] = [];
+      const argentServer = spawnDetached({
+        command: startServer.command,
+        args: startServer.args,
+        env: { ...env, ARGENT_EVENT_LOG: ARGENT_EVENT_LOG_PATH, ARGENT_EMULATOR_NO_WINDOW: '1' },
+        logger,
+        secrets,
+      });
+      if (argentServer.pid === undefined) {
+        throw new SystemError(
+          'Failed to start Argent: could not determine the PID of the launched process.'
+        );
+      }
+
       const artifactPollAbortController = new AbortController();
       let artifactPollingPromise: Promise<void> | undefined;
       let eventCollection: Awaited<ReturnType<typeof startArgentEventCollectionAsync>> | undefined;
       let toolsTunnel: Awaited<ReturnType<typeof startNgrokTunnelAsync>> | undefined;
-      let argentServer: ReturnType<typeof spawnDetached> | undefined;
-      let hostStartup: Promise<Result<DeviceSessionHost>> | undefined;
       let sessionHost: DeviceSessionHost | undefined;
       let sessionFailed = false;
-      const startHost = () =>
-        startDeviceSessionHostAsync(ctx, {
-          ...iosStartup,
-          separateLogPhase: true,
-          runtimePlatform,
-          env,
-          logger,
-          disableShare: inputs.public_preview?.value === false,
-          privatePreviewUrl: inputs.private_preview_url?.value as string | undefined,
-          frameAncestors: parseFrameAncestorsInput(inputs.frame_ancestors?.value),
-          corsOrigins: parseCorsOriginsInput(inputs.cors_origins?.value),
-          timeoutMs: STARTUP_TIMEOUT_MS,
-          signal: startupSignal,
-          onStartupError: iosStartup ? error => startupAbortController.abort(error) : undefined,
-          ...launch,
-          networkCapture,
-          networkCaptureFields,
-        }).catch(error => {
-          if (iosStartup) {
-            startupAbortController.abort(error);
-          }
-          throw error;
-        });
       try {
-        if (iosStartup) {
-          hostStartup = asyncResult(startHost());
-        }
-        logger.info('Enabling the Argent artifacts list endpoint flag.');
-        const enableArtifacts = argentExec([
-          `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
-          'enable',
-          ARGENT_ARTIFACTS_LIST_ENDPOINT_FLAG,
-        ]);
-        await runArgentSetupCommandAsync(
-          enableArtifacts.command,
-          enableArtifacts.args,
-          { env, logger },
-          setupSignal
-        );
-
-        logger.info('Enabling the Argent tool-server event log flag.');
-        const enableEventLog = argentExec([
-          `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
-          'enable',
-          ARGENT_EVENT_LOG_FLAG,
-        ]);
-        await runArgentSetupCommandAsync(
-          enableEventLog.command,
-          enableEventLog.args,
-          { env, logger },
-          setupSignal
-        );
-
-        logger.info('Disabling the Argent video watermark flag.');
-        const disableVideoWatermark = argentExec([
-          `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
-          'disable',
-          ARGENT_VIDEO_WATERMARK_FLAG,
-        ]);
-        // The watermark is cosmetic, so a failure here must not fail the session.
-        try {
-          await runArgentSetupCommandAsync(
-            disableVideoWatermark.command,
-            disableVideoWatermark.args,
-            { env, logger },
-            setupSignal
-          );
-        } catch (err) {
-          setupSignal?.throwIfAborted();
-          logger.warn(
-            { err },
-            'Could not disable the Argent video watermark, so recorded videos may include it. Continuing the session.'
-          );
-        }
-
-        setupSignal?.throwIfAborted();
-        const startServer = argentExec([
-          `${ARGENT_PACKAGE_NAME}@${versionSpec}`,
-          'server',
-          'start',
-          '--port',
-          '0',
-          '--idle-timeout',
-          '0',
-          '--force',
-        ]);
-        logger.info(
-          `Launching ${ARGENT_PACKAGE_NAME}@${versionSpec} tool-server via ${startServer.command}.`
-        );
-        // Keep Argent itself in foreground mode under the detached process. This preserves
-        // the npx/bun -> Argent CLI -> tool-server ancestry used to identify the matching state file.
-        const secrets: string[] = [];
-        argentServer = spawnDetached({
-          command: startServer.command,
-          args: startServer.args,
-          env: { ...env, ARGENT_EVENT_LOG: ARGENT_EVENT_LOG_PATH, ARGENT_EMULATOR_NO_WINDOW: '1' },
-          logger,
-          secrets,
-        });
-        if (argentServer.pid === undefined) {
-          throw new 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: number;
         let toolServerToken: string | undefined;
@@ -296,7 +233,6 @@ export function createStartArgentRemoteSessionBuildFunction(
             ancestorPid: argentServer.pid,
             timeoutMs: STARTUP_TIMEOUT_MS,
             getExitError: argentServer.getExitError,
-            signal: setupSignal,
           });
           toolServerPort = toolServerState.port;
           toolServerToken = toolServerState.token;
@@ -311,10 +247,6 @@ export function createStartArgentRemoteSessionBuildFunction(
             }${output ? `\nArgent tool-server output:\n${output}` : ''}`
           );
         }
-        if (hostStartup) {
-          sessionHost = (await hostStartup).enforceValue();
-        }
-        setupSignal?.throwIfAborted();
         logger.info(`Argent tool-server is listening on port ${toolServerPort}.`);
         const artifactPollSignal = signal
           ? AbortSignal.any([signal, artifactPollAbortController.signal])
@@ -349,7 +281,20 @@ export function createStartArgentRemoteSessionBuildFunction(
         if (launchDescription) {
           logger.info(launchDescription);
         }
-        sessionHost ??= (await (hostStartup ??= asyncResult(startHost()))).enforceValue();
+        sessionHost = await startDeviceSessionHostAsync(ctx, {
+          separateLogPhase: true,
+          runtimePlatform,
+          env,
+          logger,
+          timeoutMs: STARTUP_TIMEOUT_MS,
+          disableShare: inputs.public_preview?.value === false,
+          privatePreviewUrl: inputs.private_preview_url?.value as string | undefined,
+          launchAppIdentifier: launch.launchAppIdentifier,
+          launchArgs: launch.launchArgs,
+          openUrl: launch.openUrl,
+          networkCapture,
+          networkCaptureFields,
+        });
         const webPreview = await sessionHost.openPreviewAsync({
           baseDomain: ngrokTunnelDomain,
           authtoken: ngrokAuthtoken,
@@ -386,15 +331,13 @@ export function createStartArgentRemoteSessionBuildFunction(
               ? {
                   maxIdleTimeMinutes,
                   getLastEventObservedAt: eventCollection.getLastEventObservedAt,
-                  getLastPreviewActivityAt: () => sessionHost?.getLastPreviewActivityAt(),
                 }
               : undefined,
         });
       } catch (error) {
         sessionFailed = true;
-        throw setupSignal?.aborted ? setupSignal.reason : error;
+        throw error;
       } finally {
-        startupAbortController.abort(new Error('Argent session ended.'));
         await finishRemoteSessionAsync({
           logger,
           sessionFailed,
@@ -426,11 +369,11 @@ export function createStartArgentRemoteSessionBuildFunction(
                     );
                   }
                 } finally {
-                  await argentServer?.stopAsync();
+                  await argentServer.stopAsync();
                 }
               })(),
             ],
-            ['session host', hostStartup?.then(result => result.value?.finishAsync())],
+            ['session host', sessionHost?.finishAsync()],
           ],
         });
       }
@@ -490,31 +433,6 @@ export function warnIfArgentPackageVersionCannotBeVerified({
   }
 }
 
-async function runArgentSetupCommandAsync(
-  command: string,
-  args: string[],
-  options: SpawnOptions,
-  signal?: AbortSignal
-): Promise<void> {
-  if (!signal) {
-    await spawn(command, args, options);
-    return;
-  }
-  signal.throwIfAborted();
-  const task = spawn(command, args, { ...options, detached: true });
-  const abort = (): void => killProcessGroup(task.child, 'SIGKILL');
-  signal.addEventListener('abort', abort, { once: true });
-  if (signal.aborted) {
-    abort();
-  }
-  try {
-    await task;
-    signal.throwIfAborted();
-  } finally {
-    signal.removeEventListener('abort', abort);
-  }
-}
-
 function parseArgentToolServerState(raw: string): ArgentToolServerState {
   let json: unknown;
   try {
@@ -537,16 +455,13 @@ export async function waitForArgentToolServerStateAsync({
   timeoutMs,
   pollIntervalMs = 1_000,
   getExitError,
-  signal,
 }: {
   stateDir: string;
   ancestorPid: number;
   timeoutMs: number;
   pollIntervalMs?: number;
   getExitError?: () => Error | undefined;
-  signal?: AbortSignal;
 }): Promise<ArgentToolServerState> {
-  signal?.throwIfAborted();
   const deadline = Date.now() + timeoutMs;
   let lastError: unknown;
   const throwIfExited = (): void => {
@@ -557,7 +472,6 @@ export async function waitForArgentToolServerStateAsync({
   };
 
   while (Date.now() < deadline) {
-    signal?.throwIfAborted();
     throwIfExited();
     let matchingState: ArgentToolServerState | undefined;
     try {
@@ -583,19 +497,13 @@ export async function waitForArgentToolServerStateAsync({
       lastError = err;
     }
     // Keep process failures outside the retryable state-file read errors.
-    signal?.throwIfAborted();
     throwIfExited();
     if (matchingState) {
       return matchingState;
     }
-    if (signal) {
-      await setTimeoutAsync(pollIntervalMs, undefined, { signal });
-    } else {
-      await sleepAsync(pollIntervalMs);
-    }
+    await sleepAsync(pollIntervalMs);
   }
 
-  signal?.throwIfAborted();
   throw new SystemError(
     `Timed out waiting for an argent tool-server state file belonging to process ${ancestorPid} in ${stateDir}${
       lastError instanceof Error ? `: ${lastError.message}` : ''

packages/build-tools/src/steps/functions/startSandbox.ts

@@ -1,4 +1,4 @@
-import { SystemError, UserError } from '@expo/eas-build-job';
+import { SystemError } from '@expo/eas-build-job';
 import { BuildFunction, BuildStepInput, BuildStepInputValueTypeName } from '@expo/steps';
 import { graphql } from 'gql.tada';
 
@@ -32,11 +32,6 @@ export function createStartSandboxBuildFunction(ctx: CustomBuildContext): BuildF
         required: true,
         allowedValueTypeName: BuildStepInputValueTypeName.STRING,
       }),
-      BuildStepInput.createProvider({
-        id: 'max_duration_seconds',
-        required: false,
-        allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
-      }),
     ],
     fn: async (stepCtx, { inputs, signal, env }) => {
       // The daemon needs this credential, but shell commands do not.
@@ -49,18 +44,6 @@ export function createStartSandboxBuildFunction(ctx: CustomBuildContext): BuildF
         throw new SystemError('MCP server URL is required to start the sandbox daemon.');
       }
       const sandboxId = String(inputs.sandbox_id.value);
-      const maxDurationSeconds = inputs.max_duration_seconds?.value;
-      if (
-        maxDurationSeconds !== undefined &&
-        (typeof maxDurationSeconds !== 'number' ||
-          !Number.isFinite(maxDurationSeconds) ||
-          maxDurationSeconds <= 0)
-      ) {
-        throw new UserError(
-          'EAS_SANDBOX_INVALID_DURATION',
-          `Invalid sandbox maximum duration: ${String(maxDurationSeconds)}. Provide a finite number greater than zero, or omit max_duration_seconds.`
-        );
-      }
       const daemon = await startSandboxDaemonAsync({
         credential: sandboxToken,
         serverUrl: mcpServerUrl,
@@ -80,21 +63,7 @@ export function createStartSandboxBuildFunction(ctx: CustomBuildContext): BuildF
         stepCtx.logger.info('Sandbox daemon started.');
 
         await withLogPhaseAsync(stepCtx.logger, AWAIT_SANDBOX_STEP_NAME, async () => {
-          const timeoutSignal =
-            maxDurationSeconds === undefined
-              ? undefined
-              : AbortSignal.timeout(Math.ceil(maxDurationSeconds * 1000));
-          await waitForCompletionAsync(
-            AbortSignal.any([
-              ...(signal ? [signal] : []),
-              ...(timeoutSignal ? [timeoutSignal] : []),
-            ])
-          );
-          if (timeoutSignal?.aborted) {
-            stepCtx.logger.info(
-              `Sandbox reached its maximum runtime of ${maxDurationSeconds} seconds. Stopping.`
-            );
-          }
+          await waitForCancellationAsync(signal);
         });
       } finally {
         await daemon.stopAsync();
@@ -120,11 +89,11 @@ export async function markSandboxReadyAsync(
   }
 }
 
-async function waitForCompletionAsync(signal: AbortSignal): Promise<void> {
-  if (signal.aborted) {
+async function waitForCancellationAsync(signal?: AbortSignal): Promise<void> {
+  if (signal?.aborted) {
     return;
   }
   await new Promise<void>(resolve => {
-    signal.addEventListener('abort', () => resolve(), { once: true });
+    signal?.addEventListener('abort', () => resolve(), { once: true });
   });
 }

packages/build-tools/src/steps/functions/startWebPreviewRemoteSession.ts

@@ -17,8 +17,6 @@ import {
   withLocalEgressSession,
 } from '../utils/localEgressSession';
 import {
-  createCorsOriginsInputProvider,
-  createFrameAncestorsInputProvider,
   createIosSessionStartupInputProviders,
   createPrivatePreviewUrlInputProvider,
   createPublicPreviewInputProvider,
@@ -28,8 +26,6 @@ import {
   getNgrokAuthtokenOrThrow,
   getNgrokTunnelDomainOrThrow,
   omitNgrokAuthtoken,
-  parseCorsOriginsInput,
-  parseFrameAncestorsInput,
   selectXcodeDeveloperDirectoryAsync,
   waitForDeviceRunSessionStoppedAsync,
 } from '../utils/remoteDeviceRunSession';
@@ -50,8 +46,6 @@ export function createStartWebPreviewRemoteSessionBuildFunction(
       ...createNetworkCaptureInputProviders(),
       createPublicPreviewInputProvider(),
       createPrivatePreviewUrlInputProvider(),
-      createFrameAncestorsInputProvider(),
-      createCorsOriginsInputProvider(),
       BuildStepInput.createProvider({
         id: 'package_version',
         required: false,
@@ -110,8 +104,6 @@ export function createStartWebPreviewRemoteSessionBuildFunction(
         packageVersion,
         disableShare: inputs.public_preview?.value === false,
         privatePreviewUrl: inputs.private_preview_url?.value as string | undefined,
-        frameAncestors: parseFrameAncestorsInput(inputs.frame_ancestors?.value),
-        corsOrigins: parseCorsOriginsInput(inputs.cors_origins?.value),
         launchAppIdentifier: launch.launchAppIdentifier,
         launchArgs: launch.launchArgs,
         openUrl: launch.openUrl,

packages/build-tools/src/steps/functions/submitToGooglePlay.ts

@@ -179,6 +179,8 @@ async function submitToGooglePlayAsync({
   let editId: string | undefined;
   let committed = false;
   let commitOutcomeUnknown = false;
+  // The submission phase in progress, named in Google Play errors.
+  let action = 'create a Google Play edit';
   try {
     const packageName = submission.package_name;
     logger.info(
@@ -203,6 +205,7 @@ async function submitToGooglePlayAsync({
       logger.info(`Changelog (en-US): ${JSON.stringify(submission.changelog)}`);
     }
     editId = (await GooglePlayUtils.createEditAsync(client, { packageName, signal })).id;
+    action = `upload the ${artifactType.toUpperCase()}`;
     let lastPercent: number | undefined;
     const { versionCode } = await GooglePlayUtils.uploadApplicationAsync(client, {
       packageName,
@@ -219,6 +222,7 @@ async function submitToGooglePlayAsync({
       },
     });
     logger.info(`Uploaded version code: ${versionCode}.`);
+    action = `update track ${JSON.stringify(submission.track)}`;
     await GooglePlayUtils.updateTrackAsync(client, {
       packageName,
       editId,
@@ -230,6 +234,7 @@ async function submitToGooglePlayAsync({
     });
     logger.info(`Updated Google Play track ${JSON.stringify(submission.track)} in the edit.`);
     logger.info('Committing the Google Play edit...');
+    action = 'commit the Google Play edit';
     // Commit also validates the edit.
     await GooglePlayUtils.commitEditAsync(client, {
       packageName,
@@ -245,7 +250,14 @@ async function submitToGooglePlayAsync({
     return versionCode;
   } catch (error) {
     commitOutcomeUnknown = error instanceof GooglePlayCommitOutcomeUnknownError;
-    throw GooglePlayUtils.mapGooglePlayError(error, submission.package_name);
+    const metadata = GooglePlayUtils.getGooglePlayErrorMetadata(error);
+    if (metadata) {
+      logger.warn(metadata, 'Google Play submission failed.');
+    }
+    throw GooglePlayUtils.mapGooglePlayError(error, {
+      packageName: submission.package_name,
+      action,
+    });
   } finally {
     if (editId && !committed && !commitOutcomeUnknown) {
       try {
@@ -254,8 +266,9 @@ async function submitToGooglePlayAsync({
           editId,
           signal: AbortSignal.timeout(30_000),
         });
-      } catch {
+      } catch (error) {
         logger.warn(
+          GooglePlayUtils.getGooglePlayErrorMetadata(error) ?? {},
           'Could not discard the pending Google Play changes. Check the release in Play Console before submitting again.'
         );
       }

packages/build-tools/src/steps/functions/uploadArtifact.ts

@@ -1,4 +1,9 @@
-import { Job, ManagedArtifactType } from '@expo/eas-build-job';
+import {
+  GenericArtifactType,
+  Job,
+  ManagedArtifactType,
+  isGenericArtifact,
+} from '@expo/eas-build-job';
 import {
   BuildFunction,
   BuildStepInput,
@@ -28,12 +33,7 @@ export function createUploadArtifactBuildFunction(ctx: CustomBuildContext): Buil
           ManagedArtifactType.APPLICATION_ARCHIVE,
           ManagedArtifactType.BUILD_ARTIFACTS,
           ...Object.keys(artifactTypeInputToManagedArtifactType),
-          // Keep accepting these legacy artifact types for compatibility.
-          'android-apk',
-          'android-aab',
-          'ios-simulator-app',
-          'ios-ipa',
-          'other',
+          ...Object.values(GenericArtifactType),
         ],
         required: false,
         allowedValueTypeName: BuildStepInputValueTypeName.STRING,
@@ -126,13 +126,12 @@ export function createUploadArtifactBuildFunction(ctx: CustomBuildContext): Buil
         paths: artifactPaths,
         name: (inputs.name.value || inputs.key.value) as string,
       };
-      const artifact =
-        artifactSpec.type === null
-          ? {
-              ...artifactSpec,
-              metadata: inputs.metadata.value as Record<string, unknown> | undefined,
-            }
-          : artifactSpec;
+      const artifact = isGenericArtifact(artifactSpec)
+        ? {
+            ...artifactSpec,
+            metadata: inputs.metadata.value as Record<string, unknown> | undefined,
+          }
+        : artifactSpec;
 
       try {
         const { artifactId } = await ctx.runtimeApi.uploadArtifact({ artifact, logger });
@@ -142,7 +141,7 @@ export function createUploadArtifactBuildFunction(ctx: CustomBuildContext): Buil
         }
       } catch (error) {
         if (inputs.ignore_error.value) {
-          logger.error({ err: error }, 'Failed to upload artifact. Ignoring error.');
+          logger.error({ err: error }, `Failed to upload ${artifact.type}. Ignoring error.`);
           // Ignoring error.
           return;
         }
@@ -159,7 +158,7 @@ export function createUploadArtifactBuildFunction(ctx: CustomBuildContext): Buil
  * values. This makes sure we support all:
  * - kebab-case managed artifact types (the original)
  * - snake-caps-case managed artifact types (the mistake)
- * - workflow artifact types.
+ * - generic artifact types.
  */
 function parseArtifactTypeInput({
   inputValue,
@@ -167,15 +166,19 @@ function parseArtifactTypeInput({
 }: {
   inputValue: string;
   platform: Job['platform'];
-}): ManagedArtifactType | null {
+}): GenericArtifactType | ManagedArtifactType {
   if (!inputValue) {
     // In build jobs the default artifact type is application-archive.
-    return platform ? ManagedArtifactType.APPLICATION_ARCHIVE : null;
+    return platform ? ManagedArtifactType.APPLICATION_ARCHIVE : GenericArtifactType.OTHER;
   }
 
-  return (
-    artifactTypeInputToManagedArtifactType[inputValue] ??
-    Object.values(ManagedArtifactType).find(type => type === inputValue) ??
-    null
-  );
+  // Step's allowedValues ensures input is either
+  // a key of artifactTypeInputToManagedArtifactType
+  // or a value of an artifact type.
+  const translatedManagedArtifactType = artifactTypeInputToManagedArtifactType[inputValue];
+  if (translatedManagedArtifactType) {
+    return translatedManagedArtifactType;
+  }
+
+  return inputValue as GenericArtifactType | ManagedArtifactType;
 }

packages/build-tools/src/steps/utils/__tests__/agentDeviceEvents.test.ts

@@ -7,12 +7,7 @@ import { type CustomBuildContext } from '../../../customBuildContext';
 import HttpLogStream from '../../../logging/HttpLogStream';
 import RemoteLoggerStream from '../../../logging/RemoteLoggerStream';
 import { Sentry } from '../../../sentry';
-import { turtleFetch } from '../../../utils/turtleFetch';
 import { startAgentDeviceEventCollectionAsync } from '../agentDeviceEvents';
-import {
-  DEVICE_RUN_SESSION_TOKEN_HEADER,
-  DeviceRunSessionWorkerApiError,
-} from '../deviceRunSessionWorkerApi';
 
 const mockEventLogStream = {
   init: jest.fn(async () => undefined),
@@ -33,18 +28,10 @@ jest.mock('../../../logging/RemoteLoggerStream', () => ({
   default: jest.fn(() => mockEventLogStream),
 }));
 jest.mock('../../../sentry');
-jest.mock('../../../utils/turtleFetch');
-
-const { Response } = jest.requireActual('node-fetch') as typeof import('node-fetch');
-
-const DEVICE_RUN_SESSION_TOKEN = 'device-run-session-token-value';
-const EVENT_LOG_UPLOAD_SESSION_URL =
-  'https://api.expo.test/v2/device-run-session-worker/event-log-upload-session';
 
 describe(startAgentDeviceEventCollectionAsync, () => {
   beforeEach(() => {
     jest.clearAllMocks();
-    jest.mocked(turtleFetch).mockImplementation(async () => eventLogUploadSessionResponse());
   });
 
   it('uploads normalized events to the session event artifact once', async () => {
@@ -101,13 +88,9 @@ describe(startAgentDeviceEventCollectionAsync, () => {
       await fs.promises.rm(stateDir, { recursive: true, force: true });
     }
 
-    expect(turtleFetch).toHaveBeenCalledWith(
-      EVENT_LOG_UPLOAD_SESSION_URL,
-      'POST',
-      expect.objectContaining({
-        headers: { [DEVICE_RUN_SESSION_TOKEN_HEADER]: DEVICE_RUN_SESSION_TOKEN },
-      })
-    );
+    expect(ctx.graphqlClient.mutation).toHaveBeenCalledWith(expect.anything(), {
+      deviceRunSessionId: 'session-id',
+    });
     expect(RemoteLoggerStream).toHaveBeenCalledWith({
       logger,
       uploadMethod: {
@@ -552,13 +535,11 @@ describe(startAgentDeviceEventCollectionAsync, () => {
   });
 
   it('does not fail the session when event log setup fails', async () => {
+    const error = new Error('WWW unavailable');
     const ctx = createContext({ realtimeLogs: true });
-    jest.mocked(turtleFetch).mockResolvedValueOnce(
-      new Response(JSON.stringify({ errors: [{ message: 'WWW unavailable' }] }), {
-        status: 503,
-        headers: { 'content-type': 'application/json' },
-      })
-    );
+    jest.mocked(ctx.graphqlClient.mutation).mockReturnValueOnce({
+      toPromise: async () => ({ error }),
+    } as unknown as ReturnType<CustomBuildContext['graphqlClient']['mutation']>);
     const logger = createLogger();
 
     const collection = await startAgentDeviceEventCollectionAsync({
@@ -573,11 +554,8 @@ describe(startAgentDeviceEventCollectionAsync, () => {
     expect(logger.warn).toHaveBeenCalledWith(
       {
         err: expect.objectContaining({
-          message:
-            'Failed to create device run session event log upload session: ' +
-            'POST /v2/device-run-session-worker/event-log-upload-session failed with status 503: ' +
-            'WWW unavailable',
-          cause: expect.any(DeviceRunSessionWorkerApiError),
+          message: 'Failed to create device run session event log upload session: WWW unavailable',
+          cause: error,
         }),
       },
       'Could not persist device run session events to the artifact.'
@@ -585,11 +563,8 @@ describe(startAgentDeviceEventCollectionAsync, () => {
     expect(Sentry.capture).toHaveBeenCalledWith(
       'Could not persist device run session events',
       expect.objectContaining({
-        message:
-          'Failed to create device run session event log upload session: ' +
-          'POST /v2/device-run-session-worker/event-log-upload-session failed with status 503: ' +
-          'WWW unavailable',
-        cause: expect.any(DeviceRunSessionWorkerApiError),
+        message: 'Failed to create device run session event log upload session: WWW unavailable',
+        cause: error,
       }),
       {
         level: 'warning',
@@ -694,33 +669,30 @@ describe(startAgentDeviceEventCollectionAsync, () => {
 function createContext({
   realtimeLogs = false,
 }: { realtimeLogs?: boolean } = {}): CustomBuildContext {
-  return {
-    env: {
-      EAS_DEVICE_RUN_SESSION_TOKEN: DEVICE_RUN_SESSION_TOKEN,
-      ...(realtimeLogs ? { EXPO_STAGING: '1', EAS_BUILD_ID: 'job-run-id' } : {}),
-    },
-    expoApiV2BaseUrl: 'https://api.expo.test/v2/',
-    job: {
-      secrets: realtimeLogs ? { robotAccessToken: 'robot-access-token' } : {},
-    },
-  } as unknown as CustomBuildContext;
-}
-
-function eventLogUploadSessionResponse(): InstanceType<typeof Response> {
-  return new Response(
-    JSON.stringify({
+  const mutation = jest.fn().mockReturnValue({
+    toPromise: async () => ({
       data: {
-        uploadSession: {
-          url: 'https://uploads.expo.test/events',
-          headers: {
-            'content-disposition': 'attachment; filename="events.ndjson"',
-            'x-goog-content-length-range': '0,104857600',
+        deviceRunSession: {
+          createEventLogUploadSession: {
+            uploadSession: {
+              url: 'https://uploads.expo.test/events',
+              headers: {
+                'content-disposition': 'attachment; filename="events.ndjson"',
+                'x-goog-content-length-range': '0,104857600',
+              },
+            },
           },
         },
       },
     }),
-    { headers: { 'content-type': 'application/json' } }
-  );
+  });
+  return {
+    graphqlClient: { mutation },
+    env: realtimeLogs ? { EXPO_STAGING: '1', EAS_BUILD_ID: 'job-run-id' } : {},
+    job: {
+      secrets: realtimeLogs ? { robotAccessToken: 'robot-access-token' } : {},
+    },
+  } as unknown as CustomBuildContext;
 }
 
 function createLogger(): bunyan {

packages/build-tools/src/steps/utils/__tests__/argentEvents.test.ts

@@ -7,9 +7,7 @@ import { type CustomBuildContext } from '../../../customBuildContext';
 import HttpLogStream from '../../../logging/HttpLogStream';
 import RemoteLoggerStream from '../../../logging/RemoteLoggerStream';
 import { Sentry } from '../../../sentry';
-import { turtleFetch } from '../../../utils/turtleFetch';
 import { startArgentEventCollectionAsync } from '../argentEvents';
-import { DEVICE_RUN_SESSION_TOKEN_HEADER } from '../deviceRunSessionWorkerApi';
 
 const mockEventLogStream = {
   init: jest.fn(async () => undefined),
@@ -30,20 +28,12 @@ jest.mock('../../../logging/RemoteLoggerStream', () => ({
   default: jest.fn(() => mockEventLogStream),
 }));
 jest.mock('../../../sentry');
-jest.mock('../../../utils/turtleFetch');
-
-const { Response } = jest.requireActual('node-fetch') as typeof import('node-fetch');
-
-const DEVICE_RUN_SESSION_TOKEN = 'device-run-session-token-value';
-const EVENT_LOG_UPLOAD_SESSION_URL =
-  'https://api.expo.test/v2/device-run-session-worker/event-log-upload-session';
 
 const EVENT_LOG_FILENAME = 'tool-server-events.jsonl';
 
 describe(startArgentEventCollectionAsync, () => {
   beforeEach(() => {
     jest.clearAllMocks();
-    jest.mocked(turtleFetch).mockImplementation(async () => eventLogUploadSessionResponse());
   });
 
   it('maps tool lifecycle records onto the shared operation vocabulary', async () => {
@@ -94,13 +84,9 @@ describe(startArgentEventCollectionAsync, () => {
       await fs.promises.rm(stateDir, { recursive: true, force: true });
     }
 
-    expect(turtleFetch).toHaveBeenCalledWith(
-      EVENT_LOG_UPLOAD_SESSION_URL,
-      'POST',
-      expect.objectContaining({
-        headers: { [DEVICE_RUN_SESSION_TOKEN_HEADER]: DEVICE_RUN_SESSION_TOKEN },
-      })
-    );
+    expect(ctx.graphqlClient.mutation).toHaveBeenCalledWith(expect.anything(), {
+      deviceRunSessionId: 'session-id',
+    });
     expect(RemoteLoggerStream).toHaveBeenCalledWith({
       logger,
       uploadMethod: {
@@ -332,32 +318,29 @@ function bunyanRecord(fields: Record<string, unknown>): Record<string, unknown>
 function createContext({
   realtimeLogs = false,
 }: { realtimeLogs?: boolean } = {}): CustomBuildContext {
+  const mutation = jest.fn().mockReturnValue({
+    toPromise: async () => ({
+      data: {
+        deviceRunSession: {
+          createEventLogUploadSession: {
+            uploadSession: {
+              url: 'https://uploads.expo.test/events',
+              headers: { 'content-disposition': 'attachment; filename="events.ndjson"' },
+            },
+          },
+        },
+      },
+    }),
+  });
   return {
-    env: {
-      EAS_DEVICE_RUN_SESSION_TOKEN: DEVICE_RUN_SESSION_TOKEN,
-      ...(realtimeLogs ? { EXPO_STAGING: '1', EAS_BUILD_ID: 'job-run-id' } : {}),
-    },
-    expoApiV2BaseUrl: 'https://api.expo.test/v2/',
+    graphqlClient: { mutation },
+    env: realtimeLogs ? { EXPO_STAGING: '1', EAS_BUILD_ID: 'job-run-id' } : {},
     job: {
       secrets: realtimeLogs ? { robotAccessToken: 'robot-access-token' } : {},
     },
   } as unknown as CustomBuildContext;
 }
 
-function eventLogUploadSessionResponse(): InstanceType<typeof Response> {
-  return new Response(
-    JSON.stringify({
-      data: {
-        uploadSession: {
-          url: 'https://uploads.expo.test/events',
-          headers: { 'content-disposition': 'attachment; filename="events.ndjson"' },
-        },
-      },
-    }),
-    { headers: { 'content-type': 'application/json' } }
-  );
-}
-
 function createLogger(): bunyan {
   return { info: jest.fn(), warn: jest.fn() } as unknown as bunyan;
 }

packages/build-tools/src/steps/utils/__tests__/deviceRunSessionArtifacts.test.ts

@@ -2,56 +2,46 @@ import fetch from 'node-fetch';
 import { Readable } from 'node:stream';
 
 import { CustomBuildContext } from '../../../customBuildContext';
-import { turtleFetch } from '../../../utils/turtleFetch';
 import { uploadDeviceRunSessionArtifactAsync } from '../deviceRunSessionArtifacts';
-import { DEVICE_RUN_SESSION_TOKEN_HEADER } from '../deviceRunSessionWorkerApi';
 
 jest.mock('node-fetch');
-jest.mock('../../../utils/turtleFetch');
 
 const { Response } = jest.requireActual('node-fetch') as typeof import('node-fetch');
 
-const TOKEN = 'device-run-session-token-value';
-
-function jsonResponse(body: unknown): InstanceType<typeof Response> {
-  return new Response(JSON.stringify(body), {
-    status: 200,
-    headers: { 'Content-Type': 'application/json' },
-  });
-}
-
-function createCtx(): CustomBuildContext {
-  return {
-    env: { EAS_DEVICE_RUN_SESSION_TOKEN: TOKEN },
-    expoApiV2BaseUrl: 'https://api.expo.test/v2/',
-  } as unknown as CustomBuildContext;
-}
-
 describe(uploadDeviceRunSessionArtifactAsync, () => {
   beforeEach(() => {
     jest.mocked(fetch).mockReset();
-    jest.mocked(turtleFetch).mockReset();
   });
 
   it('streams an artifact through a signed upload URL', async () => {
     const stream = Readable.from(Buffer.from('artifact-data'));
     const reportedSize = 1024;
-    jest.mocked(turtleFetch).mockResolvedValueOnce(
-      jsonResponse({
+    const mutation = jest.fn().mockReturnValue({
+      toPromise: async () => ({
         data: {
-          uploadSession: {
-            url: 'https://uploads.expo.test/artifact',
-            headers: {
-              'Content-Length': String(reportedSize),
-              'Content-Type': 'application/octet-stream',
+          deviceRunSession: {
+            createArtifactUploadSession: {
+              uploadSession: {
+                url: 'https://uploads.expo.test/artifact',
+                headers: {
+                  'Content-Length': String(reportedSize),
+                  'Content-Type': 'application/octet-stream',
+                },
+              },
             },
           },
         },
-      })
-    );
+      }),
+    });
+    const ctx = {
+      graphqlClient: {
+        mutation,
+      },
+    } as unknown as CustomBuildContext;
+
     jest.mocked(fetch).mockResolvedValueOnce(new Response('', { status: 200 }));
 
-    await uploadDeviceRunSessionArtifactAsync(createCtx(), {
+    await uploadDeviceRunSessionArtifactAsync(ctx, {
       deviceRunSessionId: 'drs-id',
       artifactId: 'artifact-id',
       name: 'Artifact report.json (artifact-id)',
@@ -62,20 +52,19 @@ describe(uploadDeviceRunSessionArtifactAsync, () => {
       openStream: () => stream,
     });
 
-    expect(jest.mocked(turtleFetch)).toHaveBeenCalledWith(
-      'https://api.expo.test/v2/device-run-session-worker/artifact-upload-sessions',
-      'POST',
+    expect(mutation).toHaveBeenCalledWith(
+      expect.anything(),
       expect.objectContaining({
-        headers: { [DEVICE_RUN_SESSION_TOKEN_HEADER]: TOKEN },
-        json: {
+        deviceRunSessionId: 'drs-id',
+        input: {
           name: 'Artifact report.json (artifact-id)',
           filename: 'report.json',
           kind: 'agent-device-test-report',
           metadata: { firstFrameRecordAt: 'test-time' },
           size: reportedSize,
         },
-        signal: expect.any(AbortSignal),
-      })
+      }),
+      { fetch: expect.any(Function) }
     );
     expect(jest.mocked(fetch)).toHaveBeenCalledWith(
       'https://uploads.expo.test/artifact',
@@ -88,19 +77,26 @@ describe(uploadDeviceRunSessionArtifactAsync, () => {
 
   it('forwards cancellation through upload allocation and skips PUT when allocation aborts', async () => {
     const controller = new AbortController();
-    jest.mocked(turtleFetch).mockImplementationOnce(async () => {
-      controller.abort();
-      return jsonResponse({
-        data: {
-          uploadSession: {
-            url: 'https://uploads.expo.test/artifact',
-            headers: {},
+    const mutation = jest.fn().mockReturnValue({
+      toPromise: async () => {
+        controller.abort();
+        return {
+          data: {
+            deviceRunSession: {
+              createArtifactUploadSession: {
+                uploadSession: {
+                  url: 'https://uploads.expo.test/artifact',
+                  headers: {},
+                },
+              },
+            },
           },
-        },
-      });
+        };
+      },
     });
+    const ctx = { graphqlClient: { mutation } } as unknown as CustomBuildContext;
     await expect(
-      uploadDeviceRunSessionArtifactAsync(createCtx(), {
+      uploadDeviceRunSessionArtifactAsync(ctx, {
         deviceRunSessionId: 'session',
         artifactId: 'id',
         name: 'Logs',
@@ -112,8 +108,18 @@ describe(uploadDeviceRunSessionArtifactAsync, () => {
       })
     ).rejects.toThrow();
     expect(fetch).not.toHaveBeenCalled();
-    const allocationSignal = jest.mocked(turtleFetch).mock.calls[0][2].signal;
-    expect(allocationSignal).toBeInstanceOf(AbortSignal);
-    expect(allocationSignal?.aborted).toBe(true);
+    const allocationFetch = mutation.mock.calls[0][2].fetch;
+    const mockFetch = jest.spyOn(globalThis, 'fetch').mockRejectedValueOnce(new Error('aborted'));
+    try {
+      await expect(allocationFetch('https://api.expo.test/graphql', {})).rejects.toThrow('aborted');
+      expect(mockFetch).toHaveBeenCalledWith(
+        'https://api.expo.test/graphql',
+        expect.objectContaining({
+          signal: expect.objectContaining({ aborted: true }),
+        })
+      );
+    } finally {
+      mockFetch.mockRestore();
+    }
   });
 });

packages/build-tools/src/steps/utils/__tests__/deviceRunSessionPreview.test.ts

@@ -1,7 +1,7 @@
 import { type bunyan } from '@expo/logger';
 import { BuildRuntimePlatform } from '@expo/steps';
-import { SystemError } from '@expo/eas-build-job';
 import spawn from '@expo/turtle-spawn';
+import { Client, fetchExchange } from '@urql/core';
 import { getEventListeners } from 'node:events';
 import { readFile, readdir, writeFile } from 'node:fs/promises';
 import { Readable } from 'node:stream';
@@ -10,50 +10,20 @@ import fetch from 'node-fetch';
 
 import { type CustomBuildContext } from '../../../customBuildContext';
 import * as processes from '../../../utils/processes';
-import { turtleFetch } from '../../../utils/turtleFetch';
 import {
   captureDeviceRunSessionPreviewAsync,
   ensureMacosPreviewEncoderInstalledAsync,
   startDeviceRunSessionPreview,
 } from '../deviceRunSessionPreview';
-import { DEVICE_RUN_SESSION_TOKEN_HEADER } from '../deviceRunSessionWorkerApi';
 
-jest.mock('node-fetch', () => {
-  const actual = jest.requireActual('node-fetch');
-  return {
-    __esModule: true,
-    ...actual,
-    default: jest.fn(),
-  };
-});
+jest.mock('node-fetch');
 jest.mock('@expo/turtle-spawn');
-jest.mock('../../../utils/turtleFetch');
 const { Response } = jest.requireActual('node-fetch') as typeof import('node-fetch');
 
-const DEVICE_RUN_SESSION_TOKEN = 'device-run-session-token-value';
-const PREVIEW_UPLOAD_SESSION_URL =
-  'https://api.expo.test/v2/device-run-session-worker/preview-upload-session';
-const uploadSession = {
-  url: 'https://uploads.expo.test/preview',
-  headers: { 'content-type': 'image/webp' },
-};
-
-function createCtx(): CustomBuildContext {
-  return {
-    env: { EAS_DEVICE_RUN_SESSION_TOKEN: DEVICE_RUN_SESSION_TOKEN },
-    expoApiV2BaseUrl: 'https://api.expo.test/v2/',
-  } as unknown as CustomBuildContext;
-}
-
-function uploadSessionResponse(): InstanceType<typeof Response> {
-  return new Response(JSON.stringify({ data: { uploadSession } }), {
-    headers: { 'content-type': 'application/json' },
-  });
-}
-
 describe(startDeviceRunSessionPreview, () => {
   const image = Buffer.from('webp-image');
   let captureAsync: jest.Mock<Promise<Buffer>, [AbortSignal]>;
+  let mutation: jest.Mock;
   let logger: bunyan;
   let ctx: CustomBuildContext;
   let preview: ReturnType<typeof startDeviceRunSessionPreview> | undefined;
@@ -61,11 +31,21 @@ describe(startDeviceRunSessionPreview, () => {
   beforeEach(() => {
     jest.useFakeTimers();
     captureAsync = jest.fn().mockResolvedValue(image);
-    jest
-      .mocked(turtleFetch)
-      .mockReset()
-      .mockImplementation(async () => uploadSessionResponse());
-    ctx = createCtx();
+    mutation = jest.fn().mockReturnValue({
+      toPromise: async () => ({
+        data: {
+          deviceRunSession: {
+            createPreviewUploadSession: {
+              uploadSession: {
+                url: 'https://uploads.expo.test/preview',
+                headers: { 'content-type': 'image/webp' },
+              },
+            },
+          },
+        },
+      }),
+    });
+    ctx = { graphqlClient: { mutation } } as unknown as CustomBuildContext;
     logger = { warn: jest.fn() } as unknown as bunyan;
     jest
       .mocked(fetch)
@@ -94,15 +74,15 @@ describe(startDeviceRunSessionPreview, () => {
       'https://uploads.expo.test/preview',
       expect.objectContaining({
         method: 'PUT',
-        body: expect.any(Readable),
-        headers: { 'content-type': 'image/webp', 'content-length': String(image.length) },
+        body: image,
+        headers: { 'content-type': 'image/webp' },
       })
     );
     await jest.advanceTimersByTimeAsync(59_999);
     expect(captureAsync).toHaveBeenCalledTimes(1);
     await jest.advanceTimersByTimeAsync(1);
     expect(captureAsync).toHaveBeenCalledTimes(2);
-    expect(turtleFetch).toHaveBeenCalledTimes(1);
+    expect(mutation).toHaveBeenCalledTimes(1);
     await preview!.stopAsync();
     await jest.advanceTimersByTimeAsync(120_000);
     expect(captureAsync).toHaveBeenCalledTimes(2);
@@ -112,7 +92,7 @@ describe(startDeviceRunSessionPreview, () => {
     captureAsync.mockRejectedValueOnce(new Error('device not ready'));
     start();
     await jest.advanceTimersByTimeAsync(0);
-    expect(turtleFetch).not.toHaveBeenCalled();
+    expect(mutation).not.toHaveBeenCalled();
     expect(logger.warn).toHaveBeenCalled();
     await jest.advanceTimersByTimeAsync(60_000);
     expect(fetch).toHaveBeenCalledTimes(1);
@@ -122,7 +102,7 @@ describe(startDeviceRunSessionPreview, () => {
     jest.mocked(fetch).mockResolvedValueOnce(new Response('', { status: 403 }));
     start();
     await jest.advanceTimersByTimeAsync(60_000);
-    expect(turtleFetch).toHaveBeenCalledTimes(1);
+    expect(mutation).toHaveBeenCalledTimes(1);
     expect(fetch).toHaveBeenCalledTimes(2);
   });
 
@@ -137,14 +117,16 @@ describe(startDeviceRunSessionPreview, () => {
     await jest.advanceTimersByTimeAsync(0);
     expect(logger.warn).toHaveBeenCalledTimes(1);
     const [fields] = jest.mocked(logger.warn).mock.calls[0] as unknown as [{ err: Error }];
-    expect(fields.err.message).toBe('Signed URL upload failed: network error.');
+    expect(fields.err.message).toBe(
+      'Session preview upload request failed (name: FetchError, type: request-timeout).'
+    );
     expect(JSON.stringify(jest.mocked(logger.warn).mock.calls)).not.toContain('uploads.expo.test');
   });
 
   it('reuses the upload URL for the full session', async () => {
     start();
     await jest.advanceTimersByTimeAsync(119 * 60_000);
-    expect(turtleFetch).toHaveBeenCalledTimes(1);
+    expect(mutation).toHaveBeenCalledTimes(1);
   });
 
   it('does not overlap captures and aborts pending work when stopped', async () => {
@@ -174,20 +156,29 @@ describe(startDeviceRunSessionPreview, () => {
     const stopping = handle.stopAsync();
     finish(image);
     await stopping;
-    expect(turtleFetch).not.toHaveBeenCalled();
+    expect(mutation).not.toHaveBeenCalled();
   });
 });
 
-describe('session preview upload session from the worker API', () => {
+describe('session preview with the real GraphQL client', () => {
+  const uploadSession = {
+    url: 'https://uploads.expo.test/preview',
+    headers: { 'content-type': 'image/webp' },
+  };
+  let graphqlFetch: jest.SpyInstance;
   let preview: ReturnType<typeof startDeviceRunSessionPreview> | undefined;
   let logger: bunyan;
 
   beforeEach(() => {
     jest.useFakeTimers();
-    jest
-      .mocked(turtleFetch)
-      .mockReset()
-      .mockImplementation(async () => uploadSessionResponse());
+    graphqlFetch = jest.spyOn(globalThis, 'fetch').mockResolvedValue(
+      new globalThis.Response(
+        JSON.stringify({
+          data: { deviceRunSession: { createPreviewUploadSession: { uploadSession } } },
+        }),
+        { headers: { 'content-type': 'application/json' } }
+      )
+    );
     logger = { warn: jest.fn() } as unknown as bunyan;
     jest
       .mocked(fetch)
@@ -202,9 +193,14 @@ describe('session preview upload session from the worker API', () => {
     jest.useRealTimers();
   });
 
-  const start = (ctx: CustomBuildContext = createCtx()) => {
+  const start = () => {
+    const graphqlClient = new Client({
+      url: 'https://api.expo.test/graphql',
+      exchanges: [fetchExchange],
+      fetchOptions: { headers: { Authorization: 'Bearer worker-token' } },
+    });
     preview = startDeviceRunSessionPreview({
-      ctx,
+      ctx: { graphqlClient } as CustomBuildContext,
       deviceRunSessionId: 'session-id',
       captureAsync: async () => Buffer.from('webp-image'),
       logger,
@@ -212,49 +208,25 @@ describe('session preview upload session from the worker API', () => {
     return preview;
   };
 
-  it('sends the device run session token when creating the upload session', async () => {
+  it('preserves the worker authentication when creating the upload session', async () => {
     start();
     await jest.advanceTimersByTimeAsync(0);
-    expect(turtleFetch).toHaveBeenCalledWith(
-      PREVIEW_UPLOAD_SESSION_URL,
-      'POST',
-      expect.objectContaining({
-        headers: { [DEVICE_RUN_SESSION_TOKEN_HEADER]: DEVICE_RUN_SESSION_TOKEN },
-        signal: expect.any(AbortSignal),
-      })
-    );
+    const [, options] = graphqlFetch.mock.calls[0];
+    expect(new Headers(options.headers).get('authorization')).toBe('Bearer worker-token');
     expect(fetch).toHaveBeenCalledTimes(1);
   });
 
-  it('logs a failure and uploads nothing when the job has no device run session token', async () => {
-    start({
-      env: {},
-      expoApiV2BaseUrl: 'https://api.expo.test/v2/',
-    } as unknown as CustomBuildContext);
-    await jest.advanceTimersByTimeAsync(0);
-    expect(logger.warn).toHaveBeenCalledWith(
-      { err: expect.any(SystemError) },
-      'Could not refresh the session preview; retrying in 60 seconds.'
-    );
-    const [{ err }] = jest.mocked(logger.warn).mock.calls[0] as unknown as [{ err: Error }];
-    expect(err.message).toMatch(
-      /^This device run session job has no EAS_DEVICE_RUN_SESSION_TOKEN secret\./
-    );
-    expect(turtleFetch).not.toHaveBeenCalled();
-    expect(fetch).not.toHaveBeenCalled();
-  });
-
-  it.each(['shutdown', 'timeout'])('aborts a stalled worker API request on %s', async reason => {
+  it.each(['shutdown', 'timeout'])('aborts a stalled GraphQL request on %s', async reason => {
     const timeout = new AbortController();
     jest.spyOn(AbortSignal, 'timeout').mockReturnValue(timeout.signal);
     let requestSignal: AbortSignal | undefined;
     let rejectRequest!: (error: Error) => void;
-    jest.mocked(turtleFetch).mockImplementation(
-      (_url, _method, options) =>
+    graphqlFetch.mockImplementation(
+      (_url, options) =>
         new Promise((_, reject) => {
           rejectRequest = reject;
-          requestSignal = options.signal as AbortSignal;
-          requestSignal.addEventListener('abort', () => reject(requestSignal!.reason), {
+          requestSignal = options.signal;
+          requestSignal!.addEventListener('abort', () => reject(requestSignal!.reason), {
             once: true,
           });
         })
@@ -283,7 +255,14 @@ describe('session preview upload session from the worker API', () => {
       await stopping;
     } else {
       expect(logger.warn).toHaveBeenCalled();
-      jest.mocked(turtleFetch).mockImplementation(async () => uploadSessionResponse());
+      graphqlFetch.mockResolvedValue(
+        new globalThis.Response(
+          JSON.stringify({
+            data: { deviceRunSession: { createPreviewUploadSession: { uploadSession } } },
+          }),
+          { headers: { 'content-type': 'application/json' } }
+        )
+      );
       jest.spyOn(AbortSignal, 'timeout').mockReturnValue(new AbortController().signal);
       await jest.advanceTimersByTimeAsync(60_000);
       expect(fetch).toHaveBeenCalledTimes(1);

packages/build-tools/src/steps/utils/__tests__/deviceRunSessionScreenRecordings.test.ffmpeg.ts

@@ -1,7 +1,8 @@
 import type { bunyan } from '@expo/logger';
 import type { BuildStepEnv } from '@expo/steps';
+import { Client, fetchExchange } from '@urql/core';
 import { execFileSync } from 'node:child_process';
-import { copyFile, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { copyFile, mkdir, mkdtemp, rm, stat, writeFile } from 'node:fs/promises';
 import { type IncomingMessage, type ServerResponse, createServer } from 'node:http';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
@@ -24,27 +25,25 @@ let ctx: CustomBuildContext;
 let url: string;
 let directory: string;
 let creationBodies: string[];
-let creationTokens: (string | undefined)[];
 
 beforeEach(async () => {
   creationBodies = [];
-  creationTokens = [];
   directory = await mkdtemp(path.join(tmpdir(), 'recording-recovery-'));
   server = createServer((request, response) => {
-    if (request.url === '/v2/device-run-session-worker/artifact-upload-sessions') {
+    if (request.url === '/graphql') {
       request.setEncoding('utf8');
       let body = '';
       request.on('data', chunk => (body += chunk));
       request.on('end', () => {
         creationBodies.push(body);
-        creationTokens.push(request.headers['expo-device-run-session-token'] as string | undefined);
         response.setHeader('Content-Type', 'application/json');
         response.end(
           JSON.stringify({
             data: {
-              uploadSession: {
-                url: `${url}/artifact/${encodeURIComponent(JSON.parse(body).filename)}`,
-                headers: {},
+              deviceRunSession: {
+                createArtifactUploadSession: {
+                  uploadSession: { url: `${url}/artifact`, headers: {} },
+                },
               },
             },
           })
@@ -61,9 +60,12 @@ beforeEach(async () => {
   }
   url = `http://127.0.0.1:${address.port}`;
   ctx = {
-    env: { EAS_DEVICE_RUN_SESSION_TOKEN: 'session-token' },
-    expoApiV2BaseUrl: `${url}/v2/`,
-  } as unknown as CustomBuildContext;
+    graphqlClient: new Client({
+      url: `${url}/graphql`,
+      exchanges: [fetchExchange],
+      fetchOptions: { headers: { Authorization: 'Bearer test-auth' } },
+    }),
+  } as CustomBuildContext;
 });
 
 afterEach(async () => {
@@ -163,14 +165,10 @@ it('recovers unlisted recordings from a killed host and flags the unfinished one
   ]);
   expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('empty/recording.mp4.partial'));
 
-  const uploaded = new Map<string, Buffer>();
+  let putBytes = 0;
   handle = (request, response) => {
-    const chunks: Buffer[] = [];
-    request.on('data', chunk => {
-      chunks.push(chunk);
-    });
+    request.on('data', chunk => (putBytes += chunk.length));
     request.on('end', () => {
-      uploaded.set(request.url!, Buffer.concat(chunks));
       response.statusCode = 200;
       response.end();
     });
@@ -182,18 +180,9 @@ it('recovers unlisted recordings from a killed host and flags the unfinished one
       recordings,
     })
   ).resolves.toBe(true);
-  for (const recording of recordings) {
-    const manifest = await readFile(path.join(recording.directory, 'session.json'));
-    const recordingId = path.basename(recording.directory);
-    expect(uploaded.get(`/artifact/${recordingId}.json`)).toEqual(manifest);
-    expect(uploaded.get(`/artifact/${recordingId}.mp4`)).toEqual(
-      await readFile(path.join(recording.directory, JSON.parse(manifest.toString()).recording))
-    );
-  }
-  expect(creationTokens).toEqual(Array(6).fill('session-token'));
+  expect(putBytes).toBe(3 * (await stat(path.join(cut, 'recording.mp4.partial'))).size);
   const inputs = creationBodies
-    .map(body => JSON.parse(body))
-    .filter(input => input.kind === 'screen-recording')
+    .map(body => JSON.parse(body).variables.input)
     .sort((a, b) => a.filename.localeCompare(b.filename));
   expect(inputs.map(input => input.filename)).toEqual(['cut.mp4', 'done.mp4', 'failed.mp4']);
   expect(inputs.map(input => input.name.includes(', partial)'))).toEqual([true, false, true]);
@@ -204,16 +193,6 @@ it('recovers unlisted recordings from a killed host and flags the unfinished one
     width: 128,
     height: 96,
   });
-  const manifests = creationBodies
-    .map(body => JSON.parse(body))
-    .filter(input => input.kind === 'screen-recording-metadata')
-    .sort((a, b) => a.filename.localeCompare(b.filename));
-  expect(manifests.map(input => input.filename)).toEqual(['cut.json', 'done.json', 'failed.json']);
-  expect(manifests.map(input => input.metadata.recordingFilename)).toEqual([
-    'cut.mp4',
-    'done.mp4',
-    'failed.mp4',
-  ]);
   expect(inputs[2].metadata).toMatchObject({
     partial: true,
     partialReason: 'Recording finalization exceeded 30000 ms.',

packages/build-tools/src/steps/utils/__tests__/deviceRunSessionScreenRecordings.test.ts

@@ -1,141 +0,0 @@
-import type { bunyan } from '@expo/logger';
-import { vol } from 'memfs';
-import { writeFile } from 'node:fs/promises';
-
-import type { CustomBuildContext } from '../../../customBuildContext';
-import { Sentry } from '../../../sentry';
-import { uploadDeviceRunSessionArtifactAsync } from '../deviceRunSessionArtifacts';
-import { uploadDeviceRunSessionScreenRecordingsAsync } from '../deviceRunSessionScreenRecordings';
-
-jest.mock('../deviceRunSessionArtifacts');
-jest.mock('../../../sentry');
-
-const logger = { info: jest.fn(), warn: jest.fn() } as unknown as bunyan;
-const ctx = {} as CustomBuildContext;
-const recording = {
-  udid: 'simulator-id',
-  deviceName: 'iPhone Duo',
-  runtimeDisplayName: 'iOS 27.1',
-  directory: '/recordings/recording-id',
-};
-const manifest = {
-  firstFrameWallClock: { unixMs: 1_791_072_000_000, iso8601: '2026-10-04T00:00:00.000Z' },
-  width: 1440,
-  height: 1200,
-  recording: 'recording.mp4',
-};
-
-beforeEach(() => {
-  jest.mocked(uploadDeviceRunSessionArtifactAsync).mockReset().mockResolvedValue(undefined);
-});
-
-it.each([
-  {},
-  {
-    deviceStates: [
-      {
-        timeMs: 12.5,
-        state: {
-          width: 1200,
-          height: 1440,
-          orientation: 'landscape-left',
-          screen: 'inner',
-          hingeAngle: 90,
-          physicalOrientation: 'portrait',
-          tableMode: false,
-          contentRect: { x: 220, y: 0, width: 1000, height: 1200 },
-        },
-      },
-    ],
-    interruptions: [{ reason: 'simulatorReboot', pausedAtSeconds: 1, resumedAtSeconds: 2 }],
-    futureField: { label: '서울 🌲' },
-  },
-])('uploads the complete manifest unchanged beside its video (%j)', async extra => {
-  const contents = Buffer.from(JSON.stringify({ ...manifest, ...extra }, null, 2) + '\n');
-  vol.fromJSON({
-    [recording.directory + '/session.json']: contents.toString(),
-    [recording.directory + '/recording.mp4']: 'video',
-  });
-  jest.mocked(uploadDeviceRunSessionArtifactAsync).mockImplementation(async (_, input) => {
-    if (input.kind === 'screen-recording') {
-      await writeFile(recording.directory + '/session.json', '{}');
-    }
-  });
-
-  await expect(
-    uploadDeviceRunSessionScreenRecordingsAsync(ctx, {
-      logger,
-      deviceRunSessionId: 'session-id',
-      recordings: [recording],
-    })
-  ).resolves.toBe(true);
-
-  const inputs = jest
-    .mocked(uploadDeviceRunSessionArtifactAsync)
-    .mock.calls.map(([, input]) => input);
-  expect(inputs.map(input => input.filename)).toEqual(['recording-id.mp4', 'recording-id.json']);
-  expect(inputs[1]).toMatchObject({
-    deviceRunSessionId: 'session-id',
-    artifactId: 'recording-id-metadata',
-    kind: 'screen-recording-metadata',
-    metadata: {
-      __eas_type: 'screen-recording-metadata',
-      recordingFilename: 'recording-id.mp4',
-      udid: recording.udid,
-    },
-    size: contents.length,
-  });
-  for (let attempt = 0; attempt < 2; attempt++) {
-    const chunks: Buffer[] = [];
-    for await (const chunk of inputs[1].openStream()) {
-      chunks.push(Buffer.from(chunk));
-    }
-    expect(Buffer.concat(chunks)).toEqual(contents);
-  }
-});
-
-it('reports a metadata upload failure while keeping the video and uploading other recordings', async () => {
-  const other = { ...recording, directory: '/recordings/other-recording', udid: 'other-device' };
-  for (const item of [recording, other]) {
-    vol.fromJSON({
-      [item.directory + '/session.json']: JSON.stringify(manifest),
-      [item.directory + '/recording.mp4']: 'video',
-    });
-  }
-  jest.mocked(uploadDeviceRunSessionArtifactAsync).mockImplementation(async (_, input) => {
-    if (input.filename === 'recording-id.json') {
-      throw new Error('Storage unavailable');
-    }
-  });
-
-  await expect(
-    uploadDeviceRunSessionScreenRecordingsAsync(ctx, {
-      logger,
-      deviceRunSessionId: 'session-id',
-      recordings: [recording, other],
-    })
-  ).resolves.toBe(false);
-
-  expect(
-    jest.mocked(uploadDeviceRunSessionArtifactAsync).mock.calls.map(([, input]) => input.filename)
-  ).toEqual(
-    expect.arrayContaining([
-      'recording-id.mp4',
-      'recording-id.json',
-      'other-recording.mp4',
-      'other-recording.json',
-    ])
-  );
-  expect(Sentry.capture).toHaveBeenCalledWith(
-    'Could not upload device screen recording metadata',
-    expect.any(Error)
-  );
-  expect(Sentry.capture).not.toHaveBeenCalledWith(
-    'Could not upload device screen recording',
-    expect.any(Error)
-  );
-  expect(logger.warn).toHaveBeenCalledWith(
-    expect.objectContaining({ err: expect.any(Error) }),
-    `Could not upload screen recording metadata for ${recording.deviceName}.`
-  );
-});

packages/build-tools/src/steps/utils/__tests__/deviceRunSessionScreenshotsHttp.test.ts

@@ -1,5 +1,5 @@
 import type { bunyan } from '@expo/logger';
-import { BuildRuntimePlatform } from '@expo/steps';
+import { Client, fetchExchange } from '@urql/core';
 import { mkdtemp, rm, stat, writeFile } from 'node:fs/promises';
 import { type IncomingMessage, type ServerResponse, createServer } from 'node:http';
 import { tmpdir } from 'node:os';
@@ -10,7 +10,6 @@ import {
   screenshotArtifactDetails,
 } from '../deviceRunSessionScreenshotNames';
 import { uploadDeviceRunSessionScreenshotsAsync } from '../deviceRunSessionScreenshots';
-import { DEVICE_RUN_SESSION_TOKEN_HEADER } from '../deviceRunSessionWorkerApi';
 jest.unmock('node-fetch');
 jest.mock('../../../sentry');
 function deferred<T>() {
@@ -27,7 +26,7 @@ let ctx: CustomBuildContext;
 let url: string;
 let directory: string;
 let creates: number;
-let deviceRunSessionToken: string | string[] | undefined;
+let authorization: string | undefined;
 let stallCreation: boolean;
 let creationStarted: ReturnType<typeof deferred<IncomingMessage>>;
 let creationBodies: string[];
@@ -41,32 +40,42 @@ beforeEach(async () => {
   sessionLookups = 0;
   sessionLookupFails = false;
   uploadQuery = '';
-  deviceRunSessionToken = undefined;
+  authorization = undefined;
   stallCreation = false;
   creationBodies = [];
   creationStarted = deferred();
   directory = await mkdtemp(path.join(tmpdir(), 'recording-upload-http-'));
   server = createServer((request, response) => {
-    if (request.url?.startsWith('/v2/device-run-session-worker/')) {
-      deviceRunSessionToken = request.headers[DEVICE_RUN_SESSION_TOKEN_HEADER];
+    if (request.url?.startsWith('/graphql')) {
+      authorization = request.headers.authorization;
       request.setEncoding('utf8');
       let body = '';
+      if (request.method === 'GET') {
+        const requestUrl = new URL(request.url, 'http://localhost');
+        body = JSON.stringify({ query: requestUrl.searchParams.get('query') });
+      }
       request.on('data', chunk => (body += chunk));
       request.on('end', () => {
-        if (request.url === '/v2/device-run-session-worker/application') {
+        const operation = JSON.parse(body);
+        if (operation.query.includes('query ScreenshotSession')) {
           sessionLookups++;
           response.setHeader('Content-Type', 'application/json');
           if (sessionLookupFails) {
-            response.statusCode = 503;
             response.end(JSON.stringify({ errors: [{ message: 'Lookup unavailable' }] }));
           } else {
             response.end(
               JSON.stringify({
                 data: {
-                  build: {
-                    id: 'installed-build',
-                    gitCommitHash: installedCommit,
-                    applicationArchiveUrl: null,
+                  deviceRunSessions: {
+                    byId: {
+                      platform: 'IOS',
+                      app: { slug: 'session-project' },
+                      build: {
+                        id: 'installed-build',
+                        gitCommitHash: installedCommit,
+                        app: { slug: 'my-app' },
+                      },
+                    },
                   },
                 },
               })
@@ -83,7 +92,13 @@ beforeEach(async () => {
         response.setHeader('Content-Type', 'application/json');
         response.end(
           JSON.stringify({
-            data: { uploadSession: { url: `${url}/artifact${uploadQuery}`, headers: {} } },
+            data: {
+              deviceRunSession: {
+                createArtifactUploadSession: {
+                  uploadSession: { url: `${url}/artifact${uploadQuery}`, headers: {} },
+                },
+              },
+            },
           })
         );
       });
@@ -98,10 +113,12 @@ beforeEach(async () => {
   }
   url = `http://127.0.0.1:${address.port}`;
   ctx = {
-    env: { EAS_DEVICE_RUN_SESSION_TOKEN: 'test-device-run-session-token' },
-    expoApiV2BaseUrl: `${url}/v2/`,
-    runtimePlatform: BuildRuntimePlatform.DARWIN,
-  } as unknown as CustomBuildContext;
+    graphqlClient: new Client({
+      url: `${url}/graphql`,
+      exchanges: [fetchExchange],
+      fetchOptions: { headers: { Authorization: 'Bearer test-auth' } },
+    }),
+  } as CustomBuildContext;
 });
 
 afterEach(async () => {
@@ -110,7 +127,7 @@ afterEach(async () => {
   await rm(directory, { recursive: true, force: true });
 });
 
-it('publishes a manual preview PNG through the worker API and HTTP upload path', async () => {
+it('publishes a manual preview PNG through the artifact GraphQL and HTTP upload path', async () => {
   const payload = Buffer.from(
     'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aF9sAAAAASUVORK5CYII=',
     'base64'
@@ -140,20 +157,25 @@ it('publishes a manual preview PNG through the worker API and HTTP upload path',
   expect(bodies).toEqual([payload]);
   expect(creates).toBe(1);
   expect(sessionLookups).toBe(1);
-  expect(deviceRunSessionToken).toBe('test-device-run-session-token');
-  // The worker API does not return the app slug, so the filename starts with the platform.
-  expect(JSON.parse(creationBodies[0])).toEqual({
-    name: 'Screenshot 2026-09-24 08:45:59 UTC',
-    filename: 'ios-a1b2c3d-2026-09-24T08-45-59-123Z.png',
-    kind: 'screenshot',
-    size: payload.length,
-    metadata: {
-      __eas_type: 'screenshot',
-      platform: 'ios',
-      buildId: 'installed-build',
-      gitCommitHash: installedCommit,
-    },
-  });
+  expect(authorization).toBe('Bearer test-auth');
+  expect(JSON.parse(creationBodies[0]).variables).toEqual(
+    expect.objectContaining({
+      deviceRunSessionId: 'drs-id',
+      input: expect.objectContaining({
+        name: 'Screenshot 2026-09-24 08:45:59 UTC',
+        filename: 'my-app-ios-a1b2c3d-2026-09-24T08-45-59-123Z.png',
+        kind: 'screenshot',
+        size: payload.length,
+        metadata: {
+          __eas_type: 'screenshot',
+          appSlug: 'my-app',
+          platform: 'ios',
+          buildId: 'installed-build',
+          gitCommitHash: installedCommit,
+        },
+      }),
+    })
+  );
   await expect(stat(path.join(directory, filename))).rejects.toMatchObject({ code: 'ENOENT' });
 });
 
@@ -184,7 +206,7 @@ it('rereads the PNG when the artifact PUT is retried', async () => {
   await expect(stat(path.join(directory, filename))).rejects.toMatchObject({ code: 'ENOENT' });
 });
 
-it('aborts a stalled worker API upload session request and keeps the PNG', async () => {
+it('aborts a stalled GraphQL upload request and keeps the PNG', async () => {
   stallCreation = true;
   const filename = 'screenshot-2026-09-24T08-45-59-123Z-a1b2c3d4e5f6.png';
   await writeFile(path.join(directory, filename), 'png');

packages/build-tools/src/steps/utils/__tests__/deviceRunSessionUploadHttp.test.ts

@@ -1,5 +1,6 @@
 import type { bunyan } from '@expo/logger';
 import type { BuildStepEnv } from '@expo/steps';
+import { Client, fetchExchange } from '@urql/core';
 import { createReadStream } from 'node:fs';
 import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { type IncomingMessage, type ServerResponse, createServer } from 'node:http';
@@ -12,7 +13,6 @@ import { setTimeout as delay } from 'node:timers/promises';
 import type { CustomBuildContext } from '../../../customBuildContext';
 import { uploadDeviceRunSessionArtifactAsync } from '../deviceRunSessionArtifacts';
 import { findUnlistedDeviceScreenRecordingsAsync } from '../deviceRunSessionScreenRecordings';
-import { DEVICE_RUN_SESSION_TOKEN_HEADER } from '../deviceRunSessionWorkerApi';
 
 jest.unmock('node-fetch');
 jest.unmock('node:fs');
@@ -40,20 +40,20 @@ let ctx: CustomBuildContext;
 let url: string;
 let directory: string;
 let creates: number;
-let deviceRunSessionToken: string | string[] | undefined;
+let authorization: string | undefined;
 let stallCreation: boolean;
 let creationStarted: ReturnType<typeof deferred<IncomingMessage>>;
 
 beforeEach(async () => {
   creates = 0;
-  deviceRunSessionToken = undefined;
+  authorization = undefined;
   stallCreation = false;
   creationStarted = deferred();
   directory = await mkdtemp(path.join(tmpdir(), 'recording-upload-http-'));
   server = createServer((request, response) => {
-    if (request.url === '/v2/device-run-session-worker/artifact-upload-sessions') {
+    if (request.url === '/graphql') {
       creates++;
-      deviceRunSessionToken = request.headers[DEVICE_RUN_SESSION_TOKEN_HEADER];
+      authorization = request.headers.authorization;
       creationStarted.resolve(request);
       request.resume();
       request.on('end', () => {
@@ -63,7 +63,13 @@ beforeEach(async () => {
         response.setHeader('Content-Type', 'application/json');
         response.end(
           JSON.stringify({
-            data: { uploadSession: { url: `${url}/artifact`, headers: {} } },
+            data: {
+              deviceRunSession: {
+                createArtifactUploadSession: {
+                  uploadSession: { url: `${url}/artifact`, headers: {} },
+                },
+              },
+            },
           })
         );
       });
@@ -78,9 +84,12 @@ beforeEach(async () => {
   }
   url = `http://127.0.0.1:${address.port}`;
   ctx = {
-    env: { EAS_DEVICE_RUN_SESSION_TOKEN: 'test-device-run-session-token' },
-    expoApiV2BaseUrl: `${url}/v2/`,
-  } as unknown as CustomBuildContext;
+    graphqlClient: new Client({
+      url: `${url}/graphql`,
+      exchanges: [fetchExchange],
+      fetchOptions: { headers: { Authorization: 'Bearer test-auth' } },
+    }),
+  } as CustomBuildContext;
 });
 
 afterEach(async () => {
@@ -117,7 +126,7 @@ it('replays the full file after a transient PUT failure without recreating the u
     attempts: 3,
   });
   expect(creates).toBe(1);
-  expect(deviceRunSessionToken).toBe('test-device-run-session-token');
+  expect(authorization).toBe('Bearer test-auth');
   expect(bodies).toEqual([payload, payload]);
   expect(streams).toHaveLength(2);
   expect(streams.every(stream => stream.destroyed)).toBe(true);
@@ -272,7 +281,7 @@ it.each([200, 400, 503])(
   }
 );
 
-it('cancels worker API session creation with the token intact and never starts a PUT', async () => {
+it('cancels urql session creation with auth intact and never starts a PUT', async () => {
   stallCreation = true;
   const puts = jest.fn();
   handle = puts;
@@ -289,7 +298,7 @@ it('cancels worker API session creation with the token intact and never starts a
   controller.abort(new Error('test cancellation'));
   await rejected;
   await closed;
-  expect(deviceRunSessionToken).toBe('test-device-run-session-token');
+  expect(authorization).toBe('Bearer test-auth');
   expect(creates).toBe(1);
   expect(puts).not.toHaveBeenCalled();
   expect(openStream).not.toHaveBeenCalled();

packages/build-tools/src/steps/utils/__tests__/deviceRunSessionWorkerApi.test.ts

@@ -1,5 +1,4 @@
 import { SystemError } from '@expo/eas-build-job';
-import { FetchError } from 'node-fetch';
 
 import { CustomBuildContext } from '../../../customBuildContext';
 import { turtleFetch } from '../../../utils/turtleFetch';
@@ -8,11 +7,9 @@ import {
   DeviceRunSessionWorkerApi,
   DeviceRunSessionWorkerApiError,
   getDeviceRunSessionWorkerApi,
-  requireDeviceRunSessionWorkerApi,
 } from '../deviceRunSessionWorkerApi';
 
 jest.mock('../../../utils/turtleFetch');
-jest.unmock('node-fetch');
 
 const { Response } = jest.requireActual('node-fetch') as typeof import('node-fetch');
 type Response = InstanceType<typeof Response>;
@@ -91,36 +88,6 @@ describe(getDeviceRunSessionWorkerApi, () => {
   });
 });
 
-describe(requireDeviceRunSessionWorkerApi, () => {
-  it('returns the client when the job has a device run session token', () => {
-    expect(
-      requireDeviceRunSessionWorkerApi({
-        env: { EAS_DEVICE_RUN_SESSION_TOKEN: TOKEN },
-        expoApiV2BaseUrl: BASE_URL,
-      } as unknown as CustomBuildContext)
-    ).toBeInstanceOf(DeviceRunSessionWorkerApi);
-  });
-
-  it('throws a system error when the job has no device run session token', () => {
-    const error = (() => {
-      try {
-        requireDeviceRunSessionWorkerApi({
-          env: { __API_SERVER_URL: 'https://api.expo.test' },
-          expoApiV2BaseUrl: BASE_URL,
-        } as unknown as CustomBuildContext);
-      } catch (err) {
-        return err;
-      }
-      return undefined;
-    })();
-
-    expect(error).toBeInstanceOf(SystemError);
-    expect((error as Error).message).toMatch(
-      /^This device run session job has no EAS_DEVICE_RUN_SESSION_TOKEN secret\./
-    );
-  });
-});
-
 describe(DeviceRunSessionWorkerApi, () => {
   beforeEach(() => {
     jest.mocked(turtleFetch).mockReset();
@@ -134,7 +101,7 @@ describe(DeviceRunSessionWorkerApi, () => {
       route: 'session',
       json: undefined,
       data: { id: 'drs-id', status: 'in-progress' },
-      expected: { id: 'drs-id', status: 'in-progress' },
+      expected: { id: 'drs-id', status: 'IN_PROGRESS' },
     },
     {
       name: 'startAsync',
@@ -144,7 +111,7 @@ describe(DeviceRunSessionWorkerApi, () => {
       route: 'start',
       json: { remoteConfig: { type: 'agent-device', url: 'https://x.test' } },
       data: { id: 'drs-id', status: 'in-progress' },
-      expected: { id: 'drs-id', status: 'in-progress' },
+      expected: { id: 'drs-id', status: 'IN_PROGRESS' },
     },
     {
       name: 'stopAsync',
@@ -153,7 +120,7 @@ describe(DeviceRunSessionWorkerApi, () => {
       route: 'stop',
       json: undefined,
       data: { id: 'drs-id', status: 'stopped' },
-      expected: { id: 'drs-id', status: 'stopped' },
+      expected: { id: 'drs-id', status: 'STOPPED' },
     },
     {
       name: 'createArtifactUploadSessionAsync',
@@ -250,26 +217,30 @@ describe(DeviceRunSessionWorkerApi, () => {
     }
   );
 
-  it.each(['new', 'queued', 'starting', 'in-progress', 'stopped', 'errored'])(
-    'returns the www status %s unchanged',
-    async status => {
-      jest
-        .mocked(turtleFetch)
-        .mockResolvedValueOnce(jsonResponse({ data: { id: 'drs-id', status } }));
+  it.each([
+    ['new', 'NEW'],
+    ['queued', 'QUEUED'],
+    ['starting', 'STARTING'],
+    ['in-progress', 'IN_PROGRESS'],
+    ['stopped', 'STOPPED'],
+    ['errored', 'ERRORED'],
+  ])('maps the www status %s to the GraphQL status %s', async (wwwStatus, status) => {
+    jest
+      .mocked(turtleFetch)
+      .mockResolvedValueOnce(jsonResponse({ data: { id: 'drs-id', status: wwwStatus } }));
 
-      await expect(createApi().getSessionAsync()).resolves.toEqual({ id: 'drs-id', status });
-    }
-  );
+    await expect(createApi().getSessionAsync()).resolves.toEqual({ id: 'drs-id', status });
+  });
 
   it('rejects an application response without the build field', async () => {
     jest.mocked(turtleFetch).mockResolvedValueOnce(jsonResponse({ data: { platform: 'ios' } }));
 
-    await expect(createApi().getApplicationAsync({ retries: 3 })).rejects.toThrow(
+    await expect(createApi().getApplicationAsync()).rejects.toThrow(
       'GET /v2/device-run-session-worker/application returned an unexpected response'
     );
   });
 
-  it('passes the signal and timeout without enabling nested retries', async () => {
+  it('passes the signal, timeout, and retries to the request', async () => {
     jest.mocked(turtleFetch).mockResolvedValueOnce(jsonResponse({ data: { iceServers: [] } }));
     const controller = new AbortController();
 
@@ -282,7 +253,7 @@ describe(DeviceRunSessionWorkerApi, () => {
     expect(jest.mocked(turtleFetch)).toHaveBeenCalledWith(
       expect.any(String),
       'POST',
-      expect.objectContaining({ signal: controller.signal, timeout: 5000, retries: 0 })
+      expect.objectContaining({ signal: controller.signal, timeout: 5000, retries: 1 })
     );
   });
 
@@ -321,7 +292,7 @@ describe(DeviceRunSessionWorkerApi, () => {
       );
 
     const error = await createApi()
-      .getSessionAsync({ retries: 0 })
+      .getSessionAsync()
       .catch(err => err);
 
     expect(error).toBeInstanceOf(DeviceRunSessionWorkerApiError);
@@ -332,16 +303,14 @@ describe(DeviceRunSessionWorkerApi, () => {
   });
 
   it('reports a request that failed before www responded', async () => {
-    const reason = new Error('socket hang up');
-    jest.mocked(turtleFetch).mockRejectedValueOnce(reason);
+    jest.mocked(turtleFetch).mockRejectedValueOnce(new Error('socket hang up'));
 
     const error = await createApi()
-      .getSessionAsync({ retries: 0 })
+      .getSessionAsync()
       .catch(err => err);
 
     expect(error).toBeInstanceOf(DeviceRunSessionWorkerApiError);
     expect(error.status).toBeUndefined();
-    expect(error.cause).toBe(reason);
     expect(error.message).toContain('failed before www responded: socket hang up');
   });
 
@@ -350,7 +319,7 @@ describe(DeviceRunSessionWorkerApi, () => {
       .mocked(turtleFetch)
       .mockResolvedValueOnce(jsonResponse({ data: { id: 'drs-id', status: 'STOPPED' } }));
 
-    await expect(createApi().getSessionAsync({ retries: 3 })).rejects.toThrow(
+    await expect(createApi().getSessionAsync()).rejects.toThrow(
       'GET /v2/device-run-session-worker/session returned an unexpected response'
     );
   });
@@ -358,183 +327,8 @@ describe(DeviceRunSessionWorkerApi, () => {
   it('rejects a successful response that is not JSON', async () => {
     jest.mocked(turtleFetch).mockResolvedValueOnce(new Response('ok', { status: 200 }));
 
-    await expect(createApi().getSessionAsync({ retries: 3 })).rejects.toThrow(
+    await expect(createApi().getSessionAsync()).rejects.toThrow(
       'GET /v2/device-run-session-worker/session returned a response that is not JSON.'
     );
   });
 });
-
-describe('device run session worker API retries', () => {
-  beforeEach(() => {
-    jest.useFakeTimers();
-    jest.mocked(turtleFetch).mockReset();
-  });
-
-  afterEach(() => {
-    jest.useRealTimers();
-  });
-
-  it.each([429, 500, 502, 503, 504])(
-    'recovers from HTTP %s when starting a session',
-    async status => {
-      jest
-        .mocked(turtleFetch)
-        .mockResolvedValueOnce(new Response('unavailable', { status }))
-        .mockResolvedValueOnce(jsonResponse({ data: { id: 'drs-id', status: 'in-progress' } }));
-      const result = createApi().startAsync(
-        { remoteConfig: { url: 'https://preview.test' } },
-        { retries: 3, timeoutMs: 30_000 }
-      );
-      const assertion = expect(result).resolves.toEqual({ id: 'drs-id', status: 'in-progress' });
-      await jest.runAllTimersAsync();
-      await assertion;
-      expect(turtleFetch).toHaveBeenCalledTimes(2);
-      expect(jest.mocked(turtleFetch).mock.calls[1]).toEqual(
-        jest.mocked(turtleFetch).mock.calls[0]
-      );
-      expect(jest.mocked(turtleFetch).mock.calls[0][2]).toMatchObject({
-        retries: 0,
-        timeout: 30_000,
-      });
-    }
-  );
-
-  it('recovers from a network failure', async () => {
-    jest
-      .mocked(turtleFetch)
-      .mockRejectedValueOnce(new Error('socket hang up'))
-      .mockResolvedValueOnce(jsonResponse({ data: { build: null } }));
-    const assertion = expect(createApi().getApplicationAsync({ retries: 3 })).resolves.toEqual({
-      build: null,
-    });
-    await jest.runAllTimersAsync();
-    await assertion;
-    expect(turtleFetch).toHaveBeenCalledTimes(2);
-  });
-
-  it('exhausts three retries with exponential backoff', async () => {
-    jest
-      .mocked(turtleFetch)
-      .mockImplementation(async () => new Response('unavailable', { status: 503 }));
-    const assertion = expect(
-      createApi().startAsync({ remoteConfig: {} }, { retries: 3 })
-    ).rejects.toMatchObject({
-      status: 503,
-    });
-    await jest.advanceTimersByTimeAsync(0);
-    expect(turtleFetch).toHaveBeenCalledTimes(1);
-    await jest.advanceTimersByTimeAsync(1000);
-    expect(turtleFetch).toHaveBeenCalledTimes(2);
-    await jest.advanceTimersByTimeAsync(2000);
-    expect(turtleFetch).toHaveBeenCalledTimes(3);
-    await jest.advanceTimersByTimeAsync(4000);
-    await assertion;
-    expect(turtleFetch).toHaveBeenCalledTimes(4);
-  });
-
-  it.each([400, 401, 403, 404, 409])('does not retry HTTP %s', async status => {
-    jest.mocked(turtleFetch).mockResolvedValueOnce(new Response('refused', { status }));
-    await expect(
-      createApi().startAsync({ remoteConfig: {} }, { retries: 3 })
-    ).rejects.toMatchObject({ status });
-    expect(turtleFetch).toHaveBeenCalledTimes(1);
-  });
-
-  it.each([
-    ['status polling', (api: DeviceRunSessionWorkerApi) => api.getSessionAsync()],
-    ['stop', (api: DeviceRunSessionWorkerApi) => api.stopAsync()],
-    [
-      'screenshot application metadata',
-      (api: DeviceRunSessionWorkerApi) => api.getApplicationAsync(),
-    ],
-    ['event log setup', (api: DeviceRunSessionWorkerApi) => api.createEventLogUploadSessionAsync()],
-    ['preview setup', (api: DeviceRunSessionWorkerApi) => api.createPreviewUploadSessionAsync()],
-    [
-      'TURN without an explicit retry option',
-      (api: DeviceRunSessionWorkerApi) => api.fetchTurnIceServersAsync(),
-    ],
-  ])('does not retry %s by default', async (_name, call) => {
-    jest.mocked(turtleFetch).mockResolvedValueOnce(new Response('unavailable', { status: 503 }));
-    await expect(call(createApi())).rejects.toMatchObject({ status: 503 });
-    expect(turtleFetch).toHaveBeenCalledTimes(1);
-  });
-
-  it('honors an explicit retry count', async () => {
-    jest
-      .mocked(turtleFetch)
-      .mockImplementation(async () => new Response('unavailable', { status: 503 }));
-    const assertion = expect(
-      createApi().fetchTurnIceServersAsync({ retries: 1 })
-    ).rejects.toMatchObject({ status: 503 });
-    await jest.runAllTimersAsync();
-    await assertion;
-    expect(turtleFetch).toHaveBeenCalledTimes(2);
-  });
-
-  it('does not send another request after cancellation during backoff', async () => {
-    const controller = new AbortController();
-    jest.mocked(turtleFetch).mockResolvedValueOnce(new Response('unavailable', { status: 503 }));
-    const assertion = expect(
-      createApi().getApplicationAsync({ signal: controller.signal, retries: 3 })
-    ).rejects.toMatchObject({ name: 'AbortError' });
-    await jest.advanceTimersByTimeAsync(0);
-    controller.abort();
-    await jest.runAllTimersAsync();
-    await assertion;
-    expect(turtleFetch).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe('device run session retry safety', () => {
-  beforeEach(() => {
-    jest.mocked(turtleFetch).mockReset();
-  });
-
-  it('does not replay artifact creation after a transient failure', async () => {
-    jest.mocked(turtleFetch).mockResolvedValueOnce(new Response('unavailable', { status: 503 }));
-    await expect(
-      createApi().createArtifactUploadSessionAsync({
-        name: 'report',
-        filename: 'report.json',
-        size: 1,
-      })
-    ).rejects.toMatchObject({ status: 503 });
-    expect(turtleFetch).toHaveBeenCalledTimes(1);
-  });
-
-  it('does not send an already cancelled request', async () => {
-    const controller = new AbortController();
-    controller.abort();
-    await expect(
-      createApi().getApplicationAsync({ signal: controller.signal, retries: 3 })
-    ).rejects.toMatchObject({
-      name: 'AbortError',
-    });
-    expect(turtleFetch).not.toHaveBeenCalled();
-  });
-
-  it.each(['system', 'body-timeout'])(
-    'retries a response body transport failure (%s)',
-    async type => {
-      jest.useFakeTimers();
-      try {
-        const response = jsonResponse({});
-        jest
-          .spyOn(response, 'json')
-          .mockRejectedValueOnce(new FetchError('connection interrupted', type));
-        jest
-          .mocked(turtleFetch)
-          .mockResolvedValueOnce(response)
-          .mockResolvedValueOnce(jsonResponse({ data: { id: 'drs-id', status: 'in-progress' } }));
-        const assertion = expect(
-          createApi().startAsync({ remoteConfig: {} }, { retries: 3 })
-        ).resolves.toMatchObject({ status: 'in-progress' });
-        await jest.runAllTimersAsync();
-        await assertion;
-        expect(turtleFetch).toHaveBeenCalledTimes(2);
-      } finally {
-        jest.useRealTimers();
-      }
-    }
-  );
-});

packages/build-tools/src/steps/utils/__tests__/deviceRunSessionWorkerApiCallers.test.ts

@@ -1,6 +1,6 @@
 import { SystemError } from '@expo/eas-build-job';
 import { type bunyan } from '@expo/logger';
-import { BuildRuntimePlatform } from '@expo/steps';
+import { BuildRuntimePlatform, type BuildStepEnv } from '@expo/steps';
 import fetch from 'node-fetch';
 import { Readable } from 'node:stream';
 import { setImmediate } from 'node:timers/promises';
@@ -105,6 +105,8 @@ async function waitForCallAsync(mock: jest.Mock): Promise<void> {
   }
 }
 
+const env = { DEVICE_RUN_SESSION_ID: 'drs-id' } as unknown as BuildStepEnv;
+
 const eventSource = {
   producer: 'test-producer',
   findEventFilesAsync: async () => [],
@@ -151,11 +153,10 @@ describe('with a device run session token', () => {
     expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
   });
 
-  it('retries a transient failure when starting the session through the worker API', async () => {
+  it('starts the session through the worker API', async () => {
     const ctx = createCtx({ withToken: true });
     jest
       .mocked(turtleFetch)
-      .mockResolvedValueOnce(jsonResponse({ errors: [{ message: 'Service unavailable' }] }, 503))
       .mockResolvedValueOnce(jsonResponse({ data: { id: 'drs-id', status: 'in-progress' } }));
 
     await uploadRemoteSessionConfigAsync({
@@ -166,7 +167,6 @@ describe('with a device run session token', () => {
     });
 
     expectWorkerApiCall('start', 'POST', { json: { remoteConfig: { type: 'agent-device' } } });
-    expect(turtleFetch).toHaveBeenCalledTimes(2);
     expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
   });
 
@@ -203,7 +203,7 @@ describe('with a device run session token', () => {
       })
     );
 
-    const args = await fetchWebPreviewTurnArgsAsync(ctx, { logger });
+    const args = await fetchWebPreviewTurnArgsAsync(ctx, { env, logger });
 
     expect(args).toEqual([
       '--stun-url',
@@ -215,7 +215,7 @@ describe('with a device run session token', () => {
       '--turn-credential',
       'credential',
     ]);
-    expectWorkerApiCall('turn-ice-servers', 'POST', { timeout: 5000, retries: 0 });
+    expectWorkerApiCall('turn-ice-servers', 'POST', { timeout: 5000, retries: 1 });
     expect(jest.mocked(turtleFetch)).toHaveBeenCalledTimes(1);
   });
 
@@ -426,38 +426,29 @@ describe('with a device run session token', () => {
 });
 
 describe('without a device run session token', () => {
-  const MISSING_TOKEN_MESSAGE =
-    /^This device run session job has no EAS_DEVICE_RUN_SESSION_TOKEN secret\./;
-
-  function expectMissingTokenError(error: unknown): void {
-    expect(error).toBeInstanceOf(SystemError);
-    expect((error as Error).message).toMatch(MISSING_TOKEN_MESSAGE);
-  }
-
-  function expectMissingTokenWarning(message: string): void {
-    const warning = (jest.mocked(logger.warn).mock.calls as unknown[][]).find(
-      ([, warningMessage]) => warningMessage === message
-    );
-    expect(warning).toBeDefined();
-    expectMissingTokenError((warning![0] as { err: unknown }).err);
-  }
-
-  it('fails the status poll with a system error', async () => {
+  it('polls the session status with GraphQL', async () => {
     const ctx = createCtx({ withToken: false });
+    jest
+      .mocked(ctx.graphqlClient.query)
+      .mockReturnValueOnce(
+        graphqlResult({ deviceRunSessions: { byId: { id: 'drs-id', status: 'STOPPED' } } }) as never
+      );
 
-    const error = await waitForDeviceRunSessionStoppedAsync({
-      ctx,
+    await waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId: 'drs-id', logger });
+
+    expect(ctx.graphqlClient.query).toHaveBeenCalledWith(expect.anything(), {
       deviceRunSessionId: 'drs-id',
-      logger,
-    }).catch(err => err);
-
-    expectMissingTokenError(error);
+    });
     expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
-    expect(ctx.graphqlClient.query).not.toHaveBeenCalled();
   });
 
-  it('logs the failed idle stop and ends the wait', async () => {
+  it('stops an idle session with GraphQL', async () => {
     const ctx = createCtx({ withToken: false });
+    jest.mocked(ctx.graphqlClient.mutation).mockReturnValueOnce(
+      graphqlResult({
+        deviceRunSession: { ensureDeviceRunSessionStopped: { id: 'drs-id', status: 'STOPPED' } },
+      }) as never
+    );
 
     await waitForDeviceRunSessionStoppedAsync({
       ctx,
@@ -466,43 +457,65 @@ describe('without a device run session token', () => {
       idleTimeout: { maxIdleTimeMinutes: 0, getLastEventObservedAt: () => undefined },
     });
 
-    expectMissingTokenWarning(
-      'Could not mark device run session drs-id as stopped. The session job ends anyway.'
-    );
+    expect(ctx.graphqlClient.mutation).toHaveBeenCalledWith(expect.anything(), {
+      deviceRunSessionId: 'drs-id',
+    });
     expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
-    expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
   });
 
-  it('fails the start with a system error', async () => {
+  it('starts the session with GraphQL', async () => {
     const ctx = createCtx({ withToken: false });
+    jest.mocked(ctx.graphqlClient.mutation).mockReturnValueOnce(
+      graphqlResult({
+        deviceRunSession: { startDeviceRunSession: { id: 'drs-id', status: 'IN_PROGRESS' } },
+      }) as never
+    );
 
-    const error = await uploadRemoteSessionConfigAsync({
+    await uploadRemoteSessionConfigAsync({
       ctx,
       deviceRunSessionId: 'drs-id',
       remoteConfig: { type: 'agent-device' },
       logger,
-    }).catch(err => err);
+    });
 
-    expectMissingTokenError(error);
+    expect(ctx.graphqlClient.mutation).toHaveBeenCalledWith(expect.anything(), {
+      deviceRunSessionId: 'drs-id',
+      remoteConfig: { type: 'agent-device' },
+    });
     expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
-    expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
   });
 
-  it('falls back to no TURN ICE servers', async () => {
+  it('fetches TURN ICE servers from the device run sessions route with the robot token', async () => {
     const ctx = createCtx({ withToken: false });
+    jest.mocked(turtleFetch).mockResolvedValueOnce(jsonResponse({ data: { iceServers: [] } }));
 
-    await expect(fetchWebPreviewTurnArgsAsync(ctx, { logger })).resolves.toEqual([]);
+    await fetchWebPreviewTurnArgsAsync(ctx, { env, logger });
 
-    expectMissingTokenWarning(
-      'Could not fetch Cloudflare TURN ICE servers; the web preview will fall back to P2P/STUN.'
+    expect(jest.mocked(turtleFetch)).toHaveBeenCalledWith(
+      'https://api.expo.test/v2/device-run-sessions/drs-id/turn-ice-servers',
+      'POST',
+      expect.objectContaining({
+        headers: { Authorization: `Bearer ${ROBOT_ACCESS_TOKEN}` },
+        timeout: 5000,
+        retries: 1,
+      })
     );
-    expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
   });
 
-  it('fails the artifact upload with a system error before any PUT', async () => {
+  it('creates artifact upload sessions with GraphQL', async () => {
     const ctx = createCtx({ withToken: false });
+    jest.mocked(ctx.graphqlClient.mutation).mockReturnValueOnce(
+      graphqlResult({
+        deviceRunSession: {
+          createArtifactUploadSession: {
+            uploadSession: { url: 'https://uploads.expo.test/artifact', headers: {} },
+          },
+        },
+      }) as never
+    );
+    jest.mocked(fetch).mockResolvedValueOnce(new Response('', { status: 200 }));
 
-    const error = await uploadDeviceRunSessionArtifactAsync(ctx, {
+    await uploadDeviceRunSessionArtifactAsync(ctx, {
       deviceRunSessionId: 'drs-id',
       artifactId: 'artifact-id',
       name: 'Report',
@@ -510,16 +523,23 @@ describe('without a device run session token', () => {
       kind: undefined,
       size: 4,
       openStream: () => Readable.from(Buffer.from('data')),
-    }).catch(err => err);
+    });
 
-    expectMissingTokenError(error);
+    expect(ctx.graphqlClient.mutation).toHaveBeenCalled();
     expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
-    expect(jest.mocked(fetch)).not.toHaveBeenCalled();
-    expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
   });
 
-  it('runs the session without persisting events', async () => {
+  it('creates the event log upload session with GraphQL', async () => {
     const ctx = createCtx({ withToken: false });
+    jest.mocked(ctx.graphqlClient.mutation).mockReturnValueOnce(
+      graphqlResult({
+        deviceRunSession: {
+          createEventLogUploadSession: {
+            uploadSession: { url: 'https://uploads.expo.test/events', headers: {} },
+          },
+        },
+      }) as never
+    );
 
     const collection = await startDeviceRunSessionEventCollectionAsync({
       ctx,
@@ -529,14 +549,24 @@ describe('without a device run session token', () => {
     });
     await collection.stopAsync();
 
-    expectMissingTokenWarning('Could not persist device run session events to the artifact.');
-    expect(jest.mocked(RemoteLoggerStream)).not.toHaveBeenCalled();
+    expect(ctx.graphqlClient.mutation).toHaveBeenCalledWith(expect.anything(), {
+      deviceRunSessionId: 'drs-id',
+    });
     expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
-    expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
   });
 
-  it('logs the failed preview upload session and uploads no preview', async () => {
+  it('creates the preview upload session with GraphQL', async () => {
     const ctx = createCtx({ withToken: false });
+    jest.mocked(ctx.graphqlClient.mutation).mockReturnValueOnce(
+      graphqlResult({
+        deviceRunSession: {
+          createPreviewUploadSession: {
+            uploadSession: { url: 'https://uploads.expo.test/preview', headers: {} },
+          },
+        },
+      }) as never
+    );
+    jest.mocked(fetch).mockResolvedValue(new Response('', { status: 200 }));
 
     const preview = startDeviceRunSessionPreview({
       ctx,
@@ -544,25 +574,29 @@ describe('without a device run session token', () => {
       captureAsync: async () => Buffer.from('webp'),
       logger,
     });
-    await waitForCallAsync(jest.mocked(logger.warn));
+    await waitForCallAsync(jest.mocked(fetch));
     await preview.stopAsync();
 
-    expectMissingTokenWarning('Could not refresh the session preview; retrying in 60 seconds.');
+    expect(ctx.graphqlClient.mutation).toHaveBeenCalled();
     expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
-    expect(jest.mocked(fetch)).not.toHaveBeenCalled();
-    expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
   });
 
-  it('names screenshots with capture timestamps', async () => {
+  it('loads the screenshot naming details with GraphQL', async () => {
     const ctx = createCtx({ withToken: false });
-
-    await expect(loadScreenshotSessionAsync(ctx, 'drs-id', logger)).resolves.toBeNull();
-
-    expectMissingTokenWarning(
-      'Could not load screenshot session details; using capture timestamps.'
+    jest.mocked(ctx.graphqlClient.query).mockReturnValueOnce(
+      graphqlResult({
+        deviceRunSessions: {
+          byId: { platform: 'ANDROID', app: { slug: 'app' }, build: null },
+        },
+      }) as never
     );
+
+    await expect(loadScreenshotSessionAsync(ctx, 'drs-id', logger)).resolves.toEqual({
+      platform: 'ANDROID',
+      app: { slug: 'app' },
+      build: null,
+    });
     expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
-    expect(ctx.graphqlClient.query).not.toHaveBeenCalled();
   });
 
   it('looks up the build archive URL with GraphQL', async () => {

packages/build-tools/src/steps/utils/__tests__/deviceSessionHost.test.ts

@@ -12,9 +12,7 @@ import { IosSimulatorUtils } from '../../../utils/IosSimulatorUtils';
 import { verifyLocalEgressGuardAsync } from '../localEgressGuard';
 import { type ServeSimApplicationOptions } from '../remoteDeviceRunSession';
 
-import { readLocalEgressHandoffAsync } from '../localEgress';
 import { runServeSimActionAsync, stageServeSimAppAsync } from '../serveSimActions';
-import { startServeSimActivityPolling } from '../serveSimActivity';
 import { readServeSimServersAsync } from '../serveSimMetricsRecorder';
 import { Sentry } from '../../../sentry';
 import { turtleFetch } from '../../../utils/turtleFetch';
@@ -46,11 +44,6 @@ jest.mock('../../../utils/IosSimulatorUtils', () => ({
 }));
 jest.mock('../localEgressGuard', () => ({ verifyLocalEgressGuardAsync: jest.fn() }));
 jest.mock('../serveSimActions');
-jest.mock('../serveSimActivity');
-jest.mock('../localEgress', () => ({
-  ...jest.requireActual('../localEgress'),
-  readLocalEgressHandoffAsync: jest.fn().mockResolvedValue(null),
-}));
 jest.mock('../deviceRunSessionArtifacts');
 jest.mock('../../../sentry');
 jest.mock('../serveSimMetricsRecorder', () => ({
@@ -136,7 +129,6 @@ beforeEach(() => {
   jest.clearAllMocks();
   jest.mocked(IosSimulatorUtils.disableApsdAsync).mockReset().mockResolvedValue(undefined);
   jest.mocked(verifyLocalEgressGuardAsync).mockReset().mockResolvedValue(undefined);
-  jest.mocked(readLocalEgressHandoffAsync).mockReset().mockResolvedValue(null);
   stopSessionPreview.mockResolvedValue(undefined);
   jest.mocked(startDeviceRunSessionPreview).mockReturnValue({ stopAsync: stopSessionPreview });
   jest.mocked(ensureFfmpegInstalledOnceAsync).mockResolvedValue(undefined);
@@ -460,62 +452,6 @@ it('starts the readiness budget after refusals that exceed the normal startup de
   await rejected;
 });
 
-it('reports preview activity from serve-sim on iOS and stops polling when finished', async () => {
-  const observedAt = new Date('2026-10-19T12:00:00Z');
-  const stopActivity = jest.fn().mockResolvedValue(undefined);
-  jest.mocked(startServeSimActivityPolling).mockReturnValue({
-    getLastActivityObservedAt: () => observedAt,
-    stopAsync: stopActivity,
-  });
-  const host = await startDeviceSessionHostAsync(ctx, {
-    runtimePlatform: BuildRuntimePlatform.DARWIN,
-    env,
-    logger,
-    timeoutMs: 10_000,
-  });
-  const port = Number(
-    jest.mocked(spawnDetached).mock.calls[0][0].args[
-      jest.mocked(spawnDetached).mock.calls[0][0].args.indexOf('--port') + 1
-    ]
-  );
-
-  expect(startServeSimActivityPolling).toHaveBeenCalledWith({
-    port,
-    token: 'preview-token',
-    logger: expect.anything(),
-  });
-  expect(host.getLastPreviewActivityAt()).toBe(observedAt);
-
-  await host.finishAsync();
-  expect(stopActivity).toHaveBeenCalledTimes(1);
-});
-
-it('does not start polling preview activity when startup is cancelled', async () => {
-  const controller = new AbortController();
-  jest.mocked(IosSimulatorUtils.disableApsdAsync).mockImplementation(async () => {
-    controller.abort(new Error('cancelled'));
-  });
-  await expect(
-    startDeviceSessionHostAsync(ctx, {
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-      iosSimulatorUdid: 'emulator-5554',
-      env,
-      logger,
-      timeoutMs: 10_000,
-      signal: controller.signal,
-    })
-  ).rejects.toThrow();
-  expect(startServeSimActivityPolling).not.toHaveBeenCalled();
-});
-
-it('reports no preview activity on Android, where expo-device-hub keeps no event log', async () => {
-  const host = await startHostAsync();
-
-  expect(startServeSimActivityPolling).not.toHaveBeenCalled();
-  expect(host.getLastPreviewActivityAt()).toBeUndefined();
-  await host.finishAsync();
-});
-
 it('stops a host that became ready on a different Simulator', async () => {
   await expect(
     startDeviceSessionHostAsync(ctx, {
@@ -938,23 +874,6 @@ it.each([
   await host.finishAsync();
 });
 
-it('lets the session add frame ancestors and CORS origins after the website origins', async () => {
-  const host = await startDeviceSessionHostAsync(ctx, {
-    runtimePlatform: BuildRuntimePlatform.LINUX,
-    env,
-    logger,
-    separateLogPhase: true,
-    timeoutMs: 10_000,
-    frameAncestors: ['https://embed.example.test', 'https://*.example.test'],
-    corsOrigins: ['https://app.example.test'],
-  });
-  const { args } = jest.mocked(spawnDetached).mock.calls[0][0];
-  expect(args.join(' ')).toContain(
-    '--frame-ancestor https://expo.dev --frame-ancestor https://embed.example.test --frame-ancestor https://*.example.test --cors-origin https://app.example.test'
-  );
-  await host.finishAsync();
-});
-
 it('stops when expo-device-hub records no session token', async () => {
   jest.mocked(spawnDetached).mockImplementationOnce(options => {
     const flag = options.args.indexOf('--android-recording-directory');
@@ -1383,35 +1302,6 @@ it('uses the existing step logger for startup and shutdown output', async () =>
   ).toBe(false);
 });
 
-it('passes the active local-egress address to serve-sim without tunnel credentials', async () => {
-  jest.mocked(readLocalEgressHandoffAsync).mockResolvedValue({
-    port: 8899,
-    url: 'https://tunnel.example',
-    token: 'tunnel-secret',
-    fingerprint: 'fingerprint',
-  });
-  const host = await startDeviceSessionHostAsync(ctx, {
-    runtimePlatform: BuildRuntimePlatform.DARWIN,
-    env,
-    logger,
-    timeoutMs: 10_000,
-    networkCapture: true,
-  });
-  const spawned = jest.mocked(spawnDetached).mock.calls[0][0];
-  expect(spawned.args).toEqual(
-    expect.arrayContaining(['--network-capture-proxy', 'http://127.0.0.1:8899'])
-  );
-  expect(spawned.args).toContain('--network-capture');
-  expect(JSON.stringify(spawned)).not.toContain('tunnel-secret');
-  await host.finishAsync();
-});
-
-it('does not read the iOS egress handoff for an Android host', async () => {
-  const host = await startHostAsync();
-  expect(readLocalEgressHandoffAsync).not.toHaveBeenCalled();
-  await host.finishAsync();
-});
-
 it.each([true, false])(
   'waits for setup before launch or boot-only readiness (app: %s)',
   async hasApp => {

packages/build-tools/src/steps/utils/__tests__/preinstalledWda.test.ts

@@ -3,7 +3,6 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
-import * as processes from '../../../utils/processes';
 import { preparePreinstalledWdaAsync } from '../preinstalledWda';
 
 jest.mock('@expo/turtle-spawn', () => ({ __esModule: true, default: jest.fn() }));
@@ -79,37 +78,3 @@ it('does not enable preinstalled startup when the download produces no runner',
   jest.mocked(spawn).mockResolvedValue({ stdout: '' } as never);
   await expect(preparePreinstalledWdaAsync(options)).resolves.toEqual({});
 });
-
-it('drains an aborted WDA downloader before removing its partial artifact', async () => {
-  await fs.promises.mkdir(outdir, { recursive: true });
-  const controller = new AbortController();
-  const error = new Error('Simulator startup failed');
-  const child = { pid: 12345, kill: jest.fn() };
-  let closeDownloader!: (error: Error) => void;
-  jest.mocked(spawn).mockReturnValueOnce(
-    Object.assign(
-      new Promise((_resolve, reject) => {
-        closeDownloader = reject;
-      }),
-      { child }
-    ) as never
-  );
-  const killGroup = jest.spyOn(processes, 'killProcessGroup').mockImplementation(() => {});
-  const running = preparePreinstalledWdaAsync({ ...options, signal: controller.signal });
-  const settled = jest.fn();
-  const observed = running.then(settled, settled);
-  try {
-    controller.abort(error);
-    expect(killGroup).toHaveBeenCalledWith(child, 'SIGKILL');
-    expect(settled).not.toHaveBeenCalled();
-    expect(fs.existsSync(outdir)).toBe(true);
-    closeDownloader(new Error('download interrupted'));
-    await expect(running).rejects.toBe(error);
-    expect(fs.existsSync(outdir)).toBe(false);
-    expect(logger.warn).not.toHaveBeenCalled();
-  } finally {
-    closeDownloader(error);
-    await observed;
-    killGroup.mockRestore();
-  }
-});

packages/build-tools/src/steps/utils/__tests__/remoteDeviceRunSession.test.ts

@@ -1,4 +1,4 @@
-import { SystemError, UserError } from '@expo/eas-build-job';
+import { UserError } from '@expo/eas-build-job';
 import { bunyan } from '@expo/logger';
 import { BuildRuntimePlatform, BuildStepEnv, BuildStepInputValueTypeName } from '@expo/steps';
 import spawn from '@expo/turtle-spawn';
@@ -18,7 +18,6 @@ import { createGlobalContextMock } from '../../../__tests__/utils/context';
 import { CustomBuildContext } from '../../../customBuildContext';
 import { Sentry } from '../../../sentry';
 import { turtleFetch } from '../../../utils/turtleFetch';
-import * as processes from '../../../utils/processes';
 import {
   IosSimulatorRecordingUtils,
   SERVE_SIM_STOP_GRACE_PERIOD_MS,
@@ -27,10 +26,7 @@ import * as remoteDeviceRunSession from '../remoteDeviceRunSession';
 import { readServeSimServersAsync } from '../serveSimMetricsRecorder';
 import { sleepAsync } from '../../../utils/retry';
 import { uploadDeviceRunSessionScreenRecordingsAsync } from '../deviceRunSessionScreenRecordings';
-import { DEVICE_RUN_SESSION_TOKEN_HEADER } from '../deviceRunSessionWorkerApi';
 import {
-  createCorsOriginsInputProvider,
-  createFrameAncestorsInputProvider,
   createIosSessionStartupInputProviders,
   createPrivatePreviewUrlInputProvider,
   createPublicPreviewInputProvider,
@@ -38,8 +34,6 @@ import {
   describeServeSimLaunch,
   ensureFfmpegInstalledOnceAsync,
   fetchWebPreviewTurnArgsAsync,
-  parseCorsOriginsInput,
-  parseFrameAncestorsInput,
   parseServeSimLaunchInputs,
   spawnDetached,
   startNgrokTunnelAsync,
@@ -50,10 +44,8 @@ import {
 
 import {
   EXPO_DEVICE_HUB_STATE_DIR,
-  corsOriginArgs,
   createExpoDeviceHubArgs,
   createServeSimArgs,
-  frameAncestorArgs,
   simulatorPreviewPageUrl,
   startDeviceSessionHostAsync,
   waitForWebPreviewReadyAsync,
@@ -156,70 +148,73 @@ describe(spawnDetached, () => {
   );
 });
 
-const DEVICE_RUN_SESSION_TOKEN = 'device-run-session-token';
-const DEVICE_RUN_SESSION_WORKER_URL = 'https://api.expo.test/v2/device-run-session-worker/';
-
-function createCtxMock({ withToken = true }: { withToken?: boolean } = {}): CustomBuildContext {
+function createCtxMock(): CustomBuildContext {
   return {
     env: {
       __API_SERVER_URL: 'https://api.expo.test',
-      ...(withToken ? { EAS_DEVICE_RUN_SESSION_TOKEN: DEVICE_RUN_SESSION_TOKEN } : {}),
     },
-    expoApiV2BaseUrl: 'https://api.expo.test/v2/',
     job: {
       secrets: { robotAccessToken: 'robot-token' },
     },
   } as unknown as CustomBuildContext;
 }
 
-/** A successful device run session worker API response with the `{ data }` body. */
-function workerApiResponse(data: unknown): Awaited<ReturnType<typeof turtleFetch>> {
-  return {
-    ok: true,
-    status: 200,
-    json: async () => ({ data }),
-  } as unknown as Awaited<ReturnType<typeof turtleFetch>>;
-}
-
-/** The number of device run session worker API requests to the route. */
-function workerApiCallCount(route: string): number {
-  return jest
-    .mocked(turtleFetch)
-    .mock.calls.filter(([url]) => url === `${DEVICE_RUN_SESSION_WORKER_URL}${route}`).length;
-}
-
-/**
- * Serves session status polls from `results` in order, and idle stops, through the device run
- * session worker API.
- */
 function createStatusCtxMock(
   results: (
-    | { status: 'new' | 'in-progress' | 'stopped' | 'errored' }
+    | { status: 'NEW' | 'IN_PROGRESS' | 'STOPPED' | 'ERRORED' }
     | { error: Error }
     | { data: unknown }
   )[],
-  { stopError }: { stopError?: Error } = {}
+  { ensureStoppedError }: { ensureStoppedError?: Error } = {}
 ): CustomBuildContext {
-  jest.mocked(turtleFetch).mockImplementation(async url => {
-    if (url === `${DEVICE_RUN_SESSION_WORKER_URL}stop`) {
-      if (stopError) {
-        throw stopError;
-      }
-      return workerApiResponse({ id: 'drs-id', status: 'stopped' });
-    }
+  const query = jest.fn(() => {
     const result = results.shift();
     if (!result) {
       throw new Error('No mocked status result available');
     }
-    if ('error' in result) {
-      throw result.error;
-    }
-    if ('data' in result) {
-      return workerApiResponse(result.data);
-    }
-    return workerApiResponse({ id: 'drs-id', status: result.status });
+    return {
+      toPromise: async () => {
+        if ('error' in result) {
+          throw result.error;
+        }
+        if ('data' in result) {
+          return { data: result.data };
+        }
+        return {
+          data: {
+            deviceRunSessions: {
+              byId: {
+                id: 'drs-id',
+                status: result.status,
+              },
+            },
+          },
+        };
+      },
+    };
   });
-  return createCtxMock();
+
+  const mutation = jest.fn(() => ({
+    toPromise: async () => {
+      if (ensureStoppedError) {
+        return { error: ensureStoppedError };
+      }
+      return {
+        data: {
+          deviceRunSession: {
+            ensureDeviceRunSessionStopped: { id: 'drs-id', status: 'STOPPED' },
+          },
+        },
+      };
+    },
+  }));
+
+  return {
+    graphqlClient: {
+      query,
+      mutation,
+    },
+  } as unknown as CustomBuildContext;
 }
 
 function createEnvMock(): BuildStepEnv {
@@ -326,88 +321,6 @@ describe(createPrivatePreviewUrlInputProvider, () => {
   });
 });
 
-describe(createFrameAncestorsInputProvider, () => {
-  it('accepts an optional JSON list of origins from the session job', () => {
-    const input = createFrameAncestorsInputProvider()(createGlobalContextMock(), 'step-id');
-    expect(input).toMatchObject({
-      id: 'frame_ancestors',
-      required: false,
-      allowedValueTypeName: BuildStepInputValueTypeName.JSON,
-    });
-  });
-});
-
-describe(parseFrameAncestorsInput, () => {
-  it('defaults to no extra origins when the step declares nothing', () => {
-    expect(parseFrameAncestorsInput(undefined)).toEqual([]);
-  });
-
-  it('returns the origins as given', () => {
-    expect(
-      parseFrameAncestorsInput(['https://embed.example.test', 'https://*.example.test'])
-    ).toEqual(['https://embed.example.test', 'https://*.example.test']);
-  });
-
-  it.each([['https://embed.example.test'], [['https://embed.example.test', '']], [[1]]])(
-    'rejects %j',
-    value => {
-      expect(() => parseFrameAncestorsInput(value)).toThrow(
-        'Input "frame_ancestors" must be an array of non-empty strings, one origin each.'
-      );
-    }
-  );
-});
-
-describe(createCorsOriginsInputProvider, () => {
-  it('accepts an optional JSON list of origins from the session job', () => {
-    const input = createCorsOriginsInputProvider()(createGlobalContextMock(), 'step-id');
-    expect(input).toMatchObject({
-      id: 'cors_origins',
-      required: false,
-      allowedValueTypeName: BuildStepInputValueTypeName.JSON,
-    });
-  });
-});
-
-describe(parseCorsOriginsInput, () => {
-  it('defaults to no extra origins and returns the origins as given', () => {
-    expect(parseCorsOriginsInput(undefined)).toEqual([]);
-    expect(parseCorsOriginsInput(['https://app.example.test'])).toEqual([
-      'https://app.example.test',
-    ]);
-  });
-
-  it('rejects anything but a list of non-empty strings', () => {
-    expect(() => parseCorsOriginsInput(['https://app.example.test', ''])).toThrow(
-      'Input "cors_origins" must be an array of non-empty strings, one origin each.'
-    );
-  });
-});
-
-describe(corsOriginArgs, () => {
-  it('repeats the flag once per origin', () => {
-    expect(corsOriginArgs(['https://a.example.test', 'https://b.example.test'])).toEqual([
-      '--cors-origin',
-      'https://a.example.test',
-      '--cors-origin',
-      'https://b.example.test',
-    ]);
-    expect(corsOriginArgs([])).toEqual([]);
-  });
-});
-
-describe(frameAncestorArgs, () => {
-  it('repeats the flag once per origin', () => {
-    expect(frameAncestorArgs(['https://a.example.test', 'https://b.example.test'])).toEqual([
-      '--frame-ancestor',
-      'https://a.example.test',
-      '--frame-ancestor',
-      'https://b.example.test',
-    ]);
-    expect(frameAncestorArgs([])).toEqual([]);
-  });
-});
-
 describe(parseServeSimLaunchInputs, () => {
   const darwin = { runtimePlatform: BuildRuntimePlatform.DARWIN };
 
@@ -575,26 +488,6 @@ describe(createServeSimArgs, () => {
     ]);
   });
 
-  it('appends the session frame ancestors after the website args', () => {
-    const args = createServeSimArgs({
-      port: 4321,
-      websiteArgs: ['--frame-ancestor', 'https://expo.dev'],
-      frameAncestorArgs: ['--frame-ancestor', 'https://embed.example.test'],
-      corsOriginArgs: ['--cors-origin', 'https://app.example.test'],
-      shareUrl: 'https://expo.dev/simulator-preview/preview-id',
-    });
-    expect(args.slice(-8)).toEqual([
-      '--frame-ancestor',
-      'https://expo.dev',
-      '--frame-ancestor',
-      'https://embed.example.test',
-      '--cors-origin',
-      'https://app.example.test',
-      '--share-url',
-      'https://expo.dev/simulator-preview/preview-id',
-    ]);
-  });
-
   it('pins the requested package version', () => {
     expect(createServeSimArgs({ port: 4321, packageVersion: '0.1.38' })[0]).toBe(
       '@expo/[email protected]'
@@ -661,14 +554,6 @@ describe(createServeSimArgs, () => {
     );
   });
 
-  it('passes a capture proxy as one argument, including when capture will be enabled later', () => {
-    const proxy = 'http://user:p%40ss%[email protected]:8899';
-    const args = createServeSimArgs({ port: 4321, networkCaptureProxy: proxy });
-    expect(args.slice(-2)).toEqual(['--network-capture-proxy', proxy]);
-    expect(args).not.toContain('--network-capture');
-    expect(createServeSimArgs({ port: 4321 })).not.toContain('--network-capture-proxy');
-  });
-
   it('appends --network-capture when enabled, which also covers an already booted simulator', () => {
     const args = createServeSimArgs({ port: 4321, networkCapture: true });
     expect(args).toContain('--network-capture');
@@ -800,23 +685,6 @@ describe(createExpoDeviceHubArgs, () => {
     ]);
   });
 
-  it('appends the session frame ancestors after the website args', () => {
-    const args = createExpoDeviceHubArgs({
-      port: 4321,
-      websiteArgs: ['--frame-ancestor', 'https://expo.dev'],
-      frameAncestorArgs: ['--frame-ancestor', 'https://embed.example.test'],
-      corsOriginArgs: ['--cors-origin', 'https://app.example.test'],
-    });
-    expect(args.slice(-6)).toEqual([
-      '--frame-ancestor',
-      'https://expo.dev',
-      '--frame-ancestor',
-      'https://embed.example.test',
-      '--cors-origin',
-      'https://app.example.test',
-    ]);
-  });
-
   it('pins the requested package version', () => {
     expect(createExpoDeviceHubArgs({ port: 4321, packageVersion: '0.7.0' })[0]).toBe(
       '[email protected]'
@@ -1105,8 +973,6 @@ describe(startDeviceSessionHostAsync, () => {
     jest.mocked(turtleFetch).mockImplementation(async url => {
       if (url.endsWith('/turn-ice-servers')) {
         return {
-          ok: true,
-          status: 200,
           json: async () => ({
             data: {
               iceServers: [
@@ -1604,21 +1470,24 @@ describe(fetchWebPreviewTurnArgsAsync, () => {
     jest.mocked(turtleFetch).mockReset();
   });
 
-  it('requests TURN ICE servers from the device run session worker API and returns web preview args', async () => {
-    jest.mocked(turtleFetch).mockResolvedValue(
-      workerApiResponse({
-        iceServers: [
-          { urls: ['stun:stun.cloudflare.com:3478'] },
-          {
-            urls: ['turns:turn.cloudflare.com:443?transport=tcp'],
-            username: 'u',
-            credential: 'c',
-          },
-        ],
-      })
-    );
+  it('requests TURN ICE servers from the device run session endpoint and returns web preview args', async () => {
+    jest.mocked(turtleFetch).mockResolvedValue({
+      json: async () => ({
+        data: {
+          iceServers: [
+            { urls: ['stun:stun.cloudflare.com:3478'] },
+            {
+              urls: ['turns:turn.cloudflare.com:443?transport=tcp'],
+              username: 'u',
+              credential: 'c',
+            },
+          ],
+        },
+      }),
+    } as unknown as Awaited<ReturnType<typeof turtleFetch>>);
 
     const args = await fetchWebPreviewTurnArgsAsync(createCtxMock(), {
+      env: createEnvMock(),
       logger: createLoggerMock(),
     });
 
@@ -1633,10 +1502,10 @@ describe(fetchWebPreviewTurnArgsAsync, () => {
       'c',
     ]);
     expect(jest.mocked(turtleFetch)).toHaveBeenCalledWith(
-      `${DEVICE_RUN_SESSION_WORKER_URL}turn-ice-servers`,
+      'https://api.expo.test/v2/device-run-sessions/drs-id/turn-ice-servers',
       'POST',
       expect.objectContaining({
-        headers: { [DEVICE_RUN_SESSION_TOKEN_HEADER]: DEVICE_RUN_SESSION_TOKEN },
+        headers: { Authorization: 'Bearer robot-token' },
       })
     );
   });
@@ -1645,32 +1514,14 @@ describe(fetchWebPreviewTurnArgsAsync, () => {
     jest.mocked(turtleFetch).mockRejectedValue(new Error('boom'));
     const logger = createLoggerMock();
 
-    const args = await fetchWebPreviewTurnArgsAsync(createCtxMock(), { logger });
-
-    expect(args).toEqual([]);
-    expect(logger.warn).toHaveBeenCalled();
-    expect(jest.mocked(Sentry).capture).toHaveBeenCalled();
-  });
-
-  it('returns [] and warns when the job has no device run session token', async () => {
-    const logger = createLoggerMock();
-
-    const args = await fetchWebPreviewTurnArgsAsync(createCtxMock({ withToken: false }), {
+    const args = await fetchWebPreviewTurnArgsAsync(createCtxMock(), {
+      env: createEnvMock(),
       logger,
     });
 
     expect(args).toEqual([]);
-    expect(logger.warn).toHaveBeenCalledWith(
-      {
-        err: expect.objectContaining({
-          message: expect.stringMatching(
-            /^This device run session job has no EAS_DEVICE_RUN_SESSION_TOKEN secret\./
-          ),
-        }),
-      },
-      'Could not fetch Cloudflare TURN ICE servers; the web preview will fall back to P2P/STUN.'
-    );
-    expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
+    expect(logger.warn).toHaveBeenCalled();
+    expect(jest.mocked(Sentry).capture).toHaveBeenCalled();
   });
 });
 
@@ -1687,7 +1538,7 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
   });
 
   it('continues polling until the device run session is stopped', async () => {
-    const ctx = createStatusCtxMock([{ status: 'in-progress' }, { status: 'stopped' }]);
+    const ctx = createStatusCtxMock([{ status: 'IN_PROGRESS' }, { status: 'STOPPED' }]);
     const logger = createLoggerMock();
 
     await waitForDeviceRunSessionStoppedAsync({
@@ -1696,59 +1547,13 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
       logger,
     });
 
-    expect(workerApiCallCount('session')).toBe(2);
+    expect(ctx.graphqlClient.query).toHaveBeenCalledTimes(2);
     expect(logger.info).toHaveBeenCalledWith('Device run session drs-id was stopped.');
     expect(setTimeoutCallback).not.toHaveBeenCalled();
   });
 
-  it('polls the session status through the worker API with the abort signal', async () => {
-    const ctx = createStatusCtxMock([{ status: 'stopped' }]);
-
-    await waitForDeviceRunSessionStoppedAsync({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      logger: createLoggerMock(),
-    });
-
-    expect(jest.mocked(turtleFetch)).toHaveBeenCalledWith(
-      `${DEVICE_RUN_SESSION_WORKER_URL}session`,
-      'GET',
-      expect.objectContaining({
-        headers: { [DEVICE_RUN_SESSION_TOKEN_HEADER]: DEVICE_RUN_SESSION_TOKEN },
-        signal: expect.any(AbortSignal),
-        timeout: 30_000,
-      })
-    );
-  });
-
-  it('keeps polling while the session status is new', async () => {
-    const ctx = createStatusCtxMock([{ status: 'new' }, { status: 'stopped' }]);
-
-    await waitForDeviceRunSessionStoppedAsync({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      logger: createLoggerMock(),
-    });
-
-    expect(workerApiCallCount('session')).toBe(2);
-  });
-
-  it('fails with a system error when the job has no device run session token', async () => {
-    const error = await waitForDeviceRunSessionStoppedAsync({
-      ctx: createCtxMock({ withToken: false }),
-      deviceRunSessionId: 'drs-id',
-      logger: createLoggerMock(),
-    }).catch(err => err);
-
-    expect(error).toBeInstanceOf(SystemError);
-    expect(error.message).toMatch(
-      /^This device run session job has no EAS_DEVICE_RUN_SESSION_TOKEN secret\./
-    );
-    expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
-  });
-
   it('returns normally when the maximum duration elapses', async () => {
-    const ctx = createStatusCtxMock([{ status: 'in-progress' }]);
+    const ctx = createStatusCtxMock([{ status: 'IN_PROGRESS' }]);
     const logger = createLoggerMock();
     const waitPromise = waitForDeviceRunSessionStoppedAsync({
       ctx,
@@ -1762,7 +1567,7 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
     durationTimeoutCallback();
     await waitPromise;
 
-    expect(workerApiCallCount('session')).toBe(1);
+    expect(ctx.graphqlClient.query).toHaveBeenCalledTimes(1);
     expect(logger.info).toHaveBeenCalledWith(
       'Device run session drs-id reached its maximum duration.'
     );
@@ -1771,7 +1576,7 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
 
   it('clears the duration timeout when the session stops first', async () => {
     await waitForDeviceRunSessionStoppedAsync({
-      ctx: createStatusCtxMock([{ status: 'stopped' }]),
+      ctx: createStatusCtxMock([{ status: 'STOPPED' }]),
       deviceRunSessionId: 'drs-id',
       logger: createLoggerMock(),
       maxDurationSeconds: 30,
@@ -1793,12 +1598,12 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
       signal: abortController.signal,
     });
 
-    expect(workerApiCallCount('session')).toBe(0);
+    expect(ctx.graphqlClient.query).not.toHaveBeenCalled();
     expect(setTimeoutCallback).not.toHaveBeenCalled();
   });
 
   it('throws when the device run session errors', async () => {
-    const ctx = createStatusCtxMock([{ status: 'errored' }]);
+    const ctx = createStatusCtxMock([{ status: 'ERRORED' }]);
 
     await expect(
       waitForDeviceRunSessionStoppedAsync({
@@ -1812,7 +1617,7 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
   });
 
   it('clears the duration timeout when the build step is aborted', async () => {
-    const ctx = createStatusCtxMock([{ status: 'in-progress' }]);
+    const ctx = createStatusCtxMock([{ status: 'IN_PROGRESS' }]);
     const abortController = new AbortController();
     const waitPromise = waitForDeviceRunSessionStoppedAsync({
       ctx,
@@ -1825,12 +1630,12 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
     abortController.abort();
     await waitPromise;
 
-    expect(workerApiCallCount('session')).toBe(1);
+    expect(ctx.graphqlClient.query).toHaveBeenCalledTimes(1);
     expect(clearTimeoutCallback).toHaveBeenCalledWith(durationTimeout);
   });
 
   it('logs and retries transient polling errors', async () => {
-    const ctx = createStatusCtxMock([{ error: new Error('network down') }, { status: 'stopped' }]);
+    const ctx = createStatusCtxMock([{ error: new Error('network down') }, { status: 'STOPPED' }]);
     const logger = createLoggerMock();
 
     await waitForDeviceRunSessionStoppedAsync({
@@ -1839,7 +1644,7 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
       logger,
     });
 
-    expect(workerApiCallCount('session')).toBe(2);
+    expect(ctx.graphqlClient.query).toHaveBeenCalledTimes(2);
     expect(logger.warn).toHaveBeenCalledWith(
       expect.objectContaining({ failedStatusPollCount: 1 }),
       'Could not poll device run session status; will retry.'
@@ -1851,8 +1656,11 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
     );
   });
 
-  it('logs and retries when the status response does not match the route contract', async () => {
-    const ctx = createStatusCtxMock([{ data: { id: 'drs-id' } }, { status: 'stopped' }]);
+  it('logs and retries when the status response is missing', async () => {
+    const ctx = createStatusCtxMock([
+      { data: { deviceRunSessions: { byId: null } } },
+      { status: 'STOPPED' },
+    ]);
     const logger = createLoggerMock();
 
     await waitForDeviceRunSessionStoppedAsync({
@@ -1861,7 +1669,7 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
       logger,
     });
 
-    expect(workerApiCallCount('session')).toBe(2);
+    expect(ctx.graphqlClient.query).toHaveBeenCalledTimes(2);
     expect(logger.warn).toHaveBeenCalledWith(
       expect.objectContaining({ failedStatusPollCount: 1 }),
       'Could not poll device run session status; will retry.'
@@ -1869,9 +1677,7 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
     expect(jest.mocked(Sentry).capture).toHaveBeenCalledWith(
       'Could not poll device run session status',
       expect.objectContaining({
-        message: expect.stringContaining(
-          'GET /v2/device-run-session-worker/session returned an unexpected response'
-        ),
+        message: 'Device run session drs-id status response was missing.',
       }),
       { level: 'warning' }
     );
@@ -1892,8 +1698,8 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
       jest.useRealTimers();
     });
 
-    function manyInProgressStatuses(): { status: 'in-progress' }[] {
-      return Array.from({ length: 20 }, () => ({ status: 'in-progress' as const }));
+    function manyInProgressStatuses(): { status: 'IN_PROGRESS' }[] {
+      return Array.from({ length: 20 }, () => ({ status: 'IN_PROGRESS' as const }));
     }
 
     it('stops the session when no activity is observed within the max idle time', async () => {
@@ -1911,15 +1717,15 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
       });
 
       // One minute at the 5-second poll interval is 12 status polls.
-      expect(workerApiCallCount('session')).toBe(12);
-      expect(workerApiCallCount('stop')).toBe(1);
+      expect(ctx.graphqlClient.query).toHaveBeenCalledTimes(12);
+      expect(ctx.graphqlClient.mutation).toHaveBeenCalledTimes(1);
       expect(logger.info).toHaveBeenCalledWith(
         'Device run session drs-id had no activity for 1 minute(s) (max idle time). Stopping the session.'
       );
     });
 
     it('keeps the session alive while events keep arriving', async () => {
-      const ctx = createStatusCtxMock([...manyInProgressStatuses(), { status: 'stopped' }]);
+      const ctx = createStatusCtxMock([...manyInProgressStatuses(), { status: 'STOPPED' }]);
       const logger = createLoggerMock();
 
       await waitForDeviceRunSessionStoppedAsync({
@@ -1934,55 +1740,14 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
         },
       });
 
-      expect(workerApiCallCount('session')).toBe(21);
-      expect(workerApiCallCount('stop')).toBe(0);
+      expect(ctx.graphqlClient.query).toHaveBeenCalledTimes(21);
+      expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
       expect(logger.info).toHaveBeenCalledWith('Device run session drs-id was stopped.');
     });
 
-    it('keeps the session alive while preview input keeps arriving', async () => {
-      const ctx = createStatusCtxMock([...manyInProgressStatuses(), { status: 'stopped' }]);
-      const logger = createLoggerMock();
-
-      await waitForDeviceRunSessionStoppedAsync({
-        ctx,
-        deviceRunSessionId: 'drs-id',
-        logger,
-        idleTimeout: {
-          maxIdleTimeMinutes: 1,
-          getLastEventObservedAt: () => undefined,
-          getLastPreviewActivityAt: () => new Date(),
-        },
-      });
-
-      expect(workerApiCallCount('session')).toBe(21);
-      expect(workerApiCallCount('stop')).toBe(0);
-    });
-
-    it('counts idle time from the later of automation and preview activity', async () => {
-      const ctx = createStatusCtxMock(manyInProgressStatuses());
-      const logger = createLoggerMock();
-      const previewInputAt = new Date(Date.now() + 30_000);
-
-      await waitForDeviceRunSessionStoppedAsync({
-        ctx,
-        deviceRunSessionId: 'drs-id',
-        logger,
-        idleTimeout: {
-          maxIdleTimeMinutes: 1,
-          getLastEventObservedAt: () => undefined,
-          getLastPreviewActivityAt: () =>
-            Date.now() >= previewInputAt.getTime() ? previewInputAt : undefined,
-        },
-      });
-
-      // Idle from 30 s, so the stop comes at 90 s: 18 polls.
-      expect(workerApiCallCount('session')).toBe(18);
-      expect(workerApiCallCount('stop')).toBe(1);
-    });
-
     it('still returns when the session cannot be marked stopped', async () => {
       const ctx = createStatusCtxMock(manyInProgressStatuses(), {
-        stopError: new Error('forbidden'),
+        ensureStoppedError: new Error('forbidden'),
       });
       const logger = createLoggerMock();
 
@@ -1996,7 +1761,7 @@ describe(waitForDeviceRunSessionStoppedAsync, () => {
         },
       });
 
-      expect(workerApiCallCount('stop')).toBe(1);
+      expect(ctx.graphqlClient.mutation).toHaveBeenCalledTimes(1);
       expect(logger.warn).toHaveBeenCalledWith(
         { err: expect.any(Error) },
         'Could not mark device run session drs-id as stopped. The session job ends anyway.'
@@ -2185,105 +1950,6 @@ describe(ensureFfmpegInstalledOnceAsync, () => {
     expect(spawnMock).toHaveBeenCalledTimes(3);
   });
 
-  it('retries one aborted FFmpeg install for two surviving shared callers after it drains', async () => {
-    const controller = new AbortController();
-    const error = new Error('Simulator startup failed');
-    const child = { pid: 12345, kill: jest.fn() };
-    let closeInstaller!: (error: Error) => void;
-    spawnMock.mockReturnValueOnce(
-      Object.assign(
-        new Promise((_resolve, reject) => {
-          closeInstaller = reject;
-        }),
-        { child }
-      ) as never
-    );
-    let finishReplacement!: () => void;
-    spawnMock.mockReturnValueOnce(
-      new Promise<void>(resolve => {
-        finishReplacement = resolve;
-      }) as never
-    );
-    spawnMock.mockReturnValue(spawnResolved());
-    const killGroup = jest.spyOn(processes, 'killProcessGroup').mockImplementation(() => {});
-    const options = {
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-      env: createPathEnv(),
-      logger: createLoggerMock(),
-    };
-    const owner = ensureFfmpegInstalledOnceAsync({ ...options, signal: controller.signal });
-    const surviving = [
-      ensureFfmpegInstalledOnceAsync(options),
-      ensureFfmpegInstalledOnceAsync({ ...options, signal: new AbortController().signal }),
-    ];
-    const settled = jest.fn();
-    const observed = owner.then(settled, settled);
-    const borrowersSettled = jest.fn();
-    const observedBorrowers = Promise.all(surviving).then(borrowersSettled, borrowersSettled);
-    try {
-      await new Promise<void>(resolve => setImmediate(resolve));
-      controller.abort(error);
-      expect(killGroup).toHaveBeenCalledWith(child, 'SIGKILL');
-      expect(settled).not.toHaveBeenCalled();
-      expect(spawnMock).toHaveBeenCalledTimes(1);
-      closeInstaller(new Error('brew interrupted'));
-      await expect(owner).rejects.toBe(error);
-      await new Promise<void>(resolve => setImmediate(resolve));
-      expect(spawnMock).toHaveBeenCalledTimes(2);
-      expect(borrowersSettled).not.toHaveBeenCalled();
-      finishReplacement();
-      await expect(Promise.all(surviving)).resolves.toEqual([undefined, undefined]);
-      expect(spawnMock).toHaveBeenCalledTimes(3);
-      expect(spawnMock).toHaveBeenLastCalledWith(...warmUpCall);
-      expect(options.logger.warn).not.toHaveBeenCalled();
-    } finally {
-      closeInstaller?.(error);
-      finishReplacement();
-      await Promise.all([observed, observedBorrowers]);
-      killGroup.mockRestore();
-    }
-  });
-
-  it('stops an aborted shared waiter without cancelling the installer owner', async () => {
-    let finishInstall!: () => void;
-    spawnMock.mockReturnValueOnce(
-      new Promise<void>(resolve => {
-        finishInstall = resolve;
-      }) as never
-    );
-    spawnMock.mockReturnValue(spawnResolved());
-    const killGroup = jest.spyOn(processes, 'killProcessGroup').mockImplementation(() => {});
-    const controller = new AbortController();
-    const error = new Error('Appium startup failed');
-    const options = {
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-      env: createPathEnv(),
-      logger: createLoggerMock(),
-    };
-    const owner = ensureFfmpegInstalledOnceAsync(options);
-    let ownerFinished = false;
-    const observedOwner = owner.then(() => {
-      ownerFinished = true;
-    });
-    const waiter = ensureFfmpegInstalledOnceAsync({ ...options, signal: controller.signal });
-    const observedWaiter = waiter.catch(() => {});
-    try {
-      await new Promise<void>(resolve => setImmediate(resolve));
-      controller.abort(error);
-      await expect(waiter).rejects.toBe(error);
-      expect(ownerFinished).toBe(false);
-      expect(killGroup).not.toHaveBeenCalled();
-      expect(spawnMock).toHaveBeenCalledTimes(1);
-      finishInstall();
-      await expect(owner).resolves.toBeUndefined();
-      expect(spawnMock).toHaveBeenLastCalledWith(...warmUpCall);
-    } finally {
-      finishInstall();
-      await Promise.all([observedOwner, observedWaiter]);
-      killGroup.mockRestore();
-    }
-  });
-
   it('still installs on linux when the apt index refresh fails', async () => {
     spawnMock
       .mockReturnValueOnce(spawnRejected()) // apt-get update
@@ -2321,30 +1987,6 @@ describe(ensureFfmpegInstalledOnceAsync, () => {
     expect(jest.mocked(Sentry).capture).toHaveBeenCalled();
   });
 
-  it('does not retry an ordinary shared FFmpeg install failure', async () => {
-    let failInstall!: (error: Error) => void;
-    spawnMock.mockReturnValueOnce(
-      new Promise((_resolve, reject) => {
-        failInstall = reject;
-      }) as never
-    );
-    const options = {
-      runtimePlatform: BuildRuntimePlatform.DARWIN,
-      env: createPathEnv(),
-      logger: createLoggerMock(),
-    };
-    const callers = [
-      ensureFfmpegInstalledOnceAsync(options),
-      ensureFfmpegInstalledOnceAsync(options),
-      ensureFfmpegInstalledOnceAsync({ ...options, signal: new AbortController().signal }),
-    ];
-    await new Promise<void>(resolve => setImmediate(resolve));
-    failInstall(new Error('Homebrew unavailable'));
-    await expect(Promise.all(callers)).resolves.toEqual([undefined, undefined, undefined]);
-    expect(spawnMock).toHaveBeenCalledTimes(1);
-    expect(options.logger.warn).toHaveBeenCalledTimes(1);
-  });
-
   // The caller runs this with `void` and the worker installs no unhandledRejection
   // handler, so a rejection here would crash the process. `spawn` is not async and
   // can throw synchronously, which `asyncResult` cannot catch.

packages/build-tools/src/steps/utils/__tests__/sandboxArtifacts.test.ts

@@ -2,14 +2,6 @@ jest.unmock('fs');
 jest.unmock('fs/promises');
 jest.unmock('node:fs');
 jest.unmock('node:fs/promises');
-jest.mock('node-fetch', () => {
-  const actual = jest.requireActual('node-fetch');
-  return {
-    __esModule: true,
-    ...actual,
-    default: jest.fn(),
-  };
-});
 
 import { SandboxDaemonErrorCode, SystemError } from '@expo/eas-build-job';
 import { type bunyan } from '@expo/logger';
@@ -318,7 +310,7 @@ describe('sandbox artifact uploads', () => {
     expect(logger.error).toHaveBeenCalledTimes(1);
     const logged = inspect([logger.info.mock.calls, logger.error.mock.calls], { depth: 10 });
     expect(fetch).toHaveBeenCalledTimes(3);
-    expect(logged).toContain('Signed URL upload failed: ECONNRESET.');
+    expect(logged).toContain('Artifact PUT failed: ECONNRESET.');
     expect(logged).not.toContain('secret-signature');
   });
 

packages/build-tools/src/steps/utils/__tests__/serveSimActivity.test.ts

@@ -1,196 +0,0 @@
-import { type bunyan } from '@expo/logger';
-import { once } from 'node:events';
-import http from 'node:http';
-
-import { fetchLatestServeSimEventIdAsync, startServeSimActivityPolling } from '../serveSimActivity';
-
-const token = 'test-session-token';
-let server: http.Server;
-let port: number;
-let events: { id: number }[];
-let status: number;
-let requests: { url?: string; authorization?: string }[];
-let rawBody: string | undefined;
-
-function createLoggerMock(): bunyan {
-  return { info: jest.fn(), warn: jest.fn() } as unknown as bunyan;
-}
-
-beforeEach(async () => {
-  events = [];
-  status = 200;
-  requests = [];
-  rawBody = undefined;
-  server = http.createServer((req, res) => {
-    requests.push({ url: req.url, authorization: req.headers.authorization });
-    res.writeHead(status, { 'Content-Type': 'application/json' });
-    res.end(rawBody ?? JSON.stringify({ events: events.slice(-1) }));
-  });
-  server.listen(0, '127.0.0.1');
-  await once(server, 'listening');
-  port = (server.address() as { port: number }).port;
-});
-
-afterEach(async () => {
-  await new Promise<void>(resolve => server.close(() => resolve()));
-});
-
-describe(fetchLatestServeSimEventIdAsync, () => {
-  it('reads the newest event ID with the session token', async () => {
-    events = [{ id: 3 }, { id: 7 }];
-    await expect(fetchLatestServeSimEventIdAsync({ port, token })).resolves.toBe(7);
-    expect(requests).toEqual([{ url: '/api/event-log?limit=1', authorization: `Bearer ${token}` }]);
-  });
-
-  it('returns undefined when serve-sim has logged no event', async () => {
-    await expect(fetchLatestServeSimEventIdAsync({ port, token })).resolves.toBeUndefined();
-  });
-
-  it.each([
-    ['unparseable JSON', 'not json'],
-    ['a body without an events array', '{}'],
-    ['an entry without a numeric ID', '{"events":[{"id":"7"}]}'],
-  ])('rejects %s', async (_, body) => {
-    rawBody = body;
-    await expect(fetchLatestServeSimEventIdAsync({ port, token })).rejects.toThrow(
-      'serve-sim event log'
-    );
-  });
-
-  it('rejects a refused request', async () => {
-    status = 401;
-    await expect(fetchLatestServeSimEventIdAsync({ port, token })).rejects.toThrow('401');
-  });
-});
-
-describe(startServeSimActivityPolling, () => {
-  async function waitForRequestsAsync(count: number): Promise<void> {
-    while (requests.length < count) {
-      await new Promise(resolve => setTimeout(resolve, 5));
-    }
-  }
-
-  it('reports activity only when a new event appears', async () => {
-    const polling = startServeSimActivityPolling({
-      port,
-      token,
-      logger: createLoggerMock(),
-      pollIntervalMs: 10,
-    });
-    try {
-      await waitForRequestsAsync(2);
-      expect(polling.getLastActivityObservedAt()).toBeUndefined();
-
-      events = [{ id: 1 }];
-      const before = Date.now();
-      await waitForRequestsAsync(requests.length + 2);
-      const firstSeen = polling.getLastActivityObservedAt();
-      expect(firstSeen?.getTime()).toBeGreaterThanOrEqual(before);
-
-      await waitForRequestsAsync(requests.length + 2);
-      expect(polling.getLastActivityObservedAt()).toBe(firstSeen);
-
-      events = [{ id: 1 }, { id: 2 }];
-      await waitForRequestsAsync(requests.length + 2);
-      expect(polling.getLastActivityObservedAt()).not.toBe(firstSeen);
-    } finally {
-      await polling.stopAsync();
-    }
-  });
-
-  it('reports current activity while the event log fails, and warns once', async () => {
-    status = 500;
-    const logger = createLoggerMock();
-    const polling = startServeSimActivityPolling({ port, token, logger, pollIntervalMs: 10 });
-    try {
-      await waitForRequestsAsync(3);
-      expect(logger.warn).toHaveBeenCalledTimes(1);
-      const before = Date.now();
-      expect(polling.getLastActivityObservedAt()?.getTime()).toBeGreaterThanOrEqual(before);
-
-      status = 200;
-      events = [{ id: 4 }];
-      await waitForRequestsAsync(requests.length + 2);
-      const observedAt = polling.getLastActivityObservedAt();
-      await waitForRequestsAsync(requests.length + 2);
-      expect(polling.getLastActivityObservedAt()).toBe(observedAt);
-    } finally {
-      await polling.stopAsync();
-    }
-  });
-
-  it('keeps the last observation while serve-sim refuses connections', async () => {
-    await new Promise<void>(resolve => server.close(() => resolve()));
-    server = http.createServer();
-    const polling = startServeSimActivityPolling({
-      port,
-      token,
-      logger: createLoggerMock(),
-      pollIntervalMs: 10,
-    });
-    try {
-      await new Promise(resolve => setTimeout(resolve, 50));
-      expect(polling.getLastActivityObservedAt()).toBeUndefined();
-    } finally {
-      await polling.stopAsync();
-    }
-  });
-
-  it('reports current activity when serve-sim drops the connection mid-response', async () => {
-    server.removeAllListeners('request');
-    server.on('request', (req, res) => {
-      requests.push({ url: req.url });
-      res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': '100' });
-      res.write('{"events":');
-      setImmediate(() => res.socket?.destroy());
-    });
-    const polling = startServeSimActivityPolling({
-      port,
-      token,
-      logger: createLoggerMock(),
-      pollIntervalMs: 10,
-    });
-    try {
-      await waitForRequestsAsync(3);
-      const before = Date.now();
-      expect(polling.getLastActivityObservedAt()?.getTime()).toBeGreaterThanOrEqual(before);
-    } finally {
-      await polling.stopAsync();
-    }
-  });
-
-  it('reports current activity while serve-sim answers without an event log', async () => {
-    status = 404;
-    const polling = startServeSimActivityPolling({
-      port,
-      token,
-      logger: createLoggerMock(),
-      pollIntervalMs: 10,
-    });
-    try {
-      await waitForRequestsAsync(2);
-      const before = Date.now();
-      expect(polling.getLastActivityObservedAt()?.getTime()).toBeGreaterThanOrEqual(before);
-
-      status = 200;
-      await waitForRequestsAsync(requests.length + 2);
-      expect(polling.getLastActivityObservedAt()).toBeUndefined();
-    } finally {
-      await polling.stopAsync();
-    }
-  });
-
-  it('stops polling after stopAsync', async () => {
-    const polling = startServeSimActivityPolling({
-      port,
-      token,
-      logger: createLoggerMock(),
-      pollIntervalMs: 10,
-    });
-    await waitForRequestsAsync(1);
-    await polling.stopAsync();
-    const count = requests.length;
-    await new Promise(resolve => setTimeout(resolve, 50));
-    expect(requests.length).toBe(count);
-  });
-});

packages/build-tools/src/steps/utils/__tests__/serveSimLogsHttp.test.ts

@@ -6,13 +6,11 @@ import os from 'node:os';
 import path from 'node:path';
 
 import { type CustomBuildContext } from '../../../customBuildContext';
-import { DEVICE_RUN_SESSION_TOKEN_HEADER } from '../deviceRunSessionWorkerApi';
 import { uploadServeSimLogsFileAsync } from '../serveSimLogsArtifacts';
 import { streamServeSimLogsToFileAsync } from '../serveSimLogsRecorder';
 
 // This test exercises actual sockets, UTF-8 decoding, files, and PUT uploads.
-// WWW's device run session worker API is served by the local server; it does not verify cloud
-// storage.
+// Only WWW's allocation response is substituted; it does not verify cloud storage.
 jest.mock('../../../sentry');
 jest.unmock('fs');
 jest.unmock('node:fs');
@@ -57,29 +55,7 @@ it('streams selected-device logs into NDJSON and uploads the exact bytes as a se
   let streamRequest: { url?: string; authorization?: string } | undefined;
   let uploaded: Buffer | undefined;
   let uploadedLength: string | undefined;
-  let uploadSessionRequest: { token?: string | string[]; body: unknown } | undefined;
   server.on('request', (request, response) => {
-    if (request.url === '/v2/device-run-session-worker/artifact-upload-sessions') {
-      const chunks: Buffer[] = [];
-      request.on('data', chunk => chunks.push(Buffer.from(chunk)));
-      request.on('end', () => {
-        uploadSessionRequest = {
-          token: request.headers[DEVICE_RUN_SESSION_TOKEN_HEADER],
-          body: JSON.parse(Buffer.concat(chunks).toString('utf8')),
-        };
-        response.writeHead(200, { 'Content-Type': 'application/json' }).end(
-          JSON.stringify({
-            data: {
-              uploadSession: {
-                url: `${baseUrl}/upload`,
-                headers: { 'Content-Length': String(expected.length) },
-              },
-            },
-          })
-        );
-      });
-      return;
-    }
     if (request.method === 'GET') {
       streamRequest = { url: request.url, authorization: request.headers.authorization };
       response.writeHead(200, {
@@ -119,16 +95,27 @@ it('streams selected-device logs into NDJSON and uploads the exact bytes as a se
   });
   expect(await readFile(filePath)).toEqual(expected);
 
+  const mutation = jest.fn().mockReturnValue({
+    toPromise: async () => ({
+      data: {
+        deviceRunSession: {
+          createArtifactUploadSession: {
+            uploadSession: {
+              url: `${baseUrl}/upload`,
+              headers: { 'Content-Length': String(expected.length) },
+            },
+          },
+        },
+      },
+    }),
+  });
   await uploadServeSimLogsFileAsync(
-    {
-      env: { EAS_DEVICE_RUN_SESSION_TOKEN: 'device-run-session-token' },
-      expoApiV2BaseUrl: `${baseUrl}/v2/`,
-    } as unknown as CustomBuildContext,
+    { graphqlClient: { mutation } } as unknown as CustomBuildContext,
     { deviceRunSessionId: 'session-test', udid: 'device-B', filePath, logger }
   );
-  expect(uploadSessionRequest).toEqual({
-    token: 'device-run-session-token',
-    body: {
+  expect(mutation.mock.calls[0][1]).toEqual({
+    deviceRunSessionId: 'session-test',
+    input: {
       name: 'App logs (device-B)',
       filename: 'app-logs.ndjson',
       kind: 'simulator-log',

packages/build-tools/src/steps/utils/android/GooglePlayApiError.ts

@@ -1,16 +1,51 @@
-import { ErrorMetadata } from '@expo/eas-build-job';
 import { Response } from 'node-fetch';
 import { z } from 'zod';
 
-const MAX_RESPONSE_BODY_LENGTH = 8_000;
+const MAX_DETAILS = 5;
+const MAX_DETAIL_LENGTH = 500;
+
+// Reads only the human-readable parts of known google.rpc details. Other types and
+// fields, such as ErrorInfo metadata, are skipped.
+const DetailZ = z
+  .union([
+    z
+      .object({
+        '@type': z.literal('type.googleapis.com/google.rpc.ErrorInfo'),
+        reason: z.string(),
+      })
+      .transform(detail => [detail.reason]),
+    z
+      .object({
+        '@type': z.literal('type.googleapis.com/google.rpc.PreconditionFailure'),
+        violations: z.array(z.object({ type: z.string().optional(), description: z.string() })),
+      })
+      .transform(detail =>
+        detail.violations.map(({ type, description }) =>
+          type ? `${type}: ${description}` : description
+        )
+      ),
+    z
+      .object({
+        '@type': z.literal('type.googleapis.com/google.rpc.BadRequest'),
+        fieldViolations: z.array(
+          z.object({ field: z.string().optional(), description: z.string() })
+        ),
+      })
+      .transform(detail =>
+        detail.fieldViolations.map(({ field, description }) =>
+          field ? `${field}: ${description}` : description
+        )
+      ),
+  ])
+  .catch([]);
 
 export class GooglePlayApiError extends Error {
   constructor(
     readonly status: number,
     readonly apiMessage: string,
     readonly reasons: string[],
-    // Kept for Sentry only, so build logs stay short.
-    readonly diagnostics: { requestPath?: string; responseBody?: string } = {}
+    readonly details: string[] = [],
+    readonly responseBody?: unknown
   ) {
     super(`Google Play request failed (HTTP ${status})${apiMessage ? `: ${apiMessage}` : '.'}`);
   }
@@ -19,23 +54,6 @@ export class GooglePlayApiError extends Error {
     return status === 408 || status === 429 || (status >= 500 && status < 600);
   }
 
-  // Error metadata for the first Google Play API error in the cause chain. Retries and
-  // uncertain commits wrap the API error, e.g. in an AggregateError.
-  static getErrorMetadata(error: unknown): ErrorMetadata | undefined {
-    let cause = error;
-    for (let depth = 0; cause instanceof Error && depth < 5; depth++) {
-      if (cause instanceof GooglePlayApiError) {
-        return {
-          googlePlayRequestPath: cause.diagnostics.requestPath,
-          // A string, so Sentry does not cut off nested error details.
-          googlePlayErrorResponse: cause.diagnostics.responseBody,
-        };
-      }
-      cause = cause.cause;
-    }
-    return undefined;
-  }
-
   static async fromResponseAsync(
     response: Response,
     signal?: AbortSignal
@@ -52,6 +70,8 @@ export class GooglePlayApiError extends Error {
         error: z.object({
           message: z.string().optional(),
           errors: z.array(z.object({ reason: z.string().optional() })).optional(),
+          // A malformed detail must not hide the primary message.
+          details: z.array(DetailZ).catch([]),
         }),
       })
       .safeParse(data);
@@ -59,12 +79,51 @@ export class GooglePlayApiError extends Error {
       response.status,
       parsed.data?.error.message ?? '',
       parsed.data?.error.errors?.flatMap(error => (error.reason ? [error.reason] : [])) ?? [],
-      {
-        // Path only: the upload session query contains a secret.
-        requestPath: response.url ? new URL(response.url).pathname : undefined,
-        responseBody:
-          data === undefined ? undefined : JSON.stringify(data).slice(0, MAX_RESPONSE_BODY_LENGTH),
-      }
+      (parsed.data?.error.details ?? [])
+        .flat()
+        .slice(0, MAX_DETAILS)
+        .map(detail => detail.slice(0, MAX_DETAIL_LENGTH)),
+      data === undefined ? undefined : sanitizeResponseBody(data)
     );
   }
 }
+
+// Structured log properties are not covered by the worker's message secret filter.
+// Never retain headers, request bodies, non-JSON responses or unbounded API data.
+function sanitizeResponseBody(data: unknown): unknown {
+  let remainingNodes = 200;
+  const sanitize = (value: unknown, depth: number): unknown => {
+    if (--remainingNodes < 0 || depth > 6) {
+      return '[truncated]';
+    }
+    if (typeof value === 'string') {
+      return value
+        .replace(
+          /-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/g,
+          '[redacted]'
+        )
+        .replace(/https?:\/\/\S+/gi, '[URL redacted]')
+        .replace(/Bearer\s+\S+/gi, 'Bearer [redacted]')
+        .slice(0, 2000);
+    }
+    if (Array.isArray(value)) {
+      return value.slice(0, 50).map(item => sanitize(item, depth + 1));
+    }
+    if (value && typeof value === 'object') {
+      return Object.fromEntries(
+        Object.entries(value)
+          .slice(0, 50)
+          .map(([key, item]) => [
+            key.slice(0, 100),
+            /token|secret|password|authorization|cookie|credential|private.?key|email/i.test(key)
+              ? '[redacted]'
+              : sanitize(item, depth + 1),
+          ])
+      );
+    }
+    return value;
+  };
+  const sanitized = sanitize(data, 0);
+  const json = JSON.stringify(sanitized);
+  return json.length > 16000 ? { truncated: true, preview: json.slice(0, 16000) } : sanitized;
+}

packages/build-tools/src/steps/utils/android/GooglePlayUtils.ts

@@ -3,8 +3,6 @@ import { bunyan } from '@expo/logger';
 import fs from 'node:fs/promises';
 import promiseRetry from 'promise-retry';
 
-import { promiseRetryWithCondition } from '../../../utils/promiseRetryWithCondition';
-
 import { GooglePlayApiError } from './GooglePlayApiError';
 import { GooglePlayAuthRequestError } from './GooglePlayAuthClient';
 import { GooglePlayClient, ReleaseStatus } from './GooglePlayClient';
@@ -144,7 +142,7 @@ export namespace GooglePlayUtils {
       signal?: AbortSignal;
     }
   ): Promise<void> {
-    const sendCommitAsync = async ({
+    const commitOnceAsync = async ({
       changesNotSentForReview,
     }: {
       changesNotSentForReview?: boolean;
@@ -170,7 +168,7 @@ export namespace GooglePlayUtils {
         ) {
           throw new GooglePlayCommitOutcomeUnknownError(
             `Could not confirm whether Google Play saved the release for ${packageName}. Check its release status at https://play.google.com/console/ before submitting again.`,
-            { cause: error, metadata: GooglePlayApiError.getErrorMetadata(error) }
+            { cause: error, metadata: getGooglePlayErrorMetadata(error) }
           );
         }
         throw error;
@@ -181,42 +179,10 @@ export namespace GooglePlayUtils {
           : 'Google Play saved the release using its normal review process. Check its review and publishing status at https://play.google.com/console/.'
       );
     };
-    // Google can accept the bundle upload before the edit is ready to commit.
-    // Retry only this explicit rejection, not other HTTP 400 preconditions.
-    const isUploadStillProcessing = (error: unknown): boolean =>
-      error instanceof GooglePlayApiError &&
-      error.status === 400 &&
-      error.apiMessage === 'Some of the Android App Bundle uploads are not completed yet.';
-
-    const commitAsync = async (options: { changesNotSentForReview?: boolean }): Promise<void> => {
-      try {
-        await promiseRetryWithCondition(
-          sendCommitAsync,
-          error => {
-            signal?.throwIfAborted();
-            return isUploadStillProcessing(error);
-          },
-          { retries: 13, factor: 2, minTimeout: 2000, maxTimeout: 32_000 },
-          ({ attemptNumber, maxAttemptsCount }) => {
-            logger.warn(
-              `Google Play is still processing the uploaded bundle. Retrying the same edit commit (attempt ${attemptNumber}/${maxAttemptsCount}).`
-            );
-          }
-        )(options);
-      } catch (error) {
-        if (isUploadStillProcessing(error)) {
-          throw new SystemError(
-            `Google Play did not finish processing the uploaded bundle for ${packageName} within five minutes. Wait a few minutes, then check the release at https://play.google.com/console/ before submitting again.`,
-            { cause: error, metadata: GooglePlayApiError.getErrorMetadata(error) }
-          );
-        }
-        throw error;
-      }
-    };
     try {
       // Omit the optional parameter for normal review submission. Some app states
       // reject its presence, even when false. True saves changes for review in Console.
-      await commitAsync({ changesNotSentForReview: changesNotSentForReview || undefined });
+      await commitOnceAsync({ changesNotSentForReview: changesNotSentForReview || undefined });
     } catch (error) {
       if (!(error instanceof GooglePlayApiError) || error.status !== 400) {
         throw error;
@@ -229,7 +195,7 @@ export namespace GooglePlayUtils {
         logger.warn(
           'Google does not allow changesNotSentForReview for this app right now. Retrying commit once without it. The changes will be sent for review.'
         );
-        await commitAsync({});
+        await commitOnceAsync({});
       } else if (
         !changesNotSentForReview &&
         error.apiMessage.includes('Please set the query parameter changesNotSentForReview to true')
@@ -237,24 +203,29 @@ export namespace GooglePlayUtils {
         logger.warn(
           'Google requires changesNotSentForReview=true. Retrying commit once. Send the saved changes for review from Play Console.'
         );
-        await commitAsync({ changesNotSentForReview: true });
+        await commitOnceAsync({ changesNotSentForReview: true });
       } else {
         throw error;
       }
     }
   }
 
-  export function mapGooglePlayError(error: unknown, packageName: string): unknown {
+  // `action` names the failed submission phase, e.g. "create a Google Play edit".
+  // Other errors already describe themselves and are returned unchanged.
+  export function mapGooglePlayError(
+    error: unknown,
+    { packageName, action }: { packageName: string; action: string }
+  ): unknown {
     if (error instanceof AggregateError) {
-      return mapGooglePlayError(error.cause, packageName);
+      return mapGooglePlayError(error.cause, { packageName, action });
     }
     if (
       (error instanceof GooglePlayApiError || error instanceof GooglePlayAuthRequestError) &&
       GooglePlayApiError.isRetryableStatus(error.status)
     ) {
       return new SystemError(
-        `Google Play is temporarily unavailable or rate limited (HTTP ${error.status}). Try again later.`,
-        { cause: error, metadata: GooglePlayApiError.getErrorMetadata(error) }
+        `Could not ${action}. Google Play is temporarily unavailable or rate limited (HTTP ${error.status}). Try again later.`,
+        { cause: error, metadata: getGooglePlayErrorMetadata(error) }
       );
     }
     if (
@@ -265,7 +236,7 @@ export namespace GooglePlayUtils {
     ) {
       return new UserError(
         'EAS_GOOGLE_PLAY_INVALID_CREDENTIALS',
-        `Google rejected the service-account key (${error.errorCode ?? `HTTP ${error.status}`}). Check that the key is valid and the service account is enabled.`,
+        `Could not ${action}. Google rejected the service-account key (${error.errorCode ?? `HTTP ${error.status}`}). Check that the key is valid and the service account is enabled.`,
         { cause: error }
       );
     }
@@ -314,10 +285,28 @@ export namespace GooglePlayUtils {
       code = 'EAS_GOOGLE_PLAY_INVALID_RELEASE';
       detail = `Google Play rejected the release or review settings${message ? `: ${message}` : '.'} Check the track, release status, rollout, and review settings in Play Console.`;
     }
+    const googleDetails = error.details.length
+      ? `\n\nGoogle Play details:\n${error.details.map(item => `- ${item}`).join('\n')}`
+      : '';
     return new UserError(
       code,
-      `${detail}\n\nApp: ${packageName}\nGoogle Play Console: https://play.google.com/console/`,
-      { cause: error, metadata: GooglePlayApiError.getErrorMetadata(error) }
+      `Could not ${action}. ${detail}${googleDetails}\n\nApp: ${packageName}\nGoogle Play Console: https://play.google.com/console/`,
+      {
+        cause: error,
+        metadata: getGooglePlayErrorMetadata(error),
+      }
     );
   }
+
+  export function getGooglePlayErrorMetadata(error: unknown): Record<string, unknown> | undefined {
+    // Retries and uncertain commits wrap the last API error in cause.
+    const seen = new Set<Error>();
+    for (let cause = error; cause instanceof Error && !seen.has(cause); cause = cause.cause) {
+      seen.add(cause);
+      if (cause instanceof GooglePlayApiError && cause.responseBody !== undefined) {
+        return { googlePlayHttpStatus: cause.status, googlePlayErrorResponse: cause.responseBody };
+      }
+    }
+    return undefined;
+  }
 }

packages/build-tools/src/steps/utils/android/__tests__/GooglePlayApiError.test.ts

@@ -0,0 +1,92 @@
+import { Response } from 'node-fetch';
+
+import { GooglePlayApiError } from '../GooglePlayApiError';
+
+jest.unmock('node-fetch');
+
+function fromBody(error: unknown): Promise<GooglePlayApiError> {
+  return GooglePlayApiError.fromResponseAsync(
+    new Response(JSON.stringify({ error }), { status: 400 })
+  );
+}
+
+it('keeps readable Google details and skips metadata, unknown types and malformed entries', async () => {
+  const error = await fromBody({
+    message: 'Precondition check failed.',
+    errors: [{ reason: 'failedPrecondition' }],
+    details: [
+      {
+        '@type': 'type.googleapis.com/google.rpc.ErrorInfo',
+        reason: 'APP_NOT_READY',
+        metadata: { project: 'PRIVATE' },
+      },
+      {
+        '@type': 'type.googleapis.com/google.rpc.PreconditionFailure',
+        violations: [{ type: 'APP_SETUP', subject: 'PRIVATE', description: 'Complete setup.' }],
+      },
+      {
+        '@type': 'type.googleapis.com/google.rpc.BadRequest',
+        fieldViolations: [{ field: 'releases[0]', description: 'Invalid rollout.' }],
+      },
+      { '@type': 'type.googleapis.com/google.rpc.DebugInfo', detail: 'PRIVATE' },
+      { '@type': 'type.googleapis.com/google.rpc.PreconditionFailure', violations: 'invalid' },
+      null,
+    ],
+  });
+  expect(error).toMatchObject({
+    apiMessage: 'Precondition check failed.',
+    reasons: ['failedPrecondition'],
+    details: ['APP_NOT_READY', 'APP_SETUP: Complete setup.', 'releases[0]: Invalid rollout.'],
+  });
+  expect(JSON.stringify(error.details)).not.toContain('PRIVATE');
+});
+
+it('retains the JSON response with bounded and redacted diagnostic fields', async () => {
+  const error = await fromBody({
+    message: 'Denied',
+    status: 'FAILED_PRECONDITION',
+    details: [
+      {
+        '@type': 'unknown',
+        explanation: 'Useful extra detail',
+        metadata: {
+          access_token: 'SECRET',
+          password: 'SECRET',
+          url: 'https://example.com?token=SECRET',
+          description: 'Bearer SECRET',
+          private_key: 'SECRET',
+        },
+      },
+    ],
+    extra: 'x'.repeat(100000),
+  });
+  const body = JSON.stringify(error.responseBody);
+  expect(body).toContain('Useful extra detail');
+  expect(body).toContain('FAILED_PRECONDITION');
+  expect(body).not.toContain('SECRET');
+  expect(body.length).toBeLessThan(17000);
+});
+
+it('does not retain a non-JSON error response', async () => {
+  const error = await GooglePlayApiError.fromResponseAsync(new Response('SECRET', { status: 502 }));
+  expect(error.responseBody).toBeUndefined();
+});
+
+it('keeps the primary error when details is not a list', async () => {
+  const error = await fromBody({ message: 'Denied', details: { '@type': 'unknown' } });
+  expect(error).toMatchObject({ apiMessage: 'Denied', details: [] });
+});
+
+it('bounds the number and length of details', async () => {
+  const error = await fromBody({
+    message: 'Invalid request.',
+    details: [
+      {
+        '@type': 'type.googleapis.com/google.rpc.BadRequest',
+        fieldViolations: Array.from({ length: 20 }, () => ({ description: 'x'.repeat(10_000) })),
+      },
+    ],
+  });
+  expect(error.details).toHaveLength(5);
+  expect(error.details.every(detail => detail.length === 500)).toBe(true);
+});

packages/build-tools/src/steps/utils/android/__tests__/GooglePlaySubmission.test.ts

@@ -1,13 +1,12 @@
 import { SystemError, UserError } from '@expo/eas-build-job';
 import nock from 'nock';
-import { Response } from 'node-fetch';
 
 import { api, editPath, mockToken, packageName, serviceAccount } from './googlePlayTestUtils';
 import { createMockLogger } from '../../../../__tests__/utils/logger';
 import { GooglePlayAuthRequestError } from '../GooglePlayAuthClient';
 import { GooglePlayApiError } from '../GooglePlayApiError';
 import { GooglePlayClient } from '../GooglePlayClient';
-import { GooglePlayCommitOutcomeUnknownError, GooglePlayUtils } from '../GooglePlayUtils';
+import { GooglePlayUtils } from '../GooglePlayUtils';
 
 jest.unmock('node-fetch');
 jest.mock('promise-retry', () => {
@@ -15,6 +14,7 @@ jest.mock('promise-retry', () => {
   return (fn: Parameters<typeof actual>[0], options: object) =>
     actual(fn, { ...options, minTimeout: 1, maxTimeout: 1, randomize: false });
 });
+const action = 'upload the AAB';
 beforeEach(() => nock.disableNetConnect());
 afterEach(() => {
   const pending = nock.pendingMocks();
@@ -90,74 +90,6 @@ it('preserves cancellation before commit is sent', async () => {
   controller.abort(reason);
   await expect(commit({ signal: controller.signal })).rejects.toBe(reason);
 });
-const pendingUploadMessage = 'Some of the Android App Bundle uploads are not completed yet.';
-
-it.each([false, true])(
-  'waits for bundle processing without changing review settings (%s)',
-  async changesNotSentForReview => {
-    const logger = createMockLogger();
-    const query = changesNotSentForReview ? { changesNotSentForReview: 'true' } : {};
-    mockToken();
-    api()
-      .post(`${editPath}:commit`, {})
-      .query(query)
-      .reply(400, { error: { message: pendingUploadMessage } });
-    api().post(`${editPath}:commit`, {}).query(query).reply(200, { id: 'edit' });
-    await expect(commit({ changesNotSentForReview, logger })).resolves.toBeUndefined();
-    expect(logger.warn).toHaveBeenCalledWith(
-      expect.stringContaining('Google Play is still processing')
-    );
-  }
-);
-
-it('stops waiting for bundle processing after 14 attempts', async () => {
-  mockToken();
-  api()
-    .post(`${editPath}:commit`)
-    .query({})
-    .times(14)
-    .reply(400, { error: { message: pendingUploadMessage } });
-  const error = await commit().catch(error => error);
-  expect(GooglePlayUtils.mapGooglePlayError(error, packageName)).toMatchObject({
-    message: expect.stringContaining('Google Play did not finish processing'),
-    metadata: {
-      googlePlayRequestPath: `${editPath}:commit`,
-      googlePlayErrorResponse: JSON.stringify({ error: { message: pendingUploadMessage } }),
-    },
-  });
-});
-
-it('does not retry an unrelated commit precondition', async () => {
-  mockToken();
-  api()
-    .post(`${editPath}:commit`)
-    .query({})
-    .reply(400, { error: { message: 'Precondition check failed.' } });
-  await expect(commit()).rejects.toBeInstanceOf(GooglePlayApiError);
-});
-
-it('checks cancellation before sending a processing retry', async () => {
-  const controller = new AbortController();
-  const reason = new Error('cancelled while waiting');
-  const logger = createMockLogger();
-  jest.spyOn(logger, 'warn').mockImplementation(() => controller.abort(reason));
-  mockToken();
-  api()
-    .post(`${editPath}:commit`)
-    .query({})
-    .reply(400, { error: { message: pendingUploadMessage } });
-  await expect(commit({ signal: controller.signal, logger })).rejects.toBe(reason);
-});
-
-it('does not report success if a processing retry has no valid commit receipt', async () => {
-  mockToken();
-  api()
-    .post(`${editPath}:commit`)
-    .query({})
-    .reply(400, { error: { message: pendingUploadMessage } });
-  api().post(`${editPath}:commit`).query({}).reply(200, { id: 'different-edit' });
-  await expect(commit()).rejects.toBeInstanceOf(GooglePlayCommitOutcomeUnknownError);
-});
 it('preserves OAuth rejection before commit is sent', async () => {
   nock('https://oauth2.googleapis.com').post('/token').reply(400, { error: 'invalid_grant' });
   await expect(commit()).rejects.toBeInstanceOf(GooglePlayAuthRequestError);
@@ -174,13 +106,17 @@ it.each([
   [409, 'edit invalid', 'EAS_GOOGLE_PLAY_EDIT_INVALID'],
   [400, 'unknown track', 'EAS_GOOGLE_PLAY_INVALID_RELEASE'],
 ] as const)('keeps the Google error behind %s %s', (status, message, code) => {
-  const original = new GooglePlayApiError(status, message, []);
-  const mapped = GooglePlayUtils.mapGooglePlayError(original, packageName);
+  const original = new GooglePlayApiError(status, message, [], ['APP_SETUP: Complete setup.']);
+  const mapped = GooglePlayUtils.mapGooglePlayError(original, { packageName, action });
   expect(mapped).toBeInstanceOf(UserError);
   expect(mapped).toMatchObject({
     errorCode: code,
     cause: original,
   });
+  expect((mapped as Error).message).toMatch(/^Could not upload the AAB\. /);
+  expect((mapped as Error).message).toContain(
+    'Google Play details:\n- APP_SETUP: Complete setup.\n\nApp:'
+  );
   if (code === 'EAS_GOOGLE_PLAY_REQUEST_FAILED' || code === 'EAS_GOOGLE_PLAY_INVALID_RELEASE') {
     expect((mapped as Error).message).toContain(message);
   } else {
@@ -196,8 +132,9 @@ it.each([
 });
 it('maps a rejected OAuth key to a credential error', () => {
   const original = new GooglePlayAuthRequestError(400, 'invalid_grant');
-  expect(GooglePlayUtils.mapGooglePlayError(original, packageName)).toMatchObject({
+  expect(GooglePlayUtils.mapGooglePlayError(original, { packageName, action })).toMatchObject({
     errorCode: 'EAS_GOOGLE_PLAY_INVALID_CREDENTIALS',
+    message: expect.stringMatching(/^Could not upload the AAB\. /),
     cause: original,
   });
 });
@@ -206,66 +143,16 @@ it.each([408, 429, 500, 503])('classifies temporary HTTP %s errors as system err
     new GooglePlayApiError(status, 'temporary failure', []),
     new GooglePlayAuthRequestError(status, 'temporarily_unavailable'),
   ]) {
-    const mapped = GooglePlayUtils.mapGooglePlayError(original, packageName);
+    const mapped = GooglePlayUtils.mapGooglePlayError(original, { packageName, action });
     expect(mapped).toBeInstanceOf(SystemError);
-    expect(mapped).toMatchObject({ cause: original });
+    expect(mapped).toMatchObject({
+      message: expect.stringMatching(/^Could not upload the AAB\. /),
+      cause: original,
+    });
     expect((mapped as Error).message).not.toContain('settings');
   }
 });
 it('keeps non-Google errors unchanged', () => {
   const error = new SystemError('file failure');
-  expect(GooglePlayUtils.mapGooglePlayError(error, packageName)).toBe(error);
-});
-it('keeps the Google Play error response in metadata, not in the message', async () => {
-  const response = {
-    error: {
-      code: 400,
-      message: 'Precondition check failed.',
-      status: 'FAILED_PRECONDITION',
-      details: [
-        {
-          '@type': 'type.googleapis.com/google.rpc.PreconditionFailure',
-          violations: [{ type: 'APP_SETUP', description: 'Complete the app setup.' }],
-        },
-      ],
-    },
-  };
-  mockToken();
-  api().post(`${editPath}:commit`).query({}).reply(400, response);
-  const error = await commit().catch(error => error);
-  const mapped = GooglePlayUtils.mapGooglePlayError(error, packageName);
-  expect(mapped).toMatchObject({
-    errorCode: 'EAS_GOOGLE_PLAY_INVALID_RELEASE',
-    metadata: {
-      googlePlayRequestPath: `${editPath}:commit`,
-      googlePlayErrorResponse: JSON.stringify(response),
-    },
-  });
-  expect((mapped as Error).message).not.toContain('APP_SETUP');
-});
-it('keeps the last Google Play error response when the commit outcome is unknown', async () => {
-  mockToken();
-  api()
-    .post(`${editPath}:commit`)
-    .query({})
-    .times(6)
-    .reply(503, { error: { message: 'Backend error' } });
-  await expect(commit()).rejects.toMatchObject({
-    metadata: {
-      googlePlayRequestPath: `${editPath}:commit`,
-      googlePlayErrorResponse: JSON.stringify({ error: { message: 'Backend error' } }),
-    },
-  });
-});
-it('does not keep the upload session query or a non-JSON response', async () => {
-  const error = await GooglePlayApiError.fromResponseAsync(
-    new Response('<html>upload_id=SECRET</html>', {
-      status: 400,
-      url: 'https://androidpublisher.googleapis.com/upload/session?upload_id=SECRET',
-    })
-  );
-  expect(GooglePlayApiError.getErrorMetadata(error)).toEqual({
-    googlePlayRequestPath: '/upload/session',
-    googlePlayErrorResponse: undefined,
-  });
+  expect(GooglePlayUtils.mapGooglePlayError(error, { packageName, action })).toBe(error);
 });

packages/build-tools/src/steps/utils/artifactPut.ts

@@ -0,0 +1,120 @@
+import { SystemError } from '@expo/eas-build-job';
+import fetch, { Headers } from 'node-fetch';
+import type { Readable } from 'node:stream';
+import { finished } from 'node:stream/promises';
+import { setTimeout as delay } from 'node:timers/promises';
+
+import { AbortUtils } from '../../utils/AbortUtils';
+
+export type ArtifactUploadSession = { url: string; headers: unknown };
+export type ArtifactSource = { openStream: () => Readable };
+
+export async function putArtifactWithRetriesAsync(
+  {
+    uploadSession,
+    source,
+    signal,
+  }: {
+    uploadSession: ArtifactUploadSession;
+    source: ArtifactSource;
+    signal?: AbortSignal;
+  },
+  { attempts = 1 }: { attempts?: number } = {}
+): Promise<void> {
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    signal?.throwIfAborted();
+    const stream = source.openStream();
+    // Upload time scales with file size, so the deadline bounds stalls, not the whole request.
+    const timeout = AbortUtils.resettableTimeout(90_000);
+    try {
+      await putArtifactAsync({
+        uploadSession,
+        stream,
+        signal: signal ? AbortSignal.any([signal, timeout.signal]) : timeout.signal,
+        onProgress: timeout.resetDeadline,
+      });
+      return;
+    } catch (error) {
+      signal?.throwIfAborted();
+      const retryable =
+        error instanceof ArtifactPutError
+          ? [408, 429, 500, 502, 503, 504].includes(error.status)
+          : timeout.signal.aborted || error instanceof ArtifactPutNetworkError;
+      if (!retryable || attempt + 1 === attempts) {
+        throw error;
+      }
+      await delay(500 * (attempt + 1), undefined, { signal });
+    } finally {
+      stream.destroy();
+      await finished(stream).catch(() => {});
+    }
+  }
+}
+
+async function putArtifactAsync({
+  uploadSession,
+  stream,
+  signal,
+  onProgress,
+}: {
+  uploadSession: ArtifactUploadSession;
+  stream: Readable;
+  signal: AbortSignal;
+  onProgress: () => void;
+}): Promise<void> {
+  const requestController = new AbortController();
+  try {
+    const responding = fetch(uploadSession.url, {
+      method: 'PUT',
+      headers: new Headers(uploadSession.headers as Record<string, string>),
+      body: stream,
+      signal: AbortSignal.any([signal, requestController.signal]),
+    });
+    // fetch has piped the body already, so this listener observes flow without starting it.
+    stream.on('data', onProgress);
+    let response;
+    try {
+      response = await responding;
+    } catch (error) {
+      signal.throwIfAborted();
+      throw error instanceof Error && error.name === 'FetchError'
+        ? new ArtifactPutNetworkError(error)
+        : error;
+    }
+    signal.throwIfAborted();
+    if (!response.ok) {
+      throw new ArtifactPutError(response);
+    }
+  } finally {
+    // node-fetch destroys the request body on abort, and its response stream is a PassThrough
+    // whose destruction leaves the socket open, so the request itself is aborted here.
+    requestController.abort();
+  }
+}
+
+export class ArtifactPutError extends SystemError {
+  readonly status: number;
+  readonly reason: string;
+
+  constructor(response: { status: number; statusText: string }) {
+    const reason = `HTTP ${response.status} ${response.statusText}`;
+    super(`Artifact PUT failed: ${reason}.`);
+    this.status = response.status;
+    this.reason = reason;
+  }
+}
+
+// node-fetch names the request URL in its message, and here that URL is signed. The message keeps
+// only the error code, and the original is not kept as the cause because loggers and Sentry print causes.
+export class ArtifactPutNetworkError extends SystemError {
+  readonly code: string | undefined;
+  readonly reason: string;
+
+  constructor(error: Error & { code?: unknown }) {
+    const code = typeof error.code === 'string' ? error.code : undefined;
+    const reason = code ?? 'network error';
+    super(`Artifact PUT failed: ${reason}.`);
+    this.code = code;
+    this.reason = reason;
+  }
+}

packages/build-tools/src/steps/utils/deviceRunSessionArtifacts.ts

@@ -1,15 +1,33 @@
 import { SystemError } from '@expo/eas-build-job';
-import type { Readable } from 'node:stream';
+import { graphql } from 'gql.tada';
 
 import { CustomBuildContext } from '../../customBuildContext';
+import { graphqlAbortContext } from '../../utils/graphqlAbort';
 import {
-  type SignedUrl,
-  SignedUrlUploadApiError,
-  SignedUrlUploadNetworkError,
-  uploadWithSignedUrl,
-} from '../../storage/uploadWithSignedUrl';
+  ArtifactPutError,
+  ArtifactPutNetworkError,
+  type ArtifactSource,
+  type ArtifactUploadSession,
+  putArtifactWithRetriesAsync,
+} from './artifactPut';
 import { withDeviceRunSessionTimeoutAsync } from './deviceRunSessionTimeout';
-import { requireDeviceRunSessionWorkerApi } from './deviceRunSessionWorkerApi';
+import { getDeviceRunSessionWorkerApi } from './deviceRunSessionWorkerApi';
+
+const CREATE_DEVICE_RUN_SESSION_ARTIFACT_UPLOAD_SESSION_MUTATION = graphql(`
+  mutation CreateDeviceRunSessionArtifactUploadSession(
+    $deviceRunSessionId: ID!
+    $input: CreateDeviceRunSessionArtifactUploadSessionInput!
+  ) {
+    deviceRunSession {
+      createArtifactUploadSession(deviceRunSessionId: $deviceRunSessionId, input: $input) {
+        uploadSession {
+          url
+          headers
+        }
+      }
+    }
+  }
+`);
 
 type ArtifactMetadata = {
   deviceRunSessionId: string;
@@ -23,11 +41,7 @@ type ArtifactMetadata = {
 
 export async function uploadDeviceRunSessionArtifactAsync(
   ctx: CustomBuildContext,
-  options: ArtifactMetadata & {
-    openStream: () => Readable;
-    signal?: AbortSignal;
-    attempts?: number;
-  }
+  options: ArtifactMetadata & ArtifactSource & { signal?: AbortSignal; attempts?: number }
 ): Promise<void> {
   try {
     const uploadSession = await withDeviceRunSessionTimeoutAsync(
@@ -35,12 +49,12 @@ export async function uploadDeviceRunSessionArtifactAsync(
       async signal => await createDeviceRunSessionArtifactUploadSessionAsync(ctx, options, signal)
     );
     options.signal?.throwIfAborted();
-    await uploadWithSignedUrl(
-      { signedUrl: uploadSession, srcGeneratorAsync: async () => options.openStream() },
-      { signal: options.signal, retries: (options.attempts ?? 1) - 1, retryIntervalMs: 500 }
+    await putArtifactWithRetriesAsync(
+      { uploadSession, source: options, signal: options.signal },
+      { attempts: options.attempts }
     );
   } catch (error) {
-    if (error instanceof SignedUrlUploadApiError || error instanceof SignedUrlUploadNetworkError) {
+    if (error instanceof ArtifactPutError || error instanceof ArtifactPutNetworkError) {
       throw new DeviceRunSessionArtifactUploadError(options.artifactId, error.reason);
     }
     throw error;
@@ -57,29 +71,55 @@ async function createDeviceRunSessionArtifactUploadSessionAsync(
   ctx: CustomBuildContext,
   { deviceRunSessionId, artifactId, name, filename, kind, metadata, size }: ArtifactMetadata,
   signal: AbortSignal
-): Promise<SignedUrl> {
-  const workerApi = requireDeviceRunSessionWorkerApi(ctx);
-  let uploadSession: SignedUrl;
-  try {
-    uploadSession = await workerApi.createArtifactUploadSessionAsync(
-      {
-        name,
-        filename,
-        ...(kind !== undefined ? { kind } : {}),
-        ...(metadata !== undefined ? { metadata } : {}),
-        size,
-      },
-      { signal }
-    );
-  } catch (err) {
+): Promise<ArtifactUploadSession> {
+  const workerApi = getDeviceRunSessionWorkerApi(ctx);
+  if (workerApi) {
+    let uploadSession: ArtifactUploadSession;
+    try {
+      uploadSession = await workerApi.createArtifactUploadSessionAsync(
+        {
+          name,
+          filename,
+          ...(kind !== undefined ? { kind } : {}),
+          ...(metadata !== undefined ? { metadata } : {}),
+          size,
+        },
+        { signal }
+      );
+    } catch (err) {
+      signal.throwIfAborted();
+      throw new SystemError(
+        `Failed to create upload session for device run session artifact ${artifactId}: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+        { cause: err }
+      );
+    }
     signal.throwIfAborted();
+    return uploadSession;
+  }
+  const result = await ctx.graphqlClient
+    .mutation(
+      CREATE_DEVICE_RUN_SESSION_ARTIFACT_UPLOAD_SESSION_MUTATION,
+      {
+        deviceRunSessionId,
+        input: {
+          name,
+          filename,
+          ...(kind !== undefined ? { kind } : {}),
+          ...(metadata !== undefined ? { metadata } : {}),
+          size,
+        },
+      },
+      graphqlAbortContext(signal)
+    )
+    .toPromise();
+  signal.throwIfAborted();
+  if (result.error) {
     throw new SystemError(
-      `Failed to create upload session for device run session artifact ${artifactId}: ${
-        err instanceof Error ? err.message : String(err)
-      }`,
-      { cause: err }
+      `Failed to create upload session for device run session artifact ${artifactId}: ${result.error.message}`,
+      { cause: result.error }
     );
   }
-  signal.throwIfAborted();
-  return uploadSession;
+  return result.data!.deviceRunSession.createArtifactUploadSession.uploadSession;
 }

packages/build-tools/src/steps/utils/deviceRunSessionEvents.ts

@@ -1,5 +1,6 @@
 import { SystemError } from '@expo/eas-build-job';
 import { type bunyan } from '@expo/logger';
+import { graphql } from 'gql.tada';
 import fs from 'node:fs';
 import { StringDecoder } from 'node:string_decoder';
 import { setTimeout as setTimeoutAsync } from 'node:timers/promises';
@@ -9,13 +10,26 @@ import HttpLogStream from '../../logging/HttpLogStream';
 import RemoteLoggerStream from '../../logging/RemoteLoggerStream';
 import { Sentry } from '../../sentry';
 import { type SignedUrl } from '../../storage/uploadWithSignedUrl';
-import { requireDeviceRunSessionWorkerApi } from './deviceRunSessionWorkerApi';
+import { getDeviceRunSessionWorkerApi } from './deviceRunSessionWorkerApi';
 
 const POLL_INTERVAL_MS = 1_000;
 const UPLOAD_INTERVAL_MS = 5_000;
 const EAS_LOGS_THREAD = 'session-events';
 const EAS_LOGS_BUFFER_RETENTION_MS = 30_000;
 
+const CREATE_DEVICE_RUN_SESSION_EVENT_LOG_UPLOAD_SESSION_MUTATION = graphql(`
+  mutation CreateDeviceRunSessionEventLogUploadSession($deviceRunSessionId: ID!) {
+    deviceRunSession {
+      createEventLogUploadSession(deviceRunSessionId: $deviceRunSessionId) {
+        uploadSession {
+          url
+          headers
+        }
+      }
+    }
+  }
+`);
+
 /**
  * The normalized, producer-agnostic event shape uploaded to the API server.
  * Every remote-session producer (agent-device, argent, ...) tails its own
@@ -336,17 +350,35 @@ async function createEventLogUploadSessionAsync(
   ctx: CustomBuildContext,
   deviceRunSessionId: string
 ): Promise<SignedUrl> {
-  const workerApi = requireDeviceRunSessionWorkerApi(ctx);
-  try {
-    return await workerApi.createEventLogUploadSessionAsync();
-  } catch (err) {
+  const workerApi = getDeviceRunSessionWorkerApi(ctx);
+  if (workerApi) {
+    try {
+      return await workerApi.createEventLogUploadSessionAsync();
+    } catch (err) {
+      throw new SystemError(
+        `Failed to create device run session event log upload session: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+        { cause: err }
+      );
+    }
+  }
+  const result = await ctx.graphqlClient
+    .mutation(CREATE_DEVICE_RUN_SESSION_EVENT_LOG_UPLOAD_SESSION_MUTATION, {
+      deviceRunSessionId,
+    })
+    .toPromise();
+  if (result.error) {
     throw new SystemError(
-      `Failed to create device run session event log upload session: ${
-        err instanceof Error ? err.message : String(err)
-      }`,
-      { cause: err }
+      `Failed to create device run session event log upload session: ${result.error.message}`,
+      { cause: result.error }
     );
   }
+  const uploadSession = result.data!.deviceRunSession.createEventLogUploadSession.uploadSession;
+  return {
+    url: uploadSession.url,
+    headers: uploadSession.headers as Record<string, string>,
+  };
 }
 
 async function collectEventFileAsync({

packages/build-tools/src/steps/utils/deviceRunSessionPreview.ts

@@ -2,6 +2,8 @@ import { type bunyan } from '@expo/logger';
 import { asyncResult } from '@expo/results';
 import { BuildRuntimePlatform, type BuildStepEnv } from '@expo/steps';
 import spawn, { type SpawnOptions } from '@expo/turtle-spawn';
+import { graphql } from 'gql.tada';
+import fetch from 'node-fetch';
 import { createWriteStream } from 'node:fs';
 import { pipeline } from 'node:stream/promises';
 import { mkdtemp, readFile, rm } from 'node:fs/promises';
@@ -9,14 +11,51 @@ import os from 'node:os';
 import path from 'node:path';
 
 import { type CustomBuildContext } from '../../customBuildContext';
-import { uploadContentWithSignedUrl } from '../../storage/uploadWithSignedUrl';
 import { killProcessGroup } from '../../utils/processes';
-import { requireDeviceRunSessionWorkerApi } from './deviceRunSessionWorkerApi';
+import { getDeviceRunSessionWorkerApi } from './deviceRunSessionWorkerApi';
 
 const PREVIEW_INTERVAL_MS = 60_000;
 const PREVIEW_MAX_DIMENSION = 320;
 const PREVIEW_QUALITY = 70;
 const MAX_PREVIEW_SIZE_BYTES = 5 * 1024 * 1024;
+const CREATE_PREVIEW_UPLOAD_SESSION_MUTATION = graphql(`
+  mutation CreateDeviceRunSessionPreviewUploadSession($deviceRunSessionId: ID!) {
+    deviceRunSession {
+      createPreviewUploadSession(deviceRunSessionId: $deviceRunSessionId) {
+        uploadSession {
+          url
+          headers
+        }
+      }
+    }
+  }
+`);
+
+/**
+ * node-fetch includes the request URL in its error messages, and this URL is a signed upload URL
+ * that is valid for the whole session. Replace such errors with one that names only the failure.
+ */
+async function putPreviewAsync(
+  uploadSession: { url: string; headers: Record<string, string> },
+  { image, signal }: { image: Buffer; signal: AbortSignal }
+): Promise<Awaited<ReturnType<typeof fetch>>> {
+  try {
+    return await fetch(uploadSession.url, {
+      method: 'PUT',
+      headers: uploadSession.headers,
+      body: image,
+      signal,
+      timeout: 30_000,
+    });
+  } catch (err) {
+    const { name, type, code } = err as { name?: unknown; type?: unknown; code?: unknown };
+    const details = Object.entries({ name, type, code })
+      .filter(([, value]) => typeof value === 'string' && value.length > 0)
+      .map(([key, value]) => `${key}: ${value}`)
+      .join(', ');
+    throw new Error(`Session preview upload request failed (${details || 'unknown error'}).`);
+  }
+}
 
 export function startDeviceRunSessionPreview({
   ctx,
@@ -50,10 +89,10 @@ export function startDeviceRunSessionPreview({
       if (controller.signal.aborted) {
         return;
       }
-      await uploadContentWithSignedUrl(
-        { signedUrl: uploadSession, content: image },
-        { signal, retries: 0, stallTimeoutMs: 30_000 }
-      );
+      const response = await putPreviewAsync(uploadSession, { image, signal });
+      if (!response.ok) {
+        throw new Error(`Session preview upload failed: ${response.status} ${response.statusText}`);
+      }
     } catch (err) {
       if (!controller.signal.aborted) {
         logger.warn({ err }, 'Could not refresh the session preview; retrying in 60 seconds.');
@@ -83,7 +122,35 @@ async function createPreviewUploadSessionAsync(
   deviceRunSessionId: string,
   signal: AbortSignal
 ): Promise<{ url: string; headers: Record<string, string> }> {
-  return await requireDeviceRunSessionWorkerApi(ctx).createPreviewUploadSessionAsync({ signal });
+  const workerApi = getDeviceRunSessionWorkerApi(ctx);
+  if (workerApi) {
+    return await workerApi.createPreviewUploadSessionAsync({ signal });
+  }
+  const result = await ctx.graphqlClient
+    .mutation(
+      CREATE_PREVIEW_UPLOAD_SESSION_MUTATION,
+      { deviceRunSessionId },
+      {
+        // Keep the client's auth headers and combine cancellation after URQL sets its signal.
+        fetch: (url, options) =>
+          globalThis.fetch(url, {
+            ...options,
+            signal: AbortSignal.any([signal, ...(options?.signal ? [options.signal] : [])]),
+          }),
+      }
+    )
+    .toPromise();
+  if (result.error) {
+    throw result.error;
+  }
+  const session = result.data?.deviceRunSession.createPreviewUploadSession.uploadSession;
+  if (!session) {
+    throw new Error('No session preview upload URL was returned.');
+  }
+  return {
+    url: session.url,
+    headers: session.headers as Record<string, string>,
+  };
 }
 
 /**

packages/build-tools/src/steps/utils/deviceRunSessionScreenRecordings.ts

@@ -5,7 +5,6 @@ import spawn from '@expo/turtle-spawn';
 import { createReadStream } from 'node:fs';
 import { readFile, readdir, stat } from 'node:fs/promises';
 import path from 'node:path';
-import { Readable } from 'node:stream';
 import limitFactory from 'promise-limit';
 import { z } from 'zod';
 
@@ -141,8 +140,9 @@ export async function uploadDeviceRunSessionScreenRecordingsAsync(
     recordings.map(recording =>
       limit(async () => {
         try {
-          const manifest = await readFile(path.join(recording.directory, 'session.json'));
-          const metadata = RecordingManifestSchema.parse(JSON.parse(manifest.toString('utf-8')));
+          const metadata = RecordingManifestSchema.parse(
+            JSON.parse(await readFile(path.join(recording.directory, 'session.json'), 'utf-8'))
+          );
           if (path.basename(metadata.recording) !== metadata.recording) {
             throw new Error('Recording filename must not contain a directory.');
           }
@@ -186,31 +186,6 @@ export async function uploadDeviceRunSessionScreenRecordingsAsync(
             openStream: () => createReadStream(recordingPath),
             attempts: 3,
           });
-          try {
-            await uploadDeviceRunSessionArtifactAsync(ctx, {
-              deviceRunSessionId,
-              artifactId: `${recordingId}-metadata`,
-              name: `${displayName} metadata`,
-              filename: `${recordingId}.json`,
-              kind: 'screen-recording-metadata',
-              metadata: {
-                __eas_type: 'screen-recording-metadata',
-                recordingFilename: `${recordingId}.mp4`,
-                udid: recording.udid,
-              },
-              size: manifest.length,
-              openStream: () => Readable.from(manifest),
-              attempts: 3,
-            });
-          } catch (err) {
-            const error = err instanceof Error ? err : new Error(String(err));
-            Sentry.capture('Could not upload device screen recording metadata', error);
-            logger.warn(
-              { err: error },
-              `Could not upload screen recording metadata for ${recording.deviceName}.`
-            );
-            return false;
-          }
           return true;
         } catch (err) {
           const error = err instanceof Error ? err : new Error(String(err));

packages/build-tools/src/steps/utils/deviceRunSessionScreenshotNames.ts

@@ -1,8 +1,11 @@
 import type { bunyan } from '@expo/logger';
 import { BuildRuntimePlatform } from '@expo/steps';
+import { graphql } from 'gql.tada';
+import { z } from 'zod';
 
 import type { CustomBuildContext } from '../../customBuildContext';
-import { requireDeviceRunSessionWorkerApi } from './deviceRunSessionWorkerApi';
+import { graphqlAbortContext } from '../../utils/graphqlAbort';
+import { getDeviceRunSessionWorkerApi } from './deviceRunSessionWorkerApi';
 
 const SHORT_COMMIT_HASH_LENGTH = 7;
 const MAX_APP_SLUG_LENGTH = 80;
@@ -14,9 +17,38 @@ const LEADING_OR_TRAILING_DOTS_AND_HYPHENS = /^[.-]+|[.-]+$/g;
 // A full git commit hash: 40 hex characters for SHA-1 or 64 for SHA-256.
 const FULL_GIT_COMMIT_HASH = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/i;
 
+const SCREENSHOT_SESSION_QUERY = graphql(`
+  query ScreenshotSession($deviceRunSessionId: ID!) {
+    deviceRunSessions {
+      byId(deviceRunSessionId: $deviceRunSessionId) {
+        platform
+        app { slug }
+        build {
+          id
+          gitCommitHash
+          app { slug }
+        }
+      }
+    }
+  }
+`);
+
+const AppSchema = z.object({ slug: z.string() });
+const ScreenshotSessionSchema = z.object({
+  platform: z.enum(['IOS', 'ANDROID']),
+  app: AppSchema,
+  build: z
+    .object({
+      id: z.string(),
+      gitCommitHash: z.string().nullable(),
+      app: AppSchema,
+    })
+    .nullable(),
+});
+
 /**
- * Session details used to name screenshots. `app` is always null: the device run session worker
- * API does not return the app slug.
+ * Session details used to name screenshots. `app` is null when the source does not report an app
+ * slug: the device run session worker API does not return one.
  */
 export type ScreenshotSession = {
   platform: 'IOS' | 'ANDROID';
@@ -31,22 +63,30 @@ export async function loadScreenshotSessionAsync(
 ): Promise<ScreenshotSession | null> {
   try {
     const signal = AbortSignal.timeout(SESSION_LOOKUP_TIMEOUT_MS);
-    const application = await requireDeviceRunSessionWorkerApi(ctx).getApplicationAsync({
-      signal,
-    });
-    return {
-      // www runs iOS sessions only on macOS workers and Android sessions only on Linux workers,
-      // so the worker API does not return the platform.
-      platform: ctx.runtimePlatform === BuildRuntimePlatform.DARWIN ? 'IOS' : 'ANDROID',
-      app: null,
-      build: application.build
-        ? {
-            id: application.build.id,
-            gitCommitHash: application.build.gitCommitHash,
-            app: null,
-          }
-        : null,
-    };
+    const workerApi = getDeviceRunSessionWorkerApi(ctx);
+    if (workerApi) {
+      const application = await workerApi.getApplicationAsync({ signal });
+      return {
+        // www runs iOS sessions only on macOS workers and Android sessions only on Linux workers,
+        // so the worker API does not return the platform.
+        platform: ctx.runtimePlatform === BuildRuntimePlatform.DARWIN ? 'IOS' : 'ANDROID',
+        app: null,
+        build: application.build
+          ? {
+              id: application.build.id,
+              gitCommitHash: application.build.gitCommitHash,
+              app: null,
+            }
+          : null,
+      };
+    }
+    const result = await ctx.graphqlClient
+      .query(SCREENSHOT_SESSION_QUERY, { deviceRunSessionId }, graphqlAbortContext(signal))
+      .toPromise();
+    if (result.error) {
+      throw result.error;
+    }
+    return ScreenshotSessionSchema.parse(result.data?.deviceRunSessions.byId);
   } catch (err) {
     logger.warn(
       { err, deviceRunSessionId },

packages/build-tools/src/steps/utils/deviceRunSessionWorkerApi.ts

@@ -1,11 +1,9 @@
 import { type EnvironmentSecret, EnvironmentSecretType, SystemError } from '@expo/eas-build-job';
 import { type bunyan } from '@expo/logger';
 import { asyncResult } from '@expo/results';
-import { FetchError } from 'node-fetch';
 import { z } from 'zod';
 
 import { type CustomBuildContext } from '../../customBuildContext';
-import { promiseRetryWithCondition } from '../../utils/promiseRetryWithCondition';
 import { turtleFetch } from '../../utils/turtleFetch';
 
 /**
@@ -22,10 +20,24 @@ export const DEVICE_RUN_SESSION_TOKEN_HEADER = 'expo-device-run-session-token';
 
 const DEVICE_RUN_SESSION_WORKER_PATH = 'device-run-session-worker/';
 
+/**
+ * www returns the entity value of the status. The client maps it to the GraphQL enum value, so
+ * callers compare statuses the same way on both paths.
+ */
+const DEVICE_RUN_SESSION_STATUS_FROM_ENTITY_VALUE = {
+  new: 'NEW',
+  queued: 'QUEUED',
+  starting: 'STARTING',
+  'in-progress': 'IN_PROGRESS',
+  stopped: 'STOPPED',
+  errored: 'ERRORED',
+} as const;
+
 const DeviceRunSessionStatusSchema = z.object({
   id: z.string(),
-  // The status entity values that www returns.
-  status: z.enum(['new', 'queued', 'starting', 'in-progress', 'stopped', 'errored']),
+  status: z
+    .enum(['new', 'queued', 'starting', 'in-progress', 'stopped', 'errored'])
+    .transform(status => DEVICE_RUN_SESSION_STATUS_FROM_ENTITY_VALUE[status]),
 });
 
 const UploadSessionSchema = z.object({
@@ -77,7 +89,7 @@ type RequestOptions = {
   signal?: AbortSignal;
   /** node-fetch timeout of each attempt, in milliseconds. */
   timeoutMs?: number;
-  /** Additional attempts for transient failures. Defaults to none; critical callers opt in. */
+  /** Additional attempts after a failed one. Defaults to none, so each call sends one request. */
   retries?: number;
   logger?: bunyan;
 };
@@ -90,16 +102,11 @@ export class DeviceRunSessionWorkerApiError extends Error {
   constructor(
     message: string,
     /** The HTTP status of the response, or undefined when no response arrived. */
-    readonly status: number | undefined,
-    options?: ErrorOptions
+    readonly status: number | undefined
   ) {
-    super(message, options);
+    super(message);
     this.name = 'DeviceRunSessionWorkerApiError';
   }
-
-  get isTransient(): boolean {
-    return this.status === undefined || this.status >= 500;
-  }
 }
 
 /**
@@ -191,44 +198,16 @@ export class DeviceRunSessionWorkerApi {
   }
 
   private async requestAsync<T>(
-    method: 'GET' | 'POST',
-    route: string,
-    dataSchema: z.ZodType<T>,
-    { retries = 0, ...options }: RequestOptions & { json?: Record<string, unknown> }
-  ): Promise<T> {
-    const request = () => {
-      options.signal?.throwIfAborted();
-      return this.requestOnceAsync(method, route, dataSchema, options);
-    };
-    if (retries === 0) {
-      return await request();
-    }
-    return await promiseRetryWithCondition(
-      request,
-      error =>
-        !options.signal?.aborted &&
-        error instanceof DeviceRunSessionWorkerApiError &&
-        (error.status === undefined || error.status === 429 || error.status >= 500),
-      { retries, factor: 2, minTimeout: 1000 },
-      ({ attemptNumber, maxAttemptsCount }) =>
-        options.logger?.warn(
-          `Retrying ${method} /v2/${DEVICE_RUN_SESSION_WORKER_PATH}${route} (attempt ${attemptNumber}/${maxAttemptsCount}).`
-        )
-    )();
-  }
-
-  private async requestOnceAsync<T>(
     method: 'GET' | 'POST',
     route: string,
     dataSchema: z.ZodType<T>,
     {
       signal,
       timeoutMs,
+      retries = 0,
       logger,
       json,
-    }: Omit<RequestOptions, 'retries'> & {
-      json?: Record<string, unknown>;
-    }
+    }: RequestOptions & { json?: Record<string, unknown> }
   ): Promise<T> {
     const routeDescription = `${method} /v2/${DEVICE_RUN_SESSION_WORKER_PATH}${route}`;
     const url = new URL(
@@ -242,7 +221,7 @@ export class DeviceRunSessionWorkerApi {
         ...(json ? { json } : {}),
         ...(signal ? { signal } : {}),
         ...(timeoutMs !== undefined ? { timeout: timeoutMs } : {}),
-        retries: 0,
+        retries,
         shouldThrowOnNotOk: false,
         logger,
       })
@@ -253,8 +232,7 @@ export class DeviceRunSessionWorkerApi {
         `${routeDescription} failed before www responded: ${
           reason instanceof Error ? reason.message : String(reason)
         }. Check the network connection of the worker.`,
-        undefined,
-        { cause: reason }
+        undefined
       );
     }
     const response = responseResult.value;
@@ -271,15 +249,6 @@ export class DeviceRunSessionWorkerApi {
       );
     }
     if (!bodyResult.ok) {
-      if (
-        bodyResult.reason instanceof FetchError &&
-        ['system', 'body-timeout'].includes(bodyResult.reason.type)
-      ) {
-        throw new DeviceRunSessionWorkerApiError(
-          `${routeDescription} failed while reading the response body.`,
-          undefined
-        );
-      }
       throw new DeviceRunSessionWorkerApiError(
         `${routeDescription} returned a response that is not JSON.`,
         response.status
@@ -338,24 +307,6 @@ export function getDeviceRunSessionWorkerApi(
   return new DeviceRunSessionWorkerApi(getExpoApiV2BaseUrl(ctx), token);
 }
 
-/**
- * Returns the client for the device run session worker API, which every device run session job
- * uses to call www about its session.
- */
-export function requireDeviceRunSessionWorkerApi(
-  ctx: Pick<CustomBuildContext, 'env' | 'expoApiV2BaseUrl'>
-): DeviceRunSessionWorkerApi {
-  const workerApi = getDeviceRunSessionWorkerApi(ctx);
-  if (!workerApi) {
-    throw new SystemError(
-      `This device run session job has no ${DEVICE_RUN_SESSION_TOKEN_ENV} secret. ` +
-        'www gives one to every device run session job, and the worker needs it to call the ' +
-        'device run session API. Start a new session, and contact support if it happens again.'
-    );
-  }
-  return workerApi;
-}
-
 function getExpoApiV2BaseUrl(ctx: Pick<CustomBuildContext, 'env' | 'expoApiV2BaseUrl'>): string {
   if (ctx.expoApiV2BaseUrl) {
     return ctx.expoApiV2BaseUrl;

packages/build-tools/src/steps/utils/deviceSessionHost.ts

@@ -40,7 +40,6 @@ import {
   spawnDetached,
   startNgrokTunnelAsync,
 } from './remoteDeviceRunSession';
-import { LOCAL_EGRESS_PROXY_HOST, readLocalEgressHandoffAsync } from './localEgress';
 import { withDeviceRunSessionTimeoutAsync } from './deviceRunSessionTimeout';
 import {
   IosSimulatorRecordingUtils,
@@ -49,7 +48,6 @@ import {
 import { SERVE_SIM_STATE_DIR, readServeSimServersAsync } from './serveSimMetricsRecorder';
 import { startLogPhase } from '../../utils/logPhase';
 import { runServeSimActionAsync, stageServeSimAppAsync } from './serveSimActions';
-import { type ServeSimActivityPolling, startServeSimActivityPolling } from './serveSimActivity';
 import { verifyLocalEgressGuardAsync } from './localEgressGuard';
 import { IosSimulatorUtils, type IosSimulatorUuid } from '../../utils/IosSimulatorUtils';
 import { createStartupTasks } from './startupTasks';
@@ -104,16 +102,6 @@ export function websiteOriginArgs(env: BuildStepEnv): string[] {
   return [...origins].flatMap(origin => ['--cors-origin', origin, '--frame-ancestor', origin]);
 }
 
-// Both hosts take the same flag; it only applies under --require-token, which both run with.
-export function frameAncestorArgs(frameAncestors: readonly string[]): string[] {
-  return frameAncestors.flatMap(origin => ['--frame-ancestor', origin]);
-}
-
-// Both hosts take the same flag and match the same origin shapes.
-export function corsOriginArgs(corsOrigins: readonly string[]): string[] {
-  return corsOrigins.flatMap(origin => ['--cors-origin', origin]);
-}
-
 function createServeSimPackageSpec(packageVersion: string | undefined): string {
   return `${SERVE_SIM_PACKAGE_NAME}@${packageVersion ?? 'latest'}`;
 }
@@ -126,8 +114,6 @@ export function createServeSimArgs({
   port,
   turnArgs = [],
   websiteArgs = [],
-  frameAncestorArgs: frameArgs = [],
-  corsOriginArgs: corsArgs = [],
   shareUrl,
   disableShare = false,
   packageVersion,
@@ -138,13 +124,10 @@ export function createServeSimArgs({
   openUrl,
   networkCapture = false,
   networkCaptureFields = [],
-  networkCaptureProxy,
 }: {
   port: number;
   turnArgs?: string[];
   websiteArgs?: string[];
-  frameAncestorArgs?: string[];
-  corsOriginArgs?: string[];
   shareUrl?: string;
   disableShare?: boolean;
   packageVersion?: string;
@@ -152,7 +135,6 @@ export function createServeSimArgs({
   installAppPath?: string;
   networkCapture?: boolean;
   networkCaptureFields?: string[];
-  networkCaptureProxy?: string;
 } & ServeSimLaunchOptions): string[] {
   return [
     createServeSimPackageSpec(packageVersion),
@@ -176,8 +158,6 @@ export function createServeSimArgs({
     SERVE_SIM_VIDEO_FPS,
     ...turnArgs,
     ...websiteArgs,
-    ...frameArgs,
-    ...corsArgs,
     ...(shareUrl ? ['--share-url', shareUrl] : []),
     ...(disableShare ? ['--disable-share'] : []),
     ...(launchAppIdentifier ? ['--launch-app-identifier', launchAppIdentifier] : []),
@@ -192,7 +172,6 @@ export function createServeSimArgs({
           ...networkCaptureFields.flatMap(field => ['--network-capture-field', field]),
         ]
       : []),
-    ...(networkCaptureProxy !== undefined ? ['--network-capture-proxy', networkCaptureProxy] : []),
   ];
 }
 
@@ -200,16 +179,12 @@ export function createExpoDeviceHubArgs({
   port,
   turnArgs = [],
   websiteArgs = [],
-  frameAncestorArgs: frameArgs = [],
-  corsOriginArgs: corsArgs = [],
   packageVersion,
   recordingDirectory,
 }: {
   port: number;
   turnArgs?: string[];
   websiteArgs?: string[];
-  frameAncestorArgs?: string[];
-  corsOriginArgs?: string[];
   packageVersion?: string;
   recordingDirectory?: string;
 }): string[] {
@@ -239,8 +214,6 @@ export function createExpoDeviceHubArgs({
     ...(recordingDirectory ? ['--android-recording-directory', recordingDirectory] : []),
     ...turnArgs,
     ...websiteArgs,
-    ...frameArgs,
-    ...corsArgs,
   ];
 }
 
@@ -355,8 +328,6 @@ export type DeviceWebPreview = {
 
 export type DeviceSessionHost = {
   openPreviewAsync(options: { baseDomain: string; authtoken: string }): Promise<DeviceWebPreview>;
-  /** Last observed preview input. Always `undefined` on Android, which keeps no event log. */
-  getLastPreviewActivityAt(): Date | undefined;
   /**
    * Terminal and idempotent. Never rejects: a failed finalization, host stop or upload is logged
    * and reported, so callers need no error handling around it.
@@ -382,10 +353,6 @@ type DeviceSessionHostOptions = {
   packageVersion?: string;
   disableShare?: boolean;
   privatePreviewUrl?: string;
-  /** Origins allowed to embed the preview host, in addition to the website origins. */
-  frameAncestors?: string[];
-  /** Origins whose pages may call the preview host's API, in addition to the website origins. */
-  corsOrigins?: string[];
   iosSimulatorUdid?: string;
   installAppPath?: string;
   bootEnv?: Record<string, string>;
@@ -436,8 +403,6 @@ async function startDeviceSessionHostInternalAsync(
     onStartupError,
     disableShare = false,
     privatePreviewUrl,
-    frameAncestors = [],
-    corsOrigins = [],
     launchAppIdentifier,
     launchArgs,
     openUrl,
@@ -499,8 +464,7 @@ async function startDeviceSessionHostInternalAsync(
   const packageSpec = isAndroid
     ? createExpoDeviceHubPackageSpec(packageVersion)
     : createServeSimPackageSpec(packageVersion);
-  const turnArgs = await fetchWebPreviewTurnArgsAsync(ctx, { logger });
-  const localEgress = !isAndroid ? await readLocalEgressHandoffAsync() : null;
+  const turnArgs = await fetchWebPreviewTurnArgsAsync(ctx, { env, logger });
   const previewExec = resolvePackageExec(
     resolveConfiguredPackageManager(env, PackageManager.NPM),
     isAndroid
@@ -510,8 +474,6 @@ async function startDeviceSessionHostInternalAsync(
           packageVersion,
           recordingDirectory: recording?.directory,
           websiteArgs: websiteOriginArgs(env),
-          frameAncestorArgs: frameAncestorArgs(frameAncestors),
-          corsOriginArgs: corsOriginArgs(corsOrigins),
         })
       : createServeSimArgs({
           port,
@@ -519,8 +481,6 @@ async function startDeviceSessionHostInternalAsync(
           packageVersion,
           iosSimulatorUdid,
           websiteArgs: websiteOriginArgs(env),
-          frameAncestorArgs: frameAncestorArgs(frameAncestors),
-          corsOriginArgs: corsOriginArgs(corsOrigins),
           // serve-sim adds its bearer token to --share-url; private links are for worker logs only.
           shareUrl: disableShare ? undefined : previewPageUrl,
           disableShare,
@@ -530,9 +490,6 @@ async function startDeviceSessionHostInternalAsync(
           openUrl: iosSimulatorUdid ? undefined : openUrl,
           networkCapture,
           networkCaptureFields,
-          networkCaptureProxy: localEgress
-            ? `http://${LOCAL_EGRESS_PROXY_HOST}:${localEgress.port}`
-            : undefined,
         })
   );
   logger.info(
@@ -588,7 +545,6 @@ async function startDeviceSessionHostInternalAsync(
   const previewSetupController = new AbortController();
   let previewSetupTask: Promise<void> | undefined;
   let previewFailed = false;
-  let previewActivity: ServeSimActivityPolling | null = null;
 
   const host: DeviceSessionHost = {
     openPreviewAsync({ baseDomain, authtoken }) {
@@ -646,9 +602,6 @@ async function startDeviceSessionHostInternalAsync(
       });
       return opening;
     },
-    getLastPreviewActivityAt() {
-      return previewActivity?.getLastActivityObservedAt();
-    },
     finishAsync() {
       readinessController.abort(new Error('Simulator preview ended.'));
       return (finishTask ??= finishDeviceSessionHostAsync(ctx, {
@@ -657,7 +610,6 @@ async function startDeviceSessionHostInternalAsync(
           previewSetupController.abort();
           await previewSetupTask;
           await sessionPreview?.stopAsync();
-          await previewActivity?.stopAsync();
         },
         previewServer,
         screenshots,
@@ -785,9 +737,6 @@ async function startDeviceSessionHostInternalAsync(
     secrets.push(previewToken);
     if (!isAndroid) {
       IosSimulatorRecordingUtils.useServeSimPackage(packageSpec);
-      if (!finishTask) {
-        previewActivity = startServeSimActivityPolling({ port, token: previewToken, logger });
-      }
     }
     // Android installed FFmpeg before launching the host. The optional thumbnail must not delay
     // readiness on macOS, so it starts after its encoder is installed there.

packages/build-tools/src/steps/utils/preinstalledWda.ts

@@ -12,16 +12,13 @@ export async function preparePreinstalledWdaAsync({
   appiumBinPath,
   appiumEnv,
   logger,
-  signal,
 }: {
   runtimeIdentifier: string | undefined;
   appiumHome: string;
   appiumBinPath: string;
   appiumEnv: BuildStepEnv;
   logger: bunyan;
-  signal?: AbortSignal;
 }): Promise<Record<string, unknown>> {
-  signal?.throwIfAborted();
   const iosMajor = /^com\.apple\.CoreSimulator\.SimRuntime\.iOS-(\d+)(?:-|$)/.exec(
     runtimeIdentifier ?? ''
   )?.[1];
@@ -55,17 +52,10 @@ export async function preparePreinstalledWdaAsync({
     // Appium's downloader inherits its pipes; killing only Appium leaves spawn's
     // close event pending. Kill the owned group, then await close before cleanup.
     const timeout = setTimeout(() => killProcessGroup(download.child, 'SIGKILL'), 60_000);
-    const abort = (): void => killProcessGroup(download.child, 'SIGKILL');
-    signal?.addEventListener('abort', abort, { once: true });
-    if (signal?.aborted) {
-      abort();
-    }
     try {
       await download;
-      signal?.throwIfAborted();
     } finally {
       clearTimeout(timeout);
-      signal?.removeEventListener('abort', abort);
     }
     if (!(await fs.promises.stat(runner)).isDirectory()) {
       throw new Error('The downloaded WebDriverAgent runner is not an app directory.');
@@ -77,7 +67,6 @@ export async function preparePreinstalledWdaAsync({
     };
   } catch (err) {
     await fs.promises.rm(outdir, { recursive: true, force: true });
-    signal?.throwIfAborted();
     logger.warn(
       { err },
       'Could not prepare preinstalled WebDriverAgent; using the default xcodebuild startup.'

packages/build-tools/src/steps/utils/remoteDeviceRunSession.ts

@@ -10,6 +10,8 @@ import {
 } from '@expo/steps';
 import spawn from '@expo/turtle-spawn';
 import * as ngrok from '@ngrok/ngrok';
+import { graphql } from 'gql.tada';
+import nullthrows from 'nullthrows';
 import { z } from 'zod';
 import { randomBytes } from 'node:crypto';
 import fs from 'node:fs';
@@ -25,17 +27,51 @@ import {
   parseOpenUrlInput,
 } from '../functions/launchApplication';
 import { Sentry } from '../../sentry';
-import { isProcessGroupRunning, killProcessGroup } from '../../utils/processes';
+import { isProcessGroupRunning } from '../../utils/processes';
 import { sleepAsync } from '../../utils/retry';
+import { turtleFetch } from '../../utils/turtleFetch';
 import { createProcessOutput } from './processOutput';
 import { withDeviceRunSessionTimeoutAsync } from './deviceRunSessionTimeout';
-import {
-  type DeviceRunSessionStatus,
-  requireDeviceRunSessionWorkerApi,
-} from './deviceRunSessionWorkerApi';
+import { getDeviceRunSessionWorkerApi } from './deviceRunSessionWorkerApi';
 
 const XCODE_DEVELOPER_DIR = '/Applications/Xcode.app/Contents/Developer';
 
+const START_DEVICE_RUN_SESSION_MUTATION = graphql(`
+  mutation StartDeviceRunSession($deviceRunSessionId: ID!, $remoteConfig: JSONObject!) {
+    deviceRunSession {
+      startDeviceRunSession(
+        deviceRunSessionId: $deviceRunSessionId
+        remoteConfig: $remoteConfig
+      ) {
+        id
+        status
+      }
+    }
+  }
+`);
+
+const DEVICE_RUN_SESSION_STATUS_QUERY = graphql(`
+  query DeviceRunSessionStatus($deviceRunSessionId: ID!) {
+    deviceRunSessions {
+      byId(deviceRunSessionId: $deviceRunSessionId) {
+        id
+        status
+      }
+    }
+  }
+`);
+
+const ENSURE_DEVICE_RUN_SESSION_STOPPED_MUTATION = graphql(`
+  mutation EnsureDeviceRunSessionStopped($deviceRunSessionId: ID!) {
+    deviceRunSession {
+      ensureDeviceRunSessionStopped(deviceRunSessionId: $deviceRunSessionId) {
+        id
+        status
+      }
+    }
+  }
+`);
+
 const DEVICE_RUN_SESSION_STATUS_POLL_INTERVAL_MS = 5_000;
 // A request to the device run session worker API that hangs counts as a failed poll or stop.
 const DEVICE_RUN_SESSION_WORKER_REQUEST_TIMEOUT_MS = 30_000;
@@ -126,8 +162,6 @@ export type DeviceRunSessionIdleTimeout = {
    * begins, so a session nobody ever connects to still times out.
    */
   getLastEventObservedAt: () => Date | undefined;
-  /** Last observed preview input, counted like a session event. */
-  getLastPreviewActivityAt?: () => Date | undefined;
 };
 
 export async function waitForDeviceRunSessionStoppedAsync({
@@ -181,13 +215,9 @@ export async function waitForDeviceRunSessionStoppedAsync({
 
     while (!signal.aborted) {
       if (idleTimeout) {
-        for (const observedAt of [
-          idleTimeout.getLastEventObservedAt(),
-          idleTimeout.getLastPreviewActivityAt?.(),
-        ]) {
-          if (observedAt && observedAt > lastActivityAt) {
-            lastActivityAt = observedAt;
-          }
+        const lastEventObservedAt = idleTimeout.getLastEventObservedAt();
+        if (lastEventObservedAt && lastEventObservedAt > lastActivityAt) {
+          lastActivityAt = lastEventObservedAt;
         }
         if (Date.now() - lastActivityAt.getTime() >= idleTimeout.maxIdleTimeMinutes * 60_000) {
           logger.info(
@@ -200,12 +230,15 @@ export async function waitForDeviceRunSessionStoppedAsync({
       }
       try {
         const status = await fetchDeviceRunSessionStatusAsync(ctx, deviceRunSessionId, signal);
+        if (!status) {
+          throw new Error(`Device run session ${deviceRunSessionId} status response was missing.`);
+        }
         pollErrorCount = 0;
-        if (status === 'stopped') {
+        if (status === 'STOPPED') {
           logger.info(`Device run session ${deviceRunSessionId} was stopped.`);
           return;
         }
-        if (status === 'errored') {
+        if (status === 'ERRORED') {
           throw new SystemError(`Device run session ${deviceRunSessionId} errored.`);
         }
       } catch (err) {
@@ -236,14 +269,24 @@ async function fetchDeviceRunSessionStatusAsync(
   ctx: CustomBuildContext,
   deviceRunSessionId: string,
   signal: AbortSignal
-): Promise<DeviceRunSessionStatus['status']> {
-  // One request per poll; the polling loop retries on its own schedule.
-  return (
-    await requireDeviceRunSessionWorkerApi(ctx).getSessionAsync({
-      signal,
-      timeoutMs: DEVICE_RUN_SESSION_WORKER_REQUEST_TIMEOUT_MS,
-    })
-  ).status;
+): Promise<string | undefined> {
+  const workerApi = getDeviceRunSessionWorkerApi(ctx);
+  if (workerApi) {
+    // One request per poll; the polling loop retries on its own schedule.
+    return (
+      await workerApi.getSessionAsync({
+        signal,
+        timeoutMs: DEVICE_RUN_SESSION_WORKER_REQUEST_TIMEOUT_MS,
+      })
+    ).status;
+  }
+  const result = await ctx.graphqlClient
+    .query(DEVICE_RUN_SESSION_STATUS_QUERY, { deviceRunSessionId })
+    .toPromise();
+  if (result.error) {
+    throw result.error;
+  }
+  return result.data?.deviceRunSessions?.byId?.status;
 }
 
 // Best effort: when this fails, the caller still tears the session down and the
@@ -258,9 +301,17 @@ async function ensureDeviceRunSessionStoppedSafelyAsync({
   logger: bunyan;
 }): Promise<void> {
   try {
-    await requireDeviceRunSessionWorkerApi(ctx).stopAsync({
-      timeoutMs: DEVICE_RUN_SESSION_WORKER_REQUEST_TIMEOUT_MS,
-    });
+    const workerApi = getDeviceRunSessionWorkerApi(ctx);
+    if (workerApi) {
+      await workerApi.stopAsync({ timeoutMs: DEVICE_RUN_SESSION_WORKER_REQUEST_TIMEOUT_MS });
+    } else {
+      const result = await ctx.graphqlClient
+        .mutation(ENSURE_DEVICE_RUN_SESSION_STOPPED_MUTATION, { deviceRunSessionId })
+        .toPromise();
+      if (result.error) {
+        throw result.error;
+      }
+    }
   } catch (err) {
     const error = err instanceof Error ? err : new Error(String(err));
     Sentry.capture('Could not mark idle device run session as stopped', error, {
@@ -317,28 +368,14 @@ function warmUpFfmpeg(env: BuildStepEnv): void {
 async function installFfmpegWithHomebrewAsync({
   env,
   logger,
-  signal,
 }: {
   env: BuildStepEnv;
   logger: bunyan;
-  signal?: AbortSignal;
 }): Promise<void> {
-  signal?.throwIfAborted();
-  const install = spawn('brew', ['install', 'ffmpeg'], {
+  await spawn('brew', ['install', 'ffmpeg'], {
     env: { ...env, HOMEBREW_NO_AUTO_UPDATE: '1' },
     logger,
-    ...(signal ? { detached: true } : {}),
   });
-  const abort = (): void => killProcessGroup(install.child, 'SIGKILL');
-  signal?.addEventListener('abort', abort, { once: true });
-  if (signal?.aborted) {
-    abort();
-  }
-  try {
-    await install;
-  } finally {
-    signal?.removeEventListener('abort', abort);
-  }
 }
 
 async function installFfmpegWithAptAsync({
@@ -356,7 +393,7 @@ async function installFfmpegWithAptAsync({
   await spawn('sudo', ['apt-get', 'install', '-y', 'ffmpeg'], { env: aptEnv, logger });
 }
 
-let ffmpegSetupPromise: Promise<'aborted' | void> | undefined;
+let ffmpegSetupPromise: Promise<void> | undefined;
 
 /**
  * Install ffmpeg when the runtime does not already provide it. Device-session
@@ -376,16 +413,13 @@ async function ensureFfmpegInstalledAsync({
   runtimePlatform,
   env,
   logger,
-  signal,
 }: {
   runtimePlatform: BuildRuntimePlatform;
   env: BuildStepEnv;
   logger: bunyan;
-  signal?: AbortSignal;
-}): Promise<'aborted' | void> {
+}): Promise<void> {
   try {
     const ffmpegPath = await findFfmpegOnPathAsync(env);
-    signal?.throwIfAborted();
     if (ffmpegPath) {
       logger.info(`ffmpeg is already installed at ${ffmpegPath}.`);
       warmUpFfmpeg(env);
@@ -399,17 +433,13 @@ async function ensureFfmpegInstalledAsync({
       } for the device session.`
     );
     if (isDarwin) {
-      await installFfmpegWithHomebrewAsync({ env, logger, signal });
+      await installFfmpegWithHomebrewAsync({ env, logger });
     } else {
       await installFfmpegWithAptAsync({ env, logger });
     }
-    signal?.throwIfAborted();
     logger.info('Installed ffmpeg.');
     warmUpFfmpeg(env);
   } catch (err) {
-    if (signal?.aborted) {
-      return 'aborted';
-    }
     const error = err instanceof Error ? err : new Error(String(err));
     Sentry.capture('Could not install ffmpeg for the device session', error, {
       level: 'warning',
@@ -425,46 +455,20 @@ export async function ensureFfmpegInstalledOnceAsync({
   runtimePlatform,
   env,
   logger,
-  signal,
 }: {
   runtimePlatform: BuildRuntimePlatform;
   env: BuildStepEnv;
   logger: bunyan;
-  signal?: AbortSignal;
 }): Promise<void> {
-  signal?.throwIfAborted();
   if (ffmpegSetupPromise) {
-    const sharedSetup = ffmpegSetupPromise;
-    let outcome: 'aborted' | void;
-    if (signal) {
-      outcome = await new Promise<'aborted' | void>((resolve, reject) => {
-        const abort = (): void => reject(signal.reason);
-        signal.addEventListener('abort', abort, { once: true });
-        void sharedSetup.then(result => {
-          signal.removeEventListener('abort', abort);
-          resolve(result);
-        });
-        if (signal.aborted) {
-          abort();
-        }
-      });
-    } else {
-      outcome = await sharedSetup;
-    }
-    if (outcome === 'aborted') {
-      if (ffmpegSetupPromise === sharedSetup) {
-        ffmpegSetupPromise = undefined;
-      }
-      await ensureFfmpegInstalledOnceAsync({ runtimePlatform, env, logger, signal });
-    }
+    await ffmpegSetupPromise;
     return;
   }
 
-  const setupPromise = ensureFfmpegInstalledAsync({ runtimePlatform, env, logger, signal });
+  const setupPromise = ensureFfmpegInstalledAsync({ runtimePlatform, env, logger });
   ffmpegSetupPromise = setupPromise;
   try {
     await setupPromise;
-    signal?.throwIfAborted();
   } finally {
     if (ffmpegSetupPromise === setupPromise) {
       ffmpegSetupPromise = undefined;
@@ -472,6 +476,12 @@ export async function ensureFfmpegInstalledOnceAsync({
   }
 }
 
+const TurnIceServersResponseSchema = z.object({
+  data: z.object({
+    iceServers: TurnIceServersSchema,
+  }),
+});
+
 /**
  * Translate Cloudflare ICE servers into web preview CLI flags: `--stun-url` (the
  * credential-less entries) and `--turn-url`/`--turn-username`/`--turn-credential`
@@ -513,10 +523,10 @@ export function turnIceServersToWebPreviewArgs(iceServers: TurnIceServers): stri
  */
 export async function fetchWebPreviewTurnArgsAsync(
   ctx: CustomBuildContext,
-  { logger }: { logger: bunyan }
+  { env, logger }: { env: BuildStepEnv; logger: bunyan }
 ): Promise<string[]> {
   try {
-    const iceServers = await fetchTurnIceServersAsync(ctx, { logger });
+    const iceServers = await fetchTurnIceServersAsync(ctx, { env, logger });
     const args = turnIceServersToWebPreviewArgs(iceServers);
     if (args.length > 0) {
       logger.info('Configured the web preview with Cloudflare TURN ICE servers.');
@@ -535,13 +545,38 @@ export async function fetchWebPreviewTurnArgsAsync(
 
 async function fetchTurnIceServersAsync(
   ctx: CustomBuildContext,
-  { logger }: { logger: bunyan }
+  { env, logger }: { env: BuildStepEnv; logger: bunyan }
 ): Promise<TurnIceServers> {
-  return await requireDeviceRunSessionWorkerApi(ctx).fetchTurnIceServersAsync({
-    timeoutMs: 5000,
-    retries: 1,
-    logger,
-  });
+  const workerApi = getDeviceRunSessionWorkerApi(ctx);
+  if (workerApi) {
+    return await workerApi.fetchTurnIceServersAsync({ timeoutMs: 5000, retries: 1, logger });
+  }
+
+  const deviceRunSessionId = getDeviceRunSessionIdOrThrow(env);
+  const expoApiServerUrl = nullthrows(ctx.env.__API_SERVER_URL, '__API_SERVER_URL is not set');
+  const robotAccessToken = nullthrows(
+    ctx.job.secrets?.robotAccessToken,
+    'robot access token is not set'
+  );
+
+  const response = await 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());
+  return data.iceServers;
 }
 
 export async function uploadRemoteSessionConfigAsync({
@@ -558,18 +593,26 @@ export async function uploadRemoteSessionConfigAsync({
   logger.info(
     `Reporting remote config to the API server (device run session: ${deviceRunSessionId}).`
   );
-  const workerApi = requireDeviceRunSessionWorkerApi(ctx);
-  try {
-    await workerApi.startAsync(
-      { remoteConfig },
-      { retries: 3, timeoutMs: DEVICE_RUN_SESSION_WORKER_REQUEST_TIMEOUT_MS, logger }
-    );
-  } catch (err) {
+  const workerApi = getDeviceRunSessionWorkerApi(ctx);
+  if (workerApi) {
+    try {
+      await workerApi.startAsync({ remoteConfig });
+    } catch (err) {
+      throw new SystemError(
+        `Failed to start device run session ${deviceRunSessionId}: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+        { cause: err }
+      );
+    }
+    return;
+  }
+  const result = await ctx.graphqlClient
+    .mutation(START_DEVICE_RUN_SESSION_MUTATION, { deviceRunSessionId, remoteConfig })
+    .toPromise();
+  if (result.error) {
     throw new SystemError(
-      `Failed to start device run session ${deviceRunSessionId}: ${
-        err instanceof Error ? err.message : String(err)
-      }`,
-      { cause: err }
+      `Failed to start device run session ${deviceRunSessionId}: ${result.error.message}`
     );
   }
 }
@@ -837,58 +880,6 @@ export function createPrivatePreviewUrlInputProvider(): ReturnType<
   });
 }
 
-/**
- * Origins that may embed the preview host in a frame, next to the website origins. The host
- * drops values that are not an origin or a subdomain wildcard, so this parser only guards
- * the input shape.
- */
-export function createFrameAncestorsInputProvider(): ReturnType<
-  typeof BuildStepInput.createProvider
-> {
-  return BuildStepInput.createProvider({
-    id: 'frame_ancestors',
-    required: false,
-    allowedValueTypeName: BuildStepInputValueTypeName.JSON,
-  });
-}
-
-export function parseFrameAncestorsInput(value: unknown): string[] {
-  return parseOriginListInput(value, 'frame_ancestors', 'EAS_FRAME_ANCESTORS_INVALID_INPUT');
-}
-
-/**
- * Origins whose pages may call the preview host's API cross-origin, such as a page that renders
- * the device with @expo/hub-client. Framing alone does not need it. The host refuses values that
- * are not an origin or a subdomain wildcard, so this parser only guards the input shape.
- */
-export function createCorsOriginsInputProvider(): ReturnType<typeof BuildStepInput.createProvider> {
-  return BuildStepInput.createProvider({
-    id: 'cors_origins',
-    required: false,
-    allowedValueTypeName: BuildStepInputValueTypeName.JSON,
-  });
-}
-
-export function parseCorsOriginsInput(value: unknown): string[] {
-  return parseOriginListInput(value, 'cors_origins', 'EAS_CORS_ORIGINS_INVALID_INPUT');
-}
-
-function parseOriginListInput(value: unknown, inputId: string, errorCode: string): string[] {
-  if (value === undefined) {
-    return [];
-  }
-  if (
-    !Array.isArray(value) ||
-    !value.every(origin => typeof origin === 'string' && origin.trim().length > 0)
-  ) {
-    throw new UserError(
-      errorCode,
-      `Input "${inputId}" must be an array of non-empty strings, one origin each.`
-    );
-  }
-  return value;
-}
-
 export function parseServeSimLaunchInputs(
   {
     launchAppIdentifier: rawLaunchAppIdentifier,

packages/build-tools/src/steps/utils/sandboxArtifacts.ts

@@ -14,8 +14,12 @@ import { performance } from 'node:perf_hooks';
 import { Readable } from 'node:stream';
 import { setTimeout as delay } from 'node:timers/promises';
 
-import { SignedUrlUploadApiError, uploadWithSignedUrl } from '../../storage/uploadWithSignedUrl';
 import { graphqlAbortContext } from '../../utils/graphqlAbort';
+import {
+  ArtifactPutError,
+  type ArtifactUploadSession,
+  putArtifactWithRetriesAsync,
+} from './artifactPut';
 
 const CREATE_SANDBOX_ARTIFACT_UPLOAD_SESSION_MUTATION = graphql(`
   mutation CreateSandboxArtifactUploadSession(
@@ -234,23 +238,18 @@ async function putSandboxArtifactAsync({
 }: {
   filePath: string;
   size: number;
-  uploadSession: { url: string; headers: unknown };
+  uploadSession: ArtifactUploadSession;
   signal: AbortSignal;
 }): Promise<void> {
+  const openStream = (): Readable =>
+    size === 0 ? Readable.from([]) : createReadStream(filePath, { start: 0, end: size - 1 });
   try {
-    await uploadWithSignedUrl(
-      {
-        signedUrl: {
-          url: uploadSession.url,
-          headers: uploadSession.headers as Record<string, string>,
-        },
-        srcGeneratorAsync: async () =>
-          size === 0 ? Readable.from([]) : createReadStream(filePath, { start: 0, end: size - 1 }),
-      },
-      { signal, retries: 2, retryIntervalMs: 500 }
+    await putArtifactWithRetriesAsync(
+      { uploadSession, source: { openStream }, signal },
+      { attempts: 3 }
     );
   } catch (error) {
-    if (!(error instanceof SignedUrlUploadApiError && error.status === 412)) {
+    if (!(error instanceof ArtifactPutError && error.status === 412)) {
       throw error;
     }
   }