Simplify Android boot path in session handler

Author: thymikee

src/daemon/handlers/__tests__/session.test.ts

@@ -391,7 +391,6 @@ test('boot --headless launches Android emulator when no running device matches',
     resolveTargetDevice: async () => {
       throw new AppError('DEVICE_NOT_FOUND', 'No devices found');
     },
-    resolveAndroidBootSelectorDevice: async () => undefined,
     ensureAndroidEmulatorBoot: async ({ avdName, serial, headless }) => {
       launchCalls.push({ avdName, serial, headless });
       return {
@@ -435,7 +434,6 @@ test('boot launches Android emulator with GUI when no running device matches', a
     resolveTargetDevice: async () => {
       throw new AppError('DEVICE_NOT_FOUND', 'No devices found');
     },
-    resolveAndroidBootSelectorDevice: async () => undefined,
     ensureAndroidEmulatorBoot: async ({ avdName, serial, headless }) => {
       launchCalls.push({ avdName, serial, headless });
       return {
@@ -478,7 +476,6 @@ test('boot --headless requires avd selector when device cannot be resolved', asy
     resolveTargetDevice: async () => {
       throw new AppError('DEVICE_NOT_FOUND', 'No devices found');
     },
-    resolveAndroidBootSelectorDevice: async () => undefined,
     ensureAndroidEmulatorBoot: async () => {
       bootCalled = true;
       throw new Error('unexpected');
@@ -494,45 +491,6 @@ test('boot --headless requires avd selector when device cannot be resolved', asy
   }
 });
 
-test('boot uses fast Android selector lookup for already booted device', async () => {
-  const sessionStore = makeSessionStore();
-  let ensureCalls = 0;
-  const response = await handleSessionCommands({
-    req: {
-      token: 't',
-      session: 'default',
-      command: 'boot',
-      positionals: [],
-      flags: { platform: 'android', device: 'Pixel 9 Pro XL' },
-    },
-    sessionName: 'default',
-    logPath: path.join(os.tmpdir(), 'daemon.log'),
-    sessionStore,
-    invoke: noopInvoke,
-    ensureReady: async () => {
-      ensureCalls += 1;
-    },
-    resolveTargetDevice: async () => {
-      throw new Error('resolveTargetDevice should not be called when fast lookup succeeds');
-    },
-    resolveAndroidBootSelectorDevice: async () => ({
-      platform: 'android',
-      id: 'emulator-5554',
-      name: 'Pixel 9 Pro XL',
-      kind: 'emulator',
-      target: 'mobile',
-      booted: true,
-    }),
-  });
-  assert.ok(response);
-  assert.equal(response?.ok, true);
-  assert.equal(ensureCalls, 0);
-  if (response && response.ok) {
-    assert.equal(response.data?.platform, 'android');
-    assert.equal(response.data?.id, 'emulator-5554');
-  }
-});
-
 test('appstate on iOS requires active session on selected device', async () => {
   const sessionStore = makeSessionStore();
   const sessionName = 'default';

src/daemon/handlers/session.ts

@@ -54,12 +54,6 @@ type EnsureAndroidEmulatorBoot = (params: {
   headless?: boolean;
 }) => Promise<DeviceInfo>;
 
-type ResolveAndroidBootSelectorDevice = (params: {
-  deviceName?: string;
-  serial?: string;
-  includeTarget?: boolean;
-}) => Promise<DeviceInfo | undefined>;
-
 const IOS_APPSTATE_SESSION_REQUIRED_MESSAGE =
   'iOS appstate requires an active session on the target device. Run open first (for example: open --session sim --platform ios --device "<name>" <app>).';
 const BATCH_PARENT_FLAG_KEYS: Array<keyof CommandFlags> = ['platform', 'target', 'device', 'udid', 'serial', 'verbose', 'out'];
@@ -259,11 +253,6 @@ const defaultEnsureAndroidEmulatorBoot: EnsureAndroidEmulatorBoot = async ({ avd
   return await ensureAndroidEmulatorBooted({ avdName, serial, headless });
 };
 
-const defaultResolveAndroidBootSelectorDevice: ResolveAndroidBootSelectorDevice = async ({ deviceName, serial, includeTarget }) => {
-  const { resolveAndroidBootSelectorDevice } = await import('../../platforms/android/devices.ts');
-  return await resolveAndroidBootSelectorDevice({ deviceName, serial, includeTarget });
-};
-
 const defaultReinstallOps: ReinstallOps = {
   ios: async (device, app, appPath) => {
     const { reinstallIosApp } = await import('../../platforms/ios/index.ts');
@@ -481,7 +470,6 @@ export async function handleSessionCommands(params: {
     stop: typeof stopAppLog;
   };
   ensureAndroidEmulatorBoot?: EnsureAndroidEmulatorBoot;
-  resolveAndroidBootSelectorDevice?: ResolveAndroidBootSelectorDevice;
   resolveAndroidPackageForOpen?: (
     device: DeviceInfo,
     openTarget: string | undefined,
@@ -503,7 +491,6 @@ export async function handleSessionCommands(params: {
       stop: stopAppLog,
     },
     ensureAndroidEmulatorBoot: ensureAndroidEmulatorBootOverride = defaultEnsureAndroidEmulatorBoot,
-    resolveAndroidBootSelectorDevice: resolveAndroidBootSelectorDeviceOverride = defaultResolveAndroidBootSelectorDevice,
     resolveAndroidPackageForOpen: resolveAndroidPackageForOpenOverride = resolveAndroidPackageForOpen,
   } = params;
   const dispatch = dispatchOverride ?? dispatchCommand;
@@ -600,34 +587,21 @@ export async function handleSessionCommands(params: {
     const normalizedPlatform = normalizePlatformSelector(flags.platform) ?? session?.device.platform;
     const targetsAndroid = normalizedPlatform === 'android';
     const wantsAndroidHeadless = flags.headless === true;
-    const shouldUseFastAndroidSelectorLookup = targetsAndroid && Boolean(flags.device || flags.serial);
     const fallbackAvdName = resolveAndroidEmulatorAvdName({
       flags,
       sessionDevice: session?.device,
     });
     const canFallbackLaunchAndroidEmulator = targetsAndroid && Boolean(fallbackAvdName);
     let device: DeviceInfo;
     let launchedAndroidEmulator = false;
-    const fastLookupDeviceCandidate = shouldUseFastAndroidSelectorLookup
-      ? await resolveAndroidBootSelectorDeviceOverride({
-        deviceName: flags.device,
-        serial: flags.serial,
-        includeTarget: Boolean(flags.target),
-      })
-      : undefined;
-    const targetMismatch = Boolean(flags.target)
-      && fastLookupDeviceCandidate
-      && (fastLookupDeviceCandidate.target ?? 'mobile') !== flags.target;
-    const fastLookupDevice = targetMismatch ? undefined : fastLookupDeviceCandidate;
     try {
-      device = fastLookupDevice
-        ?? (await resolveCommandDevice({
-          session,
-          flags,
-          ensureReadyFn: ensureReady,
-          resolveTargetDeviceFn: resolveDevice,
-          ensureReady: false,
-        }));
+      device = await resolveCommandDevice({
+        session,
+        flags,
+        ensureReadyFn: ensureReady,
+        resolveTargetDeviceFn: resolveDevice,
+        ensureReady: false,
+      });
     } catch (error) {
       const appErr = asAppError(error);
       if (targetsAndroid && wantsAndroidHeadless && !fallbackAvdName && appErr.code === 'DEVICE_NOT_FOUND') {

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

@@ -8,7 +8,6 @@ import {
   parseAndroidAvdList,
   parseAndroidFeatureListForTv,
   parseAndroidTargetFromCharacteristics,
-  resolveAndroidBootSelectorDevice,
   resolveAndroidAvdName,
 } from '../devices.ts';
 
@@ -181,24 +180,3 @@ test('ensureAndroidEmulatorBooted launches emulator with GUI by default', async
     assert.doesNotMatch(log, /-no-window/);
   });
 });
-
-test('resolveAndroidBootSelectorDevice matches emulator by device name', async () => {
-  await withMockedAndroidTools(async () => {
-    await fs.writeFile(process.env.AGENT_DEVICE_TEST_EMU_BOOTED_FILE!, 'ready', 'utf8');
-    const device = await resolveAndroidBootSelectorDevice({ deviceName: 'Pixel 9 Pro XL', includeTarget: true });
-    assert.ok(device);
-    assert.equal(device?.id, 'emulator-5554');
-    assert.equal(device?.kind, 'emulator');
-    assert.equal(device?.target, 'mobile');
-    assert.equal(device?.booted, true);
-  });
-});
-
-test('resolveAndroidBootSelectorDevice matches by serial', async () => {
-  await withMockedAndroidTools(async () => {
-    await fs.writeFile(process.env.AGENT_DEVICE_TEST_EMU_BOOTED_FILE!, 'ready', 'utf8');
-    const device = await resolveAndroidBootSelectorDevice({ serial: 'emulator-5554' });
-    assert.ok(device);
-    assert.equal(device?.id, 'emulator-5554');
-  });
-});

src/platforms/android/devices.ts

@@ -187,62 +187,6 @@ async function listAndroidDeviceEntries(): Promise<AndroidDeviceEntry[]> {
   return parseAndroidDeviceEntries(result.stdout);
 }
 
-export async function resolveAndroidBootSelectorDevice(params: {
-  deviceName?: string;
-  serial?: string;
-  includeTarget?: boolean;
-}): Promise<DeviceInfo | undefined> {
-  const adbAvailable = await whichCmd('adb');
-  if (!adbAvailable) {
-    throw new AppError('TOOL_MISSING', 'adb not found in PATH');
-  }
-
-  const entries = await listAndroidDeviceEntries();
-  if (entries.length === 0) return undefined;
-
-  const serialSelector = params.serial?.trim();
-  const deviceNameSelector = params.deviceName?.trim();
-
-  let matched: AndroidDeviceEntry | undefined;
-  let matchedName: string | undefined;
-
-  if (serialSelector) {
-    matched = entries.find((entry) => entry.serial === serialSelector);
-    if (!matched) return undefined;
-    matchedName = await resolveAndroidDeviceName(matched.serial, matched.rawModel);
-  } else if (deviceNameSelector) {
-    const target = normalizeAndroidName(deviceNameSelector);
-    for (const entry of entries) {
-      const modelName = entry.rawModel.replace(/_/g, ' ').trim();
-      if (normalizeAndroidName(modelName) === target) {
-        matched = entry;
-        matchedName = modelName || entry.serial;
-        break;
-      }
-      const resolvedName = await resolveAndroidDeviceName(entry.serial, entry.rawModel);
-      if (normalizeAndroidName(resolvedName) === target) {
-        matched = entry;
-        matchedName = resolvedName;
-        break;
-      }
-    }
-  } else {
-    return undefined;
-  }
-
-  if (!matched) return undefined;
-  const booted = await isAndroidBooted(matched.serial);
-  const target = params.includeTarget ? await resolveAndroidTarget(matched.serial) : undefined;
-  return {
-    platform: 'android',
-    id: matched.serial,
-    name: matchedName ?? (matched.rawModel.replace(/_/g, ' ').trim() || matched.serial),
-    kind: isEmulatorSerial(matched.serial) ? 'emulator' : 'device',
-    target,
-    booted,
-  };
-}
-
 export function parseAndroidAvdList(rawOutput: string): string[] {
   return rawOutput
     .split('\n')