fix: bound compact iOS snapshots on broken AX trees

Author: thymikee

ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Alert.swift

@@ -8,20 +8,18 @@ extension RunnerTests {
   }
 
   func resolveAlert(app activeApp: XCUIApplication) -> RunnerAlert? {
+#if !os(macOS)
+    if let systemModal = firstBlockingSystemModal(in: springboard) {
+      return runnerAlert(root: systemModal, ownerApp: springboard)
+    }
+#endif
     if let alert = firstExistingElement(in: activeApp.alerts.allElementsBoundByIndex) {
       return runnerAlert(root: alert, ownerApp: activeApp)
     }
     if let popup = firstDismissPopupWindow(in: activeApp) {
       return runnerAlert(root: popup, ownerApp: activeApp)
     }
-#if os(macOS)
-    return nil
-#else
-    if let systemModal = firstBlockingSystemModal(in: springboard) {
-      return runnerAlert(root: systemModal, ownerApp: springboard)
-    }
     return nil
-#endif
   }
 
   func handleAlert(_ alert: RunnerAlert, action: String) -> Response {
@@ -33,6 +31,27 @@ extension RunnerTests {
       if let response = unsupportedResponse(for: outcome) {
         return response
       }
+      sleepFor(0.2)
+      if alertStillVisible(alert, actionButtonLabel: button.label) {
+        let frame = button.frame
+        if !frame.isNull && !frame.isEmpty {
+          let coordinateOutcome = tapAt(app: alert.ownerApp, x: frame.midX, y: frame.midY)
+          if let response = unsupportedResponse(for: coordinateOutcome) {
+            return response
+          }
+          sleepFor(0.2)
+        }
+      }
+      if alertStillVisible(alert, actionButtonLabel: button.label) {
+        return Response(
+          ok: false,
+          error: ErrorPayload(
+            code: "INTERACTION_FAILED",
+            message: "alert \(action) did not dismiss the visible alert",
+            hint: "The alert button was found but the system still reports the alert after tapping it."
+          )
+        )
+      }
       return Response(ok: true, data: DataPayload(message: action == "accept" ? "accepted" : "dismissed"))
     }
 
@@ -53,6 +72,21 @@ extension RunnerTests {
     return RunnerAlert(root: root, ownerApp: ownerApp, buttons: buttons)
   }
 
+  private func alertStillVisible(_ alert: RunnerAlert, actionButtonLabel: String) -> Bool {
+    guard let current = resolveAlert(app: alert.ownerApp) else {
+      return false
+    }
+    let previousTitle = preferredAlertTitle(alert.root, buttons: alert.buttons)
+    let currentTitle = preferredAlertTitle(current.root, buttons: current.buttons)
+    if previousTitle == currentTitle {
+      return true
+    }
+    let normalizedActionLabel = actionButtonLabel.trimmingCharacters(in: .whitespacesAndNewlines)
+    return current.buttons.contains { button in
+      button.label.trimmingCharacters(in: .whitespacesAndNewlines) == normalizedActionLabel
+    }
+  }
+
   private func firstExistingElement(in elements: [XCUIElement]) -> XCUIElement? {
     elements.first { isVisibleElement($0) }
   }

ios-runner/AgentDeviceRunner/AgentDeviceRunnerUITests/RunnerTests+Snapshot.swift

@@ -16,6 +16,7 @@ extension RunnerTests {
     .scrollView,
     .table
   ]
+  private static let flatInteractiveFallbackBudget: TimeInterval = 1.0
 
   private struct SnapshotTraversalContext {
     let queryRoot: XCUIElement
@@ -85,6 +86,9 @@ extension RunnerTests {
   }
 
   func snapshotFast(app: XCUIApplication, options: SnapshotOptions) throws -> DataPayload {
+    if options.interactiveOnly && options.compact {
+      return snapshotFlatInteractive(app: app, options: options)
+    }
     if let blocking = blockingSystemAlertSnapshot() {
       return blocking
     }
@@ -257,58 +261,50 @@ extension RunnerTests {
   }
 
   private func snapshotFlatInteractive(app: XCUIApplication, options: SnapshotOptions) -> DataPayload {
-    let viewport = safeSnapshotViewport(app: app)
     var nodes: [SnapshotNode] = [
-      SnapshotNode(
-        index: 0,
-        type: "Application",
-        label: nonEmptyElementText { app.label },
-        identifier: nonEmptyElementText { app.identifier },
-        value: nil,
-        rect: snapshotRect(from: safely("SNAPSHOT_FLAT_APP_FRAME", CGRect.zero) { app.frame }),
-        enabled: true,
-        focused: nil,
-        selected: nil,
-        hittable: false,
-        depth: 0,
-        parentIndex: nil,
-        hiddenContentAbove: nil,
-        hiddenContentBelow: nil
-      )
+      compactInteractiveRootNode(rect: .zero)
     ]
     if options.depth == 0 {
       return DataPayload(nodes: nodes, truncated: false)
     }
 
+    let deadline = options.interactiveOnly
+      ? Date().addingTimeInterval(Self.flatInteractiveFallbackBudget)
+      : Date.distantFuture
     var seen = Set<String>()
-    let candidates = flatFallbackElements(app: app)
-      .compactMap { element in
-        flatSnapshotNode(
-          element: element,
-          index: 0,
-          parentIndex: 0,
-          viewport: viewport,
-          options: options
-        )
+    var candidates: [SnapshotNode] = []
+    for element in flatFallbackElements(app: app, options: options) {
+      if Date() >= deadline {
+        NSLog("AGENT_DEVICE_RUNNER_SNAPSHOT_FLAT_FALLBACK_DEADLINE")
+        break
       }
-      .filter { node in
-        let key = "\(node.type)-\(node.label ?? "")-\(node.identifier ?? "")-\(node.value ?? "")-\(node.rect.x)-\(node.rect.y)-\(node.rect.width)-\(node.rect.height)"
-        if seen.contains(key) { return false }
-        seen.insert(key)
-        return true
+      guard let node = flatSnapshotNode(
+        element: element,
+        index: 0,
+        parentIndex: 0,
+        viewport: .infinite,
+        options: options
+      ) else {
+        continue
       }
-      .sorted { left, right in
-        if left.rect.y != right.rect.y {
-          return left.rect.y < right.rect.y
-        }
-        if left.rect.x != right.rect.x {
-          return left.rect.x < right.rect.x
-        }
-        return left.type < right.type
+      let key = "\(node.type)-\(node.label ?? "")-\(node.identifier ?? "")-\(node.value ?? "")-\(node.rect.x)-\(node.rect.y)-\(node.rect.width)-\(node.rect.height)"
+      if seen.contains(key) { continue }
+      seen.insert(key)
+      candidates.append(node)
+    }
+    candidates.sort { left, right in
+      if left.rect.y != right.rect.y {
+        return left.rect.y < right.rect.y
+      }
+      if left.rect.x != right.rect.x {
+        return left.rect.x < right.rect.x
       }
+      return left.type < right.type
+    }
 
     let remaining = max(0, fastSnapshotLimit - nodes.count)
     let truncated = candidates.count > remaining
+    nodes[0] = compactInteractiveRootNode(rect: compactInteractiveRootFrame(for: candidates))
     for candidate in candidates.prefix(remaining) {
       nodes.append(
         SnapshotNode(
@@ -332,6 +328,34 @@ extension RunnerTests {
     return DataPayload(nodes: nodes, truncated: truncated)
   }
 
+  private func compactInteractiveRootNode(rect: CGRect) -> SnapshotNode {
+    SnapshotNode(
+      index: 0,
+      type: "Application",
+      label: nil,
+      identifier: nil,
+      value: nil,
+      rect: snapshotRect(from: rect),
+      enabled: true,
+      focused: nil,
+      selected: nil,
+      hittable: false,
+      depth: 0,
+      parentIndex: nil,
+      hiddenContentAbove: nil,
+      hiddenContentBelow: nil
+    )
+  }
+
+  private func compactInteractiveRootFrame(for candidates: [SnapshotNode]) -> CGRect {
+    guard !candidates.isEmpty else {
+      return .zero
+    }
+    let maxX = candidates.map { CGFloat($0.rect.x + $0.rect.width) }.max() ?? 0
+    let maxY = candidates.map { CGFloat($0.rect.y + $0.rect.height) }.max() ?? 0
+    return CGRect(x: 0, y: 0, width: max(1, maxX), height: max(1, maxY))
+  }
+
   func snapshotRect(from frame: CGRect) -> SnapshotRect {
     return SnapshotRect(
       x: Double(frame.origin.x),
@@ -798,8 +822,26 @@ extension RunnerTests {
     safely("SNAPSHOT_QUERY", [], fetch)
   }
 
-  private func flatFallbackElements(app: XCUIApplication) -> [XCUIElement] {
-    let queries: [XCUIElementQuery] = [
+  private func flatFallbackElements(app: XCUIApplication, options: SnapshotOptions) -> [XCUIElement] {
+    let queries: [XCUIElementQuery] = options.interactiveOnly ? [
+      app.buttons,
+      app.links,
+      app.textFields,
+      app.secureTextFields,
+      app.searchFields,
+      app.textViews,
+      app.switches,
+      app.sliders,
+      app.segmentedControls,
+      app.cells,
+      app.collectionViews,
+      app.tables,
+      app.scrollViews,
+      app.pickers,
+      app.steppers,
+      app.tabBars,
+      app.menuItems
+    ] : [
       app.buttons,
       app.cells,
       app.collectionViews,
@@ -816,11 +858,26 @@ extension RunnerTests {
       app.textFields,
       app.textViews
     ]
-    return queries.flatMap { query in
-      safeSnapshotElementsQuery {
-        query.allElementsBoundByIndex
+    guard options.interactiveOnly else {
+      return queries.flatMap { query in
+        safeSnapshotElementsQuery {
+          query.allElementsBoundByIndex
+        }
+      }
+    }
+
+    let deadline = Date().addingTimeInterval(Self.flatInteractiveFallbackBudget)
+    var elements: [XCUIElement] = []
+    for query in queries {
+      if Date() >= deadline {
+        NSLog("AGENT_DEVICE_RUNNER_SNAPSHOT_FLAT_FALLBACK_DEADLINE")
+        break
       }
+      elements.append(contentsOf: safeSnapshotElementsQuery {
+        query.allElementsBoundByIndex
+      })
     }
+    return elements
   }
 
   private func flatSnapshotNode(

src/platforms/ios/__tests__/runner-session.test.ts

@@ -17,6 +17,8 @@ const {
   mockIsProcessAlive,
   mockIsProcessGroupAlive,
   mockPrepareXctestrunWithEnv,
+  mockResolveExpectedRunnerCacheMetadata,
+  mockResolveRunnerDerivedPath,
   mockRunAppleToolCommand,
   mockRunCmdBackground,
   mockRunXcrun,
@@ -31,6 +33,8 @@ const {
   mockIsProcessAlive: vi.fn(),
   mockIsProcessGroupAlive: vi.fn(),
   mockPrepareXctestrunWithEnv: vi.fn(),
+  mockResolveExpectedRunnerCacheMetadata: vi.fn(),
+  mockResolveRunnerDerivedPath: vi.fn(),
   mockRunAppleToolCommand: vi.fn(),
   mockRunCmdBackground: vi.fn(),
   mockRunXcrun: vi.fn(),
@@ -88,6 +92,8 @@ vi.mock('../runner-xctestrun.ts', async () => {
     acquireXcodebuildSimulatorSetRedirect: mockAcquireXcodebuildSimulatorSetRedirect,
     ensureXctestrunArtifact: mockEnsureXctestrunArtifact,
     prepareXctestrunWithEnv: mockPrepareXctestrunWithEnv,
+    resolveExpectedRunnerCacheMetadata: mockResolveExpectedRunnerCacheMetadata,
+    resolveRunnerDerivedPath: mockResolveRunnerDerivedPath,
   };
 });
 
@@ -116,6 +122,8 @@ beforeEach(() => {
     xctestrunPath: '/tmp/session-runner.xctestrun',
     jsonPath: '/tmp/session-runner.json',
   });
+  mockResolveExpectedRunnerCacheMetadata.mockReturnValue({ schemaVersion: 1 });
+  mockResolveRunnerDerivedPath.mockReturnValue('/tmp/derived');
   mockAcquireXcodebuildSimulatorSetRedirect.mockResolvedValue({ release: mockRedirectRelease });
   mockRunCmdBackground.mockReturnValue(makeBackgroundRunner(4242));
   mockRunAppleToolCommand.mockResolvedValue({ exitCode: 0, stdout: '', stderr: '' });
@@ -480,6 +488,36 @@ test('runner session starts xcodebuild through provider seams and reuses an aliv
   await stopRunnerSession(session);
 });
 
+test('runner session restarts alive runner when expected xctestrun artifact changes', async () => {
+  const device = { ...IOS_SIMULATOR, id: 'runner-session-stale-artifact-sim' };
+
+  mockEnsureXctestrunArtifact
+    .mockResolvedValueOnce({
+      xctestrunPath: '/tmp/base-runner.xctestrun',
+      derived: '/tmp/derived',
+      cache: 'miss',
+      artifact: 'rebuilt',
+      buildMs: 12,
+      xctestrunPathSource: 'build',
+    })
+    .mockResolvedValueOnce({
+      xctestrunPath: '/tmp/base-runner-next.xctestrun',
+      derived: '/tmp/derived-next',
+      cache: 'miss',
+      artifact: 'rebuilt',
+      buildMs: 13,
+      xctestrunPathSource: 'build',
+    });
+
+  const session = await ensureRunnerSession(device, {});
+  mockResolveRunnerDerivedPath.mockReturnValue('/tmp/derived-next');
+  const restarted = await ensureRunnerSession(device, {});
+
+  assert.notEqual(restarted, session);
+  assert.equal(restarted.xctestrunArtifact?.derived, '/tmp/derived-next');
+  assert.equal(mockRunCmdBackground.mock.calls.length, 2);
+});
+
 test('runner session keeps boot and stale bundle cleanup available when needed', async () => {
   const device = { ...IOS_SIMULATOR, id: 'runner-session-clean-sim', booted: false };