@mobileai/react-native 0.9.18 → 0.9.20

package/lib/module/core/FiberAdapter.js

@@ -0,0 +1,56 @@
+"use strict";
+
+/**
+ * FiberAdapter — Defense in depth for React internals.
+ *
+ * Centralizes all direct access to React Fiber internal properties.
+ * If React renames an internal property (e.g., in React 19/20), we only
+ * need to update it here instead of auditing the entire codebase.
+ *
+ * These are intentionally simple getter functions, not a complex class abstraction,
+ * to ensure maximum performance during tree walk.
+ */
+
+export function getChild(node) {
+  return node?.child ?? null;
+}
+export function getSibling(node) {
+  return node?.sibling ?? null;
+}
+export function getParent(node) {
+  return node?.return ?? null;
+}
+export function getProps(node) {
+  return node?.memoizedProps || {};
+}
+export function getStateNode(node) {
+  return node?.stateNode ?? null;
+}
+export function getType(node) {
+  return node?.type ?? null;
+}
+export function getDisplayName(node) {
+  return node?.type?.displayName ?? null;
+}
+
+/**
+ * Common heuristic to find the Fiber node attached to a native view.
+ *
+ * Old Architecture (Bridge): __reactFiber$<hash> or __reactInternalInstance$<hash>
+ * New Architecture (Fabric): __internalInstanceHandle (ReactNativeElement)
+ */
+export function getFiberFromNativeNode(nativeNode) {
+  if (!nativeNode) return null;
+
+  // Old Architecture: __reactFiber$ / __reactInternalInstance$
+  const key = Object.keys(nativeNode).find(k => k.startsWith('__reactFiber$') || k.startsWith('__reactInternalInstance$'));
+  if (key) return nativeNode[key];
+
+  // New Architecture (Fabric): __internalInstanceHandle
+  const handle = nativeNode.__internalInstanceHandle;
+  if (handle && (handle.child !== undefined || handle.memoizedProps !== undefined)) {
+    return handle;
+  }
+  return null;
+}
+//# sourceMappingURL=FiberAdapter.js.map

package/lib/module/core/FiberTreeWalker.js

@@ -10,6 +10,8 @@
  */
 
 import { logger } from "../utils/logger.js";
+import { getChild, getSibling, getParent, getProps, getStateNode, getType, getDisplayName } from "./FiberAdapter.js";
+import { getActiveAlert } from "./NativeAlertInterceptor.js";
 
 // ─── Walk Configuration ─────────
 
@@ -30,6 +32,7 @@ const VIDEO_TYPES = new Set(['Video', 'ExpoVideo', 'RCTVideo', 'VideoPlayer', 'V
 
 // Known RN internal component names to skip when walking up for context
 const RN_INTERNAL_NAMES = new Set(['View', 'RCTView', 'Pressable', 'TouchableOpacity', 'TouchableHighlight', 'ScrollView', 'RCTScrollView', 'FlatList', 'SectionList', 'SafeAreaView', 'RNCSafeAreaView', 'KeyboardAvoidingView', 'Modal', 'StatusBar', 'Text', 'RCTText', 'AnimatedComponent', 'AnimatedComponentWrapper', 'Animated']);
+const LOW_SIGNAL_RUNTIME_LABELS = new Set(['button', 'buttons', 'label', 'labels', 'title', 'titles', 'name', 'text', 'value', 'values', 'content', 'card', 'cards', 'row', 'rows', 'item', 'items', 'component', 'screen']);
 
 // ─── State Extraction ──
 
@@ -85,14 +88,14 @@ export function hasAnyEventHandler(props) {
  * This provides semantic context for media elements (e.g., an Image inside "ProfileHeader").
  */
 function getNearestCustomComponentName(fiber, maxDepth = 8) {
-  let current = fiber?.return;
+  let current = getParent(fiber);
   let depth = 0;
   while (current && depth < maxDepth) {
     const name = getComponentName(current);
     if (name && !RN_INTERNAL_NAMES.has(name) && !PRESSABLE_TYPES.has(name)) {
       return name;
     }
-    current = current.return;
+    current = getParent(current);
     depth++;
   }
   return null;
@@ -104,18 +107,20 @@ function getNearestCustomComponentName(fiber, maxDepth = 8) {
  * Get the display name of a Fiber node's component type.
  */
 function getComponentName(fiber) {
-  if (!fiber || !fiber.type) return null;
+  const type = getType(fiber);
+  if (!type) return null;
 
   // Host components (View, Text, etc.) — type is a string
-  if (typeof fiber.type === 'string') return fiber.type;
+  if (typeof type === 'string') return type;
 
   // Function/Class components — type has displayName or name
-  if (fiber.type.displayName) return fiber.type.displayName;
-  if (fiber.type.name) return fiber.type.name;
+  const displayName = getDisplayName(fiber);
+  if (displayName) return displayName;
+  if (type.name) return type.name;
 
   // ForwardRef components
-  if (fiber.type.render?.displayName) return fiber.type.render.displayName;
-  if (fiber.type.render?.name) return fiber.type.render.name;
+  if (type.render?.displayName) return type.render.displayName;
+  if (type.render?.name) return type.render.name;
   return null;
 }
 
@@ -124,7 +129,7 @@ function getComponentName(fiber) {
  */
 function getElementType(fiber) {
   const name = getComponentName(fiber);
-  const props = fiber.memoizedProps || {};
+  const props = getProps(fiber);
 
   // Check by component name (known React Native types)
   if (name && PRESSABLE_TYPES.has(name)) return 'pressable';
@@ -164,7 +169,7 @@ function getElementType(fiber) {
  * Check if element is disabled.
  */
 function isDisabled(fiber) {
-  const props = fiber.memoizedProps || {};
+  const props = getProps(fiber);
   return props.disabled === true || props.editable === false;
 }
 
@@ -180,10 +185,10 @@ function isDisabled(fiber) {
 function extractDeepTextContent(fiber, maxDepth = 10) {
   if (!fiber || maxDepth <= 0) return '';
   const parts = [];
-  let child = fiber.child;
+  let child = getChild(fiber);
   while (child) {
     const childName = getComponentName(child);
-    const childProps = child.memoizedProps || {};
+    const childProps = getProps(child);
 
     // Text node — extract content
     if (childName && TEXT_TYPES.has(childName)) {
@@ -199,7 +204,7 @@ function extractDeepTextContent(fiber, maxDepth = 10) {
       const nestedText = extractDeepTextContent(child, maxDepth - 1);
       if (nestedText) parts.push(nestedText);
     }
-    child = child.sibling;
+    child = getSibling(child);
   }
   return parts.join(' ').trim();
 }
@@ -217,6 +222,38 @@ function isIconGlyph(text) {
   const code = trimmed.codePointAt(0) || 0;
   return code >= 0xE000 && code <= 0xF8FF || code >= 0xF0000 && code <= 0xFFFFF || code >= 0x100000 && code <= 0x10FFFF;
 }
+function normalizeRuntimeLabel(text) {
+  if (!text) return '';
+  return String(text).replace(/\s+/g, ' ').trim();
+}
+function scoreRuntimeLabel(text, source) {
+  const normalized = normalizeRuntimeLabel(text);
+  if (!normalized) return Number.NEGATIVE_INFINITY;
+  let score = 0;
+  const words = normalized.split(/\s+/).filter(Boolean);
+  const lowered = normalized.toLowerCase();
+  if (source === 'deep-text') score += 70;
+  if (source === 'accessibility') score += 80;
+  if (source === 'placeholder') score += 25;
+  if (source === 'context') score += 10;
+  if (source === 'icon') score -= 10;
+  if (source === 'test-id') score -= 25;
+  if (normalized.length >= 3 && normalized.length <= 32) score += 20;else if (normalized.length > 60) score -= 10;
+  if (words.length >= 2 && words.length <= 8) score += 20;else if (words.length === 1) score += 5;
+  if (/^[A-Z]/.test(normalized)) score += 8;
+  if (/[A-Za-z]/.test(normalized) && !/[_./]/.test(normalized)) score += 12;
+  if (/[_./]/.test(normalized)) score -= 20;
+  if (LOW_SIGNAL_RUNTIME_LABELS.has(lowered)) score -= 120;
+  if (source === 'accessibility' && !LOW_SIGNAL_RUNTIME_LABELS.has(lowered)) score += 15;
+  return score;
+}
+function chooseBestRuntimeLabel(candidates) {
+  const best = candidates.map(candidate => ({
+    text: normalizeRuntimeLabel(candidate.text),
+    score: scoreRuntimeLabel(String(candidate.text || ''), candidate.source)
+  })).filter(candidate => candidate.text).sort((a, b) => b.score - a.score)[0];
+  return best?.text || null;
+}
 
 /**
  * Extract raw text from React children prop.
@@ -249,10 +286,10 @@ function extractRawText(children) {
  */
 function extractIconName(fiber, maxDepth = 5) {
   if (!fiber || maxDepth <= 0) return '';
-  let child = fiber.child;
+  let child = getChild(fiber);
   while (child) {
     const componentName = getComponentName(child);
-    const childProps = child.memoizedProps || {};
+    const childProps = getProps(child);
 
     // Generic icon detection: non-RN-internal component with a string `name` prop
     if (componentName && !RN_INTERNAL_NAMES.has(componentName) && !PRESSABLE_TYPES.has(componentName) && !TEXT_INPUT_TYPES.has(componentName) && typeof childProps.name === 'string' && childProps.name.length > 0) {
@@ -262,7 +299,7 @@ function extractIconName(fiber, maxDepth = 5) {
     // Recurse into ALL children (pierce through nested interactives)
     const found = extractIconName(child, maxDepth - 1);
     if (found) return found;
-    child = child.sibling;
+    child = getSibling(child);
   }
   return '';
 }
@@ -316,33 +353,70 @@ function getFiberRootFromDevTools() {
 function getFiberFromRef(ref) {
   if (!ref) return null;
 
-  // Strategy 1: __reactFiber$ keys (React DOM/RN style)
-  // Works in both dev AND release builds — primary strategy.
+  // Strategy 1a: __reactFiber$ keys (Old Architecture / Bridge)
+  // Strategy 1b: __internalInstanceHandle (New Architecture / Fabric)
+  //
+  // In the Old Architecture, React attaches __reactFiber$<hash> to native nodes.
+  // In the New Architecture (Fabric, RN 0.73+), native refs are ReactNativeElement
+  // instances with __internalInstanceHandle — which IS the Fiber node directly.
+  // Both strategies are checked in a single Object.keys pass for performance.
   try {
     const keys = Object.keys(ref);
+    logger.info('FiberTreeWalker', `Ref keys (${keys.length}): ${keys.join(', ')}`);
+
+    // 1a: __reactFiber$ / __reactInternalInstance$ (Old Architecture)
     const fiberKey = keys.find(key => key.startsWith('__reactFiber$') || key.startsWith('__reactInternalInstance$'));
     if (fiberKey) {
-      logger.debug('FiberTreeWalker', 'Accessed Fiber tree via __reactFiber$ key');
-      return ref[fiberKey];
+      const fiber = ref[fiberKey];
+      logger.info('FiberTreeWalker', `✅ Strategy 1a SUCCESS (Old Arch): Fiber via "${fiberKey}" (has child: ${!!fiber?.child})`);
+      return fiber;
     }
-  } catch {
-    // Object.keys may fail on some native nodes
+
+    // 1b: __internalInstanceHandle (New Architecture / Fabric)
+    // ReactNativeElement stores the Fiber node reference here.
+    // It has .child, .sibling, .return, .memoizedProps — the full Fiber structure.
+    if (keys.includes('__internalInstanceHandle')) {
+      const handle = ref.__internalInstanceHandle;
+      if (handle && (handle.child !== undefined || handle.memoizedProps !== undefined)) {
+        logger.info('FiberTreeWalker', `✅ Strategy 1b SUCCESS (Fabric): Fiber via __internalInstanceHandle (has child: ${!!handle.child})`);
+        return handle;
+      }
+      logger.warn('FiberTreeWalker', '⚠️ __internalInstanceHandle found but does not look like a Fiber node');
+    }
+    logger.warn('FiberTreeWalker', '❌ Strategy 1 FAILED: No __reactFiber$ or __internalInstanceHandle key found');
+  } catch (e) {
+    logger.warn('FiberTreeWalker', `❌ Strategy 1 ERROR: ${e.message}`);
   }
 
   // Strategy 2: _reactInternals (class components)
-  if (ref._reactInternals) return ref._reactInternals;
+  if (ref._reactInternals) {
+    logger.info('FiberTreeWalker', '✅ Strategy 2 SUCCESS: _reactInternals');
+    return ref._reactInternals;
+  }
 
   // Strategy 3: _reactInternalInstance (older React)
-  if (ref._reactInternalInstance) return ref._reactInternalInstance;
+  if (ref._reactInternalInstance) {
+    logger.info('FiberTreeWalker', '✅ Strategy 3 SUCCESS: _reactInternalInstance');
+    return ref._reactInternalInstance;
+  }
 
   // Strategy 4: Direct fiber node properties (ref IS a fiber — used in tests)
-  if (ref.child || ref.memoizedProps) return ref;
+  if (ref.child || ref.memoizedProps) {
+    logger.info('FiberTreeWalker', '✅ Strategy 4 SUCCESS: ref is directly a Fiber node');
+    return ref;
+  }
 
   // Strategy 5: DevTools hook (dev-only last resort)
-  const rootFiber = getFiberRootFromDevTools();
-  if (rootFiber) return rootFiber;
-  console.warn('[AIAgent] Could not access React Fiber tree. ' + 'The AI agent will not be able to detect interactive elements. ' + 'Ensure the rootRef is attached to a rendered <View>.');
-  logger.warn('FiberTreeWalker', 'All Fiber access strategies failed');
+  // Guarded by __DEV__ to ensure production builds never reference
+  // __REACT_DEVTOOLS_GLOBAL_HOOK__ — avoids App Store automated scanner flags.
+  if (typeof __DEV__ !== 'undefined' && __DEV__) {
+    const rootFiber = getFiberRootFromDevTools();
+    if (rootFiber) {
+      logger.info('FiberTreeWalker', '✅ Strategy 5 SUCCESS: DevTools hook');
+      return rootFiber;
+    }
+  }
+  logger.error('FiberTreeWalker', 'ALL Fiber access strategies FAILED. ' + `Ref type: ${typeof ref}, constructor: ${ref?.constructor?.name || 'unknown'}. ` + 'The AI agent will not detect interactive elements.');
   return null;
 }
 
@@ -355,7 +429,7 @@ function getFiberFromRef(ref) {
  */
 function matchesRefList(node, refs) {
   if (!refs || refs.length === 0) return false;
-  const stateNode = node.stateNode;
+  const stateNode = getStateNode(node);
   if (!stateNode) return false;
   for (const ref of refs) {
     if (ref.current && ref.current === stateNode) return true;
@@ -400,7 +474,7 @@ export function walkFiberTree(rootRef, config) {
   const hasWhitelist = config?.interactiveWhitelist && (config.interactiveWhitelist.length ?? 0) > 0;
   function processNode(node, depth = 0, isInsideInteractive = false, ancestorOnPress = null, currentZoneId = undefined) {
     if (!node) return '';
-    const props = node.memoizedProps || {};
+    const props = getProps(node);
 
     // ── Prune inactive screens ──────────────────────────────────
     // Two mechanisms cover all React Navigation setups:
@@ -422,10 +496,10 @@ export function walkFiberTree(rootRef, config) {
     if (props.aiIgnore === true) return '';
     if (matchesRefList(node, config?.interactiveBlacklist)) {
       let childText = '';
-      let currentChild = node.child;
+      let currentChild = getChild(node);
       while (currentChild) {
         childText += processNode(currentChild, depth, isInsideInteractive);
-        currentChild = currentChild.sibling;
+        currentChild = getSibling(currentChild);
       }
       return childText;
     }
@@ -455,7 +529,8 @@ export function walkFiberTree(rootRef, config) {
     // Only visible nodes (interactives, text, images, videos) should increment
     // depth. Structural View wrappers are transparent — they pass through the
     // same depth so indentation stays flat and doesn't waste LLM tokens.
-    const typeStr = node.type && typeof node.type === 'string' ? node.type : node.elementType && typeof node.elementType === 'string' ? node.elementType : null;
+    const type = getType(node);
+    const typeStr = type && typeof type === 'string' ? type : node.elementType && typeof node.elementType === 'string' ? node.elementType : null;
     const componentName = getComponentName(node);
     const isTextNode = typeStr === 'RCTText' || typeStr === 'Text';
     const isImageNode = !!(componentName && IMAGE_TYPES.has(componentName));
@@ -482,10 +557,10 @@ export function walkFiberTree(rootRef, config) {
 
     // Process children
     let childrenText = '';
-    let currentChild = node.child;
+    let currentChild = getChild(node);
     while (currentChild) {
       childrenText += processNode(currentChild, childDepth, isInsideInteractive || !!shouldInclude, nextAncestorOnPress, nextZoneId);
-      currentChild = currentChild.sibling;
+      currentChild = getSibling(currentChild);
     }
 
     // Prepend zone header before children if this is a zone root
@@ -494,33 +569,26 @@ export function walkFiberTree(rootRef, config) {
     }
     if (shouldInclude) {
       const resolvedType = elementType || 'pressable';
-      // Primary: accessibilityLabel → deep text (pierces nested interactives)
-      let label = props.accessibilityLabel || extractDeepTextContent(node);
-
-      // Fallback: TextInput placeholder
-      if (!label && resolvedType === 'text-input' && props.placeholder) {
-        label = props.placeholder;
-      }
-      // Fallback: Icon/symbol name (any component with a `name` prop)
-      if (!label) {
-        label = extractIconName(node);
-      }
-      // Fallback: testID/nativeID
-      if (!label && (props.testID || props.nativeID)) {
-        label = props.testID || props.nativeID;
-      }
-      // Fallback: Parent component context (skip internal RN context names)
-      if (!label) {
-        const parentContext = getNearestCustomComponentName(node);
-        if (parentContext) {
-          // Skip React Native internal implementation names that leak as labels.
-          // These are never meaningful to the AI or developer.
-          const RN_INTERNAL_NAMES = new Set(['ScrollViewContext', 'VirtualizedListContext', 'ViewabilityHelper', 'ScrollResponder', 'AnimatedComponent', 'TouchableOpacity']);
-          if (!RN_INTERNAL_NAMES.has(parentContext)) {
-            label = parentContext;
-          }
-        }
-      }
+      const parentContext = getNearestCustomComponentName(node);
+      const label = chooseBestRuntimeLabel([{
+        text: props.accessibilityLabel,
+        source: 'accessibility'
+      }, {
+        text: extractDeepTextContent(node),
+        source: 'deep-text'
+      }, {
+        text: resolvedType === 'text-input' ? props.placeholder : null,
+        source: 'placeholder'
+      }, {
+        text: extractIconName(node),
+        source: 'icon'
+      }, {
+        text: props.testID || props.nativeID,
+        source: 'test-id'
+      }, {
+        text: parentContext && !new Set(['ScrollViewContext', 'VirtualizedListContext', 'ViewabilityHelper', 'ScrollResponder', 'AnimatedComponent', 'TouchableOpacity']).has(parentContext) ? parentContext : null,
+        source: 'context'
+      }]);
       interactives.push({
         index: currentIndex,
         type: resolvedType,
@@ -600,8 +668,43 @@ export function walkFiberTree(rootRef, config) {
     }
   }
 
-  // Clean up excessive blank lines
-  elementsText = elementsText.replace(/\n{3,}/g, '\n\n');
+  // Clean up excessive blank lines safely to avoid regex stack depth limit on very large grids
+  const lines = elementsText.split('\n');
+  const cleanLines = [];
+  let emptyCount = 0;
+  for (const line of lines) {
+    if (line.trim() === '') {
+      emptyCount++;
+      if (emptyCount < 2) cleanLines.push(line);
+    } else {
+      emptyCount = 0;
+      cleanLines.push(line);
+    }
+  }
+  elementsText = cleanLines.join('\n');
+
+  // ── Inject Native OS Alerts (Virtual Elements) ──
+  if (config?.interceptNativeAlerts) {
+    const alert = getActiveAlert();
+    if (alert) {
+      elementsText += `\n\n<system_alert>\n  <title>${alert.title}</title>\n  <message>${alert.message}</message>\n`;
+      alert.buttons.forEach((btn, idx) => {
+        elementsText += `  [${currentIndex}]<pressable role="button">"${btn.text}" />\n`;
+        interactives.push({
+          index: currentIndex++,
+          type: 'pressable',
+          label: btn.text,
+          props: {},
+          fiberNode: null,
+          virtual: {
+            kind: 'alert_button',
+            alertButtonIndex: idx
+          }
+        });
+      });
+      elementsText += `</system_alert>`;
+    }
+  }
   logger.info('FiberTreeWalker', `Found ${interactives.length} interactive elements`);
   return {
     elementsText: elementsText.trim(),
@@ -643,11 +746,11 @@ function findScreenFiberNode(rootFiber, screenName) {
     }
 
     // Depth-first: search children first, then siblings
-    let child = node.child;
+    let child = getChild(node);
     while (child) {
       const found = search(child);
       if (found) return found;
-      child = child.sibling;
+      child = getSibling(child);
     }
     return null;
   }
@@ -700,7 +803,7 @@ export function findScrollableContainers(rootRef, screenName) {
       // For scrollable containers, we need the native scroll ref.
       // FlatList Fiber stateNode may be the component instance — 
       // we need to find the underlying native ScrollView.
-      let scrollRef = isPagerLike ? node.stateNode : resolveNativeScrollRef(node);
+      let scrollRef = isPagerLike ? getStateNode(node) : resolveNativeScrollRef(node);
       if (scrollRef) {
         containers.push({
           index: currentIndex++,
@@ -714,10 +817,10 @@ export function findScrollableContainers(rootRef, screenName) {
     }
 
     // Recurse into children and siblings
-    let child = node.child;
+    let child = getChild(node);
     while (child) {
       walk(child);
-      child = child.sibling;
+      child = getSibling(child);
     }
   }
   walk(startNode);
@@ -733,9 +836,9 @@ export function findScrollableContainers(rootRef, screenName) {
  * - FlatList/VirtualizedList: stateNode is a component instance,
  *   need to find the inner ScrollView via getNativeScrollRef() or
  *   by walking down the Fiber tree to find the RCTScrollView child
- */
+*/
 function resolveNativeScrollRef(fiberNode) {
-  const stateNode = fiberNode.stateNode;
+  const stateNode = getStateNode(fiberNode);
 
   // Case 1: stateNode has scrollTo (native ScrollView or RCTScrollView)
   if (stateNode && typeof stateNode.scrollTo === 'function') {
@@ -769,20 +872,23 @@ function resolveNativeScrollRef(fiberNode) {
   }
 
   // Case 5: Walk down Fiber tree to find an RCTScrollView child
-  let child = fiberNode.child;
+  let child = getChild(fiberNode);
   while (child) {
     const childName = getComponentName(child);
-    if (childName === 'RCTScrollView' && child.stateNode) {
-      return child.stateNode;
+    const childStateNode = getStateNode(child);
+    if (childName === 'RCTScrollView' && childStateNode) {
+      return childStateNode;
     }
     // Go one level deeper for wrapper patterns
-    if (child.child) {
-      const grandchildName = getComponentName(child.child);
-      if (grandchildName === 'RCTScrollView' && child.child.stateNode) {
-        return child.child.stateNode;
+    const grandchild = getChild(child);
+    if (grandchild) {
+      const grandchildName = getComponentName(grandchild);
+      const grandchildStateNode = getStateNode(grandchild);
+      if (grandchildName === 'RCTScrollView' && grandchildStateNode) {
+        return grandchildStateNode;
       }
     }
-    child = child.sibling;
+    child = getSibling(child);
   }
   logger.debug('FiberTreeWalker', 'Could not resolve native scroll ref — returning stateNode as fallback');
   return stateNode;

package/lib/module/core/IdleDetector.js

@@ -26,6 +26,25 @@ export class IdleDetector {
     this.clearTimers();
     this.config = null;
   }
+
+  /**
+   * Instantly trigger proactive help if the behavior matches a configured trigger.
+   */
+  triggerBehavior(type, currentScreen) {
+    if (!this.config || this.dismissed || !this.config.behaviorTriggers) return;
+    const trigger = this.config.behaviorTriggers.find(t => t.type === type && (t.screen === '*' || t.screen === currentScreen));
+    if (trigger) {
+      this.clearTimers(); // Intercept normal idle flow
+      const message = trigger.message || `It looks like you might be having trouble. Can I help?`;
+      if (trigger.delayMs) {
+        this.badgeTimer = setTimeout(() => {
+          this.config?.onBadge(message);
+        }, trigger.delayMs);
+      } else {
+        this.config.onBadge(message);
+      }
+    }
+  }
   resetTimers() {
     this.clearTimers();
     if (!this.config || this.dismissed) return;