agent-device 0.3.1 → 0.3.2

package/src/daemon/handlers/session.ts

@@ -14,6 +14,39 @@ import { pruneGroupNodes } from '../snapshot-processing.ts';
 import { buildSelectorChainForNode, parseSelectorChain, resolveSelectorChain, splitSelectorFromArgs } from '../selectors.ts';
 import { inferFillText, uniqueStrings } from '../action-utils.ts';
 
+type ReinstallOps = {
+  ios: (device: DeviceInfo, app: string, appPath: string) => Promise<{ bundleId: string }>;
+  android: (device: DeviceInfo, app: string, appPath: string) => Promise<{ package: string }>;
+};
+
+function hasExplicitDeviceSelector(flags: DaemonRequest['flags'] | undefined): boolean {
+  return Boolean(flags?.platform || flags?.device || flags?.udid || flags?.serial);
+}
+
+async function resolveCommandDevice(params: {
+  session: SessionState | undefined;
+  flags: DaemonRequest['flags'] | undefined;
+  ensureReadyFn: typeof ensureDeviceReady;
+  ensureReady?: boolean;
+}): Promise<DeviceInfo> {
+  const device = params.session?.device ?? (await resolveTargetDevice(params.flags ?? {}));
+  if (params.ensureReady !== false) {
+    await params.ensureReadyFn(device);
+  }
+  return device;
+}
+
+const defaultReinstallOps: ReinstallOps = {
+  ios: async (device, app, appPath) => {
+    const { reinstallIosApp } = await import('../../platforms/ios/index.ts');
+    return await reinstallIosApp(device, app, appPath);
+  },
+  android: async (device, app, appPath) => {
+    const { reinstallAndroidApp } = await import('../../platforms/android/index.ts');
+    return await reinstallAndroidApp(device, app, appPath);
+  },
+};
+
 export async function handleSessionCommands(params: {
   req: DaemonRequest;
   sessionName: string;
@@ -21,9 +54,21 @@ export async function handleSessionCommands(params: {
   sessionStore: SessionStore;
   invoke: (req: DaemonRequest) => Promise<DaemonResponse>;
   dispatch?: typeof dispatchCommand;
+  ensureReady?: typeof ensureDeviceReady;
+  reinstallOps?: ReinstallOps;
 }): Promise<DaemonResponse | null> {
-  const { req, sessionName, logPath, sessionStore, invoke, dispatch: dispatchOverride } = params;
+  const {
+    req,
+    sessionName,
+    logPath,
+    sessionStore,
+    invoke,
+    dispatch: dispatchOverride,
+    ensureReady: ensureReadyOverride,
+    reinstallOps = defaultReinstallOps,
+  } = params;
   const dispatch = dispatchOverride ?? dispatchCommand;
+  const ensureReady = ensureReadyOverride ?? ensureDeviceReady;
   const command = req.command;
 
   if (command === 'session_list') {
@@ -72,7 +117,7 @@ export async function handleSessionCommands(params: {
   if (command === 'apps') {
     const session = sessionStore.get(sessionName);
     const flags = req.flags ?? {};
-    if (!session && !flags.platform && !flags.device && !flags.udid && !flags.serial) {
+    if (!session && !hasExplicitDeviceSelector(flags)) {
       return {
         ok: false,
         error: {
@@ -81,8 +126,7 @@ export async function handleSessionCommands(params: {
         },
       };
     }
-    const device = session?.device ?? (await resolveTargetDevice(flags));
-    await ensureDeviceReady(device);
+    const device = await resolveCommandDevice({ session, flags, ensureReadyFn: ensureReady, ensureReady: true });
     if (!isCommandSupportedOnDevice('apps', device)) {
       return { ok: false, error: { code: 'UNSUPPORTED_OPERATION', message: 'apps is not supported on this device' } };
     }
@@ -106,11 +150,39 @@ export async function handleSessionCommands(params: {
     return { ok: true, data: { apps } };
   }
 
-  if (command === 'appstate') {
+  if (command === 'boot') {
     const session = sessionStore.get(sessionName);
     const flags = req.flags ?? {};
+    if (!session && !hasExplicitDeviceSelector(flags)) {
+      return {
+        ok: false,
+        error: {
+          code: 'INVALID_ARGS',
+          message: 'boot requires an active session or an explicit device selector (e.g. --platform ios).',
+        },
+      };
+    }
     const device = session?.device ?? (await resolveTargetDevice(flags));
-    await ensureDeviceReady(device);
+    if (!isCommandSupportedOnDevice('boot', device)) {
+      return { ok: false, error: { code: 'UNSUPPORTED_OPERATION', message: 'boot is not supported on this device' } };
+    }
+    await ensureReady(device);
+    return {
+      ok: true,
+      data: {
+        platform: device.platform,
+        device: device.name,
+        id: device.id,
+        kind: device.kind,
+        booted: true,
+      },
+    };
+  }
+
+  if (command === 'appstate') {
+    const session = sessionStore.get(sessionName);
+    const flags = req.flags ?? {};
+    const device = await resolveCommandDevice({ session, flags, ensureReadyFn: ensureReady, ensureReady: true });
     if (device.platform === 'ios') {
       if (session?.appBundleId) {
         return {
@@ -151,6 +223,62 @@ export async function handleSessionCommands(params: {
     };
   }
 
+  if (command === 'reinstall') {
+    const session = sessionStore.get(sessionName);
+    const flags = req.flags ?? {};
+    if (!session && !hasExplicitDeviceSelector(flags)) {
+      return {
+        ok: false,
+        error: {
+          code: 'INVALID_ARGS',
+          message: 'reinstall requires an active session or an explicit device selector (e.g. --platform ios).',
+        },
+      };
+    }
+    const app = req.positionals?.[0]?.trim();
+    const appPathInput = req.positionals?.[1]?.trim();
+    if (!app || !appPathInput) {
+      return {
+        ok: false,
+        error: { code: 'INVALID_ARGS', message: 'reinstall requires: reinstall <app> <path-to-app-binary>' },
+      };
+    }
+    const appPath = SessionStore.expandHome(appPathInput);
+    if (!fs.existsSync(appPath)) {
+      return {
+        ok: false,
+        error: { code: 'INVALID_ARGS', message: `App binary not found: ${appPath}` },
+      };
+    }
+    const device = await resolveCommandDevice({ session, flags, ensureReadyFn: ensureReady, ensureReady: false });
+    if (!isCommandSupportedOnDevice('reinstall', device)) {
+      return {
+        ok: false,
+        error: { code: 'UNSUPPORTED_OPERATION', message: 'reinstall is not supported on this device' },
+      };
+    }
+    let reinstallData:
+      | { platform: 'ios'; appId: string; bundleId: string }
+      | { platform: 'android'; appId: string; package: string };
+    if (device.platform === 'ios') {
+      const iosResult = await reinstallOps.ios(device, app, appPath);
+      reinstallData = { platform: 'ios', appId: iosResult.bundleId, bundleId: iosResult.bundleId };
+    } else {
+      const androidResult = await reinstallOps.android(device, app, appPath);
+      reinstallData = { platform: 'android', appId: androidResult.package, package: androidResult.package };
+    }
+    const result = { app, appPath, ...reinstallData };
+    if (session) {
+      sessionStore.recordAction(session, {
+        command,
+        positionals: req.positionals ?? [],
+        flags: req.flags ?? {},
+        result,
+      });
+    }
+    return { ok: true, data: result };
+  }
+
   if (command === 'open') {
     if (sessionStore.has(sessionName)) {
       const session = sessionStore.get(sessionName);
@@ -193,7 +321,6 @@ export async function handleSessionCommands(params: {
       return { ok: true, data: { session: sessionName, appName, appBundleId } };
     }
     const device = await resolveTargetDevice(req.flags ?? {});
-    await ensureDeviceReady(device);
     const inUse = sessionStore.toArray().find((s) => s.device.id === device.id);
     if (inUse) {
       return {
@@ -269,7 +396,9 @@ export async function handleSessionCommands(params: {
           flags: action.flags ?? {},
         });
         if (response.ok) continue;
-        if (!shouldUpdate) return response;
+        if (!shouldUpdate) {
+          return withReplayFailureContext(response, action, index, resolved);
+        }
         const nextAction = await healReplayAction({
           action,
           sessionName,
@@ -278,7 +407,7 @@ export async function handleSessionCommands(params: {
           dispatch,
         });
         if (!nextAction) {
-          return response;
+          return withReplayFailureContext(response, action, index, resolved);
         }
         actions[index] = nextAction;
         response = await invoke({
@@ -289,7 +418,7 @@ export async function handleSessionCommands(params: {
           flags: nextAction.flags ?? {},
         });
         if (!response.ok) {
-          return response;
+          return withReplayFailureContext(response, nextAction, index, resolved);
         }
         healed += 1;
       }
@@ -334,6 +463,42 @@ export async function handleSessionCommands(params: {
   return null;
 }
 
+function withReplayFailureContext(
+  response: DaemonResponse,
+  action: SessionAction,
+  index: number,
+  replayPath: string,
+): DaemonResponse {
+  if (response.ok) return response;
+  const step = index + 1;
+  const summary = formatReplayActionSummary(action);
+  const details = {
+    ...(response.error.details ?? {}),
+    replayPath,
+    step,
+    action: action.command,
+    positionals: action.positionals ?? [],
+  };
+  return {
+    ok: false,
+    error: {
+      code: response.error.code,
+      message: `Replay failed at step ${step} (${summary}): ${response.error.message}`,
+      details,
+    },
+  };
+}
+
+function formatReplayActionSummary(action: SessionAction): string {
+  const values = (action.positionals ?? []).map((value) => {
+    const trimmed = value.trim();
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) return trimmed;
+    if (trimmed.startsWith('@')) return trimmed;
+    return JSON.stringify(trimmed);
+  });
+  return [action.command, ...values].join(' ');
+}
+
 async function healReplayAction(params: {
   action: SessionAction;
   sessionName: string;

package/src/platforms/__tests__/boot-diagnostics.test.ts

@@ -1,23 +1,38 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { classifyBootFailure } from '../boot-diagnostics.ts';
+import { bootFailureHint, classifyBootFailure } from '../boot-diagnostics.ts';
 import { AppError } from '../../utils/errors.ts';
 
 test('classifyBootFailure maps timeout errors', () => {
-  const reason = classifyBootFailure({ message: 'bootstatus timed out after 120s' });
-  assert.equal(reason, 'BOOT_TIMEOUT');
+  const reason = classifyBootFailure({
+    message: 'bootstatus timed out after 120s',
+    context: { platform: 'ios', phase: 'boot' },
+  });
+  assert.equal(reason, 'IOS_BOOT_TIMEOUT');
 });
 
 test('classifyBootFailure maps adb offline errors', () => {
-  const reason = classifyBootFailure({ stderr: 'error: device offline' });
-  assert.equal(reason, 'DEVICE_OFFLINE');
+  const reason = classifyBootFailure({
+    stderr: 'error: device offline',
+    context: { platform: 'android', phase: 'transport' },
+  });
+  assert.equal(reason, 'ADB_TRANSPORT_UNAVAILABLE');
 });
 
-test('classifyBootFailure maps tool missing from AppError code', () => {
+test('classifyBootFailure maps tool missing from AppError code (android)', () => {
   const reason = classifyBootFailure({
     error: new AppError('TOOL_MISSING', 'adb not found in PATH'),
+    context: { platform: 'android', phase: 'transport' },
+  });
+  assert.equal(reason, 'ADB_TRANSPORT_UNAVAILABLE');
+});
+
+test('classifyBootFailure maps tool missing from AppError code (ios)', () => {
+  const reason = classifyBootFailure({
+    error: new AppError('TOOL_MISSING', 'xcrun not found in PATH'),
+    context: { platform: 'ios', phase: 'boot' },
   });
-  assert.equal(reason, 'TOOL_MISSING');
+  assert.equal(reason, 'IOS_TOOL_MISSING');
 });
 
 test('classifyBootFailure reads stderr from AppError details', () => {
@@ -25,6 +40,20 @@ test('classifyBootFailure reads stderr from AppError details', () => {
     error: new AppError('COMMAND_FAILED', 'adb failed', {
       stderr: 'error: device unauthorized',
     }),
+    context: { platform: 'android', phase: 'transport' },
+  });
+  assert.equal(reason, 'ADB_TRANSPORT_UNAVAILABLE');
+});
+
+test('bootFailureHint returns actionable guidance', () => {
+  const hint = bootFailureHint('IOS_RUNNER_CONNECT_TIMEOUT');
+  assert.equal(hint.includes('xcodebuild logs'), true);
+});
+
+test('connect phase does not classify non-timeout errors as connect timeout', () => {
+  const reason = classifyBootFailure({
+    message: 'Runner returned malformed JSON payload',
+    context: { platform: 'ios', phase: 'connect' },
   });
-  assert.equal(reason, 'PERMISSION_DENIED');
+  assert.equal(reason, 'BOOT_COMMAND_FAILED');
 });

package/src/platforms/android/__tests__/index.test.ts

@@ -1,5 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
+import { parseAndroidLaunchComponent } from '../index.ts';
 import { findBounds, parseUiHierarchy } from '../ui-hierarchy.ts';
 
 test('parseUiHierarchy reads double-quoted Android node attributes', () => {
@@ -72,3 +73,19 @@ test('findBounds ignores bounds-like fragments inside other attribute values', (
 
   assert.deepEqual(findBounds(xml, 'target'), { x: 200, y: 350 });
 });
+
+test('parseAndroidLaunchComponent extracts final resolved component', () => {
+  const stdout = [
+    'priority=0 preferredOrder=0 match=0x108000 specificIndex=-1 isDefault=true',
+    'com.boatsgroup.boattrader/com.boatsgroup.boattrader.MainActivity',
+  ].join('\n');
+  assert.equal(
+    parseAndroidLaunchComponent(stdout),
+    'com.boatsgroup.boattrader/com.boatsgroup.boattrader.MainActivity',
+  );
+});
+
+test('parseAndroidLaunchComponent returns null when no component is present', () => {
+  const stdout = 'No activity found';
+  assert.equal(parseAndroidLaunchComponent(stdout), null);
+});

package/src/platforms/android/devices.ts

@@ -2,11 +2,12 @@ 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';
+import { Deadline, isEnvTruthy, retryWithPolicy, TIMEOUT_PROFILES, type RetryTelemetryEvent } from '../../utils/retry.ts';
+import { bootFailureHint, classifyBootFailure } from '../boot-diagnostics.ts';
 
 const EMULATOR_SERIAL_PREFIX = 'emulator-';
 const ANDROID_BOOT_POLL_MS = 1000;
+const RETRY_LOGS_ENABLED = isEnvTruthy(process.env.AGENT_DEVICE_RETRY_LOGS);
 
 function adbArgs(serial: string, args: string[]): string[] {
   return ['-s', serial, ...args];
@@ -16,9 +17,13 @@ function isEmulatorSerial(serial: string): boolean {
   return serial.startsWith(EMULATOR_SERIAL_PREFIX);
 }
 
-async function readAndroidBootProp(serial: string): Promise<ExecResult> {
+async function readAndroidBootProp(
+  serial: string,
+  timeoutMs = TIMEOUT_PROFILES.android_boot.operationMs,
+): Promise<ExecResult> {
   return runCmd('adb', adbArgs(serial, ['shell', 'getprop', 'sys.boot_completed']), {
     allowFailure: true,
+    timeoutMs,
   });
 }
 
@@ -27,6 +32,7 @@ async function resolveAndroidDeviceName(serial: string, rawModel: string): Promi
   if (!isEmulatorSerial(serial)) return modelName || serial;
   const avd = await runCmd('adb', adbArgs(serial, ['emu', 'avd', 'name']), {
     allowFailure: true,
+    timeoutMs: TIMEOUT_PROFILES.android_boot.operationMs,
   });
   const avdName = avd.stdout.trim();
   if (avd.exitCode === 0 && avdName) {
@@ -41,7 +47,9 @@ export async function listAndroidDevices(): Promise<DeviceInfo[]> {
     throw new AppError('TOOL_MISSING', 'adb not found in PATH');
   }
 
-  const result = await runCmd('adb', ['devices', '-l']);
+  const result = await runCmd('adb', ['devices', '-l'], {
+    timeoutMs: TIMEOUT_PROFILES.android_boot.operationMs,
+  });
   const lines = result.stdout.split('\n').map((l: string) => l.trim());
   const entries = lines
     .filter((line) => line.length > 0 && !line.startsWith('List of devices'))
@@ -79,8 +87,9 @@ export async function isAndroidBooted(serial: string): Promise<boolean> {
 }
 
 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));
+  const timeoutBudget = timeoutMs;
+  const deadline = Deadline.fromTimeoutMs(timeoutBudget);
+  const maxAttempts = Math.max(1, Math.ceil(timeoutBudget / ANDROID_BOOT_POLL_MS));
   let lastBootResult: ExecResult | undefined;
   let timedOut = false;
   try {
@@ -95,7 +104,11 @@ export async function waitForAndroidBoot(serial: string, timeoutMs = 60000): Pro
             message: 'timeout',
           });
         }
-        const result = await readAndroidBootProp(serial);
+        const remainingMs = Math.max(1_000, attemptDeadline?.remainingMs() ?? timeoutBudget);
+        const result = await readAndroidBootProp(
+          serial,
+          Math.min(remainingMs, TIMEOUT_PROFILES.android_boot.operationMs),
+        );
         lastBootResult = result;
         if (result.stdout.trim() === '1') return;
         throw new AppError('COMMAND_FAILED', 'Android device is still booting', {
@@ -115,41 +128,61 @@ export async function waitForAndroidBoot(serial: string, timeoutMs = 60000): Pro
             error,
             stdout: lastBootResult?.stdout,
             stderr: lastBootResult?.stderr,
+            context: { platform: 'android', phase: 'boot' },
           });
-          return reason !== 'PERMISSION_DENIED' && reason !== 'TOOL_MISSING' && reason !== 'BOOT_TIMEOUT';
+          return reason !== 'ADB_TRANSPORT_UNAVAILABLE' && reason !== 'ANDROID_BOOT_TIMEOUT';
+        },
+      },
+      {
+        deadline,
+        phase: 'boot',
+        classifyReason: (error) =>
+          classifyBootFailure({
+            error,
+            stdout: lastBootResult?.stdout,
+            stderr: lastBootResult?.stderr,
+            context: { platform: 'android', phase: 'boot' },
+          }),
+        onEvent: (event: RetryTelemetryEvent) => {
+          if (!RETRY_LOGS_ENABLED) return;
+          process.stderr.write(`[agent-device][retry] ${JSON.stringify(event)}\n`);
         },
       },
-      { deadline },
     );
   } catch (error) {
     const appErr = asAppError(error);
     const stdout = lastBootResult?.stdout;
     const stderr = lastBootResult?.stderr;
     const exitCode = lastBootResult?.exitCode;
-    const reason = classifyBootFailure({
+    let reason = classifyBootFailure({
       error,
       stdout,
       stderr,
+      context: { platform: 'android', phase: 'boot' },
     });
+    if (reason === 'BOOT_COMMAND_FAILED' && appErr.message === 'Android device is still booting') {
+      reason = 'ANDROID_BOOT_TIMEOUT';
+    }
     const baseDetails = {
       serial,
-      timeoutMs,
+      timeoutMs: timeoutBudget,
       elapsedMs: deadline.elapsedMs(),
       reason,
+      hint: bootFailureHint(reason),
       stdout,
       stderr,
       exitCode,
     };
-    if (timedOut || reason === 'BOOT_TIMEOUT') {
+    if (timedOut || reason === 'ANDROID_BOOT_TIMEOUT') {
       throw new AppError('COMMAND_FAILED', 'Android device did not finish booting in time', baseDetails);
     }
-    if (appErr.code === 'TOOL_MISSING' || reason === 'TOOL_MISSING') {
+    if (appErr.code === 'TOOL_MISSING') {
       throw new AppError('TOOL_MISSING', appErr.message, {
         ...baseDetails,
         ...(appErr.details ?? {}),
       });
     }
-    if (reason === 'PERMISSION_DENIED' || reason === 'DEVICE_UNAVAILABLE' || reason === 'DEVICE_OFFLINE') {
+    if (reason === 'ADB_TRANSPORT_UNAVAILABLE') {
       throw new AppError('COMMAND_FAILED', appErr.message, {
         ...baseDetails,
         ...(appErr.details ?? {}),

package/src/platforms/android/index.ts

@@ -187,22 +187,70 @@ export async function openAndroidApp(
     );
     return;
   }
-  await runCmd(
+  try {
+    await runCmd(
+      'adb',
+      adbArgs(device, [
+        'shell',
+        'am',
+        'start',
+        '-a',
+        'android.intent.action.MAIN',
+        '-c',
+        'android.intent.category.DEFAULT',
+        '-c',
+        'android.intent.category.LAUNCHER',
+        '-p',
+        resolved.value,
+      ]),
+    );
+    return;
+  } catch (initialError) {
+    const component = await resolveAndroidLaunchComponent(device, resolved.value);
+    if (!component) throw initialError;
+    await runCmd(
+      'adb',
+      adbArgs(device, [
+        'shell',
+        'am',
+        'start',
+        '-a',
+        'android.intent.action.MAIN',
+        '-c',
+        'android.intent.category.DEFAULT',
+        '-c',
+        'android.intent.category.LAUNCHER',
+        '-n',
+        component,
+      ]),
+    );
+  }
+}
+
+async function resolveAndroidLaunchComponent(
+  device: DeviceInfo,
+  packageName: string,
+): Promise<string | null> {
+  const result = await runCmd(
     'adb',
-    adbArgs(device, [
-      'shell',
-      'am',
-      'start',
-      '-a',
-      'android.intent.action.MAIN',
-      '-c',
-      'android.intent.category.DEFAULT',
-      '-c',
-      'android.intent.category.LAUNCHER',
-      '-p',
-      resolved.value,
-    ]),
+    adbArgs(device, ['shell', 'cmd', 'package', 'resolve-activity', '--brief', packageName]),
+    { allowFailure: true },
   );
+  if (result.exitCode !== 0) return null;
+  return parseAndroidLaunchComponent(result.stdout);
+}
+
+export function parseAndroidLaunchComponent(stdout: string): string | null {
+  const lines = stdout
+    .split('\n')
+    .map((line: string) => line.trim())
+    .filter(Boolean);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index];
+    if (!line.includes('/')) continue;
+    return line.split(/\s+/)[0];
+  }
+  return null;
 }
 
 export async function openAndroidDevice(device: DeviceInfo): Promise<void> {
@@ -224,6 +272,45 @@ export async function closeAndroidApp(device: DeviceInfo, app: string): Promise<
   await runCmd('adb', adbArgs(device, ['shell', 'am', 'force-stop', resolved.value]));
 }
 
+export async function uninstallAndroidApp(
+  device: DeviceInfo,
+  app: string,
+): Promise<{ package: string }> {
+  const resolved = await resolveAndroidApp(device, app);
+  if (resolved.type === 'intent') {
+    throw new AppError('INVALID_ARGS', 'reinstall requires a package name, not an intent');
+  }
+  const result = await runCmd('adb', adbArgs(device, ['uninstall', resolved.value]), { allowFailure: true });
+  if (result.exitCode !== 0) {
+    const output = `${result.stdout}\n${result.stderr}`.toLowerCase();
+    if (!output.includes('unknown package') && !output.includes('not installed')) {
+      throw new AppError('COMMAND_FAILED', `adb uninstall failed for ${resolved.value}`, {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode,
+      });
+    }
+  }
+  return { package: resolved.value };
+}
+
+export async function installAndroidApp(device: DeviceInfo, appPath: string): Promise<void> {
+  await runCmd('adb', adbArgs(device, ['install', appPath]));
+}
+
+export async function reinstallAndroidApp(
+  device: DeviceInfo,
+  app: string,
+  appPath: string,
+): Promise<{ package: string }> {
+  if (!device.booted) {
+    await waitForAndroidBoot(device.id);
+  }
+  const { package: pkg } = await uninstallAndroidApp(device, app);
+  await installAndroidApp(device, appPath);
+  return { package: pkg };
+}
+
 export async function pressAndroid(device: DeviceInfo, x: number, y: number): Promise<void> {
   await runCmd('adb', adbArgs(device, ['shell', 'input', 'tap', String(x), String(y)]));
 }