yaver-feedback-react-native 0.8.3 → 0.8.6

package/dist/P2PClient.js

@@ -92,9 +92,10 @@ function friendlyReloadError(status, body) {
  * support for streaming feedback, listing builds, and triggering builds.
  */
 class P2PClient {
-    constructor(baseUrl, authToken) {
+    constructor(baseUrl, authToken, relayPassword = '') {
         this.baseUrl = baseUrl.replace(/\/$/, '');
         this.authToken = authToken;
+        this.relayPassword = relayPassword;
     }
     /** Update the base URL (e.g. after re-discovery). */
     setBaseUrl(url) {
@@ -104,6 +105,56 @@ class P2PClient {
     setAuthToken(token) {
         this.authToken = token;
     }
+    /** Update the relay password (used for managed-relay baseUrls). */
+    setRelayPassword(password) {
+        this.relayPassword = password;
+    }
+    /** Merge in Authorization + (optional) X-Relay-Password on top of a header block. */
+    authHeaders(extra = {}) {
+        const h = { ...extra };
+        if (this.authToken)
+            h.Authorization = `Bearer ${this.authToken}`;
+        if (this.relayPassword)
+            h['X-Relay-Password'] = this.relayPassword;
+        return h;
+    }
+    /**
+     * Start a remote browser-style sign-in for a runner (codex --device-auth
+     * / claude auth login --console). Returns a session id; callers poll
+     * getRunnerBrowserAuthStatus to surface the verification URL + one-time
+     * code. No API keys involved — the CLI writes its own auth.json once
+     * the user completes the flow in any browser.
+     */
+    async startRunnerBrowserAuth(runner) {
+        const resp = await fetch(`${this.baseUrl}/runner-auth/browser/start`, {
+            method: 'POST',
+            headers: this.authHeaders({ 'Content-Type': 'application/json' }),
+            body: JSON.stringify({ runner }),
+        });
+        if (!resp.ok) {
+            const text = await resp.text().catch(() => '');
+            throw new Error(`startRunnerBrowserAuth(${runner}) HTTP ${resp.status}: ${text}`);
+        }
+        const data = await resp.json();
+        return data.session;
+    }
+    async getRunnerBrowserAuthStatus(sessionId) {
+        const url = `${this.baseUrl}/runner-auth/browser/status?id=${encodeURIComponent(sessionId)}`;
+        const resp = await fetch(url, { headers: this.authHeaders() });
+        if (!resp.ok) {
+            const text = await resp.text().catch(() => '');
+            throw new Error(`getRunnerBrowserAuthStatus HTTP ${resp.status}: ${text}`);
+        }
+        const data = await resp.json();
+        return data.session;
+    }
+    async cancelRunnerBrowserAuth(sessionId) {
+        const url = `${this.baseUrl}/runner-auth/browser/cancel?id=${encodeURIComponent(sessionId)}`;
+        try {
+            await fetch(url, { method: 'POST', headers: this.authHeaders() });
+        }
+        catch { /* best-effort */ }
+    }
     /** Health check — returns true if the agent is reachable. */
     async health() {
         try {
@@ -563,9 +614,7 @@ class P2PClient {
     async request(method, path) {
         const response = await fetch(`${this.baseUrl}${path}`, {
             method,
-            headers: {
-                Authorization: `Bearer ${this.authToken}`,
-            },
+            headers: this.authHeaders(),
         });
         if (!response.ok) {
             const text = await response.text().catch(() => '');

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/auth.d.ts

@@ -123,6 +123,10 @@ export interface DeviceList {
     owned: RemoteDevice[];
     shared: RemoteDevice[];
 }
+export interface DeviceReachability {
+    reachable: boolean;
+    url?: string;
+}
 export interface GuestInvitation {
     hostUserId: string;
     hostName: string;
@@ -170,6 +174,8 @@ export interface InvitationPreview {
  * raw list used to render as "Kvancs-MacBook-Air.local ×3" in the picker.
  */
 export declare function listReachableDevices(token: string): Promise<DeviceList>;
+export declare function buildDeviceCandidateUrls(device: RemoteDevice): string[];
+export declare function probeDeviceReachability(device: RemoteDevice, timeoutMs?: number): Promise<DeviceReachability>;
 export declare function mintGuestSdkToken(token: string, hostUserId: string, targetDeviceId: string): Promise<{
     token: string;
     expiresAt: number;

package/dist/auth.js

@@ -37,6 +37,8 @@ exports.signInWithOAuth = signInWithOAuth;
 exports.signupWithEmail = signupWithEmail;
 exports.loginWithEmail = loginWithEmail;
 exports.listReachableDevices = listReachableDevices;
+exports.buildDeviceCandidateUrls = buildDeviceCandidateUrls;
+exports.probeDeviceReachability = probeDeviceReachability;
 exports.mintGuestSdkToken = mintGuestSdkToken;
 exports.fetchGuestHosts = fetchGuestHosts;
 exports.findInviteByCode = findInviteByCode;
@@ -412,6 +414,45 @@ async function listReachableDevices(token) {
         return { owned: [], shared: [] };
     }
 }
+function buildDeviceCandidateUrls(device) {
+    const port = device.httpPort ?? device.quicPort ?? 18080;
+    const hosts = new Set();
+    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}`);
+}
+async function probeDeviceReachability(device, timeoutMs = 2500) {
+    const candidates = buildDeviceCandidateUrls(device);
+    if (candidates.length === 0)
+        return { reachable: false };
+    const probeOne = async (baseUrl) => {
+        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 };
+}
 async function mintGuestSdkToken(token, hostUserId, targetDeviceId) {
     const res = await fetch(`${convexSiteUrl}/guests/sdk-token`, {
         method: 'POST',

package/dist/types.d.ts

@@ -1,3 +1,24 @@
+/**
+ * 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;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "yaver-feedback-react-native",
-  "version": "0.8.3",
-  "description": "Visual feedback SDK for Yaver — bug reports, screen recording, voice annotations, and local-first developer workflows",
+  "version": "0.8.6",
+  "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();
             }}
           />
         )}