@leera.io/qa-runner 1.0.0

package/dist/src/devices/desktop.js

@@ -0,0 +1,145 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { accessSync, constants, existsSync } from 'node:fs';
+import { hostname, release } from 'node:os';
+import { delimiter, join } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+/**
+ * The host pseudo-device desktop platforms run on (contracts §K): one per runner, one job at a
+ * time, plus the virtual display a Linux runner without `DISPLAY` needs.
+ */
+export const HOST_DEVICE_ID = 'host';
+/** Xvfb display number and screen used when a Linux runner has no `DISPLAY`. */
+export const XVFB_DISPLAY = ':99';
+let cachedOsVersion;
+/** The host OS version: `sw_vers -productVersion` on macOS (`26.5`), the kernel release elsewhere. */
+export function hostOsVersion(platform = process.platform) {
+    if (cachedOsVersion !== undefined)
+        return cachedOsVersion;
+    let version = null;
+    if (platform === 'darwin') {
+        const result = spawnSync('sw_vers', ['-productVersion'], { encoding: 'utf8', timeout: 5_000 });
+        version = result.status === 0 ? result.stdout.trim() || null : null;
+    }
+    cachedOsVersion = version ?? (release() || null);
+    return cachedOsVersion;
+}
+/** `{id: "host", platform, name: <hostname>, kind: "host", os_version}` with the platform as its only label. */
+export function hostDevice(platform, options = {}) {
+    return {
+        id: HOST_DEVICE_ID,
+        platform,
+        kind: 'host',
+        name: options.name ?? hostname(),
+        os_version: options.osVersion === undefined ? hostOsVersion() : options.osVersion,
+        state: 'available',
+        labels: [platform],
+        can_boot: false,
+    };
+}
+/** Where an executable named `name` is on PATH, or null. */
+export function findOnPath(name, env = process.env, exists = isExecutableFile) {
+    for (const dir of (env.PATH ?? '').split(delimiter)) {
+        if (!dir)
+            continue;
+        const path = join(dir, name);
+        if (exists(path))
+            return path;
+    }
+    return null;
+}
+function isExecutableFile(path) {
+    try {
+        accessSync(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** The fixed argv of the virtual display. */
+export function xvfbArgv(display = XVFB_DISPLAY) {
+    if (!/^:\d{1,4}$/.test(display))
+        throw new Error(`'${display}' is not an X display`);
+    return [display, '-screen', '0', '1920x1080x24'];
+}
+export function displayNeed(platform = process.platform, env = process.env, find = (name) => findOnPath(name, env)) {
+    if (platform !== 'linux')
+        return { kind: 'none' };
+    const display = env.DISPLAY?.trim() || env.WAYLAND_DISPLAY?.trim();
+    if (display)
+        return { kind: 'existing', display };
+    const xvfb = find('Xvfb');
+    return xvfb ? { kind: 'xvfb', xvfb } : { kind: 'missing' };
+}
+export const NO_DISPLAY = 'this Linux runner has no display: set DISPLAY, or install Xvfb (for example `sudo apt-get install xvfb`) so the runner can start one';
+/**
+ * Makes sure desktop apps can open windows for one job: on Linux without `DISPLAY` starts
+ * `Xvfb :99 -screen 0 1920x1080x24` and stops it after the job (a display :99 that already
+ * exists is used as is and left running).
+ */
+export async function ensureDisplay(options = {}) {
+    const need = displayNeed(options.platform, options.env, options.find);
+    if (need.kind === 'none' || need.kind === 'existing')
+        return { env: {}, stop: async () => undefined };
+    if (need.kind === 'missing')
+        throw new Error(NO_DISPLAY);
+    const socket = `/tmp/.X11-unix/X${XVFB_DISPLAY.slice(1)}`;
+    if (existsSync(socket))
+        return { env: { DISPLAY: XVFB_DISPLAY }, stop: async () => undefined };
+    const child = spawn(need.xvfb, xvfbArgv(), { stdio: ['ignore', 'ignore', 'pipe'] });
+    let stderr = '';
+    let exited = false;
+    child.stderr?.on('data', (chunk) => {
+        stderr = `${stderr}${chunk.toString('utf8')}`.slice(-2_000);
+    });
+    child.once('exit', () => {
+        exited = true;
+    });
+    child.once('error', (error) => {
+        exited = true;
+        stderr += error.message;
+    });
+    const stop = async () => {
+        if (exited)
+            return;
+        const done = new Promise((resolve) => child.once('exit', () => resolve()));
+        child.kill('SIGTERM');
+        await Promise.race([done, sleep(5_000)]);
+        if (!exited)
+            child.kill('SIGKILL');
+    };
+    const deadline = Date.now() + (options.timeoutMs ?? 10_000);
+    while (!existsSync(socket)) {
+        if (exited)
+            throw new Error(`Xvfb could not start: ${stderr.trim().split('\n').pop() ?? 'exited'}`);
+        if (Date.now() > deadline) {
+            await stop();
+            throw new Error('Xvfb did not open display :99 within 10 s');
+        }
+        await sleep(100);
+    }
+    return { env: { DISPLAY: XVFB_DISPLAY }, stop };
+}
+/** `doctor` checks for Electron: Playwright's Electron support and, on Linux, a display. */
+export function electronChecks(options) {
+    const checks = [];
+    checks.push(options.playwright && options.electronSupported
+        ? { id: 'electron.playwright', title: 'Electron: Playwright', status: 'ok', detail: `playwright-core ${options.playwright}` }
+        : {
+            id: 'electron.playwright',
+            title: 'Electron: Playwright',
+            status: 'fail',
+            detail: 'playwright-core with Electron support is not installed with this runner',
+            fix: 'Reinstall the runner',
+        });
+    const need = displayNeed(options.platform, options.env, options.find);
+    if (need.kind === 'existing')
+        checks.push({ id: 'electron.display', title: 'Electron: display', status: 'ok', detail: `DISPLAY ${need.display}` });
+    else if (need.kind === 'xvfb') {
+        checks.push({ id: 'electron.display', title: 'Electron: display', status: 'ok', detail: `no DISPLAY; jobs start ${need.xvfb} ${XVFB_DISPLAY}` });
+    }
+    else if (need.kind === 'missing') {
+        checks.push({ id: 'electron.display', title: 'Electron: display', status: 'warn', detail: NO_DISPLAY, fix: 'sudo apt-get install xvfb' });
+    }
+    return checks;
+}

package/dist/src/devices/ios/devicectl.js

@@ -0,0 +1,87 @@
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { runTool } from '../android/adb.js';
+export const REAL_UDID_RE = /^[0-9A-Fa-f]{8}-?[0-9A-Fa-f]{16}$|^[0-9A-Fa-f]{40}$|^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}$/;
+function obj(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function str(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value : null;
+}
+/**
+ * Why a real device is not ready (pairing, Developer Mode, connection), with the state the
+ * runner advertises: `unauthorized` when the person must act on the phone, `offline` when it is
+ * not reachable.
+ */
+export function readiness(device) {
+    if (device.pairingState && device.pairingState !== 'paired') {
+        return {
+            state: 'unauthorized',
+            notReady: `${device.name} is not paired with this Mac: unlock it, connect it with a cable and tap Trust`,
+        };
+    }
+    if (device.developerModeStatus === 'disabled') {
+        return {
+            state: 'unauthorized',
+            notReady: `Developer Mode is off on ${device.name}: turn it on in Settings > Privacy & Security > Developer Mode and restart the device`,
+        };
+    }
+    if (!device.transportType || device.tunnelState === 'unavailable') {
+        return { state: 'offline', notReady: `${device.name} is not connected (connect it with a cable or on the same network)` };
+    }
+    if (device.bootState && device.bootState !== 'booted') {
+        return { state: 'offline', notReady: `${device.name} is ${device.bootState}` };
+    }
+    return { state: 'available', notReady: null };
+}
+/** Parses the `devicectl list devices --json-output` file: iOS and iPadOS devices only. */
+export function parseDevicectlDevices(json) {
+    const doc = obj(typeof json === 'string' ? JSON.parse(json) : json);
+    const list = obj(doc.result).devices;
+    if (!Array.isArray(list))
+        return [];
+    const out = [];
+    for (const entry of list) {
+        const raw = obj(entry);
+        const hardware = obj(raw.hardwareProperties);
+        const props = obj(raw.deviceProperties);
+        const connection = obj(raw.connectionProperties);
+        if (str(hardware.platform) !== 'iOS')
+            continue;
+        const udid = str(hardware.udid);
+        if (!udid || !REAL_UDID_RE.test(udid))
+            continue;
+        const base = {
+            udid,
+            identifier: str(raw.identifier),
+            name: str(props.name) ?? udid,
+            osVersion: str(props.osVersionNumber),
+            productType: str(hardware.productType),
+            deviceType: str(hardware.deviceType),
+            pairingState: str(connection.pairingState),
+            transportType: str(connection.transportType),
+            tunnelState: str(connection.tunnelState),
+            bootState: str(props.bootState),
+            developerModeStatus: str(props.developerModeStatus),
+            ddiServicesAvailable: typeof props.ddiServicesAvailable === 'boolean' ? props.ddiServicesAvailable : null,
+        };
+        out.push({ ...base, ...readiness(base) });
+    }
+    return out;
+}
+export function devicectlListArgv(jsonPath) {
+    return ['devicectl', 'list', 'devices', '--quiet', '--timeout', '20', '--json-output', jsonPath];
+}
+/** Lists real devices; an Xcode without devicectl (before 15) yields an error the caller reports. */
+export async function listRealDevices(xcrun = 'xcrun') {
+    const dir = mkdtempSync(join(tmpdir(), 'qa-devicectl-'));
+    try {
+        const file = join(dir, 'devices.json');
+        await runTool(xcrun, devicectlListArgv(file), { timeoutMs: 40_000 });
+        return parseDevicectlDevices(readFileSync(file, 'utf8'));
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}

package/dist/src/devices/ios/index.js

@@ -0,0 +1,130 @@
+import { spawn } from 'node:child_process';
+import { listRealDevices } from './devicectl.js';
+import { prepareSimulator } from './prepare.js';
+import { Simctl, simulatorAppRunning, UDID_RE } from './simctl.js';
+export { Simctl } from './simctl.js';
+export function iosLabels(kind) {
+    return kind === 'real' ? ['ios', 'ios-real'] : ['ios', 'ios-simulator'];
+}
+/**
+ * A simulator as the runner advertises it (contracts §I): id = UDID, shut-down simulators are
+ * listed with `can_boot` and booted on lease.
+ */
+export function deviceFromSimulator(sim) {
+    const booted = sim.state === 'Booted';
+    const booting = sim.state === 'Booting';
+    return {
+        id: sim.udid,
+        platform: 'ios',
+        kind: 'simulator',
+        name: sim.name,
+        os_version: sim.osVersion,
+        state: !sim.available ? 'offline' : booting ? 'booting' : booted || sim.state === 'Shutdown' ? 'available' : 'offline',
+        labels: iosLabels('simulator'),
+        can_boot: sim.available && sim.state === 'Shutdown',
+    };
+}
+export function deviceFromReal(real) {
+    return {
+        id: real.udid,
+        platform: 'ios',
+        kind: 'real',
+        name: real.name,
+        os_version: real.osVersion,
+        state: real.state,
+        labels: iosLabels('real'),
+        can_boot: false,
+    };
+}
+/** Simulators (`simctl list --json`) and real devices (`devicectl list devices`). */
+export async function listIosDevices(options = {}) {
+    const simctl = options.simctl ?? new Simctl();
+    const devices = [];
+    const notReady = [];
+    const errors = [];
+    try {
+        for (const sim of await simctl.list()) {
+            if (sim.available)
+                devices.push(deviceFromSimulator(sim));
+        }
+    }
+    catch (error) {
+        errors.push(`simctl could not list simulators: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    try {
+        for (const real of await (options.real ?? listRealDevices)()) {
+            // Only ready devices are advertised: the server derives `ios-real` from what is advertised.
+            if (real.notReady || real.state !== 'available')
+                notReady.push(real.notReady ?? `${real.name} is ${real.state}`);
+            else
+                devices.push(deviceFromReal(real));
+        }
+    }
+    catch (error) {
+        errors.push(`devicectl could not list devices: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { devices, notReady, errors };
+}
+/** `open -a Simulator --args -CurrentDeviceUDID <udid>`: shows the booted simulator. */
+export function openSimulatorAppArgv(udid) {
+    if (!UDID_RE.test(udid))
+        throw new Error(`'${udid}' is not a simulator UDID`);
+    return ['-a', 'Simulator', '--args', '-CurrentDeviceUDID', udid];
+}
+/**
+ * Makes a device usable for one job or session: boots a shut-down simulator (headless,
+ * `bootstatus -b`), prepares it once per boot, or checks a real device is paired and ready.
+ */
+export async function leaseIosDevice(device, options = {}) {
+    const simctl = options.simctl ?? new Simctl();
+    if (UDID_RE.test(device.id) && device.kind !== 'real') {
+        const sims = await simctl.list();
+        const sim = sims.find((s) => s.udid === device.id);
+        if (!sim)
+            throw new Error(`the simulator ${device.id} does not exist on this Mac`);
+        if (!sim.available)
+            throw new Error(`the simulator ${sim.name} is not available (its runtime may be missing)`);
+        const booted = sim.state !== 'Booted';
+        const bootAttempts = booted
+            ? await simctl.bootAndWait(sim.udid, { ...(options.bootTimeoutMs ? { timeoutMs: options.bootTimeoutMs } : {}), ...(options.log ? { log: options.log } : {}) })
+            : [];
+        const after = (await simctl.list()).find((s) => s.udid === device.id);
+        if (after?.state !== 'Booted')
+            throw new Error(`the simulator ${sim.name} did not boot (state ${after?.state ?? 'unknown'})`);
+        const uiRunning = options.uiClientRunning ?? simulatorAppRunning;
+        if (options.headed) {
+            spawn('open', openSimulatorAppArgv(sim.udid), { stdio: 'ignore', detached: true }).on('error', () => undefined).unref();
+        }
+        // With a window wanted, wait for Simulator.app so Appium sees it and does not reboot the simulator.
+        let uiClientRunning = await uiRunning();
+        for (let i = 0; options.headed && !uiClientRunning && i < 30; i++) {
+            await new Promise((resolve) => setTimeout(resolve, 1_000));
+            uiClientRunning = await uiRunning();
+        }
+        const { errors } = await (options.prepare ?? prepareSimulator)(sim.udid, after.lastBootedAt ?? 'unknown');
+        let released = false;
+        return {
+            udid: sim.udid,
+            kind: 'simulator',
+            booted,
+            osVersion: sim.osVersion,
+            warnings: errors,
+            bootAttempts,
+            uiClientRunning,
+            async release() {
+                if (released)
+                    return;
+                released = true;
+                if (booted && options.shutdownOnRelease !== false)
+                    await simctl.shutdown(sim.udid);
+            },
+        };
+    }
+    const reals = await (options.real ?? listRealDevices)();
+    const real = reals.find((r) => r.udid === device.id);
+    if (!real)
+        throw new Error(`the iOS device ${device.id} is not connected`);
+    if (real.notReady)
+        throw new Error(real.notReady);
+    return { udid: real.udid, kind: 'real', booted: false, osVersion: real.osVersion, warnings: [], bootAttempts: [], uiClientRunning: false, release: async () => undefined };
+}

package/dist/src/devices/ios/prepare.js

@@ -0,0 +1,39 @@
+import { runTool } from '../android/adb.js';
+import { assertSimUdid } from './simctl.js';
+/**
+ * Settings written once per simulator boot so typing is predictable: no autocorrection or
+ * predictions, and the one-time "slide to type" introduction that covers the keyboard on a
+ * fresh simulator is marked as seen. Fixed strings only.
+ */
+export const SIMULATOR_PREFERENCES = [
+    ['KeyboardAutocorrection', '-bool', 'NO'],
+    ['KeyboardPrediction', '-bool', 'NO'],
+    ['KeyboardShowPredictionBar', '-bool', 'NO'],
+    ['KeyboardDidShowContinuousPathIntroduction', '-bool', 'YES'],
+];
+export function simulatorPrepareArgv(udid) {
+    return SIMULATOR_PREFERENCES.map((pref) => ['simctl', 'spawn', assertSimUdid(udid), 'defaults', 'write', 'com.apple.Preferences', ...pref]);
+}
+/** `udid:lastBootedAt` of simulators this process prepared. */
+const prepared = new Set();
+/** Prepares a booted simulator unless this process already did since its last boot. Failures are reported, not thrown. */
+export async function prepareSimulator(udid, bootKey, xcrun = 'xcrun') {
+    const key = `${udid}:${bootKey}`;
+    if (prepared.has(key))
+        return { prepared: false, errors: [] };
+    const errors = [];
+    for (const argv of simulatorPrepareArgv(udid)) {
+        try {
+            await runTool(xcrun, argv, { timeoutMs: 20_000 });
+        }
+        catch (error) {
+            errors.push(`${argv.slice(4).join(' ')}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    prepared.add(key);
+    return { prepared: true, errors };
+}
+/** Forgets which simulators were prepared (tests). */
+export function resetPreparedSimulators() {
+    prepared.clear();
+}

package/dist/src/devices/ios/record.js

@@ -0,0 +1,122 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, renameSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { assertSimUdid } from './simctl.js';
+/**
+ * Records a simulator's screen with `simctl io recordVideo` (H.264). simctl always writes a
+ * QuickTime container whatever the extension (it has no `--type`), so the file is remuxed into
+ * a real MP4 afterwards (`remuxToMp4`). The XCUITest driver's own recording needs ffmpeg; this does not.
+ */
+export function simctlRecordArgv(udid, file) {
+    if (!file.endsWith('.mp4'))
+        throw new Error('the recording file must end in .mp4');
+    return ['simctl', 'io', assertSimUdid(udid), 'recordVideo', '--codec=h264', '--force', file];
+}
+/** macOS's built-in remux: `avconvert` passthrough keeps the H.264 stream and writes an MP4 container. */
+export function avconvertRemuxArgv(source, dest) {
+    return ['--source', source, '--output', dest, '--preset', 'PresetPassthrough', '--replace'];
+}
+export function ffmpegRemuxArgv(source, dest) {
+    return ['-y', '-loglevel', 'error', '-i', source, '-c', 'copy', '-movflags', '+faststart', dest];
+}
+/** The major brand of an ISO media file (`qt  ` for QuickTime, `mp42`/`isom` for MP4), or null. */
+export function majorBrand(header) {
+    return header.length >= 12 && header.toString('latin1', 4, 8) === 'ftyp' ? header.toString('latin1', 8, 12) : null;
+}
+/**
+ * Rewrites a QuickTime recording as an MP4 container in place, with `avconvert` (macOS) or else
+ * ffmpeg when present. Returns how, or null when neither worked (the QuickTime file is kept;
+ * browsers and the server still accept it as video/mp4).
+ */
+export function remuxToMp4(file, run = runQuiet) {
+    const temp = `${file}.remux.mp4`;
+    for (const [tool, argv] of [
+        ['avconvert', avconvertRemuxArgv(file, temp)],
+        ['ffmpeg', ffmpegRemuxArgv(file, temp)],
+    ]) {
+        rmSync(temp, { force: true });
+        if (run(tool, [...argv]) && existsSync(temp) && statSync(temp).size > 0) {
+            renameSync(temp, file);
+            return tool;
+        }
+    }
+    rmSync(temp, { force: true });
+    return null;
+}
+function runQuiet(cmd, args) {
+    const result = spawnSync(cmd, args, { stdio: 'ignore', timeout: 120_000 });
+    return !result.error && result.status === 0;
+}
+export class SimulatorRecorder {
+    udid;
+    xcrun;
+    child = null;
+    dir;
+    file;
+    exited = false;
+    constructor(udid, xcrun = 'xcrun') {
+        this.udid = udid;
+        this.xcrun = xcrun;
+        this.dir = mkdtempSync(join(tmpdir(), 'qa-video-'));
+        this.file = join(this.dir, 'video.mp4');
+    }
+    /** Starts recording; resolves once simctl reports it is recording (or throws when it exits first). */
+    async start(timeoutMs = 15_000) {
+        const child = spawn(this.xcrun, simctlRecordArgv(this.udid, this.file), { stdio: ['ignore', 'pipe', 'pipe'] });
+        this.child = child;
+        let output = '';
+        const onData = (chunk) => {
+            output += chunk.toString('utf8');
+        };
+        child.stdout?.on('data', onData);
+        child.stderr?.on('data', onData);
+        child.once('exit', () => {
+            this.exited = true;
+        });
+        child.once('error', (error) => {
+            this.exited = true;
+            output += error.message;
+        });
+        const deadline = Date.now() + timeoutMs;
+        while (!/Recording started/i.test(output)) {
+            if (this.exited) {
+                this.cleanup();
+                throw new Error(`simctl could not record the screen: ${output.trim().split('\n').pop() ?? 'exited'}`);
+            }
+            if (Date.now() > deadline)
+                break;
+            await sleep(100);
+        }
+    }
+    /** Stops recording (SIGINT lets simctl finish the file) and returns the video path, or undefined. */
+    async stop(timeoutMs = 20_000) {
+        const child = this.child;
+        this.child = null;
+        if (!child)
+            return undefined;
+        if (!this.exited) {
+            const done = new Promise((resolve) => child.once('exit', () => resolve()));
+            child.kill('SIGINT');
+            await Promise.race([done, sleep(timeoutMs)]);
+            if (!this.exited)
+                child.kill('SIGKILL');
+        }
+        try {
+            if (existsSync(this.file) && statSync(this.file).size > 0) {
+                remuxToMp4(this.file);
+                return this.file;
+            }
+        }
+        catch {
+            // fall through
+        }
+        this.cleanup();
+        return undefined;
+    }
+    /** Removes the recording directory (when the caller does not take the video). */
+    cleanup() {
+        rmSync(this.dir, { recursive: true, force: true });
+    }
+}

package/dist/src/devices/ios/settings.js

@@ -0,0 +1,55 @@
+import { readJsonFile } from '../../home.js';
+export const DEFAULT_SIMULATOR_BOOT_TIMEOUT_SECS = 300;
+export const MIN_SIMULATOR_BOOT_TIMEOUT_SECS = 30;
+export const MAX_SIMULATOR_BOOT_TIMEOUT_SECS = 3_600;
+export const TEAM_ID_RE = /^[A-Z0-9]{10}$/;
+export const WDA_BUNDLE_ID_RE = /^[A-Za-z0-9-]+(\.[A-Za-z0-9-]+)+$/;
+export const DEFAULT_SIGNING_ID = 'Apple Development';
+function pick(...values) {
+    for (const value of values) {
+        const trimmed = value?.trim();
+        if (trimmed)
+            return trimmed;
+    }
+    return null;
+}
+/** Reads the settings; values that are not valid are reported, not used. */
+export function iosSettings(env, file) {
+    const problems = [];
+    let teamId = pick(env.RUNNER_IOS_TEAM_ID, file?.ios?.team_id);
+    if (teamId && !TEAM_ID_RE.test(teamId)) {
+        problems.push(`ios.team_id '${teamId}' is not a 10-character Apple Team ID`);
+        teamId = null;
+    }
+    let wdaBundleId = pick(env.RUNNER_IOS_WDA_BUNDLE_ID, file?.ios?.wda_bundle_id);
+    if (wdaBundleId && !WDA_BUNDLE_ID_RE.test(wdaBundleId)) {
+        problems.push(`ios.wda_bundle_id '${wdaBundleId}' is not a bundle id`);
+        wdaBundleId = null;
+    }
+    let signingId = pick(env.RUNNER_IOS_SIGNING_ID, file?.ios?.signing_id);
+    if (signingId && (signingId.length > 100 || /[\n\r"]/.test(signingId))) {
+        problems.push('ios.signing_id is not a code signing identity name');
+        signingId = null;
+    }
+    let simulatorBootTimeoutMs = DEFAULT_SIMULATOR_BOOT_TIMEOUT_SECS * 1000;
+    const rawBoot = pick(env.RUNNER_IOS_BOOT_TIMEOUT_SECS, file?.ios?.simulator_boot_timeout_secs == null ? null : String(file.ios.simulator_boot_timeout_secs));
+    if (rawBoot) {
+        const secs = Number(rawBoot);
+        if (Number.isInteger(secs) && secs >= MIN_SIMULATOR_BOOT_TIMEOUT_SECS && secs <= MAX_SIMULATOR_BOOT_TIMEOUT_SECS)
+            simulatorBootTimeoutMs = secs * 1000;
+        else
+            problems.push(`ios.simulator_boot_timeout_secs '${rawBoot}' is not a whole number of seconds from ${MIN_SIMULATOR_BOOT_TIMEOUT_SECS} to ${MAX_SIMULATOR_BOOT_TIMEOUT_SECS}`);
+    }
+    return { teamId, wdaBundleId, signingId, simulatorBootTimeoutMs, problems };
+}
+/** The settings from the runner home's config.json plus the environment. */
+export function loadIosSettings(env, paths) {
+    let file = null;
+    try {
+        file = readJsonFile(paths.config);
+    }
+    catch {
+        file = null;
+    }
+    return iosSettings(env, file);
+}