yaver-feedback-react-native 0.9.10 → 0.9.12

package/src/MachinePickerScreen.tsx

@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect, useState } from 'react';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
 import {
   View,
   Text,
@@ -23,8 +23,10 @@ export interface YaverMachinePickerProps {
   token: string;
   /** Currently-selected deviceId (from config / cache) — highlighted. */
   currentDeviceId?: string;
-  onPick: (device: RemoteDevice) => void;
+  onPick: (device: RemoteDevice) => void | Promise<void>;
   onCancel?: () => void;
+  /** Optional flow-specific title, e.g. "Choose a machine for SFMG". */
+  title?: string;
 }
 
 /**
@@ -39,6 +41,7 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
   currentDeviceId,
   onPick,
   onCancel,
+  title = 'Choose a machine',
 }) => {
   const [loading, setLoading] = useState(true);
   const [refreshing, setRefreshing] = useState(false);
@@ -46,32 +49,28 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
   const [list, setList] = useState<DeviceList>({ owned: [] });
   const [pairingDevice, setPairingDevice] = useState<RemoteDevice | null>(null);
   const [reachability, setReachability] = useState<Record<string, DeviceReachability | undefined>>({});
+  const [selectingDeviceId, setSelectingDeviceId] = useState<string | null>(null);
+  const mountedRef = useRef(true);
+  const loadGenerationRef = useRef(0);
 
   const load = useCallback(async (silent = false) => {
+    const generation = ++loadGenerationRef.current;
     if (!silent) setLoading(true);
     setError(null);
     try {
       const result = await listReachableDevices(token);
       setList(result);
       setReachability({});
-      void (async () => {
-        const devices = result.owned;
-        const settled = await Promise.allSettled(
-          devices.map(async (device) => ({
-            deviceId: device.deviceId,
-            result: await probeDeviceReachability(device),
-          })),
-        );
-        setReachability((prev) => {
-          const next = { ...prev };
-          for (const entry of settled) {
-            if (entry.status === 'fulfilled') {
-              next[entry.value.deviceId] = entry.value.result;
-            }
-          }
-          return next;
-        });
-      })();
+      // Convex already gives us a fresh, heartbeat-gated online answer. Render
+      // that immediately. Only probe cloud-offline rows to detect a phone-LAN
+      // route that came back before the next heartbeat, and publish each result
+      // as it arrives instead of holding the whole list behind the slowest box.
+      for (const device of result.owned.filter((candidate) => !candidate.isOnline)) {
+        void probeDeviceReachability(device).then((probe) => {
+          if (!mountedRef.current || loadGenerationRef.current !== generation) return;
+          setReachability((prev) => ({ ...prev, [device.deviceId]: probe }));
+        }).catch(() => {});
+      }
       if (result.owned.length === 0) {
         setError('No machines found yet. Run `yaver auth` + `yaver serve` on your machine.');
       }
@@ -84,7 +83,9 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
   }, [token]);
 
   useEffect(() => {
+    mountedRef.current = true;
     void load();
+    return () => { mountedRef.current = false; };
   }, [load]);
 
   const handlePick = async (device: RemoteDevice) => {
@@ -97,7 +98,9 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
       setPairingDevice(device);
       return;
     }
-    const direct = await probeDeviceReachability(device);
+    const direct = device.isOnline
+      ? { reachable: true } as DeviceReachability
+      : await probeDeviceReachability(device);
     // Do not hard-block selection just because the LAN /health probe
     // failed. The standalone SDK can still reach a healthy machine via
     // the normal selected-device discovery path (including relay), and
@@ -110,12 +113,18 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
       setReachability((prev) => ({ ...prev, [device.deviceId]: direct }));
       return;
     }
-    await saveSelectedDeviceId(device.deviceId);
-    onPick(device);
+    setSelectingDeviceId(device.deviceId);
+    try {
+      await saveSelectedDeviceId(device.deviceId);
+      await onPick(device);
+    } finally {
+      if (mountedRef.current) setSelectingDeviceId(null);
+    }
   };
 
   const renderDevice = (device: RemoteDevice) => {
     const selected = device.deviceId === currentDeviceId;
+    const selecting = device.deviceId === selectingDeviceId;
     const probe = reachability[device.deviceId];
     // Trust Convex's `isOnline` — the backend already gates it on a
     // fresh 90 s heartbeat (see backend/convex/devices.ts
@@ -134,14 +143,16 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
       : effectivelyReachable
         ? '#22c55e'
         : device.isOnline
-          ? '#f59e0b'
+          ? '#22c55e'
           : explicitlyOffline || !device.isOnline
           ? '#ef4444'
           : '#22c55e';
     // Derive a single short status phrase the user can act on.
     let statusLine = device.platform;
-    if (probe === undefined) {
-      statusLine = 'Checking connection…';
+    if (selecting) {
+      statusLine = 'Connecting…';
+    } else if (probe === undefined && device.isOnline) {
+      statusLine = device.platform || 'Online';
     } else if (!device.isOnline && effectivelyReachable) {
       statusLine = 'Reachable now — waiting for cloud status to refresh';
     } else if (!device.isOnline) {
@@ -162,13 +173,15 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
         key={device.deviceId}
         style={[styles.deviceRow, selected && styles.deviceSelected]}
         onPress={() => handlePick(device)}
+        disabled={selectingDeviceId !== null}
       >
         <View style={[styles.health, { backgroundColor: healthColor }]} />
         <View style={{ flex: 1 }}>
           <Text style={styles.deviceName}>{device.name || device.deviceId}</Text>
           <Text style={styles.deviceMeta}>{statusLine}</Text>
         </View>
-        {selected && <Text style={styles.selectedBadge}>seçili</Text>}
+        {selecting ? <ActivityIndicator color="#a5b4fc" size="small" /> : null}
+        {selected && !selecting && <Text style={styles.selectedBadge}>selected</Text>}
       </TouchableOpacity>
     );
   };
@@ -176,10 +189,10 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
   return (
     <SafeAreaView style={styles.container}>
       <View style={styles.header}>
-        <Text style={styles.title}>Makine Seç</Text>
+        <Text style={styles.title}>{title}</Text>
         {onCancel && (
           <TouchableOpacity onPress={onCancel} style={styles.cancel}>
-            <Text style={styles.cancelText}>Kapat</Text>
+            <Text style={styles.cancelText}>Close</Text>
           </TouchableOpacity>
         )}
       </View>
@@ -203,7 +216,7 @@ export const YaverMachinePickerScreen: React.FC<YaverMachinePickerProps> = ({
           <>
             {list.owned.length > 0 && (
               <View style={styles.section}>
-                <Text style={styles.sectionTitle}>Kendi makinelerim</Text>
+                <Text style={styles.sectionTitle}>Your machines</Text>
                 {list.owned.map(renderDevice)}
               </View>
             )}

package/src/__tests__/DogfoodRuntime.test.ts

@@ -2,6 +2,7 @@ import {
   DogfoodController,
   DogfoodRuntimeError,
   defaultDogfoodLane,
+  dogfoodLanePlan,
   dogfoodLaneOptions,
   dogfoodLogLinesFromDevEvent,
   validateDogfoodProject,
@@ -92,6 +93,41 @@ describe('DogfoodController', () => {
     await controller.stop();
     expect(stopSecond).toHaveBeenCalledTimes(1);
   });
+
+  test('keeps a failed preferred lane in the console and automatically recovers through browser', async () => {
+    const stopPreferred = jest.fn();
+    const lanes: string[] = [];
+    const controller = new DogfoodController({
+      ...expo,
+      lane: 'hermes',
+      fallbackLane: 'browser',
+    }, {
+      async start(ctx) {
+        lanes.push(ctx.project.lane);
+        if (ctx.project.lane === 'hermes') {
+          ctx.registerCleanup(stopPreferred);
+          throw new DogfoodRuntimeError({
+            code: 'DOGFOOD_HERMES_BUILD_FAILED',
+            error: 'Hermes build failed',
+            remedy: 'Use the browser build.',
+            retryable: true,
+          });
+        }
+        return { lane: 'browser', url: 'http://agent/dev/', metadata: { recovered: true } };
+      },
+    });
+
+    await expect(controller.trigger()).resolves.toMatchObject({
+      lane: 'browser',
+      metadata: { fallbackFrom: 'hermes', fallbackReason: 'DOGFOOD_HERMES_BUILD_FAILED' },
+    });
+    expect(lanes).toEqual(['hermes', 'browser']);
+    expect(stopPreferred).toHaveBeenCalledTimes(1);
+    expect(controller.snapshot()).toMatchObject({ phase: 'ready', project: { lane: 'browser' } });
+    expect(controller.snapshot().logs.map((line) => line.text)).toContain(
+      '[fallback] hermes failed (DOGFOOD_HERMES_BUILD_FAILED); trying browser',
+    );
+  });
 });
 
 describe('Dogfood lanes and console events', () => {
@@ -112,6 +148,21 @@ describe('Dogfood lanes and console events', () => {
     expect(flutter.find((option) => option.lane === 'hermes')?.supported).toBe(false);
   });
 
+  test('uses browser as the framework-aware default and as second choice after an explicit native preference', () => {
+    expect(dogfoodLanePlan('flutter', { nativeRuntimeAvailable: true })).toMatchObject({
+      preferred: 'browser', fallback: undefined,
+    });
+    expect(dogfoodLanePlan('expo', { nativeRuntimeAvailable: true }, 'hermes')).toMatchObject({
+      preferred: 'hermes', fallback: 'browser',
+    });
+    expect(dogfoodLanePlan('flutter', { nativeRuntimeAvailable: true }, 'webrtc')).toMatchObject({
+      preferred: 'webrtc', fallback: 'browser',
+    });
+    expect(dogfoodLanePlan('swift', { nativeRuntimeAvailable: true }, 'webrtc')).toMatchObject({
+      preferred: 'webrtc', fallback: undefined,
+    });
+  });
+
   test('keeps Yaver self-development on the same RN three-lane contract', () => {
     const options = dogfoodLaneOptions('expo', { nativeRuntimeAvailable: true, selfDevelopment: true });
     expect(options).toHaveLength(3);

package/src/__tests__/FeedbackModalContract.test.ts

@@ -46,12 +46,18 @@ describe('FeedbackModal authenticated chat contract', () => {
   });
 
   it('uses Chat as the authenticated entry surface without legacy command buttons', () => {
-    expect(source).toContain("setActiveTab(authenticated ? 'chat' : 'settings')");
+    expect(source).toContain("useState<'chat' | 'settings'>('chat')");
     expect(source).toContain('setShowVibeInput(authenticated || directDogfood)');
     expect(source).not.toContain('Screenshot & Fix');
     expect(source).not.toContain('<DeployPanel');
   });
 
+  it('opens explicit Dogfood onboarding on setup and makes the runtime console the first live surface', () => {
+    expect(source).toContain("setActiveTab('settings')");
+    expect(source).toContain("setDogfoodSetupStage('runtime')");
+    expect(source).toMatch(/dogfoodSetupStage === 'runtime'[\s\S]*?<DogfoodLiveConsole/);
+  });
+
   it('keeps Dogfood setup to box, runner, and checkout before asking for a runtime', () => {
     const setupSteps = source.match(/const dogfoodSetupSteps = \[([\s\S]*?)\n  \];/)?.[1] || '';
     expect([...setupSteps.matchAll(/key: '([^']+)'/g)].map((match) => match[1]))
@@ -61,18 +67,23 @@ describe('FeedbackModal authenticated chat contract', () => {
     expect(setupSteps).not.toContain("key: 'model'");
     expect(setupSteps).not.toContain("key: 'lane'");
     expect(source).toContain("type DogfoodSetupStage = 'setup' | 'lane' | 'runtime'");
-    expect(source).toContain('label="Choose runtime"');
+    expect(source).toContain("label={dogfoodSetupReady ? 'Continue to runtime' : 'Complete the choices above'}");
+    expect(source).toContain('{!dogfoodOnboarding ? <>');
+    expect(source).toContain("? `Set up ${dogfoodOnboarding.projectName || dogfoodOnboarding.label || 'this app'} Dogfood`");
   });
 
   it('passes the selected native target and labels the live log source', () => {
-    expect(source).toContain("nativeTargetId: dogfoodLane === 'webrtc' ? dogfoodNativeTargetId : undefined");
+    expect(source).toContain("nativeTargetId: lanePlan.preferred === 'webrtc' ? dogfoodNativeTargetId : undefined");
+    expect(source).toContain('fallbackLane: lanePlan.fallback');
+    expect(source).toContain('fallbackLane={dogfoodLanePolicy.fallback}');
     expect(source).toMatch(/<DogfoodLiveConsole[\s\S]*?sourceLabel=\{dogfoodSourceLabel\}/);
     expect(source).toContain('Simulator, emulator, or device');
   });
 
-  it('has one iOS keyboard inset owner and no gesture-stealing sheet Pressable', () => {
-    expect(source).toContain('automaticallyAdjustKeyboardInsets={Platform.OS === \'ios\'}');
-    expect(source).not.toContain('<KeyboardAvoidingView');
+  it('has one keyboard inset owner and no gesture-stealing sheet Pressable', () => {
+    expect(source).toContain("behavior={Platform.OS === 'ios' ? 'padding' : 'height'}");
+    expect(source).toContain('automaticallyAdjustKeyboardInsets={false}');
+    expect(source).toContain('<KeyboardAvoidingView');
     expect(source).not.toContain('keyboardInset');
     expect(source).toContain('<Pressable style={styles.backdrop} onPress={handleClose}');
     expect(source).toMatch(/<View[\s\S]{0,300}?style=\{\[\s*styles\.modal/);

package/src/__tests__/MachinePickerScreenContract.test.ts

@@ -0,0 +1,24 @@
+import fs from 'fs';
+import path from 'path';
+
+const source = fs.readFileSync(path.join(__dirname, '..', 'MachinePickerScreen.tsx'), 'utf8');
+
+describe('MachinePickerScreen progressive reachability contract', () => {
+  it('makes heartbeat-online machines immediately selectable', () => {
+    expect(source).toContain("const direct = device.isOnline");
+    expect(source).toContain("? { reachable: true } as DeviceReachability");
+    expect(source).not.toContain("statusLine = 'Checking connection…'");
+    expect(source).toContain("statusLine = device.platform || 'Online'");
+  });
+
+  it('does not hold every row behind the slowest direct probe', () => {
+    expect(source).not.toContain('Promise.allSettled');
+    expect(source).toContain("filter((candidate) => !candidate.isOnline)");
+    expect(source).toContain("setReachability((prev) => ({ ...prev, [device.deviceId]: probe }))");
+  });
+
+  it('names the selected machine connection operation', () => {
+    expect(source).toContain("statusLine = 'Connecting…'");
+    expect(source).toContain('disabled={selectingDeviceId !== null}');
+  });
+});

package/src/index.ts

@@ -92,6 +92,7 @@ export {
   DogfoodController,
   DogfoodRuntimeError,
   defaultDogfoodLane,
+  dogfoodLanePlan,
   dogfoodLaneOptions,
   dogfoodLogLinesFromDevEvent,
   runtimeLogLinesFromDevEvent,
@@ -103,6 +104,7 @@ export type {
   DogfoodFailure,
   DogfoodLane,
   DogfoodLaneOption,
+  DogfoodLanePlan,
   DogfoodLogLine,
   DogfoodPhase,
   DogfoodProject,