[worker] Mask secrets in all build log fields without stalling on stdout

Write to stdout without waiting for it to flush, so uploads and the error
log buffer are not held back. Mask every string field except logger
metadata, and serialize records safely so circular or BigInt values
cannot throw into the logging call site.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

.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/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/cold-wda-startup.md

@@ -0,0 +1,5 @@
+---
+'@expo/build-tools': patch
+---
+
+Speed up cold iOS Appium sessions by launching preinstalled WebDriverAgent.

.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/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/help-description-style.md

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

.changeset/mask-worker-stdout.md

@@ -0,0 +1,5 @@
+---
+'@expo/worker': patch
+---
+
+Mask build secrets in every build log field, worker stdout and the build error log buffer.

.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/serve-sim-pr-4585.md

@@ -0,0 +1,5 @@
+---
+'@expo/build-tools': minor
+---
+
+Give agent-device and its simulator preview separate session logs.

.changeset/serve-sim-web-preview-logs.md

@@ -0,0 +1,5 @@
+---
+'@expo/build-tools': minor
+---
+
+Stream simulator preview output into its existing session step.

.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/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,88 +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
-
-- [eas-cli] Default new simulator sessions to authenticated preview links and omit preview credentials from private output; use `simulator:start --public-link` for public sharing, while `simulator:get` follows the saved preference. ([#4619](https://github.com/expo/eas-cli/pull/4619) by [@gwdp](https://github.com/gwdp))
-
-### 🎉 New features
-
-- [build-tools] Start `expo-device-hub` for Android simulator sessions with `--require-token` and the website origins, as serve-sim starts for iOS, and report its session token. ([#4578](https://github.com/expo/eas-cli/pull/4578) by [@krystofwoldrich](https://github.com/krystofwoldrich))
-- [build-tools] Respect saved sharing preferences for iOS simulator preview sessions. ([#4620](https://github.com/expo/eas-cli/pull/4620) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Give agent-device and its simulator preview separate session logs. ([#4585](https://github.com/expo/eas-cli/pull/4585) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Give Appium and its simulator preview separate session logs. ([#4586](https://github.com/expo/eas-cli/pull/4586) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Give Argent and its simulator preview separate session logs. ([#4587](https://github.com/expo/eas-cli/pull/4587) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Let serve-sim start the iOS Simulator for web-preview sessions. ([#4601](https://github.com/expo/eas-cli/pull/4601) by [@gwdp](https://github.com/gwdp))
-- [build-tools] Stream simulator preview output into its existing session step. ([#4525](https://github.com/expo/eas-cli/pull/4525) by [@gwdp](https://github.com/gwdp))
-- [eas-cli] Use effectivePermissions for logic about capabilities and account:view display. ([#4637](https://github.com/expo/eas-cli/pull/4637) by [@wschurman](https://github.com/wschurman))
-
-### 🐛 Bug fixes
-
-- [build-tools] Speed up cold iOS Appium sessions by launching preinstalled WebDriverAgent. ([#4618](https://github.com/expo/eas-cli/pull/4618) by [@gwdp](https://github.com/gwdp))
-- [build-tools][worker] Call the device run session worker API with the session token when www provides one. ([#4615](https://github.com/expo/eas-cli/pull/4615) by [@szdziedzic](https://github.com/szdziedzic))
-- [build-tools][eas-json] Clarify Google Play submission messages and reject zero Android submission rollouts. ([#4625](https://github.com/expo/eas-cli/pull/4625) by [@sjchmiela](https://github.com/sjchmiela))
-- [eas-cli] Update error message for scoped VC in EAS CLI now that scoped can be used outside build. ([#4636](https://github.com/expo/eas-cli/pull/4636) by [@wschurman](https://github.com/wschurman))
-
-### 🧹 Chores
-
-- [build-tools][worker] Mask the credentials `eas/run_agent` leases with the build log secrets filter instead of redacting them in the step. ([#4624](https://github.com/expo/eas-cli/pull/4624) by [@hSATAC](https://github.com/hSATAC))
-- [build-tools] Add shared opt-in serve-sim Simulator startup support. ([#4605](https://github.com/expo/eas-cli/pull/4605) by [@gwdp](https://github.com/gwdp))
-
 ## [24.14.0](https://github.com/expo/eas-cli/releases/tag/v24.14.0) - 2026-10-14
 
 ### 🎉 New features

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": "24.14.0",
+  "PRODUCTION": "24.14.0"
 }

lerna.json

@@ -1,5 +1,5 @@
 {
   "npmClient": "yarn",
-  "version": "25.3.0",
+  "version": "24.14.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,60 +0,0 @@
-# @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
-
-- Start `expo-device-hub` for Android simulator sessions with `--require-token` and the website origins, as serve-sim starts for iOS, and report its session token. ([#4578](https://github.com/expo/eas-cli/pull/4578) by [@krystofwoldrich](https://github.com/krystofwoldrich))
-- Respect saved sharing preferences for iOS simulator preview sessions. ([#4620](https://github.com/expo/eas-cli/pull/4620) by [@gwdp](https://github.com/gwdp))
-- Give agent-device and its simulator preview separate session logs. ([#4585](https://github.com/expo/eas-cli/pull/4585) by [@gwdp](https://github.com/gwdp))
-- Give Appium and its simulator preview separate session logs. ([#4586](https://github.com/expo/eas-cli/pull/4586) by [@gwdp](https://github.com/gwdp))
-- Give Argent and its simulator preview separate session logs. ([#4587](https://github.com/expo/eas-cli/pull/4587) by [@gwdp](https://github.com/gwdp))
-- Let serve-sim start the iOS Simulator for web-preview sessions. ([#4601](https://github.com/expo/eas-cli/pull/4601) by [@gwdp](https://github.com/gwdp))
-- Stream simulator preview output into its existing session step. ([#4525](https://github.com/expo/eas-cli/pull/4525) by [@gwdp](https://github.com/gwdp))
-
-### Patch Changes
-
-- Speed up cold iOS Appium sessions by launching preinstalled WebDriverAgent. ([#4618](https://github.com/expo/eas-cli/pull/4618) by [@gwdp](https://github.com/gwdp))
-- Call the device run session worker API with the session token when www provides one. ([#4615](https://github.com/expo/eas-cli/pull/4615) by [@szdziedzic](https://github.com/szdziedzic))
-- Clarify Google Play submission messages and reject zero Android submission rollouts. ([#4625](https://github.com/expo/eas-cli/pull/4625) by [@sjchmiela](https://github.com/sjchmiela))

packages/build-tools/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/build-tools",
-  "version": "25.3.0",
+  "version": "24.14.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": "24.13.0",
+    "@expo/eas-build-job": "24.13.0",
     "@expo/env": "^0.4.0",
-    "@expo/logger": "25.3.0",
+    "@expo/logger": "24.13.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": "24.13.0",
+    "@expo/template-file": "24.13.0",
+    "@expo/turtle-spawn": "24.13.0",
     "@expo/xcpretty": "^4.3.1",
     "@ngrok/ngrok": "1.7.0",
     "@sentry/node": "7.77.0",

packages/build-tools/resources/egress-guard/README.md

@@ -71,17 +71,6 @@ by a coverage report from `lsof`, listing any process without the library. Both
 `packages/worker/package.sh` for the iOS worker tarball and by the
 `test-egress-guard` EAS workflow, not committed.
 
-For serve-sim-owned iOS session startup, build-tools passes the guard through
-`SERVE_SIM_ADDITIONAL_DYLIBS` and its configuration and proxy variables through
-inherited `SIMCTL_CHILD_` variables. It shuts down an already booted selected
-device so every process inherits the guard. Serve-sim boots that device while
-build-tools prepares the app. After serve-sim's control endpoint is available,
-build-tools runs the packaged guard self-check before requesting installation
-and launch through the authenticated host API. Preview readiness and application
-startup both complete before reporting the remote session live. Build-tools keeps
-the event relay and egress cleanup without rewriting launchd's dylib list after
-serve-sim adds its capability loader.
-
 Failure semantics: a missing library, a failed `launchctl setenv`, or a failed
 self-check fails the session, since a `--egress local` session without the
 guard would silently leak. Only an unwritable event log is a warning, because

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/__tests__/datadog.test.ts

@@ -318,49 +318,6 @@ describe('Datadog singleton', () => {
     );
   });
 
-  it('POSTs distribution metrics to the device run session worker API with the session token', () => {
-    turtleFetchMock.mockResolvedValueOnce({} as Response);
-
-    Datadog.setup({
-      expoApiV2BaseUrl: 'https://api.expo.test/v2/',
-      deviceRunSessionToken: 'session-token',
-      target: { kind: 'deviceRunSession' },
-    });
-
-    Datadog.distribution('eas.workflow.hook', 1, { hook: 'on_start' });
-
-    expect(turtleFetchMock).toHaveBeenCalledWith(
-      'https://api.expo.test/v2/device-run-session-worker/metrics',
-      'POST',
-      {
-        json: {
-          metrics: [
-            {
-              name: 'eas.workflow.hook',
-              type: 'distribution',
-              value: 1,
-              tags: { hook: 'on_start', target: 'job_run' },
-            },
-          ],
-        },
-        headers: { 'expo-device-run-session-token': 'session-token' },
-        retries: 2,
-      }
-    );
-  });
-
-  it('does not report logs for device run session targets', () => {
-    Datadog.setup({
-      expoApiV2BaseUrl: 'https://api.expo.test/v2/',
-      deviceRunSessionToken: 'session-token',
-      target: { kind: 'deviceRunSession' },
-    });
-
-    Datadog.log('Custom build saw user-provided function');
-
-    expect(turtleFetchMock).not.toHaveBeenCalled();
-  });
-
   it('flushes pending metric uploads', async () => {
     let resolveUpload!: (response: Response) => void;
     turtleFetchMock.mockReturnValueOnce(

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>;
@@ -67,7 +69,6 @@ export interface BuildContextOptions {
   metadata?: Metadata;
   expoApiV2BaseUrl?: string;
   mcpServerUrl?: string;
-  addBuildLogMask?: (secret: string) => void;
 }
 
 export class SkipNativeBuildError extends Error {}
@@ -85,7 +86,6 @@ export class BuildContext<TJob extends Job = Job> {
   public readonly skipNativeBuild?: boolean;
   public readonly expoApiV2BaseUrl?: string;
   public readonly mcpServerUrl?: string;
-  public readonly addBuildLogMask?: (secret: string) => void;
   public artifacts: Artifacts = {};
 
   private readonly _isLocal: boolean;
@@ -115,7 +115,6 @@ export class BuildContext<TJob extends Job = Job> {
     this.skipNativeBuild = options.skipNativeBuild;
     this.expoApiV2BaseUrl = options.expoApiV2BaseUrl;
     this.mcpServerUrl = options.mcpServerUrl;
-    this.addBuildLogMask = options.addBuildLogMask;
 
     const environmentSecrets = this.getEnvironmentSecrets(job);
     this._env = {
@@ -239,7 +238,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/customBuildContext.ts

@@ -32,7 +32,6 @@ export interface BuilderRuntimeApi {
   uploadArtifact: (spec: { artifact: ArtifactToUpload; logger: bunyan }) => Promise<{
     artifactId: string | null;
   }>;
-  addBuildLogMask?: (secret: string) => void;
 }
 
 export class CustomBuildContext<TJob extends Job = Job> implements ExternalBuildContextProvider {
@@ -85,7 +84,6 @@ export class CustomBuildContext<TJob extends Job = Job> implements ExternalBuild
     this.buildLogsDirectory = path.join(buildCtx.workingdir, 'logs');
     this.runtimeApi = {
       uploadArtifact: (...args) => buildCtx['uploadArtifact'](...args),
-      addBuildLogMask: buildCtx.addBuildLogMask,
     };
     this.mcpServerUrl = buildCtx.mcpServerUrl;
     this.expoApiV2BaseUrl = buildCtx.expoApiV2BaseUrl;

packages/build-tools/src/datadog.ts

@@ -1,24 +1,15 @@
 import { Sentry } from './sentry';
-import { DEVICE_RUN_SESSION_TOKEN_HEADER } from './steps/utils/deviceRunSessionWorkerApi';
 import { turtleFetch } from './utils/turtleFetch';
 
 type MetricsTarget =
   | { kind: 'build'; turtleBuildId: string }
-  | { kind: 'jobRun'; turtleJobRunId: string }
-  // A device run session job with a session token. The token names the session and its job run.
-  | { kind: 'deviceRunSession' };
+  | { kind: 'jobRun'; turtleJobRunId: string };
 
-type DatadogSetupOptions =
-  | {
-      expoApiV2BaseUrl: string;
-      robotAccessToken: string;
-      target: Exclude<MetricsTarget, { kind: 'deviceRunSession' }>;
-    }
-  | {
-      expoApiV2BaseUrl: string;
-      deviceRunSessionToken: string;
-      target: Extract<MetricsTarget, { kind: 'deviceRunSession' }>;
-    };
+type DatadogSetupOptions = {
+  expoApiV2BaseUrl: string;
+  robotAccessToken: string;
+  target: MetricsTarget;
+};
 
 let setupOptions: DatadogSetupOptions | null = null;
 let pendingUploads: Promise<unknown>[] = [];
@@ -27,30 +18,9 @@ function withTargetTag(
   tags: Record<string, string>,
   target: MetricsTarget
 ): Record<string, string> {
-  // A device run session job is a job run, so its metrics keep the job run tag.
   return { ...tags, target: target.kind === 'build' ? 'build' : 'job_run' };
 }
 
-function getMetricsRequest(options: DatadogSetupOptions): {
-  path: string;
-  headers: Record<string, string>;
-} {
-  if ('deviceRunSessionToken' in options) {
-    return {
-      path: 'device-run-session-worker/metrics',
-      headers: { [DEVICE_RUN_SESSION_TOKEN_HEADER]: options.deviceRunSessionToken },
-    };
-  }
-  const { target, robotAccessToken } = options;
-  return {
-    path:
-      target.kind === 'build'
-        ? `turtle-builds/${target.turtleBuildId}/metrics`
-        : `turtle-job-runs/${target.turtleJobRunId}/metrics`,
-    headers: { Authorization: `Bearer ${robotAccessToken}` },
-  };
-}
-
 export const Datadog = {
   setup(opts: DatadogSetupOptions | null): void {
     setupOptions = opts;
@@ -60,7 +30,7 @@ export const Datadog = {
     if (!setupOptions) {
       return;
     }
-    const { expoApiV2BaseUrl, target } = setupOptions;
+    const { expoApiV2BaseUrl, robotAccessToken, target } = setupOptions;
     const metrics = [
       {
         name,
@@ -70,11 +40,16 @@ export const Datadog = {
       },
     ];
 
-    const { path: metricsPath, headers } = getMetricsRequest(setupOptions);
+    const metricsPath =
+      target.kind === 'build'
+        ? `turtle-builds/${target.turtleBuildId}/metrics`
+        : `turtle-job-runs/${target.turtleJobRunId}/metrics`;
 
     const uploadPromise = turtleFetch(new URL(metricsPath, expoApiV2BaseUrl).toString(), 'POST', {
       json: { metrics },
-      headers,
+      headers: {
+        Authorization: `Bearer ${robotAccessToken}`,
+      },
       retries: 2,
     }).catch(err => {
       Sentry.capture(`Failed to report turtle ${target.kind} metric`, err, {
@@ -86,9 +61,7 @@ export const Datadog = {
   },
 
   log(message: string, tags: Record<string, string> = {}): void {
-    // The device run session worker API has no logs route, and the session token is not a bearer
-    // credential, so a device run session job does not report these logs.
-    if (!setupOptions || !('robotAccessToken' in setupOptions)) {
+    if (!setupOptions) {
       return;
     }
     const { expoApiV2BaseUrl, robotAccessToken, target } = setupOptions;

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';
 
@@ -41,6 +33,5 @@ export type { GradleProfileTask } from './android/gradleProfile';
 export * from './generic';
 
 export { Datadog } from './datadog';
-export { getDeviceRunSessionTokenFromEnvironmentSecrets } from './steps/utils/deviceRunSessionWorkerApi';
 export { Sentry } from './sentry';
 export * from './runtimeSettings';

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() {
     const fn = createFunction({} as CustomBuildContext);
     await fn.fn!(
       {
@@ -123,16 +117,9 @@ describe.each([
       } as unknown as BuildStepContext,
       {
         // 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 }>,
-          {
-            get: (target, id: string) => target[id] ?? { value: undefined },
-          }
-        ),
+        inputs: new Proxy({} as Record<string, { value: unknown }>, {
+          get: (target, id: string) => target[id] ?? { value: undefined },
+        }),
         outputs: {},
         env: {
           DEVICE_RUN_SESSION_ID: 'session-id',
@@ -145,7 +132,7 @@ describe.each([
 
   it('holds the host until session completion', async () => {
     await runAsync();
-    expect(openPreview).toHaveBeenCalledWith({ baseDomain: 'example.test', authtoken: 'token' });
+    expect(openPreview).toHaveBeenCalledWith({ baseDomain: 'example.test' });
     expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith(
       expect.objectContaining({
         remoteConfig: expect.objectContaining({
@@ -164,59 +151,6 @@ describe.each([
     expect(stopTunnel).toHaveBeenCalledTimes(1);
   });
 
-  it('opens tunnels with the ngrok token but keeps it out of spawned processes', async () => {
-    await runAsync();
-    expect(startNgrokTunnelAsync).toHaveBeenCalledWith(
-      expect.objectContaining({ authtoken: 'token' })
-    );
-    const spawnedEnvs = [
-      ...jest.mocked(spawn).mock.calls.map(([, , options]) => options?.env),
-      ...jest.mocked(spawnDetached).mock.calls.map(([options]) => options.env),
-      ...jest.mocked(startDeviceSessionHostAsync).mock.calls.map(([, options]) => options.env),
-    ];
-    expect(spawnedEnvs.length).toBeGreaterThan(0);
-    for (const env of spawnedEnvs) {
-      expect(env).toEqual(expect.objectContaining({ DEVICE_RUN_SESSION_ID: 'session-id' }));
-      expect(env).not.toHaveProperty('NGROK_AUTHTOKEN');
-    }
-  });
-
-  it.each([undefined, true, false])('maps public_preview=%s to the host', async publicPreview => {
-    await runAsync(publicPreview);
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({ disableShare: publicPreview === false })
-    );
-  });
-
-  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,
@@ -891,131 +591,6 @@ describe('createDownloadBuildFunction', () => {
     expect(graphqlClient.query).not.toHaveBeenCalled();
   });
 
-  describe('with a device run session token in the job env', () => {
-    const { Response: ActualResponse } = jest.requireActual(
-      'node-fetch'
-    ) as typeof import('node-fetch');
-    const workerApiUrl = 'https://api.expo.test/v2/device-run-session-worker/application';
-
-    function createSessionCtx(graphqlClient: Client): any {
-      return {
-        graphqlClient,
-        env: { EAS_DEVICE_RUN_SESSION_TOKEN: 'session-token' },
-        expoApiV2BaseUrl: 'https://api.expo.test/v2/',
-      };
-    }
-
-    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({
-          logger: createMockLogger(),
-          staticContextContent: { job: { secrets: { robotAccessToken: 'session-token' } } },
-        }),
-        { callInputs }
-      );
-    }
-
-    it('looks up build_id through the worker API and downloads without an Authorization header', async () => {
-      const buildId = randomUUID();
-      const graphqlClient = createMockGraphqlClient({});
-      jest.mocked(fetch).mockImplementation(async url => {
-        if (url === workerApiUrl) {
-          return createApplicationResponse(buildId);
-        }
-        return {
-          ok: false,
-          text: () => Promise.resolve('Internal Server Error'),
-          status: 500,
-        } as unknown as Response;
-      });
-
-      await expect(
-        createStep(createSessionCtx(graphqlClient), {
-          build_id: buildId,
-          extensions: ['app'],
-        }).executeAsync()
-      ).rejects.toThrow('Internal Server Error');
-
-      expect(jest.mocked(fetch)).toHaveBeenCalledWith(
-        workerApiUrl,
-        expect.objectContaining({
-          method: 'GET',
-          headers: { 'expo-device-run-session-token': 'session-token' },
-        })
-      );
-      expect(jest.mocked(fetch)).toHaveBeenCalledWith(
-        APPLICATION_ARCHIVE_URL,
-        expect.objectContaining({ headers: undefined })
-      );
-      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({
-        ok: false,
-        text: () => Promise.resolve('Internal Server Error'),
-        status: 500,
-      } as unknown as Response);
-
-      await expect(
-        createStep(createSessionCtx(graphqlClient), {
-          application_archive_url: APPLICATION_ARCHIVE_URL,
-          extensions: ['app'],
-        }).executeAsync()
-      ).rejects.toThrow('Internal Server Error');
-
-      expect(jest.mocked(fetch)).toHaveBeenCalledTimes(1);
-      expect(jest.mocked(fetch)).toHaveBeenCalledWith(
-        APPLICATION_ARCHIVE_URL,
-        expect.objectContaining({ headers: undefined })
-      );
-      expect(graphqlClient.query).not.toHaveBeenCalled();
-    });
-  });
-
   it('should download a build', async () => {
     const buildId = randomUUID();
     const graphqlClient = createMockGraphqlClient({

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,
@@ -35,8 +29,8 @@ jest.mock('../../../utils/processes');
 jest.mock('../../../utils/turtleFetch');
 jest.mock('../../utils/deviceSessionHost');
 jest.mock('../../utils/agentDeviceArtifacts');
+// The agent-device session step boots the Simulator itself; this test covers local egress.
 jest.mock('../startIosSimulator', () => ({
-  ...jest.requireActual('../startIosSimulator'),
   bootIosSimulatorAsync: jest
     .fn()
     .mockResolvedValue({ deviceIdentifier: 'sim', udid: 'sim', displayName: 'iPhone' }),
@@ -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__/runAgent.test.ts

@@ -25,7 +25,6 @@ const leaseMock = jest.mocked(leaseAgentRunProviderCredentialsAsync);
 const ctx = {
   expoApiV2BaseUrl: 'https://staging-api.expo.test/v2/',
   mcpServerUrl: 'wss://staging-mcp.expo.test',
-  runtimeApi: { addBuildLogMask: jest.fn() },
 } as any;
 const inputs = {
   agent_kind: { value: 'claude-code' },
@@ -116,19 +115,6 @@ describe(createRunAgentBuildFunction, () => {
     expect(agentEnv.HOME).not.toBe('/home/expo');
   });
 
-  it('hands the build log secrets filter to the agent run', async () => {
-    const runAgentSpy = jest.spyOn(agentRun, 'runAgentAsync').mockResolvedValue();
-    try {
-      await runAsync();
-
-      expect(runAgentSpy).toHaveBeenCalledWith(
-        expect.objectContaining({ addBuildLogMask: ctx.runtimeApi.addBuildLogMask })
-      );
-    } finally {
-      runAgentSpy.mockRestore();
-    }
-  });
-
   it.each([
     ['wss://staging-mcp.expo.test', 'https://staging-mcp.expo.test/mcp'],
     ['ws://localhost:8787', 'http://localhost:8787/mcp'],
@@ -176,7 +162,6 @@ describe(createRunAgentBuildFunction, () => {
     ['no PATH', { env: { ...env, PATH: '' } }],
     ['no Expo API URL', { ctx: { ...ctx, expoApiV2BaseUrl: undefined } }],
     ['no MCP server URL', { ctx: { ...ctx, mcpServerUrl: undefined } }],
-    ['no build log secrets filter', { ctx: { ...ctx, runtimeApi: {} } }],
   ])('throws a system error for %s', async (_name, overrides) => {
     await expect(runAsync(overrides)).rejects.toBeInstanceOf(SystemError);
 

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

@@ -70,14 +70,11 @@ 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
+  capture: CaptureInputs = NO_CAPTURE
 ): Promise<void> {
   await runAgentDeviceRemoteSessionAsync(ctx, {
     env: {},
@@ -89,16 +86,11 @@ 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 +120,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 +146,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 +185,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() };
 
@@ -233,24 +199,6 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
     );
   });
 
-  it('hands a private preview choice to the session host', async () => {
-    const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
-    await runAsync(
-      logger,
-      BuildRuntimePlatform.DARWIN,
-      NO_CAPTURE,
-      true,
-      'https://expo.dev/private-preview'
-    );
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      ctx,
-      expect.objectContaining({
-        disableShare: true,
-        privatePreviewUrl: 'https://expo.dev/private-preview',
-      })
-    );
-  });
-
   it('starts the session host without waiting for the agent-device daemon', async () => {
     const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
     const sessionHost = await jest.mocked(startDeviceSessionHostAsync).getMockImplementation()!(
@@ -319,14 +267,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 +282,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 +304,7 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
         maxDurationSeconds: undefined,
         capture: NO_CAPTURE,
         tasks,
-        device: sessionDevice,
+        device: typeof device === 'function' ? device(tasks) : device,
       });
     }
 
@@ -374,31 +314,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 +326,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 +339,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 +356,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 +372,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,10 @@
 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 +14,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 +42,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>;
@@ -100,11 +67,9 @@ async function flushAsync(): Promise<void> {
 
 function runStep(
   runtimePlatform: BuildRuntimePlatform,
-  inputValues: Record<string, unknown> = {},
-  signal?: AbortSignal,
-  stepCtx: CustomBuildContext = ctx
+  inputValues: Record<string, unknown> = {}
 ): Promise<void> {
-  const buildFunction = createStartAgentDeviceSessionBuildFunction(stepCtx);
+  const buildFunction = createStartAgentDeviceSessionBuildFunction(ctx);
   const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
   const inputs = Object.fromEntries(
     [
@@ -119,10 +84,6 @@ function runStep(
       'open_url',
       'network_capture',
       'network_capture_fields',
-      'public_preview',
-      'private_preview_url',
-      'frame_ancestors',
-      'cors_origins',
       'package_version',
       'max_idle_time_minutes',
       'max_duration_seconds',
@@ -136,32 +97,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 +128,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,180 +153,32 @@ 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]
-    );
-  });
-
-  it('downloads build_id through the device run session worker API when the job has a session token', async () => {
-    const sessionCtx = {
-      graphqlClient,
-      env: { EAS_DEVICE_RUN_SESSION_TOKEN: 'session-token' },
-      expoApiV2BaseUrl: 'https://api.expo.test/v2/',
-    } as unknown as CustomBuildContext;
-
-    await runStep(BuildRuntimePlatform.LINUX, { build_id: 'build-id' }, undefined, sessionCtx);
-
-    expect(downloadBuildAsync).toHaveBeenCalledWith(
-      expect.objectContaining({
-        buildId: 'build-id',
-        deviceRunSessionWorkerApi: expect.any(DeviceRunSessionWorkerApi),
-      })
-    );
-  });
-
-  it('does not use the worker API without a session token or for an archive URL', async () => {
-    await runStep(BuildRuntimePlatform.LINUX, { build_id: 'build-id' });
-    expect(downloadBuildAsync).toHaveBeenLastCalledWith(
-      expect.objectContaining({ buildId: 'build-id', deviceRunSessionWorkerApi: null })
-    );
-
-    const sessionCtx = {
-      graphqlClient,
-      env: { EAS_DEVICE_RUN_SESSION_TOKEN: 'session-token' },
-      expoApiV2BaseUrl: 'https://api.expo.test/v2/',
-    } as unknown as CustomBuildContext;
-    await runStep(
-      BuildRuntimePlatform.LINUX,
-      { application_archive_url: 'https://example.test/app.tar.gz' },
-      undefined,
-      sessionCtx
-    );
-    expect(downloadBuildAsync).toHaveBeenLastCalledWith(
-      expect.objectContaining({
-        applicationArchiveUrl: 'https://example.test/app.tar.gz',
-        deviceRunSessionWorkerApi: null,
-      })
-    );
-  });
-
-  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(installBuildAsync).toHaveBeenCalledWith(
+      expect.objectContaining({ artifactPath: '/tmp/App.app' })
     );
-    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(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]
     );
-    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 +190,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 +231,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 +276,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 +316,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 () => {
@@ -623,90 +370,12 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
       'open_url',
       'network_capture',
       'network_capture_fields',
-      'public_preview',
-      'private_preview_url',
-      'frame_ancestors',
-      'cors_origins',
       'package_version',
       'max_idle_time_minutes',
       'max_duration_seconds',
     ]);
   });
 
-  it.each([undefined, true, false])(
-    'passes public_preview=%s to the iOS session host',
-    async publicPreview => {
-      await runStep(BuildRuntimePlatform.DARWIN, {
-        public_preview: publicPreview,
-        private_preview_url: 'https://expo.dev/private-preview',
-      });
-      expect(runAgentDeviceRemoteSessionAsync).toHaveBeenCalledWith(
-        ctx,
-        expect.objectContaining({
-          disableShare: publicPreview === false,
-          privatePreviewUrl: 'https://expo.dev/private-preview',
-        })
-      );
-    }
-  );
-
-  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

@@ -1,4 +1,4 @@
-import { BuildRuntimePlatform, type BuildStepContext } from '@expo/steps';
+import { BuildRuntimePlatform } from '@expo/steps';
 import spawn from '@expo/turtle-spawn';
 import fs from 'node:fs';
 
@@ -6,19 +6,7 @@ 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 { selectXcodeDeveloperDirectoryAsync } from '../../utils/remoteDeviceRunSession';
 
 import {
   createStartAppiumRemoteSessionBuildFunction,
@@ -31,45 +19,13 @@ 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(),
 }));
 jest.mock('@expo/turtle-spawn', () => ({ __esModule: true, default: jest.fn() }));
-jest.mock('../../../sentry');
-jest.mock('../../../utils/retry', () => ({
-  ...jest.requireActual('../../../utils/retry'),
-  sleepAsync: jest.fn(),
-}));
-jest.mock('../../../utils/turtleFetch', () => ({
-  ...jest.requireActual('../../../utils/turtleFetch'),
-  turtleFetch: jest.fn(),
-}));
-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(),
-}));
 
 const logger = { info: jest.fn(), warn: jest.fn() } as never;
 
@@ -106,6 +62,7 @@ describe(resolveAppiumDeviceAsync, () => {
       resolveAppiumDeviceAsync({
         runtimePlatform: BuildRuntimePlatform.DARWIN,
         env: {},
+        logger,
       })
     ).resolves.toEqual({
       platformName: 'iOS',
@@ -114,6 +71,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 +87,7 @@ describe(resolveAppiumDeviceAsync, () => {
       resolveAppiumDeviceAsync({
         runtimePlatform: BuildRuntimePlatform.LINUX,
         env: {},
+        logger,
       })
     ).resolves.toEqual({
       platformName: 'Android',
@@ -209,501 +168,6 @@ describe('createStartAppiumRemoteSessionBuildFunction', () => {
 
     expect(
       buildFunction.inputProviders?.map(provider => provider(globalCtx, 'Test step').id)
-    ).toEqual(
-      expect.arrayContaining([
-        'launch_app_identifier',
-        'launch_args',
-        'open_url',
-        'public_preview',
-        'private_preview_url',
-      ])
-    );
-  });
-});
-
-describe('createStartAppiumRemoteSessionBuildFunction session lifecycle', () => {
-  const stopError = new Error('Process output drain timed out after 5000ms.');
-  const stopAppium = jest.fn();
-  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);
-    jest
-      .mocked(AndroidEmulatorUtils.getAttachedDevicesAsync)
-      .mockResolvedValue([{ serialId: 'emulator-5554', state: 'device' } as never]);
-    stopAppium.mockRejectedValue(stopError);
-    jest.mocked(spawnDetached).mockReturnValue({
-      pid: 4242,
-      getOutput: () => '',
-      getExitError: () => undefined,
-      stopAsync: stopAppium,
-    });
-    jest.mocked(turtleFetch).mockResolvedValue({ ok: true } as never);
-    stopEventCollection.mockResolvedValue(undefined);
-    jest.mocked(startAppiumEventCollectionAsync).mockResolvedValue({
-      stopAsync: stopEventCollection,
-      getLastEventObservedAt: () => undefined,
-    });
-    jest.mocked(startNgrokTunnelAsync).mockResolvedValue({
-      url: 'https://appium-abc.tunnel.example.com',
-      subdomainId: 'appium-abc',
-      stopAsync: jest.fn(),
-    });
-    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: jest.fn(),
-    });
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  async function runSessionAsync(
-    logger: { info: jest.Mock; warn: jest.Mock },
-    maxIdleTimeMinutes?: number,
-    runtimePlatform = BuildRuntimePlatform.LINUX,
-    startupInputs: Record<string, { value: unknown }> = {}
-  ): Promise<void> {
-    await createStartAppiumRemoteSessionBuildFunction({} as CustomBuildContext).fn!(
-      {
-        logger,
-        global: { runtimePlatform },
-      } as unknown as BuildStepContext,
-      {
-        inputs: {
-          package_version: { value: undefined },
-          max_idle_time_minutes: { value: maxIdleTimeMinutes },
-          ...startupInputs,
-        },
-        outputs: {},
-        env: {
-          DEVICE_RUN_SESSION_ID: 'device-run-session-id',
-          EAS_SIMULATOR_NGROK_TUNNEL_DOMAIN: 'tunnel.example.com',
-          NGROK_AUTHTOKEN: 'ngrok-token',
-        },
-      } as never
-    );
-  }
-
-  function expectAppiumStoppedAndHomeRemoved(logger: { warn: jest.Mock }): void {
-    expect(stopAppium).toHaveBeenCalledTimes(1);
-    expect(fs.existsSync(jest.mocked(spawnDetached).mock.calls[0][0].env.APPIUM_HOME!)).toBe(false);
-    expect(logger.warn).toHaveBeenCalledWith(
-      { err: stopError },
-      'Could not stop the Appium server during remote session teardown.'
-    );
-  }
-
-  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);
-    jest.mocked(sleepAsync).mockImplementation(async ms => {
-      now += ms;
-    });
-    jest.mocked(turtleFetch).mockRejectedValue(new Error('connect ECONNREFUSED'));
-    const logger = { info: jest.fn(), warn: jest.fn() };
-
-    await expect(runSessionAsync(logger)).rejects.toThrow(
-      'Timed out waiting for Appium to become ready.'
-    );
-    expectAppiumStoppedAndHomeRemoved(logger);
-    expect(startAppiumEventCollectionAsync).not.toHaveBeenCalled();
-    expect(startNgrokTunnelAsync).not.toHaveBeenCalled();
-  });
-
-  it('keeps the event collection error when Appium cannot be stopped', async () => {
-    const collectionError = new Error('event collection failed');
-    jest.mocked(startAppiumEventCollectionAsync).mockRejectedValueOnce(collectionError);
-    const logger = { info: jest.fn(), warn: jest.fn() };
-
-    await expect(runSessionAsync(logger)).rejects.toBe(collectionError);
-    expectAppiumStoppedAndHomeRemoved(logger);
-    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]
-    );
+    ).toEqual(expect.arrayContaining(['launch_app_identifier', 'launch_args', 'open_url']));
   });
 });

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

@@ -6,13 +6,10 @@ 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';
 import {
   ensureFfmpegInstalledOnceAsync,
   getDeviceRunSessionIdOrThrow,
@@ -25,7 +22,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 +36,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 +102,6 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
         apiUrl: 'https://web-preview.tunnel.example.com',
         closeAsync: jest.fn(),
       }),
-      getLastPreviewActivityAt: jest.fn(),
       finishAsync: mockPreviewStopAsync,
     });
     jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue(undefined);
@@ -143,21 +119,18 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
     await fs.promises.rm(TEST_HOME, { recursive: true, force: true });
   });
 
-  it('reports an early exit with output and stops Argent before opening tunnels', async () => {
-    const stopError = new Error('drain timed out');
-    const stopServer = jest.fn().mockRejectedValue(stopError);
+  it('reports an early exit with output before opening tunnels or publishing readiness', async () => {
     jest.mocked(spawnDetached).mockReturnValue({
       pid: 4242,
       getOutput: () => 'could not bind server port',
       getExitError: () => new Error('process exited with code 1'),
-      stopAsync: stopServer,
+      stopAsync: jest.fn(),
     });
-    const logger = { info: jest.fn(), warn: jest.fn() };
     const buildFunction = createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext);
     await expect(
       buildFunction.fn!(
         {
-          logger,
+          logger: { info: jest.fn(), warn: jest.fn() },
           global: { runtimePlatform: BuildRuntimePlatform.LINUX },
         } as unknown as BuildStepContext,
         {
@@ -172,66 +145,11 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
     ).rejects.toThrow(
       'Argent exited before becoming ready: process exited with code 1\nArgent tool-server output:\ncould not bind server port'
     );
-    expect(stopServer).toHaveBeenCalledTimes(1);
-    expect(logger.warn).toHaveBeenCalledWith(
-      { err: stopError },
-      'Could not stop the Argent tool-server during remote session teardown.'
-    );
-    expect(pollArgentArtifactsForUploadAsync).not.toHaveBeenCalled();
     expect(startNgrokTunnelAsync).not.toHaveBeenCalled();
     expect(uploadRemoteSessionConfigAsync).not.toHaveBeenCalled();
     expect(startArgentEventCollectionAsync).not.toHaveBeenCalled();
   });
 
-  it('drains artifact polling and stops the tool-server when event collection cannot start', async () => {
-    const collectionError = new Error('event collection failed');
-    const stopError = new Error('drain timed out');
-    let pollingFinished = false;
-    jest
-      .mocked(pollArgentArtifactsForUploadAsync)
-      .mockImplementationOnce(async (_ctx, { signal }) => {
-        await new Promise(resolve => signal.addEventListener('abort', resolve, { once: true }));
-        pollingFinished = true;
-      });
-    jest.mocked(startArgentEventCollectionAsync).mockRejectedValueOnce(collectionError);
-    const stopServer = jest.fn(async () => {
-      expect(pollingFinished).toBe(true);
-      throw stopError;
-    });
-    jest.mocked(spawnDetached).mockReturnValueOnce({
-      pid: 4242,
-      getOutput: () => '',
-      getExitError: () => undefined,
-      stopAsync: stopServer,
-    });
-    const logger = { info: jest.fn(), warn: jest.fn() };
-    const buildFunction = createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext);
-    await expect(
-      buildFunction.fn!(
-        {
-          logger,
-          global: { runtimePlatform: BuildRuntimePlatform.LINUX },
-        } as unknown as BuildStepContext,
-        {
-          inputs: {
-            package_version: { value: undefined },
-            max_idle_time_minutes: { value: undefined },
-          },
-          outputs: {},
-          env: {},
-        } as never
-      )
-    ).rejects.toBe(collectionError);
-    expect(pollingFinished).toBe(true);
-    expect(stopServer).toHaveBeenCalledTimes(1);
-    expect(logger.warn).toHaveBeenCalledWith(
-      { err: stopError },
-      'Could not stop the Argent tool-server during remote session teardown.'
-    );
-    expect(startNgrokTunnelAsync).not.toHaveBeenCalled();
-    expect(startDeviceSessionHostAsync).not.toHaveBeenCalled();
-  });
-
   it.each(['preview', 'config', 'wait'])(
     'finishes the host and tools after %s fails',
     async phase => {
@@ -239,7 +157,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') {
@@ -271,59 +188,6 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
     }
   );
 
-  it.each([
-    ['succeeded', false],
-    ['failed', true],
-  ])(
-    'fails after stopping the host and tools when the tools tunnel cannot close and the session %s',
-    async (_description, sessionFails) => {
-      const closeError = new Error('ngrok close failed');
-      const sessionError = new Error('session failed');
-      mockTunnelStopAsync.mockRejectedValueOnce(closeError);
-      if (sessionFails) {
-        jest.mocked(waitForDeviceRunSessionStoppedAsync).mockRejectedValueOnce(sessionError);
-      }
-      const logger = { info: jest.fn(), warn: jest.fn() };
-      const buildFunction = createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext);
-      // The tunnel may still be serving, so its failure fails a session that otherwise succeeded.
-      await expect(
-        buildFunction.fn!(
-          {
-            logger,
-            global: { runtimePlatform: BuildRuntimePlatform.LINUX },
-          } as unknown as BuildStepContext,
-          {
-            inputs: {
-              package_version: { value: undefined },
-              max_idle_time_minutes: { value: undefined },
-            },
-            outputs: {},
-            env: {},
-          } as never
-        )
-      ).rejects.toBe(sessionFails ? sessionError : closeError);
-      expect(mockTunnelStopAsync).toHaveBeenCalledTimes(1);
-      expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
-      expect(mockStopAsync).toHaveBeenCalledTimes(1);
-      expect(jest.mocked(spawnDetached).mock.results[0].value.stopAsync).toHaveBeenCalledTimes(1);
-      expect(logger.warn).toHaveBeenCalledWith(
-        { err: closeError },
-        'Could not stop the Argent tunnel during remote session teardown.'
-      );
-      expect(jest.mocked(Sentry.capture).mock.calls).toEqual(
-        sessionFails
-          ? [
-              [
-                'Could not stop the Argent tunnel after the remote session failed',
-                closeError,
-                { level: 'warning' },
-              ],
-            ]
-          : []
-      );
-    }
-  );
-
   it('enables the event log flag, disables the video watermark, shares one path, and starts/stops the collector', async () => {
     const ctx = {} as unknown as CustomBuildContext;
     const buildFunction = createStartArgentRemoteSessionBuildFunction(ctx);
@@ -404,7 +268,7 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
     expect(mockTunnelStopAsync).toHaveBeenCalledTimes(1);
     expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
       ctx,
-      expect.objectContaining({ runtimePlatform: BuildRuntimePlatform.LINUX, disableShare: false })
+      expect.objectContaining({ runtimePlatform: BuildRuntimePlatform.LINUX })
     );
     expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -417,82 +281,6 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
     expect(mockPreviewStopAsync).toHaveBeenCalledTimes(1);
   });
 
-  it('passes public_preview=false 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 },
-          public_preview: { value: false },
-          private_preview_url: { value: 'https://expo.dev/private-preview' },
-        },
-        outputs: {},
-        env: {},
-      } as never
-    );
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      ctx,
-      expect.objectContaining({
-        disableShare: true,
-        privatePreviewUrl: 'https://expo.dev/private-preview',
-      })
-    );
-  });
-
-  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,81 +318,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(
-      path.join(ARGENT_STATE_DIR, 'tool-server-orchestration.json'),
-      JSON.stringify({ port: 5678, pid: 9999, token })
-    );
-    const logger = { info: jest.fn(), warn: jest.fn() };
-    jest.mocked(spawnDetached).mockImplementationOnce(options => {
-      const output = createProcessOutput(options.logger, options.secrets);
-      output.stdout.append(`argent link argent://${encodeURIComponent(token)}@127.0.0.1:5678\n`);
-      return {
-        pid: 4242,
-        getOutput: output.getOutput,
-        getExitError: () => undefined,
-        stopAsync: async () => {
-          output.stderr.append(`opaque ${token}\nencoded ${encodeURIComponent(token)}\n`);
-          output.stderr.append(`escaped ${JSON.stringify(token).slice(1, -1)}\n`);
-          output.finish();
-        },
-      };
-    });
-    const buildFunction = createStartArgentRemoteSessionBuildFunction({} as CustomBuildContext);
-    await buildFunction.fn!(
-      {
-        logger,
-        global: { runtimePlatform: BuildRuntimePlatform.LINUX },
-      } as unknown as BuildStepContext,
-      {
-        inputs: {
-          package_version: { value: undefined },
-          max_idle_time_minutes: { value: undefined },
-        },
-        outputs: {},
-        env: {},
-      } as never
-    );
-    expect(logger.info).toHaveBeenCalledWith(
-      { source: 'stdout' },
-      'argent link argent://[REDACTED]@127.0.0.1:5678'
-    );
-    for (const label of ['opaque', 'encoded', 'escaped']) {
-      expect(logger.info).toHaveBeenCalledWith({ source: 'stderr' }, `${label} [REDACTED]`);
-    }
-    expect(JSON.stringify(logger.info.mock.calls)).not.toContain('secret');
-  });
-
   it('hands the launch inputs to serve-sim and announces them on an iOS session', async () => {
     const ctx = {} as unknown as CustomBuildContext;
     const logger = { info: jest.fn(), warn: jest.fn() };
@@ -644,280 +357,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() };
@@ -951,15 +390,7 @@ describe('createStartArgentRemoteSessionBuildFunction orchestration', () => {
 
     expect(
       buildFunction.inputProviders?.map(provider => provider(globalCtx, 'Test step').id)
-    ).toEqual(
-      expect.arrayContaining([
-        'launch_app_identifier',
-        'launch_args',
-        'open_url',
-        'public_preview',
-        'private_preview_url',
-      ])
-    );
+    ).toEqual(expect.arrayContaining(['launch_app_identifier', 'launch_args', 'open_url']));
   });
 
   it('stops automation without waiting for recording upload', async () => {

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

@@ -32,7 +32,6 @@ jest.mock('../../utils/remoteDeviceRunSession', () => ({
   startNgrokTunnelAsync: jest.fn(),
   getNgrokAuthtokenOrThrow: () => 'ngrok-token',
   getNgrokTunnelDomainOrThrow: () => 'example.com',
-  omitNgrokAuthtoken: jest.requireActual('../../utils/remoteDeviceRunSession').omitNgrokAuthtoken,
 }));
 
 const logger = { info: jest.fn(), warn: jest.fn() } as unknown as bunyan;

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

@@ -3,7 +3,6 @@ import { BuildRuntimePlatform, type BuildStepContext, type BuildStepEnv } from '
 
 import { createGlobalContextMock } from '../../../__tests__/utils/context';
 import { type CustomBuildContext } from '../../../customBuildContext';
-import { IosSimulatorUtils } from '../../../utils/IosSimulatorUtils';
 import { startDeviceSessionHostAsync } from '../../utils/deviceSessionHost';
 import {
   getDeviceRunSessionIdOrThrow,
@@ -15,22 +14,6 @@ import {
 import { createStartWebPreviewRemoteSessionBuildFunction } from '../startWebPreviewRemoteSession';
 
 jest.mock('../../utils/deviceSessionHost');
-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/iosAppArtifact', () => ({
-  ...jest.requireActual('../../utils/iosAppArtifact'),
-  readIosApplicationIdentifierAsync: jest.fn().mockResolvedValue('dev.example.app'),
-}));
-jest.mock('../../utils/localEgressGuard', () => ({
-  resolveLocalEgressServeSimBootEnvironmentAsync: jest.fn().mockResolvedValue(null),
-}));
-
 jest.mock('../../utils/remoteDeviceRunSession', () => ({
   ...jest.requireActual('../../utils/remoteDeviceRunSession'),
   getDeviceRunSessionIdOrThrow: jest.fn(),
@@ -41,8 +24,7 @@ jest.mock('../../utils/remoteDeviceRunSession', () => ({
 }));
 
 const ctx = {} as CustomBuildContext;
-const env = { NGROK_AUTHTOKEN: 'ngrok-token', PATH: '/usr/bin' } as BuildStepEnv;
-const childEnv = { PATH: '/usr/bin' } as BuildStepEnv;
+const env = {} as BuildStepEnv;
 const logger = { info: jest.fn(), warn: jest.fn() } as unknown as bunyan;
 const stopAsync = jest.fn();
 
@@ -77,11 +59,9 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
     jest.mocked(startDeviceSessionHostAsync).mockResolvedValue({
       openPreviewAsync: jest.fn().mockResolvedValue({
         previewPageUrl: 'https://expo.dev/simulator-preview/preview-id',
-        sharePageUrl: 'https://expo.dev/simulator-preview/preview-id',
         apiUrl: 'https://web-preview.example.test',
         closeAsync: jest.fn(),
       }),
-      getLastPreviewActivityAt: jest.fn(),
       finishAsync: stopAsync,
     });
     jest.mocked(uploadRemoteSessionConfigAsync).mockResolvedValue(undefined);
@@ -93,12 +73,10 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
     jest.mocked(startDeviceSessionHostAsync).mockResolvedValue({
       openPreviewAsync: jest.fn().mockResolvedValue({
         previewPageUrl: 'https://expo.dev/simulator-preview/preview-id',
-        sharePageUrl: 'https://expo.dev/simulator-preview/preview-id',
         apiUrl: 'https://web-preview.example.test',
         previewToken: 'tok-1',
         closeAsync: jest.fn(),
       }),
-      getLastPreviewActivityAt: jest.fn(),
       finishAsync: stopAsync,
     });
 
@@ -117,62 +95,11 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
     );
   });
 
-  it('logs the authenticated link while publishing the public frame URL', async () => {
-    const privatePreviewUrl = 'https://expo.dev/private-preview';
-    jest.mocked(startDeviceSessionHostAsync).mockResolvedValueOnce({
-      openPreviewAsync: jest.fn().mockResolvedValue({
-        previewPageUrl: 'https://expo.dev/simulator-preview/preview-id',
-        sharePageUrl: privatePreviewUrl,
-        apiUrl: 'https://web-preview.example.test',
-        closeAsync: jest.fn(),
-      }),
-      getLastPreviewActivityAt: jest.fn(),
-      finishAsync: stopAsync,
-    });
-
-    await runAsync(BuildRuntimePlatform.DARWIN, {
-      public_preview: { value: false },
-      private_preview_url: { value: privatePreviewUrl },
-    });
-
-    expect(logger.info).toHaveBeenCalledWith(
-      `Preview URL: ${privatePreviewUrl} (server: https://web-preview.example.test).`
-    );
-    expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith(
-      expect.objectContaining({
-        remoteConfig: expect.objectContaining({
-          webPreviewUrl: 'https://expo.dev/simulator-preview/preview-id',
-        }),
-      })
-    );
-  });
-
-  it('does not log the public link when a private job lacks its authenticated URL', async () => {
-    jest.mocked(startDeviceSessionHostAsync).mockResolvedValueOnce({
-      openPreviewAsync: jest.fn().mockResolvedValue({
-        previewPageUrl: 'https://expo.dev/simulator-preview/preview-id',
-        apiUrl: 'https://web-preview.example.test',
-        closeAsync: jest.fn(),
-      }),
-      getLastPreviewActivityAt: jest.fn(),
-      finishAsync: stopAsync,
-    });
-    await runAsync(BuildRuntimePlatform.DARWIN, { public_preview: { value: false } });
-
-    expect(logger.info).toHaveBeenCalledWith('Private preview URL unavailable for this session.');
-    expect(jest.mocked(logger.info).mock.calls).not.toEqual(
-      expect.arrayContaining([
-        expect.arrayContaining([expect.stringContaining('/simulator-preview/preview-id')]),
-      ])
-    );
-  });
-
   it.each(['preview', 'config', 'wait'])('finishes the session after %s fails', async phase => {
     const error = new Error(`${phase} failed`);
     if (phase === 'preview') {
       jest.mocked(startDeviceSessionHostAsync).mockResolvedValueOnce({
         openPreviewAsync: jest.fn().mockRejectedValue(error),
-        getLastPreviewActivityAt: jest.fn(),
         finishAsync: stopAsync,
       });
     } else if (phase === 'config') {
@@ -188,46 +115,21 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
     [BuildRuntimePlatform.DARWIN, true],
     [BuildRuntimePlatform.LINUX, false],
   ])('starts the web preview for %s', async (runtimePlatform, selectsXcode) => {
-    await runAsync(runtimePlatform, selectsXcode ? { boot_simulator: { value: true } } : {});
+    await runAsync(runtimePlatform);
 
-    expect(
-      jest
-        .mocked(logger.info)
-        .mock.calls.filter(
-          ([message]) =>
-            message ===
-            'Preview URL: https://expo.dev/simulator-preview/preview-id (server: https://web-preview.example.test).'
-        )
-    ).toHaveLength(1);
     expect(selectXcodeDeveloperDirectoryAsync).toHaveBeenCalledTimes(selectsXcode ? 1 : 0);
     expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(ctx, {
       runtimePlatform,
-      env: childEnv,
+      env,
       logger,
       timeoutMs: 60_000,
-      signal: undefined,
-      ...(selectsXcode
-        ? {
-            iosSimulatorUdid: 'SELECTED-IOS-UDID',
-            installAppPath: undefined,
-            bootEnv: undefined,
-          }
-        : {}),
       packageVersion: '1.2.3',
-      disableShare: false,
-      frameAncestors: [],
-      corsOrigins: [],
       launchAppIdentifier: undefined,
       launchArgs: [],
       openUrl: undefined,
       networkCapture: false,
       networkCaptureFields: [],
     });
-    const host = await jest.mocked(startDeviceSessionHostAsync).mock.results[0].value;
-    expect(host.openPreviewAsync).toHaveBeenCalledWith({
-      baseDomain: 'tunnel.example.com',
-      authtoken: 'ngrok-token',
-    });
     expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith({
       ctx,
       deviceRunSessionId: 'device-run-session-id',
@@ -258,15 +160,8 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
       'launch_app_identifier',
       'launch_args',
       'open_url',
-      'boot_simulator',
-      'device_identifier',
-      'install_app_path',
       'network_capture',
       'network_capture_fields',
-      'public_preview',
-      'private_preview_url',
-      'frame_ancestors',
-      'cors_origins',
       'package_version',
       'max_duration_seconds',
     ]);
@@ -293,64 +188,6 @@ describe(createStartWebPreviewRemoteSessionBuildFunction, () => {
     );
   });
 
-  it('hands the downloaded app and selected device to serve-sim with initial launch options', async () => {
-    await runAsync(BuildRuntimePlatform.DARWIN, {
-      device_identifier: { value: 'chosen-device' },
-      install_app_path: { value: '/tmp/App.app' },
-      launch_args: { value: ['--literal', 'value with spaces'] },
-      open_url: { value: 'example://home' },
-    });
-    expect(
-      jest.mocked(selectXcodeDeveloperDirectoryAsync).mock.invocationCallOrder[0]
-    ).toBeLessThan(jest.mocked(IosSimulatorUtils.resolveUdidAsync).mock.invocationCallOrder[0]);
-    expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-      ctx,
-      expect.objectContaining({
-        iosSimulatorUdid: 'SELECTED-IOS-UDID',
-        installAppPath: '/tmp/App.app',
-        launchAppIdentifier: 'dev.example.app',
-        launchArgs: ['--literal', 'value with spaces'],
-        openUrl: 'example://home',
-      })
-    );
-  });
-  it.each([true, false])(
-    'maps public_preview=%s to the native Share option',
-    async publicPreview => {
-      await runAsync(BuildRuntimePlatform.DARWIN, {
-        public_preview: { value: publicPreview },
-        private_preview_url: { value: 'https://expo.dev/private-preview' },
-      });
-      expect(startDeviceSessionHostAsync).toHaveBeenCalledWith(
-        ctx,
-        expect.objectContaining({
-          disableShare: !publicPreview,
-          privatePreviewUrl: 'https://expo.dev/private-preview',
-        })
-      );
-    }
-  );
-
-  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

@@ -15,11 +15,6 @@ import {
 import { createSubmitToGooglePlayBuildFunction } from '../submitToGooglePlay';
 
 jest.unmock('node-fetch');
-jest.mock('promise-retry', () => {
-  const actual = jest.requireActual('promise-retry');
-  return (fn: Parameters<typeof actual>[0], options: object) =>
-    actual(fn, { ...options, minTimeout: 1, maxTimeout: 1, randomize: false });
-});
 jest.unmock('fs');
 jest.unmock('node:fs');
 jest.unmock('fs/promises');
@@ -179,7 +174,7 @@ it('preserves the original failure when cleanup fails', async () => {
   api()
     .put(`${editPath}/tracks/internal`)
     .reply(400, { error: { message: 'unknown track' } });
-  api().delete(editPath).times(6).reply(500);
+  api().delete(editPath).reply(500);
   await expect(submission().run()).rejects.toMatchObject({
     cause: expect.objectContaining({ apiMessage: 'unknown track' }),
   });
@@ -188,7 +183,6 @@ it('does not delete the edit or publish outputs when commit outcome is unknown',
   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);
   let deleted = false;
   api()
     .delete(editPath)
@@ -226,32 +220,3 @@ it('preserves the cause when the service-account file cannot be read', async ()
     read.mockRestore();
   }
 });
-
-it('logs a formatted rollout and confirms the track update before committing', async () => {
-  upload();
-  const task = submission({ rollout: 0.29 });
-  const info = jest.spyOn(task.step.ctx.logger, 'info');
-  const updatedMessage = 'Updated Google Play track "internal" in the edit.';
-  let loggedBeforeUpdate = false;
-  let messagesBeforeCommit: unknown[] = [];
-  api()
-    .put(`${editPath}/tracks/internal`)
-    .reply(() => {
-      loggedBeforeUpdate = info.mock.calls.some(([message]) => message === updatedMessage);
-      return [200, { track: 'internal' }];
-    });
-  api()
-    .post(`${editPath}:commit`)
-    .query({})
-    .reply(() => {
-      messagesBeforeCommit = info.mock.calls.map(([message]) => message);
-      return [200, { id: 'edit' }];
-    });
-  await task.run();
-  expect(info).toHaveBeenCalledWith('Release status: inProgress. Rollout: 29%.');
-  expect(loggedBeforeUpdate).toBe(false);
-  expect(messagesBeforeCommit.slice(-2)).toEqual([
-    updatedMessage,
-    'Committing the Google Play edit...',
-  ]);
-});

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,18 +26,8 @@ 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';
 
 const streamPipeline = promisify(stream.pipeline);
 
@@ -128,7 +118,6 @@ export function createDownloadBuildFunction(ctx: CustomBuildContext): BuildFunct
         logger,
         ...source,
         graphqlClient: ctx.graphqlClient,
-        deviceRunSessionWorkerApi: buildId ? getDeviceRunSessionWorkerApi(ctx) : null,
         robotAccessToken: stepsCtx.global.staticContext.job.secrets?.robotAccessToken ?? null,
         extensions,
         signal,
@@ -142,50 +131,28 @@ export function createDownloadBuildFunction(ctx: CustomBuildContext): BuildFunct
 async function fetchApplicationArchiveUrlAsync({
   buildId,
   graphqlClient,
-  deviceRunSessionWorkerApi,
   signal,
 }: {
   buildId: string;
   graphqlClient: Client;
-  deviceRunSessionWorkerApi?: DeviceRunSessionWorkerApi | null;
   signal?: AbortSignal;
 }): Promise<string> {
   signal?.throwIfAborted();
-  if (deviceRunSessionWorkerApi) {
-    return await fetchDeviceRunSessionApplicationArchiveUrlAsync({
-      buildId,
-      deviceRunSessionWorkerApi,
-      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',
@@ -196,76 +163,17 @@ async function fetchApplicationArchiveUrlAsync({
   return applicationArchiveUrl;
 }
 
-/**
- * A device run session token can read only the build of its own session, so the build comes from
- * `GET /v2/device-run-session-worker/application` instead of the builds GraphQL query.
- *
- * Only device run session jobs, whose steps www generates from the session, reach this path, so
- * every failure here is a system error: neither the request nor `build_id` comes from the user.
- */
-async function fetchDeviceRunSessionApplicationArchiveUrlAsync({
-  buildId,
-  deviceRunSessionWorkerApi,
-  signal,
-}: {
-  buildId: string;
-  deviceRunSessionWorkerApi: DeviceRunSessionWorkerApi;
-  signal?: AbortSignal;
-}): 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,
-      }
-    );
-  } catch (err) {
-    signal?.throwIfAborted();
-    throw new SystemError(
-      `Could not fetch build ${buildId} for this device run session: ${describeError(err)}`,
-      { cause: err }
-    );
-  }
-  signal?.throwIfAborted();
-
-  if (application.build?.id !== buildId) {
-    throw new SystemError(
-      `Could not fetch build ${buildId}: this device run session runs ${
-        application.build ? `build ${application.build.id}` : 'no build'
-      }, and its session token can read only that build. www generates this step from the ` +
-        'session, so the two should always match. Start a new session, and contact support if ' +
-        'it happens again.'
-    );
-  }
-  if (!application.build.applicationArchiveUrl) {
-    throw new UserError(
-      'EAS_DOWNLOAD_BUILD_NO_APPLICATION_ARCHIVE',
-      'Build does not have an application archive url'
-    );
-  }
-  return application.build.applicationArchiveUrl;
-}
-
 export async function downloadBuildAsync(
   params: DownloadBuildSource & {
     logger: bunyan;
     graphqlClient: Client;
-    /**
-     * Set in a device run session job that has a session token. The build lookup then uses the
-     * device run session worker API instead of GraphQL.
-     */
-    deviceRunSessionWorkerApi?: DeviceRunSessionWorkerApi | null;
     robotAccessToken: string | null;
     extensions: string[];
     /** Stops the build lookup, the request and the file write when aborted, and skips the rest. */
     signal?: AbortSignal;
   }
 ): Promise<{ artifactPath: string }> {
-  const { logger, graphqlClient, deviceRunSessionWorkerApi, robotAccessToken, extensions, signal } =
-    params;
+  const { logger, graphqlClient, robotAccessToken, extensions, signal } = params;
 
   let downloadUrl: string;
   let headers: { Authorization: string } | undefined;
@@ -280,19 +188,8 @@ export async function downloadBuildAsync(
     headers = undefined;
   } else if (params.buildId) {
     const buildId = z.string().uuid().parse(params.buildId);
-    downloadUrl = await fetchApplicationArchiveUrlAsync({
-      buildId,
-      graphqlClient,
-      deviceRunSessionWorkerApi,
-      signal,
-    });
-    // The archive URL from the device run session worker API points to an artifact route that
-    // needs no auth. After www stops minting EXPO_TOKEN for session jobs, robotAccessToken is the
-    // session token, and www rejects it as a bearer credential on every route.
-    headers =
-      robotAccessToken && !deviceRunSessionWorkerApi
-        ? { Authorization: `Bearer ${robotAccessToken}` }
-        : undefined;
+    downloadUrl = await fetchApplicationArchiveUrlAsync({ buildId, graphqlClient, signal });
+    headers = robotAccessToken ? { Authorization: `Bearer ${robotAccessToken}` } : undefined;
   } else {
     throw new UserError(
       'EAS_DOWNLOAD_BUILD_INVALID_SOURCE',
@@ -305,34 +202,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/runAgent.ts

@@ -96,9 +96,6 @@ export function createRunAgentBuildFunction(ctx: CustomBuildContext): BuildFunct
       if (!ctx.mcpServerUrl) {
         throw new SystemError('MCP server URL is required to run an agent.');
       }
-      if (!ctx.runtimeApi.addBuildLogMask) {
-        throw new SystemError('A build log secrets filter is required to run an agent.');
-      }
       // The worker config holds the MCP server's WebSocket URL; its HTTP endpoint is on the same host.
       const mcpUrl = new URL('/mcp', ctx.mcpServerUrl);
       mcpUrl.protocol = mcpUrl.protocol.replace(/^ws/, 'http');
@@ -123,7 +120,6 @@ export function createRunAgentBuildFunction(ctx: CustomBuildContext): BuildFunct
           pathEnv,
           npmCacheUrl,
           logger: stepCtx.logger,
-          addBuildLogMask: ctx.runtimeApi.addBuildLogMask,
           signal: signal
             ? AbortSignal.any([signal, timeoutController.signal])
             : timeoutController.signal,

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,
@@ -93,10 +96,6 @@ export async function runAgentDeviceRemoteSessionAsync(
     maxIdleTimeMinutes,
     maxDurationSeconds,
     capture,
-    disableShare = false,
-    privatePreviewUrl,
-    frameAncestors,
-    corsOrigins,
     tasks,
     device,
   }: {
@@ -109,26 +108,10 @@ export async function runAgentDeviceRemoteSessionAsync(
     maxIdleTimeMinutes: number | undefined;
     maxDurationSeconds: number | undefined;
     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 +122,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 +150,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,
@@ -184,45 +163,28 @@ export async function runAgentDeviceRemoteSessionAsync(
       env,
       logger: taskLogger,
       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();
+    const webPreview = await sessionHost.openPreviewAsync({ baseDomain: ngrokTunnelDomain });
     taskLogger.info(
-      webPreview.sharePageUrl
-        ? `Web preview URL: ${webPreview.sharePageUrl} (server: ${webPreview.apiUrl}).`
-        : 'Private preview URL unavailable for this session.'
+      `Web preview URL: ${webPreview.previewPageUrl} (server: ${webPreview.apiUrl}).`
     );
     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 +201,6 @@ export async function runAgentDeviceRemoteSessionAsync(
       },
       logger,
     });
-    tasks.signal.throwIfAborted();
     void pollAgentDeviceArtifactsForUploadAsync(ctx, {
       deviceRunSessionId,
       daemonUrl: `http://127.0.0.1:${daemonPort}`,
@@ -265,7 +226,6 @@ export async function runAgentDeviceRemoteSessionAsync(
           ? {
               maxIdleTimeMinutes,
               getLastEventObservedAt: eventCollection.getLastEventObservedAt,
-              getLastPreviewActivityAt: () => sessionHost?.getLastPreviewActivityAt(),
             }
           : undefined,
     });
@@ -276,7 +236,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 +280,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 +289,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,27 +15,14 @@ import {
   AndroidEmulatorUtils,
   AndroidVirtualDeviceName,
 } from '../../utils/AndroidEmulatorUtils';
-import { getDeviceRunSessionWorkerApi } from '../utils/deviceRunSessionWorkerApi';
+import { IosSimulatorName, IosSimulatorUuid } from '../../utils/IosSimulatorUtils';
 import { withLocalEgressSession } from '../utils/localEgressSession';
-import {
-  createCorsOriginsInputProvider,
-  createFrameAncestorsInputProvider,
-  createPrivatePreviewUrlInputProvider,
-  createPublicPreviewInputProvider,
-  omitNgrokAuthtoken,
-  parseCorsOriginsInput,
-  parseFrameAncestorsInput,
-  selectXcodeDeveloperDirectoryAsync,
-} from '../utils/remoteDeviceRunSession';
+import { selectXcodeDeveloperDirectoryAsync } from '../utils/remoteDeviceRunSession';
 import {
   createNetworkCaptureInputProviders,
   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 +36,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({
@@ -116,10 +114,6 @@ export function createStartAgentDeviceSessionBuildFunction(ctx: CustomBuildConte
       }),
       // Session.
       ...createNetworkCaptureInputProviders(),
-      createPublicPreviewInputProvider(),
-      createPrivatePreviewUrlInputProvider(),
-      createFrameAncestorsInputProvider(),
-      createCorsOriginsInputProvider(),
       BuildStepInput.createProvider({
         id: 'package_version',
         required: false,
@@ -136,14 +130,13 @@ export function createStartAgentDeviceSessionBuildFunction(ctx: CustomBuildConte
         allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
       }),
     ],
-    fn: withLocalEgressSession(async (stepsCtx, { inputs, env: stepEnv, signal }) => {
+    fn: withLocalEgressSession(async (stepsCtx, { inputs, env, signal }) => {
       const { logger, global } = stepsCtx;
       const { runtimePlatform } = global;
       const isIos = runtimePlatform === BuildRuntimePlatform.DARWIN;
 
       // Validate everything before any expensive work starts.
-      const sessionEnv = getAgentDeviceRemoteSessionEnvOrThrow(stepEnv);
-      const env = omitNgrokAuthtoken(stepEnv);
+      const sessionEnv = getAgentDeviceRemoteSessionEnvOrThrow(env);
       const buildId = inputs.build_id.value as string | undefined;
       const applicationArchiveUrl = inputs.application_archive_url.value as string | undefined;
       if (buildId && applicationArchiveUrl) {
@@ -162,11 +155,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 +164,104 @@ 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,
+              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,
+        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,29 +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,
   describeServeSimLaunch,
   ensureFfmpegInstalledOnceAsync,
@@ -52,9 +44,7 @@ import {
   getDeviceRunSessionIdOrThrow,
   getNgrokAuthtokenOrThrow,
   getNgrokTunnelDomainOrThrow,
-  omitNgrokAuthtoken,
-  parseCorsOriginsInput,
-  parseFrameAncestorsInput,
+  parseServeSimLaunchInputs,
   selectXcodeDeveloperDirectoryAsync,
   spawnDetached,
   startNgrokTunnelAsync,
@@ -81,12 +71,7 @@ export function createStartAppiumRemoteSessionBuildFunction(
     __metricsId: 'eas/start_appium_remote_session',
     inputProviders: [
       ...createServeSimLaunchInputProviders(),
-      ...createIosSessionStartupInputProviders(),
       ...createNetworkCaptureInputProviders(),
-      createPublicPreviewInputProvider(),
-      createPrivatePreviewUrlInputProvider(),
-      createFrameAncestorsInputProvider(),
-      createCorsOriginsInputProvider(),
       BuildStepInput.createProvider({
         id: 'package_version',
         required: false,
@@ -98,29 +83,21 @@ export function createStartAppiumRemoteSessionBuildFunction(
         allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
       }),
     ],
-    fn: withLocalEgressSession(async ({ logger, global }, { inputs, env: stepEnv, signal }) => {
-      const deviceRunSessionId = getDeviceRunSessionIdOrThrow(stepEnv);
-      const ngrokTunnelDomain = getNgrokTunnelDomainOrThrow(stepEnv);
-      const ngrokAuthtoken = getNgrokAuthtokenOrThrow(stepEnv);
-      const env = omitNgrokAuthtoken(stepEnv);
+    fn: withLocalEgressSession(async ({ logger, global }, { inputs, env, signal }) => {
+      const deviceRunSessionId = getDeviceRunSessionIdOrThrow(env);
+      const ngrokTunnelDomain = getNgrokTunnelDomainOrThrow(env);
+      const ngrokAuthtoken = getNgrokAuthtokenOrThrow(env);
       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,131 +110,65 @@ 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;
-      let eventCollection: Awaited<ReturnType<typeof startAppiumEventCollectionAsync>> | undefined;
-      let appiumTunnel: Awaited<ReturnType<typeof startNgrokTunnelAsync>> | 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,
-        });
+      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,
+      });
 
-        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();
-        eventCollection = await startAppiumEventCollectionAsync({
-          ctx,
-          deviceRunSessionId,
-          appiumUrl: `http://${APPIUM_HOST}:${APPIUM_PORT}/`,
-          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,
+      });
+      try {
+        await waitForAppiumReadyAsync({ appiumProcess, logger });
+      } catch (error) {
+        await appiumProcess.stopAsync();
+        await fs.promises.rm(appiumHome, { recursive: true, force: true });
+        throw error;
+      }
+
+      const eventCollection = await startAppiumEventCollectionAsync({
+        ctx,
+        deviceRunSessionId,
+        appiumUrl: `http://${APPIUM_HOST}:${APPIUM_PORT}/`,
+        logger,
+      });
+      let appiumTunnel: Awaited<ReturnType<typeof startNgrokTunnelAsync>> | undefined;
+      let sessionHost: DeviceSessionHost | undefined;
+      let sessionFailed = false;
+      try {
         appiumTunnel = await startNgrokTunnelAsync({
           port: APPIUM_PORT,
           subdomainPrefix: 'appium',
@@ -272,11 +183,18 @@ export function createStartAppiumRemoteSessionBuildFunction(
         if (launchDescription) {
           logger.info(launchDescription);
         }
-        sessionHost ??= (await (hostStartup ??= asyncResult(startHost()))).enforceValue();
-        const webPreview = await sessionHost.openPreviewAsync({
-          baseDomain: ngrokTunnelDomain,
-          authtoken: ngrokAuthtoken,
+        sessionHost = await startDeviceSessionHostAsync(ctx, {
+          runtimePlatform,
+          env,
+          logger,
+          timeoutMs: APPIUM_STARTUP_TIMEOUT_MS,
+          launchAppIdentifier: launch.launchAppIdentifier,
+          launchArgs: launch.launchArgs,
+          openUrl: launch.openUrl,
+          networkCapture,
+          networkCaptureFields,
         });
+        const webPreview = await sessionHost.openPreviewAsync({ baseDomain: ngrokTunnelDomain });
 
         await uploadRemoteSessionConfigWithLocalEgressAsync({
           env,
@@ -307,15 +225,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,
@@ -325,19 +241,14 @@ export function createStartAppiumRemoteSessionBuildFunction(
               'Appium server',
               (async () => {
                 try {
-                  await eventCollection?.stopAsync();
+                  await eventCollection.stopAsync();
                 } finally {
-                  try {
-                    await appiumProcess?.stopAsync();
-                  } finally {
-                    if (appiumHome) {
-                      await fs.promises.rm(appiumHome, { recursive: true, force: true });
-                    }
-                  }
+                  await appiumProcess.stopAsync();
+                  await fs.promises.rm(appiumHome, { recursive: true, force: true });
                 }
               })(),
             ],
-            ['session host', hostStartup?.then(result => result.value?.finishAsync())],
+            ['session host', sessionHost?.finishAsync()],
           ],
         });
       }
@@ -367,12 +278,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 +323,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,16 +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,
   describeServeSimLaunch,
   ensureFfmpegInstalledOnceAsync,
@@ -49,9 +41,7 @@ import {
   getDeviceRunSessionIdOrThrow,
   getNgrokAuthtokenOrThrow,
   getNgrokTunnelDomainOrThrow,
-  omitNgrokAuthtoken,
-  parseCorsOriginsInput,
-  parseFrameAncestorsInput,
+  parseServeSimLaunchInputs,
   selectXcodeDeveloperDirectoryAsync,
   spawnDetached,
   startNgrokTunnelAsync,
@@ -93,12 +83,7 @@ export function createStartArgentRemoteSessionBuildFunction(
     __metricsId: 'eas/start_argent_remote_session',
     inputProviders: [
       ...createServeSimLaunchInputProviders(),
-      ...createIosSessionStartupInputProviders(),
       ...createNetworkCaptureInputProviders(),
-      createPublicPreviewInputProvider(),
-      createPrivatePreviewUrlInputProvider(),
-      createFrameAncestorsInputProvider(),
-      createCorsOriginsInputProvider(),
       BuildStepInput.createProvider({
         id: 'package_version',
         required: false,
@@ -115,15 +100,14 @@ export function createStartArgentRemoteSessionBuildFunction(
         allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
       }),
     ],
-    fn: withLocalEgressSession(async ({ logger, global }, { inputs, env: stepEnv, signal }) => {
+    fn: withLocalEgressSession(async ({ logger, global }, { inputs, env, signal }) => {
       // Fail fast before any expensive setup if the injected env
       // vars are missing: DEVICE_RUN_SESSION_ID (to report the remote config
       // back to the API server), EAS_SIMULATOR_NGROK_TUNNEL_DOMAIN (base domain
       // for our ngrok tunnels), and NGROK_AUTHTOKEN (to authenticate them).
-      const deviceRunSessionId = getDeviceRunSessionIdOrThrow(stepEnv);
-      const ngrokTunnelDomain = getNgrokTunnelDomainOrThrow(stepEnv);
-      const ngrokAuthtoken = getNgrokAuthtokenOrThrow(stepEnv);
-      const env = omitNgrokAuthtoken(stepEnv);
+      const deviceRunSessionId = getDeviceRunSessionIdOrThrow(env);
+      const ngrokTunnelDomain = getNgrokTunnelDomainOrThrow(env);
+      const ngrokAuthtoken = getNgrokAuthtokenOrThrow(env);
 
       const packageVersion = inputs.package_version.value as string | undefined;
       // A missing or non-positive value disables the idle timeout (opt-in feature).
@@ -132,21 +116,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 +135,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,171 +150,108 @@ 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 argentServer = spawnDetached({
+        command: startServer.command,
+        args: startServer.args,
+        env: { ...env, ARGENT_EVENT_LOG: ARGENT_EVENT_LOG_PATH, ARGENT_EMULATOR_NO_WINDOW: '1' },
+      });
+      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;
+      try {
+        const toolServerState = await waitForArgentToolServerStateAsync({
+          stateDir: ARGENT_STATE_DIR,
+          ancestorPid: argentServer.pid,
+          timeoutMs: STARTUP_TIMEOUT_MS,
+          getExitError: argentServer.getExitError,
+        });
+        toolServerPort = toolServerState.port;
+        toolServerToken = toolServerState.token;
+      } catch (err) {
+        const output = argentServer.getOutput();
+        throw new SystemError(
+          `${
+            err instanceof Error ? err.message : `Timed out waiting for argent tool-server state.`
+          }${output ? `\nArgent tool-server output:\n${output}` : ''}`
+        );
+      }
+      logger.info(`Argent tool-server is listening on port ${toolServerPort}.`);
       const artifactPollAbortController = new AbortController();
-      let artifactPollingPromise: Promise<void> | undefined;
-      let eventCollection: Awaited<ReturnType<typeof startArgentEventCollectionAsync>> | undefined;
+      const artifactPollSignal = signal
+        ? AbortSignal.any([signal, artifactPollAbortController.signal])
+        : artifactPollAbortController.signal;
+      const artifactPollingPromise = pollArgentArtifactsForUploadAsync(ctx, {
+        deviceRunSessionId,
+        toolsUrl: `http://127.0.0.1:${toolServerPort}`,
+        toolsAuthToken: toolServerToken,
+        logger,
+        signal: artifactPollSignal,
+      });
+
+      const eventCollection = await startArgentEventCollectionAsync({
+        ctx,
+        deviceRunSessionId,
+        eventLogPath: ARGENT_EVENT_LOG_PATH,
+        logger,
+      });
+
       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;
-        try {
-          const toolServerState = await waitForArgentToolServerStateAsync({
-            stateDir: ARGENT_STATE_DIR,
-            ancestorPid: argentServer.pid,
-            timeoutMs: STARTUP_TIMEOUT_MS,
-            getExitError: argentServer.getExitError,
-            signal: setupSignal,
-          });
-          toolServerPort = toolServerState.port;
-          toolServerToken = toolServerState.token;
-          if (toolServerToken) {
-            secrets.push(toolServerToken);
-          }
-        } catch (err) {
-          const output = argentServer.getOutput();
-          throw new SystemError(
-            `${
-              err instanceof Error ? err.message : `Timed out waiting for argent tool-server state.`
-            }${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])
-          : artifactPollAbortController.signal;
-        artifactPollingPromise = pollArgentArtifactsForUploadAsync(ctx, {
-          deviceRunSessionId,
-          toolsUrl: `http://127.0.0.1:${toolServerPort}`,
-          toolsAuthToken: toolServerToken,
-          logger,
-          signal: artifactPollSignal,
-        });
-
-        eventCollection = await startArgentEventCollectionAsync({
-          ctx,
-          deviceRunSessionId,
-          eventLogPath: ARGENT_EVENT_LOG_PATH,
-          logger,
-        });
-
         toolsTunnel = await startNgrokTunnelAsync({
           port: toolServerPort,
           subdomainPrefix: 'argent',
@@ -349,15 +267,20 @@ export function createStartArgentRemoteSessionBuildFunction(
         if (launchDescription) {
           logger.info(launchDescription);
         }
-        sessionHost ??= (await (hostStartup ??= asyncResult(startHost()))).enforceValue();
-        const webPreview = await sessionHost.openPreviewAsync({
-          baseDomain: ngrokTunnelDomain,
-          authtoken: ngrokAuthtoken,
+        sessionHost = await startDeviceSessionHostAsync(ctx, {
+          runtimePlatform,
+          env,
+          logger,
+          timeoutMs: STARTUP_TIMEOUT_MS,
+          launchAppIdentifier: launch.launchAppIdentifier,
+          launchArgs: launch.launchArgs,
+          openUrl: launch.openUrl,
+          networkCapture,
+          networkCaptureFields,
         });
+        const webPreview = await sessionHost.openPreviewAsync({ baseDomain: ngrokTunnelDomain });
         logger.info(
-          webPreview.sharePageUrl
-            ? `Web preview URL: ${webPreview.sharePageUrl} (server: ${webPreview.apiUrl}).`
-            : 'Private preview URL unavailable for this session.'
+          `Web preview URL: ${webPreview.previewPageUrl} (server: ${webPreview.apiUrl}).`
         );
 
         await uploadRemoteSessionConfigWithLocalEgressAsync({
@@ -386,15 +309,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,
@@ -404,13 +325,11 @@ export function createStartArgentRemoteSessionBuildFunction(
               'Argent tool-server',
               (async () => {
                 try {
-                  if (eventCollection) {
-                    await stopArgentEventCollectionSafelyAsync({
-                      eventCollection,
-                      deviceRunSessionId,
-                      logger,
-                    });
-                  }
+                  await stopArgentEventCollectionSafelyAsync({
+                    eventCollection,
+                    deviceRunSessionId,
+                    logger,
+                  });
                   artifactPollAbortController.abort();
                   try {
                     await artifactPollingPromise;
@@ -426,11 +345,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 +409,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 +431,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 +448,6 @@ export async function waitForArgentToolServerStateAsync({
   };
 
   while (Date.now() < deadline) {
-    signal?.throwIfAborted();
     throwIfExited();
     let matchingState: ArgentToolServerState | undefined;
     try {
@@ -583,19 +473,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/startLocalEgress.ts

@@ -25,7 +25,6 @@ import {
   findAvailablePortAsync,
   getNgrokAuthtokenOrThrow,
   getNgrokTunnelDomainOrThrow,
-  omitNgrokAuthtoken,
   startNgrokTunnelAsync,
 } from '../utils/remoteDeviceRunSession';
 
@@ -77,11 +76,11 @@ function awaitLocalEgressAcquisitionAsync<T>(
 
 /**
  * Points the device host's system HTTP(S) proxy at the EAS CLI's egress client.
- * Must run before iOS simulator startup: the simulator reads the system proxy
- * at boot. Startup supplies proxy variables for gRPC/libcurl and the guard that
- * refuses connections bypassing the proxy. Serve-sim-owned startup passes this
- * boot configuration to serve-sim.
- * On Linux it starts the Android emulator relay and fence instead; see
+ * Must run before `eas/start_ios_simulator`: the simulator reads the system proxy
+ * at boot. Once a simulator boots, `eas/start_ios_simulator` also sets proxy
+ * environment variables inside it for clients that read them (gRPC, libcurl)
+ * and installs the local egress guard, which refuses connections that ignore
+ * both. On Linux it starts the Android emulator relay and fence instead; see
  * androidLocalEgress.ts. The shared session cleanup releases the resources
  * started here when the session ends, with a job finalizer as a fallback.
  */
@@ -92,10 +91,9 @@ export function createStartLocalEgressBuildFunction(): BuildFunction {
     name: 'Start local egress',
     __metricsId: 'eas/start_local_egress',
     supportedRuntimePlatforms: [BuildRuntimePlatform.DARWIN, BuildRuntimePlatform.LINUX],
-    fn: async ({ logger, global }, { env: stepEnv, signal }) => {
-      const ngrokTunnelDomain = getNgrokTunnelDomainOrThrow(stepEnv);
-      const ngrokAuthtoken = getNgrokAuthtokenOrThrow(stepEnv);
-      const env = omitNgrokAuthtoken(stepEnv);
+    fn: async ({ logger, global }, { env, signal }) => {
+      const ngrokTunnelDomain = getNgrokTunnelDomainOrThrow(env);
+      const ngrokAuthtoken = getNgrokAuthtokenOrThrow(env);
       const isAndroid = global?.runtimePlatform === BuildRuntimePlatform.LINUX;
       let workDir: string | undefined;
       let server: DetachedProcessHandle | undefined;

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

@@ -7,7 +7,6 @@ import {
 
 import { CustomBuildContext } from '../../customBuildContext';
 import { startDeviceSessionHostAsync } from '../utils/deviceSessionHost';
-import { resolveIosSessionStartupAsync } from '../utils/iosSimulatorSession';
 import {
   createNetworkCaptureInputProviders,
   parseNetworkCaptureInputs,
@@ -17,19 +16,11 @@ import {
   withLocalEgressSession,
 } from '../utils/localEgressSession';
 import {
-  createCorsOriginsInputProvider,
-  createFrameAncestorsInputProvider,
-  createIosSessionStartupInputProviders,
-  createPrivatePreviewUrlInputProvider,
-  createPublicPreviewInputProvider,
   createServeSimLaunchInputProviders,
   describeServeSimLaunch,
   getDeviceRunSessionIdOrThrow,
-  getNgrokAuthtokenOrThrow,
   getNgrokTunnelDomainOrThrow,
-  omitNgrokAuthtoken,
-  parseCorsOriginsInput,
-  parseFrameAncestorsInput,
+  parseServeSimLaunchInputs,
   selectXcodeDeveloperDirectoryAsync,
   waitForDeviceRunSessionStoppedAsync,
 } from '../utils/remoteDeviceRunSession';
@@ -46,12 +37,7 @@ export function createStartWebPreviewRemoteSessionBuildFunction(
     __metricsId: 'eas/start_serve_sim_remote_session',
     inputProviders: [
       ...createServeSimLaunchInputProviders(),
-      ...createIosSessionStartupInputProviders(),
       ...createNetworkCaptureInputProviders(),
-      createPublicPreviewInputProvider(),
-      createPrivatePreviewUrlInputProvider(),
-      createFrameAncestorsInputProvider(),
-      createCorsOriginsInputProvider(),
       BuildStepInput.createProvider({
         id: 'package_version',
         required: false,
@@ -63,29 +49,20 @@ export function createStartWebPreviewRemoteSessionBuildFunction(
         allowedValueTypeName: BuildStepInputValueTypeName.NUMBER,
       }),
     ],
-    fn: withLocalEgressSession(async ({ logger, global }, { inputs, env: stepEnv, signal }) => {
-      const deviceRunSessionId = getDeviceRunSessionIdOrThrow(stepEnv);
-      const ngrokTunnelDomain = getNgrokTunnelDomainOrThrow(stepEnv);
-      const ngrokAuthtoken = getNgrokAuthtokenOrThrow(stepEnv);
-      const env = omitNgrokAuthtoken(stepEnv);
+    fn: withLocalEgressSession(async ({ logger, global }, { inputs, env, signal }) => {
+      const deviceRunSessionId = getDeviceRunSessionIdOrThrow(env);
+      const ngrokTunnelDomain = getNgrokTunnelDomainOrThrow(env);
       const maxDurationSeconds = inputs.max_duration_seconds?.value as number | undefined;
       const packageVersion = inputs.package_version?.value as string | 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 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,
@@ -100,18 +77,16 @@ export function createStartWebPreviewRemoteSessionBuildFunction(
         logger.info(launchDescription);
       }
 
+      if (runtimePlatform === BuildRuntimePlatform.DARWIN) {
+        await selectXcodeDeveloperDirectoryAsync({ env, logger });
+      }
+
       const sessionHost = await startDeviceSessionHostAsync(ctx, {
-        ...iosStartup,
         runtimePlatform,
         env,
         logger,
         timeoutMs: STARTUP_TIMEOUT_MS,
-        signal,
         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,
@@ -120,15 +95,8 @@ export function createStartWebPreviewRemoteSessionBuildFunction(
       });
 
       try {
-        const webPreview = await sessionHost.openPreviewAsync({
-          baseDomain: ngrokTunnelDomain,
-          authtoken: ngrokAuthtoken,
-        });
-        logger.info(
-          webPreview.sharePageUrl
-            ? `Preview URL: ${webPreview.sharePageUrl} (server: ${webPreview.apiUrl}).`
-            : 'Private preview URL unavailable for this session.'
-        );
+        const webPreview = await sessionHost.openPreviewAsync({ baseDomain: ngrokTunnelDomain });
+        logger.info(`Preview URL: ${webPreview.previewPageUrl} (server: ${webPreview.apiUrl}).`);
         await uploadRemoteSessionConfigWithLocalEgressAsync({
           env,
           signal,

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

@@ -131,7 +131,7 @@ export function createSubmitToGooglePlayBuildFunction(): BuildFunction {
         keyPath: path.resolve(ctx.workingDirectory, submission.service_account_key_path),
       });
       const artifactPath = path.resolve(ctx.workingDirectory, submission.artifact_path);
-      const client = new GooglePlayClient(credentials, ctx.logger);
+      const client = new GooglePlayClient(credentials);
       const versionCode = await submitToGooglePlayAsync({
         artifactType: submission.artifact_type,
         client,
@@ -185,19 +185,7 @@ async function submitToGooglePlayAsync({
       `Submitting ${packageName} (${artifactType}) to track ${JSON.stringify(submission.track)}.`
     );
     logger.info(
-      `Release status: ${release.status}. Rollout: ${release.userFraction === undefined ? 'none' : new Intl.NumberFormat('en-US', { style: 'percent', maximumSignificantDigits: 15 }).format(release.userFraction)}.`
-    );
-    if (submission.release_status !== release.status) {
-      logger.info(
-        release.status === 'completed'
-          ? 'A 100% rollout is submitted as a completed release.'
-          : 'A partial rollout is submitted as an in-progress release.'
-      );
-    }
-    logger.info(
-      submission.changes_not_sent_for_review
-        ? 'Save changes without sending them for review.'
-        : 'Send changes for review.'
+      `Requested status: ${submission.release_status}; rollout: ${submission.rollout ?? 'none'}. Effective status: ${release.status}; rollout: ${release.userFraction ?? 'none'}. changes_not_sent_for_review: ${submission.changes_not_sent_for_review}.`
     );
     if (submission.changelog) {
       logger.info(`Changelog (en-US): ${JSON.stringify(submission.changelog)}`);
@@ -228,8 +216,7 @@ async function submitToGooglePlayAsync({
       changelog: submission.changelog ? { locale: 'en-US', text: submission.changelog } : undefined,
       signal,
     });
-    logger.info(`Updated Google Play track ${JSON.stringify(submission.track)} in the edit.`);
-    logger.info('Committing the Google Play edit...');
+    logger.info('Updated Google Play track ' + JSON.stringify(submission.track) + ' in the edit.');
     // Commit also validates the edit.
     await GooglePlayUtils.commitEditAsync(client, {
       packageName,
@@ -245,7 +232,7 @@ async function submitToGooglePlayAsync({
     return versionCode;
   } catch (error) {
     commitOutcomeUnknown = error instanceof GooglePlayCommitOutcomeUnknownError;
-    throw GooglePlayUtils.mapGooglePlayError(error, submission.package_name);
+    throw GooglePlayUtils.mapGooglePlayError(error);
   } finally {
     if (editId && !committed && !commitOutcomeUnknown) {
       try {
@@ -256,7 +243,7 @@ async function submitToGooglePlayAsync({
         });
       } catch {
         logger.warn(
-          'Could not discard the pending Google Play changes. Check the release in Play Console before submitting again.'
+          'Could not delete the Google Play edit after failure. The original submission error is preserved.'
         );
       }
     }

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__/agentRun.test.ts

@@ -140,7 +140,6 @@ function createOptions(
     pathEnv: '/usr/local/bin:/usr/bin',
     npmCacheUrl: 'https://npm-cache.expo.test',
     logger: createMockLogger(),
-    addBuildLogMask: jest.fn(),
     signal: new AbortController().signal,
     ...overrides,
   };
@@ -221,22 +220,23 @@ describe(runAgentAsync, () => {
     expect(agent.stdin).toHaveBeenCalledWith('Fix the failing test.');
   });
 
-  it('writes the agent output as log lines', async () => {
+  it('writes the agent output as log lines with the leased credentials masked', async () => {
     leaseMock.mockResolvedValue(anthropicLease);
     const logger = createMockLogger();
     mockSpawn({
       onAgent: agent => {
-        const toolResultEvent =
-          '{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"toolu_1","content":"3 tests passed"}]}}\n';
-        agent.child.stdout.write(toolResultEvent.slice(0, 40));
-        agent.child.stdout.write(toolResultEvent.slice(40));
+        // One JSON event split across two chunks, in the middle of the token.
         agent.child.stdout.write(
-          '{"type":"assistant","message":{"content":[{"type":"text","text":"Done.\\nThe tests pass.\\n"}]}}\n'
+          '{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"toolu_1","content":"token: anthropic-acc'
+        );
+        agent.child.stdout.write('ess-token"}]}}\n');
+        agent.child.stdout.write(
+          '{"type":"assistant","message":{"content":[{"type":"text","text":"Done.\\nThe token was anthropic-access-token.\\n"}]}}\n'
         );
         agent.child.stdout.write(
           '{"type":"result","subtype":"error_during_execution","is_error":true,"errors":["boom"]}\n'
         );
-        agent.child.stderr.write('warning: deprecated flag\n');
+        agent.child.stderr.write('warning: anthropic-access-token\n');
         agent.exit(0);
       },
     });
@@ -247,54 +247,11 @@ describe(runAgentAsync, () => {
     expect(child.mock.calls).toEqual([[{ source: 'stdout' }], [{ source: 'stderr' }]]);
     const [stdoutLogger, stderrLogger] = child.mock.results.map(result => result.value);
     expect(stdoutLogger.info.mock.calls).toEqual([
-      ['Tool result: 3 tests passed'],
-      ['Agent: Done.\nThe tests pass.'],
+      ['Tool result: token: [redacted]'],
+      ['Agent: Done.\nThe token was [redacted].'],
     ]);
     expect(stdoutLogger.error.mock.calls).toEqual([['Agent failed: boom']]);
-    expect(stderrLogger.info.mock.calls).toEqual([['warning: deprecated flag']]);
-  });
-
-  it.each([
-    ['claude-code', anthropicLease, ['anthropic-access-token']],
-    ['codex', openaiLease, ['openai-access-token', 'openai-id-token']],
-  ] as const)(
-    'registers the credentials leased for %s with the build log secrets filter before starting the agent',
-    async (agentKind, lease, secrets) => {
-      leaseMock.mockResolvedValue(lease);
-      const addBuildLogMask = jest.fn();
-      const invocations = mockSpawn({
-        onAgent: agent => {
-          expect(addBuildLogMask.mock.calls).toEqual(secrets.map(secret => [secret]));
-          agent.exit(0);
-        },
-      });
-
-      await runAgentAsync(createOptions({ agentKind, addBuildLogMask }));
-
-      expect(invocations).toHaveLength(1);
-    }
-  );
-
-  it('registers renewed credentials before resuming the agent', async () => {
-    leaseMock
-      .mockResolvedValueOnce(anthropicLease)
-      .mockResolvedValueOnce({ ...anthropicLease, accessToken: 'renewed-access-token' });
-    const addBuildLogMask = jest.fn();
-    const invocations = mockSpawn({
-      onAgent: agent => {
-        if (invocations.length === 2) {
-          expect(addBuildLogMask.mock.calls).toEqual([
-            ['anthropic-access-token'],
-            ['renewed-access-token'],
-          ]);
-        }
-        agent.exit(invocations.length === 1 ? 1 : 0);
-      },
-    });
-
-    await runAgentAsync(createOptions({ addBuildLogMask }));
-
-    expect(invocations).toHaveLength(2);
+    expect(stderrLogger.info.mock.calls).toEqual([['warning: [redacted]']]);
   });
 
   it('reports a line the formatter cannot handle instead of ending the run', async () => {
@@ -470,7 +427,12 @@ describe(runAgentAsync, () => {
     leaseMock.mockResolvedValueOnce(anthropicLease).mockResolvedValueOnce(renewedLease);
     const logger = createMockLogger();
     const invocations = mockSpawn({
-      onAgent: agent => agent.exit(invocations.length === 1 ? 1 : 0),
+      onAgent: agent => {
+        if (invocations.length === 2) {
+          agent.child.stderr.write('tokens: anthropic-access-token renewed-access-token\n');
+        }
+        agent.exit(invocations.length === 1 ? 1 : 0);
+      },
     });
 
     await runAgentAsync(createOptions({ logger }));
@@ -490,6 +452,8 @@ describe(runAgentAsync, () => {
       [{ source: 'stdout' }],
       [{ source: 'stderr' }],
     ]);
+    const [, , , resumedStderrLogger] = child.mock.results.map(result => result.value);
+    expect(resumedStderrLogger.info.mock.calls).toEqual([['tokens: [redacted] [redacted]']]);
   });
 
   it('resumes Codex with new credentials when the lease changed during the run', async () => {

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__/deviceRunSessionScreenshotNames.test.ts

@@ -45,38 +45,3 @@ it('accepts a full SHA-256 commit hash', () => {
   expect(result.filename).toBe(`my-app-ios-bbbbbbb-${timestamp}.png`);
   expect(result.metadata.gitCommitHash).toBe(gitCommitHash);
 });
-
-describe('without an app slug (device run session worker API)', () => {
-  const sessionWithoutSlug = {
-    platform: 'IOS' as const,
-    app: null,
-    build: { id: 'installed-build', gitCommitHash, app: null },
-  };
-
-  it('starts the filename with the platform and omits appSlug from the metadata', () => {
-    expect(screenshotArtifactDetails(timestamp, sessionWithoutSlug)).toEqual({
-      name,
-      filename: `ios-a1b2c3d-${timestamp}.png`,
-      metadata: {
-        __eas_type: 'screenshot',
-        platform: 'ios',
-        buildId: 'installed-build',
-        gitCommitHash,
-      },
-    });
-  });
-
-  it('omits the commit when the session has no build', () => {
-    expect(
-      screenshotArtifactDetails(timestamp, {
-        ...sessionWithoutSlug,
-        platform: 'ANDROID',
-        build: null,
-      })
-    ).toEqual({
-      name,
-      filename: `android-${timestamp}.png`,
-      metadata: { __eas_type: 'screenshot', platform: 'android' },
-    });
-  });
-});

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__/deviceRunSessionTokenPropagation.test.ts

@@ -1,115 +0,0 @@
-import { EnvironmentSecretType, Generic } from '@expo/eas-build-job';
-import { BuildStepGlobalContext } from '@expo/steps';
-
-import { createMockLogger } from '../../../__tests__/utils/logger';
-import { BuildContext } from '../../../context';
-import { CustomBuildContext } from '../../../customBuildContext';
-import { turtleFetch } from '../../../utils/turtleFetch';
-import {
-  DEVICE_RUN_SESSION_TOKEN_ENV,
-  DEVICE_RUN_SESSION_TOKEN_HEADER,
-  getDeviceRunSessionTokenFromEnvironmentSecrets,
-  getDeviceRunSessionWorkerApi,
-} from '../deviceRunSessionWorkerApi';
-
-jest.mock('../../../utils/turtleFetch');
-
-const { Response } = jest.requireActual('node-fetch') as typeof import('node-fetch');
-
-const API_V2_BASE_URL = 'https://api.expo.test/v2/';
-
-function createSessionJob(
-  environmentSecrets: { name: string; type: EnvironmentSecretType; value: string }[]
-): Generic.Job {
-  return {
-    triggeredBy: 'GIT_BASED_INTEGRATION',
-    steps: [],
-    secrets: { robotAccessToken: 'robot-access-token', environmentSecrets },
-    builderEnvironment: { env: { DEVICE_RUN_SESSION_ID: 'drs-id' } },
-  } as unknown as Generic.Job;
-}
-
-function createCustomBuildContext(job: Generic.Job): CustomBuildContext<Generic.Job> {
-  const buildCtx = new BuildContext(job, {
-    env: { __API_SERVER_URL: 'https://api.expo.test' },
-    logBuffer: { getLogs: () => [], getPhaseLogs: () => [] },
-    logger: createMockLogger(),
-    uploadArtifact: jest.fn(),
-    workingdir: '',
-    expoApiV2BaseUrl: API_V2_BASE_URL,
-  });
-  return new CustomBuildContext(buildCtx);
-}
-
-async function getSentTokenAsync(ctx: CustomBuildContext): Promise<string | undefined> {
-  jest.mocked(turtleFetch).mockResolvedValueOnce(
-    new Response(JSON.stringify({ data: { id: 'drs-id', status: 'in-progress' } }), {
-      status: 200,
-    })
-  );
-  await getDeviceRunSessionWorkerApi(ctx)!.getSessionAsync();
-  const [url, , options] = jest.mocked(turtleFetch).mock.calls[0];
-  expect(url).toBe(`${API_V2_BASE_URL}device-run-session-worker/session`);
-  return (options.headers as Record<string, string>)[DEVICE_RUN_SESSION_TOKEN_HEADER];
-}
-
-describe('device run session token propagation', () => {
-  beforeEach(() => {
-    jest.mocked(turtleFetch).mockReset();
-  });
-
-  it('makes the environment secret reach the worker API client and the step env', async () => {
-    const job = createSessionJob([
-      { name: 'NGROK_AUTHTOKEN', type: EnvironmentSecretType.STRING, value: 'ngrok' },
-      { name: DEVICE_RUN_SESSION_TOKEN_ENV, type: EnvironmentSecretType.STRING, value: 'token-a' },
-    ]);
-    const ctx = createCustomBuildContext(job);
-
-    expect(new BuildStepGlobalContext(ctx, false).env[DEVICE_RUN_SESSION_TOKEN_ENV]).toBe(
-      'token-a'
-    );
-    await expect(getSentTokenAsync(ctx)).resolves.toBe('token-a');
-  });
-
-  it('resolves duplicate secrets to the same token in the build env and the worker', async () => {
-    const environmentSecrets = [
-      { name: DEVICE_RUN_SESSION_TOKEN_ENV, type: EnvironmentSecretType.STRING, value: 'token-a' },
-      { name: DEVICE_RUN_SESSION_TOKEN_ENV, type: EnvironmentSecretType.STRING, value: 'token-b' },
-    ];
-    const ctx = createCustomBuildContext(createSessionJob(environmentSecrets));
-
-    const workerToken = getDeviceRunSessionTokenFromEnvironmentSecrets(environmentSecrets);
-    expect(workerToken).toBe('token-b');
-    await expect(getSentTokenAsync(ctx)).resolves.toBe(workerToken);
-  });
-
-  it('returns no client when the job has no session token', () => {
-    const ctx = createCustomBuildContext(
-      createSessionJob([
-        { name: 'NGROK_AUTHTOKEN', type: EnvironmentSecretType.STRING, value: 'ngrok' },
-      ])
-    );
-
-    expect(getDeviceRunSessionWorkerApi(ctx)).toBeNull();
-  });
-});
-
-describe(getDeviceRunSessionTokenFromEnvironmentSecrets, () => {
-  it('returns null without secrets or without the token', () => {
-    expect(getDeviceRunSessionTokenFromEnvironmentSecrets(undefined)).toBeNull();
-    expect(
-      getDeviceRunSessionTokenFromEnvironmentSecrets([
-        { name: 'OTHER', type: EnvironmentSecretType.STRING, value: 'x' },
-      ])
-    ).toBeNull();
-  });
-
-  it('returns null when the last secret with the name is a file secret', () => {
-    expect(
-      getDeviceRunSessionTokenFromEnvironmentSecrets([
-        { name: DEVICE_RUN_SESSION_TOKEN_ENV, type: EnvironmentSecretType.STRING, value: 'a' },
-        { name: DEVICE_RUN_SESSION_TOKEN_ENV, type: EnvironmentSecretType.FILE, value: 'Yg==' },
-      ])
-    ).toBeNull();
-  });
-});

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,540 +0,0 @@
-import { SystemError } from '@expo/eas-build-job';
-import { FetchError } from 'node-fetch';
-
-import { CustomBuildContext } from '../../../customBuildContext';
-import { turtleFetch } from '../../../utils/turtleFetch';
-import {
-  DEVICE_RUN_SESSION_TOKEN_HEADER,
-  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>;
-
-const BASE_URL = 'https://api.expo.test/v2/';
-const TOKEN = 'device-run-session-token-value';
-
-function jsonResponse(body: unknown, status = 200): Response {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { 'Content-Type': 'application/json' },
-  });
-}
-
-function createApi(): DeviceRunSessionWorkerApi {
-  return new DeviceRunSessionWorkerApi(BASE_URL, TOKEN);
-}
-
-describe(getDeviceRunSessionWorkerApi, () => {
-  it('returns null when the job has no device run session token', () => {
-    expect(
-      getDeviceRunSessionWorkerApi({
-        env: { __API_SERVER_URL: 'https://api.expo.test' },
-        expoApiV2BaseUrl: BASE_URL,
-      } as unknown as CustomBuildContext)
-    ).toBeNull();
-    expect(
-      getDeviceRunSessionWorkerApi({
-        env: { EAS_DEVICE_RUN_SESSION_TOKEN: '' },
-        expoApiV2BaseUrl: BASE_URL,
-      } as unknown as CustomBuildContext)
-    ).toBeNull();
-  });
-
-  it('uses the API v2 base URL of the context', async () => {
-    jest
-      .mocked(turtleFetch)
-      .mockResolvedValueOnce(jsonResponse({ data: { id: 'drs-id', status: 'in-progress' } }));
-    const api = getDeviceRunSessionWorkerApi({
-      env: { EAS_DEVICE_RUN_SESSION_TOKEN: TOKEN, __API_SERVER_URL: 'https://other.expo.test' },
-      expoApiV2BaseUrl: BASE_URL,
-    } as unknown as CustomBuildContext);
-
-    await api!.getSessionAsync();
-
-    expect(jest.mocked(turtleFetch)).toHaveBeenCalledWith(
-      'https://api.expo.test/v2/device-run-session-worker/session',
-      'GET',
-      expect.anything()
-    );
-  });
-
-  it('derives the API v2 base URL from __API_SERVER_URL when the context has none', async () => {
-    jest
-      .mocked(turtleFetch)
-      .mockResolvedValueOnce(jsonResponse({ data: { id: 'drs-id', status: 'in-progress' } }));
-    const api = getDeviceRunSessionWorkerApi({
-      env: { EAS_DEVICE_RUN_SESSION_TOKEN: TOKEN, __API_SERVER_URL: 'https://api.expo.test' },
-    } as unknown as CustomBuildContext);
-
-    await api!.getSessionAsync();
-
-    expect(jest.mocked(turtleFetch)).toHaveBeenCalledWith(
-      'https://api.expo.test/v2/device-run-session-worker/session',
-      'GET',
-      expect.anything()
-    );
-  });
-
-  it('throws a system error when the token is set but no API URL is known', () => {
-    expect(() =>
-      getDeviceRunSessionWorkerApi({
-        env: { EAS_DEVICE_RUN_SESSION_TOKEN: TOKEN },
-      } as unknown as CustomBuildContext)
-    ).toThrow(SystemError);
-  });
-});
-
-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();
-  });
-
-  it.each([
-    {
-      name: 'getSessionAsync',
-      call: (api: DeviceRunSessionWorkerApi) => api.getSessionAsync(),
-      method: 'GET',
-      route: 'session',
-      json: undefined,
-      data: { id: 'drs-id', status: 'in-progress' },
-      expected: { id: 'drs-id', status: 'in-progress' },
-    },
-    {
-      name: 'startAsync',
-      call: (api: DeviceRunSessionWorkerApi) =>
-        api.startAsync({ remoteConfig: { type: 'agent-device', url: 'https://x.test' } }),
-      method: 'POST',
-      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' },
-    },
-    {
-      name: 'stopAsync',
-      call: (api: DeviceRunSessionWorkerApi) => api.stopAsync(),
-      method: 'POST',
-      route: 'stop',
-      json: undefined,
-      data: { id: 'drs-id', status: 'stopped' },
-      expected: { id: 'drs-id', status: 'stopped' },
-    },
-    {
-      name: 'createArtifactUploadSessionAsync',
-      call: (api: DeviceRunSessionWorkerApi) =>
-        api.createArtifactUploadSessionAsync({
-          name: 'Screenshot',
-          filename: 'screenshot.png',
-          kind: 'screenshot',
-          size: 12,
-          metadata: { __eas_type: 'screenshot' },
-        }),
-      method: 'POST',
-      route: 'artifact-upload-sessions',
-      json: {
-        name: 'Screenshot',
-        filename: 'screenshot.png',
-        kind: 'screenshot',
-        size: 12,
-        metadata: { __eas_type: 'screenshot' },
-      },
-      data: { uploadSession: { url: 'https://uploads.test/a', headers: { 'X-A': '1' } } },
-      expected: { url: 'https://uploads.test/a', headers: { 'X-A': '1' } },
-    },
-    {
-      name: 'createEventLogUploadSessionAsync',
-      call: (api: DeviceRunSessionWorkerApi) => api.createEventLogUploadSessionAsync(),
-      method: 'POST',
-      route: 'event-log-upload-session',
-      json: undefined,
-      data: { uploadSession: { url: 'https://uploads.test/events', headers: {} } },
-      expected: { url: 'https://uploads.test/events', headers: {} },
-    },
-    {
-      name: 'createPreviewUploadSessionAsync',
-      call: (api: DeviceRunSessionWorkerApi) => api.createPreviewUploadSessionAsync(),
-      method: 'POST',
-      route: 'preview-upload-session',
-      json: undefined,
-      data: { uploadSession: { url: 'https://uploads.test/preview', headers: {} } },
-      expected: { url: 'https://uploads.test/preview', headers: {} },
-    },
-    {
-      name: 'fetchTurnIceServersAsync',
-      call: (api: DeviceRunSessionWorkerApi) => api.fetchTurnIceServersAsync(),
-      method: 'POST',
-      route: 'turn-ice-servers',
-      json: undefined,
-      data: {
-        iceServers: [
-          { urls: ['stun:stun.test:3478'] },
-          { urls: ['turn:turn.test:3478'], username: 'user', credential: 'secret' },
-        ],
-      },
-      expected: [
-        { urls: ['stun:stun.test:3478'] },
-        { urls: ['turn:turn.test:3478'], username: 'user', credential: 'secret' },
-      ],
-    },
-    {
-      name: 'getApplicationAsync',
-      call: (api: DeviceRunSessionWorkerApi) => api.getApplicationAsync(),
-      method: 'GET',
-      route: 'application',
-      json: undefined,
-      data: {
-        build: {
-          id: 'build-id',
-          gitCommitHash: null,
-          applicationArchiveUrl: 'https://expo.test/artifacts/eas/a.tar.gz',
-        },
-      },
-      expected: {
-        build: {
-          id: 'build-id',
-          gitCommitHash: null,
-          applicationArchiveUrl: 'https://expo.test/artifacts/eas/a.tar.gz',
-        },
-      },
-    },
-  ])(
-    '$name calls $method /v2/device-run-session-worker/$route with the session token header',
-    async ({ call, method, route, json, data, expected }) => {
-      jest.mocked(turtleFetch).mockResolvedValueOnce(jsonResponse({ data }));
-
-      await expect(call(createApi())).resolves.toEqual(expected);
-
-      expect(jest.mocked(turtleFetch)).toHaveBeenCalledTimes(1);
-      const [url, calledMethod, options] = jest.mocked(turtleFetch).mock.calls[0];
-      expect(url).toBe(`https://api.expo.test/v2/device-run-session-worker/${route}`);
-      expect(calledMethod).toBe(method);
-      expect(options.headers).toEqual({ [DEVICE_RUN_SESSION_TOKEN_HEADER]: TOKEN });
-      expect(options.json).toEqual(json);
-      expect(options).toEqual(expect.objectContaining({ retries: 0, shouldThrowOnNotOk: false }));
-    }
-  );
-
-  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 } }));
-
-      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(
-      'GET /v2/device-run-session-worker/application returned an unexpected response'
-    );
-  });
-
-  it('passes the signal and timeout without enabling nested retries', async () => {
-    jest.mocked(turtleFetch).mockResolvedValueOnce(jsonResponse({ data: { iceServers: [] } }));
-    const controller = new AbortController();
-
-    await createApi().fetchTurnIceServersAsync({
-      signal: controller.signal,
-      timeoutMs: 5000,
-      retries: 1,
-    });
-
-    expect(jest.mocked(turtleFetch)).toHaveBeenCalledWith(
-      expect.any(String),
-      'POST',
-      expect.objectContaining({ signal: controller.signal, timeout: 5000, retries: 0 })
-    );
-  });
-
-  it('reports the API v2 error message and status without the token', async () => {
-    jest.mocked(turtleFetch).mockResolvedValueOnce(
-      jsonResponse(
-        {
-          errors: [
-            {
-              code: 'UNAUTHORIZED_ERROR',
-              message: 'This device run session no longer accepts worker requests.',
-            },
-          ],
-        },
-        403
-      )
-    );
-
-    const error = await createApi()
-      .stopAsync()
-      .catch(err => err);
-
-    expect(error).toBeInstanceOf(DeviceRunSessionWorkerApiError);
-    expect(error.status).toBe(403);
-    expect(error.message).toBe(
-      'POST /v2/device-run-session-worker/stop failed with status 403: This device run session no longer accepts worker requests.'
-    );
-    expect(error.message).not.toContain(TOKEN);
-  });
-
-  it('reports the status text when the error response is not an API v2 error', async () => {
-    jest
-      .mocked(turtleFetch)
-      .mockResolvedValueOnce(
-        new Response('<html>bad gateway</html>', { status: 502, statusText: 'Bad Gateway' })
-      );
-
-    const error = await createApi()
-      .getSessionAsync({ retries: 0 })
-      .catch(err => err);
-
-    expect(error).toBeInstanceOf(DeviceRunSessionWorkerApiError);
-    expect(error.status).toBe(502);
-    expect(error.message).toBe(
-      'GET /v2/device-run-session-worker/session failed with status 502: Bad Gateway'
-    );
-  });
-
-  it('reports a request that failed before www responded', async () => {
-    const reason = new Error('socket hang up');
-    jest.mocked(turtleFetch).mockRejectedValueOnce(reason);
-
-    const error = await createApi()
-      .getSessionAsync({ retries: 0 })
-      .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');
-  });
-
-  it('rejects a response that does not match the route contract', async () => {
-    jest
-      .mocked(turtleFetch)
-      .mockResolvedValueOnce(jsonResponse({ data: { id: 'drs-id', status: 'STOPPED' } }));
-
-    await expect(createApi().getSessionAsync({ retries: 3 })).rejects.toThrow(
-      'GET /v2/device-run-session-worker/session returned an unexpected response'
-    );
-  });
-
-  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(
-      '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,601 +0,0 @@
-import { SystemError } from '@expo/eas-build-job';
-import { type bunyan } from '@expo/logger';
-import { BuildRuntimePlatform } from '@expo/steps';
-import fetch from 'node-fetch';
-import { Readable } from 'node:stream';
-import { setImmediate } from 'node:timers/promises';
-
-import { type CustomBuildContext } from '../../../customBuildContext';
-import RemoteLoggerStream from '../../../logging/RemoteLoggerStream';
-import { turtleFetch } from '../../../utils/turtleFetch';
-import { downloadBuildAsync } from '../../functions/downloadBuild';
-import { uploadDeviceRunSessionArtifactAsync } from '../deviceRunSessionArtifacts';
-import { startDeviceRunSessionEventCollectionAsync } from '../deviceRunSessionEvents';
-import { startDeviceRunSessionPreview } from '../deviceRunSessionPreview';
-import { loadScreenshotSessionAsync } from '../deviceRunSessionScreenshotNames';
-import {
-  DEVICE_RUN_SESSION_TOKEN_HEADER,
-  DeviceRunSessionWorkerApi,
-} from '../deviceRunSessionWorkerApi';
-import {
-  fetchWebPreviewTurnArgsAsync,
-  uploadRemoteSessionConfigAsync,
-  waitForDeviceRunSessionStoppedAsync,
-} from '../remoteDeviceRunSession';
-
-jest.mock('node-fetch');
-jest.mock('@ngrok/ngrok');
-jest.mock('@expo/turtle-spawn');
-jest.mock('../../../utils/turtleFetch');
-jest.mock('../../../sentry');
-jest.mock('../../../logging/HttpLogStream', () => ({
-  __esModule: true,
-  default: jest.fn(() => ({ write: jest.fn(), cleanUp: jest.fn(async () => undefined) })),
-}));
-jest.mock('../../../logging/RemoteLoggerStream', () => ({
-  __esModule: true,
-  default: jest.fn(() => ({
-    init: jest.fn(async () => undefined),
-    write: jest.fn(),
-    cleanUp: jest.fn(async () => undefined),
-  })),
-}));
-
-const { Response } = jest.requireActual('node-fetch') as typeof import('node-fetch');
-
-const TOKEN = 'device-run-session-token-value';
-const ROBOT_ACCESS_TOKEN = 'robot-access-token-value';
-const API_V2_BASE_URL = 'https://api.expo.test/v2/';
-const BUILD_ID = '0a8b5f3c-7c38-4a2f-9c0c-2a1f0e7d8b11';
-const APPLICATION_ARCHIVE_URL = 'https://expo.test/artifacts/eas/app.tar.gz';
-
-const logger = {
-  info: jest.fn(),
-  warn: jest.fn(),
-  error: jest.fn(),
-  debug: jest.fn(),
-  child: jest.fn(),
-} as unknown as bunyan;
-
-function jsonResponse(body: unknown, status = 200): InstanceType<typeof Response> {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: { 'Content-Type': 'application/json' },
-  });
-}
-
-function createCtx({ withToken }: { withToken: boolean }): CustomBuildContext {
-  return {
-    env: {
-      __API_SERVER_URL: 'https://api.expo.test',
-      EAS_BUILD_ID: 'job-run-id',
-      ...(withToken ? { EAS_DEVICE_RUN_SESSION_TOKEN: TOKEN } : {}),
-    },
-    expoApiV2BaseUrl: API_V2_BASE_URL,
-    job: { secrets: { robotAccessToken: ROBOT_ACCESS_TOKEN } },
-    graphqlClient: {
-      query: jest.fn(),
-      mutation: jest.fn(),
-    },
-  } as unknown as CustomBuildContext;
-}
-
-function graphqlResult(data: unknown): { toPromise: () => Promise<{ data: unknown }> } {
-  return { toPromise: async () => ({ data }) };
-}
-
-function expectWorkerApiCall(
-  route: string,
-  method: 'GET' | 'POST',
-  options: Record<string, unknown> = {}
-): void {
-  expect(jest.mocked(turtleFetch)).toHaveBeenCalledWith(
-    `${API_V2_BASE_URL}device-run-session-worker/${route}`,
-    method,
-    expect.objectContaining({
-      headers: { [DEVICE_RUN_SESSION_TOKEN_HEADER]: TOKEN },
-      ...options,
-    })
-  );
-}
-
-async function waitForCallAsync(mock: jest.Mock): Promise<void> {
-  for (let i = 0; i < 100 && mock.mock.calls.length === 0; i++) {
-    await setImmediate();
-  }
-}
-
-const eventSource = {
-  producer: 'test-producer',
-  findEventFilesAsync: async () => [],
-  sourceKeyForFile: () => 'source',
-  parseLine: () => ({}),
-};
-
-beforeEach(() => {
-  jest.mocked(turtleFetch).mockReset();
-  jest.mocked(fetch).mockReset();
-});
-
-describe('with a device run session token', () => {
-  it('polls the session status through the worker API', async () => {
-    const ctx = createCtx({ withToken: true });
-    jest
-      .mocked(turtleFetch)
-      .mockResolvedValueOnce(jsonResponse({ data: { id: 'drs-id', status: 'stopped' } }));
-
-    await waitForDeviceRunSessionStoppedAsync({ ctx, deviceRunSessionId: 'drs-id', logger });
-
-    expectWorkerApiCall('session', 'GET', {
-      retries: 0,
-      timeout: 30_000,
-      signal: expect.any(AbortSignal),
-    });
-    expect(ctx.graphqlClient.query).not.toHaveBeenCalled();
-  });
-
-  it('stops an idle session through the worker API', async () => {
-    const ctx = createCtx({ withToken: true });
-    jest
-      .mocked(turtleFetch)
-      .mockResolvedValueOnce(jsonResponse({ data: { id: 'drs-id', status: 'stopped' } }));
-
-    await waitForDeviceRunSessionStoppedAsync({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      logger,
-      idleTimeout: { maxIdleTimeMinutes: 0, getLastEventObservedAt: () => undefined },
-    });
-
-    expectWorkerApiCall('stop', 'POST', { timeout: 30_000 });
-    expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
-  });
-
-  it('retries a transient failure when starting 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({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      remoteConfig: { type: 'agent-device' },
-      logger,
-    });
-
-    expectWorkerApiCall('start', 'POST', { json: { remoteConfig: { type: 'agent-device' } } });
-    expect(turtleFetch).toHaveBeenCalledTimes(2);
-    expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
-  });
-
-  it('fails the start with a system error that does not contain the token', async () => {
-    const ctx = createCtx({ withToken: true });
-    jest
-      .mocked(turtleFetch)
-      .mockResolvedValueOnce(jsonResponse({ errors: [{ message: 'The session finished.' }] }, 403));
-
-    const error = await uploadRemoteSessionConfigAsync({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      remoteConfig: {},
-      logger,
-    }).catch(err => err);
-
-    expect(error).toBeInstanceOf(SystemError);
-    expect(error.message).toBe(
-      'Failed to start device run session drs-id: POST /v2/device-run-session-worker/start failed with status 403: The session finished.'
-    );
-    expect(error.message).not.toContain(TOKEN);
-  });
-
-  it('fetches TURN ICE servers through the worker API', async () => {
-    const ctx = createCtx({ withToken: true });
-    jest.mocked(turtleFetch).mockResolvedValueOnce(
-      jsonResponse({
-        data: {
-          iceServers: [
-            { urls: ['stun:stun.test:3478'] },
-            { urls: ['turn:turn.test:3478'], username: 'user', credential: 'credential' },
-          ],
-        },
-      })
-    );
-
-    const args = await fetchWebPreviewTurnArgsAsync(ctx, { logger });
-
-    expect(args).toEqual([
-      '--stun-url',
-      'stun:stun.test:3478',
-      '--turn-url',
-      'turn:turn.test:3478',
-      '--turn-username',
-      'user',
-      '--turn-credential',
-      'credential',
-    ]);
-    expectWorkerApiCall('turn-ice-servers', 'POST', { timeout: 5000, retries: 0 });
-    expect(jest.mocked(turtleFetch)).toHaveBeenCalledTimes(1);
-  });
-
-  it('creates artifact upload sessions through the worker API', async () => {
-    const ctx = createCtx({ withToken: true });
-    jest.mocked(turtleFetch).mockResolvedValueOnce(
-      jsonResponse({
-        data: { uploadSession: { url: 'https://uploads.expo.test/artifact', headers: {} } },
-      })
-    );
-    jest.mocked(fetch).mockResolvedValueOnce(new Response('', { status: 200 }));
-
-    await uploadDeviceRunSessionArtifactAsync(ctx, {
-      deviceRunSessionId: 'drs-id',
-      artifactId: 'artifact-id',
-      name: 'Report',
-      filename: 'report.json',
-      kind: 'test-report',
-      metadata: { a: 'b' },
-      size: 4,
-      openStream: () => Readable.from(Buffer.from('data')),
-    });
-
-    expectWorkerApiCall('artifact-upload-sessions', 'POST', {
-      json: {
-        name: 'Report',
-        filename: 'report.json',
-        kind: 'test-report',
-        metadata: { a: 'b' },
-        size: 4,
-      },
-      signal: expect.any(AbortSignal),
-    });
-    expect(jest.mocked(fetch)).toHaveBeenCalledWith(
-      'https://uploads.expo.test/artifact',
-      expect.objectContaining({ method: 'PUT' })
-    );
-    expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
-  });
-
-  it('creates the event log upload session through the worker API', async () => {
-    const ctx = createCtx({ withToken: true });
-    jest.mocked(turtleFetch).mockResolvedValueOnce(
-      jsonResponse({
-        data: {
-          uploadSession: { url: 'https://uploads.expo.test/events', headers: { 'X-A': '1' } },
-        },
-      })
-    );
-
-    const collection = await startDeviceRunSessionEventCollectionAsync({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      source: eventSource,
-      logger,
-    });
-    await collection.stopAsync();
-
-    expectWorkerApiCall('event-log-upload-session', 'POST');
-    expect(jest.mocked(RemoteLoggerStream)).toHaveBeenCalledWith(
-      expect.objectContaining({
-        uploadMethod: {
-          signedUrl: { url: 'https://uploads.expo.test/events', headers: { 'X-A': '1' } },
-        },
-      })
-    );
-    expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
-  });
-
-  it('creates the preview upload session through the worker API', async () => {
-    const ctx = createCtx({ withToken: true });
-    jest.mocked(turtleFetch).mockResolvedValueOnce(
-      jsonResponse({
-        data: { uploadSession: { url: 'https://uploads.expo.test/preview', headers: {} } },
-      })
-    );
-    jest.mocked(fetch).mockResolvedValue(new Response('', { status: 200 }));
-
-    const preview = startDeviceRunSessionPreview({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      captureAsync: async () => Buffer.from('webp'),
-      logger,
-    });
-    await waitForCallAsync(jest.mocked(fetch));
-    await preview.stopAsync();
-
-    expectWorkerApiCall('preview-upload-session', 'POST', { signal: expect.any(AbortSignal) });
-    expect(jest.mocked(fetch)).toHaveBeenCalledWith(
-      'https://uploads.expo.test/preview',
-      expect.objectContaining({ method: 'PUT' })
-    );
-    expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
-  });
-
-  it.each([
-    [BuildRuntimePlatform.DARWIN, 'IOS'],
-    [BuildRuntimePlatform.LINUX, 'ANDROID'],
-  ] as const)(
-    'loads the screenshot naming details through the worker API on a %s worker',
-    async (runtimePlatform, platform) => {
-      const ctx = { ...createCtx({ withToken: true }), runtimePlatform } as CustomBuildContext;
-      jest.mocked(turtleFetch).mockResolvedValueOnce(
-        jsonResponse({
-          data: {
-            build: {
-              id: BUILD_ID,
-              gitCommitHash: 'abc',
-              applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
-            },
-          },
-        })
-      );
-
-      await expect(loadScreenshotSessionAsync(ctx, 'drs-id', logger)).resolves.toEqual({
-        platform,
-        app: null,
-        build: { id: BUILD_ID, gitCommitHash: 'abc', app: null },
-      });
-      expectWorkerApiCall('application', 'GET', { signal: expect.any(AbortSignal), retries: 0 });
-      expect(ctx.graphqlClient.query).not.toHaveBeenCalled();
-    }
-  );
-
-  it('downloads the session build from the worker API archive URL without an Authorization header', async () => {
-    const ctx = createCtx({ withToken: true });
-    jest.mocked(turtleFetch).mockResolvedValueOnce(
-      jsonResponse({
-        data: {
-          build: {
-            id: BUILD_ID,
-            gitCommitHash: null,
-            applicationArchiveUrl: APPLICATION_ARCHIVE_URL,
-          },
-        },
-      })
-    );
-    jest.mocked(fetch).mockResolvedValueOnce(new Response('stop here', { status: 500 }));
-
-    await expect(
-      downloadBuildAsync({
-        logger,
-        buildId: BUILD_ID,
-        graphqlClient: ctx.graphqlClient,
-        deviceRunSessionWorkerApi: new DeviceRunSessionWorkerApi(API_V2_BASE_URL, TOKEN),
-        robotAccessToken: ROBOT_ACCESS_TOKEN,
-        extensions: ['app'],
-      })
-    ).rejects.toThrow('Unexpected response from server (500): stop here');
-
-    expectWorkerApiCall('application', 'GET');
-    expect(jest.mocked(fetch)).toHaveBeenCalledWith(
-      APPLICATION_ARCHIVE_URL,
-      expect.objectContaining({ headers: undefined })
-    );
-    expect(ctx.graphqlClient.query).not.toHaveBeenCalled();
-  });
-
-  it('refuses to download a build that is not the session build', async () => {
-    jest.mocked(turtleFetch).mockResolvedValueOnce(jsonResponse({ data: { build: null } }));
-
-    const error = await downloadBuildAsync({
-      logger,
-      buildId: BUILD_ID,
-      graphqlClient: createCtx({ withToken: true }).graphqlClient,
-      deviceRunSessionWorkerApi: new DeviceRunSessionWorkerApi(API_V2_BASE_URL, TOKEN),
-      robotAccessToken: ROBOT_ACCESS_TOKEN,
-      extensions: ['app'],
-    }).catch(err => err);
-
-    expect(error).toBeInstanceOf(SystemError);
-    expect(error.message).toContain(
-      `Could not fetch build ${BUILD_ID}: this device run session runs no build`
-    );
-    expect(jest.mocked(fetch)).not.toHaveBeenCalled();
-  });
-
-  it('reports a rejected build lookup as a system error, because the job sends no user input', async () => {
-    jest.mocked(turtleFetch).mockResolvedValueOnce(
-      jsonResponse(
-        {
-          errors: [
-            {
-              code: 'UNAUTHORIZED_ERROR',
-              message: 'This device run session no longer accepts worker requests.',
-            },
-          ],
-        },
-        403
-      )
-    );
-
-    const error = await downloadBuildAsync({
-      logger,
-      buildId: BUILD_ID,
-      graphqlClient: createCtx({ withToken: true }).graphqlClient,
-      deviceRunSessionWorkerApi: new DeviceRunSessionWorkerApi(API_V2_BASE_URL, TOKEN),
-      robotAccessToken: ROBOT_ACCESS_TOKEN,
-      extensions: ['app'],
-    }).catch(err => err);
-
-    expect(error).toBeInstanceOf(SystemError);
-    expect(error.message).toContain(
-      `Could not fetch build ${BUILD_ID} for this device run session: GET /v2/device-run-session-worker/application failed with status 403: This device run session no longer accepts worker requests.`
-    );
-    expect(jest.mocked(fetch)).not.toHaveBeenCalled();
-  });
-});
-
-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 () => {
-    const ctx = createCtx({ withToken: false });
-
-    const error = await waitForDeviceRunSessionStoppedAsync({
-      ctx,
-      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 () => {
-    const ctx = createCtx({ withToken: false });
-
-    await waitForDeviceRunSessionStoppedAsync({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      logger,
-      idleTimeout: { maxIdleTimeMinutes: 0, getLastEventObservedAt: () => undefined },
-    });
-
-    expectMissingTokenWarning(
-      'Could not mark device run session drs-id as stopped. The session job ends anyway.'
-    );
-    expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
-    expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
-  });
-
-  it('fails the start with a system error', async () => {
-    const ctx = createCtx({ withToken: false });
-
-    const error = await uploadRemoteSessionConfigAsync({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      remoteConfig: { type: 'agent-device' },
-      logger,
-    }).catch(err => err);
-
-    expectMissingTokenError(error);
-    expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
-    expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
-  });
-
-  it('falls back to no TURN ICE servers', async () => {
-    const ctx = createCtx({ withToken: false });
-
-    await expect(fetchWebPreviewTurnArgsAsync(ctx, { logger })).resolves.toEqual([]);
-
-    expectMissingTokenWarning(
-      'Could not fetch Cloudflare TURN ICE servers; the web preview will fall back to P2P/STUN.'
-    );
-    expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
-  });
-
-  it('fails the artifact upload with a system error before any PUT', async () => {
-    const ctx = createCtx({ withToken: false });
-
-    const error = await uploadDeviceRunSessionArtifactAsync(ctx, {
-      deviceRunSessionId: 'drs-id',
-      artifactId: 'artifact-id',
-      name: 'Report',
-      filename: 'report.json',
-      kind: undefined,
-      size: 4,
-      openStream: () => Readable.from(Buffer.from('data')),
-    }).catch(err => err);
-
-    expectMissingTokenError(error);
-    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 () => {
-    const ctx = createCtx({ withToken: false });
-
-    const collection = await startDeviceRunSessionEventCollectionAsync({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      source: eventSource,
-      logger,
-    });
-    await collection.stopAsync();
-
-    expectMissingTokenWarning('Could not persist device run session events to the artifact.');
-    expect(jest.mocked(RemoteLoggerStream)).not.toHaveBeenCalled();
-    expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
-    expect(ctx.graphqlClient.mutation).not.toHaveBeenCalled();
-  });
-
-  it('logs the failed preview upload session and uploads no preview', async () => {
-    const ctx = createCtx({ withToken: false });
-
-    const preview = startDeviceRunSessionPreview({
-      ctx,
-      deviceRunSessionId: 'drs-id',
-      captureAsync: async () => Buffer.from('webp'),
-      logger,
-    });
-    await waitForCallAsync(jest.mocked(logger.warn));
-    await preview.stopAsync();
-
-    expectMissingTokenWarning('Could not refresh the session preview; retrying in 60 seconds.');
-    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 () => {
-    const ctx = createCtx({ withToken: false });
-
-    await expect(loadScreenshotSessionAsync(ctx, 'drs-id', logger)).resolves.toBeNull();
-
-    expectMissingTokenWarning(
-      'Could not load screenshot session details; using capture timestamps.'
-    );
-    expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
-    expect(ctx.graphqlClient.query).not.toHaveBeenCalled();
-  });
-
-  it('looks up the build archive URL with GraphQL', async () => {
-    const ctx = createCtx({ withToken: false });
-    jest.mocked(ctx.graphqlClient.query).mockReturnValueOnce(
-      graphqlResult({
-        builds: {
-          byId: {
-            id: BUILD_ID,
-            platform: 'IOS',
-            artifacts: { applicationArchiveUrl: APPLICATION_ARCHIVE_URL },
-          },
-        },
-      }) as never
-    );
-    jest.mocked(fetch).mockResolvedValueOnce(new Response('stop here', { status: 500 }));
-
-    await expect(
-      downloadBuildAsync({
-        logger,
-        buildId: BUILD_ID,
-        graphqlClient: ctx.graphqlClient,
-        deviceRunSessionWorkerApi: null,
-        robotAccessToken: ROBOT_ACCESS_TOKEN,
-        extensions: ['app'],
-      })
-    ).rejects.toThrow('Unexpected response from server (500)');
-
-    expect(ctx.graphqlClient.query).toHaveBeenCalled();
-    expect(jest.mocked(fetch)).toHaveBeenCalledWith(
-      APPLICATION_ARCHIVE_URL,
-      expect.objectContaining({ headers: { Authorization: `Bearer ${ROBOT_ACCESS_TOKEN}` } })
-    );
-    expect(jest.mocked(turtleFetch)).not.toHaveBeenCalled();
-  });
-});

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

@@ -1,63 +0,0 @@
-import spawn from '@expo/turtle-spawn';
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-
-import { readIosApplicationIdentifierAsync } from '../iosAppArtifact';
-
-jest.mock('@expo/turtle-spawn', () => ({ __esModule: true, default: jest.fn() }));
-jest.unmock('fs');
-jest.unmock('node:fs');
-jest.unmock('fs/promises');
-jest.unmock('node:fs/promises');
-
-describe(readIosApplicationIdentifierAsync, () => {
-  let directory: string;
-  let artifactPath: string;
-
-  beforeEach(async () => {
-    jest.mocked(spawn).mockReset();
-    directory = await mkdtemp(path.join(os.tmpdir(), 'ios-app-artifact-'));
-    artifactPath = path.join(directory, 'Example.app');
-    await mkdir(artifactPath);
-  });
-
-  afterEach(async () => {
-    await rm(directory, { recursive: true, force: true });
-  });
-
-  it('reads app metadata without installing or launching', async () => {
-    jest.mocked(spawn).mockResolvedValue({ stdout: 'com.example.app\n', stderr: '' } as never);
-    await expect(readIosApplicationIdentifierAsync({ artifactPath, env: {} })).resolves.toBe(
-      'com.example.app'
-    );
-    expect(jest.mocked(spawn).mock.calls).toEqual([
-      [
-        'plutil',
-        ['-extract', 'CFBundleIdentifier', 'raw', '-o', '-', path.join(artifactPath, 'Info.plist')],
-        { stdio: 'pipe', env: {} },
-      ],
-    ]);
-  });
-
-  it.each(['missing', 'file', 'wrong extension'])('rejects an invalid artifact: %s', async kind => {
-    await rm(artifactPath, { recursive: true });
-    if (kind === 'file') {
-      await writeFile(artifactPath, 'not an app directory');
-    } else if (kind === 'wrong extension') {
-      artifactPath = path.join(directory, 'Example.ipa');
-      await mkdir(artifactPath);
-    }
-    await expect(
-      readIosApplicationIdentifierAsync({ artifactPath, env: {} })
-    ).rejects.toMatchObject({ errorCode: 'EAS_INSTALL_BUILD_INVALID_ARTIFACT' });
-    expect(spawn).not.toHaveBeenCalled();
-  });
-
-  it('rejects a missing bundle identifier', async () => {
-    jest.mocked(spawn).mockResolvedValue({ stdout: '  ', stderr: '' } as never);
-    await expect(
-      readIosApplicationIdentifierAsync({ artifactPath, env: {} })
-    ).rejects.toMatchObject({ errorCode: 'EAS_INSTALL_BUILD_MISSING_IDENTIFIER' });
-  });
-});

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

@@ -1,191 +0,0 @@
-import { BuildRuntimePlatform } from '@expo/steps';
-import spawn from '@expo/turtle-spawn';
-
-import { createMockLogger } from '../../../__tests__/utils/logger';
-import { IosSimulatorUtils, type IosSimulatorUuid } from '../../../utils/IosSimulatorUtils';
-import { resolveIosSessionStartupAsync } from '../iosSimulatorSession';
-import { readIosApplicationIdentifierAsync } from '../iosAppArtifact';
-import {
-  resolveLocalEgressServeSimBootEnvironmentAsync,
-  startLocalEgressGuardRelayAsync,
-} from '../localEgressGuard';
-
-jest.mock('@expo/turtle-spawn', () => ({ __esModule: true, default: jest.fn() }));
-jest.mock('../../../utils/IosSimulatorUtils');
-jest.mock('../iosAppArtifact', () => ({ readIosApplicationIdentifierAsync: jest.fn() }));
-jest.mock('../localEgressGuard', () => ({
-  resolveLocalEgressServeSimBootEnvironmentAsync: jest.fn(),
-  startLocalEgressGuardRelayAsync: jest.fn(),
-}));
-
-const mockedSpawn = jest.mocked(spawn);
-const mockedUtils = jest.mocked(IosSimulatorUtils);
-
-describe('serve-sim Simulator preparation', () => {
-  const hostOptions = {
-    runtimePlatform: BuildRuntimePlatform.DARWIN,
-    env: {},
-    logger: createMockLogger(),
-  };
-  beforeEach(() => {
-    jest.clearAllMocks();
-    mockedUtils.getAvailableDevicesAsync.mockResolvedValue([
-      {
-        udid: 'selected-udid',
-        name: 'iPhone 17',
-        isAvailable: true,
-        deviceTypeIdentifier: 'com.apple.CoreSimulator.SimDeviceType.iPhone-17',
-      },
-    ] as never);
-    mockedUtils.resolveUdidAsync.mockResolvedValue('selected-udid' as IosSimulatorUuid);
-    jest.mocked(resolveLocalEgressServeSimBootEnvironmentAsync).mockResolvedValue(null);
-    mockedSpawn.mockResolvedValue({ stdout: '', stderr: '' } as never);
-    jest.mocked(readIosApplicationIdentifierAsync).mockResolvedValue('dev.example.app');
-  });
-  it.each([
-    ['argument count', Array(257).fill('a')],
-    ['argument length', ['a'.repeat(9000)]],
-    ['NUL argument', ['a\u0000b']],
-    ['total UTF-8 bytes', Array(8).fill('😃'.repeat(4096))],
-  ])('rejects invalid launch %s before Simulator preparation', async (_, launchArgs) => {
-    await expect(
-      resolveIosSessionStartupAsync({
-        ...hostOptions,
-        bootSimulator: true,
-        launchAppIdentifier: 'dev.example.app',
-        launchArgs,
-      })
-    ).rejects.toThrow('iOS launch_args');
-    expect(mockedUtils.getAvailableDevicesAsync).not.toHaveBeenCalled();
-    expect(mockedUtils.resolveUdidAsync).not.toHaveBeenCalled();
-    expect(resolveLocalEgressServeSimBootEnvironmentAsync).not.toHaveBeenCalled();
-  });
-
-  it.each([
-    ['an oversized URL', `https://example.test/${'a'.repeat(8192)}`],
-    ['NUL in a URL', 'exp://example.test/a\0b'],
-  ])('rejects %s before Simulator preparation', async (_, openUrl) => {
-    await expect(
-      resolveIosSessionStartupAsync({
-        ...hostOptions,
-        bootSimulator: true,
-        launchAppIdentifier: 'dev.example.app',
-        openUrl,
-      })
-    ).rejects.toThrow('iOS open_url');
-    expect(mockedUtils.getAvailableDevicesAsync).not.toHaveBeenCalled();
-    expect(mockedUtils.resolveUdidAsync).not.toHaveBeenCalled();
-    expect(resolveLocalEgressServeSimBootEnvironmentAsync).not.toHaveBeenCalled();
-  });
-
-  it('keeps an explicit launch identifier independent of the installed app', async () => {
-    const startup = await resolveIosSessionStartupAsync({
-      ...hostOptions,
-      installAppPath: '/tmp/App.app',
-      launchAppIdentifier: 'another.installed.app',
-    });
-    expect(startup.launch.launchAppIdentifier).toBe('another.installed.app');
-    expect(readIosApplicationIdentifierAsync).not.toHaveBeenCalled();
-  });
-
-  it('infers the launch identifier from the downloaded app', async () => {
-    const startup = await resolveIosSessionStartupAsync({
-      ...hostOptions,
-      installAppPath: '/tmp/App.app',
-    });
-    expect(startup.launch.launchAppIdentifier).toBe('dev.example.app');
-    expect(readIosApplicationIdentifierAsync).toHaveBeenCalledWith({
-      artifactPath: '/tmp/App.app',
-      env: {},
-    });
-  });
-
-  it('does no Simulator work on Android and rejects iOS installation inputs', async () => {
-    const options = { ...hostOptions, runtimePlatform: BuildRuntimePlatform.LINUX };
-    await expect(resolveIosSessionStartupAsync(options)).resolves.toEqual({
-      launch: { launchArgs: [], launchAppIdentifier: undefined, openUrl: undefined },
-    });
-    await expect(
-      resolveIosSessionStartupAsync({ ...options, installAppPath: '/tmp/App.app' })
-    ).rejects.toThrow('only supported for iOS');
-    expect(mockedUtils.resolveUdidAsync).not.toHaveBeenCalled();
-  });
-
-  it('preserves older workflows that already prepared the Simulator and app', async () => {
-    const startup = await resolveIosSessionStartupAsync({
-      ...hostOptions,
-      launchAppIdentifier: 'previously.installed.app',
-    });
-    expect(startup.iosStartup).toBeUndefined();
-    expect(startup.launch.launchAppIdentifier).toBe('previously.installed.app');
-    expect(mockedUtils.resolveUdidAsync).not.toHaveBeenCalled();
-    expect(resolveLocalEgressServeSimBootEnvironmentAsync).not.toHaveBeenCalled();
-    expect(spawn).not.toHaveBeenCalled();
-  });
-
-  it('prepares a session without an app when the workflow requests owned startup', async () => {
-    const startup = await resolveIosSessionStartupAsync({ ...hostOptions, bootSimulator: true });
-    expect(startup.iosStartup?.iosSimulatorUdid).toBe('SELECTED-UDID');
-    expect(startup.launch.launchAppIdentifier).toBeUndefined();
-  });
-
-  it.each(['Booted', 'Booting', 'Shutdown'])(
-    'prepares guarded startup on a %s device',
-    async state => {
-      const bootEnv = { SERVE_SIM_ADDITIONAL_DYLIBS: '/guard.dylib' };
-      jest.mocked(resolveLocalEgressServeSimBootEnvironmentAsync).mockResolvedValue(bootEnv);
-      mockedUtils.getDeviceAsync.mockResolvedValue({ state } as never);
-      const startup = await resolveIosSessionStartupAsync({ ...hostOptions, bootSimulator: true });
-      expect(startup.iosStartup).toEqual({
-        iosSimulatorUdid: 'SELECTED-UDID',
-        bootEnv,
-        installAppPath: undefined,
-      });
-      if (state === 'Shutdown') {
-        expect(spawn).not.toHaveBeenCalled();
-      } else {
-        expect(spawn).toHaveBeenCalledWith(
-          'xcrun',
-          ['simctl', 'shutdown', 'SELECTED-UDID'],
-          expect.anything()
-        );
-      }
-      expect(startLocalEgressGuardRelayAsync).toHaveBeenCalled();
-      expect(mockedUtils.bootAsync).not.toHaveBeenCalled();
-    }
-  );
-
-  it('resolves an explicit Simulator without booting or configuring it', async () => {
-    const startup = await resolveIosSessionStartupAsync({
-      ...hostOptions,
-      deviceIdentifier: 'iPhone 17',
-    });
-    expect(startup.iosStartup?.iosSimulatorUdid).toBe('SELECTED-UDID');
-    expect(mockedUtils.resolveUdidAsync).toHaveBeenCalledWith({
-      deviceIdentifier: 'iPhone 17',
-      env: {},
-    });
-    expect(mockedUtils.getAvailableDevicesAsync).not.toHaveBeenCalled();
-    expect(mockedUtils.bootAsync).not.toHaveBeenCalled();
-    expect(mockedUtils.startAsync).not.toHaveBeenCalled();
-    expect(mockedUtils.enableAccessibilitySettingsAsync).not.toHaveBeenCalled();
-  });
-
-  it('selects the default iPhone without booting', async () => {
-    mockedUtils.getAvailableDevicesAsync.mockResolvedValue([
-      { name: 'iPad', udid: 'ipad' },
-      { name: 'iPhone 17 Pro', udid: 'pro' },
-      { name: 'iPhone 17', udid: 'base' },
-    ] as never);
-    await resolveIosSessionStartupAsync({ ...hostOptions, bootSimulator: true });
-    expect(mockedUtils.resolveUdidAsync).toHaveBeenCalledWith({
-      deviceIdentifier: 'base',
-      env: {},
-    });
-    expect(mockedUtils.bootAsync).not.toHaveBeenCalled();
-    mockedUtils.getAvailableDevicesAsync.mockResolvedValue([]);
-    await expect(
-      resolveIosSessionStartupAsync({ ...hostOptions, bootSimulator: true })
-    ).rejects.toThrow('Could not find an iPhone');
-  });
-});

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

@@ -21,8 +21,6 @@ import {
   rebindLocalEgressGuardRelays,
   resolveEgressGuardLibraryAsync,
   resolveLocalEgressBootEnvironmentAsync,
-  resolveLocalEgressServeSimBootEnvironmentAsync,
-  startLocalEgressGuardRelayAsync,
   stopLocalEgressGuardRelaysAsync,
   verifyLocalEgressGuardAsync,
 } from '../localEgressGuard';
@@ -403,38 +401,6 @@ describe(installLocalEgressGuardAsync, () => {
     expect(sessionLogger.lines.at(-1)?.msg).toContain('refused 1 connection attempt(s)');
   });
 
-  it('still installs the guard when its event log cannot be created', async () => {
-    const handoffPath = path.join(dir, 'handoff.json');
-    await writeLocalEgressHandoffAsync(handoff, handoffPath);
-    const libraryPath = path.join(dir, 'egress-guard.dylib');
-    const blockedDirectory = path.join(dir, 'not-a-directory');
-    await fs.promises.writeFile(blockedDirectory, 'file');
-    await expect(
-      installLocalEgressGuardAsync({
-        udid: 'u' as any,
-        env: process.env,
-        logger,
-        handoffPath,
-        libraryPath,
-        logPath: path.join(blockedDirectory, 'guard.log'),
-      })
-    ).resolves.toBe(true);
-    expect(mockedSetEnv).toHaveBeenCalledWith({
-      udid: 'u',
-      env: process.env,
-      variables: buildGuardLaunchdEnvironment({
-        libraryPath,
-        logPath: path.join(blockedDirectory, 'guard.log'),
-        mode: 'block',
-      }),
-    });
-    expect(
-      logger.lines.some(
-        line => line.level === 'warn' && line.msg.includes('They are still refused.')
-      )
-    ).toBe(true);
-  });
-
   it('fails the session when launchctl fails', async () => {
     const handoffPath = path.join(dir, 'handoff.json');
     await writeLocalEgressHandoffAsync(handoff, handoffPath);
@@ -503,101 +469,6 @@ describe(resolveLocalEgressBootEnvironmentAsync, () => {
   });
 });
 
-describe(resolveLocalEgressServeSimBootEnvironmentAsync, () => {
-  let dir: string;
-  let handoffPath: string;
-  beforeEach(async () => {
-    dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'guard-serve-sim-'));
-    handoffPath = path.join(dir, 'handoff.json');
-  });
-  afterEach(async () => {
-    await fs.promises.rm(dir, { recursive: true, force: true });
-  });
-
-  it('does not require the guard or check for an ordinary session', async () => {
-    await expect(
-      resolveLocalEgressServeSimBootEnvironmentAsync({
-        handoffPath,
-        libraryPath: null,
-        checkPath: null,
-      })
-    ).resolves.toBeNull();
-  });
-
-  it('requires both packaged files before handing startup to serve-sim', async () => {
-    await writeLocalEgressHandoffAsync(handoff, handoffPath);
-    await expect(
-      resolveLocalEgressServeSimBootEnvironmentAsync({ handoffPath, libraryPath: null })
-    ).rejects.toThrow('missing bin/egress-guard.dylib');
-    await expect(
-      resolveLocalEgressServeSimBootEnvironmentAsync({
-        handoffPath,
-        libraryPath: '/w/bin/egress-guard.dylib',
-        checkPath: null,
-      })
-    ).rejects.toThrow('missing bin/egress-guard-check');
-  });
-
-  it('passes the additional dylib and prefixed child variables without host DYLD injection', async () => {
-    await writeLocalEgressHandoffAsync(handoff, handoffPath);
-    const bootEnv = await resolveLocalEgressServeSimBootEnvironmentAsync({
-      handoffPath,
-      libraryPath: '/w/bin/egress-guard.dylib',
-      checkPath: '/w/bin/egress-guard-check',
-      logPath: '/tmp/guard.log',
-    });
-    expect(bootEnv).toEqual({
-      SERVE_SIM_ADDITIONAL_DYLIBS: '/w/bin/egress-guard.dylib',
-      SIMCTL_CHILD_EAS_EGRESS_GUARD_LOG: '/tmp/guard.log',
-      SIMCTL_CHILD_EAS_EGRESS_GUARD_MODE: 'block',
-      SIMCTL_CHILD_http_proxy: 'http://127.0.0.1:8899',
-      SIMCTL_CHILD_https_proxy: 'http://127.0.0.1:8899',
-      SIMCTL_CHILD_HTTP_PROXY: 'http://127.0.0.1:8899',
-      SIMCTL_CHILD_HTTPS_PROXY: 'http://127.0.0.1:8899',
-      SIMCTL_CHILD_grpc_proxy: 'http://127.0.0.1:8899',
-      SIMCTL_CHILD_no_proxy: 'localhost,127.0.0.1,::1',
-      SIMCTL_CHILD_NO_PROXY: 'localhost,127.0.0.1,::1',
-    });
-  });
-});
-
-describe(startLocalEgressGuardRelayAsync, () => {
-  it('relays boot events once after repeated starts without changing Simulator state', async () => {
-    const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'guard-relay-'));
-    const logPath = path.join(dir, 'guard.log');
-    const logger = createLogger();
-    mockedSetEnv.mockClear();
-    await fs.promises.writeFile(
-      logPath,
-      'eas-egress-guard\tSpringBoard\t4001\tconnect\tblocked\t1.1.1.1:443\tNetwork\n'
-    );
-    jest.useFakeTimers({ doNotFake: ['nextTick', 'setImmediate'] });
-    try {
-      await startLocalEgressGuardRelayAsync({ logger, logPath, tailIntervalMs: 5 });
-      await startLocalEgressGuardRelayAsync({ logger, logPath, tailIntervalMs: 5 });
-      await fs.promises.appendFile(
-        logPath,
-        'eas-egress-guard\tMyApp\t4002\tconnect\tblocked\t1.1.1.1:443\tNetwork\n'
-      );
-      await jest.advanceTimersByTimeAsync(20);
-      await stopLocalEgressGuardRelaysAsync(logger);
-      expect(mockedSetEnv).not.toHaveBeenCalled();
-      expect(
-        logger.lines.filter(line => /refused connect from SpringBoard/.test(line.msg))
-      ).toHaveLength(1);
-      expect(logger.lines.filter(line => /refused connect from MyApp/.test(line.msg))).toHaveLength(
-        1
-      );
-      expect(logger.lines.at(-1)?.msg).toContain('refused 2 connection attempt(s)');
-    } finally {
-      await stopLocalEgressGuardRelaysAsync(logger);
-      jest.clearAllTimers();
-      jest.useRealTimers();
-      await fs.promises.rm(dir, { recursive: true, force: true });
-    }
-  });
-});
-
 describe(parseGuardCoverage, () => {
   const ps = [
     '    1     0 /sbin/launchd',

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__/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__/serveSimActions.test.ts

@@ -1,184 +0,0 @@
-import { once } from 'node:events';
-import {
-  access,
-  lstat,
-  mkdir,
-  mkdtemp,
-  readFile,
-  readdir,
-  readlink,
-  rm,
-  stat,
-  symlink,
-  writeFile,
-} from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { WebSocketServer } from 'ws';
-
-import { runServeSimActionAsync, stageServeSimAppAsync } from '../serveSimActions';
-
-jest.unmock('fs');
-jest.unmock('node:fs');
-jest.unmock('fs/promises');
-jest.unmock('node:fs/promises');
-
-let server: WebSocketServer;
-let port: number;
-const token = 'test-session-token';
-const request = () => ({
-  port,
-  token,
-  action: 'app.install',
-  params: { udid: 'device', path: '/tmp/App.app' },
-  timeoutMs: 2_000,
-});
-
-beforeEach(async () => {
-  server = new WebSocketServer({ host: '127.0.0.1', port: 0 });
-  await once(server, 'listening');
-  port = (server.address() as { port: number }).port;
-});
-
-afterEach(async () => {
-  for (const socket of server.clients) {
-    socket.terminate();
-  }
-  await new Promise<void>(resolve => server.close(() => resolve()));
-});
-
-it('authenticates the upgrade, waits for ready, and sends the action once', async () => {
-  const actions: unknown[] = [];
-  const upgrades: unknown[] = [];
-  server.on('connection', (socket, upgrade) => {
-    upgrades.push({
-      url: upgrade.url,
-      protocol: upgrade.headers['sec-websocket-protocol'],
-    });
-    socket.on('message', raw => {
-      actions.push(JSON.parse(raw.toString()));
-      socket.send(JSON.stringify({ id: 1, stdout: '', stderr: '', exitCode: 0 }));
-    });
-    socket.send(JSON.stringify({ ready: true }));
-    socket.send(JSON.stringify({ ready: true }));
-  });
-  await runServeSimActionAsync(request());
-  expect(upgrades).toEqual([{ url: '/exec-ws', protocol: `serve-sim.token.${token}` }]);
-  expect(actions).toEqual([{ id: 1, action: 'app.install', params: request().params }]);
-});
-
-it.each([
-  [{ id: 1, exitCode: 1, stderr: 'install refused' }, 'install refused'],
-  [{ id: 1, error: 'unknown action app.install' }, 'unknown action'],
-  [{ id: 1, stdout: '' }, 'invalid response'],
-  [{ id: 1, exitCode: 1, stderr: '' }, 'invalid response'],
-])('rejects unsuccessful action replies without retrying', async (reply, message) => {
-  let attempts = 0;
-  server.on('connection', socket => {
-    socket.send(JSON.stringify({ ready: true }));
-    socket.on('message', () => {
-      attempts++;
-      socket.send(JSON.stringify(reply));
-    });
-  });
-  await expect(runServeSimActionAsync(request())).rejects.toThrow(message);
-  expect(attempts).toBe(1);
-});
-
-it('rejects a connection that closes before its action finishes', async () => {
-  server.on('connection', socket => socket.close());
-  await expect(runServeSimActionAsync(request())).rejects.toThrow('closed before completion');
-});
-
-it('rejects an upgrade refused by the server without executing an action', async () => {
-  const connected = jest.fn();
-  server.options.verifyClient = () => false;
-  server.on('connection', connected);
-  await expect(runServeSimActionAsync(request())).rejects.toThrow('connection failed');
-  expect(connected).not.toHaveBeenCalled();
-});
-
-it('rejects malformed replies without resending the action', async () => {
-  const actions = jest.fn();
-  server.on('connection', socket => {
-    socket.send(JSON.stringify({ ready: true }));
-    socket.on('message', () => {
-      actions();
-      socket.send('not JSON');
-    });
-  });
-  await expect(runServeSimActionAsync(request())).rejects.toThrow('returned invalid JSON');
-  expect(actions).toHaveBeenCalledTimes(1);
-});
-
-it('times out and closes a socket that never becomes ready', async () => {
-  const disconnected = new Promise(resolve =>
-    server.on('connection', socket => socket.on('close', resolve))
-  );
-  await expect(runServeSimActionAsync({ ...request(), timeoutMs: 30 })).rejects.toThrow(
-    'timed out'
-  );
-  await disconnected;
-});
-
-it('aborts an in-flight action without resending it', async () => {
-  const controller = new AbortController();
-  let attempts = 0;
-  server.on('connection', socket => {
-    socket.send(JSON.stringify({ ready: true }));
-    socket.on('message', () => {
-      attempts++;
-      controller.abort(new Error('session stopped'));
-    });
-  });
-  await expect(runServeSimActionAsync({ ...request(), signal: controller.signal })).rejects.toThrow(
-    'session stopped'
-  );
-  expect(attempts).toBe(1);
-});
-
-it('does not connect when already aborted', async () => {
-  const connected = jest.fn();
-  server.on('connection', connected);
-  await expect(
-    runServeSimActionAsync({
-      ...request(),
-      signal: AbortSignal.abort(new Error('already stopped')),
-    })
-  ).rejects.toThrow('already stopped');
-  expect(connected).not.toHaveBeenCalled();
-});
-
-it("stages a local app without consuming the caller's original", async () => {
-  const root = await mkdtemp(path.join(os.tmpdir(), 'serve-sim-stage-test-'));
-  try {
-    const source = path.join(root, 'downloaded', 'App.app');
-    await mkdir(source, { recursive: true });
-    await writeFile(path.join(source, 'marker'), 'app');
-    await symlink('marker', path.join(source, 'current'));
-    const alias = path.join(root, 'Alias.app');
-    await symlink(source, alias);
-    const staged = await stageServeSimAppAsync(alias, root);
-    expect(staged.path).toMatch(/serve-sim-uploads\/eas-app-[^/]+\/Alias.app$/);
-    expect((await lstat(staged.path)).isDirectory()).toBe(true);
-    await access(path.join(staged.path, 'marker'));
-    expect(await readlink(path.join(staged.path, 'current'))).toBe('marker');
-    expect((await stat(path.join(root, 'serve-sim-uploads'))).mode & 0o777).toBe(0o700);
-    await rm(staged.directory, { recursive: true, force: true });
-    expect(await readFile(path.join(source, 'marker'), 'utf8')).toBe('app');
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-it('removes its staging directory when the source app cannot be read', async () => {
-  const root = await mkdtemp(path.join(os.tmpdir(), 'serve-sim-stage-test-'));
-  try {
-    await expect(stageServeSimAppAsync(path.join(root, 'Missing.app'), root)).rejects.toThrow(
-      'ENOENT'
-    );
-    expect(await readdir(path.join(root, 'serve-sim-uploads'))).toEqual([]);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});

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',