agent-device 0.4.0 → 0.4.2

package/src/daemon-client.ts

@@ -6,6 +6,10 @@ import { AppError } from './utils/errors.ts';
 import type { CommandFlags } from './core/dispatch.ts';
 import { runCmdDetached } from './utils/exec.ts';
 import { findProjectRoot, readVersion } from './utils/version.ts';
+import {
+  isAgentDeviceDaemonProcess,
+  stopProcessForTakeover,
+} from './utils/process-identity.ts';
 
 export type DaemonRequest = {
   token: string;
@@ -19,12 +23,32 @@ export type DaemonResponse =
   | { ok: true; data?: Record<string, unknown> }
   | { ok: false; error: { code: string; message: string; details?: Record<string, unknown> } };
 
-type DaemonInfo = { port: number; token: string; pid: number; version?: string };
+type DaemonInfo = {
+  port: number;
+  token: string;
+  pid: number;
+  version?: string;
+  processStartTime?: string;
+};
+
+type DaemonLockInfo = {
+  pid: number;
+  processStartTime?: string;
+  startedAt?: number;
+};
+
+type DaemonMetadataState = {
+  hasInfo: boolean;
+  hasLock: boolean;
+};
 
 const baseDir = path.join(os.homedir(), '.agent-device');
 const infoPath = path.join(baseDir, 'daemon.json');
-const REQUEST_TIMEOUT_MS = resolveRequestTimeoutMs();
+const lockPath = path.join(baseDir, 'daemon.lock');
+const REQUEST_TIMEOUT_MS = resolveDaemonRequestTimeoutMs();
 const DAEMON_STARTUP_TIMEOUT_MS = 5000;
+const DAEMON_TAKEOVER_TERM_TIMEOUT_MS = 3000;
+const DAEMON_TAKEOVER_KILL_TIMEOUT_MS = 1000;
 
 export async function sendToDaemon(req: Omit<DaemonRequest, 'token'>): Promise<DaemonResponse> {
   const info = await ensureDaemon();
@@ -38,40 +62,128 @@ async function ensureDaemon(): Promise<DaemonInfo> {
   const existingReachable = existing ? await canConnect(existing) : false;
   if (existing && existing.version === localVersion && existingReachable) return existing;
   if (existing && (existing.version !== localVersion || !existingReachable)) {
+    await stopDaemonProcessForTakeover(existing);
     removeDaemonInfo();
   }
 
+  cleanupStaleDaemonLockIfSafe();
   await startDaemon();
+  const started = await waitForDaemonInfo(DAEMON_STARTUP_TIMEOUT_MS);
+  if (started) return started;
+
+  if (await recoverDaemonLockHolder()) {
+    await startDaemon();
+    const recovered = await waitForDaemonInfo(DAEMON_STARTUP_TIMEOUT_MS);
+    if (recovered) return recovered;
+  }
+
+  throw new AppError('COMMAND_FAILED', 'Failed to start daemon', {
+    kind: 'daemon_startup_failed',
+    infoPath,
+    lockPath,
+    hint: resolveDaemonStartupHint(getDaemonMetadataState()),
+  });
+}
 
+async function waitForDaemonInfo(timeoutMs: number): Promise<DaemonInfo | null> {
   const start = Date.now();
-  while (Date.now() - start < DAEMON_STARTUP_TIMEOUT_MS) {
+  while (Date.now() - start < timeoutMs) {
     const info = readDaemonInfo();
     if (info && (await canConnect(info))) return info;
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
+  return null;
+}
 
-  throw new AppError('COMMAND_FAILED', 'Failed to start daemon', {
-    infoPath,
-    hint: 'Run pnpm build, or delete ~/.agent-device/daemon.json if stale.',
+async function recoverDaemonLockHolder(): Promise<boolean> {
+  const state = getDaemonMetadataState();
+  if (!state.hasLock || state.hasInfo) return false;
+  const lockInfo = readDaemonLockInfo();
+  if (!lockInfo) {
+    removeDaemonLock();
+    return true;
+  }
+  if (!isAgentDeviceDaemonProcess(lockInfo.pid, lockInfo.processStartTime)) {
+    removeDaemonLock();
+    return true;
+  }
+  await stopProcessForTakeover(lockInfo.pid, {
+    termTimeoutMs: DAEMON_TAKEOVER_TERM_TIMEOUT_MS,
+    killTimeoutMs: DAEMON_TAKEOVER_KILL_TIMEOUT_MS,
+    expectedStartTime: lockInfo.processStartTime,
+  });
+  removeDaemonLock();
+  return true;
+}
+
+async function stopDaemonProcessForTakeover(info: DaemonInfo): Promise<void> {
+  await stopProcessForTakeover(info.pid, {
+    termTimeoutMs: DAEMON_TAKEOVER_TERM_TIMEOUT_MS,
+    killTimeoutMs: DAEMON_TAKEOVER_KILL_TIMEOUT_MS,
+    expectedStartTime: info.processStartTime,
   });
 }
 
 function readDaemonInfo(): DaemonInfo | null {
-  if (!fs.existsSync(infoPath)) return null;
+  const data = readJsonFile(infoPath) as DaemonInfo | null;
+  if (!data || !data.port || !data.token) return null;
+  return {
+    ...data,
+    pid: Number.isInteger(data.pid) && data.pid > 0 ? data.pid : 0,
+  };
+}
+
+function readDaemonLockInfo(): DaemonLockInfo | null {
+  const data = readJsonFile(lockPath) as DaemonLockInfo | null;
+  if (!data || !Number.isInteger(data.pid) || data.pid <= 0) {
+    return null;
+  }
+  return data;
+}
+
+function removeDaemonInfo(): void {
+  removeFileIfExists(infoPath);
+}
+
+function removeDaemonLock(): void {
+  removeFileIfExists(lockPath);
+}
+
+function cleanupStaleDaemonLockIfSafe(): void {
+  const state = getDaemonMetadataState();
+  if (!state.hasLock || state.hasInfo) return;
+  const lockInfo = readDaemonLockInfo();
+  if (!lockInfo) {
+    removeDaemonLock();
+    return;
+  }
+  if (isAgentDeviceDaemonProcess(lockInfo.pid, lockInfo.processStartTime)) {
+    return;
+  }
+  removeDaemonLock();
+}
+
+function getDaemonMetadataState(): DaemonMetadataState {
+  return {
+    hasInfo: fs.existsSync(infoPath),
+    hasLock: fs.existsSync(lockPath),
+  };
+}
+
+function readJsonFile(filePath: string): unknown | null {
+  if (!fs.existsSync(filePath)) return null;
   try {
-    const data = JSON.parse(fs.readFileSync(infoPath, 'utf8')) as DaemonInfo;
-    if (!data.port || !data.token) return null;
-    return data;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8')) as unknown;
   } catch {
     return null;
   }
 }
 
-function removeDaemonInfo(): void {
+function removeFileIfExists(filePath: string): void {
   try {
-    if (fs.existsSync(infoPath)) fs.unlinkSync(infoPath);
+    if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
   } catch {
-    // Best-effort cleanup only; daemon can still overwrite this file on startup.
+    // Best-effort cleanup only.
   }
 }
 
@@ -142,10 +254,19 @@ async function sendRequest(info: DaemonInfo, req: DaemonRequest): Promise<Daemon
   });
 }
 
-function resolveRequestTimeoutMs(): number {
-  const raw = process.env.AGENT_DEVICE_DAEMON_TIMEOUT_MS;
-  if (!raw) return 60000;
+export function resolveDaemonRequestTimeoutMs(raw: string | undefined = process.env.AGENT_DEVICE_DAEMON_TIMEOUT_MS): number {
+  if (!raw) return 90000;
   const parsed = Number(raw);
-  if (!Number.isFinite(parsed)) return 60000;
+  if (!Number.isFinite(parsed)) return 90000;
   return Math.max(1000, Math.floor(parsed));
 }
+
+export function resolveDaemonStartupHint(state: { hasInfo: boolean; hasLock: boolean }): string {
+  if (state.hasLock && !state.hasInfo) {
+    return 'Detected ~/.agent-device/daemon.lock without daemon.json. If no agent-device daemon process is running, delete ~/.agent-device/daemon.lock and retry.';
+  }
+  if (state.hasLock && state.hasInfo) {
+    return 'Daemon metadata may be stale. If no agent-device daemon process is running, delete ~/.agent-device/daemon.json and ~/.agent-device/daemon.lock, then retry.';
+  }
+  return 'Daemon metadata is missing or stale. Delete ~/.agent-device/daemon.json if present and retry.';
+}

package/src/daemon.ts

@@ -7,7 +7,7 @@ import { dispatchCommand, type CommandFlags } from './core/dispatch.ts';
 import { isCommandSupportedOnDevice } from './core/capabilities.ts';
 import { asAppError, AppError } from './utils/errors.ts';
 import { readVersion } from './utils/version.ts';
-import { stopIosRunnerSession } from './platforms/ios/runner-client.ts';
+import { stopAllIosRunnerSessions } from './platforms/ios/runner-client.ts';
 import type { DaemonRequest, DaemonResponse } from './daemon/types.ts';
 import { SessionStore } from './daemon/session-store.ts';
 import { contextFromFlags as contextFromFlagsWithLog, type DaemonCommandContext } from './daemon/context.ts';
@@ -18,9 +18,14 @@ import { handleRecordTraceCommands } from './daemon/handlers/record-trace.ts';
 import { handleInteractionCommands } from './daemon/handlers/interaction.ts';
 import { assertSessionSelectorMatches } from './daemon/session-selector.ts';
 import { resolveEffectiveSessionName } from './daemon/session-routing.ts';
+import {
+  isAgentDeviceDaemonProcess,
+  readProcessStartTime,
+} from './utils/process-identity.ts';
 
 const baseDir = path.join(os.homedir(), '.agent-device');
 const infoPath = path.join(baseDir, 'daemon.json');
+const lockPath = path.join(baseDir, 'daemon.lock');
 const logPath = path.join(baseDir, 'daemon.log');
 const sessionsDir = path.join(baseDir, 'sessions');
 const sessionStore = new SessionStore(sessionsDir);
@@ -28,6 +33,15 @@ const version = readVersion();
 const token = crypto.randomBytes(24).toString('hex');
 const selectorValidationExemptCommands = new Set(['session_list', 'devices']);
 
+type DaemonLockInfo = {
+  pid: number;
+  version: string;
+  startedAt: number;
+  processStartTime?: string;
+};
+
+const daemonProcessStartTime = readProcessStartTime(process.pid) ?? undefined;
+
 function contextFromFlags(
   flags: CommandFlags | undefined,
   appBundleId?: string,
@@ -122,7 +136,7 @@ function writeInfo(port: number): void {
   fs.writeFileSync(logPath, '');
   fs.writeFileSync(
     infoPath,
-    JSON.stringify({ port, token, pid: process.pid, version }, null, 2),
+    JSON.stringify({ port, token, pid: process.pid, version, processStartTime: daemonProcessStartTime }, null, 2),
     {
       mode: 0o600,
     },
@@ -133,7 +147,73 @@ function removeInfo(): void {
   if (fs.existsSync(infoPath)) fs.unlinkSync(infoPath);
 }
 
+function readLockInfo(): DaemonLockInfo | null {
+  if (!fs.existsSync(lockPath)) return null;
+  try {
+    const parsed = JSON.parse(fs.readFileSync(lockPath, 'utf8')) as DaemonLockInfo;
+    if (!Number.isInteger(parsed.pid) || parsed.pid <= 0) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function acquireDaemonLock(): boolean {
+  if (!fs.existsSync(baseDir)) fs.mkdirSync(baseDir, { recursive: true });
+  const lockData: DaemonLockInfo = {
+    pid: process.pid,
+    version,
+    startedAt: Date.now(),
+    processStartTime: daemonProcessStartTime,
+  };
+  const payload = JSON.stringify(lockData, null, 2);
+
+  const tryWriteLock = (): boolean => {
+    try {
+      fs.writeFileSync(lockPath, payload, { flag: 'wx', mode: 0o600 });
+      return true;
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'EEXIST') return false;
+      throw err;
+    }
+  };
+
+  if (tryWriteLock()) return true;
+  const existing = readLockInfo();
+  if (
+    existing?.pid
+    && existing.pid !== process.pid
+    && isAgentDeviceDaemonProcess(existing.pid, existing.processStartTime)
+  ) {
+    return false;
+  }
+  // Best-effort stale-lock cleanup: another process may win the race between unlink and re-create.
+  // We rely on the subsequent write with `wx` to enforce single-writer semantics.
+  try {
+    fs.unlinkSync(lockPath);
+  } catch {
+    // ignore
+  }
+  return tryWriteLock();
+}
+
+function releaseDaemonLock(): void {
+  const existing = readLockInfo();
+  if (existing && existing.pid !== process.pid) return;
+  try {
+    if (fs.existsSync(lockPath)) fs.unlinkSync(lockPath);
+  } catch {
+    // ignore
+  }
+}
+
 function start(): void {
+  if (!acquireDaemonLock()) {
+    process.stderr.write('Daemon lock is held by another process; exiting.\n');
+    process.exit(0);
+    return;
+  }
+
   const server = net.createServer((socket) => {
     let buffer = '';
     socket.setEncoding('utf8');
@@ -172,18 +252,28 @@ function start(): void {
     }
   });
 
+  let shuttingDown = false;
+  const closeServer = async (): Promise<void> => {
+    await new Promise<void>((resolve) => {
+      try {
+        server.close(() => resolve());
+      } catch {
+        resolve();
+      }
+    });
+  };
   const shutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    await closeServer();
     const sessionsToStop = sessionStore.toArray();
     for (const session of sessionsToStop) {
-      if (session.device.platform === 'ios') {
-        await stopIosRunnerSession(session.device.id);
-      }
       sessionStore.writeSessionLog(session);
     }
-    server.close(() => {
-      removeInfo();
-      process.exit(0);
-    });
+    await stopAllIosRunnerSessions();
+    removeInfo();
+    releaseDaemonLock();
+    process.exit(0);
   };
 
   process.on('SIGINT', () => {

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

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import { promises as fs } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { openAndroidApp, parseAndroidLaunchComponent, swipeAndroid } from '../index.ts';
+import { inferAndroidAppName, listAndroidApps, openAndroidApp, parseAndroidLaunchComponent, swipeAndroid } from '../index.ts';
 import type { DeviceInfo } from '../../../utils/device.ts';
 import { AppError } from '../../../utils/errors.ts';
 import { findBounds, parseUiHierarchy } from '../ui-hierarchy.ts';
@@ -95,6 +95,123 @@ test('parseAndroidLaunchComponent returns null when no component is present', ()
   assert.equal(parseAndroidLaunchComponent(stdout), null);
 });
 
+test('inferAndroidAppName derives readable names from package ids', () => {
+  assert.equal(inferAndroidAppName('com.android.settings'), 'Settings');
+  assert.equal(inferAndroidAppName('com.google.android.apps.maps'), 'Maps');
+  assert.equal(inferAndroidAppName('org.mozilla.firefox'), 'Firefox');
+  assert.equal(inferAndroidAppName('com.facebook.katana'), 'Katana');
+  assert.equal(inferAndroidAppName('single'), 'Single');
+  assert.equal(inferAndroidAppName('com.android.app.services'), 'Services');
+});
+
+test('listAndroidApps returns launchable apps with inferred names', async () => {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'agent-device-android-apps-all-'));
+  const adbPath = path.join(tmpDir, 'adb');
+  await fs.writeFile(
+    adbPath,
+    [
+      '#!/bin/sh',
+      'if [ "$1" = "-s" ]; then',
+      '  shift',
+      '  shift',
+      'fi',
+      'if [ "$1" = "shell" ] && [ "$2" = "cmd" ] && [ "$3" = "package" ] && [ "$4" = "query-activities" ]; then',
+      '  echo "com.google.android.apps.maps/.MainActivity"',
+      '  echo "org.mozilla.firefox/.App"',
+      '  echo "com.android.settings/.Settings"',
+      '  exit 0',
+      'fi',
+      'if [ "$1" = "shell" ] && [ "$2" = "pm" ] && [ "$3" = "list" ] && [ "$4" = "packages" ] && [ "$5" = "-3" ]; then',
+      '  echo "package:com.google.android.apps.maps"',
+      '  echo "package:com.example.serviceonly"',
+      '  echo "package:org.mozilla.firefox"',
+      '  exit 0',
+      'fi',
+      'echo "unexpected args: $@" >&2',
+      'exit 1',
+      '',
+    ].join('\n'),
+    'utf8',
+  );
+  await fs.chmod(adbPath, 0o755);
+
+  const previousPath = process.env.PATH;
+  process.env.PATH = `${tmpDir}${path.delimiter}${previousPath ?? ''}`;
+
+  const device: DeviceInfo = {
+    platform: 'android',
+    id: 'emulator-5554',
+    name: 'Pixel',
+    kind: 'emulator',
+    booted: true,
+  };
+
+  try {
+    const apps = await listAndroidApps(device, 'all');
+    assert.deepEqual(apps, [
+      { package: 'com.android.settings', name: 'Settings' },
+      { package: 'com.google.android.apps.maps', name: 'Maps' },
+      { package: 'org.mozilla.firefox', name: 'Firefox' },
+    ]);
+  } finally {
+    process.env.PATH = previousPath;
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test('listAndroidApps user-installed excludes non-launchable packages', async () => {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'agent-device-android-apps-user-'));
+  const adbPath = path.join(tmpDir, 'adb');
+  await fs.writeFile(
+    adbPath,
+    [
+      '#!/bin/sh',
+      'if [ "$1" = "-s" ]; then',
+      '  shift',
+      '  shift',
+      'fi',
+      'if [ "$1" = "shell" ] && [ "$2" = "cmd" ] && [ "$3" = "package" ] && [ "$4" = "query-activities" ]; then',
+      '  echo "com.google.android.apps.maps/.MainActivity"',
+      '  echo "org.mozilla.firefox/.App"',
+      '  exit 0',
+      'fi',
+      'if [ "$1" = "shell" ] && [ "$2" = "pm" ] && [ "$3" = "list" ] && [ "$4" = "packages" ] && [ "$5" = "-3" ]; then',
+      '  echo "package:com.google.android.apps.maps"',
+      '  echo "package:com.example.serviceonly"',
+      '  echo "package:org.mozilla.firefox"',
+      '  exit 0',
+      'fi',
+      'echo "unexpected args: $@" >&2',
+      'exit 1',
+      '',
+    ].join('\n'),
+    'utf8',
+  );
+  await fs.chmod(adbPath, 0o755);
+
+  const previousPath = process.env.PATH;
+  process.env.PATH = `${tmpDir}${path.delimiter}${previousPath ?? ''}`;
+
+  const device: DeviceInfo = {
+    platform: 'android',
+    id: 'emulator-5554',
+    name: 'Pixel',
+    kind: 'emulator',
+    booted: true,
+  };
+
+  try {
+    const apps = await listAndroidApps(device, 'user-installed');
+    assert.deepEqual(apps, [
+      { package: 'com.google.android.apps.maps', name: 'Maps' },
+      { package: 'org.mozilla.firefox', name: 'Firefox' },
+    ]);
+  } finally {
+    process.env.PATH = previousPath;
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  }
+});
+
 test('openAndroidApp rejects activity override for deep link URLs', async () => {
   const device: DeviceInfo = {
     platform: 'android',

package/src/platforms/android/index.ts

@@ -48,60 +48,87 @@ export async function resolveAndroidApp(
 
 export async function listAndroidApps(
   device: DeviceInfo,
-  filter: 'launchable' | 'user-installed' | 'all' = 'launchable',
-): Promise<string[]> {
-  if (filter === 'launchable') {
-    const result = await runCmd(
-      'adb',
-      adbArgs(device, [
-        'shell',
-        'cmd',
-        'package',
-        'query-activities',
-        '--brief',
-        '-a',
-        'android.intent.action.MAIN',
-        '-c',
-        'android.intent.category.LAUNCHER',
-      ]),
-      { allowFailure: true },
-    );
-    if (result.exitCode === 0 && result.stdout.trim().length > 0) {
-      const packages = new Set<string>();
-      for (const line of result.stdout.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        const firstToken = trimmed.split(/\s+/)[0];
-        const pkg = firstToken.includes('/') ? firstToken.split('/')[0] : firstToken;
-        if (pkg) packages.add(pkg);
-      }
-      if (packages.size > 0) {
-        return Array.from(packages);
-      }
-    }
-    // fallback: list all if query-activities not available
+  filter: 'user-installed' | 'all' = 'all',
+): Promise<Array<{ package: string; name: string }>> {
+  const launchable = await listAndroidLaunchablePackages(device);
+  const packageIds =
+    filter === 'user-installed'
+      ? (await listAndroidUserInstalledPackages(device)).filter((pkg) => launchable.has(pkg))
+      : Array.from(launchable);
+  return packageIds
+    .sort((a, b) => a.localeCompare(b))
+    .map((pkg) => ({ package: pkg, name: inferAndroidAppName(pkg) }));
+}
+
+async function listAndroidLaunchablePackages(device: DeviceInfo): Promise<Set<string>> {
+  const result = await runCmd(
+    'adb',
+    adbArgs(device, [
+      'shell',
+      'cmd',
+      'package',
+      'query-activities',
+      '--brief',
+      '-a',
+      'android.intent.action.MAIN',
+      '-c',
+      'android.intent.category.LAUNCHER',
+    ]),
+    { allowFailure: true },
+  );
+  if (result.exitCode !== 0 || result.stdout.trim().length === 0) {
+    return new Set<string>();
+  }
+  const packages = new Set<string>();
+  for (const line of result.stdout.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const firstToken = trimmed.split(/\s+/)[0];
+    const pkg = firstToken.includes('/') ? firstToken.split('/')[0] : firstToken;
+    if (pkg) packages.add(pkg);
   }
+  return packages;
+}
 
-  const args =
-    filter === 'user-installed'
-      ? ['shell', 'pm', 'list', 'packages', '-3']
-      : ['shell', 'pm', 'list', 'packages'];
-  const result = await runCmd('adb', adbArgs(device, args));
+async function listAndroidUserInstalledPackages(device: DeviceInfo): Promise<string[]> {
+  const result = await runCmd('adb', adbArgs(device, ['shell', 'pm', 'list', 'packages', '-3']));
   return result.stdout
     .split('\n')
     .map((line: string) => line.replace('package:', '').trim())
     .filter(Boolean);
 }
 
-export async function listAndroidAppsMetadata(
-  device: DeviceInfo,
-  filter: 'launchable' | 'user-installed' | 'all' = 'launchable',
-): Promise<Array<{ package: string; launchable: boolean }>> {
-  const apps = await listAndroidApps(device, filter);
-  const launchable = filter === 'launchable'
-    ? new Set(apps)
-    : new Set(await listAndroidApps(device, 'launchable'));
-  return apps.map((pkg) => ({ package: pkg, launchable: launchable.has(pkg) }));
+export function inferAndroidAppName(packageName: string): string {
+  const ignoredTokens = new Set([
+    'com',
+    'android',
+    'google',
+    'app',
+    'apps',
+    'service',
+    'services',
+    'mobile',
+    'client',
+  ]);
+  const tokens = packageName
+    .split('.')
+    .flatMap((segment) => segment.split(/[_-]+/))
+    .map((token) => token.trim().toLowerCase())
+    .filter((token) => token.length > 0);
+  // Fallback to last token if every token is ignored (e.g. "com.android.app.services" → "Services").
+  let chosen = tokens[tokens.length - 1] ?? packageName;
+  for (let index = tokens.length - 1; index >= 0; index -= 1) {
+    const token = tokens[index];
+    if (!ignoredTokens.has(token)) {
+      chosen = token;
+      break;
+    }
+  }
+  return chosen
+    .split(/[^a-z0-9]+/i)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ');
 }
 
 export async function getAndroidAppState(
@@ -180,7 +207,7 @@ export async function openAndroidApp(
     if (activity) {
       throw new AppError('INVALID_ARGS', 'Activity override requires a package name, not an intent');
     }
-    await runCmd('adb', adbArgs(device, ['shell', 'am', 'start', '-a', resolved.value]));
+    await runCmd('adb', adbArgs(device, ['shell', 'am', 'start', '-W', '-a', resolved.value]));
     return;
   }
   if (activity) {
@@ -193,6 +220,7 @@ export async function openAndroidApp(
         'shell',
         'am',
         'start',
+        '-W',
         '-a',
         'android.intent.action.MAIN',
         '-c',
@@ -212,6 +240,7 @@ export async function openAndroidApp(
         'shell',
         'am',
         'start',
+        '-W',
         '-a',
         'android.intent.action.MAIN',
         '-c',
@@ -232,6 +261,7 @@ export async function openAndroidApp(
         'shell',
         'am',
         'start',
+        '-W',
         '-a',
         'android.intent.action.MAIN',
         '-c',