fix: tolerate android emulator avd probe timeouts (#243)

* fix: tolerate android emulator avd probe timeouts

* fix: only ignore timed out android avd probes

Author: thymikee

src/platforms/android/__tests__/devices.test.ts

@@ -3,13 +3,16 @@ import assert from 'node:assert/strict';
 import { promises as fs } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { AppError } from '../../../utils/errors.ts';
 import {
   ensureAndroidEmulatorBooted,
+  listAndroidDevices,
   parseAndroidAvdList,
   parseAndroidEmulatorAvdNameOutput,
   parseAndroidFeatureListForTv,
   parseAndroidTargetFromCharacteristics,
   resolveAndroidAvdName,
+  resolveAndroidEmulatorAvdName,
 } from '../devices.ts';
 
 const MOCK_ANDROID_ADB_SCRIPT = [
@@ -22,14 +25,23 @@ const MOCK_ANDROID_ADB_SCRIPT = [
   '  exit 0',
   'fi',
   'if [ "$1" = "-s" ] && [ "$2" = "emulator-5554" ] && [ "$3" = "emu" ] && [ "$4" = "avd" ] && [ "$5" = "name" ]; then',
+  '  if [ "$AGENT_DEVICE_TEST_AVD_NAME_MODE" = "missing" ]; then',
+  '    exit 0',
+  '  fi',
   '  echo "Pixel_9_Pro_XL"',
   '  exit 0',
   'fi',
   'if [ "$1" = "-s" ] && [ "$2" = "emulator-5554" ] && [ "$3" = "shell" ] && [ "$4" = "getprop" ] && [ "$5" = "ro.boot.qemu.avd_name" ]; then',
+  '  if [ "$AGENT_DEVICE_TEST_AVD_NAME_MODE" = "missing" ]; then',
+  '    exit 0',
+  '  fi',
   '  echo "Pixel_9_Pro_XL"',
   '  exit 0',
   'fi',
   'if [ "$1" = "-s" ] && [ "$2" = "emulator-5554" ] && [ "$3" = "shell" ] && [ "$4" = "getprop" ] && [ "$5" = "persist.sys.avd_name" ]; then',
+  '  if [ "$AGENT_DEVICE_TEST_AVD_NAME_MODE" = "missing" ]; then',
+  '    exit 0',
+  '  fi',
   '  echo "Pixel_9_Pro_XL"',
   '  exit 0',
   'fi',
@@ -137,6 +149,7 @@ test('resolveAndroidAvdName supports space vs underscore matching', () => {
 
 async function withMockedAndroidTools(
   run: (ctx: { emulatorLogPath: string; emulatorBootedPath: string }) => Promise<void>,
+  options: { avdNameMode?: 'success' | 'missing' } = {},
 ): Promise<void> {
   const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'agent-device-android-headless-'));
   const emulatorLogPath = path.join(tmpDir, 'emulator.log');
@@ -153,6 +166,7 @@ async function withMockedAndroidTools(
         PATH: `${tmpDir}${path.delimiter}${process.env.PATH ?? ''}`,
         AGENT_DEVICE_TEST_EMU_BOOTED_FILE: emulatorBootedPath,
         AGENT_DEVICE_TEST_EMU_LOG_FILE: emulatorLogPath,
+        AGENT_DEVICE_TEST_AVD_NAME_MODE: options.avdNameMode ?? 'success',
         HOME: tmpDir,
         ANDROID_SDK_ROOT: undefined,
         ANDROID_HOME: undefined,
@@ -198,6 +212,72 @@ async function withMockedAndroidSdkRoot(
   }
 }
 
+test('resolveAndroidEmulatorAvdName ignores probe timeouts and keeps probing', async () => {
+  const calls: string[][] = [];
+  const results = [
+    new AppError('COMMAND_FAILED', 'adb timed out after 1500ms', { timeoutMs: 1500 }),
+    { stdout: '', stderr: '', exitCode: 0 },
+    { stdout: 'Pixel_9_Pro_XL\n', stderr: '', exitCode: 0 },
+  ];
+  const runAdb = async (
+    _cmd: string,
+    args: string[],
+  ): Promise<{ stdout: string; stderr: string; exitCode: number }> => {
+    calls.push(args);
+    const next = results.shift();
+    if (next instanceof AppError) throw next;
+    assert.ok(next);
+    return next;
+  };
+
+  const avdName = await resolveAndroidEmulatorAvdName('emulator-5554', runAdb);
+
+  assert.equal(avdName, 'Pixel_9_Pro_XL');
+  assert.deepEqual(
+    calls.map((args) => args.slice(2)),
+    [
+      ['shell', 'getprop', 'ro.boot.qemu.avd_name'],
+      ['shell', 'getprop', 'persist.sys.avd_name'],
+      ['emu', 'avd', 'name'],
+    ],
+  );
+});
+
+test('resolveAndroidEmulatorAvdName rethrows non-timeout probe failures', async () => {
+  const failure = new AppError('COMMAND_FAILED', 'adb exited with code 1', {
+    stderr: 'device offline',
+    exitCode: 1,
+    processExitError: true,
+  });
+  let callCount = 0;
+  const runAdb = async (): Promise<{ stdout: string; stderr: string; exitCode: number }> => {
+    callCount += 1;
+    throw failure;
+  };
+
+  await assert.rejects(
+    async () => await resolveAndroidEmulatorAvdName('emulator-5554', runAdb),
+    (error) => error === failure,
+  );
+  assert.equal(callCount, 1);
+});
+
+test('listAndroidDevices falls back to model when emulator avd name is unavailable', async () => {
+  await withMockedAndroidTools(
+    async ({ emulatorBootedPath }) => {
+      await fs.writeFile(emulatorBootedPath, 'ready', 'utf8');
+
+      const devices = await listAndroidDevices();
+
+      assert.equal(devices.length, 1);
+      assert.equal(devices[0]?.id, 'emulator-5554');
+      assert.equal(devices[0]?.name, 'Pixel 9 Pro XL');
+      assert.equal(devices[0]?.kind, 'emulator');
+    },
+    { avdNameMode: 'missing' },
+  );
+});
+
 test('ensureAndroidEmulatorBooted launches emulator in headless mode when requested', async () => {
   await withMockedAndroidTools(async ({ emulatorLogPath, emulatorBootedPath }) => {
     const device = await ensureAndroidEmulatorBooted({

src/platforms/android/devices.ts

@@ -22,6 +22,8 @@ type AndroidDeviceDiscoveryOptions = {
   serialAllowlist?: ReadonlySet<string>;
 };
 
+type AndroidAdbRunner = typeof runCmd;
+
 function commandOutput(result: ExecResult): string {
   return `${result.stdout}\n${result.stderr}`;
 }
@@ -68,22 +70,53 @@ async function resolveAndroidDeviceName(serial: string, rawModel: string): Promi
   return modelName || serial;
 }
 
-async function resolveAndroidEmulatorAvdName(serial: string): Promise<string | undefined> {
-  const avdPropKeys = ['ro.boot.qemu.avd_name', 'persist.sys.avd_name'];
-  for (const prop of avdPropKeys) {
-    const result = await runCmd('adb', adbArgs(serial, ['shell', 'getprop', prop]), {
+async function runBestEffortAndroidEmulatorNameProbe(
+  serial: string,
+  args: string[],
+  runAdb: AndroidAdbRunner,
+): Promise<ExecResult | undefined> {
+  try {
+    return await runAdb('adb', adbArgs(serial, args), {
       allowFailure: true,
       timeoutMs: ANDROID_EMULATOR_AVD_NAME_TIMEOUT_MS,
     });
+  } catch (error) {
+    const appError = asAppError(error);
+    // Friendly-name lookup is optional during discovery, but only probe timeouts should fall back.
+    if (isAndroidEmulatorNameProbeTimeout(appError)) {
+      return undefined;
+    }
+    throw error;
+  }
+}
+
+function isAndroidEmulatorNameProbeTimeout(error: AppError): boolean {
+  return error.code === 'COMMAND_FAILED' && typeof error.details?.timeoutMs === 'number';
+}
+
+export async function resolveAndroidEmulatorAvdName(
+  serial: string,
+  runAdb: AndroidAdbRunner = runCmd,
+): Promise<string | undefined> {
+  const avdPropKeys = ['ro.boot.qemu.avd_name', 'persist.sys.avd_name'];
+  for (const prop of avdPropKeys) {
+    const result = await runBestEffortAndroidEmulatorNameProbe(
+      serial,
+      ['shell', 'getprop', prop],
+      runAdb,
+    );
+    if (!result) continue;
     const value = result.stdout.trim();
     if (result.exitCode === 0 && value.length > 0) {
       return value;
     }
   }
-  const emuResult = await runCmd('adb', adbArgs(serial, ['emu', 'avd', 'name']), {
-    allowFailure: true,
-    timeoutMs: ANDROID_EMULATOR_AVD_NAME_TIMEOUT_MS,
-  });
+  const emuResult = await runBestEffortAndroidEmulatorNameProbe(
+    serial,
+    ['emu', 'avd', 'name'],
+    runAdb,
+  );
+  if (!emuResult) return undefined;
   const emuValue = parseAndroidEmulatorAvdNameOutput(emuResult.stdout);
   if (emuResult.exitCode === 0 && emuValue) {
     return emuValue;