Compare commits

...
Author SHA1 Message Date
Expo CI 67972c5d6a v27.11.0 2026-11-19 16:17:39 +00:00
Mustafa Abban d88708d842 [eas-build-job] support Observe error occurrence events (#4860) 2026-11-19 10:41:38 -05:00
expo-tuft[bot] 13056cac22 [build-tools] report the installed app identifier in the agent-device remote config (#4831) 2026-11-19 18:02:26 +08:00
David Mokos 1b45814e3c updates agent-cli-detector to 0.1.8 (#4912) 2026-11-19 00:34:22 +01:00
Tomasz Mazur 8d00e33806 [build-tools] Compress dSYMs with zip level 1 in fastlane gym (#4909) 2026-11-18 21:05:24 +01:00
Szymon Świerk f27e7988a1 [eas-build-job] Accept issue_comment as a workflow github.event_name (#4906) 2026-11-17 18:45:59 +01:00
Gabe DebesandClaude Opus 5.5 b4e4229464 [build-tools] Add step functions to record simulator crash artifacts (#4596)
* [build-tools] Collect simulator crash artifacts

* [build-tools] Use shared crash artifact upload deadlines

* [build-tools] Link crash artifact changelog entry

* [build-tools] Bound crash collection retries and uploads

* [build-tools] Keep retrying productive crash streams

* [build-tools] preserve crash shutdown mock in merged host tests

* Save individual native IPS crash artifacts

* [build-tools] Keep missing crash reports outside artifact limits

* [build-tools] Verify missing crash reports across reconnects

* [build-tools] Reserve crash collection before asynchronous setup

* [build-tools] Release failed crash recorder initialization

* [build-tools] Address crash artifact review findings

Skip a crash occurrence whose detail fails or exceeds 8 MiB instead of
reconnecting, and check each device's crash list once more on stop so
occurrences the stream had not delivered are kept. Key occurrences by
capture time and report path, merge the seen and skipped sets, create the
directory before the session is registered, and log dropped errors.
Artifacts are now kind simulator-crash with per-device numbered ids,
names, and filenames.

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

* [build-tools] Retry transient crash detail failures

Try a failed crash detail up to three times before skipping it; skip a
missing, mismatched, malformed, or oversized detail at once.

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

* [build-tools] Address second crash artifact review

Keep each device's serve-sim address current for the final pass, warn
when its deadline stops a device, report poller and upload failures to
Sentry, name failed uploads by report, and fall back to the process name
when the app name is empty.

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

* [build-tools] Skip crash details that a retry cannot fix

Treat invalid JSON and permanent 4xx responses as unusable, so they are
not retried three times before later reports are collected.

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

* [build-tools] Upload crash reports with the shared file upload helper

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

---------

Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-11-16 16:09:00 -07:00
Gabe DebesandClaude Opus 5.5 a04489e678 [build-tools] Add step functions to record simulator HAR artifacts (#4495)
* [build-tools] record network capture with serve-sim capture har steps

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>

* [build-tools] Rename the network capture recording step

Edited-by: Codex

* [build-tools] Remove the capture recorder command override

Edited-by: Codex

* [build-tools] Bound failed network capture followers

* [build-tools] Limit HAR artifact uploads to 500 MiB

* [build-tools] Address HAR capture review findings

Rename the record step to eas/start_serve_sim_network_capture and the
upload helper to a one-file serveSimNetworkCaptureArtifacts; the collect
step numbers parts. Count HARs by their entry log so empty recordings
are neither uploaded nor use recording slots, give followers that record
nothing a slower restart and a separate start cap, drop the spawn
failure throttle and unreachable guards, and allow 60 s for the final
HAR rebuild with followers stopped together.

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

* [build-tools] Bound HAR recording slots and uploads

Exited followers that recorded nothing no longer use recording slots, a
restarted serve-sim replaces the old identity's follower, the recording
limit warns once, and each HAR upload has a 10-minute limit.

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

* [build-tools] Keep the ngrok token from the HAR follower

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

* [build-tools] Drop requests a restarted HAR follower replays

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

* [build-tools] Keep unflushed HAR requests and remove replayed parts

Rebuild every kept HAR from its entry log before its requests count as
recorded, and delete the files of a follower that held only replayed
requests when it is dropped.

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

* [build-tools] Upload network captures with the shared file upload helper

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

* [build-tools] Import formatBytes from eas-build-job

Main moved formatBytes into @expo/eas-build-job (#4854).

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

---------

Co-authored-by: Claude Opus 5.5 (1M context) <[email protected]>
2026-11-16 16:09:00 -07:00
65 changed files with 3625 additions and 279 deletions

No files matched your search

@@ -1,5 +0,0 @@
---
'@expo/build-tools': minor
---
Count Android web preview input as session activity, so `max_idle_time_minutes` works on Android sessions. `eas/start_serve_sim_remote_session` no longer rejects it on Android; the API does not accept an idle timeout for Android web-preview-only sessions yet.
-5
View File
@@ -1,5 +0,0 @@
---
'eas-cli': patch
---
Mark the default device for each platform in `eas simulator:devices` and include `isDefault` in JSON output.
@@ -1,5 +0,0 @@
---
'@expo/build-tools': patch
---
A successful remote device run session no longer fails when its agent-device, Appium, or Argent tunnel does not stop within its time-out.
+18
View File
@@ -2,6 +2,24 @@
This is the log of notable changes to EAS CLI and related packages.
## [27.11.0](https://github.com/expo/eas-cli/releases/tag/v27.11.0) - 2026-11-19
### 🎉 New features
- [build-tools] Report the identifier of the installed app as `applicationIdentifier` in the agent-device remote config, so clients can attach to the app of an `application_archive_url` session. ([#4831](https://github.com/expo/eas-cli/pull/4831) by [@expo-tuft](https://github.com/apps/expo-tuft))
- [build-tools] Count Android web preview input as session activity, so `max_idle_time_minutes` works on Android sessions. `eas/start_serve_sim_remote_session` no longer rejects it on Android; the API does not accept an idle timeout for Android web-preview-only sessions yet. ([#4890](https://github.com/expo/eas-cli/pull/4890) by [@szdziedzic](https://github.com/szdziedzic))
- [eas-build-job] Accept `issue_comment` as a `github.event_name` value in the workflow interpolation context. ([#4906](https://github.com/expo/eas-cli/pull/4906) by [@sswrk](https://github.com/sswrk))
- [eas-build-job] Support error occurrence events in Observe workflow context. ([#4860](https://github.com/expo/eas-cli/pull/4860) by [@AbbanMustafa](https://github.com/AbbanMustafa))
- [build-tools] Add start and collect steps that attach serve-sim simulator crash reports to device run sessions as IPS files. ([#4596](https://github.com/expo/eas-cli/pull/4596) by [@gwdp](https://github.com/gwdp))
- [build-tools] Add start and collect steps that attach serve-sim network captures to device run sessions as HAR files. ([#4495](https://github.com/expo/eas-cli/pull/4495) by [@gwdp](https://github.com/gwdp))
### 🐛 Bug fixes
- [eas-cli] Detect Factory Droid, Grok Bot, Claude Cowork, and Muse in EAS CLI telemetry. ([#4912](https://github.com/expo/eas-cli/pull/4912) by [@davidmokos](https://github.com/davidmokos))
- [build-tools] Default `fastlane gym` dSYM compression level to 1. ([#4909](https://github.com/expo/eas-cli/pull/4909) by [@AHGIJMKLKKZNPJKQR](https://github.com/AHGIJMKLKKZNPJKQR))
- [eas-cli] Mark the default device for each platform in `eas simulator:devices` and include `isDefault` in JSON output. ([#4895](https://github.com/expo/eas-cli/pull/4895) by [@gwdp](https://github.com/gwdp))
- [build-tools] A successful remote device run session no longer fails when its agent-device, Appium, or Argent tunnel does not stop within its time-out. ([#4893](https://github.com/expo/eas-cli/pull/4893) by [@szdziedzic](https://github.com/szdziedzic))
## [27.10.0](https://github.com/expo/eas-cli/releases/tag/v27.10.0) - 2026-11-13
### 🎉 New features
+1 -1
View File
@@ -1,5 +1,5 @@
{
"npmClient": "yarn",
"version": "27.10.0",
"version": "27.11.0",
"$schema": "node_modules/lerna/schemas/lerna-schema.json"
}
+14
View File
@@ -1,5 +1,19 @@
# @expo/build-tools
## 27.11.0
### Minor Changes
- Report the identifier of the installed app as `applicationIdentifier` in the agent-device remote config, so clients can attach to the app of an `application_archive_url` session. ([#4831](https://github.com/expo/eas-cli/pull/4831) by [@expo-tuft](https://github.com/apps/expo-tuft))
- Count Android web preview input as session activity, so `max_idle_time_minutes` works on Android sessions. `eas/start_serve_sim_remote_session` no longer rejects it on Android; the API does not accept an idle timeout for Android web-preview-only sessions yet. ([#4890](https://github.com/expo/eas-cli/pull/4890) by [@szdziedzic](https://github.com/szdziedzic))
- Add start and collect steps that attach serve-sim simulator crash reports to device run sessions as IPS files. ([#4596](https://github.com/expo/eas-cli/pull/4596) by [@gwdp](https://github.com/gwdp))
- Add start and collect steps that attach serve-sim network captures to device run sessions as HAR files. ([#4495](https://github.com/expo/eas-cli/pull/4495) by [@gwdp](https://github.com/gwdp))
### Patch Changes
- Default `fastlane gym` dSYM compression level to 1. ([#4909](https://github.com/expo/eas-cli/pull/4909) by [@AHGIJMKLKKZNPJKQR](https://github.com/AHGIJMKLKKZNPJKQR))
- A successful remote device run session no longer fails when its agent-device, Appium, or Argent tunnel does not stop within its time-out. ([#4893](https://github.com/expo/eas-cli/pull/4893) by [@szdziedzic](https://github.com/szdziedzic))
## 27.10.0
### Minor Changes
+7 -7
View File
@@ -1,6 +1,6 @@
{
"name": "@expo/build-tools",
"version": "27.10.0",
"version": "27.11.0",
"bugs": "https://github.com/expo/eas-cli/issues",
"license": "BUSL-1.1",
"author": "Expo <[email protected]>",
@@ -42,17 +42,17 @@
"dependencies": {
"@expo/config": "55.0.10",
"@expo/config-plugins": "55.0.7",
"@expo/downloader": "27.10.0",
"@expo/eas-build-job": "27.10.0",
"@expo/downloader": "27.11.0",
"@expo/eas-build-job": "27.11.0",
"@expo/env": "^0.4.0",
"@expo/logger": "27.10.0",
"@expo/logger": "27.11.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": "27.10.0",
"@expo/template-file": "27.10.0",
"@expo/turtle-spawn": "27.10.0",
"@expo/steps": "27.11.0",
"@expo/template-file": "27.11.0",
"@expo/turtle-spawn": "27.11.0",
"@expo/xcpretty": "^4.4.7",
"@ngrok/ngrok": "1.7.0",
"@sentry/node": "7.77.0",
@@ -5,3 +5,7 @@ export const COMMON_FASTLANE_ENV = {
FASTLANE_HIDE_TIMESTAMP: 'true',
LC_ALL: 'en_US.UTF-8',
};
export const DEFAULT_FASTLANE_GYM_ENV = {
ZIPOPT: '-1',
};
@@ -23,13 +23,19 @@ const WORKING_DIR = '/workingdir';
// BuildContext.getReactNativeProjectDirectory() nests the RN project under `${workingdir}/build`.
const IOS_DIR = path.join(WORKING_DIR, 'build', 'ios');
function makeIosBuildContext({ simulator }: { simulator: boolean }): BuildContext<Ios.Job> {
function makeIosBuildContext({
simulator,
env = {},
}: {
simulator: boolean;
env?: Record<string, string>;
}): BuildContext<Ios.Job> {
const job: Ios.Job = { ...createTestIosJob(), simulator };
return new BuildContext(job, {
workingdir: WORKING_DIR,
logger: createMockLogger(),
logBuffer: { getLogs: () => [], getPhaseLogs: () => [] },
env: { __API_SERVER_URL: 'http://api.expo.test' },
env: { __API_SERVER_URL: 'http://api.expo.test', ...env },
uploadArtifact: jest.fn(),
});
}
@@ -125,4 +131,25 @@ describe(runFastlaneGym, () => {
workspacePath: IOS_DIR,
});
});
it.each<{ name: string; env: Record<string, string>; expectedZipopt: string }>([
{ name: 'defaults ZIPOPT to -1', env: {}, expectedZipopt: '-1' },
{ name: 'keeps ZIPOPT from the build env', env: { ZIPOPT: '-9' }, expectedZipopt: '-9' },
])('$name', async ({ env, expectedZipopt }) => {
const ctx = makeIosBuildContext({ simulator: false, env });
await runFastlaneGym(ctx, {
scheme: 'App',
credentials: ARCHIVE_CREDENTIALS,
entitlements: null,
});
expect(spawn).toHaveBeenCalledWith(
'fastlane',
['gym'],
expect.objectContaining({
env: expect.objectContaining({ ZIPOPT: expectedZipopt }),
})
);
});
});
+2 -2
View File
@@ -10,7 +10,7 @@ import type { Credentials } from './credentials/manager';
import { createFastfileForResigningBuild } from './fastfile';
import { createGymfileForArchiveBuild, createGymfileForSimulatorBuild } from './gymfile';
import { isTVOS } from './tvos';
import { COMMON_FASTLANE_ENV } from '../common/fastlane';
import { COMMON_FASTLANE_ENV, DEFAULT_FASTLANE_GYM_ENV } from '../common/fastlane';
import { XcodeBuildLogger } from '../common/xcpretty';
import { BuildContext, SkipNativeBuildError } from '../context';
@@ -52,7 +52,7 @@ export async function runFastlaneGym<TJob extends Ios.Job>(
await runFastlane(['gym'], {
cwd: workspacePath,
logger: ctx.logger,
env: { ...ctx.env, ...extraEnv },
env: { ...DEFAULT_FASTLANE_GYM_ENV, ...ctx.env, ...extraEnv },
});
} finally {
await buildLogger.flush();
@@ -62,9 +62,13 @@ import { createStartWebPreviewRemoteSessionBuildFunction } from './functions/sta
import { createStartServeSimMetricsBuildFunction } from './functions/startServeSimMetrics';
import { createStartServeSimLogsBuildFunction } from './functions/startServeSimLogs';
import { createCollectServeSimLogsBuildFunction } from './functions/collectServeSimLogs';
import { createStartServeSimNetworkCaptureBuildFunction } from './functions/startServeSimNetworkCapture';
import { createStartServeSimCrashesBuildFunction } from './functions/startServeSimCrashes';
import { createCollectServeSimCrashesBuildFunction } from './functions/collectServeSimCrashes';
import { createCollectAndroidEmulatorLogsBuildFunction } from './functions/collectAndroidEmulatorLogs';
import { createStartSandboxBuildFunction } from './functions/startSandbox';
import { createCollectServeSimMetricsBuildFunction } from './functions/collectServeSimMetrics';
import { createCollectServeSimNetworkCaptureBuildFunction } from './functions/collectServeSimNetworkCapture';
import { createUploadArtifactBuildFunction } from './functions/uploadArtifact';
import { createUploadDeviceRunSessionScreenRecordingsBuildFunction } from './functions/uploadDeviceRunSessionScreenRecordings';
import { createUploadEmbeddedBundleBuildFunction } from './functions/uploadEmbeddedBundle';
@@ -129,11 +133,15 @@ export function getEasFunctions(ctx: CustomBuildContext): BuildFunction[] {
createStartWebPreviewRemoteSessionBuildFunction(ctx, { warm: true }),
createStartServeSimMetricsBuildFunction(),
createStartServeSimLogsBuildFunction(),
createStartServeSimCrashesBuildFunction(),
createCollectServeSimCrashesBuildFunction(ctx),
createCollectServeSimLogsBuildFunction(ctx),
createCollectAndroidEmulatorLogsBuildFunction(ctx),
createStartSandboxBuildFunction(ctx),
createRunAgentBuildFunction(ctx),
createCollectServeSimMetricsBuildFunction(ctx),
createStartServeSimNetworkCaptureBuildFunction(),
createCollectServeSimNetworkCaptureBuildFunction(ctx),
createInstallMaestroBuildFunction(),
createInstallMitmproxyBuildFunction(),
@@ -0,0 +1,121 @@
import { type bunyan } from '@expo/logger';
import { type BuildStepContext, type BuildStepEnv } from '@expo/steps';
import { access, mkdir, mkdtemp, writeFile } from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import { type CustomBuildContext } from '../../../customBuildContext';
import { Sentry } from '../../../sentry';
import { getDeviceRunSessionIdOrThrow } from '../../utils/remoteDeviceRunSession';
import { uploadServeSimCrashesFileAsync } from '../../utils/serveSimCrashesArtifacts';
import { ServeSimCrashesRecorder } from '../../utils/serveSimCrashesRecorder';
import { createCollectServeSimCrashesBuildFunction } from '../collectServeSimCrashes';
import { createStartServeSimCrashesBuildFunction } from '../startServeSimCrashes';
jest.mock('../../../sentry');
jest.mock('../../utils/serveSimCrashesRecorder');
jest.mock('../../utils/serveSimCrashesArtifacts');
jest.mock('../../utils/remoteDeviceRunSession');
const logger = { info: jest.fn(), warn: jest.fn() } as unknown as bunyan;
const ctx = {} as CustomBuildContext;
const step = { logger } as BuildStepContext;
const args = { inputs: {}, outputs: {}, env: {} as BuildStepEnv };
beforeEach(() => {
jest.mocked(getDeviceRunSessionIdOrThrow).mockReturnValue('session-id');
jest
.mocked(ServeSimCrashesRecorder.finishAsync)
.mockResolvedValue({ outputDirectory: null, crashes: [] });
});
it('starts collection and tolerates startup failures', async () => {
jest.mocked(ServeSimCrashesRecorder.startAsync).mockRejectedValueOnce(new Error('disk failure'));
await expect(createStartServeSimCrashesBuildFunction().fn?.(step, args)).resolves.toBeUndefined();
expect(logger.warn).toHaveBeenCalled();
expect(Sentry.capture).toHaveBeenCalledWith(
'Could not start serve-sim simulator crashes',
expect.any(Error)
);
});
it('uploads each report and removes the collection directory', async () => {
const directory = '/tmp/crashes-collected';
await mkdir(directory, { recursive: true });
await writeFile(`${directory}/A.ips`, 'private crash report');
jest.mocked(ServeSimCrashesRecorder.finishAsync).mockResolvedValue({
outputDirectory: directory,
crashes: [
{ udid: 'A', filePath: `${directory}/A.ips`, size: 20, number: 1 },
{ udid: 'B', filePath: `${directory}/B.ips`, size: 20, number: 1 },
],
});
await createCollectServeSimCrashesBuildFunction(ctx).fn?.(step, args);
expect(uploadServeSimCrashesFileAsync).toHaveBeenCalledTimes(2);
expect(uploadServeSimCrashesFileAsync).toHaveBeenCalledWith(ctx, {
deviceRunSessionId: 'session-id',
crash: { udid: 'A', filePath: `${directory}/A.ips`, size: 20, number: 1 },
logger,
signal: expect.any(AbortSignal),
});
await expect(access(directory)).rejects.toMatchObject({ code: 'ENOENT' });
});
it('skips empty collection and warns on finalization failure', async () => {
await createCollectServeSimCrashesBuildFunction(ctx).fn?.(step, args);
expect(uploadServeSimCrashesFileAsync).not.toHaveBeenCalled();
jest.mocked(ServeSimCrashesRecorder.finishAsync).mockRejectedValueOnce(new Error('failure'));
await expect(
createCollectServeSimCrashesBuildFunction(ctx).fn?.(step, args)
).resolves.toBeUndefined();
expect(logger.warn).toHaveBeenCalled();
expect(Sentry.capture).toHaveBeenCalledWith(
'Could not finalize serve-sim simulator crashes',
expect.any(Error)
);
});
it.each([
['no crashes were recorded', [], false],
['session resolution fails', [{ udid: 'A', filePath: 'A.ips', size: 20, number: 1 }], true],
])('removes the collection directory when %s', async (_name, crashes, failSession) => {
const outputDirectory = await mkdtemp(path.join(os.tmpdir(), 'crashes-collected-'));
jest.mocked(ServeSimCrashesRecorder.finishAsync).mockResolvedValue({ outputDirectory, crashes });
if (failSession) {
jest.mocked(getDeviceRunSessionIdOrThrow).mockImplementationOnce(() => {
throw new Error('Missing session ID');
});
}
await expect(
createCollectServeSimCrashesBuildFunction(ctx).fn?.(step, args)
).resolves.toBeUndefined();
await expect(access(outputDirectory)).rejects.toMatchObject({ code: 'ENOENT' });
expect(uploadServeSimCrashesFileAsync).not.toHaveBeenCalled();
});
it('skips remaining reports for an exhausted device and continues with other devices', async () => {
jest.mocked(ServeSimCrashesRecorder.finishAsync).mockResolvedValue({
outputDirectory: null,
crashes: [
{ udid: 'A', filePath: '/tmp/A-1.ips', size: 20, number: 1 },
{ udid: 'A', filePath: '/tmp/A-2.ips', size: 20, number: 2 },
{ udid: 'B', filePath: '/tmp/B-1.ips', size: 20, number: 1 },
],
});
const controller = new AbortController();
const timeout = jest.spyOn(AbortSignal, 'timeout').mockReturnValueOnce(controller.signal);
jest.mocked(uploadServeSimCrashesFileAsync).mockImplementationOnce(async () => {
controller.abort(new Error('Upload budget exhausted'));
});
try {
await createCollectServeSimCrashesBuildFunction(ctx).fn?.(step, args);
expect(
jest.mocked(uploadServeSimCrashesFileAsync).mock.calls.map(([, { crash }]) => crash.filePath)
).toEqual(['/tmp/A-1.ips', '/tmp/B-1.ips']);
expect(logger.warn).toHaveBeenCalledWith(
'Simulator crash upload reached its time limit for A; remaining reports will not be uploaded.'
);
} finally {
timeout.mockRestore();
}
});
@@ -0,0 +1,104 @@
import { bunyan } from '@expo/logger';
import { type BuildStepEnv } from '@expo/steps';
import { access, mkdtemp } from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import { type CustomBuildContext } from '../../../customBuildContext';
import { uploadServeSimNetworkCaptureFileAsync } from '../../utils/serveSimNetworkCaptureArtifacts';
import { ServeSimNetworkCaptureRecorder } from '../../utils/serveSimNetworkCaptureRecorder';
import { createCollectServeSimNetworkCaptureBuildFunction } from '../collectServeSimNetworkCapture';
import { createStartServeSimNetworkCaptureBuildFunction } from '../startServeSimNetworkCapture';
jest.mock('../../../sentry');
jest.mock('../../utils/serveSimNetworkCaptureArtifacts');
jest.mock('../../utils/serveSimNetworkCaptureRecorder');
const ctx = {} as CustomBuildContext;
const logger = {
info: jest.fn(),
warn: jest.fn(),
error: jest.fn(),
debug: jest.fn(),
} as unknown as bunyan;
type Fn = (stepCtx: unknown, options: unknown) => Promise<void>;
function runFn(
fn: unknown,
options: { env: BuildStepEnv; inputs?: Record<string, { value: unknown }> }
): Promise<void> {
return (fn as Fn)({ logger }, { inputs: {}, ...options });
}
beforeEach(() => {
jest.clearAllMocks();
});
it('starts the recorder with the session package version and never fails the step', async () => {
const buildFunction = createStartServeSimNetworkCaptureBuildFunction();
expect(buildFunction.id).toBe('start_serve_sim_network_capture');
const { fn } = buildFunction as unknown as { fn: Fn };
const env = {} as BuildStepEnv;
await runFn(fn, { env, inputs: { package_version: { value: '0.5.0' } } });
expect(ServeSimNetworkCaptureRecorder.startAsync).toHaveBeenCalledWith({
logger,
env,
packageVersion: '0.5.0',
});
jest.mocked(ServeSimNetworkCaptureRecorder.startAsync).mockRejectedValueOnce(new Error('ENOSPC'));
await expect(
runFn(fn, { env, inputs: { package_version: { value: undefined } } })
).resolves.toBeUndefined();
expect(logger.warn).toHaveBeenCalledWith(
{ err: expect.objectContaining({ message: 'ENOSPC' }) },
'Could not start the serve-sim network capture recorder.'
);
});
it('uploads each recorded HAR as a numbered part per device, then removes the directory', async () => {
const outputDirectory = await mkdtemp(path.join(os.tmpdir(), 'serve-sim-network-capture-'));
const captures = [
{ udid: 'SIM-A', filePath: path.join(outputDirectory, 'SIM-A-1.har'), size: 24 },
{ udid: 'SIM-B', filePath: path.join(outputDirectory, 'SIM-B-1.har'), size: 25 },
{ udid: 'SIM-A', filePath: path.join(outputDirectory, 'SIM-A-3.har'), size: 26 },
];
jest
.mocked(ServeSimNetworkCaptureRecorder.finishAsync)
.mockResolvedValueOnce({ outputDirectory, captures });
const { fn } = createCollectServeSimNetworkCaptureBuildFunction(ctx) as unknown as { fn: Fn };
await runFn(fn, { env: { DEVICE_RUN_SESSION_ID: 'drs-id' } as BuildStepEnv });
const signal = expect.any(AbortSignal);
expect(jest.mocked(uploadServeSimNetworkCaptureFileAsync).mock.calls).toEqual([
[ctx, { deviceRunSessionId: 'drs-id', ...captures[0], part: 1, logger, signal }],
[ctx, { deviceRunSessionId: 'drs-id', ...captures[1], part: 1, logger, signal }],
[ctx, { deviceRunSessionId: 'drs-id', ...captures[2], part: 2, logger, signal }],
]);
await expect(access(outputDirectory)).rejects.toThrow();
});
it('does not fail the step without a device run session, and still removes the directory', async () => {
const outputDirectory = await mkdtemp(path.join(os.tmpdir(), 'serve-sim-network-capture-'));
jest.mocked(ServeSimNetworkCaptureRecorder.finishAsync).mockResolvedValueOnce({
outputDirectory,
captures: [{ udid: 'SIM-A', filePath: path.join(outputDirectory, 'SIM-A-1.har'), size: 24 }],
});
const { fn } = createCollectServeSimNetworkCaptureBuildFunction(ctx) as unknown as { fn: Fn };
await expect(runFn(fn, { env: {} as BuildStepEnv })).resolves.toBeUndefined();
expect(uploadServeSimNetworkCaptureFileAsync).not.toHaveBeenCalled();
expect(logger.warn).toHaveBeenCalledWith(
{ err: expect.any(Error) },
'Could not upload the network capture.'
);
await expect(access(outputDirectory)).rejects.toThrow();
});
it('skips the upload when nothing was recorded', async () => {
jest
.mocked(ServeSimNetworkCaptureRecorder.finishAsync)
.mockResolvedValueOnce({ outputDirectory: null, captures: [] });
const { fn } = createCollectServeSimNetworkCaptureBuildFunction(ctx) as unknown as { fn: Fn };
await runFn(fn, { env: { DEVICE_RUN_SESSION_ID: 'drs-id' } as BuildStepEnv });
expect(uploadServeSimNetworkCaptureFileAsync).not.toHaveBeenCalled();
expect(logger.info).toHaveBeenCalledWith('No network capture was recorded; skipping upload.');
});
@@ -216,6 +216,36 @@ describe('runAgentDeviceRemoteSessionAsync orchestration', () => {
);
});
it.each([
[
BuildRuntimePlatform.DARWIN,
{
iosSimulatorUdid: 'selected-udid',
application: Promise.resolve({
installAppPath: '/tmp/App.app',
launchAppIdentifier: 'com.example.archive',
}),
},
],
[
BuildRuntimePlatform.LINUX,
{ booted: Promise.resolve(), ready: Promise.resolve('com.example.archive') },
],
])(
'reports the identifier of the app the %s device launched',
async (runtimePlatform, device) => {
const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
await runAsync(logger, runtimePlatform, { device });
expect(uploadRemoteSessionConfigAsync).toHaveBeenCalledWith(
expect.objectContaining({
remoteConfig: expect.objectContaining({ applicationIdentifier: 'com.example.archive' }),
})
);
}
);
it('uses the warm daemon after adoption and starts no daemon of its own', async () => {
const logger = { info: jest.fn(), warn: jest.fn(), child: jest.fn().mockReturnThis() };
const warmServer = { port: 3200 } as never;
@@ -517,6 +517,10 @@ describe(createStartAgentDeviceSessionBuildFunction, () => {
expect(launchApplicationAsync).toHaveBeenCalledWith(
expect.objectContaining({ applicationIdentifier: 'dev.example.app', activityName: '.Main' })
);
// The remote session reports it so clients can attach to an archive session's app.
await expect((sessionDevice() as { ready: Promise<unknown> }).ready).resolves.toBe(
'dev.example.app'
);
});
it('stops the download and waits for it when Android boot fails', async () => {
@@ -0,0 +1,62 @@
import { BuildFunction, BuildRuntimePlatform } from '@expo/steps';
import { rm } from 'node:fs/promises';
import { type CustomBuildContext } from '../../customBuildContext';
import { Sentry } from '../../sentry';
import { getDeviceRunSessionIdOrThrow } from '../utils/remoteDeviceRunSession';
import { uploadServeSimCrashesFileAsync } from '../utils/serveSimCrashesArtifacts';
import { ServeSimCrashesRecorder } from '../utils/serveSimCrashesRecorder';
const UPLOAD_TIMEOUT_MS = 30_000;
export function createCollectServeSimCrashesBuildFunction(ctx: CustomBuildContext): BuildFunction {
return new BuildFunction({
namespace: 'eas',
id: 'collect_serve_sim_crashes',
name: 'Collect serve-sim simulator crashes',
__metricsId: 'eas/collect_serve_sim_crashes',
supportedRuntimePlatforms: [BuildRuntimePlatform.DARWIN],
fn: async ({ logger }, { env }) => {
let outputDirectory: string | null = null;
try {
const collected = await ServeSimCrashesRecorder.finishAsync();
outputDirectory = collected.outputDirectory;
if (collected.crashes.length === 0) {
logger.info('No simulator crashes collected; skipping upload.');
return;
}
const deviceRunSessionId = getDeviceRunSessionIdOrThrow(env);
for (const udid of new Set(collected.crashes.map(crash => crash.udid))) {
const signal = AbortSignal.timeout(UPLOAD_TIMEOUT_MS);
for (const crash of collected.crashes.filter(crash => crash.udid === udid)) {
if (signal.aborted) {
logger.warn(
`Simulator crash upload reached its time limit for ${udid}; remaining reports will not be uploaded.`
);
break;
}
await uploadServeSimCrashesFileAsync(ctx, {
deviceRunSessionId,
crash,
logger,
signal,
});
}
}
} catch (err) {
const error = err instanceof Error ? err : new Error(String(err));
Sentry.capture('Could not finalize serve-sim simulator crashes', error);
logger.warn(
{ err: error },
'Could not finalize simulator crashes; the session result is unchanged.'
);
} finally {
if (outputDirectory) {
await rm(outputDirectory, { recursive: true, force: true }).catch(err => {
logger.warn({ err }, 'Could not remove the simulator crash directory.');
});
}
}
},
});
}
@@ -0,0 +1,63 @@
import { BuildFunction, BuildRuntimePlatform } from '@expo/steps';
import { rm } from 'node:fs/promises';
import { type CustomBuildContext } from '../../customBuildContext';
import { Sentry } from '../../sentry';
import { getDeviceRunSessionIdOrThrow } from '../utils/remoteDeviceRunSession';
import { uploadServeSimNetworkCaptureFileAsync } from '../utils/serveSimNetworkCaptureArtifacts';
import { ServeSimNetworkCaptureRecorder } from '../utils/serveSimNetworkCaptureRecorder';
// Each HAR may be up to 500 MiB, so one slow upload gets its own long limit.
const UPLOAD_TIMEOUT_MS = 10 * 60 * 1000;
export function createCollectServeSimNetworkCaptureBuildFunction(
ctx: CustomBuildContext
): BuildFunction {
return new BuildFunction({
namespace: 'eas',
id: 'collect_serve_sim_network_capture',
name: 'Collect serve-sim network capture',
__metricsId: 'eas/collect_serve_sim_network_capture',
supportedRuntimePlatforms: [BuildRuntimePlatform.DARWIN],
fn: async ({ logger }, { env }) => {
const { outputDirectory, captures } = await ServeSimNetworkCaptureRecorder.finishAsync({
logger,
});
try {
if (captures.length === 0) {
logger.info('No network capture was recorded; skipping upload.');
return;
}
const deviceRunSessionId = getDeviceRunSessionIdOrThrow(env);
// A device's HARs are numbered parts, one per capture har run that recorded requests.
const parts = new Map<string, number>();
for (const { udid, filePath, size } of captures) {
const part = (parts.get(udid) ?? 0) + 1;
parts.set(udid, part);
await uploadServeSimNetworkCaptureFileAsync(ctx, {
deviceRunSessionId,
udid,
filePath,
size,
part,
logger,
signal: AbortSignal.timeout(UPLOAD_TIMEOUT_MS),
});
}
} catch (err) {
const error = err instanceof Error ? err : new Error(String(err));
Sentry.capture('Could not upload the network capture', error);
logger.warn({ err: error }, 'Could not upload the network capture.');
} finally {
if (outputDirectory) {
await rm(outputDirectory, { recursive: true, force: true }).catch(err => {
logger.warn(
{ err },
`Could not remove the network capture directory ${outputDirectory}.`
);
});
}
}
},
});
}
@@ -126,7 +126,8 @@ export async function runAgentDeviceRemoteSessionAsync(
device:
| {
booted: Promise<unknown>;
ready: Promise<unknown>;
/** Resolves with the identifier of the app it installed, if any. */
ready: Promise<string | void>;
}
| {
iosSimulatorUdid: string;
@@ -244,6 +245,7 @@ export async function runAgentDeviceRemoteSessionAsync(
const [
{ port: daemonPort, token: daemonToken, remoteSessionUrl: agentDeviceRemoteSessionUrl },
webPreview,
installedApplicationIdentifier,
] = await Promise.all([agentDeviceStartup, sessionHostStartup, deviceReady]).catch(
(err: unknown) => {
// Also aborts for a `device.ready` that does not come from `tasks.run`.
@@ -253,6 +255,11 @@ export async function runAgentDeviceRemoteSessionAsync(
);
tasks.signal.throwIfAborted();
logger.info(tasks.summary());
// Reported so clients can attach to the app of a session with no build record, like an
// `application_archive_url` one. The session host already launched the iOS app.
const applicationIdentifier = hostBootedDevice?.application
? (await tasks.untilAborted(hostBootedDevice.application))?.launchAppIdentifier
: installedApplicationIdentifier;
const sessionStart = await uploadRemoteSessionConfigWithLocalEgressAsync({
env,
@@ -265,6 +272,7 @@ export async function runAgentDeviceRemoteSessionAsync(
webPreviewUrl: webPreview.previewPageUrl,
previewApiUrl: webPreview.apiUrl,
...(webPreview.previewToken ? { webPreviewToken: webPreview.previewToken } : {}),
...(applicationIdentifier ? { applicationIdentifier } : {}),
},
logger,
});
@@ -226,6 +226,7 @@ export function createStartAgentDeviceSessionBuildFunction(
let sessionOwnsTeardown = false;
let downloaded: Promise<string> | undefined;
let applicationReady: Promise<ServeSimApplicationOptions | void> | undefined;
let installedAndroidApplication: Promise<string> | undefined;
try {
if (isIos) {
@@ -321,7 +322,7 @@ export function createStartAgentDeviceSessionBuildFunction(
installAppPath,
});
} else if (!isIos && (installAppPath || downloadedApp)) {
applicationReady = tasks.run('app install and launch', async taskLogger => {
installedAndroidApplication = tasks.run('app install and launch', async taskLogger => {
await tasks.untilAborted(booted!);
const artifactPath = installAppPath ?? (await downloadedApp);
if (!artifactPath) {
@@ -344,6 +345,7 @@ export function createStartAgentDeviceSessionBuildFunction(
env,
logger: taskLogger,
});
return applicationIdentifier;
});
}
@@ -374,7 +376,7 @@ export function createStartAgentDeviceSessionBuildFunction(
}
: {
booted,
ready: applicationReady ?? tasks.untilAborted(booted),
ready: installedAndroidApplication ?? tasks.untilAborted(booted),
},
});
} catch (error) {
@@ -388,7 +390,12 @@ export function createStartAgentDeviceSessionBuildFunction(
throw error;
} finally {
tasks.abort(new Error('Agent-device session ended.'));
await Promise.allSettled([booted, downloaded, applicationReady]);
await Promise.allSettled([
booted,
downloaded,
applicationReady,
installedAndroidApplication,
]);
}
};
try {
@@ -0,0 +1,26 @@
import { BuildFunction, BuildRuntimePlatform } from '@expo/steps';
import { Sentry } from '../../sentry';
import { ServeSimCrashesRecorder } from '../utils/serveSimCrashesRecorder';
export function createStartServeSimCrashesBuildFunction(): BuildFunction {
return new BuildFunction({
namespace: 'eas',
id: 'start_serve_sim_crashes',
name: 'Start serve-sim simulator crashes',
__metricsId: 'eas/start_serve_sim_crashes',
supportedRuntimePlatforms: [BuildRuntimePlatform.DARWIN],
fn: async ({ logger }) => {
try {
await ServeSimCrashesRecorder.startAsync({ logger });
} catch (err) {
const error = err instanceof Error ? err : new Error(String(err));
Sentry.capture('Could not start serve-sim simulator crashes', error);
logger.warn(
{ err: error },
'Could not start simulator crash collection; the session will continue.'
);
}
},
});
}
@@ -0,0 +1,39 @@
import {
BuildFunction,
BuildRuntimePlatform,
BuildStepInput,
BuildStepInputValueTypeName,
} from '@expo/steps';
import { Sentry } from '../../sentry';
import { ServeSimNetworkCaptureRecorder } from '../utils/serveSimNetworkCaptureRecorder';
export function createStartServeSimNetworkCaptureBuildFunction(): BuildFunction {
return new BuildFunction({
namespace: 'eas',
id: 'start_serve_sim_network_capture',
name: 'Start serve-sim network capture',
__metricsId: 'eas/start_serve_sim_network_capture',
supportedRuntimePlatforms: [BuildRuntimePlatform.DARWIN],
inputProviders: [
BuildStepInput.createProvider({
id: 'package_version',
required: false,
allowedValueTypeName: BuildStepInputValueTypeName.STRING,
}),
],
fn: async ({ logger }, { inputs, env }) => {
try {
await ServeSimNetworkCaptureRecorder.startAsync({
logger,
env,
packageVersion: inputs.package_version.value as string | undefined,
});
} catch (err) {
const error = err instanceof Error ? err : new Error(String(err));
Sentry.capture('Could not start the serve-sim network capture recorder', error);
logger.warn({ err: error }, 'Could not start the serve-sim network capture recorder.');
}
},
});
}
@@ -47,9 +47,11 @@ import {
} from '../serveSimActions';
import { startPreviewActivityPolling } from '../previewActivity';
import { readServeSimServersAsync } from '../serveSimMetricsRecorder';
import { ServeSimCrashesRecorder } from '../serveSimCrashesRecorder';
import * as previewCapture from '../serveSimPreviewCapture';
jest.mock('@ngrok/ngrok');
jest.mock('../serveSimCrashesRecorder');
jest.mock('@expo/turtle-spawn');
jest.mock('../../../utils/IosSimulatorUtils', () => ({
IosSimulatorUtils: { disableApsdAsync: jest.fn(), waitForReadyAsync: jest.fn() },
@@ -152,6 +154,7 @@ const stopSessionPreview = jest.fn();
beforeEach(() => {
jest.clearAllMocks();
jest.mocked(ServeSimCrashesRecorder.stopAsync).mockReset().mockResolvedValue(undefined);
jest
.mocked(startNgrokTunnelAsync)
.mockReset()
@@ -2360,6 +2363,22 @@ it('cancels an in-flight install while Simulator setup is pending', async () =>
expect(stopServer).toHaveBeenCalledTimes(1);
});
it('finishes in-flight crash collection before stopping the host', async () => {
const host = await startHostAsync();
const collecting = deferred<void>();
const entered = deferred<void>();
jest.mocked(ServeSimCrashesRecorder.stopAsync).mockImplementationOnce(async () => {
entered.resolve();
await collecting.promise;
});
const finishing = host.finishAsync();
await entered.promise;
expect(stopServer).not.toHaveBeenCalled();
collecting.resolve();
await finishing;
expect(stopServer).toHaveBeenCalledTimes(1);
});
it('redacts bearer tokens from preview readiness diagnostics while preserving the failure', async () => {
const output = [
'Native addon failed to initialize',
@@ -0,0 +1,69 @@
import type { bunyan } from '@expo/logger';
import { mkdtemp, writeFile } from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import type { CustomBuildContext } from '../../../customBuildContext';
import { Sentry } from '../../../sentry';
import { uploadDeviceRunSessionArtifactAsync } from '../deviceRunSessionArtifacts';
import { uploadServeSimCrashesFileAsync } from '../serveSimCrashesArtifacts';
jest.mock('../../../sentry');
jest.mock('../deviceRunSessionArtifacts');
jest.unmock('fs');
jest.unmock('node:fs');
jest.unmock('fs/promises');
jest.unmock('node:fs/promises');
const ctx = {} as CustomBuildContext;
const logger = { info: jest.fn(), warn: jest.fn() } as unknown as bunyan;
let crash: { udid: string; filePath: string; size: number; number: number };
beforeAll(async () => {
const filePath = path.join(await mkdtemp(path.join(os.tmpdir(), 'crash-test-')), 'A-2.ips');
await writeFile(filePath, '{"app_name":"Crash"}');
crash = { udid: 'ABCDEF123456', filePath, size: 20, number: 2 };
});
beforeEach(() => {
jest.clearAllMocks();
});
it.each([
[undefined, 'Crash report 2 (ABCDEF12)', 'crash-2.ips'],
['My/App:Beta\n', 'Crash report 2: My/App:Beta\n (ABCDEF12)', 'My-App-Beta--2.ips'],
])('names the report for process %j', async (processName, name, filename) => {
await uploadServeSimCrashesFileAsync(ctx, {
deviceRunSessionId: 'drs-id',
crash: { ...crash, ...(processName ? { processName } : {}) },
logger,
});
expect(uploadDeviceRunSessionArtifactAsync).toHaveBeenCalledWith(ctx, {
deviceRunSessionId: 'drs-id',
artifactId: 'simulator-crash-ABCDEF123456-2',
name,
filename,
kind: 'simulator-crash',
metadata: { __eas_type: 'simulator-crash', udid: 'ABCDEF123456', source: 'serve-sim/crashes' },
size: 20,
openStream: expect.any(Function),
signal: expect.any(AbortSignal),
attempts: 3,
});
});
it('reports a failed upload by report number without rejecting', async () => {
jest.mocked(uploadDeviceRunSessionArtifactAsync).mockRejectedValueOnce(new Error('offline'));
await expect(
uploadServeSimCrashesFileAsync(ctx, { deviceRunSessionId: 'drs-id', crash, logger })
).resolves.toBeUndefined();
expect(Sentry.capture).toHaveBeenCalledWith(
'Could not upload a simulator crash report',
expect.objectContaining({ message: 'offline' }),
{ level: 'warning' }
);
expect(logger.warn).toHaveBeenCalledWith(
{ err: expect.objectContaining({ message: 'offline' }) },
'Could not upload crash report 2 for ABCDEF123456; other artifacts will continue.'
);
});
@@ -0,0 +1,816 @@
import { type bunyan } from '@expo/logger';
import { mkdtemp, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
import { type IncomingMessage, type Server, type ServerResponse, createServer } from 'node:http';
import { type AddressInfo } from 'node:net';
import os from 'node:os';
import path from 'node:path';
import { setTimeout as delay } from 'node:timers/promises';
import { type CustomBuildContext } from '../../../customBuildContext';
import { DEVICE_RUN_SESSION_TOKEN_HEADER } from '../deviceRunSessionWorkerApi';
import { uploadServeSimCrashesFileAsync } from '../serveSimCrashesArtifacts';
import { ServeSimCrashesRecorder } from '../serveSimCrashesRecorder';
import * as serveSimServers from '../serveSimMetricsRecorder';
jest.mock('../../../sentry');
jest.unmock('fs');
jest.unmock('node:fs');
jest.unmock('fs/promises');
jest.unmock('node:fs/promises');
jest.unmock('node-fetch');
const fs = jest.requireActual<typeof import('node:fs/promises')>('node:fs/promises');
const logger = { info: jest.fn(), warn: jest.fn() } as unknown as bunyan;
let directory: string;
let server: Server;
let baseUrl: string;
const summary = { id: 'crash/a', appName: 'Fixture', occurrenceTimes: [{ key: 1 }, { key: 2 }] };
const report = (key: number) =>
JSON.stringify({ app_name: 'Fixture 서울 🌲', incident_id: `INC-${key}` }) +
'\n' +
JSON.stringify({ exception: { type: 'EXC_CRASH', signal: 'SIGABRT' }, incident: `INC-${key}` }) +
'\n';
const detail = (key: number) => ({
record: { id: summary.id, bundleId: 'dev.expo.fixture' },
occurrence: { key, incidentId: `INC-${key}`, logTail: ['PRIVATE APP LOG'], pid: 123 },
report: report(key),
reportError: null,
});
/** Answers the one-shot list that stopping reads; returns false for other requests. */
function answerList(
request: IncomingMessage,
response: ServerResponse,
crashes: unknown[] = []
): boolean {
if (request.headers.accept !== 'application/json') {
return false;
}
response.setHeader('Content-Type', 'application/json');
response.end(JSON.stringify({ meta: { statusError: null }, crashes }));
return true;
}
function stoppedRetrying(): boolean {
return jest
.mocked(logger.warn)
.mock.calls.some(([message]) =>
String(message).startsWith('Stopped retrying simulator crash collection')
);
}
async function waitFor(read: () => boolean | Promise<boolean>): Promise<void> {
for (let i = 0; i < 200; i++) {
if (await read()) {
return;
}
await delay(10);
}
throw new Error('Timed out waiting for crash recording');
}
async function start(maxBytes?: number): Promise<void> {
await writeFile(
path.join(directory, 'server-device-A.json'),
JSON.stringify({
device: 'device-A',
url: baseUrl,
token: 'test-token',
})
);
await ServeSimCrashesRecorder.startAsync({
logger,
stateDir: directory,
pollIntervalMs: 10,
maxBytes,
});
}
beforeEach(async () => {
directory = await mkdtemp(path.join(os.tmpdir(), 'crashes-http-test-'));
server = createServer();
await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
baseUrl = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
});
afterEach(async () => {
const { outputDirectory } = await ServeSimCrashesRecorder.finishAsync();
if (outputDirectory) {
await rm(outputDirectory, { recursive: true, force: true });
}
server.closeAllConnections();
await new Promise<void>(resolve => server.close(() => resolve()));
await rm(directory, { recursive: true, force: true });
});
it('saves recurrences as separate private IPS files and uploads unchanged reports without app logs', async () => {
let connections = 0;
let requests = 0;
const uploaded: Buffer[] = [];
let uploadAttempts = 0;
const uploadInputs: { filename: string }[] = [];
server.on('request', (request, response) => {
if (request.url === '/v2/device-run-session-worker/artifact-upload-sessions') {
expect(request.method).toBe('POST');
expect(request.headers[DEVICE_RUN_SESSION_TOKEN_HEADER]).toBe('worker-token');
const chunks: Buffer[] = [];
request.on('data', chunk => chunks.push(chunk));
request.on('end', () => {
uploadInputs.push(JSON.parse(Buffer.concat(chunks).toString()));
response.setHeader('Content-Type', 'application/json');
response.end(
JSON.stringify({ data: { uploadSession: { url: baseUrl + '/upload', headers: {} } } })
);
});
return;
}
if (request.method === 'PUT') {
const chunks: Buffer[] = [];
request.on('data', chunk => chunks.push(chunk));
request.on('end', () => {
uploaded.push(Buffer.concat(chunks));
uploadAttempts += 1;
response.writeHead(uploadAttempts === 1 ? 503 : 200).end();
});
return;
}
expect(request.headers.authorization).toBe('Bearer test-token');
const url = new URL(request.url!, baseUrl);
expect(url.searchParams.get('device')).toBe('device-A');
if (answerList(request, response, [summary])) {
return;
}
if (url.pathname === '/crashes') {
expect(url.searchParams.has('tail')).toBe(false);
expect(request.headers.accept).toBe('text/event-stream');
connections += 1;
response.writeHead(200, { 'Content-Type': 'text/event-stream' });
const initial = { ...summary, occurrenceTimes: [{ key: 1 }] };
const wire = `data: ${JSON.stringify({ type: 'list', crashes: [initial] })}\r\n\r\n`;
if (connections === 1) {
response.end(wire);
} else {
response.write(
wire + `data: ${JSON.stringify({ type: 'recurred', record: summary })}\r\n\r\n`
);
}
} else {
expect(url.pathname).toBe('/crashes/crash%2Fa');
requests += 1;
response.end(JSON.stringify(detail(Number(url.searchParams.get('key')))));
}
});
await start();
await waitFor(() => requests === 2);
await ServeSimCrashesRecorder.stopAsync();
const { crashes: files } = await ServeSimCrashesRecorder.finishAsync();
expect(files).toHaveLength(2);
expect(requests).toBe(2);
const expected = [Buffer.from(report(1)), Buffer.from(report(2))];
for (const [index, file] of files.entries()) {
expect(path.extname(file.filePath)).toBe('.ips');
expect(await readFile(file.filePath)).toEqual(expected[index]);
expect((await stat(file.filePath)).mode & 0o777).toBe(0o600);
expect((await stat(path.dirname(file.filePath))).mode & 0o777).toBe(0o700);
}
expect(files[0].filePath).not.toBe(files[1].filePath);
const context = {
env: { EAS_DEVICE_RUN_SESSION_TOKEN: 'worker-token' },
expoApiV2BaseUrl: baseUrl + '/v2/',
} as unknown as CustomBuildContext;
for (const crash of files) {
await uploadServeSimCrashesFileAsync(context, {
deviceRunSessionId: 'session-id',
crash,
logger,
});
}
expect(uploaded).toEqual([expected[0], expected[0], expected[1]]);
expect(uploadAttempts).toBe(3);
expect(uploadInputs.map(input => input.filename)).toEqual(['Fixture-1.ips', 'Fixture-2.ips']);
expect(uploadInputs[0]).toMatchObject({
name: 'Crash report 1: Fixture (device-A)',
kind: 'simulator-crash',
metadata: { __eas_type: 'simulator-crash', udid: 'device-A', source: 'serve-sim/crashes' },
});
expect(JSON.stringify(uploadInputs)).not.toContain('PRIVATE APP LOG');
expect(await ServeSimCrashesRecorder.finishAsync()).toEqual({
outputDirectory: null,
crashes: [],
});
await rm(path.dirname(files[0].filePath), { recursive: true, force: true });
});
it('keeps an in-flight report download alive during stop and waits for its write', async () => {
let requested = false;
let finishReport: () => void = () => {};
server.on('request', (request, response) => {
if (request.url!.startsWith('/crashes?')) {
response.writeHead(200, { 'Content-Type': 'text/event-stream' });
response.write(`data: ${JSON.stringify({ type: 'crash', record: summary })}\n\n`);
} else {
requested = true;
finishReport = () => response.end(JSON.stringify(detail(1)));
}
});
await start();
await waitFor(() => requested);
const stopped = ServeSimCrashesRecorder.stopAsync();
finishReport();
await stopped;
const { crashes: files } = await ServeSimCrashesRecorder.finishAsync();
expect(await readFile(files[0].filePath, 'utf8')).toBe(report(1));
await rm(path.dirname(files[0].filePath), { recursive: true, force: true });
});
it('closes a rejected stream socket and produces no artifact for an empty session', async () => {
let closed = false;
server.on('request', (request, response) => {
request.socket.on('close', () => {
closed = true;
});
response.writeHead(403).write('unfinished response');
});
await start();
await waitFor(() => closed);
const collected = await ServeSimCrashesRecorder.finishAsync();
expect(collected.crashes).toEqual([]);
expect(collected.outputDirectory).toEqual(expect.any(String));
await rm(collected.outputDirectory!, { recursive: true, force: true });
expect(JSON.stringify(jest.mocked(logger.warn).mock.calls)).not.toContain('test-token');
});
it('stops at a complete-record byte limit and keeps earlier reports', async () => {
let requested = 0;
server.on('request', (request, response) => {
if (request.url!.startsWith('/crashes?')) {
response.writeHead(200, { 'Content-Type': 'text/event-stream' });
response.write(`data: ${JSON.stringify({ type: 'list', crashes: [summary] })}\n\n`);
} else {
requested += 1;
response.end(
JSON.stringify(detail(Number(new URL(request.url!, baseUrl).searchParams.get('key'))))
);
}
});
await writeFile(
path.join(directory, 'server-device-A.json'),
JSON.stringify({ device: 'device-A', url: baseUrl })
);
await ServeSimCrashesRecorder.startAsync({
logger,
stateDir: directory,
pollIntervalMs: 10,
maxBytes: Buffer.byteLength(report(1)),
});
await waitFor(() => requested === 2);
await ServeSimCrashesRecorder.stopAsync();
const { crashes: files } = await ServeSimCrashesRecorder.finishAsync();
expect(await readFile(files[0].filePath, 'utf8')).toBe(report(1));
expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('reached its limit'));
await rm(path.dirname(files[0].filePath), { recursive: true, force: true });
});
it.each([
[
'fails on every request',
3,
'Could not download crash occurrence 1 for device-A; skipping it.',
(response: ServerResponse) => response.writeHead(500).end(),
],
[
'is refused with a permanent 4xx',
1,
'Could not download crash occurrence 1 for device-A; skipping it.',
(response: ServerResponse) => response.writeHead(400).end(),
],
[
'is not valid JSON',
1,
'Could not download crash occurrence 1 for device-A; skipping it.',
(response: ServerResponse) => response.end('{broken'),
],
[
'exceeds 8 MiB',
1,
'Could not download crash occurrence 1 for device-A; skipping it.',
(response: ServerResponse) =>
response.end(JSON.stringify({ ...detail(1), report: 'x'.repeat(8 * 1024 * 1024) })),
],
[
'does not match the occurrence',
1,
'Could not download crash occurrence 1 for device-A; skipping it.',
(response: ServerResponse) => response.end(JSON.stringify(detail(2))),
],
[
'is no longer kept',
1,
'Crash occurrence 1 is no longer available for device-A; earlier reports will be retained.',
(response: ServerResponse) => response.writeHead(404).end(),
],
])(
'skips an occurrence whose detail %s after %i attempts and keeps collecting the device',
async (_name, attempts, warning, respond) => {
let connections = 0;
let badRequests = 0;
server.on('request', (request, response) => {
const url = new URL(request.url!, baseUrl);
if (answerList(request, response)) {
return;
}
if (url.pathname === '/crashes') {
connections += 1;
response.writeHead(200, { 'Content-Type': 'text/event-stream' });
// Every stream ends, so each reconnect replays the bad occurrence.
response.end(
`data: ${JSON.stringify({
type: 'list',
crashes: [
{ id: 'crash/b', occurrenceTimes: [{ key: 1 }] },
{ ...summary, occurrenceTimes: [{ key: 1 }] },
],
})}\n\n`
);
} else if (url.pathname === '/crashes/crash%2Fb') {
badRequests += 1;
respond(response);
} else {
response.end(JSON.stringify(detail(1)));
}
});
await start();
await waitFor(() => connections >= 12);
const collected = await ServeSimCrashesRecorder.finishAsync();
expect(badRequests).toBe(attempts);
expect(stoppedRetrying()).toBe(false);
expect(jest.mocked(logger.warn).mock.calls.filter(call => call.includes(warning))).toHaveLength(
1
);
expect(collected.crashes).toHaveLength(1);
expect(await readFile(collected.crashes[0].filePath, 'utf8')).toBe(report(1));
await rm(collected.outputDirectory!, { recursive: true, force: true });
}
);
it('saves an occurrence whose detail fails once, without reconnecting', async () => {
let connections = 0;
let requests = 0;
server.on('request', (request, response) => {
if (answerList(request, response)) {
return;
}
if (request.url!.startsWith('/crashes?')) {
connections += 1;
response.writeHead(200, { 'Content-Type': 'text/event-stream' });
response.write(
`data: ${JSON.stringify({ type: 'list', crashes: [{ ...summary, occurrenceTimes: [{ key: 1 }] }] })}\n\n`
);
} else {
requests += 1;
if (requests === 1) {
response.writeHead(503).end();
} else {
response.end(JSON.stringify(detail(1)));
}
}
});
await start();
await waitFor(() => requests === 2);
const collected = await ServeSimCrashesRecorder.finishAsync();
expect(connections).toBe(1);
expect(collected.crashes).toHaveLength(1);
expect(await readFile(collected.crashes[0].filePath, 'utf8')).toBe(report(1));
expect(logger.warn).not.toHaveBeenCalledWith(
expect.anything(),
expect.stringContaining('Could not download')
);
await rm(collected.outputDirectory!, { recursive: true, force: true });
});
it('collects an occurrence listed after the stream last delivered, when stopping', async () => {
let streaming = false;
server.on('request', (request, response) => {
const url = new URL(request.url!, baseUrl);
const listed = { ...summary, appName: '', procName: 'FixtureProcess' };
if (answerList(request, response, [{ ...listed, occurrenceTimes: [{ key: 1 }] }])) {
return;
}
if (url.pathname === '/crashes') {
streaming = true;
response.writeHead(200, { 'Content-Type': 'text/event-stream' });
response.write(`data: ${JSON.stringify({ type: 'list', crashes: [] })}\n\n`);
} else {
response.end(JSON.stringify(detail(1)));
}
});
await start();
await waitFor(() => streaming);
const collected = await ServeSimCrashesRecorder.finishAsync();
expect(collected.crashes).toEqual([
{
udid: 'device-A',
filePath: path.join(collected.outputDirectory!, 'device-A-1.ips'),
size: Buffer.byteLength(report(1)),
number: 1,
processName: 'FixtureProcess',
},
]);
expect(await readFile(collected.crashes[0].filePath, 'utf8')).toBe(report(1));
await rm(collected.outputDirectory!, { recursive: true, force: true });
});
it('stops the final pass at its deadline and warns', async () => {
let streaming = false;
server.on('request', (request, response) => {
if (answerList(request, response, [{ ...summary, occurrenceTimes: [{ key: 1 }] }])) {
return;
}
if (request.url!.startsWith('/crashes?')) {
streaming = true;
response.writeHead(200, { 'Content-Type': 'text/event-stream' });
response.write(`data: ${JSON.stringify({ type: 'list', crashes: [] })}\n\n`);
}
// The detail never answers.
});
await writeFile(
path.join(directory, 'server-device-A.json'),
JSON.stringify({ device: 'device-A', url: baseUrl, token: 'test-token' })
);
await ServeSimCrashesRecorder.startAsync({
logger,
stateDir: directory,
pollIntervalMs: 10,
finalPassTimeoutMs: 100,
});
await waitFor(() => streaming);
const collected = await ServeSimCrashesRecorder.finishAsync();
expect(collected.crashes).toEqual([]);
expect(logger.warn).toHaveBeenCalledWith(
'Stopped checking device-A for crashes at the end-of-session deadline; collected reports will be retained.'
);
await rm(collected.outputDirectory!, { recursive: true, force: true });
});
it('warns once per device when serve-sim cannot watch crash reports', async () => {
let connections = 0;
server.on('request', (_request, response) => {
connections += 1;
response.writeHead(200, { 'Content-Type': 'text/event-stream' });
response.end(
`data: ${JSON.stringify({ type: 'meta', meta: { statusError: 'EACCES' } })}\n\n` +
`data: ${JSON.stringify({ type: 'list', crashes: [] })}\n\n`
);
});
await start();
await waitFor(() => connections >= 3);
const collected = await ServeSimCrashesRecorder.finishAsync();
expect(
jest
.mocked(logger.warn)
.mock.calls.filter(([message]) => String(message).startsWith('serve-sim cannot watch'))
).toHaveLength(1);
await rm(collected.outputDirectory!, { recursive: true, force: true });
});
it.each([
['empty', ''],
['heartbeat-only', ': heartbeat\n\n'],
['meta-only', `data: ${JSON.stringify({ type: 'meta', meta: { statusError: null } })}\n\n`],
['invalid JSON', 'data: {invalid}\n\n'],
['invalid frame', 'data: {"type":"list","crashes":false}\n\n'],
])('stops retrying after ten %s streams', async (_name, payload) => {
let connections = 0;
server.on('request', (_request, response) => {
connections += 1;
response.writeHead(200, { 'Content-Type': 'text/event-stream' });
response.end(payload);
});
await start();
await waitFor(stoppedRetrying);
await delay(30);
expect(connections).toBe(10);
const collected = await ServeSimCrashesRecorder.finishAsync();
expect(collected.crashes).toEqual([]);
await rm(collected.outputDirectory!, { recursive: true, force: true });
});
it('keeps retrying streams that process a healthy empty crash list', async () => {
let connections = 0;
server.on('request', (_request, response) => {
connections += 1;
response.writeHead(200, { 'Content-Type': 'text/event-stream' });
const frame = `data: ${JSON.stringify({ type: 'list', crashes: [] })}\n\n`;
if (connections < 12) {
response.end(frame);
} else {
response.write(frame);
}
});
await start();
await waitFor(() => connections === 12);
expect(stoppedRetrying()).toBe(false);
});
it('recovers the same server after registry absence without resetting dedupe or the byte budget', async () => {
let connections = 0;
let healthy = false;
let expectAbsence = false;
let observedAbsence = false;
const keys: number[] = [];
const readServers = serveSimServers.readServeSimServersAsync;
const registry = jest
.spyOn(serveSimServers, 'readServeSimServersAsync')
.mockImplementation(async stateDir => {
const servers = await readServers(stateDir);
if (expectAbsence && servers.length === 0) {
observedAbsence = true;
}
return servers;
});
server.on('request', (request, response) => {
const url = new URL(request.url!, baseUrl);
if (url.pathname === '/crashes') {
connections += 1;
if (connections > 1 && !healthy) {
response.writeHead(503).end();
return;
}
response.writeHead(200, { 'Content-Type': 'text/event-stream' });
const record = {
...summary,
occurrenceTimes: healthy ? [{ key: 1 }, { key: 2 }, { key: 3 }] : [{ key: 1 }],
};
const frame = `data: ${JSON.stringify({ type: 'list', crashes: [record] })}\n\n`;
if (healthy) {
response.write(frame);
} else {
response.end(frame);
}
} else {
const key = Number(url.searchParams.get('key'));
keys.push(key);
response.end(JSON.stringify(detail(key)));
}
});
try {
const expected = report(1) + report(2);
await start(Buffer.byteLength(expected));
await waitFor(stoppedRetrying);
expect(connections).toBe(11);
expectAbsence = true;
await rm(path.join(directory, 'server-device-A.json'));
await waitFor(() => observedAbsence);
healthy = true;
await writeFile(
path.join(directory, 'server-device-A.json'),
JSON.stringify({
device: 'device-A',
url: baseUrl,
token: 'test-token',
})
);
await waitFor(() => keys.includes(3));
const collected = await ServeSimCrashesRecorder.finishAsync();
expect(connections).toBe(12);
expect(keys).toEqual([1, 2, 3]);
expect(collected.crashes).toHaveLength(2);
expect(
(await Promise.all(collected.crashes.map(file => readFile(file.filePath, 'utf8')))).join('')
).toBe(expected);
await rm(collected.outputDirectory!, { recursive: true, force: true });
} finally {
registry.mockRestore();
}
});
it('closes a stalled upload within its budget and lets another device upload', async () => {
const firstFile = path.join(directory, 'A.ips');
const secondFile = path.join(directory, 'B.ips');
await writeFile(firstFile, report(1));
const expected = Buffer.from(report(2));
await writeFile(secondFile, expected);
let firstClosed = false;
let firstRequests = 0;
let uploaded: Buffer | undefined;
let sessions = 0;
server.on('request', (request, response) => {
if (request.url === '/v2/device-run-session-worker/artifact-upload-sessions') {
expect(request.method).toBe('POST');
expect(request.headers[DEVICE_RUN_SESSION_TOKEN_HEADER]).toBe('worker-token');
request.resume();
request.on('end', () => {
response.setHeader('Content-Type', 'application/json');
response.end(
JSON.stringify({
data: {
uploadSession: {
url: baseUrl + (sessions++ === 0 ? '/stalled' : '/upload'),
headers: {},
},
},
})
);
});
return;
}
if (request.url === '/stalled') {
firstRequests += 1;
response.on('close', () => {
firstClosed = true;
});
request.resume();
} else {
const chunks: Buffer[] = [];
request.on('data', chunk => chunks.push(chunk));
request.on('end', () => {
uploaded = Buffer.concat(chunks);
response.end();
});
}
});
const context = {
env: { EAS_DEVICE_RUN_SESSION_TOKEN: 'worker-token' },
expoApiV2BaseUrl: baseUrl + '/v2/',
} as unknown as CustomBuildContext;
await uploadServeSimCrashesFileAsync(context, {
deviceRunSessionId: 'session-id',
crash: { udid: 'A', filePath: firstFile, size: Buffer.byteLength(report(1)), number: 1 },
logger,
signal: AbortSignal.timeout(50),
});
await waitFor(() => firstClosed);
expect(firstRequests).toBe(1);
expect(logger.warn).toHaveBeenCalledWith(
expect.any(Object),
'Could not upload crash report 1 for A; other artifacts will continue.'
);
await uploadServeSimCrashesFileAsync(context, {
deviceRunSessionId: 'session-id',
crash: { udid: 'B', filePath: secondFile, size: expected.length, number: 1 },
logger,
signal: AbortSignal.timeout(1_000),
});
expect(sessions).toBe(2);
expect(uploaded).toEqual(expected);
});
it.each([null, ''])(
'does not create an artifact when the native report is %s',
async nativeReport => {
let requested = false;
server.on('request', (request, response) => {
if (request.url!.startsWith('/crashes?')) {
response.writeHead(200, { 'Content-Type': 'text/event-stream' });
response.write(
`data: ${JSON.stringify({ type: 'list', crashes: [{ ...summary, occurrenceTimes: [{ key: 1 }] }] })}\n\n`
);
} else {
requested = true;
response.end(
JSON.stringify({ ...detail(1), report: nativeReport, reportError: 'Report unavailable' })
);
}
});
await start();
await waitFor(() => requested);
const collected = await ServeSimCrashesRecorder.finishAsync();
expect(collected.crashes).toEqual([]);
expect(await readdir(collected.outputDirectory!)).toEqual([]);
expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('has no native report'));
await rm(collected.outputDirectory!, { recursive: true, force: true });
}
);
it('does not duplicate a saved incident when a restarted serve-sim reuses occurrence keys', async () => {
let requested = 0;
server.on('request', (request, response) => {
if (answerList(request, response)) {
return;
}
// A restarted serve-sim numbers occurrences from 1 again; the capture time tells them apart.
const restarted = request.headers.authorization === 'Bearer new-token';
if (request.url!.startsWith('/crashes?')) {
response.writeHead(200, { 'Content-Type': 'text/event-stream' });
const occurrence = restarted
? { key: 1, capturedAtMs: 2_000, rawPath: '/DiagnosticReports/Fixture-2.ips' }
: { key: 1, capturedAtMs: 1_000, rawPath: '/DiagnosticReports/Fixture-1.ips' };
response.write(
`data: ${JSON.stringify({ type: 'list', crashes: [{ ...summary, occurrenceTimes: [occurrence] }] })}\n\n`
);
} else {
requested += 1;
response.end(JSON.stringify(detail(1)));
}
});
await start();
await waitFor(() => requested === 1);
await writeFile(
path.join(directory, 'server-device-A.json'),
JSON.stringify({ device: 'device-A', url: baseUrl, token: 'new-token' })
);
server.closeAllConnections();
await waitFor(() => requested === 2);
const collected = await ServeSimCrashesRecorder.finishAsync();
expect(collected.crashes).toHaveLength(1);
expect(await readFile(collected.crashes[0].filePath, 'utf8')).toBe(report(1));
await rm(collected.outputDirectory!, { recursive: true, force: true });
});
it('removes a partial file before retrying a failed write', async () => {
const write = fs.writeFile;
let attempted = 0;
const writing = jest.spyOn(fs, 'writeFile').mockImplementation(async (file, data, options) => {
if (String(file).endsWith('.ips') && attempted++ === 0) {
await write(file, 'partial report', options);
throw new Error('disk write failed');
}
await write(file, data, options);
});
server.on('request', (request, response) => {
if (request.url!.startsWith('/crashes?')) {
response.writeHead(200, { 'Content-Type': 'text/event-stream' });
response.write(
`data: ${JSON.stringify({ type: 'list', crashes: [{ ...summary, occurrenceTimes: [{ key: 1 }] }] })}\n\n`
);
} else {
response.end(JSON.stringify(detail(1)));
}
});
try {
await start();
await waitFor(() => attempted >= 2);
const collected = await ServeSimCrashesRecorder.finishAsync();
expect(collected.crashes).toHaveLength(1);
expect(await readdir(collected.outputDirectory!)).toEqual([
path.basename(collected.crashes[0].filePath),
]);
expect(await readFile(collected.crashes[0].filePath, 'utf8')).toBe(report(1));
await rm(collected.outputDirectory!, { recursive: true, force: true });
} finally {
writing.mockRestore();
}
});
it('keeps the report allowance and deduplicates reconnects after more missing reports than the allowance', async () => {
const missingCount = 1_001;
const requested: number[] = [];
let connections = 0;
let completed: (() => void) | undefined;
const processed = new Promise<void>(resolve => {
completed = resolve;
});
const occurrence = (key: number) => ({ ...summary, occurrenceTimes: [{ key }] });
server.on('request', (request, response) => {
if (answerList(request, response)) {
return;
}
if (request.url!.startsWith('/crashes?')) {
response.writeHead(200, { 'Content-Type': 'text/event-stream' });
connections += 1;
if (connections === 1) {
for (let key = 1; key <= missingCount; key++) {
response.write(
`data: ${JSON.stringify({ type: 'recurred', record: occurrence(key) })}\n\n`
);
}
} else {
const retained = {
...summary,
occurrenceTimes: Array.from({ length: 5 }, (_, index) => ({
key: missingCount - 4 + index,
})),
};
response.write(`data: ${JSON.stringify({ type: 'list', crashes: [retained] })}\n\n`);
}
if (connections < 3) {
response.end();
} else {
response.write(
`data: ${JSON.stringify({ type: 'recurred', record: occurrence(missingCount + 1) })}\n\n`
);
}
} else {
const key = Number(new URL(request.url!, baseUrl).searchParams.get('key'));
requested.push(key);
response.end(
JSON.stringify({ ...detail(key), report: key <= missingCount ? null : report(key) })
);
if (key === missingCount + 1) {
completed?.();
}
}
});
await start();
await processed;
const collected = await ServeSimCrashesRecorder.finishAsync();
try {
expect(connections).toBe(3);
expect(requested).toEqual(Array.from({ length: missingCount + 1 }, (_, index) => index + 1));
expect(collected.crashes).toHaveLength(1);
expect(await readFile(collected.crashes[0].filePath, 'utf8')).toBe(report(missingCount + 1));
expect(logger.warn).not.toHaveBeenCalledWith(expect.stringContaining('reached its limit'));
} finally {
await rm(collected.outputDirectory!, { recursive: true, force: true });
}
}, 15_000);
@@ -0,0 +1,94 @@
import type { bunyan } from '@expo/logger';
import { mkdtemp, writeFile } from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import type { CustomBuildContext } from '../../../customBuildContext';
import { Sentry } from '../../../sentry';
import { uploadDeviceRunSessionArtifactAsync } from '../deviceRunSessionArtifacts';
import { uploadServeSimNetworkCaptureFileAsync } from '../serveSimNetworkCaptureArtifacts';
jest.mock('../../../sentry');
jest.mock('../deviceRunSessionArtifacts');
const ctx = {} as CustomBuildContext;
const logger = { info: jest.fn(), warn: jest.fn() } as unknown as bunyan;
async function harAsync(name: string): Promise<string> {
const filePath = path.join(await mkdtemp(path.join(os.tmpdir(), 'network-capture-test-')), name);
await writeFile(filePath, '{"log":{"entries":[{}]}}');
return filePath;
}
beforeEach(() => {
jest.clearAllMocks();
jest.mocked(uploadDeviceRunSessionArtifactAsync).mockImplementation(async (_ctx, options) => {
options.openStream().destroy();
});
});
it.each([
[1, 'Network capture (ABCDEF12)'],
[2, 'Network capture (ABCDEF12, part 2)'],
])('uploads part %i as a network-capture artifact', async (part, name) => {
const filePath = await harAsync('A.har');
await uploadServeSimNetworkCaptureFileAsync(ctx, {
deviceRunSessionId: 'drs-id',
udid: 'ABCDEF123456',
filePath,
size: 24,
part,
logger,
});
expect(uploadDeviceRunSessionArtifactAsync).toHaveBeenCalledWith(ctx, {
deviceRunSessionId: 'drs-id',
artifactId: `network-capture-ABCDEF123456-${part}`,
name,
filename: 'network-capture.har',
kind: 'network-capture',
metadata: { __eas_type: 'network-capture', format: 'har', udid: 'ABCDEF123456', part },
size: 24,
openStream: expect.any(Function),
signal: expect.any(AbortSignal),
attempts: 3,
});
});
it('logs a failed upload without rejecting', async () => {
jest.mocked(uploadDeviceRunSessionArtifactAsync).mockRejectedValueOnce(new Error('offline'));
await expect(
uploadServeSimNetworkCaptureFileAsync(ctx, {
deviceRunSessionId: 'drs-id',
udid: 'A',
filePath: await harAsync('A.har'),
size: 24,
part: 1,
logger,
})
).resolves.toBeUndefined();
expect(logger.warn).toHaveBeenCalledWith(
{ err: expect.objectContaining({ message: 'offline' }) },
'Could not upload the network capture for A.'
);
expect(Sentry.capture).toHaveBeenCalledTimes(1);
});
it('accepts 500 MiB and skips larger HARs', async () => {
const limit = 500 * 1024 * 1024;
const filePath = await harAsync('A.har');
for (const size of [limit, limit + 1]) {
await uploadServeSimNetworkCaptureFileAsync(ctx, {
deviceRunSessionId: 'drs-id',
udid: 'A',
filePath,
size,
part: 1,
logger,
});
}
expect(uploadDeviceRunSessionArtifactAsync).toHaveBeenCalledTimes(1);
expect(logger.warn).toHaveBeenCalledWith(
'Skipping network capture for A: exceeds the 500 MB upload limit.'
);
expect(Sentry.capture).not.toHaveBeenCalled();
});
@@ -0,0 +1,606 @@
import { bunyan } from '@expo/logger';
import { type BuildStepEnv } from '@expo/steps';
import { appendFileSync, existsSync, writeFileSync } from 'node:fs';
import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import { setTimeout as delay } from 'node:timers/promises';
import { spawnDetached } from '../remoteDeviceRunSession';
import { ServeSimNetworkCaptureRecorder } from '../serveSimNetworkCaptureRecorder';
jest.mock('../../../sentry');
jest.mock('../remoteDeviceRunSession', () => ({
...jest.requireActual('../remoteDeviceRunSession'),
spawnDetached: jest.fn(),
}));
const logger = {
info: jest.fn(),
warn: jest.fn(),
error: jest.fn(),
debug: jest.fn(),
} as unknown as bunyan;
const env = {} as BuildStepEnv;
const stopFollower = jest.fn();
let stateDir: string;
async function writeServerAsync(udid: string, state: Record<string, unknown>): Promise<void> {
await writeFile(
path.join(stateDir, `server-${udid}.json`),
JSON.stringify({ device: udid, ...state })
);
}
/** Writes what `capture har` leaves: a HAR, and its entry log with one line per request. */
function record(harPath: string, entries: number): void {
writeFileSync(harPath, `${JSON.stringify({ log: { entries: Array(entries).fill({}) } })}\n`);
writeFileSync(harPath.replace(/\.har$/, '.entries.ndjson'), '{}\n'.repeat(entries));
}
type Request = { id: string; startedAt: number };
function entryFor({ id, startedAt }: Request) {
return {
startedDateTime: new Date(startedAt).toISOString(),
request: { url: `https://example.com/${id}` },
_captureId: id,
_captureStartedAt: startedAt,
};
}
/** Writes a recording as serve-sim does: entries by completion time, the HAR in start order. */
function recordRequests(harPath: string, requests: Request[]): void {
const entries = requests.map(entryFor);
const sorted = [...entries].sort((a, b) => a._captureStartedAt - b._captureStartedAt);
writeFileSync(
harPath,
`${JSON.stringify({
log: {
version: '1.2',
creator: { name: '@expo/serve-sim', version: '0.10.2' },
entries: sorted,
},
})}\n`
);
writeFileSync(
harPath.replace(/\.har$/, '.entries.ndjson'),
entries.map(entry => `${JSON.stringify(entry)}\n`).join('')
);
}
async function readHarAsync(harPath: string): Promise<any> {
return JSON.parse(await readFile(harPath, 'utf8'));
}
function followerArgs(): string[][] {
return jest.mocked(spawnDetached).mock.calls.map(([options]) => options.args);
}
async function waitForFollowersAsync(count: number): Promise<void> {
for (let i = 0; i < 300 && jest.mocked(spawnDetached).mock.calls.length < count; i++) {
await delay(10);
}
expect(spawnDetached).toHaveBeenCalledTimes(count);
}
beforeEach(async () => {
jest.clearAllMocks();
stopFollower.mockResolvedValue(undefined);
jest.mocked(spawnDetached).mockImplementation(() => ({
pid: 1234,
getOutput: () => 'Stopped before recording began.',
getExitError: () => undefined,
stopAsync: stopFollower,
}));
stateDir = await mkdtemp(path.join(os.tmpdir(), 'serve-sim-network-capture-test-'));
await mkdir(stateDir, { recursive: true });
});
afterEach(async () => {
await ServeSimNetworkCaptureRecorder.finishAsync({ logger });
await rm(stateDir, { recursive: true, force: true });
});
it('starts one capture har follower per serve-sim that can serve capture routes', async () => {
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await writeServerAsync('SIM-B', { url: 'http://127.0.0.1:4200' });
await ServeSimNetworkCaptureRecorder.startAsync({
logger,
env,
packageVersion: '0.5.0',
stateDir,
pollIntervalMs: 10,
});
await waitForFollowersAsync(1);
await delay(50);
expect(spawnDetached).toHaveBeenCalledTimes(1);
const [options] = jest.mocked(spawnDetached).mock.calls[0];
expect(options.command).toBe('npx');
expect(options.args).toEqual([
'--yes',
'@expo/[email protected]',
'capture',
'har',
'-o',
expect.stringMatching(/SIM-A-1\.har$/),
'-d',
'SIM-A',
]);
expect(options.stopGracePeriodMs).toBe(60_000);
});
it('does not pass the ngrok token to the follower', async () => {
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await ServeSimNetworkCaptureRecorder.startAsync({
logger,
env: { NGROK_AUTHTOKEN: 'ngrok-secret', PATH: '/usr/bin' } as BuildStepEnv,
stateDir,
pollIntervalMs: 10,
});
await waitForFollowersAsync(1);
expect(jest.mocked(spawnDetached).mock.calls[0][0].env).toEqual({ PATH: '/usr/bin' });
});
it('starts a new follower only when serve-sim restarts for the device', async () => {
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await ServeSimNetworkCaptureRecorder.startAsync({
logger,
env,
stateDir,
pollIntervalMs: 10,
packageVersion: '0.5.0',
});
await waitForFollowersAsync(1);
await delay(50);
expect(spawnDetached).toHaveBeenCalledTimes(1);
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-restarted' });
await waitForFollowersAsync(2);
expect(jest.mocked(spawnDetached).mock.calls[1][0].command).toBe('npx');
expect(followerArgs()[1]).toEqual([
'--yes',
'@expo/[email protected]',
'capture',
'har',
'-o',
expect.stringMatching(/SIM-A-2\.har$/),
'-d',
'SIM-A',
]);
});
it('stops every follower and returns only the HARs that hold requests', async () => {
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await writeServerAsync('SIM-B', { url: 'http://127.0.0.1:4200', token: 'token-b' });
await ServeSimNetworkCaptureRecorder.startAsync({ logger, env, stateDir, pollIntervalMs: 10 });
await waitForFollowersAsync(2);
const recorded = followerArgs().find(args => args.includes('SIM-A'))!;
record(recorded[recorded.indexOf('-o') + 1], 1);
// serve-sim writes an empty HAR when recording begins, before any request.
const empty = followerArgs().find(args => args.includes('SIM-B'))!;
record(empty[empty.indexOf('-o') + 1], 0);
const { outputDirectory, captures } = await ServeSimNetworkCaptureRecorder.finishAsync({
logger,
});
expect(stopFollower).toHaveBeenCalledTimes(2);
expect(captures).toEqual([
{ udid: 'SIM-A', filePath: recorded[recorded.indexOf('-o') + 1], size: 25 },
]);
expect(outputDirectory).toBe(path.dirname(captures[0].filePath));
expect(logger.info).toHaveBeenCalledWith(
{ output: 'Stopped before recording began.' },
'No network capture was recorded for SIM-B.'
);
});
it('stops followers in parallel', async () => {
let stopping = 0;
let mostAtOnce = 0;
stopFollower.mockImplementation(async () => {
stopping += 1;
mostAtOnce = Math.max(mostAtOnce, stopping);
await delay(20);
stopping -= 1;
});
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await writeServerAsync('SIM-B', { url: 'http://127.0.0.1:4200', token: 'token-b' });
await ServeSimNetworkCaptureRecorder.startAsync({ logger, env, stateDir, pollIntervalMs: 10 });
await waitForFollowersAsync(2);
await ServeSimNetworkCaptureRecorder.finishAsync({ logger });
expect(mostAtOnce).toBe(2);
});
it('keeps collecting when a follower cannot be stopped', async () => {
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await ServeSimNetworkCaptureRecorder.startAsync({ logger, env, stateDir, pollIntervalMs: 10 });
await waitForFollowersAsync(1);
stopFollower.mockRejectedValueOnce(new Error('EPERM'));
await expect(ServeSimNetworkCaptureRecorder.finishAsync({ logger })).resolves.toEqual({
outputDirectory: expect.any(String),
captures: [],
});
expect(logger.warn).toHaveBeenCalledWith(
{ err: expect.objectContaining({ message: 'EPERM' }) },
'Could not stop the network capture follower for SIM-A.'
);
});
it('returns nothing when the recorder never started', async () => {
await expect(ServeSimNetworkCaptureRecorder.finishAsync({ logger })).resolves.toEqual({
outputDirectory: null,
captures: [],
});
});
describe('restarting followers', () => {
const exits: (Error | undefined)[] = [];
beforeEach(() => {
exits.length = 0;
jest.mocked(spawnDetached).mockImplementation(() => {
const index = exits.push(undefined) - 1;
return {
pid: 1234,
getOutput: () => 'Network capture is not enabled on this device.',
getExitError: () => exits[index],
stopAsync: stopFollower,
};
});
});
function outPath(call: number): string {
const args = followerArgs()[call];
return args[args.indexOf('-o') + 1];
}
it('starts another follower when one exits before capture was on, and drops the empty one', async () => {
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await ServeSimNetworkCaptureRecorder.startAsync({
logger,
env,
stateDir,
pollIntervalMs: 10,
idleRestartIntervalMs: 30,
});
await waitForFollowersAsync(1);
exits[0] = new Error('Process exited with code 1.');
await waitForFollowersAsync(2);
expect(outPath(1)).toMatch(/SIM-A-2\.har$/);
record(outPath(1), 1);
const { captures } = await ServeSimNetworkCaptureRecorder.finishAsync({ logger });
expect(captures).toEqual([{ udid: 'SIM-A', filePath: outPath(1), size: 25 }]);
expect(stopFollower).toHaveBeenCalledTimes(1);
});
it('keeps a recording when its stream drops and records the rest in a new part', async () => {
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await ServeSimNetworkCaptureRecorder.startAsync({
logger,
env,
stateDir,
pollIntervalMs: 10,
restartIntervalMs: 30,
});
await waitForFollowersAsync(1);
record(outPath(0), 2);
exits[0] = new Error('Process exited with code 1.');
await waitForFollowersAsync(2);
record(outPath(1), 1);
const { captures } = await ServeSimNetworkCaptureRecorder.finishAsync({ logger });
expect(captures).toEqual([
{ udid: 'SIM-A', filePath: outPath(0), size: 28 },
{ udid: 'SIM-A', filePath: outPath(1), size: 25 },
]);
});
describe('when a new follower replays the requests serve-sim holds', () => {
const r1 = { id: 'r1', startedAt: 1_000 };
const r2 = { id: 'r2', startedAt: 2_000 };
async function startAsync(): Promise<void> {
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await ServeSimNetworkCaptureRecorder.startAsync({
logger,
env,
stateDir,
pollIntervalMs: 10,
restartIntervalMs: 30,
});
await waitForFollowersAsync(1);
}
it('drops a part that holds only replayed requests', async () => {
await startAsync();
recordRequests(outPath(0), [r2, r1]);
exits[0] = new Error('Process exited with code 1.');
await waitForFollowersAsync(2);
recordRequests(outPath(1), [r2, r1]);
const { captures } = await ServeSimNetworkCaptureRecorder.finishAsync({ logger });
expect(captures.map(capture => capture.filePath)).toEqual([outPath(0)]);
});
it('keeps only the new requests in a later part, in start order', async () => {
await startAsync();
recordRequests(outPath(0), [r1]);
exits[0] = new Error('Process exited with code 1.');
await waitForFollowersAsync(2);
// A request from a later capture session reuses the id r1 with another start time.
const r1Again = { id: 'r1', startedAt: 4_000 };
recordRequests(outPath(1), [r1Again, r1, r2]);
const { captures } = await ServeSimNetworkCaptureRecorder.finishAsync({ logger });
expect(captures.map(capture => capture.filePath)).toEqual([outPath(0), outPath(1)]);
const har = await readHarAsync(outPath(1));
expect(har.log.creator).toEqual({ name: '@expo/serve-sim', version: '0.10.2' });
expect(har.log.entries.map((entry: any) => entry._captureStartedAt)).toEqual([2_000, 4_000]);
expect(captures[1].size).toBe((await readFile(outPath(1))).length);
});
it('keeps the requests a killed follower logged before its HAR caught up', async () => {
const r3 = { id: 'r3', startedAt: 3_000 };
await startAsync();
// serve-sim writes the entry log before it rebuilds the HAR, so a killed follower's HAR can
// lack r2 although its entry log has it.
recordRequests(outPath(0), [r1]);
appendFileSync(
outPath(0).replace(/\.har$/, '.entries.ndjson'),
`${JSON.stringify(entryFor(r2))}\n`
);
exits[0] = new Error('Process exited with code 1.');
await waitForFollowersAsync(2);
recordRequests(outPath(1), [r1, r2, r3]);
const { captures } = await ServeSimNetworkCaptureRecorder.finishAsync({ logger });
expect(captures.map(capture => capture.filePath)).toEqual([outPath(0), outPath(1)]);
const ids = async (harPath: string): Promise<string[]> =>
(await readHarAsync(harPath)).log.entries.map((entry: any) => entry._captureId);
expect(await ids(outPath(0))).toEqual(['r1', 'r2']);
expect(await ids(outPath(1))).toEqual(['r3']);
});
it('leaves out a line a killed follower cut off', async () => {
await startAsync();
recordRequests(outPath(0), [r1]);
appendFileSync(outPath(0).replace(/\.har$/, '.entries.ndjson'), '{"startedDateTime":"20');
const { captures } = await ServeSimNetworkCaptureRecorder.finishAsync({ logger });
expect(captures.map(capture => capture.filePath)).toEqual([outPath(0)]);
const har = await readHarAsync(outPath(0));
expect(har.log.entries.map((entry: any) => entry._captureId)).toEqual(['r1']);
});
it('removes the files of a part that holds only replayed requests', async () => {
await startAsync();
recordRequests(outPath(0), [r1]);
exits[0] = new Error('Process exited with code 1.');
await waitForFollowersAsync(2);
recordRequests(outPath(1), [r1]);
const replayedFiles = [
outPath(1),
outPath(1).replace(/\.har$/, '.entries.ndjson'),
outPath(1).replace(/\.har$/, '.network-capture.json'),
`${outPath(1)}.0f7c2a4e-9d1b-4c3a-8e5f-6a7b8c9d0e1f.seed.tmp`,
];
for (const file of replayedFiles.slice(2)) {
writeFileSync(file, '{}');
}
exits[1] = new Error('Process exited with code 1.');
await waitForFollowersAsync(3);
expect(replayedFiles.filter(file => existsSync(file))).toEqual([]);
expect(existsSync(outPath(0))).toBe(true);
});
it('does not use a recording slot for followers that recorded no new request', async () => {
jest.mocked(spawnDetached).mockImplementation(({ args }) => {
recordRequests(args[args.indexOf('-o') + 1], [r1]);
return {
pid: 1234,
getOutput: () => '',
getExitError: () => new Error('Process exited with code 1.'),
stopAsync: stopFollower,
};
});
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await ServeSimNetworkCaptureRecorder.startAsync({
logger,
env,
stateDir,
pollIntervalMs: 1,
restartIntervalMs: 0,
});
for (let i = 0; i < 300 && jest.mocked(spawnDetached).mock.calls.length < 25; i++) {
await delay(10);
}
expect(jest.mocked(spawnDetached).mock.calls.length).toBeGreaterThanOrEqual(25);
const { captures } = await ServeSimNetworkCaptureRecorder.finishAsync({ logger });
expect(captures.map(capture => capture.filePath)).toEqual([outPath(0)]);
expect(logger.warn).not.toHaveBeenCalledWith(
'Network capture reached its limit of 20 recordings; recorded captures will be retained.'
);
});
});
it('waits longer to replace a follower that recorded nothing than one that recorded requests', async () => {
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await ServeSimNetworkCaptureRecorder.startAsync({
logger,
env,
stateDir,
pollIntervalMs: 10,
restartIntervalMs: 30,
idleRestartIntervalMs: 60_000,
});
await waitForFollowersAsync(1);
exits[0] = new Error('Process exited with code 1.');
await delay(100);
expect(spawnDetached).toHaveBeenCalledTimes(1);
record(outPath(0), 1);
await waitForFollowersAsync(2);
});
it('drops an empty follower from an earlier serve-sim when serve-sim restarts', async () => {
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await ServeSimNetworkCaptureRecorder.startAsync({ logger, env, stateDir, pollIntervalMs: 10 });
await waitForFollowersAsync(1);
exits[0] = new Error('Process exited with code 1.');
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-restarted' });
await waitForFollowersAsync(2);
const { captures } = await ServeSimNetworkCaptureRecorder.finishAsync({ logger });
expect(captures).toEqual([]);
// Only the new follower is left to stop, and the device is reported once.
expect(stopFollower).toHaveBeenCalledTimes(1);
expect(
jest
.mocked(logger.info)
.mock.calls.filter(
([, message]) => message === 'No network capture was recorded for SIM-A.'
)
).toHaveLength(1);
});
it('waits 30 s by default before replacing a follower that recorded nothing', async () => {
const startedAt = Date.now();
const now = jest.spyOn(Date, 'now');
try {
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await ServeSimNetworkCaptureRecorder.startAsync({
logger,
env,
stateDir,
pollIntervalMs: 10,
restartIntervalMs: 0,
});
await waitForFollowersAsync(1);
exits[0] = new Error('Process exited with code 1.');
now.mockReturnValue(startedAt + 29_000);
await delay(50);
expect(spawnDetached).toHaveBeenCalledTimes(1);
now.mockReturnValue(startedAt + 31_000);
await waitForFollowersAsync(2);
} finally {
now.mockRestore();
}
});
it('stops starting followers once 20 HARs hold requests', async () => {
jest.mocked(spawnDetached).mockImplementation(({ args }) => {
record(args[args.indexOf('-o') + 1], 1);
return {
pid: 1234,
getOutput: () => '',
getExitError: () => new Error('Process exited with code 1.'),
stopAsync: stopFollower,
};
});
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await ServeSimNetworkCaptureRecorder.startAsync({
logger,
env,
stateDir,
pollIntervalMs: 1,
restartIntervalMs: 0,
});
await waitForFollowersAsync(20);
await delay(50);
expect(spawnDetached).toHaveBeenCalledTimes(20);
const { captures } = await ServeSimNetworkCaptureRecorder.finishAsync({ logger });
expect(captures).toHaveLength(20);
expect(logger.warn).toHaveBeenCalledTimes(1);
expect(logger.warn).toHaveBeenCalledWith(
'Network capture reached its limit of 20 recordings; recorded captures will be retained.'
);
});
});
it('keeps polling after a follower fails to start, and retries on the next poll', async () => {
jest.mocked(spawnDetached).mockImplementationOnce(() => {
throw new Error('spawn EAGAIN');
});
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await ServeSimNetworkCaptureRecorder.startAsync({
logger,
env,
stateDir,
pollIntervalMs: 10,
restartIntervalMs: 60_000,
idleRestartIntervalMs: 60_000,
});
await waitForFollowersAsync(2);
expect(logger.warn).toHaveBeenCalledWith(
{ err: expect.objectContaining({ message: 'spawn EAGAIN' }) },
'Could not start the network capture follower for SIM-A; retrying.'
);
expect(followerArgs()[1]).toContainEqual(expect.stringMatching(/SIM-A-2\.har$/));
});
it('bounds followers that record nothing, warns once, and retries a new server identity', async () => {
jest.mocked(spawnDetached).mockImplementation(() => ({
pid: 1234,
getOutput: () => 'npm error: the requested serve-sim package was not found',
getExitError: () => new Error('Process exited with code 1.'),
stopAsync: stopFollower,
}));
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await ServeSimNetworkCaptureRecorder.startAsync({
logger,
env,
stateDir,
pollIntervalMs: 1,
idleRestartIntervalMs: 0,
});
// Runs that recorded nothing do not use up the 20 HARs that may hold requests.
await waitForFollowersAsync(120);
await delay(50);
expect(spawnDetached).toHaveBeenCalledTimes(120);
const warnings = jest
.mocked(logger.warn)
.mock.calls.filter(([, message]) =>
String(message).startsWith('Stopped retrying network capture')
);
expect(warnings).toEqual([
[
{ output: 'npm error: the requested serve-sim package was not found' },
'Stopped retrying network capture for SIM-A after 120 attempts; recorded captures will be retained.',
],
]);
jest.mocked(spawnDetached).mockImplementation(() => ({
pid: 1234,
getOutput: () => '',
getExitError: () => undefined,
stopAsync: stopFollower,
}));
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'new-token' });
await waitForFollowersAsync(121);
await delay(50);
expect(spawnDetached).toHaveBeenCalledTimes(121);
expect(followerArgs()[120]).toContainEqual(expect.stringMatching(/SIM-A-121\.har$/));
});
it('keeps a running empty follower waiting without spending more attempts', async () => {
await writeServerAsync('SIM-A', { url: 'http://127.0.0.1:4100', token: 'token-a' });
await ServeSimNetworkCaptureRecorder.startAsync({
logger,
env,
stateDir,
pollIntervalMs: 1,
restartIntervalMs: 0,
idleRestartIntervalMs: 0,
});
await waitForFollowersAsync(1);
await delay(50);
expect(spawnDetached).toHaveBeenCalledTimes(1);
expect(logger.warn).not.toHaveBeenCalled();
});
@@ -47,6 +47,7 @@ import {
IosSimulatorRecordingUtils,
SERVE_SIM_STOP_GRACE_PERIOD_MS,
} from './IosSimulatorRecordingUtils';
import { ServeSimCrashesRecorder } from './serveSimCrashesRecorder';
import { SERVE_SIM_STATE_DIR, readServeSimServersAsync } from './serveSimMetricsRecorder';
import { startLogPhase } from '../../utils/logPhase';
import { runServeSimActionAsync, stageServeSimAppAsync } from './serveSimActions';
@@ -128,7 +129,7 @@ export function corsOriginArgs(corsOrigins: readonly string[]): string[] {
return corsOrigins.flatMap(origin => ['--cors-origin', origin]);
}
function createServeSimPackageSpec(packageVersion: string | undefined): string {
export function createServeSimPackageSpec(packageVersion: string | undefined): string {
return `${SERVE_SIM_PACKAGE_NAME}@${packageVersion ?? 'latest'}`;
}
@@ -1175,6 +1176,8 @@ async function finishDeviceSessionHostAsync(
logger,
});
}
// Crash reports are read from serve-sim, so collection finishes before it stops.
await ServeSimCrashesRecorder.stopAsync();
let hostStopped = false;
try {
await previewServer.stopAsync();
@@ -3,7 +3,7 @@ import { BuildStepEnv } from '@expo/steps';
import spawn, { SpawnResult } from '@expo/turtle-spawn';
import path from 'path';
import { COMMON_FASTLANE_ENV } from '../../../common/fastlane';
import { COMMON_FASTLANE_ENV, DEFAULT_FASTLANE_GYM_ENV } from '../../../common/fastlane';
import { XcodeBuildLogger } from '../../../common/xcpretty';
export async function runFastlaneGym({
@@ -25,7 +25,7 @@ export async function runFastlaneGym({
await runFastlane(['gym'], {
cwd: path.join(workingDir, 'ios'),
logger,
env,
env: { ...DEFAULT_FASTLANE_GYM_ENV, ...env },
extraEnv,
});
} finally {
@@ -0,0 +1,48 @@
import { type bunyan } from '@expo/logger';
import { type CustomBuildContext } from '../../customBuildContext';
import { Sentry } from '../../sentry';
import { type CollectedCrash } from './serveSimCrashesRecorder';
import { uploadDeviceRunSessionFileAsync } from './uploadDeviceRunSessionFile';
export async function uploadServeSimCrashesFileAsync(
ctx: CustomBuildContext,
{
deviceRunSessionId,
crash: { udid, filePath, number, processName },
logger,
signal,
}: {
deviceRunSessionId: string;
crash: CollectedCrash;
logger: bunyan;
signal?: AbortSignal;
}
): Promise<void> {
const device = udid.slice(0, 8);
try {
await uploadDeviceRunSessionFileAsync(ctx, {
filePath,
describe: () => ({
deviceRunSessionId,
artifactId: `simulator-crash-${udid}-${number}`,
name: processName
? `Crash report ${number}: ${processName} (${device})`
: `Crash report ${number} (${device})`,
// Process names are not paths; keep separators out of the download name.
filename: `${(processName ?? 'crash').replace(/[/\\:\x00-\x1f]/g, '-')}-${number}.ips`,
kind: 'simulator-crash',
metadata: { __eas_type: 'simulator-crash', udid, source: 'serve-sim/crashes' },
}),
attempts: 3,
signal,
});
} catch (err) {
const error = err instanceof Error ? err : new Error(String(err));
Sentry.capture('Could not upload a simulator crash report', error, { level: 'warning' });
logger.warn(
{ err: error },
`Could not upload crash report ${number} for ${udid}; other artifacts will continue.`
);
}
}
@@ -0,0 +1,521 @@
import { type bunyan } from '@expo/logger';
import fetch from 'node-fetch';
import { mkdtemp, rm, writeFile } from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import { setTimeout as delay } from 'node:timers/promises';
import { z } from 'zod';
import { Sentry } from '../../sentry';
import { SERVE_SIM_STATE_DIR, readServeSimServersAsync } from './serveSimMetricsRecorder';
const MAX_BYTES_PER_DEVICE = 20 * 1024 * 1024;
const MAX_REPORTS_PER_DEVICE = 1_000;
const MAX_CONSECUTIVE_FAILURES = 10;
const MAX_FRAME_LENGTH = 1024 * 1024;
const MAX_DETAIL_BYTES = 8 * 1024 * 1024;
// A 5xx, timeout, or dropped connection is retried; a missing or unusable detail is not.
const MAX_DETAIL_ATTEMPTS = 3;
const DETAIL_RETRY_DELAY_MS = 500;
// serve-sim lists a crash about 5 s after it happens, once ReportCrash has written the report,
// so stopping checks each device once more for occurrences the stream had not delivered yet.
const FINAL_PASS_TIMEOUT_MS = 10_000;
const SummarySchema = z.object({
id: z.string(),
appName: z.string().nullable().optional(),
procName: z.string().nullable().optional(),
occurrenceTimes: z.array(
z.object({
key: z.number().int().nonnegative(),
capturedAtMs: z.number().nullable().optional(),
rawPath: z.string().optional(),
})
),
});
const FrameSchema = z.discriminatedUnion('type', [
z.object({ type: z.literal('meta'), meta: z.object({ statusError: z.string().nullable() }) }),
z.object({ type: z.literal('list'), crashes: z.array(SummarySchema) }),
z.object({ type: z.enum(['crash', 'recurred']), record: SummarySchema }),
]);
const ListSchema = z.object({ crashes: z.array(SummarySchema) });
const DetailSchema = z.object({
record: z.object({ id: z.string() }),
occurrence: z.object({
key: z.number().int().nonnegative(),
incidentId: z.string().nullable().optional(),
}),
report: z.string().nullable(),
});
/** A detail that will not change on retry: mismatched, malformed, or over 8 MiB. */
class UnusableDetailError extends Error {}
type ServeSimServer = { udid: string; url: string; token?: string };
export type CollectedCrash = {
udid: string;
filePath: string;
size: number;
number: number;
processName?: string;
};
type FinishedCrashes = { outputDirectory: string | null; crashes: CollectedCrash[] };
type Device = {
// The latest registry entry; unset while the server is absent, so its return counts as new.
server?: ServeSimServer;
identity?: string;
// Occurrences saved or skipped; reconnects replay the retained list and must not retry them.
handled: Set<string>;
incidents: Set<string>;
bytesWritten: number;
reportsWritten: number;
limitReached: boolean;
failures: number;
stoppedRetrying: boolean;
warnedStatusError: boolean;
};
type Session = {
outputDirectory: string;
logger: bunyan;
maxBytes: number;
finalPassTimeoutMs: number;
controller: AbortController;
timer: NodeJS.Timeout;
polling: Promise<void>;
streams: Map<string, Promise<void>>;
devices: Map<string, Device>;
files: CollectedCrash[];
stopping?: Promise<void>;
finishing?: Promise<FinishedCrashes>;
};
let activeSession: Session | undefined;
export namespace ServeSimCrashesRecorder {
export async function startAsync({
logger,
stateDir = SERVE_SIM_STATE_DIR,
pollIntervalMs = 2_000,
maxBytes = MAX_BYTES_PER_DEVICE,
maxDurationMs = 30 * 60 * 1000,
finalPassTimeoutMs = FINAL_PASS_TIMEOUT_MS,
}: {
logger: bunyan;
stateDir?: string;
pollIntervalMs?: number;
maxBytes?: number;
maxDurationMs?: number;
finalPassTimeoutMs?: number;
}): Promise<void> {
if (activeSession) {
return;
}
const controller = new AbortController();
const session: Session = {
outputDirectory: await mkdtemp(path.join(os.tmpdir(), 'serve-sim-crashes-')),
logger,
maxBytes,
finalPassTimeoutMs,
controller,
timer: setTimeout(() => {
logger.warn(
'Simulator crash collection reached its duration limit; collected reports will be retained.'
);
controller.abort();
}, maxDurationMs),
polling: Promise.resolve(),
streams: new Map(),
devices: new Map(),
files: [],
};
session.timer.unref();
activeSession = session;
session.polling = (async () => {
while (!controller.signal.aborted) {
const servers = await readServeSimServersAsync(stateDir);
const present = new Set(servers.map(server => server.udid));
for (const [udid, device] of session.devices) {
if (!present.has(udid)) {
device.server = undefined;
device.identity = undefined;
}
}
for (const server of servers) {
if (controller.signal.aborted) {
break;
}
const device = getDevice(session, server.udid);
// Kept current while a stream runs, so the final pass reads the latest address.
device.server = server;
if (session.streams.has(server.udid)) {
continue;
}
const identity = JSON.stringify([server.url, server.token]);
if (device.identity !== identity) {
device.identity = identity;
device.failures = 0;
device.stoppedRetrying = false;
}
if (device.limitReached || device.stoppedRetrying) {
continue;
}
if (device.failures >= MAX_CONSECUTIVE_FAILURES) {
device.stoppedRetrying = true;
logger.warn(
`Stopped retrying simulator crash collection for ${server.udid} after ${MAX_CONSECUTIVE_FAILURES} failed connections; collected reports will be retained.`
);
continue;
}
device.failures += 1;
const done = streamServeSimCrashesAsync(session, server, device).finally(() =>
session.streams.delete(server.udid)
);
session.streams.set(server.udid, done);
}
await delay(pollIntervalMs, undefined, { signal: controller.signal }).catch(() => {});
}
})().catch(err => {
const error = err instanceof Error ? err : new Error(String(err));
Sentry.capture('serve-sim simulator crash poller failed', error);
logger.warn(
{ err: error },
'Could not collect simulator crashes; collected reports will be retained.'
);
controller.abort();
});
logger.info('Started collecting simulator crashes (up to 20 MiB per device and 30 minutes).');
}
/** Never rejects. */
export async function stopAsync(): Promise<void> {
const session = activeSession;
if (!session) {
return;
}
session.stopping ??= (async () => {
clearTimeout(session.timer);
session.controller.abort();
await session.polling;
await Promise.all(session.streams.values());
await collectRemainingCrashesAsync(session);
})();
await session.stopping;
}
export async function finishAsync(): Promise<FinishedCrashes> {
const session = activeSession;
if (!session || session.finishing) {
await session?.finishing;
return { outputDirectory: null, crashes: [] };
}
session.finishing = (async () => {
await stopAsync();
return { outputDirectory: session.outputDirectory, crashes: session.files };
})();
try {
return await session.finishing;
} finally {
if (activeSession === session) {
activeSession = undefined;
}
}
}
}
function getDevice(session: Session, udid: string): Device {
let device = session.devices.get(udid);
if (!device) {
device = {
handled: new Set(),
incidents: new Set(),
bytesWritten: 0,
reportsWritten: 0,
limitReached: false,
failures: 0,
stoppedRetrying: false,
warnedStatusError: false,
};
session.devices.set(udid, device);
}
return device;
}
async function streamServeSimCrashesAsync(
session: Session,
server: ServeSimServer,
device: Device
): Promise<void> {
const { logger } = session;
const signal = session.controller.signal;
const controller = new AbortController();
try {
const url = new URL('/crashes', server.url);
url.searchParams.set('device', server.udid);
const response = await fetch(url.toString(), {
redirect: 'error',
signal: AbortSignal.any([signal, controller.signal]),
headers: {
Accept: 'text/event-stream',
...(server.token ? { Authorization: `Bearer ${server.token}` } : {}),
},
});
if (
!response.ok ||
!response.body ||
!response.headers.get('content-type')?.includes('text/event-stream')
) {
throw new Error(`serve-sim /crashes responded ${response.status}`);
}
const decoder = new TextDecoder();
let buffer = '';
for await (const chunk of response.body) {
buffer += decoder.decode(chunk as Buffer, { stream: true });
let newline: number;
while ((newline = buffer.indexOf('\n')) !== -1) {
const line = buffer.slice(0, newline).replace(/\r$/, '');
buffer = buffer.slice(newline + 1);
if (line.length > MAX_FRAME_LENGTH) {
throw new Error('Crash frame exceeded limit');
}
if (!line.startsWith('data:')) {
continue;
}
const frame = FrameSchema.safeParse(JSON.parse(line.slice(5)));
if (!frame.success) {
continue;
}
if (frame.data.type === 'meta') {
if (frame.data.meta.statusError && !device.warnedStatusError) {
device.warnedStatusError = true;
logger.warn(
'serve-sim cannot watch crash reports; crash collection will resume when the watcher recovers.'
);
}
continue;
}
const summaries = frame.data.type === 'list' ? frame.data.crashes : [frame.data.record];
await saveOccurrencesAsync(session, server, device, summaries, { stop: signal });
if (signal.aborted || device.limitReached) {
return;
}
device.failures = 0;
}
if (buffer.length > MAX_FRAME_LENGTH) {
throw new Error('Crash frame exceeded limit');
}
}
} catch (err) {
if (!signal.aborted) {
logger.warn(
{ err },
`Simulator crash stream for ${server.udid} ended; collection will be retried.`
);
}
} finally {
controller.abort();
}
}
/** One look at each device's crash list, for occurrences the stream had not delivered. */
async function collectRemainingCrashesAsync(session: Session): Promise<void> {
const signal = AbortSignal.timeout(session.finalPassTimeoutMs);
await Promise.all(
[...session.devices.values()].map(async device => {
const { server } = device;
if (!server || device.limitReached) {
return;
}
try {
const url = new URL('/crashes', server.url);
url.searchParams.set('device', server.udid);
const response = await fetch(url.toString(), {
redirect: 'error',
signal,
headers: {
Accept: 'application/json',
...(server.token ? { Authorization: `Bearer ${server.token}` } : {}),
},
});
if (!response.ok || !response.headers.get('content-type')?.includes('application/json')) {
throw new Error(`serve-sim /crashes responded ${response.status}`);
}
const { crashes } = ListSchema.parse(await response.json());
await saveOccurrencesAsync(session, server, device, crashes, {
stop: signal,
deadline: signal,
});
} catch (err) {
session.logger.warn(
{ err },
`Could not check ${server.udid} for crashes before the session ended; collected reports will be retained.`
);
}
})
);
}
async function saveOccurrencesAsync(
session: Session,
server: ServeSimServer,
device: Device,
summaries: z.infer<typeof SummarySchema>[],
// `stop` ends the loop between occurrences; `deadline` also aborts a download in progress.
{ stop, deadline }: { stop: AbortSignal; deadline?: AbortSignal }
): Promise<void> {
const { logger } = session;
// Each caller returns once this is true, so the deadline warning is logged once per pass.
const stopped = (): boolean => {
if (deadline?.aborted) {
logger.warn(
`Stopped checking ${server.udid} for crashes at the end-of-session deadline; collected reports will be retained.`
);
}
return stop.aborted || !!deadline?.aborted;
};
for (const summary of summaries) {
for (const occurrence of summary.occurrenceTimes) {
if (device.limitReached || stopped()) {
return;
}
// Keys restart when serve-sim does; the capture time and report path tell such occurrences apart.
const key = JSON.stringify([
summary.id,
occurrence.key,
occurrence.capturedAtMs ?? null,
occurrence.rawPath ?? null,
]);
if (device.handled.has(key)) {
continue;
}
let detail: z.infer<typeof DetailSchema> | undefined;
try {
for (let attempt = 1; ; attempt++) {
try {
detail = await readCrashDetailAsync(server, summary.id, occurrence.key, deadline);
break;
} catch (err) {
if (err instanceof UnusableDetailError || attempt >= MAX_DETAIL_ATTEMPTS) {
throw err;
}
await delay(DETAIL_RETRY_DELAY_MS, undefined, { signal: stop });
}
}
} catch (err) {
// Stopping leaves the occurrence unhandled, so the final pass can still save it.
if (stopped()) {
return;
}
device.handled.add(key);
logger.warn(
{ err },
`Could not download crash occurrence ${occurrence.key} for ${server.udid}; skipping it.`
);
continue;
}
device.handled.add(key);
if (!detail) {
logger.warn(
`Crash occurrence ${occurrence.key} is no longer available for ${server.udid}; earlier reports will be retained.`
);
continue;
}
const { incidentId } = detail.occurrence;
if (incidentId && device.incidents.has(incidentId)) {
continue;
}
if (!detail.report) {
logger.warn(
`Crash occurrence ${occurrence.key} has no native report for ${server.udid}; skipping its artifact.`
);
continue;
}
const size = Buffer.byteLength(detail.report);
if (
device.bytesWritten + size > session.maxBytes ||
device.reportsWritten >= MAX_REPORTS_PER_DEVICE
) {
device.limitReached = true;
logger.warn(
`Simulator crash collection reached its limit for ${server.udid}; collected reports will be retained.`
);
return;
}
const number = device.reportsWritten + 1;
const filePath = path.join(session.outputDirectory, `${server.udid}-${number}.ips`);
try {
await writeFile(filePath, detail.report, { mode: 0o600, flag: 'wx' });
} catch (error) {
device.handled.delete(key);
await rm(filePath, { force: true }).catch(() => {});
throw error;
}
device.bytesWritten += size;
device.reportsWritten = number;
if (incidentId) {
device.incidents.add(incidentId);
}
const processName = summary.appName || summary.procName || undefined;
session.files.push({
udid: server.udid,
filePath,
size,
number,
...(processName ? { processName } : {}),
});
}
}
}
/** Resolves `undefined` when serve-sim no longer keeps the occurrence. */
async function readCrashDetailAsync(
server: ServeSimServer,
id: string,
key: number,
deadline?: AbortSignal
): Promise<z.infer<typeof DetailSchema> | undefined> {
const url = new URL(`/crashes/${encodeURIComponent(id)}`, server.url);
url.searchParams.set('device', server.udid);
url.searchParams.set('key', String(key));
const controller = new AbortController();
try {
const response = await fetch(url.toString(), {
redirect: 'error',
size: MAX_DETAIL_BYTES,
signal: AbortSignal.any([
controller.signal,
AbortSignal.timeout(5_000),
...(deadline ? [deadline] : []),
]),
...(server.token ? { headers: { Authorization: `Bearer ${server.token}` } } : {}),
});
if (response.status === 404) {
return undefined;
}
if (!response.ok) {
// Other 4xx responses will not change on a retry; 408, 429 and 5xx can.
const permanent = response.status < 500 && response.status !== 408 && response.status !== 429;
throw new (permanent ? UnusableDetailError : Error)(
`serve-sim crash detail responded ${response.status}`
);
}
const body = await response.json().catch(err => {
const type = (err as { type?: string }).type;
if (type === 'max-size') {
throw new UnusableDetailError('Crash detail exceeds 8 MiB');
}
if (type === 'invalid-json') {
throw new UnusableDetailError('Crash detail is not valid JSON');
}
throw err;
});
const detail = DetailSchema.safeParse(body);
if (!detail.success) {
throw new UnusableDetailError('Crash detail is not valid');
}
if (detail.data.record.id !== id || detail.data.occurrence.key !== key) {
throw new UnusableDetailError('Crash detail does not match the requested occurrence');
}
return detail.data;
} finally {
controller.abort();
}
}
@@ -0,0 +1,59 @@
import { formatBytes } from '@expo/eas-build-job';
import { type bunyan } from '@expo/logger';
import { CustomBuildContext } from '../../customBuildContext';
import { Sentry } from '../../sentry';
import { uploadDeviceRunSessionFileAsync } from './uploadDeviceRunSessionFile';
const NETWORK_CAPTURE_ARTIFACT_FILENAME = 'network-capture.har';
const MAX_NETWORK_CAPTURE_ARTIFACT_SIZE_BYTES = 500 * 1024 * 1024;
/** Never rejects; a failed upload is logged. */
export async function uploadServeSimNetworkCaptureFileAsync(
ctx: CustomBuildContext,
{
deviceRunSessionId,
udid,
filePath,
size,
part,
logger,
signal,
}: {
deviceRunSessionId: string;
udid: string;
filePath: string;
size: number;
part: number;
logger: bunyan;
signal?: AbortSignal;
}
): Promise<void> {
const label = part > 1 ? `, part ${part}` : '';
if (size > MAX_NETWORK_CAPTURE_ARTIFACT_SIZE_BYTES) {
logger.warn(
`Skipping network capture for ${udid}${label}: exceeds the ${formatBytes(MAX_NETWORK_CAPTURE_ARTIFACT_SIZE_BYTES)} upload limit.`
);
return;
}
try {
logger.info(`Uploading the network capture for ${udid}${label} (${formatBytes(size)}).`);
await uploadDeviceRunSessionFileAsync(ctx, {
filePath,
describe: () => ({
deviceRunSessionId,
artifactId: `network-capture-${udid}-${part}`,
name: `Network capture (${udid.slice(0, 8)}${label})`,
filename: NETWORK_CAPTURE_ARTIFACT_FILENAME,
kind: 'network-capture',
metadata: { __eas_type: 'network-capture', format: 'har', udid, part },
}),
attempts: 3,
signal,
});
} catch (err) {
const error = err instanceof Error ? err : new Error(String(err));
Sentry.capture('Could not upload the network capture', error, { level: 'warning' });
logger.warn({ err: error }, `Could not upload the network capture for ${udid}.`);
}
}
@@ -0,0 +1,472 @@
import { type bunyan } from '@expo/logger';
import { type BuildStepEnv } from '@expo/steps';
import { createReadStream } from 'node:fs';
import { mkdtemp, open, readdir, rename, rm, stat } from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import { createInterface } from 'node:readline';
import { setTimeout as delay } from 'node:timers/promises';
import { Sentry } from '../../sentry';
import {
PackageManager,
resolveConfiguredPackageManager,
resolvePackageExec,
} from '../../utils/packageManager';
import { createServeSimPackageSpec } from './deviceSessionHost';
import {
type DetachedProcessHandle,
omitNgrokAuthtoken,
spawnDetached,
} from './remoteDeviceRunSession';
import { SERVE_SIM_STATE_DIR, readServeSimServersAsync } from './serveSimMetricsRecorder';
const POLL_INTERVAL_MS = 2_000;
// While serve-sim runs, an exited follower (stream dropped, capture off) is replaced after this long;
// one that recorded nothing (usually capture off) waits longer, since it may stay off all session.
const FOLLOWER_RESTART_INTERVAL_MS = 10_000;
const IDLE_FOLLOWER_RESTART_INTERVAL_MS = 30_000;
// On stop the follower rebuilds the whole HAR from its entry log; a shorter --flush-ms would not
// shorten that last rebuild, so a large recording gets a longer grace before it is killed.
const FOLLOWER_STOP_GRACE_PERIOD_MS = 60_000;
// HARs holding requests, across the session.
const MAX_RECORDINGS = 20;
// Followers started for one serve-sim server; at the idle interval this covers about an hour.
const MAX_FOLLOWER_STARTS = 120;
const OUTPUT_TAIL_CHARS = 2_000;
type Follower = {
udid: string;
filePath: string;
handle: DetachedProcessHandle;
startedAt: number;
/** Set once the follower has exited and holds requests no earlier follower recorded. */
kept?: boolean;
};
type ServeSimNetworkCaptureSession = {
logger: bunyan;
stateDir: string;
pollIntervalMs: number;
restartIntervalMs: number;
idleRestartIntervalMs: number;
outputDirectory: string;
command: { command: string; args: string[] };
env: BuildStepEnv;
followers: Follower[];
current: Map<string, Follower>;
followerStarts: Map<string, number>;
stoppedRetrying: Set<string>;
warnedRecordingLimit: boolean;
fileCounts: Map<string, number>;
/** Per device, the requests of the exited followers that were kept. */
keptRequests: Map<string, Set<string>>;
pollingPromise: Promise<void>;
abortController: AbortController;
};
export type RecordedNetworkCapture = { udid: string; filePath: string; size: number };
let activeSession: ServeSimNetworkCaptureSession | null = null;
/** serve-sim deletes capture files when capture stops; a `capture har` follower keeps the HAR. */
export namespace ServeSimNetworkCaptureRecorder {
export async function startAsync({
logger,
env,
packageVersion,
stateDir = SERVE_SIM_STATE_DIR,
pollIntervalMs = POLL_INTERVAL_MS,
restartIntervalMs = FOLLOWER_RESTART_INTERVAL_MS,
idleRestartIntervalMs = IDLE_FOLLOWER_RESTART_INTERVAL_MS,
}: {
logger: bunyan;
env: BuildStepEnv;
packageVersion?: string;
stateDir?: string;
pollIntervalMs?: number;
restartIntervalMs?: number;
idleRestartIntervalMs?: number;
}): Promise<void> {
if (activeSession) {
logger.info('The serve-sim network capture recorder is already running.');
return;
}
const command = resolvePackageExec(resolveConfiguredPackageManager(env, PackageManager.NPM), [
createServeSimPackageSpec(packageVersion),
]);
const session: ServeSimNetworkCaptureSession = {
logger,
stateDir,
pollIntervalMs,
restartIntervalMs,
idleRestartIntervalMs,
outputDirectory: await mkdtemp(path.join(os.tmpdir(), 'serve-sim-network-capture-')),
command,
env: omitNgrokAuthtoken(env),
followers: [],
current: new Map(),
followerStarts: new Map(),
stoppedRetrying: new Set(),
warnedRecordingLimit: false,
fileCounts: new Map(),
keptRequests: new Map(),
pollingPromise: Promise.resolve(),
abortController: new AbortController(),
};
activeSession = session;
logger.info('Started watching serve-sim for network capture.');
session.pollingPromise = pollServeSimServersAsync(session).catch(err => {
const error = err instanceof Error ? err : new Error(String(err));
Sentry.capture('serve-sim network capture poller failed', error);
logger.warn({ err: error }, 'serve-sim network capture poller failed.');
});
}
/** Never rejects. */
export async function finishAsync({
logger,
}: {
logger: bunyan;
}): Promise<{ outputDirectory: string | null; captures: RecordedNetworkCapture[] }> {
const session = activeSession;
if (!session) {
logger.info('The serve-sim network capture recorder is not running.');
return { outputDirectory: null, captures: [] };
}
activeSession = null;
session.abortController.abort();
await session.pollingPromise;
// Stopped together, so the final HAR rebuilds share one grace period.
await Promise.all(
session.followers.map(follower =>
follower.handle.stopAsync().catch(err => {
logger.warn({ err }, `Could not stop the network capture follower for ${follower.udid}.`);
})
)
);
const captures: RecordedNetworkCapture[] = [];
const recorded = new Map<string, Set<string>>();
for (const follower of session.followers) {
try {
if (!(await rebuildHarAsync(follower, requestsFor(recorded, follower.udid)))) {
continue;
}
} catch (err) {
logger.warn(
{ err },
`Could not rebuild a network capture for ${follower.udid}; its HAR is kept as serve-sim wrote it.`
);
}
const size = await stat(follower.filePath).then(
stats => stats.size,
() => 0
);
if (size > 0) {
captures.push({ udid: follower.udid, filePath: follower.filePath, size });
}
}
for (const follower of session.current.values()) {
if (!captures.some(capture => capture.udid === follower.udid)) {
logger.info(
{ output: follower.handle.getOutput().slice(-OUTPUT_TAIL_CHARS) || '<empty>' },
`No network capture was recorded for ${follower.udid}.`
);
}
}
return { outputDirectory: session.outputDirectory, captures };
}
}
async function pollServeSimServersAsync(session: ServeSimNetworkCaptureSession): Promise<void> {
const { abortController } = session;
while (!abortController.signal.aborted) {
for (const server of await readServeSimServersAsync(session.stateDir)) {
// serve-sim's capture routes require a token, so `capture har` refuses a server without one.
if (!server.token) {
continue;
}
const key = `${server.udid}\n${server.url}\n${server.token}`;
try {
await ensureFollowerAsync(session, key, server.udid);
} catch (err) {
session.logger.warn(
{ err },
`Could not start the network capture follower for ${server.udid}; retrying.`
);
}
}
await delay(session.pollIntervalMs, undefined, { signal: abortController.signal }).catch(
() => {}
);
}
}
async function ensureFollowerAsync(
session: ServeSimNetworkCaptureSession,
key: string,
udid: string
): Promise<void> {
const previous = session.current.get(key);
if (previous) {
if (previous.handle.getExitError() === undefined) {
return;
}
const recorded = await hasEntriesAsync(previous);
const interval = recorded ? session.restartIntervalMs : session.idleRestartIntervalMs;
if (Date.now() - previous.startedAt < interval) {
return;
}
} else {
// serve-sim restarted with a new token; the old identity's follower is no longer current.
for (const [otherKey, other] of session.current) {
if (other.udid === udid) {
session.current.delete(otherKey);
}
}
}
// A new follower replays the requests serve-sim already holds, so an exited follower that recorded
// no new request holds no capture of its own and does not use a recording slot. Another server's
// current follower waits for its own restart, which reads its entry log.
const current = new Set(session.current.values());
for (const follower of [...session.followers]) {
if (
follower.kept ||
follower.handle.getExitError() === undefined ||
(follower !== previous && current.has(follower))
) {
continue;
}
const keptRequests = requestsFor(session.keptRequests, follower.udid);
const requests = await readRequestKeysAsync(entriesPathFor(follower));
if (requests.some(request => request === null || !keptRequests.has(request))) {
follower.kept = true;
for (const request of requests) {
if (request !== null) {
keptRequests.add(request);
}
}
} else {
session.followers.splice(session.followers.indexOf(follower), 1);
await removeFollowerFilesAsync(follower, session.logger);
}
}
if (session.followers.length >= MAX_RECORDINGS) {
if (!session.warnedRecordingLimit) {
session.warnedRecordingLimit = true;
session.logger.warn(
`Network capture reached its limit of ${MAX_RECORDINGS} recordings; recorded captures will be retained.`
);
}
return;
}
const starts = session.followerStarts.get(key) ?? 0;
if (starts >= MAX_FOLLOWER_STARTS) {
if (!session.stoppedRetrying.has(key)) {
session.stoppedRetrying.add(key);
session.logger.warn(
{ output: previous?.handle.getOutput().slice(-OUTPUT_TAIL_CHARS) || '<empty>' },
`Stopped retrying network capture for ${udid} after ${MAX_FOLLOWER_STARTS} attempts; recorded captures will be retained.`
);
}
return;
}
session.followerStarts.set(key, starts + 1);
const count = (session.fileCounts.get(udid) ?? 0) + 1;
session.fileCounts.set(udid, count);
const filePath = path.join(session.outputDirectory, `${udid}-${count}.har`);
if (!previous) {
session.logger.info(`Recording network capture for ${udid}.`);
}
const follower: Follower = {
udid,
filePath,
startedAt: Date.now(),
handle: spawnDetached({
command: session.command.command,
args: [...session.command.args, 'capture', 'har', '-o', filePath, '-d', udid],
env: session.env,
stopGracePeriodMs: FOLLOWER_STOP_GRACE_PERIOD_MS,
}),
};
session.followers.push(follower);
session.current.set(key, follower);
}
/** serve-sim writes an empty HAR when recording begins; requests go to `<stem>.entries.ndjson`. */
function entriesPathFor(follower: Follower): string {
return follower.filePath.replace(/\.har$/, '.entries.ndjson');
}
/** Removes the HAR and the working files serve-sim names after it, such as its entry log. */
async function removeFollowerFilesAsync(follower: Follower, logger: bunyan): Promise<void> {
const directory = path.dirname(follower.filePath);
const prefix = `${path.basename(follower.filePath, '.har')}.`;
try {
const names = (await readdir(directory)).filter(name => name.startsWith(prefix));
await Promise.all(names.map(name => rm(path.join(directory, name), { force: true })));
} catch (err) {
logger.warn({ err }, `Could not remove a replayed network capture for ${follower.udid}.`);
}
}
async function hasEntriesAsync(follower: Follower): Promise<boolean> {
return await stat(entriesPathFor(follower)).then(
stats => stats.size > 0,
() => false
);
}
function requestsFor(requests: Map<string, Set<string>>, udid: string): Set<string> {
let forDevice = requests.get(udid);
if (!forDevice) {
forDevice = new Set();
requests.set(udid, forDevice);
}
return forDevice;
}
type Entry = { _captureId?: unknown; _captureStartedAt?: unknown; startedDateTime?: unknown };
/**
* Reads an entry log line; null when it is not JSON, such as a line a killed follower cut off.
* Entries without a valid start time sort last.
*/
function parseEntry(line: string): { key: string | null; start: number } | null {
let entry: Entry;
try {
entry = JSON.parse(line);
} catch {
return null;
}
const start = Date.parse(String(entry?.startedDateTime));
return { key: requestKey(entry), start: Number.isNaN(start) ? Number.POSITIVE_INFINITY : start };
}
/**
* A request's identity, as serve-sim's `capture har` matches its replays: request ids restart in
* every capture session, so the request's start time tells them apart. null when serve-sim did not
* record an id, so the request cannot be matched.
*/
function requestKey(entry: Entry | null): string | null {
if (typeof entry?._captureId !== 'string') {
return null;
}
return entry._captureStartedAt !== undefined
? `${entry._captureId} ${entry._captureStartedAt}`
: `${entry._captureId} ${entry.startedDateTime}`;
}
/** Streams the entry log, so a large recording never has to fit in memory. */
async function forEachEntryAsync(
entriesPath: string,
onEntry: (line: string, offset: number) => void
): Promise<void> {
// A follower that never began recording leaves no entry log.
if (
!(await stat(entriesPath).then(
() => true,
() => false
))
) {
return;
}
const input = createReadStream(entriesPath, { encoding: 'utf8' });
const lines = createInterface({ input, crlfDelay: Infinity });
let offset = 0;
try {
for await (const line of lines) {
if (line) {
onEntry(line, offset);
}
offset += Buffer.byteLength(line) + 1;
}
} finally {
lines.close();
input.destroy();
}
}
async function readRequestKeysAsync(entriesPath: string): Promise<(string | null)[]> {
const keys: (string | null)[] = [];
await forEachEntryAsync(entriesPath, line => {
const entry = parseEntry(line);
if (entry) {
keys.push(entry.key);
}
});
return keys;
}
/**
* Rebuilds a stopped follower's HAR from its entry log, which a killed follower's HAR can lag,
* without the requests an earlier follower for the device recorded. Then adds its requests to
* `recorded`. Returns false when it holds no new request.
*/
async function rebuildHarAsync(follower: Follower, recorded: Set<string>): Promise<boolean> {
const entriesPath = entriesPathFor(follower);
const entries: { start: number; offset: number; length: number }[] = [];
const requests: string[] = [];
await forEachEntryAsync(entriesPath, (line, offset) => {
const entry = parseEntry(line);
if (!entry || (entry.key !== null && recorded.has(entry.key))) {
return;
}
if (entry.key !== null) {
requests.push(entry.key);
}
entries.push({ start: entry.start, offset, length: Buffer.byteLength(line) });
});
if (entries.length === 0) {
return false;
}
await writeHarAsync(follower.filePath, entriesPath, entries);
for (const request of requests) {
recorded.add(request);
}
return true;
}
const HAR_HEADER_BYTES = 4_096;
const HAR_ENTRIES_START = '"entries":[';
/** Rebuilds the HAR from the given entry log lines, in start order as serve-sim writes it. */
async function writeHarAsync(
harPath: string,
entriesPath: string,
entries: { start: number; offset: number; length: number }[]
): Promise<void> {
// serve-sim writes `{"log":{...,"entries":[` first; its version and creator are kept.
const har = await open(harPath, 'r');
let header: string;
try {
const buffer = Buffer.alloc(HAR_HEADER_BYTES);
const { bytesRead } = await har.read(buffer, 0, buffer.length, 0);
header = buffer.subarray(0, bytesRead).toString('utf8');
} finally {
await har.close();
}
const at = header.indexOf(HAR_ENTRIES_START);
if (at === -1) {
throw new Error('The HAR does not start like a serve-sim HAR.');
}
const tempPath = `${harPath}.rebuilt.tmp`;
const out = await open(tempPath, 'wx', 0o600);
const source = await open(entriesPath, 'r');
try {
await out.write(Buffer.from(header.slice(0, at + HAR_ENTRIES_START.length)));
const sorted = [...entries].sort((a, b) => a.start - b.start);
for (const [index, { offset, length }] of sorted.entries()) {
const line = Buffer.alloc(length);
await source.read(line, 0, length, offset);
await out.write(index > 0 ? Buffer.concat([Buffer.from(','), line]) : line);
}
await out.write(Buffer.from(']}}\n'));
} finally {
await source.close();
await out.close();
}
await rename(tempPath, harPath);
}
@@ -1,5 +1,9 @@
# create-eas-build-function
## 27.11.0
No changes in this release.
## 27.10.0
No changes in this release.
@@ -1,6 +1,6 @@
{
"name": "create-eas-build-function",
"version": "27.10.0",
"version": "27.11.0",
"description": "Create functions for use in EAS Build custom builds.",
"keywords": [
"expo",
@@ -35,7 +35,7 @@
"clean": "rimraf ./build/ \"*.tsbuildinfo\""
},
"dependencies": {
"@expo/steps": "27.10.0"
"@expo/steps": "27.11.0"
},
"devDependencies": {
"@expo/package-manager": "1.9.10",
+4
View File
@@ -1,5 +1,9 @@
# @expo/downloader
## 27.11.0
No changes in this release.
## 27.10.0
No changes in this release.
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@expo/downloader",
"version": "27.10.0",
"version": "27.11.0",
"bugs": "https://github.com/expo/eas-cli/issues",
"license": "BUSL-1.1",
"author": "Expo <[email protected]>",
@@ -1,5 +1,9 @@
# eas-build-cache-provider
## 27.11.0
No changes in this release.
## 27.10.0
No changes in this release.
@@ -1,6 +1,6 @@
{
"name": "eas-build-cache-provider",
"version": "27.10.0",
"version": "27.11.0",
"description": "A build cache provider plugin for the Expo CLI",
"homepage": "https://github.com/expo/eas-cli",
"bugs": "https://github.com/expo/eas-cli/issues",
+7
View File
@@ -1,5 +1,12 @@
# @expo/eas-build-job
## 27.11.0
### Minor Changes
- Accept `issue_comment` as a `github.event_name` value in the workflow interpolation context. ([#4906](https://github.com/expo/eas-cli/pull/4906) by [@sswrk](https://github.com/sswrk))
- Support error occurrence events in Observe workflow context. ([#4860](https://github.com/expo/eas-cli/pull/4860) by [@AbbanMustafa](https://github.com/AbbanMustafa))
## 27.10.0
No changes in this release.
+3 -3
View File
@@ -1,6 +1,6 @@
{
"name": "@expo/eas-build-job",
"version": "27.10.0",
"version": "27.11.0",
"bugs": "https://github.com/expo/eas-cli/issues",
"license": "MIT",
"author": "Expo <[email protected]>",
@@ -25,9 +25,9 @@
"clean": "rimraf node_modules dist coverage \"*.tsbuildinfo\""
},
"dependencies": {
"@expo/logger": "27.10.0",
"@expo/logger": "27.11.0",
"@expo/results": "1.0.0",
"@expo/turtle-spawn": "27.10.0",
"@expo/turtle-spawn": "27.11.0",
"joi": "^17.13.9",
"semver": "^7.6.2",
"zod": "^4.6.7"
@@ -922,6 +922,50 @@ describe('GitHub context event payload passthrough', () => {
expect(parsed.github?.event).toMatchObject(context.github.event);
});
it('accepts the issue_comment event with issue and comment fields', () => {
const context = {
after: {},
needs: {},
github: {
event_name: 'issue_comment',
sha: 'abc123',
ref: 'refs/heads/main',
ref_name: 'main',
ref_type: 'branch',
event: {
action: 'created',
issue: {
number: 123,
title: 'Issue title',
},
comment: {
id: 456,
body: 'Comment body',
},
},
},
workflow: {
id: 'workflow-id',
name: 'Workflow',
filename: 'workflow.yml',
url: 'https://expo.dev',
},
app: {
id: 'app-id',
slug: 'app-slug',
},
account: {
id: 'account-id',
name: 'account-name',
},
};
const parsed = StaticWorkflowInterpolationContextZ.parse(context);
expect(parsed.github?.event_name).toBe('issue_comment');
expect(parsed.github?.event).toMatchObject(context.github.event);
});
});
describe('fetchEasCliVersionsAsync', () => {
@@ -1,7 +1,7 @@
import { ArchiveSourceType, BuildTrigger, StaticWorkflowInterpolationContextZ } from '../common';
import { Generic } from '../generic';
function createContext() {
function createContext(eventType: 'new_error' | 'error_occurrence' = 'new_error') {
return {
after: {},
needs: {},
@@ -16,7 +16,7 @@ function createContext() {
observe: {
event: {
id: '123e4567-e89b-42d3-a456-426614174001',
type: 'new_error' as const,
type: eventType,
occurredAt: '2026-10-29T12:00:00.000Z',
appId: '123e4567-e89b-42d3-a456-426614174000',
fingerprint: { value: 'error-fingerprint', version: 'v1' },
@@ -31,23 +31,36 @@ function createContext() {
}
describe('Observe workflow context', () => {
it('preserves the event when validating a generic job', () => {
it.each(['new_error', 'error_occurrence'] as const)(
'preserves %s events when validating a generic job',
eventType => {
const context = createContext(eventType);
const job = {
projectArchive: { type: ArchiveSourceType.GIT, gitCommitHash: 'abc123', gitRef: null },
steps: [{ run: 'echo "${{ observe.event.exception.message }}"', shell: 'sh' }],
secrets: { robotAccessToken: 'token', environmentSecrets: [] },
expoDevUrl: context.workflow.url,
builderEnvironment: { image: 'ubuntu', env: {} },
triggeredBy: BuildTrigger.GIT_BASED_INTEGRATION,
appId: context.app.id,
initiatingUserId: '123e4567-e89b-42d3-a456-426614174002',
workflowInterpolationContext: context,
};
const parsed = Generic.JobZ.parse(job);
expect(parsed.workflowInterpolationContext).toEqual(context);
}
);
it('rejects unknown Observe event types', () => {
const context = createContext();
const job = {
projectArchive: { type: ArchiveSourceType.GIT, gitCommitHash: 'abc123', gitRef: null },
steps: [{ run: 'echo "${{ observe.event.exception.message }}"', shell: 'sh' }],
secrets: { robotAccessToken: 'token', environmentSecrets: [] },
expoDevUrl: context.workflow.url,
builderEnvironment: { image: 'ubuntu', env: {} },
triggeredBy: BuildTrigger.GIT_BASED_INTEGRATION,
appId: context.app.id,
initiatingUserId: '123e4567-e89b-42d3-a456-426614174002',
workflowInterpolationContext: context,
};
const parsed = Generic.JobZ.parse(job);
expect(parsed.workflowInterpolationContext).toEqual(context);
expect(
StaticWorkflowInterpolationContextZ.safeParse({
...context,
observe: { event: { ...context.observe.event, type: 'unknown' } },
}).success
).toBe(false);
});
it('accepts nullable event metadata and an omitted device OS', () => {
+2 -2
View File
@@ -194,7 +194,7 @@ export const CacheSchema = Joi.object({
const GitHubContextZ = z.object({
triggering_actor: z.string().optional(),
event_name: z.enum(['push', 'pull_request', 'workflow_dispatch', 'schedule']),
event_name: z.enum(['push', 'pull_request', 'workflow_dispatch', 'schedule', 'issue_comment']),
sha: z.string(),
ref: z.string(),
ref_name: z.string(),
@@ -347,7 +347,7 @@ const SentryContextZ = z.looseObject({
const ObserveContextZ = z.looseObject({
event: z.looseObject({
id: z.uuid(),
type: z.literal('new_error'),
type: z.enum(['new_error', 'error_occurrence']),
occurredAt: z.iso.datetime(),
appId: z.uuid(),
fingerprint: z.looseObject({
+7
View File
@@ -1,5 +1,12 @@
# eas-cli
## 27.11.0
### Patch Changes
- Detect Factory Droid, Grok Bot, Claude Cowork, and Muse in EAS CLI telemetry. ([#4912](https://github.com/expo/eas-cli/pull/4912) by [@davidmokos](https://github.com/davidmokos))
- Mark the default device for each platform in `eas simulator:devices` and include `isDefault` in JSON output. ([#4895](https://github.com/expo/eas-cli/pull/4895) by [@gwdp](https://github.com/gwdp))
## 27.10.0
### Minor Changes
+149 -149
View File
File diff suppressed because it is too large. Load diff
+6 -6
View File
@@ -1,6 +1,6 @@
{
"name": "eas-cli",
"version": "27.10.0",
"version": "27.11.0",
"description": "EAS command line tool",
"keywords": [
"cli",
@@ -48,12 +48,12 @@
"@expo/code-signing-certificates": "0.0.5",
"@expo/config": "55.0.10",
"@expo/config-plugins": "55.0.7",
"@expo/eas-build-job": "27.10.0",
"@expo/eas-json": "27.10.0",
"@expo/eas-build-job": "27.11.0",
"@expo/eas-json": "27.11.0",
"@expo/env": "^1.0.0",
"@expo/experimentation": "0.0.5",
"@expo/json-file": "8.3.3",
"@expo/logger": "27.10.0",
"@expo/logger": "27.11.0",
"@expo/multipart-body-parser": "2.0.0",
"@expo/osascript": "2.1.4",
"@expo/package-manager": "1.9.10",
@@ -65,7 +65,7 @@
"@expo/results": "1.0.0",
"@expo/rudder-sdk-node": "1.1.1",
"@expo/spawn-async": "1.7.2",
"@expo/steps": "27.10.0",
"@expo/steps": "27.11.0",
"@expo/timeago.js": "1.0.0",
"@oclif/core": "^4.8.3",
"@oclif/plugin-autocomplete": "^3.2.40",
@@ -73,7 +73,7 @@
"@sentry/node": "7.77.0",
"@urql/core": "4.0.11",
"@urql/exchange-retry": "1.2.0",
"agent-cli-detector": "0.1.7",
"agent-cli-detector": "0.1.8",
"ajv": "8.20.0",
"ajv-formats": "2.1.1",
"better-opn": "3.0.2",
+4
View File
@@ -1,5 +1,9 @@
# @expo/eas-json
## 27.11.0
No changes in this release.
## 27.10.0
No changes in this release.
+2 -2
View File
@@ -1,6 +1,6 @@
{
"name": "@expo/eas-json",
"version": "27.10.0",
"version": "27.11.0",
"description": "A library for interacting with eas.json",
"homepage": "https://github.com/expo/eas-cli",
"bugs": "https://github.com/expo/eas-cli/issues",
@@ -32,7 +32,7 @@
},
"dependencies": {
"@babel/code-frame": "7.23.5",
"@expo/eas-build-job": "27.10.0",
"@expo/eas-build-job": "27.11.0",
"chalk": "4.1.2",
"env-string": "1.0.1",
"fs-extra": "11.2.0",
+4
View File
@@ -1,5 +1,9 @@
# eas-cli-local-build-plugin
## 27.11.0
No changes in this release.
## 27.10.0
No changes in this release.
+5 -5
View File
@@ -1,6 +1,6 @@
{
"name": "eas-cli-local-build-plugin",
"version": "27.10.0",
"version": "27.11.0",
"description": "Tool for running EAS compatible builds on a local machine.",
"bugs": "https://github.com/expo/eas-cli/issues",
"license": "BUSL-1.1",
@@ -26,12 +26,12 @@
"clean": "rimraf node_modules dist coverage \"*.tsbuildinfo\""
},
"dependencies": {
"@expo/build-tools": "27.10.0",
"@expo/build-tools": "27.11.0",
"@expo/bunyan": "^4.0.1",
"@expo/eas-build-job": "27.10.0",
"@expo/logger": "27.10.0",
"@expo/eas-build-job": "27.11.0",
"@expo/logger": "27.11.0",
"@expo/spawn-async": "^1.7.2",
"@expo/turtle-spawn": "27.10.0",
"@expo/turtle-spawn": "27.11.0",
"chalk": "4.1.2",
"env-paths": "^2.2.1",
"fs-extra": "^11.2.0",
+4
View File
@@ -1,5 +1,9 @@
# @expo/logger
## 27.11.0
No changes in this release.
## 27.10.0
No changes in this release.
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@expo/logger",
"version": "27.10.0",
"version": "27.11.0",
"bugs": "https://github.com/expo/eas-cli/issues",
"license": "BUSL-1.1",
"author": "Expo <[email protected]>",
+4
View File
@@ -1,5 +1,9 @@
# @expo/simulator-launcher
## 27.11.0
No changes in this release.
## 27.10.0
No changes in this release.
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@expo/simulator-launcher",
"version": "27.10.0",
"version": "27.11.0",
"description": "Launch and claim Simulator sessions on EAS workers",
"bugs": "https://github.com/expo/eas-cli/issues",
"license": "BUSL-1.1",
+4
View File
@@ -1,5 +1,9 @@
# @expo/steps
## 27.11.0
No changes in this release.
## 27.10.0
No changes in this release.
+3 -3
View File
@@ -1,6 +1,6 @@
{
"name": "@expo/steps",
"version": "27.10.0",
"version": "27.11.0",
"bugs": "https://github.com/expo/eas-cli/issues",
"license": "BUSL-1.1",
"author": "Expo <[email protected]>",
@@ -27,8 +27,8 @@
"clean": "rimraf node_modules dist coverage \"*.tsbuildinfo\""
},
"dependencies": {
"@expo/eas-build-job": "27.10.0",
"@expo/logger": "27.10.0",
"@expo/eas-build-job": "27.11.0",
"@expo/logger": "27.11.0",
"@expo/spawn-async": "^1.7.2",
"arg": "^5.0.2",
"fast-glob": "^3.3.2",
+4
View File
@@ -1,5 +1,9 @@
# @expo/template-file
## 27.11.0
No changes in this release.
## 27.10.0
No changes in this release.
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@expo/template-file",
"version": "27.10.0",
"version": "27.11.0",
"bugs": "https://github.com/expo/eas-cli/issues",
"license": "BUSL-1.1",
"author": "Expo <[email protected]>",
+4
View File
@@ -1,5 +1,9 @@
# @expo/turtle-spawn
## 27.11.0
No changes in this release.
## 27.10.0
No changes in this release.
+2 -2
View File
@@ -1,6 +1,6 @@
{
"name": "@expo/turtle-spawn",
"version": "27.10.0",
"version": "27.11.0",
"bugs": "https://github.com/expo/eas-cli/issues",
"license": "BUSL-1.1",
"author": "Expo <[email protected]>",
@@ -25,7 +25,7 @@
"clean": "rimraf node_modules dist coverage \"*.tsbuildinfo\""
},
"dependencies": {
"@expo/logger": "27.10.0",
"@expo/logger": "27.11.0",
"@expo/spawn-async": "^1.7.2"
},
"devDependencies": {
+4
View File
@@ -1,5 +1,9 @@
# @expo/vm-tools
## 27.11.0
No changes in this release.
## 27.10.0
No changes in this release.
+1 -1
View File
@@ -1,6 +1,6 @@
{
"name": "@expo/vm-tools",
"version": "27.10.0",
"version": "27.11.0",
"description": "VM startup script loader",
"bugs": "https://github.com/expo/eas-cli/issues",
"license": "BUSL-1.1",
+4
View File
@@ -1,5 +1,9 @@
# @expo/worker
## 27.11.0
No changes in this release.
## 27.10.0
No changes in this release.
+7 -7
View File
@@ -1,6 +1,6 @@
{
"name": "@expo/worker",
"version": "27.10.0",
"version": "27.11.0",
"private": true,
"scripts": {
"start": "yarn watch",
@@ -19,17 +19,17 @@
},
"dependencies": {
"@babel/core": "7.24.7",
"@expo/build-tools": "27.10.0",
"@expo/build-tools": "27.11.0",
"@expo/config-plugins": "55.0.7",
"@expo/config-types": "55.0.5",
"@expo/eas-build-job": "27.10.0",
"@expo/logger": "27.10.0",
"@expo/eas-build-job": "27.11.0",
"@expo/logger": "27.11.0",
"@expo/results": "1.0.0",
"@expo/rudder-sdk-node": "1.1.1",
"@expo/spawn-async": "1.7.2",
"@expo/steps": "27.10.0",
"@expo/template-file": "27.10.0",
"@expo/turtle-spawn": "27.10.0",
"@expo/steps": "27.11.0",
"@expo/template-file": "27.11.0",
"@expo/turtle-spawn": "27.11.0",
"@hapi/boom": "10.0.1",
"check-disk-space": "3.4.0",
"fast-glob": "3.3.2",
Generated
+40 -40
View File
@@ -2515,24 +2515,24 @@ __metadata:
languageName: node
linkType: hard
"@expo/build-tools@npm:27.10.0, @expo/build-tools@workspace:packages/build-tools":
"@expo/build-tools@npm:27.11.0, @expo/build-tools@workspace:packages/build-tools":
version: 0.0.0-use.local
resolution: "@expo/build-tools@workspace:packages/build-tools"
dependencies:
"@expo/config": "npm:55.0.10"
"@expo/config-plugins": "npm:55.0.7"
"@expo/downloader": "npm:27.10.0"
"@expo/eas-build-job": "npm:27.10.0"
"@expo/downloader": "npm:27.11.0"
"@expo/eas-build-job": "npm:27.11.0"
"@expo/env": "npm:^0.4.0"
"@expo/logger": "npm:27.10.0"
"@expo/logger": "npm:27.11.0"
"@expo/package-manager": "npm:1.9.10"
"@expo/plist": "npm:^0.3.5"
"@expo/repack-app": "npm:~0.9.0"
"@expo/results": "npm:^1.0.0"
"@expo/spawn-async": "npm:1.7.2"
"@expo/steps": "npm:27.10.0"
"@expo/template-file": "npm:27.10.0"
"@expo/turtle-spawn": "npm:27.10.0"
"@expo/steps": "npm:27.11.0"
"@expo/template-file": "npm:27.11.0"
"@expo/turtle-spawn": "npm:27.11.0"
"@expo/xcpretty": "npm:^4.4.7"
"@ngrok/ngrok": "npm:1.7.0"
"@sentry/node": "npm:7.77.0"
@@ -2768,7 +2768,7 @@ __metadata:
languageName: node
linkType: hard
"@expo/downloader@npm:27.10.0, @expo/downloader@workspace:packages/downloader":
"@expo/downloader@npm:27.11.0, @expo/downloader@workspace:packages/downloader":
version: 0.0.0-use.local
resolution: "@expo/downloader@workspace:packages/downloader"
dependencies:
@@ -2784,13 +2784,13 @@ __metadata:
languageName: unknown
linkType: soft
"@expo/eas-build-job@npm:27.10.0, @expo/eas-build-job@workspace:packages/eas-build-job":
"@expo/eas-build-job@npm:27.11.0, @expo/eas-build-job@workspace:packages/eas-build-job":
version: 0.0.0-use.local
resolution: "@expo/eas-build-job@workspace:packages/eas-build-job"
dependencies:
"@expo/logger": "npm:27.10.0"
"@expo/logger": "npm:27.11.0"
"@expo/results": "npm:1.0.0"
"@expo/turtle-spawn": "npm:27.10.0"
"@expo/turtle-spawn": "npm:27.11.0"
"@types/jest": "npm:^29.5.12"
"@types/node": "npm:22.20.5"
jest: "npm:^29.7.0"
@@ -2803,12 +2803,12 @@ __metadata:
languageName: unknown
linkType: soft
"@expo/eas-json@npm:27.10.0, @expo/eas-json@workspace:packages/eas-json":
"@expo/eas-json@npm:27.11.0, @expo/eas-json@workspace:packages/eas-json":
version: 0.0.0-use.local
resolution: "@expo/eas-json@workspace:packages/eas-json"
dependencies:
"@babel/code-frame": "npm:7.23.5"
"@expo/eas-build-job": "npm:27.10.0"
"@expo/eas-build-job": "npm:27.11.0"
"@tsconfig/node22": "npm:22.0.6"
"@types/babel__code-frame": "npm:7.0.3"
"@types/fs-extra": "npm:11.0.4"
@@ -2931,7 +2931,7 @@ __metadata:
languageName: node
linkType: hard
"@expo/logger@npm:27.10.0, @expo/logger@workspace:packages/logger":
"@expo/logger@npm:27.11.0, @expo/logger@workspace:packages/logger":
version: 0.0.0-use.local
resolution: "@expo/logger@workspace:packages/logger"
dependencies:
@@ -3149,12 +3149,12 @@ __metadata:
languageName: node
linkType: hard
"@expo/steps@npm:27.10.0, @expo/steps@workspace:packages/steps":
"@expo/steps@npm:27.11.0, @expo/steps@workspace:packages/steps":
version: 0.0.0-use.local
resolution: "@expo/steps@workspace:packages/steps"
dependencies:
"@expo/eas-build-job": "npm:27.10.0"
"@expo/logger": "npm:27.10.0"
"@expo/eas-build-job": "npm:27.11.0"
"@expo/logger": "npm:27.11.0"
"@expo/spawn-async": "npm:^1.7.2"
"@jest/globals": "npm:^29.7.0"
"@types/jest": "npm:^29.5.12"
@@ -3180,7 +3180,7 @@ __metadata:
languageName: unknown
linkType: soft
"@expo/template-file@npm:27.10.0, @expo/template-file@workspace:packages/template-file":
"@expo/template-file@npm:27.11.0, @expo/template-file@workspace:packages/template-file":
version: 0.0.0-use.local
resolution: "@expo/template-file@workspace:packages/template-file"
dependencies:
@@ -3203,11 +3203,11 @@ __metadata:
languageName: node
linkType: hard
"@expo/turtle-spawn@npm:27.10.0, @expo/turtle-spawn@workspace:packages/turtle-spawn":
"@expo/turtle-spawn@npm:27.11.0, @expo/turtle-spawn@workspace:packages/turtle-spawn":
version: 0.0.0-use.local
resolution: "@expo/turtle-spawn@workspace:packages/turtle-spawn"
dependencies:
"@expo/logger": "npm:27.10.0"
"@expo/logger": "npm:27.11.0"
"@expo/spawn-async": "npm:^1.7.2"
"@types/jest": "npm:^29.5.12"
"@types/node": "npm:22.20.5"
@@ -3238,17 +3238,17 @@ __metadata:
resolution: "@expo/worker@workspace:packages/worker"
dependencies:
"@babel/core": "npm:7.24.7"
"@expo/build-tools": "npm:27.10.0"
"@expo/build-tools": "npm:27.11.0"
"@expo/config-plugins": "npm:55.0.7"
"@expo/config-types": "npm:55.0.5"
"@expo/eas-build-job": "npm:27.10.0"
"@expo/logger": "npm:27.10.0"
"@expo/eas-build-job": "npm:27.11.0"
"@expo/logger": "npm:27.11.0"
"@expo/results": "npm:1.0.0"
"@expo/rudder-sdk-node": "npm:1.1.1"
"@expo/spawn-async": "npm:1.7.2"
"@expo/steps": "npm:27.10.0"
"@expo/template-file": "npm:27.10.0"
"@expo/turtle-spawn": "npm:27.10.0"
"@expo/steps": "npm:27.11.0"
"@expo/template-file": "npm:27.11.0"
"@expo/turtle-spawn": "npm:27.11.0"
"@hapi/boom": "npm:10.0.1"
"@types/babel__core": "npm:7.20.5"
"@types/fs-extra": "npm:11.0.4"
@@ -8380,12 +8380,12 @@ __metadata:
languageName: node
linkType: hard
"agent-cli-detector@npm:0.1.7":
version: 0.1.7
resolution: "agent-cli-detector@npm:0.1.7"
"agent-cli-detector@npm:0.1.8":
version: 0.1.8
resolution: "agent-cli-detector@npm:0.1.8"
bin:
agent-cli-detector: dist/cli.js
checksum: 10c0/4ff016e5fad2d96a0c53db9fd75c2359bb005a672969e8e6e7bce5c910e94107c226cbcba1303409d1da3a1cdf8f22290e63049705bb530823cce4699d39fc1d
checksum: 10c0/1d686317a6f18b1a2849b6da2bd881cebafc7304933019876b0a93686e29921f12f1aa41a4416360ab4a4615e59b370d39fd28501992106eff7e127aebe6853b
languageName: node
linkType: hard
@@ -10123,7 +10123,7 @@ __metadata:
resolution: "create-eas-build-function@workspace:packages/create-eas-build-function"
dependencies:
"@expo/package-manager": "npm:1.9.10"
"@expo/steps": "npm:27.10.0"
"@expo/steps": "npm:27.11.0"
"@jest/globals": "npm:^29.7.0"
"@types/jest": "npm:^29.5.12"
"@types/node": "npm:22.20.5"
@@ -10707,12 +10707,12 @@ __metadata:
version: 0.0.0-use.local
resolution: "eas-cli-local-build-plugin@workspace:packages/local-build-plugin"
dependencies:
"@expo/build-tools": "npm:27.10.0"
"@expo/build-tools": "npm:27.11.0"
"@expo/bunyan": "npm:^4.0.1"
"@expo/eas-build-job": "npm:27.10.0"
"@expo/logger": "npm:27.10.0"
"@expo/eas-build-job": "npm:27.11.0"
"@expo/logger": "npm:27.11.0"
"@expo/spawn-async": "npm:^1.7.2"
"@expo/turtle-spawn": "npm:27.10.0"
"@expo/turtle-spawn": "npm:27.11.0"
"@types/fs-extra": "npm:^11.0.4"
"@types/hapi__joi": "npm:^17.1.14"
"@types/lodash": "npm:^4.17.4"
@@ -10766,12 +10766,12 @@ __metadata:
"@expo/code-signing-certificates": "npm:0.0.5"
"@expo/config": "npm:55.0.10"
"@expo/config-plugins": "npm:55.0.7"
"@expo/eas-build-job": "npm:27.10.0"
"@expo/eas-json": "npm:27.10.0"
"@expo/eas-build-job": "npm:27.11.0"
"@expo/eas-json": "npm:27.11.0"
"@expo/env": "npm:^1.0.0"
"@expo/experimentation": "npm:0.0.5"
"@expo/json-file": "npm:8.3.3"
"@expo/logger": "npm:27.10.0"
"@expo/logger": "npm:27.11.0"
"@expo/multipart-body-parser": "npm:2.0.0"
"@expo/osascript": "npm:2.1.4"
"@expo/package-manager": "npm:1.9.10"
@@ -10783,7 +10783,7 @@ __metadata:
"@expo/results": "npm:1.0.0"
"@expo/rudder-sdk-node": "npm:1.1.1"
"@expo/spawn-async": "npm:1.7.2"
"@expo/steps": "npm:27.10.0"
"@expo/steps": "npm:27.11.0"
"@expo/timeago.js": "npm:1.0.0"
"@graphql-codegen/cli": "npm:6.3.1"
"@graphql-codegen/introspection": "npm:5.0.2"
@@ -10818,7 +10818,7 @@ __metadata:
"@types/ws": "npm:8.5.10"
"@urql/core": "npm:4.0.11"
"@urql/exchange-retry": "npm:1.2.0"
agent-cli-detector: "npm:0.1.7"
agent-cli-detector: "npm:0.1.8"
ajv: "npm:8.20.0"
ajv-formats: "npm:2.1.1"
axios: "npm:1.18.1"