@devicelab/maestro-runner-darwin-arm64 1.1.29 → 1.1.30

package/drivers/ios/WebDriverAgent/lib/xcodebuild.ts

@@ -26,6 +26,9 @@ import {
 
 const DEFAULT_SIGNING_ID = 'iPhone Developer';
 const PREBUILD_DELAY = 0;
+// Bounds the best-effort udid case lookup so a hung 'xcodebuild -showdestinations' cannot stall
+// session startup past wdaLaunchTimeout, which does not cover this step.
+const XCODE_DEVICE_UDID_RESOLUTION_TIMEOUT_MS = 15000;
 
 const ERROR_WRITING_ATTACHMENT = 'Error writing attachment data to file';
 const ERROR_COPYING_ATTACHMENT = 'Error copying testing attachment';
@@ -43,6 +46,7 @@ export class XcodeBuild {
   readonly device: AppleDevice;
   readonly realDevice: boolean;
   readonly agentPath: string;
+  private _xcodeDeviceUdidPromise?: Promise<string>;
   readonly bootstrapPath: string;
   readonly platformVersion?: string;
   readonly platformName?: string;
@@ -70,7 +74,6 @@ export class XcodeBuild {
   private readonly resultBundlePath?: string;
   private readonly resultBundleVersion?: string;
   private _didBuildFail: boolean;
-  private _didProcessExit: boolean;
   private readonly _buildSettingsPromises = new Map<string, Promise<XcodeBuildSettings | undefined>>();
   private noSessionProxy?: NoSessionProxy;
   private xctestrunFilePath?: string;
@@ -126,7 +129,6 @@ export class XcodeBuild {
     this.resultBundleVersion = args.resultBundleVersion;
 
     this._didBuildFail = false;
-    this._didProcessExit = false;
   }
 
   /**
@@ -138,6 +140,8 @@ export class XcodeBuild {
     this.noSessionProxy = noSessionProxy;
 
     if (this.useXctestrunFile) {
+      // Keep the caller's udid casing: the canonical case is only for '-destination id=';
+      // switching it here would orphan an existing .xctestrun file on case-sensitive filesystems.
       const deviceInfo = {
         isRealDevice: !!this.realDevice,
         udid: this.device.udid,
@@ -244,11 +248,13 @@ export class XcodeBuild {
       throw new Error('xcodebuild subprocess was not created');
     }
     const xcodebuild = this.xcodebuild;
+    // Exit state belongs to this invocation, including build-only invocations.
+    let didProcessExit = false;
     return await new Promise<StringRecord | void>((resolve, reject) => {
       xcodebuild.once('exit', (code, signal) => {
         xcodeLog.error(`xcodebuild exited with code '${code}' and signal '${signal}'`);
         xcodebuild.removeAllListeners();
-        this._didProcessExit = true;
+        didProcessExit = true;
         if (this._didBuildFail || (!signal && code !== 0)) {
           let errorMessage =
             `xcodebuild failed with code ${code}.` +
@@ -279,7 +285,7 @@ export class XcodeBuild {
           }
           await xcodebuild.start(true);
           if (!buildOnly) {
-            const result = await this.waitForStart(timer);
+            const result = await this.waitForStart(timer, () => didProcessExit);
             resolve(result ?? undefined);
           }
         } catch (err: any) {
@@ -358,7 +364,48 @@ export class XcodeBuild {
     return entry.buildSettings;
   }
 
-  private getCommand(buildOnly: boolean = false): {cmd: string; args: string[]} {
+  /**
+   * Best-effort resolves this real device's udid to the case xcodebuild's own
+   * `-showdestinations` listing reports it in, so the `-destination id=` argument this class
+   * builds does not depend on whatever case the caller happened to pass in — different Apple
+   * tooling doesn't agree on udid letter case. Falls back to `device.udid` unchanged on any
+   * failure, timeout, or when no destination matches. A no-op for simulators, whose udid is
+   * already canonical by construction.
+   */
+  private resolveXcodeDeviceUdid(): Promise<string> {
+    if (!this.realDevice) {
+      return Promise.resolve(this.device.udid);
+    }
+    // Cache the in-flight promise itself (not just a "did we start" flag), so concurrent callers
+    // await the same resolution instead of one of them racing ahead with a value that isn't
+    // resolved yet.
+    if (!this._xcodeDeviceUdidPromise) {
+      this._xcodeDeviceUdidPromise = this.fetchXcodeDeviceUdid();
+    }
+    return this._xcodeDeviceUdidPromise;
+  }
+
+  private async fetchXcodeDeviceUdid(): Promise<string> {
+    const runnerScheme = `WebDriverAgentRunner${getPlatformSchemeSuffix(this.platformName || '')}`;
+    let stdout: string;
+    try {
+      ({stdout} = await exec('xcodebuild', ['-showdestinations', '-project', this.agentPath, '-scheme', runnerScheme], {
+        timeout: XCODE_DEVICE_UDID_RESOLUTION_TIMEOUT_MS,
+      }));
+    } catch (err: any) {
+      this.log.debug(
+        `Cannot list xcodebuild destinations to resolve the canonical udid case for '${this.device.udid}'. ` +
+          `Will use it as is. Original error: ${err.message}`,
+      );
+      return this.device.udid;
+    }
+
+    const udid = this.device.udid.toLowerCase();
+    const match = [...stdout.matchAll(/\bid:([0-9A-Fa-f-]+)/g)].find(([, id]) => id.toLowerCase() === udid);
+    return match?.[1] ?? this.device.udid;
+  }
+
+  private getCommand(buildOnly: boolean, resolvedUdid: string): {cmd: string; args: string[]} {
     const cmd = 'xcodebuild';
     const args: string[] = [];
 
@@ -396,7 +443,7 @@ export class XcodeBuild {
         args.push('-derivedDataPath', this.derivedDataPath);
       }
     }
-    args.push('-destination', `id=${this.device.udid}`);
+    args.push('-destination', `id=${resolvedUdid}`);
 
     const versionMatch = this.platformVersion ? new RegExp(/^(\d+)\.(\d+)/).exec(this.platformVersion) : null;
     if (versionMatch) {
@@ -443,7 +490,8 @@ export class XcodeBuild {
       await setRealDeviceSecurity(this.keychainPath, this.keychainPassword);
     }
 
-    const {cmd, args} = this.getCommand(buildOnly);
+    const resolvedUdid = await this.resolveXcodeDeviceUdid();
+    const {cmd, args} = this.getCommand(buildOnly, resolvedUdid);
     this.log.debug(
       `Beginning ${buildOnly ? 'build' : 'test'} with command '${cmd} ${args.join(' ')}' ` +
         `in directory '${this.bootstrapPath}'`,
@@ -505,7 +553,7 @@ export class XcodeBuild {
     return xcodebuild;
   }
 
-  private async waitForStart(timer: timing.Timer): Promise<StringRecord | null> {
+  private async waitForStart(timer: timing.Timer, didProcessExit: () => boolean): Promise<StringRecord | null> {
     // try to connect once every 0.5 seconds, until `launchTimeout` is up
     const timeout = this.launchTimeout || 60000; // Default to 60 seconds if not set
     this.log.debug(`Waiting up to ${timeout}ms for WebDriverAgent to start`);
@@ -517,7 +565,7 @@ export class XcodeBuild {
       }
       const noSessionProxy = this.noSessionProxy;
       await retryInterval(retries, 1000, async () => {
-        if (this._didProcessExit) {
+        if (didProcessExit()) {
           // there has been an error elsewhere and we need to short-circuit
           return currentStatus;
         }
@@ -537,7 +585,7 @@ export class XcodeBuild {
         }
       });
 
-      if (this._didProcessExit) {
+      if (didProcessExit()) {
         // there has been an error elsewhere and we need to short-circuit
         return currentStatus;
       }

package/drivers/ios/WebDriverAgent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium-webdriveragent",
-  "version": "16.12.8",
+  "version": "16.17.5",
   "description": "Package bundling WebDriverAgent",
   "keywords": [
     "Appium",
@@ -9,15 +9,16 @@
     "WebDriverAgent",
     "iOS"
   ],
-  "homepage": "https://github.com/appium/WebDriverAgent#readme",
+  "homepage": "https://github.com/appium/appium-ios/tree/main/packages/webdriveragent",
   "bugs": {
-    "url": "https://github.com/appium/WebDriverAgent/issues"
+    "url": "https://github.com/appium/appium-ios/issues"
   },
   "license": "Apache-2.0",
   "author": "Appium Contributors",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/appium/WebDriverAgent.git"
+    "url": "https://github.com/appium/appium-ios.git",
+    "directory": "packages/webdriveragent"
   },
   "files": [
     "lib",
@@ -48,10 +49,6 @@
     "build": "tsc -b",
     "dev": "npm run build -- --watch",
     "clean": "npm run build -- --clean",
-    "lint": "oxlint -c oxlint.config.mjs .",
-    "lint:fix": "oxlint -c oxlint.config.mjs --fix .",
-    "format": "oxfmt -c oxfmt.config.mjs .",
-    "format:check": "oxfmt -c oxfmt.config.mjs --check .",
     "prepare": "npm run build",
     "version": "npm run sync-wda-version",
     "test": "node --enable-source-maps --experimental-test-module-mocks --test --test-timeout=60000 \"./build/test/unit/**/*.spec.js\"",
@@ -67,22 +64,18 @@
     "@appium/base-driver": "^10.8.0",
     "@appium/strongbox": "^2.0.0",
     "@appium/support": "^7.2.6",
-    "appium-ios-simulator": "^9.1.3",
-    "async-lock": "^1.0.0",
-    "asyncbox": "^6.4.3",
+    "asyncbox": "^6.5.0",
     "axios": "^1.18.0",
     "teen_process": "^4.2.0"
   },
   "devDependencies": {
+    "@appium/coresim": "^1.14.0",
     "@appium/oxc-config": "^1.1.0",
-    "@appium/semantic-release-config": "^1.1.0",
     "@appium/tsconfig": "^1.2.0",
     "@appium/types": "^1.0.0-rc.1",
-    "@types/async-lock": "^1.4.2",
     "@types/node": "^26.0.0",
     "@types/sinon": "^22.0.0",
-    "appium-xcode": "^7.1.1",
-    "node-simctl": "^9.0.0",
+    "appium-xcode": "^7.2.4",
     "semver": "^7.3.7",
     "sinon": "^22.0.0"
   },

package/drivers/ios/WebDriverAgent/test/functional/helpers/display-settings.ts

@@ -0,0 +1,49 @@
+import assert from 'node:assert/strict';
+
+/** Exercise the currentDisplayId setting against a live WDA session. */
+export async function assertCurrentDisplayIdSetting(baseUrl: string, sessionId: string): Promise<void> {
+  const screensResponse = await fetch(`${baseUrl}/wda/screens`);
+  assert.equal(screensResponse.status, 200);
+  const {value: screens} = (await screensResponse.json()) as {
+    value: {displayId: number; isMain: boolean}[];
+  };
+  const main = screens.find((screen) => screen.isMain);
+  assert.ok(main, 'expected a main display');
+  const sessionUrl = `${baseUrl}/session/${sessionId}`;
+  const setDisplay = async (value: unknown) =>
+    await fetch(`${sessionUrl}/appium/settings`, {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({settings: {currentDisplayId: value}}),
+    });
+  const getDisplay = async () => {
+    const response = await fetch(`${sessionUrl}/appium/settings`);
+    assert.equal(response.status, 200);
+    return ((await response.json()) as {value: {currentDisplayId: number}}).value.currentDisplayId;
+  };
+  const assertScreenshot = async () => {
+    const response = await fetch(`${sessionUrl}/screenshot`);
+    assert.equal(response.status, 200);
+    const {value} = (await response.json()) as {value: string};
+    assert.ok(Buffer.from(value, 'base64').length > 0, 'expected screenshot data');
+  };
+
+  assert.equal(await getDisplay(), main.displayId);
+  assert.equal((await setDisplay(main.displayId)).status, 200);
+  assert.equal(await getDisplay(), main.displayId);
+  await assertScreenshot();
+
+  const unknownId = Math.max(...screens.map((screen) => screen.displayId)) + 1;
+  for (const value of [true, false, unknownId, 1.5, '1']) {
+    const response = await setDisplay(value);
+    assert.equal(response.status, 400, `expected invalid argument for ${JSON.stringify(value)}`);
+    const {value: body} = (await response.json()) as {value: {error: string}};
+    assert.equal(body.error, 'invalid argument');
+    assert.equal(await getDisplay(), main.displayId, 'invalid input must not change the display');
+  }
+  assert.equal(await getDisplay(), main.displayId);
+
+  assert.equal((await setDisplay(null)).status, 200);
+  assert.equal(await getDisplay(), main.displayId);
+  await assertScreenshot();
+}

package/drivers/ios/WebDriverAgent/test/functional/helpers/simulator.ts

@@ -1,4 +1,4 @@
-import {Simctl} from 'node-simctl';
+import {NativeSimctl, SimDeviceState} from '@appium/coresim';
 
 import type {AppleDevice} from '../../../lib/types.js';
 import {DEVICE_NAME} from '../desired.js';
@@ -9,7 +9,7 @@ const LOCAL_SIM_BOOT_TIMEOUT_MS = 60 * 1000 * 5;
  * Locates the simulator these tests should run against.
  *
  * In CI, the workflow boots and settles a simulator ahead of time (via
- * `futureware-tech/simulator-action` + `Scripts/ci/wait-for-simulator-idle.mjs`) and passes its
+ * `futureware-tech/simulator-action` with `settle_timeout_seconds`) and passes its
  * UDID through `SIMULATOR_UDID` - these tests must not boot their own there, since CI applies the
  * settle-wait stability fix once per job, not once per test file.
  *
@@ -28,17 +28,17 @@ export async function getTargetDevice(): Promise<AppleDevice> {
     return {udid: process.env.SIMULATOR_UDID};
   }
 
-  const simctl = new Simctl();
-  const allDevices = Object.values(await simctl.getDevices()).flat();
+  const simctl = new NativeSimctl();
+  const allDevices = await simctl.getDevices();
   const device = allDevices.find((d) => d.name === DEVICE_NAME);
   if (!device) {
     const available = [...new Set(allDevices.map((d) => d.name))].sort().join(', ');
     throw new Error(`No simulator named '${DEVICE_NAME}' exists. Available simulators: ${available || '(none)'}`);
   }
 
-  if (device.state !== 'Booted') {
-    simctl.udid = device.udid;
-    await simctl.startBootMonitor({shouldPreboot: true, timeout: LOCAL_SIM_BOOT_TIMEOUT_MS});
+  if (device.state !== SimDeviceState.Booted) {
+    await simctl.bootDevice(device.udid);
+    await simctl.waitForBoot(device.udid, {timeoutMs: LOCAL_SIM_BOOT_TIMEOUT_MS});
   }
 
   return {udid: device.udid};

package/drivers/ios/WebDriverAgent/test/functional/webdriveragent-e2e.spec.ts

@@ -5,6 +5,7 @@ import {describe, before, afterEach, it} from 'node:test';
 import type {AppleDevice} from '../../lib/types.js';
 import {WebDriverAgent} from '../../lib/webdriveragent.js';
 import {PLATFORM_NAME, PLATFORM_VERSION} from './desired.js';
+import {assertCurrentDisplayIdSetting} from './helpers/display-settings.js';
 import {getTargetDevice} from './helpers/simulator.js';
 
 const WDA_BASE_URL = 'http://localhost:8100';
@@ -59,6 +60,9 @@ async function assertSessionScopedSourceWorks(): Promise<void> {
     assert.equal(sessionSourceResponse.status, 200);
     const sessionSource = (await sessionSourceResponse.json()) as {value: string};
     assert.ok(sessionSource.value.length > 0, 'expected session-scoped /source to return non-empty page source');
+    if (PLATFORM_NAME.toLowerCase() === 'ios') {
+      await assertCurrentDisplayIdSetting(WDA_BASE_URL, wdaSessionId);
+    }
   } finally {
     await fetch(`${WDA_BASE_URL}/session/${wdaSessionId}`, {method: 'DELETE'});
   }

package/drivers/ios/WebDriverAgent/test/unit/xcodebuild.spec.ts

@@ -0,0 +1,230 @@
+import assert from 'node:assert/strict';
+import {EventEmitter} from 'node:events';
+import {describe, it, beforeEach, mock} from 'node:test';
+
+import * as teenProcess from 'teen_process';
+
+import type {XcodeBuildArgs} from '../../lib/types.js';
+import * as utilsIndex from '../../lib/utils/index.js';
+
+let currentExec: (...args: any[]) => any = async () => ({stdout: '', stderr: ''});
+
+mock.module('teen_process', {
+  namedExports: {
+    ...teenProcess,
+    exec: (...args: any[]) => currentExec(...args),
+  },
+});
+
+let currentSetXctestrunFile: (...args: any[]) => any = async () => '/fake/WebDriverAgentRunner.xctestrun';
+
+mock.module('../../lib/utils/index.js', {
+  namedExports: {
+    ...utilsIndex,
+    setXctestrunFile: (...args: any[]) => currentSetXctestrunFile(...args),
+  },
+});
+
+const {XcodeBuild} = await import('../../lib/xcodebuild.js');
+
+const SHOWDESTINATIONS_OUTPUT = `
+\tDestinations compatible with the "WebDriverAgentRunner" scheme:
+\t\t{ platform:iOS, id:00008030-000A49391460202E, name:iPad von Galyna }
+\t\t{ platform:iOS Simulator, id:BB720847-B182-40BD-BB5A-338951D32ADC, OS:27.0, name:iPad (A16) }
+`;
+
+function makeXcodeBuild(udid: string, realDevice: boolean): InstanceType<typeof XcodeBuild> {
+  const args: XcodeBuildArgs = {
+    realDevice,
+    agentPath: '/fake/WebDriverAgent.xcodeproj',
+    bootstrapPath: '/fake',
+  };
+  return new XcodeBuild({udid}, args);
+}
+
+describe('XcodeBuild real-device udid case resolution', function () {
+  beforeEach(function () {
+    currentExec = async () => ({stdout: SHOWDESTINATIONS_OUTPUT, stderr: ''});
+  });
+
+  it('resolves to the canonical case xcodebuild reports', async function () {
+    const xcodebuild = makeXcodeBuild('00008030-000a49391460202e', true);
+    const resolved = await (xcodebuild as any).resolveXcodeDeviceUdid();
+    assert.strictEqual(resolved, '00008030-000A49391460202E');
+  });
+
+  it('falls back to the given udid when no destination matches', async function () {
+    const xcodebuild = makeXcodeBuild('unknown-udid', true);
+    const resolved = await (xcodebuild as any).resolveXcodeDeviceUdid();
+    assert.strictEqual(resolved, 'unknown-udid');
+  });
+
+  it("falls back to the given udid when 'xcodebuild -showdestinations' fails", async function () {
+    currentExec = async () => {
+      throw new Error('boom');
+    };
+    const xcodebuild = makeXcodeBuild('some-udid', true);
+    const resolved = await (xcodebuild as any).resolveXcodeDeviceUdid();
+    assert.strictEqual(resolved, 'some-udid');
+  });
+
+  it('is a no-op for simulators, whose udid is already canonical', async function () {
+    let execCalled = false;
+    currentExec = async () => {
+      execCalled = true;
+      return {stdout: '', stderr: ''};
+    };
+    const xcodebuild = makeXcodeBuild('sim-udid', false);
+    const resolved = await (xcodebuild as any).resolveXcodeDeviceUdid();
+    assert.strictEqual(execCalled, false);
+    assert.strictEqual(resolved, 'sim-udid');
+  });
+
+  it("only shells out to 'xcodebuild -showdestinations' once even if resolution is triggered multiple times", async function () {
+    let execCallCount = 0;
+    currentExec = async () => {
+      execCallCount++;
+      return {stdout: SHOWDESTINATIONS_OUTPUT, stderr: ''};
+    };
+    const xcodebuild = makeXcodeBuild('00008030-000a49391460202e', true);
+    await (xcodebuild as any).resolveXcodeDeviceUdid();
+    await (xcodebuild as any).resolveXcodeDeviceUdid();
+    assert.strictEqual(execCallCount, 1);
+  });
+
+  it('lets truly concurrent callers await the same in-flight resolution instead of racing ahead', async function () {
+    let execCallCount = 0;
+    let releaseExec: () => void = () => {};
+    const execGate = new Promise<void>((resolve) => {
+      releaseExec = resolve;
+    });
+    currentExec = async () => {
+      execCallCount++;
+      await execGate;
+      return {stdout: SHOWDESTINATIONS_OUTPUT, stderr: ''};
+    };
+    const xcodebuild = makeXcodeBuild('00008030-000a49391460202e', true);
+
+    // Both calls start before the (gated) exec() resolves — a naive "already started" boolean
+    // would let the second one return immediately with a value that isn't resolved yet.
+    const first = (xcodebuild as any).resolveXcodeDeviceUdid();
+    const second = (xcodebuild as any).resolveXcodeDeviceUdid();
+    releaseExec();
+    const [firstResolved, secondResolved] = await Promise.all([first, second]);
+
+    assert.strictEqual(execCallCount, 1);
+    assert.strictEqual(firstResolved, '00008030-000A49391460202E');
+    assert.strictEqual(secondResolved, '00008030-000A49391460202E');
+  });
+
+  it("builds the '-destination id=' argument from the resolved udid", async function () {
+    const xcodebuild = makeXcodeBuild('00008030-000a49391460202e', true);
+    const resolved = await (xcodebuild as any).resolveXcodeDeviceUdid();
+    const {args} = (xcodebuild as any).getCommand(false, resolved);
+    assert.ok(args.includes('id=00008030-000A49391460202E'));
+  });
+
+  it("bounds 'xcodebuild -showdestinations' with a timeout", async function () {
+    let capturedOpts: any;
+    currentExec = async (_cmd: string, _args: string[], opts: any) => {
+      capturedOpts = opts;
+      return {stdout: SHOWDESTINATIONS_OUTPUT, stderr: ''};
+    };
+    const xcodebuild = makeXcodeBuild('00008030-000a49391460202e', true);
+    await (xcodebuild as any).resolveXcodeDeviceUdid();
+    assert.ok(typeof capturedOpts?.timeout === 'number' && capturedOpts.timeout > 0);
+  });
+
+  it('falls back to the given udid when resolution times out', async function () {
+    currentExec = async () => {
+      throw new Error("Command 'xcodebuild ...' timed out after 15000ms");
+    };
+    const xcodebuild = makeXcodeBuild('some-udid', true);
+    const resolved = await (xcodebuild as any).resolveXcodeDeviceUdid();
+    assert.strictEqual(resolved, 'some-udid');
+  });
+
+  it("keeps the caller's udid casing for the .xctestrun file lookup, unaffected by resolution", async function () {
+    let capturedDeviceInfo: any;
+    currentSetXctestrunFile = async ({deviceInfo}: any) => {
+      capturedDeviceInfo = deviceInfo;
+      return '/fake/WebDriverAgentRunner.xctestrun';
+    };
+    const xcodebuild = new XcodeBuild(
+      {udid: '00008030-000a49391460202e'},
+      {
+        realDevice: true,
+        agentPath: '/fake/WebDriverAgent.xcodeproj',
+        bootstrapPath: '/fake',
+        useXctestrunFile: true,
+      },
+    );
+    await xcodebuild.init({} as any);
+    assert.strictEqual(capturedDeviceInfo.udid, '00008030-000a49391460202e');
+  });
+});
+
+describe('XcodeBuild readiness after a previous process exits', function () {
+  function setup() {
+    const build = new XcodeBuild(
+      {udid: 'sim-udid'},
+      {
+        realDevice: false,
+        agentPath: '/fake',
+        bootstrapPath: '/fake',
+        prebuildDelay: 0,
+      },
+    );
+    const processes: EventEmitter[] = [];
+    let statusCalls = 0;
+    const status = {ready: true};
+    (build as any).noSessionProxy = {
+      timeout: 5000,
+      command: async () => {
+        statusCalls++;
+        return status;
+      },
+    };
+    (build as any).createSubProcess = async (buildOnly: boolean) => {
+      const process = new EventEmitter();
+      processes.push(process);
+      (process as any).start = async () => {
+        if (buildOnly) {
+          process.emit('exit', 0, null);
+        }
+      };
+      return process;
+    };
+    return {build, processes, status, statusCalls: () => statusCalls};
+  }
+
+  it('checks status after a successful prebuild', async function () {
+    const fixture = setup();
+    await fixture.build.prebuild();
+    assert.deepStrictEqual(await fixture.build.start(), fixture.status);
+    assert.strictEqual(fixture.statusCalls(), 1);
+  });
+
+  it('checks status again when restarting the same instance', async function () {
+    const fixture = setup();
+    await fixture.build.start();
+    fixture.processes[0].emit('exit', 0, null);
+    assert.deepStrictEqual(await fixture.build.start(), fixture.status);
+    assert.strictEqual(fixture.statusCalls(), 2);
+  });
+
+  it('does not let an old process exit mark the new process as exited', async function () {
+    const fixture = setup();
+    await fixture.build.start();
+    const create = (fixture.build as any).createSubProcess;
+    (fixture.build as any).createSubProcess = async (buildOnly: boolean) => {
+      const process = await create(buildOnly);
+      process.start = async () => {
+        fixture.processes[0].emit('exit', 0, null);
+      };
+      return process;
+    };
+    assert.deepStrictEqual(await fixture.build.start(), fixture.status);
+    assert.strictEqual(fixture.statusCalls(), 2);
+  });
+});

package/drivers/ios/WebDriverAgent/tsconfig.json

@@ -10,5 +10,6 @@
     "module": "NodeNext",
     "moduleResolution": "NodeNext"
   },
-  "include": ["lib", "test"]
+  "include": ["lib", "test"],
+  "references": [{"path": "../coresim"}, {"path": "../xcode"}]
 }

package/drivers/ios/devicelab-ios-agent/README.md

@@ -38,6 +38,16 @@ maestro-runner --platform ios --driver devicelab --team-id <TEAM_ID> \
 Regenerate `SigningStub.xcodeproj` from `signing-stub/project.yml` with
 `xcodegen generate`.
 
+## Access
+
+Each run starts the agent with a random token (`DL_AGENT_TOKEN`, through
+`SIMCTL_CHILD_` or the xctestrun's environment) and sends it on every request
+as `X-DeviceLab-Token`; an agent built with token support answers a request
+without it 401 and runs nothing. The token is saved, readable by the user only,
+in `~/.maestro-runner/cache/devicelab-ios-agent/<udid>/agent.json` so a later
+run can re-attach to a kept agent. The agent listens on 127.0.0.1 only: on a
+simulator that is the Mac, on a device the end of the usbmux forward.
+
 Overrides:
 
 - `DEVICELAB_IOS_AGENT_DIR` — use an agent build from another directory
@@ -49,3 +59,5 @@ Overrides:
 - `DEVICELAB_IOS_AGENT_BUNDLE_ID` — sign the agent on a device as another
   bundle id (a personal team cannot use the team wildcard App ID, and
   `dev.devicelab.agent` may already be registered elsewhere)
+- `DEVICELAB_IOS_AGENT_BIND=any` — on a device, have the agent listen on every
+  interface instead of loopback (the token is still required)

package/drivers/ios/devicelab-ios-agent/device/manifest.json

@@ -1,18 +1,18 @@
 {
-  "version": "a2f0bc8",
+  "version": "ff2be7b",
   "protocol": "1.0",
   "xcode": "Xcode 27.0",
   "runnerBundleId": "dev.devicelab.agent.uitests.xctrunner",
   "hostBundleId": "dev.devicelab.agent",
   "files": {
     "agent.xctestrun": "93df94d1ffdc3f93a8cbe7d9b453096bde1436e8ed7cafd88436dfbc210d3f98",
-    "DevicelabIOSAgent.app/DevicelabIOSAgent": "398d638b732d9dd5e088c9a1fb75abe231adc6ea506227c3c9ac9c53e48c088d",
+    "DevicelabIOSAgent.app/DevicelabIOSAgent": "98a49ac56496fd30dfec399c6c20b6070f478ee7b3e2f84ad0df7ebab4574864",
     "DevicelabIOSAgent.app/Info.plist": "cba8d7ca7542f6c6a0bf195b957a692fa5a924f0c4ef3c547edd5100399b8b7c",
     "DevicelabIOSAgent.app/PkgInfo": "82502191c9484b04d685374f9879a0066069c49b8acae7a04b01d38d07e8eca0",
     "DevicelabIOSAgentUITests-Runner.app/DevicelabIOSAgentUITests-Runner": "26d1a9837de9735a1c9dcaef554144297f03d6291c8421aa04d6e8f6c9bc5833",
     "DevicelabIOSAgentUITests-Runner.app/Info.plist": "ffc0b193115180aa4af30f183fe4bf67eb821c79c763f363fdd7b41e82262498",
     "DevicelabIOSAgentUITests-Runner.app/PkgInfo": "82502191c9484b04d685374f9879a0066069c49b8acae7a04b01d38d07e8eca0",
-    "DevicelabIOSAgentUITests-Runner.app/PlugIns/DevicelabIOSAgentUITests.xctest/DevicelabIOSAgentUITests": "c546096e04e0f747d661a8ce09bc8bcf1a23a25ea0dc6787187c699ae54e271d",
+    "DevicelabIOSAgentUITests-Runner.app/PlugIns/DevicelabIOSAgentUITests.xctest/DevicelabIOSAgentUITests": "9a33ba998859cacc4c34d7fda9393aea445ec6f9c60d0dddc055ed35e767153c",
     "DevicelabIOSAgentUITests-Runner.app/PlugIns/DevicelabIOSAgentUITests.xctest/Info.plist": "82c7c5c76ae134228a1cbc5235630dc5a63964bf5d3721b660790b08bec534f7"
   }
 }

package/drivers/ios/devicelab-ios-agent/simulator/manifest.json

@@ -1,12 +1,12 @@
 {
-  "version": "a2f0bc8",
+  "version": "ff2be7b",
   "protocol": "1.0",
   "xcode": "Xcode 27.0",
   "runnerBundleId": "dev.devicelab.agent.uitests.xctrunner",
   "hostBundleId": "dev.devicelab.agent",
   "files": {
     "agent.xctestrun": "45b704ea6a432fef69461223a1de91e381743cb9413e082db7f2966283beea75",
-    "DevicelabIOSAgent.app/DevicelabIOSAgent": "95d73c9fb94710f32f39d68956388c9ca249cd6595e21689691abbc4631d8a87",
+    "DevicelabIOSAgent.app/DevicelabIOSAgent": "6b660b46764d4052dd1fb7323b7dece22c9febdeb530d1149613f3eba2d5ec36",
     "DevicelabIOSAgent.app/Info.plist": "1de91d903f985c153b06d9ce6d2086812e2d8f49e657b17f6e58f4a8733af93e",
     "DevicelabIOSAgent.app/PkgInfo": "82502191c9484b04d685374f9879a0066069c49b8acae7a04b01d38d07e8eca0",
     "DevicelabIOSAgentUITests-Runner.app/DevicelabIOSAgentUITests-Runner": "d776d95c3da519cf802b9e58794802128cd158160db68471c703005522b37337",
@@ -156,7 +156,7 @@
     "DevicelabIOSAgentUITests-Runner.app/Frameworks/XCUnit.framework/XCUnit": "ca2ce84e479758c3f2ab3c95964de49938d917b3ed3fa3d98038a6c4ef5ddc33",
     "DevicelabIOSAgentUITests-Runner.app/Info.plist": "db45280229a22ebbda188c44e0b97d8ba049d65c2373a1b11b4c5b61525014a0",
     "DevicelabIOSAgentUITests-Runner.app/PkgInfo": "82502191c9484b04d685374f9879a0066069c49b8acae7a04b01d38d07e8eca0",
-    "DevicelabIOSAgentUITests-Runner.app/PlugIns/DevicelabIOSAgentUITests.xctest/DevicelabIOSAgentUITests": "67607c905d8889ebbda54d782dd47c4b9135e3a3dc63f84ce07b78dd485834f8",
+    "DevicelabIOSAgentUITests-Runner.app/PlugIns/DevicelabIOSAgentUITests.xctest/DevicelabIOSAgentUITests": "ad228f590c4ed2713fe457128979ec023c933bd9d65dff7c926a129f46930a10",
     "DevicelabIOSAgentUITests-Runner.app/PlugIns/DevicelabIOSAgentUITests.xctest/Info.plist": "b4b1ff08ff01133dd8e3664807675a48476c073d5eba8dee0afa29f0c1bf46d5"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devicelab/maestro-runner-darwin-arm64",
-  "version": "1.1.29",
+  "version": "1.1.30",
   "description": "maestro-runner binary for darwin arm64. Installed automatically as an optional dependency of maestro-runner.",
   "homepage": "https://open.devicelab.dev/maestro-runner",
   "repository": {