yaver-feedback-react-native 0.7.0 → 0.7.1

package/dist/auth.js

@@ -346,6 +346,10 @@ async function loginWithEmail(email, password) {
 /**
  * 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.
  */
 async function listReachableDevices(token) {
     try {
@@ -355,10 +359,39 @@ async function listReachableDevices(token) {
         if (!res.ok)
             return { owned: [], shared: [] };
         const data = await res.json();
-        const all = (data.devices ?? []);
+        const raw = (data.devices ?? []);
+        // Normalise Convex field names → SDK's RemoteDevice shape. The
+        // backend returns `localIps`, sometimes the mobile-side mapping
+        // surfaces `lanIps` — accept either so the field survives.
+        const normalised = raw.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,
+        }));
+        // Lazy require so Jest + tree-shakers don't choke on a circular import.
+        const { collapseRemoteDevices } = require('./deviceDedup');
+        const deduped = collapseRemoteDevices(normalised);
         return {
-            owned: all.filter((d) => !d.isGuest),
-            shared: all.filter((d) => d.isGuest),
+            owned: deduped.filter((d) => !d.isGuest),
+            shared: deduped.filter((d) => d.isGuest),
         };
     }
     catch {

package/dist/deviceDedup.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Device deduplication + online-signal merging, ported from the Yaver
+ * mobile app's DeviceContext.collapseAliasDevices.
+ *
+ * Convex stores one row per pair (device, re-install). After a re-pair
+ * or hostname change the list can contain 2-3 rows for the same
+ * physical machine, with different hwid/publicKey values. The picker
+ * then shows duplicates and the user can't tell which one is live.
+ *
+ * This file collapses rows in three passes:
+ *   1. Identity key (hwid → publicKey → "host:os:name" → id → name)
+ *   2. Alias key (os + normalized-hostname) — catches re-pairs that
+ *      mint a new hwid
+ *   3. Endpoint key (host:port)
+ *
+ * When collapsing, `mergeDeviceEntries` prefers: authenticated over
+ * needsAuth, online over offline, freshest lastHeartbeat.
+ */
+import type { RemoteDevice } from './auth';
+/**
+ * Collapse a Convex device list so each physical machine appears once.
+ * Safe on an empty list; idempotent on an already-deduped list.
+ */
+export declare function collapseRemoteDevices(devices: RemoteDevice[]): RemoteDevice[];
+/**
+ * Threshold for "online" based on heartbeat age, in milliseconds.
+ * Matches the mobile app (HEARTBEAT_STALE_MS = 90 s). The SDK used
+ * 60 s, which flashed yellow on single missed beats.
+ */
+export declare const HEARTBEAT_STALE_MS = 90000;
+/**
+ * Returns a freshness flag consistent with the mobile app. A device is
+ * "fresh" when it was online per Convex AND its heartbeat is within
+ * `HEARTBEAT_STALE_MS`.
+ */
+export declare function isDeviceFresh(d: RemoteDevice): boolean;
+/**
+ * Pick the best candidate for an auto-connect attempt. Preference:
+ *   1. matches the preferred deviceId when supplied + still fresh
+ *   2. fresh (online + recent heartbeat) + has a quicHost
+ *   3. online + has a quicHost
+ *   4. first with a quicHost
+ */
+export declare function pickTargetDevice(devices: RemoteDevice[], preferredDeviceId?: string): RemoteDevice | null;

package/dist/deviceDedup.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * Device deduplication + online-signal merging, ported from the Yaver
+ * mobile app's DeviceContext.collapseAliasDevices.
+ *
+ * Convex stores one row per pair (device, re-install). After a re-pair
+ * or hostname change the list can contain 2-3 rows for the same
+ * physical machine, with different hwid/publicKey values. The picker
+ * then shows duplicates and the user can't tell which one is live.
+ *
+ * This file collapses rows in three passes:
+ *   1. Identity key (hwid → publicKey → "host:os:name" → id → name)
+ *   2. Alias key (os + normalized-hostname) — catches re-pairs that
+ *      mint a new hwid
+ *   3. Endpoint key (host:port)
+ *
+ * When collapsing, `mergeDeviceEntries` prefers: authenticated over
+ * needsAuth, online over offline, freshest lastHeartbeat.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HEARTBEAT_STALE_MS = void 0;
+exports.collapseRemoteDevices = collapseRemoteDevices;
+exports.isDeviceFresh = isDeviceFresh;
+exports.pickTargetDevice = pickTargetDevice;
+function normalizedName(name) {
+    return String(name || '').trim().toLowerCase().replace(/\.local$/i, '');
+}
+function normalizedHost(host) {
+    return String(host || '').trim().toLowerCase().replace(/\.local$/i, '');
+}
+function identityKey(d) {
+    if (d.hwid)
+        return `hwid:${d.hwid}`;
+    if (d.publicKey)
+        return `pub:${d.publicKey}`;
+    if (d.isGuest) {
+        const scope = d.hostEmail || d.hostName || 'guest';
+        return `guest:${scope}:${d.deviceId || d.name}`;
+    }
+    const n = normalizedName(d.name);
+    const os = String(d.platform || '').trim().toLowerCase();
+    if (n && os)
+        return `host:${os}:${n}`;
+    if (d.deviceId)
+        return `id:${d.deviceId}`;
+    return `name:${d.name}`;
+}
+function aliasKey(d) {
+    if (d.isGuest)
+        return null;
+    const n = normalizedName(d.name);
+    const os = String(d.platform || '').trim().toLowerCase();
+    if (!n || !os)
+        return null;
+    return `${os}:${n}`;
+}
+function endpointKey(d) {
+    if (d.isGuest)
+        return null;
+    const h = normalizedHost(d.quicHost);
+    if (!h)
+        return null;
+    return `${h}:${d.quicPort || 0}`;
+}
+function mergeEntries(existing, incoming) {
+    const incomingWins = (!!existing.needsAuth && !incoming.needsAuth) ||
+        (incoming.lastHeartbeat || 0) > (existing.lastHeartbeat || 0) ||
+        (!!incoming.isOnline && !existing.isOnline);
+    const base = incomingWins ? incoming : existing;
+    const other = incomingWins ? existing : incoming;
+    return {
+        ...other,
+        ...base,
+        quicHost: base.quicHost || other.quicHost,
+        quicPort: base.quicPort || other.quicPort,
+        isOnline: base.isOnline || other.isOnline,
+        runnerDown: base.runnerDown && other.runnerDown,
+        publicKey: base.publicKey || other.publicKey,
+        lastHeartbeat: Math.max(existing.lastHeartbeat || 0, incoming.lastHeartbeat || 0),
+    };
+}
+// When two rows share the same alias key (hostname + OS) but differ on
+// hwid/publicKey, pick the active one over the stale needs-auth leftover.
+function pickActiveOverStaleNeedsAuth(a, b) {
+    const aDead = a.needsAuth && !a.isOnline;
+    const bDead = b.needsAuth && !b.isOnline;
+    const aLive = !a.needsAuth && a.isOnline;
+    const bLive = !b.needsAuth && b.isOnline;
+    if (aDead && bLive)
+        return b;
+    if (bDead && aLive)
+        return a;
+    return null;
+}
+/**
+ * Collapse a Convex device list so each physical machine appears once.
+ * Safe on an empty list; idempotent on an already-deduped list.
+ */
+function collapseRemoteDevices(devices) {
+    if (!Array.isArray(devices) || devices.length === 0)
+        return [];
+    const byIdentity = new Map();
+    for (const d of devices) {
+        const k = identityKey(d);
+        const prev = byIdentity.get(k);
+        byIdentity.set(k, prev ? mergeEntries(prev, d) : d);
+    }
+    const byAlias = new Map();
+    for (const d of byIdentity.values()) {
+        const k = aliasKey(d);
+        if (!k) {
+            byAlias.set(`id:${d.deviceId}`, d);
+            continue;
+        }
+        const prev = byAlias.get(k);
+        if (!prev) {
+            byAlias.set(k, d);
+            continue;
+        }
+        const strongIdentityConflict = !!prev.publicKey && !!d.publicKey && prev.publicKey !== d.publicKey;
+        if (strongIdentityConflict) {
+            const winner = pickActiveOverStaleNeedsAuth(prev, d);
+            if (winner) {
+                byAlias.set(k, winner);
+                continue;
+            }
+        }
+        byAlias.set(k, mergeEntries(prev, d));
+    }
+    const byEndpoint = new Map();
+    for (const d of byAlias.values()) {
+        const k = endpointKey(d);
+        if (!k) {
+            byEndpoint.set(`id:${d.deviceId}`, d);
+            continue;
+        }
+        const prev = byEndpoint.get(k);
+        byEndpoint.set(k, prev ? mergeEntries(prev, d) : d);
+    }
+    return [...byEndpoint.values()];
+}
+/**
+ * Threshold for "online" based on heartbeat age, in milliseconds.
+ * Matches the mobile app (HEARTBEAT_STALE_MS = 90 s). The SDK used
+ * 60 s, which flashed yellow on single missed beats.
+ */
+exports.HEARTBEAT_STALE_MS = 90000;
+/**
+ * Returns a freshness flag consistent with the mobile app. A device is
+ * "fresh" when it was online per Convex AND its heartbeat is within
+ * `HEARTBEAT_STALE_MS`.
+ */
+function isDeviceFresh(d) {
+    if (!d.isOnline)
+        return false;
+    if (!d.lastHeartbeat)
+        return true;
+    return Date.now() - d.lastHeartbeat < exports.HEARTBEAT_STALE_MS;
+}
+/**
+ * Pick the best candidate for an auto-connect attempt. Preference:
+ *   1. matches the preferred deviceId when supplied + still fresh
+ *   2. fresh (online + recent heartbeat) + has a quicHost
+ *   3. online + has a quicHost
+ *   4. first with a quicHost
+ */
+function pickTargetDevice(devices, preferredDeviceId) {
+    if (!devices.length)
+        return null;
+    if (preferredDeviceId) {
+        const preferred = devices.find((d) => d.deviceId === preferredDeviceId && d.quicHost);
+        if (preferred && isDeviceFresh(preferred))
+            return preferred;
+        if (preferred)
+            return preferred;
+    }
+    const fresh = devices.find((d) => isDeviceFresh(d) && d.quicHost);
+    if (fresh)
+        return fresh;
+    const online = devices.find((d) => d.isOnline && d.quicHost);
+    if (online)
+        return online;
+    return devices.find((d) => d.quicHost) || devices[0] || null;
+}

package/package.json

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