@blario/react-native 0.1.4 → 0.1.6

package/src/agent/compose.ts

@@ -20,6 +20,7 @@ export interface AgentEnvironment {
   transport: AgentTransport;
   getAnchorFiber: () => Fiber | null;
   getViewport: () => Size;
+  getWindow: () => Size;
   getNavigationRef: () => NavigationRefLike | null;
   getCaptureTarget: () => unknown;
   reading: ReadingPort;
@@ -40,6 +41,7 @@ export function createAgentController(environment: AgentEnvironment): AgentContr
     getAnchorFiber: environment.getAnchorFiber,
     registry,
     getViewport: environment.getViewport,
+    getWindow: environment.getWindow,
     getExtraRoutes: (): string[] => navigation.listRefRoutePaths(),
   });
   const commitWatch = new CommitWatch(environment.getAnchorFiber, environment.onCommit);

package/src/agent/controller.ts

@@ -14,6 +14,8 @@ import { handleElementContext } from './handlers/element-context.ts';
 import { handleScreenshot } from './handlers/screenshot.ts';
 import { handleTextDom, readTextDom } from './handlers/text-dom.ts';
 
+const MESSAGE_TEXT_DOM_MAX_CHARS = 100_000;
+
 export interface ControllerDependencies {
   transport: AgentTransport;
   commitWatch: CommitWatch;
@@ -44,7 +46,7 @@ export class AgentController {
 
   async readMessageMetadata(options: { includeTextDom: boolean; tabId: string }): Promise<MessageMetadata> {
     const snapshot = await this.context.capturer.capture('peek');
-    const textDom = options.includeTextDom ? await readTextDom(this.context, { viewportOnly: false, maxChars: 0 }) : null;
+    const textDom = options.includeTextDom ? await readTextDom(this.context, { viewportOnly: false, maxChars: MESSAGE_TEXT_DOM_MAX_CHARS }) : null;
     return buildMessageMetadata({
       screen: snapshot.screen,
       tabId: options.tabId,

package/src/agent-mode/keyboard-guard.ts

@@ -0,0 +1,33 @@
+export interface KeyboardPort {
+  addListener: (event: 'keyboardWillShow' | 'keyboardDidShow', listener: () => void) => { remove: () => void };
+  dismiss: () => void;
+}
+
+// Nobody types during a run, and an open keyboard only covers what the agent is doing: an input that focuses itself would
+// otherwise leave it up. Android has no keyboardWillShow, so it hides a beat later. The agent's own typing never opens it
+// (focusWithoutKeyboard); ending the run closes the field it left focused, so the next tap opens a normal keyboard.
+export class KeyboardGuard {
+  private subscriptions: Array<{ remove: () => void }> = [];
+
+  constructor(
+    private readonly keyboard: KeyboardPort,
+    private readonly onRelease: () => void = () => undefined,
+  ) {}
+
+  setActive(active: boolean): void {
+    if (!active) {
+      if (this.subscriptions.length > 0) {
+        this.subscriptions.splice(0).forEach((subscription) => subscription.remove());
+        this.keyboard.dismiss();
+      }
+      this.onRelease();
+      return;
+    }
+    if (this.subscriptions.length > 0) {
+      return;
+    }
+    const dismiss = (): void => this.keyboard.dismiss();
+    this.subscriptions = [this.keyboard.addListener('keyboardWillShow', dismiss), this.keyboard.addListener('keyboardDidShow', dismiss)];
+    dismiss();
+  }
+}

package/src/backend/app-info.ts

@@ -1,9 +1,11 @@
 import { Platform } from 'react-native';
 
 import { isRecord } from '../fiber/narrow.ts';
+import { SDK_VERSION } from '../version.ts';
 
 export interface AppInfo {
   platform: 'react-native';
+  sdk_version: string;
   os: string;
   os_version: string;
   rn_version: string;
@@ -32,6 +34,7 @@ export function detectNewArchitecture(markers: GlobalMarkers): boolean {
 export function readAppInfo(): AppInfo {
   return {
     platform: 'react-native',
+    sdk_version: SDK_VERSION,
     os: Platform.OS,
     os_version: String(Platform.Version),
     rn_version: readReactNativeVersion(),

package/src/chat/ChatSheet.tsx

@@ -1,5 +1,5 @@
 import React, { useEffect, useRef } from 'react';
-import { Animated, BackHandler, Dimensions, Easing, KeyboardAvoidingView, Platform, Pressable, StyleSheet, View } from 'react-native';
+import { Animated, BackHandler, Dimensions, Easing, Keyboard, Platform, Pressable, StyleSheet, View } from 'react-native';
 
 import { useInsets } from '../ui/useInsets.ts';
 import type { UiStrings } from '../ui/strings.ts';
@@ -16,12 +16,38 @@ export interface ChatSheetProps {
 const TOP_GAP = 12;
 const ANIMATION_MS = 240;
 
+// iOS lifts the sheet over the keyboard while the chat is open. Not KeyboardAvoidingView: it reacts to every keyboard in
+// the app even with the chat closed, and its LayoutAnimation applies to the host's whole next commit, which aborted a
+// debug build as soon as a keyboard opened while the host mounted views. On Android the window resizes by itself.
+function useKeyboardInset(active: boolean, homeIndicator: number): Animated.Value {
+  const inset = useRef(new Animated.Value(0)).current;
+  useEffect(() => {
+    if (!active || Platform.OS !== 'ios') {
+      inset.setValue(0);
+      return undefined;
+    }
+    const subscription = Keyboard.addListener('keyboardWillChangeFrame', (event) => {
+      const covered = Dimensions.get('window').height - event.endCoordinates.screenY;
+      Animated.timing(inset, {
+        // The keyboard covers the home-indicator inset, so the sheet's bottom padding sits under it, not above it.
+        toValue: Math.max(0, covered - homeIndicator),
+        duration: event.duration,
+        easing: Easing.out(Easing.cubic),
+        useNativeDriver: false,
+      }).start();
+    });
+    return () => subscription.remove();
+  }, [active, homeIndicator, inset]);
+  return inset;
+}
+
 export function ChatSheet({ mode, mounted, strings, onClose, children }: ChatSheetProps): React.JSX.Element | null {
   const insets = useInsets();
   const windowHeight = Dimensions.get('window').height;
   const sheetHeight = windowHeight - insets.top - TOP_GAP;
   const progress = useRef(new Animated.Value(mode === 'open' ? 1 : 0)).current;
   const isOpen = mode === 'open';
+  const keyboardInset = useKeyboardInset(isOpen, insets.bottom);
 
   useEffect(() => {
     Animated.timing(progress, { toValue: isOpen ? 1 : 0, duration: ANIMATION_MS, easing: Easing.out(Easing.cubic), useNativeDriver: true }).start();
@@ -48,13 +74,7 @@ export function ChatSheet({ mode, mounted, strings, onClose, children }: ChatShe
       <Animated.View style={[styles.backdrop, { opacity: backdropOpacity }]}>
         <Pressable accessibilityLabel={strings.chatClose} style={StyleSheet.absoluteFill} onPress={onClose} />
       </Animated.View>
-      <KeyboardAvoidingView
-        style={[styles.container, { paddingTop: insets.top + TOP_GAP }]}
-        behavior={Platform.OS === 'ios' ? 'padding' : undefined}
-        // The keyboard covers the home-indicator inset, so the sheet's bottom padding sits under it, not above it.
-        keyboardVerticalOffset={-insets.bottom}
-        pointerEvents="box-none"
-      >
+      <Animated.View style={[styles.container, { paddingTop: insets.top + TOP_GAP, paddingBottom: keyboardInset }]} pointerEvents="box-none">
         <Animated.View
           accessibilityElementsHidden={!isOpen}
           importantForAccessibility={isOpen ? 'yes' : 'no-hide-descendants'}
@@ -62,7 +82,7 @@ export function ChatSheet({ mode, mounted, strings, onClose, children }: ChatShe
         >
           {children}
         </Animated.View>
-      </KeyboardAvoidingView>
+      </Animated.View>
     </View>
   );
 }

package/src/chat/ChatView.tsx

@@ -107,7 +107,7 @@ export function ChatView({ shell, unavailableText, getMetadata, getProof, onClos
       mixedContentMode="always"
       setSupportMultipleWindows={false}
       keyboardDisplayRequiresUserAction={false}
-      // The sheet's KeyboardAvoidingView already lifts the chat above the keyboard. WKWebView would also scroll its
+      // The sheet already lifts the chat above the keyboard. WKWebView would also scroll its
       // own page up to reveal the composer, pushing the widget out of the sheet; with scrolling off it resets that
       // offset (the message list is an overflow container and keeps scrolling). The form bar (^ v Done) is for
       // multi-field forms, not a one-field composer.