yaver-feedback-react-native 0.8.4 → 0.8.7

package/dist/QuickActionIcon.js

@@ -115,6 +115,7 @@ const QuickActionIcon = ({ color: colorProp, backgroundColor: backgroundColorPro
     const [shakenThisSession, setShakenThisSession] = (0, react_1.useState)(false);
     const [menuOpen, setMenuOpen] = (0, react_1.useState)(false);
     const [hostSuppressed] = (0, react_1.useState)(() => isRunningInsideYaverHost());
+    const [launching, setLaunching] = (0, react_1.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
     // be worse than a tiny delayed appearance.
@@ -162,6 +163,24 @@ const QuickActionIcon = ({ color: colorProp, backgroundColor: backgroundColorPro
             colorSub.remove();
         };
     }, []);
+    (0, react_1.useEffect)(() => {
+        const launchSub = react_native_1.DeviceEventEmitter.addListener('yaverFeedback:reportLaunch', (event) => {
+            if (event?.state === 'starting') {
+                setLaunching(true);
+                return;
+            }
+            setLaunching(false);
+        });
+        const reportSub = react_native_1.DeviceEventEmitter.addListener('yaverFeedback:startReport', () => setLaunching(false));
+        const loginSub = react_native_1.DeviceEventEmitter.addListener('yaverFeedback:startLogin', () => setLaunching(false));
+        const pickerSub = react_native_1.DeviceEventEmitter.addListener('yaverFeedback:startMachinePicker', () => setLaunching(false));
+        return () => {
+            launchSub.remove();
+            reportSub.remove();
+            loginSub.remove();
+            pickerSub.remove();
+        };
+    }, []);
     const panResponder = (0, react_1.useRef)(react_native_1.PanResponder.create({
         onStartShouldSetPanResponder: () => true,
         onMoveShouldSetPanResponder: (_, g) => Math.abs(g.dx) > 3 || Math.abs(g.dy) > 3,
@@ -195,9 +214,11 @@ const QuickActionIcon = ({ color: colorProp, backgroundColor: backgroundColorPro
         },
     })).current;
     const openFeedback = (0, react_1.useCallback)(() => {
+        if (launching)
+            return;
         setMenuOpen(false);
         void YaverFeedback_1.YaverFeedback.startReport();
-    }, []);
+    }, [launching]);
     const hideForever = (0, react_1.useCallback)(() => {
         setMenuOpen(false);
         setUserDisabled(true);
@@ -233,10 +254,14 @@ const QuickActionIcon = ({ color: colorProp, backgroundColor: backgroundColorPro
                 didDrag.current = false;
                 return;
             }
+            if (launching)
+                return;
             openFeedback();
         }} onLongPress={() => {
             if (didDrag.current)
                 return;
+            if (launching)
+                return;
             setMenuOpen((m) => !m);
         }} delayLongPress={LONG_PRESS_MS} hitSlop={6} accessibilityRole="button" accessibilityLabel="Open Yaver feedback" style={({ pressed }) => [
             styles.icon,
@@ -247,7 +272,7 @@ const QuickActionIcon = ({ color: colorProp, backgroundColor: backgroundColorPro
                 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,
             },
         ]}>
           <react_native_1.Text style={[

package/dist/YaverFeedback.d.ts

@@ -65,6 +65,19 @@ export declare class YaverFeedback {
     static setPreferredDevice(deviceId: string): Promise<void>;
     /** Resolve the currently selected remote machine from the authenticated device list. */
     static getSelectedRemoteDevice(): Promise<import("./auth").RemoteDevice | 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 startRunnerBrowserAuth(runner: string): Promise<import('./types').RunnerBrowserAuthSession>;
+    static getRunnerBrowserAuthStatus(sessionId: string): Promise<import('./types').RunnerBrowserAuthSession>;
+    static cancelRunnerBrowserAuth(sessionId: string): Promise<void>;
     /**
      * Sign out: clear cached token + device, tear down the P2P client. The
      * SDK stays enabled; the next feedback trigger will re-prompt for login.

package/dist/YaverFeedback.js

@@ -35,6 +35,7 @@ let enabled = false;
 let p2pClient = null;
 let shakeDetector = null;
 let p2pAuthToken = null;
+let reportLaunchInFlight = false;
 /** Ring buffer of captured errors. */
 let errorBuffer = [];
 let maxErrors = 5;
@@ -396,6 +397,32 @@ class YaverFeedback {
         const all = [...devices.owned, ...devices.shared];
         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) {
+        if (!p2pClient) {
+            throw new Error('Not connected to any agent. Select a machine first.');
+        }
+        return p2pClient.startRunnerBrowserAuth(runner);
+    }
+    static async getRunnerBrowserAuthStatus(sessionId) {
+        if (!p2pClient)
+            throw new Error('Not connected to any agent.');
+        return p2pClient.getRunnerBrowserAuthStatus(sessionId);
+    }
+    static async cancelRunnerBrowserAuth(sessionId) {
+        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.
@@ -425,47 +452,64 @@ class YaverFeedback {
         if (!enabled) {
             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();
-            }
-            if (!config.authToken) {
-                YaverFeedback.showLogin();
-                return;
-            }
+        if (reportLaunchInFlight) {
+            return;
         }
-        // Auto-discover if no agent URL was provided
-        if (!config.agentUrl) {
-            try {
-                const result = await Discovery_1.YaverDiscovery.discover({
-                    convexUrl: config.convexUrl,
-                    authToken: config.authToken,
-                    preferredDeviceId: config.preferredDeviceId,
-                });
-                if (result) {
-                    config.agentUrl = result.url;
-                    await YaverFeedback.rebuildP2PClient(result.url);
+        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) {
+                if (config.autoLogin !== false) {
+                    await YaverFeedback.hydrateSession();
                 }
-                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();
+                if (!config.authToken) {
+                    YaverFeedback.showLogin();
                     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);
+            // Auto-discover if no agent URL was provided
+            if (!config.agentUrl) {
+                try {
+                    const result = await Discovery_1.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);
+                }
             }
+            // Emit event that the FeedbackModal listens for
+            DeviceEventEmitter.emit('yaverFeedback:startReport');
+        }
+        finally {
+            reportLaunchInFlight = false;
+            DeviceEventEmitter.emit('yaverFeedback:reportLaunch', {
+                state: 'settled',
+                at: Date.now(),
+            });
         }
-        // Emit event that the FeedbackModal listens for
-        const { DeviceEventEmitter } = require('react-native');
-        DeviceEventEmitter.emit('yaverFeedback:startReport');
     }
     /** Returns true if the SDK has been initialized. */
     static isInitialized() {

package/dist/__tests__/AuthDevices.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/AuthDevices.test.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const auth_1 = require("../auth");
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+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 (0, auth_1.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 (0, auth_1.listReachableDevices)('guest-only-token');
+        expect(result.owned).toEqual([]);
+        expect(result.shared).toHaveLength(1);
+        expect(result.shared[0].deviceId).toBe('guest-only');
+    });
+});

package/dist/types.d.ts

@@ -1,3 +1,79 @@
+/**
+ * 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 IncidentEvent {
+    id: string;
+    timestamp: number;
+    severity: 'info' | 'warn' | 'error' | 'fatal';
+    category: string;
+    code: string;
+    source: string;
+    title: string;
+    userMessage: string;
+    technicalInfo?: string;
+    suggestedAction?: string;
+    operationId?: string;
+    deviceId?: string;
+    projectPath?: string;
+    target?: string;
+    logsAvailable: boolean;
+    logRefs?: string[];
+    correlationId?: string;
+    recoverable: boolean;
+    metadata?: Record<string, unknown>;
+    resolved?: boolean;
+}
+export interface OperationState {
+    id: string;
+    kind: string;
+    status: string;
+    phase?: string;
+    message?: string;
+    progress?: number;
+    deviceId?: string;
+    projectPath?: string;
+    startedAt: number;
+    updatedAt: number;
+    incidentIds?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface CapabilityTargetReadiness {
+    enabled: boolean;
+    reasonCode?: string;
+    reason?: string;
+    suggestedAction?: string;
+    notes?: string[];
+}
+export interface CapabilitySnapshot {
+    generatedAt: string;
+    machine?: Record<string, unknown>;
+    infra?: Record<string, unknown>;
+    connectivity?: {
+        directAvailable?: boolean;
+        relayConfigured?: boolean;
+        tunnelConfigured?: boolean;
+        tailscaleAvailable?: boolean;
+    };
+    targets: Record<string, CapabilityTargetReadiness>;
+}
 export interface FeedbackConfig {
     /** URL of the Yaver agent (e.g. "http://192.168.1.10:18080"). If omitted, auto-discovery is used. */
     agentUrl?: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "yaver-feedback-react-native",
-  "version": "0.8.4",
-  "description": "Visual feedback SDK for Yaver — bug reports, screen recording, voice annotations, and local-first developer workflows",
+  "version": "0.8.7",
+  "description": "Visual feedback SDK for Yaver \u2014 bug reports, screen recording, voice annotations, and local-first developer workflows",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [

package/src/AuthOverlay.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useState } from 'react';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
 import { DeviceEventEmitter, Modal } from 'react-native';
 import { YaverLoginScreen } from './LoginScreen';
 import { YaverMachinePickerScreen } from './MachinePickerScreen';
@@ -26,6 +26,35 @@ export const AuthOverlay: React.FC = () => {
   const [pickerVisible, setPickerVisible] = useState(false);
   const [token, setToken] = useState<string | null>(null);
   const [pendingInviteCode, setPendingInviteCode] = useState<string | null>(null);
+  const activeOverlayRef = useRef<'none' | 'login' | 'guest' | 'picker'>('none');
+
+  const openLogin = useCallback(() => {
+    activeOverlayRef.current = 'login';
+    setGuestVisible(false);
+    setPickerVisible(false);
+    setLoginVisible(true);
+  }, []);
+
+  const openGuest = useCallback(() => {
+    activeOverlayRef.current = 'guest';
+    setLoginVisible(false);
+    setPickerVisible(false);
+    setGuestVisible(true);
+  }, []);
+
+  const openPicker = useCallback(() => {
+    activeOverlayRef.current = 'picker';
+    setLoginVisible(false);
+    setGuestVisible(false);
+    setPickerVisible(true);
+  }, []);
+
+  const closeAll = useCallback(() => {
+    activeOverlayRef.current = 'none';
+    setLoginVisible(false);
+    setGuestVisible(false);
+    setPickerVisible(false);
+  }, []);
 
   useEffect(() => {
     let mounted = true;
@@ -36,14 +65,18 @@ export const AuthOverlay: React.FC = () => {
 
     const loginSub = DeviceEventEmitter.addListener(
       'yaverFeedback:startLogin',
-      () => setLoginVisible(true),
+      () => {
+        if (activeOverlayRef.current !== 'none') return;
+        openLogin();
+      },
     );
     const pickerSub = DeviceEventEmitter.addListener(
       'yaverFeedback:startMachinePicker',
       async () => {
+        if (activeOverlayRef.current !== 'none') return;
         const cached = await getToken();
         if (cached) setToken(cached);
-        if (cached) setPickerVisible(true);
+        if (cached) openPicker();
       },
     );
     return () => {
@@ -51,24 +84,23 @@ export const AuthOverlay: React.FC = () => {
       loginSub.remove();
       pickerSub.remove();
     };
-  }, []);
+  }, [openLogin, openPicker]);
 
   const continueAfterAuth = async (newToken: string, inviteCode?: string) => {
     setToken(newToken);
     await YaverFeedback.setAuthToken(newToken);
     const devices = await listReachableDevices(newToken).catch(() => ({ owned: [], shared: [] }));
-    setLoginVisible(false);
     const cleanedInviteCode = (inviteCode ?? '').trim().toUpperCase();
     if (cleanedInviteCode) {
       setPendingInviteCode(cleanedInviteCode);
-      setGuestVisible(true);
+      openGuest();
       return;
     }
     if (devices.owned.length === 0 && devices.shared.length === 0) {
-      setGuestVisible(true);
+      openGuest();
       return;
     }
-    setPickerVisible(true);
+    openPicker();
   };
 
   const handleLoggedIn = async (newToken: string, opts?: { inviteCode?: string }) => {
@@ -77,8 +109,7 @@ export const AuthOverlay: React.FC = () => {
 
   const handleDevicePicked = async (device: RemoteDevice) => {
     await YaverFeedback.setPreferredDevice(device.deviceId);
-    setPickerVisible(false);
-    setGuestVisible(false);
+    closeAll();
     // Continue straight into the feedback flow the user originally triggered.
     DeviceEventEmitter.emit('yaverFeedback:startReport');
   };
@@ -89,11 +120,11 @@ export const AuthOverlay: React.FC = () => {
         visible={loginVisible}
         animationType="slide"
         presentationStyle="fullScreen"
-        onRequestClose={() => setLoginVisible(false)}
+        onRequestClose={closeAll}
       >
         <YaverLoginScreen
           onLoggedIn={handleLoggedIn}
-          onCancel={() => setLoginVisible(false)}
+          onCancel={closeAll}
           initialInviteCode={pendingInviteCode ?? YaverFeedback.getConfig()?.guestInviteCode}
         />
       </Modal>
@@ -102,14 +133,14 @@ export const AuthOverlay: React.FC = () => {
         visible={pickerVisible && !!token}
         animationType="slide"
         presentationStyle="fullScreen"
-        onRequestClose={() => setPickerVisible(false)}
+        onRequestClose={closeAll}
       >
         {token && (
           <YaverMachinePickerScreen
             token={token}
             currentDeviceId={YaverFeedback.getConfig()?.preferredDeviceId}
             onPick={handleDevicePicked}
-            onCancel={() => setPickerVisible(false)}
+            onCancel={closeAll}
           />
         )}
       </Modal>
@@ -118,21 +149,19 @@ export const AuthOverlay: React.FC = () => {
         visible={guestVisible && !!token}
         animationType="slide"
         presentationStyle="fullScreen"
-        onRequestClose={() => setGuestVisible(false)}
+        onRequestClose={closeAll}
       >
         {token && (
           <YaverGuestOnboardingScreen
             token={token}
             initialInviteCode={pendingInviteCode ?? YaverFeedback.getConfig()?.guestInviteCode}
             onContinue={() => {
-              setGuestVisible(false);
               setPendingInviteCode(null);
-              setPickerVisible(true);
+              openPicker();
             }}
             onCancel={() => {
-              setGuestVisible(false);
               setPendingInviteCode(null);
-              setPickerVisible(true);
+              openPicker();
             }}
           />
         )}