yaver-feedback-react-native 0.7.0 → 0.7.1

package/dist/Discovery.d.ts

@@ -5,55 +5,68 @@ export interface DiscoveryResult {
     latency: number;
 }
 /**
- * Device discovery for finding Yaver agents on the local network or via Convex.
+ * Device discovery for finding Yaver agents.
  *
- * Three discovery strategies (tried in order):
- * 1. **Convex cloud** — fetch agent IP from Convex `/devices/list` (for cloud machines)
- * 2. **Stored connection** — try cached URL from last successful connection
- * 3. **LAN scan** — probe common LAN IPs via `/health` endpoint
+ * **Convex is the primary source of truth.** The user's Convex account
+ * has the freshest IP / port for each registered agent, updated every
+ * 2 minutes via heartbeat. The SDK should therefore:
+ *   1. On every `discover()` call, re-query Convex for the latest IP
+ *      (no local cache shortcut when `convexUrl` + `authToken` are
+ *      available).
+ *   2. Dedup the returned list (Convex can carry stale rows after
+ *      re-pair) and pick the freshest online machine.
+ *   3. Probe the machine's `quicHost:httpPort` directly.
+ *   4. If the direct probe fails (different LAN / roaming), route
+ *      through the configured relay.
+ *   5. Store the successful URL only AFTER the probe confirms it's
+ *      reachable. Stored cache is used only as a last-chance shortcut
+ *      when Convex itself is unreachable.
+ *
+ * Compared to the previous implementation this removes the "trust
+ * stored URL first" shortcut that caused the SDK to keep trying a dead
+ * cached IP long after the Mac's IP rotated.
  */
 export declare class YaverDiscovery {
-    /**
-     * Discover an agent. Tries Convex cloud first (if configured),
-     * then stored connection, then LAN scan.
-     */
     static discover(options?: {
         convexUrl?: string;
         authToken?: string;
         preferredDeviceId?: string;
     }): Promise<DiscoveryResult | null>;
     /**
-     * Fetch the agent URL from Convex device list or cloud machines.
-     * No hardcoded IPs needed — Convex knows where the agent is.
+     * Re-query Convex ignoring any cached URL. Intended for the call
+     * site right after a probe/network failure — it's the "the IP
+     * probably changed, ask the source of truth again" path.
      */
-    static discoverFromConvex(convexUrl: string, authToken: string, preferredDeviceId?: string): Promise<DiscoveryResult | null>;
+    static refreshFromConvex(options: {
+        convexUrl: string;
+        authToken: string;
+        preferredDeviceId?: string;
+    }): Promise<DiscoveryResult | null>;
     /**
-     * Discover agent via relay HTTP proxy.
-     * Fetches relay server list from Convex platformConfig, then probes
-     * `{relayHttpUrl}/d/{deviceId}/health` to reach the agent over the internet.
+     * Fetch the agent URL from Convex. Dedups rows, prefers fresh ones,
+     * falls back to relay if the direct LAN IP isn't reachable.
      */
-    static discoverViaRelay(convexUrl: string, authToken: string, deviceId: string): Promise<DiscoveryResult | null>;
+    static discoverFromConvex(convexUrl: string, authToken: string, preferredDeviceId?: string): Promise<DiscoveryResult | null>;
     /**
-     * Probe with extra headers (e.g. relay password).
+     * Race `/health` probes across N URLs in parallel. First 200 wins;
+     * everything else is abandoned. Mirrors the mobile app's
+     * `raceDirectCandidates` pattern — the single most reliable thing it
+     * does on same-LAN.
      */
-    static probeWithHeaders(url: string, headers: Record<string, string>): Promise<DiscoveryResult | null>;
+    static raceProbe(urls: string[]): Promise<DiscoveryResult | null>;
     /**
-     * Probe a specific URL for a running Yaver agent.
-     * Hits the `/health` endpoint with a 2s timeout.
+     * Discover agent via relay HTTP proxy. Uses the user's configured
+     * relay first (from `/auth/validate`), then the platform relay list.
      */
+    static discoverViaRelay(convexUrl: string, authToken: string, deviceId: string): Promise<DiscoveryResult | null>;
+    static probeWithHeaders(url: string, headers: Record<string, string>): Promise<DiscoveryResult | null>;
+    /** Probe a specific URL for a running Yaver agent (2.5 s timeout). */
     static probe(url: string): Promise<DiscoveryResult | null>;
-    /**
-     * Manually connect to a specific agent URL.
-     * Probes the URL and stores the connection if successful.
-     */
     static connect(url: string): Promise<DiscoveryResult | null>;
-    /** Get the cached agent connection from storage. */
     static getStored(): Promise<{
         url: string;
         hostname: string;
     } | null>;
-    /** Store a successful discovery result. */
     static store(result: DiscoveryResult): Promise<void>;
-    /** Clear the stored agent connection. */
     static clear(): Promise<void>;
 }

package/dist/Discovery.js

@@ -14,27 +14,43 @@ function getAsyncStorage() {
         return null;
     }
 }
+const deviceDedup_1 = require("./deviceDedup");
 const STORAGE_KEY = 'yaver_feedback_agent';
 const DEFAULT_PORT = 18080;
-const TIMEOUT_MS = 2000;
-// Common LAN subnets and host suffixes to scan
-const SUBNETS = ['192.168.1', '192.168.0', '10.0.0', '10.0.1'];
-const HOST_SUFFIXES = [1, 2, 50, 100, 101, 200];
+const PROBE_TIMEOUT_MS = 2500;
+const RELAY_PROBE_TIMEOUT_MS = 6000;
+// LAN fallback sweep used ONLY when Convex lookup fails AND the stored
+// cache probe fails. Keep tight — covers 192.168.1/0.x and 10.0.0/1.x
+// with a handful of common host suffixes. The primary path is always
+// Convex.
+const LAN_SUBNETS = ['192.168.1', '192.168.0', '10.0.0', '10.0.1'];
+const LAN_HOST_SUFFIXES = [1, 2, 50, 100, 101, 200];
 /**
- * Device discovery for finding Yaver agents on the local network or via Convex.
+ * Device discovery for finding Yaver agents.
  *
- * Three discovery strategies (tried in order):
- * 1. **Convex cloud** — fetch agent IP from Convex `/devices/list` (for cloud machines)
- * 2. **Stored connection** — try cached URL from last successful connection
- * 3. **LAN scan** — probe common LAN IPs via `/health` endpoint
+ * **Convex is the primary source of truth.** The user's Convex account
+ * has the freshest IP / port for each registered agent, updated every
+ * 2 minutes via heartbeat. The SDK should therefore:
+ *   1. On every `discover()` call, re-query Convex for the latest IP
+ *      (no local cache shortcut when `convexUrl` + `authToken` are
+ *      available).
+ *   2. Dedup the returned list (Convex can carry stale rows after
+ *      re-pair) and pick the freshest online machine.
+ *   3. Probe the machine's `quicHost:httpPort` directly.
+ *   4. If the direct probe fails (different LAN / roaming), route
+ *      through the configured relay.
+ *   5. Store the successful URL only AFTER the probe confirms it's
+ *      reachable. Stored cache is used only as a last-chance shortcut
+ *      when Convex itself is unreachable.
+ *
+ * Compared to the previous implementation this removes the "trust
+ * stored URL first" shortcut that caused the SDK to keep trying a dead
+ * cached IP long after the Mac's IP rotated.
  */
 class YaverDiscovery {
-    /**
-     * Discover an agent. Tries Convex cloud first (if configured),
-     * then stored connection, then LAN scan.
-     */
     static async discover(options) {
-        // Strategy 1: Convex cloud discovery (for cloud machines)
+        // Strategy 1: Convex — always tried first when credentials are
+        // available. No cache shortcut.
         if (options?.convexUrl && options?.authToken) {
             const result = await YaverDiscovery.discoverFromConvex(options.convexUrl, options.authToken, options.preferredDeviceId);
             if (result) {
@@ -42,19 +58,22 @@ class YaverDiscovery {
                 return result;
             }
         }
-        // Strategy 2: Try stored connection
+        // Strategy 2: Stored URL. Only used as a fallback when Convex was
+        // unreachable. A successful probe here means either the mobile is
+        // offline or Convex is — we'll trust the stored IP.
         const stored = await YaverDiscovery.getStored();
         if (stored) {
             const result = await YaverDiscovery.probe(stored.url);
-            if (result) {
+            if (result)
                 return result;
-            }
             await YaverDiscovery.clear();
         }
-        // Strategy 3: Scan common LAN IPs in parallel
+        // Strategy 3: LAN fallback. Small sweep of common subnets. This is
+        // only hit when the user has no Convex session (device-local mode)
+        // or both Convex + cache lookups failed.
         const candidates = [];
-        for (const subnet of SUBNETS) {
-            for (const suffix of HOST_SUFFIXES) {
+        for (const subnet of LAN_SUBNETS) {
+            for (const suffix of LAN_HOST_SUFFIXES) {
                 candidates.push(`http://${subnet}.${suffix}:${DEFAULT_PORT}`);
             }
         }
@@ -68,13 +87,26 @@ class YaverDiscovery {
         return null;
     }
     /**
-     * Fetch the agent URL from Convex device list or cloud machines.
-     * No hardcoded IPs needed — Convex knows where the agent is.
+     * Re-query Convex ignoring any cached URL. Intended for the call
+     * site right after a probe/network failure — it's the "the IP
+     * probably changed, ask the source of truth again" path.
+     */
+    static async refreshFromConvex(options) {
+        await YaverDiscovery.clear();
+        const result = await YaverDiscovery.discoverFromConvex(options.convexUrl, options.authToken, options.preferredDeviceId);
+        if (result)
+            await YaverDiscovery.store(result);
+        return result;
+    }
+    /**
+     * Fetch the agent URL from Convex. Dedups rows, prefers fresh ones,
+     * falls back to relay if the direct LAN IP isn't reachable.
      */
     static async discoverFromConvex(convexUrl, authToken, preferredDeviceId) {
         const base = convexUrl.replace(/\/$/, '');
         try {
-            // Try cloud machines first (CPU/GPU managed machines)
+            // Try cloud machines first (CPU/GPU managed machines). These are
+            // long-lived with stable IPs so the direct probe is cheap.
             const machinesRes = await fetch(`${base}/machines`, {
                 headers: { Authorization: `Bearer ${authToken}` },
             });
@@ -88,27 +120,71 @@ class YaverDiscovery {
                         return probed;
                 }
             }
-            // Fall back to device list (personal machines registered with Convex)
+            // Fall back to personal devices registered in Convex.
             const devicesRes = await fetch(`${base}/devices/list`, {
                 headers: { Authorization: `Bearer ${authToken}` },
             });
             if (!devicesRes.ok)
                 return null;
             const data = await devicesRes.json();
-            const devices = data.devices ?? data ?? [];
-            // Find preferred device or first online one
-            const target = preferredDeviceId
-                ? devices.find((d) => d.deviceId === preferredDeviceId)
-                : devices.find((d) => d.isOnline);
-            if (!target?.quicHost)
+            const rawList = Array.isArray(data?.devices) ? data.devices : data;
+            if (!Array.isArray(rawList) || rawList.length === 0)
+                return null;
+            // Normalise Convex fields → RemoteDevice shape so dedup works the
+            // same way `listReachableDevices` does it.
+            const normalised = rawList.map((d) => ({
+                deviceId: d.deviceId ?? d.id,
+                name: d.name ?? '',
+                platform: d.platform ?? d.os ?? '',
+                isOnline: !!d.isOnline,
+                needsAuth: !!d.needsAuth,
+                runnerDown: !!d.runnerDown,
+                lastHeartbeat: d.lastHeartbeat ?? 0,
+                isGuest: !!d.isGuest,
+                hostName: d.hostName,
+                hostEmail: d.hostEmail,
+                accessScope: d.accessScope ?? 'owner',
+                quicHost: d.quicHost ?? d.host ?? '',
+                quicPort: d.quicPort ?? 0,
+                httpPort: d.httpPort ?? d.quicPort,
+                publicKey: d.publicKey,
+                hwid: d.hardwareId ?? d.hwid,
+                localIps: Array.isArray(d.localIps)
+                    ? d.localIps
+                    : Array.isArray(d.lanIps)
+                        ? d.lanIps
+                        : undefined,
+            }));
+            const deduped = (0, deviceDedup_1.collapseRemoteDevices)(normalised);
+            const target = (0, deviceDedup_1.pickTargetDevice)(deduped, preferredDeviceId);
+            if (!target)
                 return null;
-            // Try direct connection first (same LAN)
-            const port = target.httpPort ?? DEFAULT_PORT;
-            const directUrl = `http://${target.quicHost}:${port}`;
-            const directResult = await YaverDiscovery.probe(directUrl);
-            if (directResult)
-                return directResult;
-            // Direct connection failed — try via HTTP relay (off-LAN)
+            // Build the same candidate set the Yaver mobile app races on: the
+            // primary `quicHost` plus every LAN IP reported in the latest
+            // heartbeat (`localIps`). Multi-homed hosts commonly advertise
+            // en0 + utun (tailscale) + docker0 etc.; probing all of them in
+            // parallel makes the SDK "just work" on the same Wi-Fi without
+            // depending on which NIC the user's router DHCP'd them from.
+            const port = target.httpPort ?? target.quicPort ?? DEFAULT_PORT;
+            const ipSet = new Set();
+            if (target.quicHost)
+                ipSet.add(target.quicHost);
+            for (const ip of target.localIps ?? []) {
+                if (ip)
+                    ipSet.add(ip);
+            }
+            const candidates = Array.from(ipSet).map((ip) => `http://${ip}:${port}`);
+            if (candidates.length > 0) {
+                const direct = await YaverDiscovery.raceProbe(candidates);
+                if (direct)
+                    return direct;
+            }
+            // Warn if the chosen target looks stale — informative only; we
+            // still fell through to the relay path below.
+            const stale = target.lastHeartbeat &&
+                Date.now() - target.lastHeartbeat > deviceDedup_1.HEARTBEAT_STALE_MS;
+            void stale;
+            // Direct probes all failed — route through relay.
             const relayResult = await YaverDiscovery.discoverViaRelay(base, authToken, target.deviceId);
             if (relayResult)
                 return relayResult;
@@ -119,13 +195,51 @@ class YaverDiscovery {
         }
     }
     /**
-     * Discover agent via relay HTTP proxy.
-     * Fetches relay server list from Convex platformConfig, then probes
-     * `{relayHttpUrl}/d/{deviceId}/health` to reach the agent over the internet.
+     * Race `/health` probes across N URLs in parallel. First 200 wins;
+     * everything else is abandoned. Mirrors the mobile app's
+     * `raceDirectCandidates` pattern — the single most reliable thing it
+     * does on same-LAN.
+     */
+    static async raceProbe(urls) {
+        if (!urls || urls.length === 0)
+            return null;
+        const attempts = urls.map((url) => YaverDiscovery.probe(url).then((r) => {
+            if (!r)
+                throw new Error('no-200');
+            return r;
+        }));
+        try {
+            // `Promise.any` isn't on every RN runtime yet (older Hermes).
+            // Hand-roll the same behaviour so we don't need a polyfill.
+            return await new Promise((resolve) => {
+                let remaining = attempts.length;
+                let settled = false;
+                attempts.forEach((p) => {
+                    p.then((r) => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        resolve(r);
+                    }).catch(() => {
+                        remaining -= 1;
+                        if (remaining <= 0 && !settled) {
+                            settled = true;
+                            resolve(null);
+                        }
+                    });
+                });
+            });
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Discover agent via relay HTTP proxy. Uses the user's configured
+     * relay first (from `/auth/validate`), then the platform relay list.
      */
     static async discoverViaRelay(convexUrl, authToken, deviceId) {
         try {
-            // Fetch relay server list from user settings first, then platform config
             const settingsRes = await fetch(`${convexUrl}/auth/validate`, {
                 headers: { Authorization: `Bearer ${authToken}` },
             });
@@ -136,7 +250,6 @@ class YaverDiscovery {
                 relayUrl = settingsData.relayUrl;
                 relayPassword = settingsData.relayPassword;
             }
-            // If no user-level relay, fetch platform relay servers
             if (!relayUrl) {
                 const configRes = await fetch(`${convexUrl}/platform-config?key=relay_servers`);
                 if (configRes.ok) {
@@ -145,36 +258,29 @@ class YaverDiscovery {
                         ? JSON.parse(configData.value)
                         : configData.value;
                     if (Array.isArray(servers) && servers.length > 0) {
-                        // Pick the first (highest priority) relay with an httpUrl
                         const relay = servers.find((s) => s.httpUrl);
-                        if (relay) {
+                        if (relay)
                             relayUrl = relay.httpUrl;
-                        }
                     }
                 }
             }
             if (!relayUrl)
                 return null;
-            // Probe agent through relay: {relayHttpUrl}/d/{deviceId}/health
             const relayBase = `${relayUrl.replace(/\/$/, '')}/d/${deviceId}`;
-            const result = await YaverDiscovery.probeWithHeaders(relayBase, {
+            return YaverDiscovery.probeWithHeaders(relayBase, {
                 'X-Relay-Password': relayPassword || '',
             });
-            return result;
         }
         catch {
             return null;
         }
     }
-    /**
-     * Probe with extra headers (e.g. relay password).
-     */
     static async probeWithHeaders(url, headers) {
         const base = url.replace(/\/$/, '');
         const start = Date.now();
         try {
             const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), TIMEOUT_MS + 3000); // relay adds latency
+            const timeoutId = setTimeout(() => controller.abort(), RELAY_PROBE_TIMEOUT_MS);
             const response = await fetch(`${base}/health`, {
                 method: 'GET',
                 headers,
@@ -192,7 +298,7 @@ class YaverDiscovery {
                 version = data.version ?? 'unknown';
             }
             catch {
-                // Health endpoint might return plain text
+                // /health may return plain text
             }
             return { url: base, hostname, version, latency };
         }
@@ -200,24 +306,20 @@ class YaverDiscovery {
             return null;
         }
     }
-    /**
-     * Probe a specific URL for a running Yaver agent.
-     * Hits the `/health` endpoint with a 2s timeout.
-     */
+    /** Probe a specific URL for a running Yaver agent (2.5 s timeout). */
     static async probe(url) {
         const base = url.replace(/\/$/, '');
         const start = Date.now();
         try {
             const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), TIMEOUT_MS);
+            const timeoutId = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
             const response = await fetch(`${base}/health`, {
                 method: 'GET',
                 signal: controller.signal,
             });
             clearTimeout(timeoutId);
-            if (!response.ok) {
+            if (!response.ok)
                 return null;
-            }
             const latency = Date.now() - start;
             let hostname = 'Unknown';
             let version = 'unknown';
@@ -227,7 +329,7 @@ class YaverDiscovery {
                 version = data.version ?? 'unknown';
             }
             catch {
-                // Health endpoint might return plain text — that's fine
+                // /health may return plain text
             }
             return { url: base, hostname, version, latency };
         }
@@ -235,18 +337,12 @@ class YaverDiscovery {
             return null;
         }
     }
-    /**
-     * Manually connect to a specific agent URL.
-     * Probes the URL and stores the connection if successful.
-     */
     static async connect(url) {
         const result = await YaverDiscovery.probe(url);
-        if (result) {
+        if (result)
             await YaverDiscovery.store(result);
-        }
         return result;
     }
-    /** Get the cached agent connection from storage. */
     static async getStored() {
         const storage = getAsyncStorage();
         if (!storage)
@@ -265,7 +361,6 @@ class YaverDiscovery {
             return null;
         }
     }
-    /** Store a successful discovery result. */
     static async store(result) {
         const storage = getAsyncStorage();
         if (!storage)
@@ -277,7 +372,6 @@ class YaverDiscovery {
             // Storage failure is non-fatal
         }
     }
-    /** Clear the stored agent connection. */
     static async clear() {
         const storage = getAsyncStorage();
         if (!storage)

package/dist/FeedbackModal.js

@@ -75,17 +75,44 @@ const FeedbackModal = () => {
         setToast(null);
         setAction('idle');
     }, []);
-    // ─── 1. Hot reload ─────────────────────────────────────────────────
-    const handleHotReload = (0, react_1.useCallback)(async () => {
-        const client = YaverFeedback_1.YaverFeedback.getP2PClient();
+    // Helper: run a P2P call; on network failure, ask YaverFeedback to
+    // re-query Convex for the fresh IP and retry once. Solves the common
+    // case where the Mac's LAN IP rotated while the SDK held a stale URL.
+    const runWithReconnect = (0, react_1.useCallback)(async (fn) => {
+        let client = YaverFeedback_1.YaverFeedback.getP2PClient();
         if (!client) {
-            setError('Not connected to the agent yet.');
-            return;
+            const ok = await YaverFeedback_1.YaverFeedback.reconnect();
+            if (ok)
+                client = YaverFeedback_1.YaverFeedback.getP2PClient();
+        }
+        if (!client) {
+            throw new Error('Not connected to the agent yet.');
         }
+        try {
+            await fn(client);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const transient = /Network request failed|timeout|ECONNREFUSED|Failed to fetch|fetch failed|aborted/i.test(msg);
+            if (!transient)
+                throw err;
+            const ok = await YaverFeedback_1.YaverFeedback.reconnect();
+            if (!ok)
+                throw err;
+            const fresh = YaverFeedback_1.YaverFeedback.getP2PClient();
+            if (!fresh)
+                throw err;
+            await fn(fresh);
+        }
+    }, []);
+    // ─── 1. Hot reload ─────────────────────────────────────────────────
+    const handleHotReload = (0, react_1.useCallback)(async () => {
         setAction('hot-reloading');
         setError(null);
         try {
-            await client.reloadApp('dev');
+            await runWithReconnect(async (client) => {
+                await client.reloadApp('dev');
+            });
             setToast('Reload sent');
             closeSoon(800);
         }
@@ -96,7 +123,7 @@ const FeedbackModal = () => {
             if (mountedRef.current)
                 setAction('idle');
         }
-    }, [closeSoon]);
+    }, [closeSoon, runWithReconnect]);
     // ─── 2. Screenshot + Fix ───────────────────────────────────────────
     //
     // Hide the modal first so the screenshot captures the actual screen

package/dist/MachinePickerScreen.js

@@ -79,7 +79,11 @@ const YaverMachinePickerScreen = ({ token, currentDeviceId, onPick, onCancel, })
     };
     const renderDevice = (device) => {
         const selected = device.deviceId === currentDeviceId;
-        const stale = Date.now() - device.lastHeartbeat > 60000;
+        // Match the Yaver mobile app: HEARTBEAT_STALE_MS is 90 s. Using
+        // 60 s here flashed yellow on a single missed agent beat even
+        // though the Mac was up.
+        const stale = device.lastHeartbeat > 0 &&
+            Date.now() - device.lastHeartbeat > 90000;
         const healthColor = !device.isOnline
             ? '#ef4444'
             : device.needsAuth || device.runnerDown || stale

package/dist/YaverFeedback.d.ts

@@ -19,6 +19,16 @@ export declare class YaverFeedback {
      * Sets config.agentUrl and creates P2PClient on success.
      */
     static discoverAgent(): Promise<void>;
+    /**
+     * Force a fresh Convex lookup for the agent URL — ignoring any
+     * cached URL. Callers use this after a P2P request fails
+     * (connection refused / timeout) because the most common cause is
+     * the Mac's LAN IP rotating. Convex has the fresh one, so we
+     * re-query and probe `[quicHost, ...localIps]` in parallel.
+     *
+     * Returns true when a new URL was adopted.
+     */
+    static reconnect(): Promise<boolean>;
     /**
      * Pull a cached session token + selected device from AsyncStorage (populated
      * by the in-SDK login + machine-picker screens). When present the SDK can

package/dist/YaverFeedback.js

@@ -188,6 +188,36 @@ class YaverFeedback {
             // Discovery failed — FloatingButton will show disconnected, user can retry
         }
     }
+    /**
+     * Force a fresh Convex lookup for the agent URL — ignoring any
+     * cached URL. Callers use this after a P2P request fails
+     * (connection refused / timeout) because the most common cause is
+     * the Mac's LAN IP rotating. Convex has the fresh one, so we
+     * re-query and probe `[quicHost, ...localIps]` in parallel.
+     *
+     * Returns true when a new URL was adopted.
+     */
+    static async reconnect() {
+        if (!config || !enabled)
+            return false;
+        if (!config.authToken || !config.convexUrl)
+            return false;
+        try {
+            const result = await Discovery_1.YaverDiscovery.refreshFromConvex({
+                convexUrl: config.convexUrl,
+                authToken: config.authToken,
+                preferredDeviceId: config.preferredDeviceId,
+            });
+            if (!result)
+                return false;
+            config.agentUrl = result.url;
+            p2pClient = new P2PClient_1.P2PClient(result.url, config.authToken ?? '');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * Pull a cached session token + selected device from AsyncStorage (populated
      * by the in-SDK login + machine-picker screens). When present the SDK can

package/dist/auth.d.ts

@@ -105,7 +105,17 @@ export interface RemoteDevice {
     accessScope: 'owner' | 'shared-scoped' | 'shared-legacy';
     quicHost: string;
     quicPort: number;
+    /** Agent HTTP port — preferred over quicPort when present. */
+    httpPort?: number;
     publicKey?: string;
+    /** Hardware identifier — used for dedup across re-pair events. */
+    hwid?: string;
+    /**
+     * Every LAN IP the agent reported in its last heartbeat. Useful on
+     * multi-homed hosts — probing all of them in parallel is the same
+     * trick the Yaver mobile app uses to "just work" on the same Wi-Fi.
+     */
+    localIps?: string[];
 }
 export interface DeviceList {
     owned: RemoteDevice[];
@@ -114,5 +124,9 @@ export interface DeviceList {
 /**
  * Fetch the set of remote dev machines this user can reach. Splits into
  * owned (user is the host) vs shared (host invited them as a guest).
+ *
+ * Collapses duplicate rows before splitting — Convex can return multiple
+ * rows per physical machine after a re-pair or hostname change, and the
+ * raw list used to render as "Kvancs-MacBook-Air.local ×3" in the picker.
  */
 export declare function listReachableDevices(token: string): Promise<DeviceList>;