@leera.io/qa-runner 1.0.4 → 1.0.6

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

@@ -245,6 +245,10 @@ export class Adb {
     async pidof(serial, pkg) {
         return parsePidof(await this.shell(serial, ['pidof', assertPackage(pkg)], 10_000).catch(() => ''));
     }
+    /** Drops adb's connection to a device so it reconnects (the fix for one stuck `offline`). */
+    async reconnect(serial) {
+        await this.run(['-s', assertSerial(serial), 'reconnect'], 15_000).catch(() => undefined);
+    }
     async killEmulator(serial) {
         await this.run(['-s', assertSerial(serial), 'emu', 'kill'], 15_000).catch(() => undefined);
     }

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

@@ -140,6 +140,28 @@ export async function waitForBoot(adb, serial, timeoutMs, failed = () => null) {
         await sleep(2_000);
     }
 }
+/**
+ * Waits for a device adb lost for a moment (a busy emulator, a USB reconnect) to come back and
+ * finish booting. A device still `offline` after a few seconds gets its connection reset once.
+ */
+export async function waitForDeviceBack(adb, serial, { timeoutMs = 120_000, nudgeAfterMs = 10_000, intervalMs = 2_000 } = {}) {
+    const deadline = Date.now() + timeoutMs;
+    const nudgeAt = Date.now() + nudgeAfterMs;
+    let nudged = false;
+    for (;;) {
+        const state = (await adb.devices().catch(() => [])).find((d) => d.serial === serial)?.state;
+        if (state === 'device' && (await adb.getprop(serial, 'sys.boot_completed').catch(() => '')) === '1')
+            return;
+        if (state === 'offline' && !nudged && Date.now() >= nudgeAt) {
+            nudged = true;
+            await adb.reconnect(serial);
+        }
+        if (Date.now() > deadline) {
+            throw new Error(`${serial} is ${state ?? 'not connected'} and did not come back within ${Math.round(timeoutMs / 1000)} s`);
+        }
+        await sleep(intervalMs);
+    }
+}
 export async function shutdownEmulator(adb, serial, timeoutMs = 60_000) {
     bootedHere.delete(serial);
     await adb.killEmulator(serial);

package/dist/src/drivers/android-appium.js

@@ -7,6 +7,7 @@ import { bundledDrivers } from '../appium/drivers.js';
 import { AppNotAvailable, resolveAppFile } from '../builds/install.js';
 import { androidInstallable } from '../builds/unpack.js';
 import { Adb, resolveAndroidSdk } from '../devices/android/adb.js';
+import { waitForDeviceBack } from '../devices/android/emulator.js';
 import { leaseAndroidDevice, listAndroidDevices } from '../devices/android/index.js';
 import { LogcatSink } from '../devices/android/logcat.js';
 import { dismissSystemErrorDialog } from '../devices/android/system-dialog.js';
@@ -33,6 +34,33 @@ export function appiumLogLines(text, redact) {
     });
     return { lines: kept, dropped: all.length - kept.length };
 }
+/** adb's words for a device it lost for the moment: `offline`, or missing from its list. */
+export function lostDevice(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /\bdevice offline\b|\bdevice ('[^']*' )?not found\b/i.test(message);
+}
+/**
+ * Opens the Appium session, and once more when adb lost the device while Appium set it up. A busy
+ * emulator or a USB reconnect drops the device for a few seconds, and Appium (which retries
+ * "not found" but not "offline") then fails the whole session. `recover` waits for the device;
+ * when it does not come back, the first error stands.
+ */
+export async function startSession(open, recover) {
+    try {
+        return await open();
+    }
+    catch (error) {
+        if (!lostDevice(error))
+            throw error;
+        try {
+            await recover();
+        }
+        catch {
+            throw error;
+        }
+        return open();
+    }
+}
 /** `android.sdk_path` from config.json, when the runner config has one. */
 export function configuredSdkPath(paths) {
     try {
@@ -191,14 +219,19 @@ export class AndroidAppiumDriver {
             const url = await this.appium.ensure();
             this.systemPort = await SYSTEM_PORTS.take();
             this.mjpegPort = await MJPEG_PORTS.take();
-            this.client = await openSession(url, uiautomator2Capabilities({
+            const capabilities = uiautomator2Capabilities({
                 serial,
                 appPackage: app.id,
                 appActivity: app.launch_activity,
                 systemPort: this.systemPort,
                 mjpegServerPort: this.mjpegPort,
                 newCommandTimeoutSecs: Math.max(300, Math.ceil((this.ctx.session?.idle_timeout_seconds ?? 0) + 60)),
-            }));
+            });
+            const adb = this.adb;
+            this.client = await startSession(() => openSession(url, capabilities), async () => {
+                this.ctx.log.warn('adb lost the device while Appium started the session; waiting for it to retry', { serial });
+                await waitForDeviceBack(adb, serial);
+            });
         }
         catch (error) {
             const log = this.appium.logSince(logOffset, 2_000).trim().split('\n').slice(-5).join(' | ');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leera.io/qa-runner",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Runs recorded QA test scripts on your own machines and reports results back to your workspace.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",