fix: recover Android app-owned ANRs

Author: thymikee

src/command-catalog.ts

@@ -110,6 +110,26 @@ export const DAEMON_COMMAND_GROUPS = {
     PUBLIC_COMMANDS.type,
     PUBLIC_COMMANDS.wait,
   ),
+  androidBlockingDialogGuardedAction: commandSet(
+    PUBLIC_COMMANDS.back,
+    PUBLIC_COMMANDS.click,
+    PUBLIC_COMMANDS.fill,
+    PUBLIC_COMMANDS.focus,
+    PUBLIC_COMMANDS.gesture,
+    PUBLIC_COMMANDS.home,
+    PUBLIC_COMMANDS.keyboard,
+    PUBLIC_COMMANDS.longPress,
+    'fling',
+    'pan',
+    'pinch',
+    PUBLIC_COMMANDS.press,
+    PUBLIC_COMMANDS.rotate,
+    'rotate-gesture',
+    PUBLIC_COMMANDS.scroll,
+    PUBLIC_COMMANDS.swipe,
+    'transform-gesture',
+    PUBLIC_COMMANDS.type,
+  ),
   selectorValidationExempt: commandSet(
     INTERNAL_COMMANDS.sessionList,
     PUBLIC_COMMANDS.devices,

src/daemon/__tests__/request-router-android-modal.test.ts

@@ -56,6 +56,7 @@ vi.mock('../../platforms/android/app-lifecycle.ts', async (importOriginal) => {
     ...actual,
     openAndroidApp: vi.fn(async () => {}),
     getAndroidAppState: vi.fn(async () => ({ package: 'com.android.settings' })),
+    getAndroidBlockingDialogFocus: vi.fn(async () => null),
   };
 });
 

src/daemon/__tests__/request-router-screenshot.test.ts

@@ -8,6 +8,14 @@ vi.mock('../../core/dispatch.ts', async (importOriginal) => {
   return { ...actual, dispatchCommand: vi.fn(async () => ({})) };
 });
 
+vi.mock('../../platforms/android/app-lifecycle.ts', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../platforms/android/app-lifecycle.ts')>();
+  return {
+    ...actual,
+    getAndroidBlockingDialogFocus: vi.fn(async () => null),
+  };
+});
+
 import { dispatchCommand } from '../../core/dispatch.ts';
 import { createRequestHandler } from '../request-router.ts';
 import { dispatchScreenshotViaRuntime } from '../screenshot-runtime.ts';

src/daemon/android-system-dialog.ts

@@ -1,18 +1,29 @@
-import { getAndroidAppState, openAndroidApp } from '../platforms/android/app-lifecycle.ts';
+import {
+  getAndroidAppState,
+  getAndroidBlockingDialogFocus,
+  openAndroidApp,
+  type AndroidBlockingDialogFocus,
+} from '../platforms/android/app-lifecycle.ts';
 import { snapshotAndroid } from '../platforms/android/snapshot.ts';
 import { runAndroidAdb } from '../platforms/android/adb.ts';
 import { emitDiagnostic } from '../utils/diagnostics.ts';
+import { AppError } from '../utils/errors.ts';
 import { centerOfRect, attachRefs, type SnapshotNode } from '../utils/snapshot.ts';
 import { sleep } from '../utils/timeouts.ts';
 import { pruneGroupNodes } from './snapshot-processing.ts';
 import type { SessionState } from './types.ts';
 
-const ANDROID_BLOCKING_MODAL_PATTERN = /\bis(?:n't| not)\s+responding\b/i;
+const ANDROID_BLOCKING_MODAL_PATTERN = /\bis(?:n(?:'|'|')?t| not)\s+responding\b/i;
 const ANDROID_CLOSE_APP_PATTERN = /^close app$/i;
 const ANDROID_MODAL_POLL_MS = 500;
 const ANDROID_MODAL_POLL_ATTEMPTS = 12;
+const ANDROID_BLOCKING_DIALOG_HINT =
+  'Wait for Android to recover, close the dialog, restart the app, or reboot the emulator, then retry.';
 
 export type AndroidBlockingDialogRecoveryResult = 'absent' | 'recovered' | 'failed';
+export type AndroidBlockingDialogReadinessResult =
+  | { status: 'clear' }
+  | { status: 'recovered'; warning: string };
 
 export async function recoverAndroidBlockingSystemDialog(params: {
   session: SessionState;
@@ -107,6 +118,146 @@ export async function recoverAndroidBlockingSystemDialog(params: {
   }
 }
 
+export async function ensureAndroidBlockingSystemDialogReady(params: {
+  session: SessionState;
+  command: string;
+  phase: 'before-command' | 'after-command';
+}): Promise<AndroidBlockingDialogReadinessResult> {
+  const { session, command } = params;
+  if (session.device.platform !== 'android') return { status: 'clear' };
+
+  const focus = await getAndroidBlockingDialogFocus(session.device);
+  if (!focus) return { status: 'clear' };
+
+  if (isSessionAppAnr(session, focus)) {
+    const recovered = await recoverAppOwnedAndroidBlockingSystemDialogSafely(session);
+    if (recovered) {
+      const warning = `Recovered Android app ANR before ${command}: closed and relaunched ${session.appBundleId}.`;
+      if (params.phase === 'before-command') return { status: 'recovered', warning };
+
+      throw androidBlockingDialogError({
+        session,
+        command,
+        focus,
+        message: `Android app ANR appeared after ${command}; ${session.appBundleId} was closed and relaunched. Retry the command against the fresh app session.`,
+        hint: 'Retry the command. If the ANR returns, inspect app logs or restart the emulator.',
+      });
+    }
+
+    throw androidBlockingDialogError({
+      session,
+      command,
+      focus,
+      message: `Android app ANR blocked ${command}: ${formatAndroidBlockingDialogFocus(focus)}. Automatic recovery failed.`,
+      hint: ANDROID_BLOCKING_DIALOG_HINT,
+    });
+  }
+
+  throw androidBlockingDialogError({
+    session,
+    command,
+    focus,
+    message: `Android system dialog is blocking ${command}: ${formatAndroidBlockingDialogFocus(focus)}.`,
+    hint: ANDROID_BLOCKING_DIALOG_HINT,
+  });
+}
+
+async function recoverAppOwnedAndroidBlockingSystemDialogSafely(
+  session: SessionState,
+): Promise<boolean> {
+  try {
+    return await recoverAppOwnedAndroidBlockingSystemDialog(session);
+  } catch (error) {
+    emitDiagnostic({
+      level: 'warn',
+      phase: 'android_app_anr_recovery_failed',
+      data: {
+        session: session.name,
+        deviceId: session.device.id,
+        appBundleId: session.appBundleId,
+        error: error instanceof Error ? error.message : String(error),
+      },
+    });
+    return false;
+  }
+}
+
+function isSessionAppAnr(session: SessionState, focus: AndroidBlockingDialogFocus): boolean {
+  return Boolean(session.appBundleId && focus.package === session.appBundleId);
+}
+
+async function recoverAppOwnedAndroidBlockingSystemDialog(session: SessionState): Promise<boolean> {
+  if (!session.appBundleId) return false;
+
+  const nodes = await readAndroidSnapshotNodes(session);
+  const closeAppButton = findCloseAppButton(nodes, { requireDialogSignal: false });
+  if (!closeAppButton?.rect) return false;
+
+  const { x, y } = centerOfRect(closeAppButton.rect);
+  const tapResult = await runAndroidAdb(
+    session.device,
+    ['shell', 'input', 'tap', String(Math.round(x)), String(Math.round(y))],
+    { allowFailure: true },
+  );
+  if (tapResult.exitCode !== 0) return false;
+
+  await openAndroidApp(session.device, session.appBundleId);
+  const focused = await waitForRecoveredAndroidAppFocus(session, session.appBundleId);
+  if (focused) {
+    emitDiagnostic({
+      level: 'warn',
+      phase: 'android_app_anr_recovered',
+      data: {
+        session: session.name,
+        deviceId: session.device.id,
+        appBundleId: session.appBundleId,
+        x,
+        y,
+      },
+    });
+  }
+  return focused;
+}
+
+async function waitForRecoveredAndroidAppFocus(
+  session: SessionState,
+  appBundleId: string,
+): Promise<boolean> {
+  for (let attempt = 0; attempt < ANDROID_MODAL_POLL_ATTEMPTS; attempt += 1) {
+    const blockingFocus = await getAndroidBlockingDialogFocus(session.device);
+    const state = await getAndroidAppState(session.device);
+    if (!blockingFocus && state.package === appBundleId) {
+      return true;
+    }
+    await sleep(ANDROID_MODAL_POLL_MS);
+  }
+  const blockingFocus = await getAndroidBlockingDialogFocus(session.device);
+  const state = await getAndroidAppState(session.device);
+  return !blockingFocus && state.package === appBundleId;
+}
+
+function androidBlockingDialogError(params: {
+  session: SessionState;
+  command: string;
+  focus: AndroidBlockingDialogFocus;
+  message: string;
+  hint: string;
+}): AppError {
+  const { session, command, focus, message, hint } = params;
+  return new AppError('COMMAND_FAILED', message, {
+    command,
+    expectedPackage: session.appBundleId,
+    focusedPackage: focus.package,
+    focusedWindow: focus.focusedWindow,
+    rawFocus: focus.raw,
+    hint,
+  });
+}
+
+function formatAndroidBlockingDialogFocus(focus: AndroidBlockingDialogFocus): string {
+  return focus.package ? `${focus.focusedWindow} (package ${focus.package})` : focus.focusedWindow;
+}
+
 async function readAndroidSnapshotNodes(session: SessionState): Promise<SnapshotNode[]> {
   const rawSnapshot = await snapshotAndroid(session.device, {
     interactiveOnly: false,
@@ -115,13 +266,17 @@ async function readAndroidSnapshotNodes(session: SessionState): Promise<Snapshot
   return attachRefs(pruneGroupNodes(rawSnapshot.nodes));
 }
 
-function findCloseAppButton(nodes: SnapshotNode[]): SnapshotNode | undefined {
-  if (!containsBlockingDialog(nodes)) {
+function findCloseAppButton(
+  nodes: SnapshotNode[],
+  options: { requireDialogSignal?: boolean } = {},
+): SnapshotNode | undefined {
+  if (options.requireDialogSignal !== false && !containsBlockingDialog(nodes)) {
     return undefined;
   }
   return nodes.find((node) => {
-    const text = readNodeText(node);
-    return text.length > 0 && ANDROID_CLOSE_APP_PATTERN.test(text) && node.rect;
+    return (
+      readNodeTextParts(node).some((text) => ANDROID_CLOSE_APP_PATTERN.test(text)) && node.rect
+    );
   });
 }
 
@@ -157,14 +312,21 @@ function readNodeText(node: {
   value?: string | number | boolean | null;
   identifier?: string;
 }): string {
+  return readNodeTextParts(node).join(' ').trim();
+}
+
+function readNodeTextParts(node: {
+  label?: string;
+  value?: string | number | boolean | null;
+  identifier?: string;
+}): string[] {
   const parts = [node.label, node.identifier];
   if (typeof node.value === 'string' && node.value.trim().length > 0) {
     parts.push(node.value);
   }
   return parts
     .filter((part): part is string => typeof part === 'string' && part.trim().length > 0)
-    .join(' ')
-    .trim();
+    .map((part) => part.trim());
 }
 
 function containsBlockingDialog(nodes: SnapshotNode[]): boolean {

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

@@ -40,6 +40,7 @@ vi.mock('../../../platforms/android/app-lifecycle.ts', async (importOriginal) =>
   return {
     ...actual,
     getAndroidAppState: vi.fn(async () => ({})),
+    getAndroidBlockingDialogFocus: vi.fn(async () => null),
   };
 });
 
@@ -64,11 +65,15 @@ vi.mock('../../../platforms/ios/runner-client.ts', async (importOriginal) => {
 });
 
 import { dispatchCommand } from '../../../core/dispatch.ts';
-import { getAndroidAppState } from '../../../platforms/android/app-lifecycle.ts';
+import {
+  getAndroidAppState,
+  getAndroidBlockingDialogFocus,
+} from '../../../platforms/android/app-lifecycle.ts';
 import { getAndroidScreenSize } from '../../../platforms/android/input-actions.ts';
 import { captureSnapshotForSession } from '../interaction-snapshot.ts';
 const mockDispatch = vi.mocked(dispatchCommand);
 const mockGetAndroidAppState = vi.mocked(getAndroidAppState);
+const mockGetAndroidBlockingDialogFocus = vi.mocked(getAndroidBlockingDialogFocus);
 const mockGetAndroidScreenSize = vi.mocked(getAndroidScreenSize);
 const mockCaptureSnapshotForSession = vi.mocked(captureSnapshotForSession);
 
@@ -132,6 +137,8 @@ beforeEach(() => {
   mockDispatch.mockResolvedValue({});
   mockGetAndroidAppState.mockReset();
   mockGetAndroidAppState.mockResolvedValue({});
+  mockGetAndroidBlockingDialogFocus.mockReset();
+  mockGetAndroidBlockingDialogFocus.mockResolvedValue(null);
   mockGetAndroidScreenSize.mockReset();
   mockGetAndroidScreenSize.mockResolvedValue({ width: 1344, height: 2992 });
   mockCaptureSnapshotForSession.mockReset();

src/daemon/handlers/interaction-touch.ts

@@ -46,6 +46,7 @@ import {
   readSimpleIosSelectorTarget,
   type DirectIosSelectorTarget,
 } from '../direct-ios-selector.ts';
+import { ensureAndroidBlockingSystemDialogReady } from '../android-system-dialog.ts';
 
 export async function handleTouchInteractionCommands(
   params: InteractionHandlerParams & {
@@ -429,10 +430,24 @@ async function dispatchRuntimeInteraction<
   const runtime = createInteractionRuntime(params);
   const actionStartedAt = Date.now();
   try {
+    const readiness = await ensureAndroidBlockingSystemDialogReady({
+      session,
+      command: params.req.command,
+      phase: 'before-command',
+    });
     const runtimeResult = await options.run(runtime);
     await options.afterRun?.(runtimeResult);
+    await ensureAndroidBlockingSystemDialogReady({
+      session,
+      command: params.req.command,
+      phase: 'after-command',
+    });
     const actionFinishedAt = Date.now();
     const { result, responseData } = await options.buildPayloads(runtimeResult);
+    if (readiness.status === 'recovered') {
+      result.warning = readiness.warning;
+      responseData.warning = readiness.warning;
+    }
     return finalizeTouchInteraction({
       session,
       sessionStore: params.sessionStore,

src/daemon/handlers/interaction.ts

@@ -11,7 +11,10 @@ import { isCommandSupportedOnDevice } from '../../core/capabilities.ts';
 import { typeCommandDefinition } from '../../commands/interactions/definition.ts';
 import { normalizeError } from '../../utils/errors.ts';
 import { successText } from '../../utils/success-text.ts';
-import { recoverAndroidBlockingSystemDialog } from '../android-system-dialog.ts';
+import {
+  ensureAndroidBlockingSystemDialogReady,
+  recoverAndroidBlockingSystemDialog,
+} from '../android-system-dialog.ts';
 
 export async function handleInteractionCommands(
   params: InteractionHandlerParams,
@@ -62,18 +65,29 @@ async function dispatchTypeViaRuntime(
   const runtime = createInteractionRuntime(params);
   const actionStartedAt = Date.now();
   try {
+    const readiness = await ensureAndroidBlockingSystemDialogReady({
+      session,
+      command: req.command,
+      phase: 'before-command',
+    });
     const result = await runtime.interactions.typeText(text, {
       session: sessionName,
       requestId: req.meta?.requestId,
       delayMs: req.flags?.delayMs,
     });
+    await ensureAndroidBlockingSystemDialogReady({
+      session,
+      command: req.command,
+      phase: 'after-command',
+    });
     const actionFinishedAt = Date.now();
-    const responseData = {
+    const responseData: Record<string, unknown> = {
       ...(result.backendResult ?? {}),
       text: result.text,
       delayMs: result.delayMs,
       ...successText(result.message ?? `Typed ${Array.from(result.text).length} chars`),
     };
+    if (readiness.status === 'recovered') responseData.warning = readiness.warning;
     return finalizeTouchInteraction({
       session,
       sessionStore,