fix: tighten large text read follow-ups

Author: thymikee

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

@@ -132,7 +132,13 @@ extension RunnerTests {
         if leftArea != rightArea {
           return leftArea < rightArea
         }
-        return left.debugDescription.count < right.debugDescription.count
+        if left.frame.minY != right.frame.minY {
+          return left.frame.minY < right.frame.minY
+        }
+        if left.frame.minX != right.frame.minX {
+          return left.frame.minX < right.frame.minX
+        }
+        return left.elementType.rawValue < right.elementType.rawValue
       }
 
     for element in candidates where prefersExpandedTextRead(element) {

macos-helper/Sources/AgentDeviceMacOSHelper/main.swift

@@ -349,8 +349,11 @@ private func optionValue(arguments: [String], name: String) -> String? {
 }
 
 private func readTextAtPosition(bundleId: String?, surface: String?, x: Double, y: Double) throws -> String {
+  let targetApp: NSRunningApplication?
   if surface == "frontmost-app" || (surface == nil && bundleId != nil) {
-    _ = try resolveTargetApplication(bundleId: bundleId, surface: surface)
+    targetApp = try resolveTargetApplication(bundleId: bundleId, surface: surface)
+  } else {
+    targetApp = nil
   }
 
   let systemWide = AXUIElementCreateSystemWide()
@@ -361,14 +364,32 @@ private func readTextAtPosition(bundleId: String?, surface: String?, x: Double,
     throw HelperError.commandFailed("read did not resolve an accessibility element")
   }
 
+  if let targetApp {
+    var pid: pid_t = 0
+    guard AXUIElementGetPid(hitElement, &pid) == .success else {
+      throw HelperError.commandFailed("read could not resolve element owner")
+    }
+    guard pid == targetApp.processIdentifier else {
+      throw HelperError.commandFailed(
+        "read resolved text from a different app",
+        details: [
+          "expectedPid": String(targetApp.processIdentifier),
+          "actualPid": String(pid)
+        ]
+      )
+    }
+  }
+
   var current: AXUIElement? = hitElement
-  var depth = 0
-  while let element = current, depth < 8 {
+  while let element = current {
     if let text = readableText(for: element) {
       return text
     }
-    current = elementAttribute(element, attribute: kAXParentAttribute as String)
-    depth += 1
+    let parent = elementAttribute(element, attribute: kAXParentAttribute as String)
+    if let parent, CFEqual(parent, element) {
+      break
+    }
+    current = parent
   }
 
   throw HelperError.commandFailed("read did not resolve text")

src/core/dispatch.ts

@@ -605,6 +605,7 @@ export async function dispatchCommand(
             });
             return { action: 'read', text: result.text };
           }
+          // macOS app sessions run through the XCUITest runner; only desktop/menubar surfaces use the helper.
           const result = await runIosRunnerCommand(
             device,
             {

src/daemon/__tests__/snapshot-processing.test.ts

@@ -63,3 +63,20 @@ test('extractNodeReadText prefers underlying value for text surfaces', () => {
   ]);
   assert.equal(extractNodeReadText(nodes[0]), 'package com.example.app\nclass MainActivity {}');
 });
+
+test('extractNodeReadText ignores generic implementation identifiers as fallback text', () => {
+  const nodes = attachRefs([
+    {
+      index: 0,
+      type: 'android.widget.TextView',
+      identifier: 'com.example:id/content_frame',
+    },
+    {
+      index: 1,
+      type: 'AXStaticText',
+      identifier: '_NS:248',
+    },
+  ]);
+  assert.equal(extractNodeReadText(nodes[0]), '');
+  assert.equal(extractNodeReadText(nodes[1]), '');
+});

src/utils/snapshot-lines.ts

@@ -1,10 +1,5 @@
 import type { SnapshotNode } from './snapshot.ts';
-import {
-  buildTextPreview,
-  extractReadableText,
-  isLargeTextSurface,
-  trimText,
-} from './text-surface.ts';
+import { buildTextPreview, describeTextSurface, trimText } from './text-surface.ts';
 
 type SnapshotDisplayLine = {
   node: SnapshotNode;
@@ -56,10 +51,11 @@ export function formatSnapshotLine(
   options: SnapshotLineFormatOptions = {},
 ): string {
   const type = normalizedType ?? formatRole(node.type ?? 'Element');
-  const label = resolveDisplayLabel(node, type, options);
+  const textSurface = describeTextSurface(node, type);
+  const label = resolveDisplayLabel(node, type, options, textSurface);
   const indent = '  '.repeat(depth);
   const ref = node.ref ? `@${node.ref}` : '';
-  const metadata = buildLineMetadata(node, type, options);
+  const metadata = buildLineMetadata(node, type, options, textSurface);
   const metadataText = metadata.map((entry) => ` [${entry}]`).join('');
   const textPart = label ? ` "${label}"` : '';
   if (hiddenGroup) {
@@ -188,22 +184,23 @@ function resolveDisplayLabel(
   node: SnapshotNode,
   type: string,
   options: SnapshotLineFormatOptions,
+  textSurface: { text: string; isLargeSurface: boolean; shouldSummarize: boolean },
 ): string {
   if (!options.summarizeTextSurfaces) {
     return displayLabel(node, type);
   }
-  const text = extractReadableText(node);
-  if (!isLargeTextSurface(node, type) || !shouldSummarizeTextSurface(text)) {
+  if (!textSurface.shouldSummarize) {
     return displayLabel(node, type);
   }
-  const semanticLabel = semanticSurfaceLabel(node, type, text);
+  const semanticLabel = semanticSurfaceLabel(node, type, textSurface.text);
   return semanticLabel || displayLabel(node, type);
 }
 
 function buildLineMetadata(
   node: SnapshotNode,
   type: string,
   options: SnapshotLineFormatOptions,
+  textSurface: { text: string; isLargeSurface: boolean; shouldSummarize: boolean },
 ): string[] {
   const metadata: string[] = [];
   if (node.enabled === false) metadata.push('disabled');
@@ -213,22 +210,14 @@ function buildLineMetadata(
   if (!options.summarizeTextSurfaces) {
     return metadata;
   }
-  const text = extractReadableText(node);
-  if (!isLargeTextSurface(node, type) || !shouldSummarizeTextSurface(text)) {
+  if (!textSurface.shouldSummarize) {
     return metadata;
   }
-  metadata.push(`preview:"${escapePreviewText(buildTextPreview(text))}"`);
+  metadata.push(`preview:"${escapePreviewText(buildTextPreview(textSurface.text))}"`);
   metadata.push('truncated');
   return uniqueMetadata(metadata);
 }
 
-function shouldSummarizeTextSurface(text: string): boolean {
-  if (!text) {
-    return false;
-  }
-  return text.length > 80 || /[\r\n]/.test(text);
-}
-
 function semanticSurfaceLabel(node: SnapshotNode, type: string, text: string): string {
   const label = trimText(node.label);
   if (label && label !== text) {

src/utils/text-surface.ts

@@ -11,10 +11,11 @@ export function extractReadableText(node: TextSurfaceNode): string {
   const label = trimText(node.label);
   const value = trimText(node.value);
   const identifier = trimText(node.identifier);
+  const fallbackIdentifier = isMeaningfulReadableIdentifier(identifier) ? identifier : '';
   if (prefersValueForReadableText(node.type ?? '')) {
-    return value || label || identifier;
+    return value || label || fallbackIdentifier;
   }
-  return label || value || identifier;
+  return label || value || fallbackIdentifier;
 }
 
 export function isLargeTextSurface(node: TextSurfaceNode, displayType?: string): boolean {
@@ -43,6 +44,30 @@ export function buildTextPreview(text: string): string {
   return `${normalized.slice(0, 45)}...`;
 }
 
+export function describeTextSurface(
+  node: TextSurfaceNode,
+  displayType?: string,
+): {
+  text: string;
+  isLargeSurface: boolean;
+  shouldSummarize: boolean;
+} {
+  const text = extractReadableText(node);
+  const isLargeSurface = isLargeTextSurface(node, displayType);
+  return {
+    text,
+    isLargeSurface,
+    shouldSummarize: isLargeSurface && shouldSummarizeTextSurface(text),
+  };
+}
+
+export function shouldSummarizeTextSurface(text: string): boolean {
+  if (!text) {
+    return false;
+  }
+  return text.length > 80 || /[\r\n]/.test(text);
+}
+
 export function trimText(value: unknown): string {
   return typeof value === 'string' ? value.trim() : '';
 }
@@ -71,3 +96,10 @@ function normalizeTextSurfaceType(type: string): string {
   }
   return normalized;
 }
+
+function isMeaningfulReadableIdentifier(value: string): boolean {
+  if (!value) {
+    return false;
+  }
+  return !/^[\w.]+:id\/[\w.-]+$/i.test(value) && !/^_?NS:\d+$/i.test(value);
+}