yaver-feedback-react-native 0.8.3 → 0.8.6

package/src/QuickActionIcon.tsx

@@ -133,6 +133,7 @@ export const QuickActionIcon: React.FC<QuickActionIconProps> = ({
   const [shakenThisSession, setShakenThisSession] = useState(false);
   const [menuOpen, setMenuOpen] = useState(false);
   const [hostSuppressed] = useState<boolean>(() => isRunningInsideYaverHost());
+  const [launching, setLaunching] = useState(false);
 
   // Load the persisted disable flag once on mount. Until it resolves we
   // render nothing — a one-frame flash of the icon before hiding would
@@ -194,6 +195,37 @@ export const QuickActionIcon: React.FC<QuickActionIconProps> = ({
     };
   }, []);
 
+  useEffect(() => {
+    const launchSub = DeviceEventEmitter.addListener(
+      'yaverFeedback:reportLaunch',
+      (event?: { state?: string }) => {
+        if (event?.state === 'starting') {
+          setLaunching(true);
+          return;
+        }
+        setLaunching(false);
+      },
+    );
+    const reportSub = DeviceEventEmitter.addListener(
+      'yaverFeedback:startReport',
+      () => setLaunching(false),
+    );
+    const loginSub = DeviceEventEmitter.addListener(
+      'yaverFeedback:startLogin',
+      () => setLaunching(false),
+    );
+    const pickerSub = DeviceEventEmitter.addListener(
+      'yaverFeedback:startMachinePicker',
+      () => setLaunching(false),
+    );
+    return () => {
+      launchSub.remove();
+      reportSub.remove();
+      loginSub.remove();
+      pickerSub.remove();
+    };
+  }, []);
+
   const panResponder = useRef(
     PanResponder.create({
       onStartShouldSetPanResponder: () => true,
@@ -231,9 +263,10 @@ export const QuickActionIcon: React.FC<QuickActionIconProps> = ({
   ).current;
 
   const openFeedback = useCallback(() => {
+    if (launching) return;
     setMenuOpen(false);
     void YaverFeedback.startReport();
-  }, []);
+  }, [launching]);
 
   const hideForever = useCallback(() => {
     setMenuOpen(false);
@@ -275,10 +308,12 @@ export const QuickActionIcon: React.FC<QuickActionIconProps> = ({
               didDrag.current = false;
               return;
             }
+            if (launching) return;
             openFeedback();
           }}
           onLongPress={() => {
             if (didDrag.current) return;
+            if (launching) return;
             setMenuOpen((m) => !m);
           }}
           delayLongPress={LONG_PRESS_MS}
@@ -294,7 +329,7 @@ export const QuickActionIcon: React.FC<QuickActionIconProps> = ({
               backgroundColor: presetColors?.backgroundColor ?? backgroundColor,
               borderColor: presetColors?.borderColor ?? borderColor,
               shadowColor: presetColors?.shadowColor ?? shadowColor,
-              opacity: pressed ? 0.85 : 1,
+              opacity: launching ? 0.62 : pressed ? 0.85 : 1,
             },
           ]}
         >

package/src/YaverFeedback.ts

@@ -51,6 +51,7 @@ let enabled = false;
 let p2pClient: P2PClient | null = null;
 let shakeDetector: ShakeDetector | null = null;
 let p2pAuthToken: string | null = null;
+let reportLaunchInFlight = false;
 
 /** Ring buffer of captured errors. */
 let errorBuffer: CapturedError[] = [];
@@ -420,6 +421,37 @@ export class YaverFeedback {
     return all.find((device) => device.deviceId === preferredDeviceId) ?? null;
   }
 
+  /**
+   * Trigger remote device-auth for a CLI runner on the selected agent
+   * (codex login --device-auth / claude auth login --console). Returns
+   * the session so the host UI can render the verification URL + code.
+   *
+   * RN UI layer owns the modal (see FeedbackModal's runner sign-in
+   * buttons). This method just proxies into P2PClient — no browser
+   * launch, no API keys, works through the relay with an SDK token
+   * that carries the runner-auth scope.
+   */
+  static async startRunnerBrowserAuth(
+    runner: string,
+  ): Promise<import('./types').RunnerBrowserAuthSession> {
+    if (!p2pClient) {
+      throw new Error('Not connected to any agent. Select a machine first.');
+    }
+    return p2pClient.startRunnerBrowserAuth(runner);
+  }
+
+  static async getRunnerBrowserAuthStatus(
+    sessionId: string,
+  ): Promise<import('./types').RunnerBrowserAuthSession> {
+    if (!p2pClient) throw new Error('Not connected to any agent.');
+    return p2pClient.getRunnerBrowserAuthStatus(sessionId);
+  }
+
+  static async cancelRunnerBrowserAuth(sessionId: string): Promise<void> {
+    if (!p2pClient) return;
+    await p2pClient.cancelRunnerBrowserAuth(sessionId);
+  }
+
   /**
    * Sign out: clear cached token + device, tear down the P2P client. The
    * SDK stays enabled; the next feedback trigger will re-prompt for login.
@@ -450,47 +482,64 @@ export class YaverFeedback {
     if (!enabled) {
       return;
     }
+    if (reportLaunchInFlight) {
+      return;
+    }
 
-    // If the caller has autoLogin enabled and we have no session yet, show
-    // the in-SDK login flow instead of a failing discovery + warning spam.
-    if (!config.authToken) {
-      if (config.autoLogin !== false) {
-        await YaverFeedback.hydrateSession();
-      }
+    reportLaunchInFlight = true;
+    const { DeviceEventEmitter } = require('react-native');
+    DeviceEventEmitter.emit('yaverFeedback:reportLaunch', {
+      state: 'starting',
+      at: Date.now(),
+    });
+    try {
+
+      // If the caller has autoLogin enabled and we have no session yet, show
+      // the in-SDK login flow instead of a failing discovery + warning spam.
       if (!config.authToken) {
-        YaverFeedback.showLogin();
-        return;
+        if (config.autoLogin !== false) {
+          await YaverFeedback.hydrateSession();
+        }
+        if (!config.authToken) {
+          YaverFeedback.showLogin();
+          return;
+        }
       }
-    }
 
-    // Auto-discover if no agent URL was provided
-    if (!config.agentUrl) {
-      try {
-        const result = await YaverDiscovery.discover({
-          convexUrl: config.convexUrl,
-          authToken: config.authToken,
-          preferredDeviceId: config.preferredDeviceId,
-        });
-        if (result) {
-          config.agentUrl = result.url;
-          await YaverFeedback.rebuildP2PClient(result.url);
-        } else if (config.autoLogin !== false && !config.preferredDeviceId) {
-          // No agent discovered and no device picked yet — prompt the user
-          // to pick one of their machines (handles the non-LAN case where
-          // relay discovery requires knowing which deviceId to target).
-          YaverFeedback.showMachinePicker();
-          return;
-        } else {
-          console.warn('[YaverFeedback] No agent found. Check that `yaver serve` is running on the selected machine.');
+      // Auto-discover if no agent URL was provided
+      if (!config.agentUrl) {
+        try {
+          const result = await YaverDiscovery.discover({
+            convexUrl: config.convexUrl,
+            authToken: config.authToken,
+            preferredDeviceId: config.preferredDeviceId,
+          });
+          if (result) {
+            config.agentUrl = result.url;
+            await YaverFeedback.rebuildP2PClient(result.url);
+          } else if (config.autoLogin !== false && !config.preferredDeviceId) {
+            // No agent discovered and no device picked yet — prompt the user
+            // to pick one of their machines (handles the non-LAN case where
+            // relay discovery requires knowing which deviceId to target).
+            YaverFeedback.showMachinePicker();
+            return;
+          } else {
+            console.warn('[YaverFeedback] No agent found. Check that `yaver serve` is running on the selected machine.');
+          }
+        } catch (err) {
+          console.warn('[YaverFeedback] Auto-discovery failed:', err);
         }
-      } catch (err) {
-        console.warn('[YaverFeedback] Auto-discovery failed:', err);
       }
-    }
 
-    // Emit event that the FeedbackModal listens for
-    const { DeviceEventEmitter } = require('react-native');
-    DeviceEventEmitter.emit('yaverFeedback:startReport');
+      // Emit event that the FeedbackModal listens for
+      DeviceEventEmitter.emit('yaverFeedback:startReport');
+    } finally {
+      reportLaunchInFlight = false;
+      DeviceEventEmitter.emit('yaverFeedback:reportLaunch', {
+        state: 'settled',
+        at: Date.now(),
+      });
+    }
   }
 
   /** Returns true if the SDK has been initialized. */

package/src/__tests__/AuthDevices.test.ts

@@ -0,0 +1,93 @@
+import { listReachableDevices } from '../auth';
+
+const mockFetch = jest.fn();
+global.fetch = mockFetch as any;
+
+describe('auth device listing', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockFetch.mockReset();
+  });
+
+  it('keeps guest-shared devices in the shared bucket', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          devices: [
+            {
+              deviceId: 'own-1',
+              name: 'My Mac',
+              platform: 'macos',
+              isOnline: true,
+              isGuest: false,
+              quicHost: '10.0.0.10',
+              quicPort: 18080,
+              lastHeartbeat: 123,
+            },
+            {
+              deviceId: 'guest-1',
+              name: 'yaver-test-ephemeral',
+              platform: 'linux',
+              isOnline: true,
+              isGuest: true,
+              hostName: 'Kivanc Cakmak',
+              hostEmail: 'kivanc.cakmak@icloud.com',
+              accessScope: 'shared-scoped',
+              quicHost: '157.180.114.179',
+              quicPort: 18080,
+              lastHeartbeat: 456,
+            },
+          ],
+        }),
+    });
+
+    const result = await listReachableDevices('sdk-user-token');
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      expect.stringContaining('/devices/list'),
+      expect.objectContaining({
+        headers: { Authorization: 'Bearer sdk-user-token' },
+      }),
+    );
+    expect(result.owned).toHaveLength(1);
+    expect(result.shared).toHaveLength(1);
+    expect(result.owned[0].deviceId).toBe('own-1');
+    expect(result.shared[0]).toMatchObject({
+      deviceId: 'guest-1',
+      isGuest: true,
+      hostEmail: 'kivanc.cakmak@icloud.com',
+      accessScope: 'shared-scoped',
+    });
+  });
+
+  it('shows shared devices even when the guest owns no machines', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: () =>
+        Promise.resolve({
+          devices: [
+            {
+              deviceId: 'guest-only',
+              name: 'yaver-test-ephemeral',
+              platform: 'linux',
+              isOnline: true,
+              isGuest: true,
+              hostName: 'Kivanc Cakmak',
+              hostEmail: 'kivanc.cakmak@icloud.com',
+              accessScope: 'shared-scoped',
+              quicHost: '157.180.114.179',
+              quicPort: 18080,
+              lastHeartbeat: 789,
+            },
+          ],
+        }),
+    });
+
+    const result = await listReachableDevices('guest-only-token');
+
+    expect(result.owned).toEqual([]);
+    expect(result.shared).toHaveLength(1);
+    expect(result.shared[0].deviceId).toBe('guest-only');
+  });
+});

package/src/auth.ts

@@ -435,6 +435,11 @@ export interface DeviceList {
   shared: RemoteDevice[];
 }
 
+export interface DeviceReachability {
+  reachable: boolean;
+  url?: string;
+}
+
 export interface GuestInvitation {
   hostUserId: string;
   hostName: string;
@@ -536,6 +541,47 @@ export async function listReachableDevices(
   }
 }
 
+export function buildDeviceCandidateUrls(device: RemoteDevice): string[] {
+  const port = device.httpPort ?? device.quicPort ?? 18080;
+  const hosts = new Set<string>();
+  if (device.quicHost) hosts.add(device.quicHost);
+  for (const ip of device.localIps ?? []) {
+    if (ip) hosts.add(ip);
+  }
+  return Array.from(hosts).map((host) => `http://${host}:${port}`);
+}
+
+export async function probeDeviceReachability(
+  device: RemoteDevice,
+  timeoutMs = 2500,
+): Promise<DeviceReachability> {
+  const candidates = buildDeviceCandidateUrls(device);
+  if (candidates.length === 0) return { reachable: false };
+
+  const probeOne = async (baseUrl: string): Promise<string> => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(`${baseUrl}/health`, {
+        method: 'GET',
+        signal: controller.signal,
+      });
+      if (!response.ok) throw new Error(`health ${response.status}`);
+      return baseUrl;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+
+  const settled = await Promise.allSettled(candidates.map((url) => probeOne(url)));
+  for (const result of settled) {
+    if (result.status === 'fulfilled') {
+      return { reachable: true, url: result.value };
+    }
+  }
+  return { reachable: false };
+}
+
 export async function mintGuestSdkToken(
   token: string,
   hostUserId: string,

package/src/types.ts

@@ -1,3 +1,25 @@
+/**
+ * Remote browser-style sign-in session for a coding-agent CLI on the
+ * connected yaver host. Mirrors runnerBrowserAuthSession on the agent
+ * Go side. Progression: starting → awaiting_browser (openUrl + code
+ * filled) → completed | failed | cancelled.
+ */
+export interface RunnerBrowserAuthSession {
+  id: string;
+  runner: string;
+  method: string;
+  status: 'starting' | 'awaiting_browser' | 'completed' | 'failed' | 'cancelled';
+  openUrl?: string;
+  code?: string;
+  detail?: string;
+  authConfigured?: boolean;
+  authSource?: string;
+  error?: string;
+  startedAt: number;
+  updatedAt: number;
+  completedAt?: number;
+}
+
 export interface FeedbackConfig {
   /** URL of the Yaver agent (e.g. "http://192.168.1.10:18080"). If omitted, auto-discovery is used. */
   agentUrl?: string;