devices.ts

import { runCmd, whichCmd } from '../../utils/exec.ts';
import type { ExecResult } from '../../utils/exec.ts';
import { AppError, asAppError } from '../../utils/errors.ts';
import type { DeviceInfo } from '../../utils/device.ts';
import { Deadline, retryWithPolicy } from '../../utils/retry.ts';
import { classifyBootFailure } from '../boot-diagnostics.ts';

const EMULATOR_SERIAL_PREFIX = 'emulator-';
const ANDROID_BOOT_POLL_MS = 1000;

function adbArgs(serial: string, args: string[]): string[] {
  return ['-s', serial, ...args];
}

function isEmulatorSerial(serial: string): boolean {
  return serial.startsWith(EMULATOR_SERIAL_PREFIX);
}

async function readAndroidBootProp(serial: string): Promise<ExecResult> {
  return runCmd('adb', adbArgs(serial, ['shell', 'getprop', 'sys.boot_completed']), {
    allowFailure: true,
  });
}

async function resolveAndroidDeviceName(serial: string, rawModel: string): Promise<string> {
  const modelName = rawModel.replace(/_/g, ' ').trim();
  if (!isEmulatorSerial(serial)) return modelName || serial;
  const avd = await runCmd('adb', adbArgs(serial, ['emu', 'avd', 'name']), {
    allowFailure: true,
  });
  const avdName = avd.stdout.trim();
  if (avd.exitCode === 0 && avdName) {
    return avdName.replace(/_/g, ' ');
  }
  return modelName || serial;
}

export async function listAndroidDevices(): Promise<DeviceInfo[]> {
  const adbAvailable = await whichCmd('adb');
  if (!adbAvailable) {
    throw new AppError('TOOL_MISSING', 'adb not found in PATH');
  }

  const result = await runCmd('adb', ['devices', '-l']);
  const lines = result.stdout.split('\n').map((l: string) => l.trim());
  const entries = lines
    .filter((line) => line.length > 0 && !line.startsWith('List of devices'))
    .map((line) => line.split(/\s+/))
    .filter((parts) => parts[1] === 'device')
    .map((parts) => ({
      serial: parts[0],
      rawModel: (parts.find((p: string) => p.startsWith('model:')) ?? '').replace('model:', ''),
    }));

  const devices = await Promise.all(entries.map(async ({ serial, rawModel }) => {
    const [name, booted] = await Promise.all([
      resolveAndroidDeviceName(serial, rawModel),
      isAndroidBooted(serial),
    ]);
    return {
      platform: 'android',
      id: serial,
      name,
      kind: isEmulatorSerial(serial) ? 'emulator' : 'device',
      booted,
    } satisfies DeviceInfo;
  }));

  return devices;
}

export async function isAndroidBooted(serial: string): Promise<boolean> {
  try {
    const result = await readAndroidBootProp(serial);
    return result.stdout.trim() === '1';
  } catch {
    return false;
  }
}

export async function waitForAndroidBoot(serial: string, timeoutMs = 60000): Promise<void> {
  const deadline = Deadline.fromTimeoutMs(timeoutMs);
  const maxAttempts = Math.max(1, Math.ceil(timeoutMs / ANDROID_BOOT_POLL_MS));
  let lastBootResult: ExecResult | undefined;
  let timedOut = false;
  try {
    await retryWithPolicy(
      async ({ deadline: attemptDeadline }) => {
        if (attemptDeadline?.isExpired()) {
          timedOut = true;
          throw new AppError('COMMAND_FAILED', 'Android boot deadline exceeded', {
            serial,
            timeoutMs,
            elapsedMs: deadline.elapsedMs(),
            message: 'timeout',
          });
        }
        const result = await readAndroidBootProp(serial);
        lastBootResult = result;
        if (result.stdout.trim() === '1') return;
        throw new AppError('COMMAND_FAILED', 'Android device is still booting', {
          serial,
          stdout: result.stdout,
          stderr: result.stderr,
          exitCode: result.exitCode,
        });
      },
      {
        maxAttempts,
        baseDelayMs: ANDROID_BOOT_POLL_MS,
        maxDelayMs: ANDROID_BOOT_POLL_MS,
        jitter: 0,
        shouldRetry: (error) => {
          const reason = classifyBootFailure({
            error,
            stdout: lastBootResult?.stdout,
            stderr: lastBootResult?.stderr,
          });
          return reason !== 'PERMISSION_DENIED' && reason !== 'TOOL_MISSING' && reason !== 'BOOT_TIMEOUT';
        },
      },
      { deadline },
    );
  } catch (error) {
    const appErr = asAppError(error);
    const stdout = lastBootResult?.stdout;
    const stderr = lastBootResult?.stderr;
    const exitCode = lastBootResult?.exitCode;
    const reason = classifyBootFailure({
      error,
      stdout,
      stderr,
    });
    const baseDetails = {
      serial,
      timeoutMs,
      elapsedMs: deadline.elapsedMs(),
      reason,
      stdout,
      stderr,
      exitCode,
    };
    if (timedOut || reason === 'BOOT_TIMEOUT') {
      throw new AppError('COMMAND_FAILED', 'Android device did not finish booting in time', baseDetails);
    }
    if (appErr.code === 'TOOL_MISSING' || reason === 'TOOL_MISSING') {
      throw new AppError('TOOL_MISSING', appErr.message, {
        ...baseDetails,
        ...(appErr.details ?? {}),
      });
    }
    if (reason === 'PERMISSION_DENIED' || reason === 'DEVICE_UNAVAILABLE' || reason === 'DEVICE_OFFLINE') {
      throw new AppError('COMMAND_FAILED', appErr.message, {
        ...baseDetails,
        ...(appErr.details ?? {}),
      });
    }
    throw new AppError(appErr.code, appErr.message, {
      ...baseDetails,
      ...(appErr.details ?? {}),
    }, appErr.cause);
  }
}