@leera.io/qa-runner 1.0.0

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

@@ -0,0 +1,133 @@
+import { Adb, isEmulatorSerial, resolveAndroidSdk } from './adb.js';
+import { androidVersionForApi, listAvds, readAvdInfo } from './avd.js';
+import { bootAvd, shutdownEmulator } from './emulator.js';
+import { prepareDevice } from './prepare.js';
+export { Adb, resolveAndroidSdk } from './adb.js';
+export const AVD_PREFIX = 'avd:';
+export function androidLabels(kind) {
+    return kind === 'real' ? ['android', 'android-real'] : ['android', 'android-emulator'];
+}
+function stateOf(line) {
+    if (line.state === 'device')
+        return 'available';
+    if (line.state === 'unauthorized')
+        return 'unauthorized';
+    return 'offline';
+}
+/** Maps what adb reports to the runner's device shape. */
+export function deviceFromAdb(line, props, avdName) {
+    const emulator = isEmulatorSerial(line.serial) || props['ro.kernel.qemu'] === '1' || props['ro.boot.qemu'] === '1';
+    const kind = emulator ? 'emulator' : 'real';
+    const model = props['ro.product.model'] || line.fields.model?.replace(/_/g, ' ') || null;
+    return {
+        id: line.serial,
+        platform: 'android',
+        kind,
+        name: avdName ?? model ?? line.serial,
+        os_version: props['ro.build.version.release'] || null,
+        state: stateOf(line),
+        labels: androidLabels(kind),
+        can_boot: false,
+    };
+}
+export function deviceFromAvd(name, osVersion) {
+    return {
+        id: `${AVD_PREFIX}${name}`,
+        platform: 'android',
+        kind: 'emulator',
+        name,
+        os_version: osVersion,
+        state: 'available',
+        labels: androidLabels('emulator'),
+        can_boot: true,
+    };
+}
+export function sdkFor(env, configured) {
+    const lookup = { env, ...(configured ? { configured } : {}) };
+    return resolveAndroidSdk(lookup);
+}
+/**
+ * Connected devices (`adb devices -l` + `getprop`) plus every AVD that is not running,
+ * advertised as `avd:<name>` with `can_boot: true`.
+ */
+export async function listAndroidDevices(sdk, env = process.env) {
+    const adb = new Adb(sdk.adb);
+    const devices = [];
+    const runningAvds = new Set();
+    for (const line of await adb.devices()) {
+        let props = {};
+        let avd = null;
+        if (line.state === 'device') {
+            props = await adb.getprops(line.serial).catch(() => ({}));
+            if (isEmulatorSerial(line.serial))
+                avd = await adb.avdName(line.serial);
+        }
+        if (avd)
+            runningAvds.add(avd);
+        devices.push(deviceFromAdb(line, props, avd));
+    }
+    if (sdk.emulator) {
+        const names = await listAvds(sdk.emulator).catch(() => []);
+        for (const name of names) {
+            if (runningAvds.has(name))
+                continue;
+            devices.push(deviceFromAvd(name, androidVersionForApi(readAvdInfo(name, env).apiLevel)));
+        }
+    }
+    return devices;
+}
+/** Boots `avd:<name>` on demand (or checks a connected device is usable), then prepares it once per boot. */
+export async function leaseAndroidDevice(device, options) {
+    const adb = new Adb(options.sdk.adb);
+    let serial;
+    let booted = false;
+    if (device.id.startsWith(AVD_PREFIX)) {
+        if (!options.sdk.emulator)
+            throw new Error('the Android emulator is not installed: run `leera-qa-runner setup android`');
+        const name = device.id.slice(AVD_PREFIX.length);
+        const before = (await adb.devices().catch(() => [])).map((d) => d.serial);
+        serial = await bootAvd(options.sdk.emulator, adb, name, {
+            headless: options.headless ?? true,
+            ...(options.logFile ? { logFile: options.logFile } : {}),
+            ...(options.bootTimeoutMs ? { timeoutMs: options.bootTimeoutMs } : {}),
+            ...(options.env ? { env: options.env } : {}),
+        });
+        booted = !before.includes(serial);
+    }
+    else {
+        serial = device.id;
+        const line = (await adb.devices()).find((d) => d.serial === serial);
+        if (!line)
+            throw new Error(`the Android device ${serial} is not connected`);
+        if (line.state === 'unauthorized') {
+            throw new Error(`the Android device ${serial} has not authorised this computer: accept the USB debugging prompt on the phone`);
+        }
+        if (line.state !== 'device')
+            throw new Error(`the Android device ${serial} is ${line.state}`);
+    }
+    const { errors } = await prepareDevice(adb, serial);
+    const full = {
+        platform: 'android',
+        kind: 'emulator',
+        name: device.name ?? serial,
+        os_version: device.os_version ?? null,
+        state: 'available',
+        labels: device.labels ?? androidLabels(device.kind ?? 'emulator'),
+        can_boot: device.can_boot ?? false,
+        ...device,
+    };
+    let released = false;
+    return {
+        serial,
+        device: full,
+        booted,
+        warnings: errors,
+        async release() {
+            if (released)
+                return;
+            released = true;
+            if (booted && options.shutdownOnRelease)
+                await shutdownEmulator(adb, serial);
+        },
+    };
+}

package/dist/src/devices/android/logcat.js

@@ -0,0 +1,205 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { assertPackage, SERIAL_RE } from './adb.js';
+/** Parses one `logcat -v threadtime` line: `09-17 00:12:01.123  1234  1250 E Tag     : message`. */
+export function parseLogcatLine(line) {
+    const match = /^(\d\d-\d\d \d\d:\d\d:\d\d\.\d{3})\s+(\d+)\s+(\d+)\s+([VDIWEFA])\s+(.*?)\s*:\s(.*)$/.exec(line);
+    if (!match)
+        return null;
+    return {
+        time: match[1],
+        pid: Number(match[2]),
+        tid: Number(match[3]),
+        level: match[4],
+        tag: match[5],
+        message: match[6],
+    };
+}
+/** `Start proc 4321:com.acme.app/u0a190 for …` → 4321 when it is the app's process. */
+export function startedPid(line, pkg) {
+    const match = /Start proc (\d+):([^/\s]+)/.exec(line.message);
+    if (!match)
+        return null;
+    const name = match[2];
+    return name === pkg || name.startsWith(`${pkg}:`) ? Number(match[1]) : null;
+}
+export function formatLogcat(line) {
+    return `${line.level}/${line.tag}: ${line.message}`;
+}
+export const LOGCAT_LIMITS = { linesPerStep: 200, crashesPerStep: 10, lineChars: 500, crashChars: 8_000, drain: 50 };
+/**
+ * Keeps the app's warning and error lines (by pid) and crash reports (`FATAL EXCEPTION`,
+ * `ANR in`) from a logcat stream, filed under the step that was running.
+ */
+export class LogcatCollector {
+    pkg;
+    redact;
+    steps = new Map();
+    current = null;
+    pids = new Set();
+    crash = null;
+    pending = [];
+    constructor(pkg, redact = (t) => t) {
+        this.pkg = pkg;
+        this.redact = redact;
+    }
+    setPids(pids) {
+        for (const pid of pids)
+            this.pids.add(pid);
+    }
+    begin(index) {
+        this.flushCrash();
+        this.current = index;
+    }
+    /** A line from the runner itself (e.g. a system dialog it answered) for the current step. */
+    note(text) {
+        const line = this.redact(text).slice(0, LOGCAT_LIMITS.lineChars);
+        this.pending.push(line);
+        if (this.current === null)
+            return;
+        const debug = this.entry(this.current);
+        const list = (debug.device_log ??= []);
+        if (list.length < LOGCAT_LIMITS.linesPerStep)
+            list.push(line);
+        else {
+            debug.dropped ??= {};
+            debug.dropped.device_log = (debug.dropped.device_log ?? 0) + 1;
+        }
+    }
+    /** Lines seen since the last call, for session results. */
+    drain() {
+        const out = this.pending;
+        this.pending = [];
+        return out.slice(-LOGCAT_LIMITS.drain);
+    }
+    for(index) {
+        this.flushCrash();
+        const debug = this.steps.get(index);
+        if (!debug || (!debug.device_log?.length && !debug.crashes?.length))
+            return undefined;
+        return debug;
+    }
+    accept(raw) {
+        const line = parseLogcatLine(raw);
+        if (!line)
+            return;
+        const started = startedPid(line, this.pkg);
+        if (started !== null)
+            this.pids.add(started);
+        // Crash blocks: AndroidRuntime lines of one pid, starting at FATAL EXCEPTION.
+        if (line.tag === 'AndroidRuntime' && line.level === 'E') {
+            if (line.message.startsWith('FATAL EXCEPTION')) {
+                this.flushCrash();
+                this.crash = { pid: line.pid, lines: [formatLogcat(line)], step: this.current };
+                return;
+            }
+            if (this.crash && line.pid === this.crash.pid) {
+                this.crash.lines.push(line.message);
+                const processLine = /^Process: ([^,]+), PID: (\d+)/.exec(line.message);
+                if (processLine && processLine[1] !== this.pkg && !processLine[1].startsWith(`${this.pkg}:`))
+                    this.crash.step = null; // another app
+                return;
+            }
+        }
+        else if (this.crash) {
+            this.flushCrash();
+        }
+        if (line.tag === 'ActivityManager' && line.level === 'E' && line.message.startsWith(`ANR in ${this.pkg}`)) {
+            this.addCrash(this.current, formatLogcat(line));
+            return;
+        }
+        if (!this.pids.has(line.pid))
+            return;
+        if (line.level !== 'W' && line.level !== 'E' && line.level !== 'F' && line.level !== 'A')
+            return;
+        const text = this.redact(formatLogcat(line)).slice(0, LOGCAT_LIMITS.lineChars);
+        this.pending.push(text);
+        if (this.pending.length > LOGCAT_LIMITS.drain * 2)
+            this.pending.splice(0, this.pending.length - LOGCAT_LIMITS.drain);
+        if (this.current === null)
+            return;
+        const debug = this.entry(this.current);
+        const list = (debug.device_log ??= []);
+        if (list.length < LOGCAT_LIMITS.linesPerStep)
+            list.push(text);
+        else {
+            debug.dropped ??= {};
+            debug.dropped.device_log = (debug.dropped.device_log ?? 0) + 1;
+        }
+    }
+    flushCrash() {
+        const crash = this.crash;
+        this.crash = null;
+        if (!crash || crash.step === null)
+            return;
+        this.addCrash(crash.step, crash.lines.join('\n'));
+    }
+    addCrash(step, text) {
+        const redacted = this.redact(text).slice(0, LOGCAT_LIMITS.crashChars);
+        this.pending.push(redacted.split('\n').slice(0, 3).join(' | ').slice(0, LOGCAT_LIMITS.lineChars));
+        if (step === null)
+            return;
+        const debug = this.entry(step);
+        const list = (debug.crashes ??= []);
+        if (list.length < LOGCAT_LIMITS.crashesPerStep)
+            list.push(redacted);
+        else {
+            debug.dropped ??= {};
+            debug.dropped.crashes = (debug.dropped.crashes ?? 0) + 1;
+        }
+    }
+    entry(index) {
+        let debug = this.steps.get(index);
+        if (!debug) {
+            debug = {};
+            this.steps.set(index, debug);
+        }
+        return debug;
+    }
+}
+/** The fixed argv that follows the device log from now on. */
+export function logcatArgv(serial) {
+    if (!SERIAL_RE.test(serial))
+        throw new Error(`'${serial}' is not a valid adb serial`);
+    return ['-s', serial, 'logcat', '-v', 'threadtime', '-T', '1'];
+}
+/** Runs `adb logcat` for one job and feeds a collector; refreshes the app's pids every 2 s. */
+export class LogcatSink {
+    adb;
+    serial;
+    child = null;
+    timer = null;
+    collector;
+    constructor(adb, serial, pkg, redact) {
+        this.adb = adb;
+        this.serial = serial;
+        assertPackage(pkg);
+        this.collector = new LogcatCollector(pkg, redact);
+        this.pkg = pkg;
+    }
+    pkg;
+    start() {
+        if (this.child)
+            return;
+        const child = spawn(this.adb.path, logcatArgv(this.serial), { stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
+        child.on('error', () => undefined);
+        this.child = child;
+        if (child.stdout) {
+            const lines = createInterface({ input: child.stdout });
+            lines.on('line', (line) => this.collector.accept(line));
+        }
+        const refresh = () => {
+            void this.adb.pidof(this.serial, this.pkg).then((pids) => this.collector.setPids(pids));
+        };
+        refresh();
+        this.timer = setInterval(refresh, 2_000);
+        this.timer.unref();
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        this.child?.kill();
+        this.child = null;
+    }
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Shell argv run once per device boot: animations off (steadier timing, smaller videos),
+ * screen kept on while charging/USB, keyguard dismissed. Fixed strings only.
+ */
+export const PREPARE_COMMANDS = [
+    ['settings', 'put', 'global', 'window_animation_scale', '0'],
+    ['settings', 'put', 'global', 'transition_animation_scale', '0'],
+    ['settings', 'put', 'global', 'animator_duration_scale', '0'],
+    ['svc', 'power', 'stayon', 'true'],
+    ['input', 'keyevent', 'KEYCODE_WAKEUP'],
+    ['wm', 'dismiss-keyguard'],
+];
+/** `serial:boot_id` of devices already prepared by this process. */
+const prepared = new Set();
+async function bootId(adb, serial) {
+    const id = (await adb.shell(serial, ['cat', '/proc/sys/kernel/random/boot_id'], 10_000).catch(() => '')).trim();
+    return id || 'unknown';
+}
+/** Prepares a device unless this process already did so since its last boot. Failures are reported, not thrown. */
+export async function prepareDevice(adb, serial) {
+    const key = `${serial}:${await bootId(adb, serial)}`;
+    if (prepared.has(key))
+        return { prepared: false, errors: [] };
+    const errors = [];
+    for (const argv of PREPARE_COMMANDS) {
+        try {
+            await adb.shell(serial, [...argv], 15_000);
+        }
+        catch (error) {
+            // Real devices may refuse some settings (e.g. without WRITE_SECURE_SETTINGS); keep going.
+            errors.push(`${argv.join(' ')}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    prepared.add(key);
+    return { prepared: true, errors };
+}
+/** Forgets which devices were prepared (tests). */
+export function resetPrepared() {
+    prepared.clear();
+}

package/dist/src/devices/android/setup.js

@@ -0,0 +1,162 @@
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import { bundledDrivers } from '../../appium/drivers.js';
+import { appiumHomeDir, seedAppiumHome } from '../../appium/home.js';
+import { bundledAppium } from '../../appium/server.js';
+import { ExitCode, messageOf } from '../../errors.js';
+import { ensureHome, readJsonFile } from '../../home.js';
+import { resolveAndroidSdk, resolveSdkManager, runTool } from './adb.js';
+import { AVD_NAME_RE, listAvds } from './avd.js';
+import { listAndroidDevices } from './index.js';
+export const IMAGE_RE = /^system-images;android-\d{2,3};[a-z_]+;(arm64-v8a|x86_64|x86)$/;
+export const SDK_PLATFORM = 35;
+export const BUILD_TOOLS = '35.0.0';
+/** The system image `--install-sdk` installs by default for this CPU. */
+export function defaultSystemImage(arch = process.arch) {
+    return `system-images;android-${SDK_PLATFORM};google_apis;${arch === 'arm64' ? 'arm64-v8a' : 'x86_64'}`;
+}
+/** The fixed argv for sdkmanager's package install. */
+export function sdkmanagerInstallArgv(sdkRoot, image) {
+    if (!IMAGE_RE.test(image))
+        throw new Error(`'${image}' is not a system image id such as ${defaultSystemImage()}`);
+    return [`--sdk_root=${sdkRoot}`, 'platform-tools', 'emulator', `build-tools;${BUILD_TOOLS}`, `platforms;android-${SDK_PLATFORM}`, image];
+}
+/** The fixed argv that creates an AVD from a system image. */
+export function avdCreateArgv(name, image) {
+    if (!AVD_NAME_RE.test(name))
+        throw new Error(`'${name}' is not a valid emulator name (letters, digits, . _ -)`);
+    if (!IMAGE_RE.test(image))
+        throw new Error(`'${image}' is not a system image id`);
+    return ['create', 'avd', '--name', name, '--package', image, '--device', 'pixel_8'];
+}
+/** The fixed argv that lists Appium's installed drivers as JSON. */
+export function appiumDriverListArgv(node, appiumDir) {
+    return [node, join(appiumDir, 'index.js'), 'driver', 'list', '--installed', '--json'];
+}
+function spawnInherit(file, args, env, input) {
+    return new Promise((resolve) => {
+        const child = spawn(file, args, { stdio: [input === undefined ? 'inherit' : 'pipe', 'inherit', 'inherit'], env, windowsHide: true });
+        if (input !== undefined)
+            child.stdin?.end(input);
+        child.on('error', () => resolve(1));
+        child.on('close', (code) => resolve(code ?? 1));
+    });
+}
+/**
+ * `setup android`: seeds Appium's home with the bundled UiAutomator2 driver and checks that
+ * Appium sees it, finds the SDK (optionally installing packages with the SDK's own sdkmanager
+ * and creating an emulator), then lists devices.
+ */
+export async function setupAndroid(io, paths, options) {
+    ensureHome(paths);
+    let ok = true;
+    // 1. Appium and its driver.
+    const appium = bundledAppium();
+    const drivers = bundledDrivers(io.platform).filter((d) => d.platforms.includes('android'));
+    if (!appium || drivers.length === 0) {
+        io.stderr('Appium and its UiAutomator2 driver are not installed with this runner. Install the runner with its installer, or with npm without --omit=optional.');
+        return ExitCode.environmentNotReady;
+    }
+    const home = appiumHomeDir(paths);
+    const seeded = seedAppiumHome(home, appium, drivers);
+    io.stdout(`Appium ${appium.version} home: ${home}${seeded.changed ? ' (updated)' : ''}`);
+    try {
+        const argv = appiumDriverListArgv(process.execPath, appium.dir);
+        const { stdout } = await runTool(argv[0], argv.slice(1), { timeoutMs: 120_000, env: { ...io.env, APPIUM_HOME: home } });
+        const listed = JSON.parse(stdout.slice(stdout.indexOf('{')));
+        for (const driver of drivers) {
+            const found = listed[driver.name];
+            if (found)
+                io.stdout(`  driver ${driver.name} ${found.version ?? driver.version}: installed`);
+            else {
+                ok = false;
+                io.stderr(`  driver ${driver.name}: Appium does not see it in ${home}`);
+            }
+        }
+    }
+    catch (error) {
+        ok = false;
+        io.stderr(`Appium could not list its drivers: ${messageOf(error)}`);
+    }
+    // 2. The Android SDK.
+    let configured = null;
+    try {
+        configured = readJsonFile(paths.config)?.android?.sdk_path?.trim() || null;
+    }
+    catch {
+        configured = null;
+    }
+    let sdk = resolveAndroidSdk({ env: io.env, platform: io.platform, ...(configured ? { configured } : {}) });
+    if (options.installSdk) {
+        const image = options.image ?? defaultSystemImage();
+        // A folder with only cmdline-tools/latest is enough: sdkmanager installs platform-tools and the rest.
+        const target = sdk?.root && sdk.sdkmanager
+            ? { root: sdk.root, sdkmanager: sdk.sdkmanager }
+            : resolveSdkManager({ env: io.env, platform: io.platform, ...(configured ? { configured } : {}) });
+        if (!target) {
+            io.stderr([
+                'Installing SDK packages needs the Android command-line tools first:',
+                '  1. Download "Command line tools only" from https://developer.android.com/studio#command-line-tools-only',
+                '  2. Unpack it to <sdk>/cmdline-tools/latest (for example ~/Library/Android/sdk on macOS, ~/Android/Sdk on Linux)',
+                '  3. Set ANDROID_HOME to <sdk> and run this command again',
+            ].join('\n'));
+            return ExitCode.environmentNotReady;
+        }
+        let argv;
+        try {
+            argv = sdkmanagerInstallArgv(target.root, image);
+        }
+        catch (error) {
+            io.stderr(messageOf(error));
+            return ExitCode.usage;
+        }
+        io.stdout(`Installing ${argv.slice(1).join(', ')} with sdkmanager (it asks you to review and accept the SDK licences) ...`);
+        if ((await spawnInherit(target.sdkmanager, argv, io.env)) !== 0) {
+            io.stderr('sdkmanager did not finish; see its output above.');
+            return ExitCode.error;
+        }
+        sdk = resolveAndroidSdk({ env: { ...io.env, ANDROID_HOME: target.root }, platform: io.platform });
+        const avds = sdk?.emulator ? await listAvds(sdk.emulator).catch(() => []) : [];
+        if (sdk?.avdmanager && avds.length === 0) {
+            const name = options.avd ?? 'leera_pixel';
+            try {
+                const create = avdCreateArgv(name, image);
+                io.stdout(`Creating emulator ${name} ...`);
+                // avdmanager asks whether to create a custom hardware profile; the answer is always no.
+                if ((await spawnInherit(sdk.avdmanager, create, { ...io.env, ANDROID_HOME: sdk.root ?? '' }, 'no\n')) !== 0) {
+                    ok = false;
+                    io.stderr('avdmanager could not create the emulator; see its output above.');
+                }
+            }
+            catch (error) {
+                io.stderr(messageOf(error));
+                return ExitCode.usage;
+            }
+        }
+    }
+    if (!sdk) {
+        io.stderr('The Android SDK was not found. Install Android Studio (or the command-line tools), set ANDROID_HOME, or set "android": {"sdk_path": "<dir>"} in the runner config.json.');
+        return ExitCode.environmentNotReady;
+    }
+    io.stdout(`Android SDK: ${sdk.root} (from ${sdk.source})`);
+    if (!sdk.emulator)
+        io.stdout('  The emulator is not installed; only USB devices can run jobs. Use --install-sdk to add it.');
+    // 3. Devices.
+    try {
+        const devices = await listAndroidDevices(sdk, io.env);
+        if (devices.length === 0)
+            io.stdout('Devices: none (connect a phone with USB debugging, or create an emulator with --install-sdk)');
+        else {
+            io.stdout('Devices:');
+            for (const device of devices) {
+                io.stdout(`  ${device.id}  ${device.name}  ${device.kind}${device.os_version ? ` Android ${device.os_version}` : ''}  ${device.state}${device.can_boot ? ' (booted when a job needs it)' : ''}`);
+            }
+        }
+    }
+    catch (error) {
+        ok = false;
+        io.stderr(`adb could not list devices: ${messageOf(error)}`);
+    }
+    io.stdout(ok ? 'Android is set up. Check everything with `leera-qa-runner doctor --platform android`.' : 'Android setup is incomplete; see the messages above.');
+    return ok ? ExitCode.ok : ExitCode.environmentNotReady;
+}

package/dist/src/devices/android/system-dialog.js

@@ -0,0 +1,78 @@
+import { parsePageSource } from '../../drivers/webdriver/xml-tree.js';
+/**
+ * System "isn't responding" / "keeps stopping" dialogs on Android.
+ *
+ * On slow devices (software-rendered emulators right after boot above all) the system shows an
+ * ANR or crash dialog for System UI or the launcher over the app under test, and every locate
+ * then fails. Such a dialog is not the app's fault, so the runner answers it with Wait (or
+ * Close app) and carries on. A dialog about the app under test is a real failure and is never
+ * touched.
+ */
+const TITLE_ID = 'android:id/alertTitle';
+const WAIT_ID = 'android:id/aerr_wait';
+const CLOSE_ID = 'android:id/aerr_close';
+/** Packages that draw these dialogs; a title with this text from any other package is the app's own UI. */
+const SYSTEM_PACKAGES = new Set(['android', 'com.android.systemui']);
+const TITLE_RE = /(?:isn['’]t|is not) responding|keeps stopping/i;
+/** The system error dialog in a UiAutomator2 page source, or null. */
+export function errorDialogIn(xml) {
+    let all;
+    try {
+        all = parsePageSource(xml).all;
+    }
+    catch {
+        return null;
+    }
+    const title = all.find((e) => e.attrs['resource-id'] === TITLE_ID && TITLE_RE.test(e.attrs.text ?? ''));
+    if (!title)
+        return null;
+    return {
+        title: title.attrs.text ?? '',
+        drawnBy: title.attrs.package ?? '',
+        hasWait: all.some((e) => e.attrs['resource-id'] === WAIT_ID),
+        hasClose: all.some((e) => e.attrs['resource-id'] === CLOSE_ID),
+    };
+}
+/**
+ * The packages an ANR or crash dialog is about, from `dumpsys window windows`
+ * (`Window{… u0 Application Not Responding: com.android.systemui}`, `… Application Error: pkg}`).
+ */
+export function errorDialogOwners(dumpsys) {
+    const owners = [];
+    for (const match of dumpsys.matchAll(/Application (?:Not Responding|Error): ([A-Za-z][A-Za-z0-9_]*(?:\.[A-Za-z0-9_]+)*)/g)) {
+        if (!owners.includes(match[1]))
+            owners.push(match[1]);
+    }
+    return owners;
+}
+/** Whether and how to answer a dialog. Anything uncertain is left alone. */
+export function decideErrorDialog(dialog, owners, appPackage) {
+    if (!SYSTEM_PACKAGES.has(dialog.drawnBy))
+        return { action: 'none', reason: 'not a system dialog' };
+    const ours = (pkg) => appPackage !== null && (pkg === appPackage || pkg.startsWith(`${appPackage}:`));
+    if (owners.some(ours))
+        return { action: 'none', reason: 'belongs to the app under test' };
+    const owner = owners[0];
+    if (!owner)
+        return { action: 'none', reason: 'owner unknown' };
+    if (dialog.hasWait)
+        return { action: 'wait', owner };
+    if (dialog.hasClose)
+        return { action: 'close', owner };
+    return { action: 'none', reason: 'no button' };
+}
+/** Answers a system error dialog not about the app under test; returns the note to log, or null. */
+export async function dismissSystemErrorDialog(appPackage, deps) {
+    const xml = await deps.pageSource().catch(() => '');
+    const dialog = xml ? errorDialogIn(xml) : null;
+    if (!dialog)
+        return null;
+    const owners = errorDialogOwners(await deps.dumpsysWindows().catch(() => ''));
+    const decision = decideErrorDialog(dialog, owners, appPackage);
+    if (decision.action === 'none')
+        return null;
+    const tapped = await deps.tapId(decision.action === 'wait' ? WAIT_ID : CLOSE_ID).catch(() => false);
+    if (!tapped)
+        return null;
+    return `runner: answered the system dialog "${dialog.title}" (${decision.owner}) with ${decision.action === 'wait' ? 'Wait' : 'Close app'}`;
+}