yaver-feedback-react-native 0.7.8 → 0.7.9

package/dist/Discovery.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.YaverDiscovery = void 0;
 function getAsyncStorage() {
@@ -201,38 +234,20 @@ class YaverDiscovery {
      * 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 {
+        // Delegate to the canonical client-core implementation so mobile +
+        // SDK run the same race logic. Returned shape is `ProbeResult` —
+        // structurally compatible with DiscoveryResult minus the required
+        // hostname/version fields, which we backfill with sane defaults.
+        const { raceHealthProbes } = await Promise.resolve().then(() => __importStar(require('./_core/device')));
+        const res = await raceHealthProbes(urls, { timeoutMs: PROBE_TIMEOUT_MS });
+        if (!res)
             return null;
-        }
+        return {
+            url: res.url,
+            hostname: res.hostname ?? 'Unknown',
+            version: res.version ?? 'unknown',
+            latency: res.latency ?? 0,
+        };
     }
     /**
      * Discover agent via relay HTTP proxy. Uses the user's configured

package/dist/_core/device.d.ts

@@ -0,0 +1,79 @@
+export interface CoreDevice {
+    /** Convex-issued device id. */
+    deviceId: string;
+    /** Display name — usually hostname. */
+    name: string;
+    /** OS family — "darwin", "linux", "windows". */
+    platform: string;
+    isOnline: boolean;
+    needsAuth: boolean;
+    runnerDown: boolean;
+    /** Unix ms of the latest heartbeat the agent sent to Convex. */
+    lastHeartbeat: number;
+    isGuest: boolean;
+    hostName?: string;
+    hostEmail?: string;
+    accessScope?: 'owner' | 'shared-scoped' | 'shared-legacy';
+    /** Primary LAN IP (or tunnel host) the agent advertised. */
+    quicHost: string;
+    quicPort: number;
+    /** HTTP port the agent listens on (usually 18080). */
+    httpPort?: number;
+    publicKey?: string;
+    /** Stable hardware identifier — dedup key for re-pair events. */
+    hwid?: string;
+    /**
+     * Every LAN IP the agent reported in its last heartbeat. Used by
+     * Discovery.raceProbe to try all interfaces in parallel.
+     */
+    localIps?: string[];
+}
+export declare function deviceIdentityKey(d: CoreDevice): string;
+export declare function deviceAliasKey(d: CoreDevice): string | null;
+export declare function deviceEndpointKey(d: CoreDevice): string | null;
+export declare function mergeDeviceEntries(a: CoreDevice, b: CoreDevice): CoreDevice;
+/**
+ * Collapse duplicate Convex rows so each physical machine appears
+ * exactly once. Three passes — identity key → alias key → endpoint key.
+ * Safe on empty lists; idempotent on already-deduped input.
+ */
+export declare function collapseDevices(devices: CoreDevice[]): CoreDevice[];
+/**
+ * "Fresh" matches the mobile app: online + heartbeat < 90 s. Clients
+ * read Convex's `isOnline` first (backend already applies its own 90 s
+ * gate from the server clock), then use this helper when they need the
+ * phone-side freshness opinion too — e.g. for auto-connect picks.
+ */
+export declare function isDeviceFresh(d: CoreDevice, now?: number): boolean;
+/**
+ * Choose the best candidate for an auto-connect attempt. Preference:
+ *   1. explicit `preferredDeviceId` that's 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: CoreDevice[], preferredDeviceId?: string): CoreDevice | null;
+/**
+ * Build the set of `/health` candidate URLs for a target device —
+ * `quicHost` plus every LAN IP the agent reported in `localIps`,
+ * uniqued and formatted. This is the thing that makes direct LAN
+ * reloads "just work" on multi-homed hosts (en0 + utun tailscale +
+ * docker0 etc.) — the mobile app races them in parallel via
+ * Promise.any.
+ */
+export declare function buildProbeCandidates(target: CoreDevice, defaultHttpPort?: number): string[];
+export interface ProbeResult {
+    url: string;
+    hostname?: string;
+    version?: string;
+    latency?: number;
+}
+/**
+ * Race `/health` probes across N URLs. First 200 wins; everything else
+ * is abandoned. Older Hermes doesn't have Promise.any, so we hand-roll
+ * the same semantic.
+ */
+export declare function raceHealthProbes(urls: string[], opts?: {
+    timeoutMs?: number;
+    headers?: Record<string, string>;
+}): Promise<ProbeResult | null>;

package/dist/_core/device.js

@@ -0,0 +1,310 @@
+"use strict";
+// AUTO-SYNCED from shared/client-core/src/device.ts.
+// DO NOT EDIT IN PLACE. Edit the source and re-run
+// scripts/sync-client-core.sh. CI checks drift via `--check`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deviceIdentityKey = deviceIdentityKey;
+exports.deviceAliasKey = deviceAliasKey;
+exports.deviceEndpointKey = deviceEndpointKey;
+exports.mergeDeviceEntries = mergeDeviceEntries;
+exports.collapseDevices = collapseDevices;
+exports.isDeviceFresh = isDeviceFresh;
+exports.pickTargetDevice = pickTargetDevice;
+exports.buildProbeCandidates = buildProbeCandidates;
+exports.raceHealthProbes = raceHealthProbes;
+/**
+ * Device dedup, merging, freshness, and target-picking.
+ *
+ * Phase-2 extract of the Yaver-mobile logic that lives at
+ * mobile/src/context/DeviceContext.tsx:193-413. Ported faithfully —
+ * mobile's collapseAliasDevices has been battle-tested through
+ * multiple Convex schema changes and the re-pair edge cases; this
+ * file is byte-identical in behaviour, only renamed for the shared
+ * RemoteDevice shape. The Feedback SDK used to carry its own copy
+ * (sdk/feedback/react-native/src/deviceDedup.ts) that drifted on
+ * `hwid` strong-identity and `runners`/`local` field preservation.
+ *
+ * Canonical device shape shared across every surface:
+ *   - Mobile app:  mobile/src/context/DeviceContext.tsx::Device (adapts
+ *                  into this shape at the Convex /devices/list fetch
+ *                  site).
+ *   - Feedback SDK: src/auth.ts::RemoteDevice re-exports this type.
+ *   - Web / Desktop: same.
+ *
+ * The mobile app may have extra view-model fields it wants to keep on
+ * its own Device interface (edgeProfile, sessionBinding, etc.) — those
+ * stay as local extensions; the core operates only on the fields
+ * declared here.
+ */
+const constants_1 = require("./constants");
+// ── Normalisers ───────────────────────────────────────────────────────
+function normName(name) {
+    return String(name || '').trim().toLowerCase().replace(/\.local$/i, '');
+}
+function normHost(host) {
+    return String(host || '').trim().toLowerCase().replace(/\.local$/i, '');
+}
+// ── Keys ──────────────────────────────────────────────────────────────
+function deviceIdentityKey(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 = normName(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 deviceAliasKey(d) {
+    if (d.isGuest)
+        return null;
+    const n = normName(d.name);
+    const os = String(d.platform || '').trim().toLowerCase();
+    if (!n || !os)
+        return null;
+    return `${os}:${n}`;
+}
+function deviceEndpointKey(d) {
+    if (d.isGuest)
+        return null;
+    const h = normHost(d.quicHost);
+    if (!h)
+        return null;
+    return `${h}:${d.quicPort || 0}`;
+}
+// ── Merge rules ───────────────────────────────────────────────────────
+function mergeDeviceEntries(a, b) {
+    const incomingWins = (!!a.needsAuth && !b.needsAuth) ||
+        (b.lastHeartbeat || 0) > (a.lastHeartbeat || 0) ||
+        (!!b.isOnline && !a.isOnline);
+    const base = incomingWins ? b : a;
+    const other = incomingWins ? a : b;
+    return {
+        ...other,
+        ...base,
+        quicHost: base.quicHost || other.quicHost,
+        quicPort: base.quicPort || other.quicPort,
+        httpPort: base.httpPort || other.httpPort,
+        isOnline: base.isOnline || other.isOnline,
+        runnerDown: base.runnerDown && other.runnerDown,
+        publicKey: base.publicKey || other.publicKey,
+        hwid: base.hwid || other.hwid,
+        lastHeartbeat: Math.max(a.lastHeartbeat || 0, b.lastHeartbeat || 0),
+        localIps: (() => {
+            const set = new Set();
+            for (const ip of a.localIps || [])
+                if (ip)
+                    set.add(ip);
+            for (const ip of b.localIps || [])
+                if (ip)
+                    set.add(ip);
+            return set.size > 0 ? [...set] : undefined;
+        })(),
+    };
+}
+// When two rows share the same alias (hostname + OS) but differ on
+// hwid / publicKey, prefer the authenticated + online row over a
+// stale "needsAuth + offline" leftover. That leftover pattern is
+// what re-pair / wipe-and-reinstall produces on Convex.
+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 (three-pass dedup) ───────────────────────────────────────
+/**
+ * Collapse duplicate Convex rows so each physical machine appears
+ * exactly once. Three passes — identity key → alias key → endpoint key.
+ * Safe on empty lists; idempotent on already-deduped input.
+ */
+function collapseDevices(devices) {
+    if (!Array.isArray(devices) || devices.length === 0)
+        return [];
+    // Pass 1: identity key (hwid / publicKey / name+os).
+    const byIdentity = new Map();
+    for (const d of devices) {
+        const k = deviceIdentityKey(d);
+        const prev = byIdentity.get(k);
+        byIdentity.set(k, prev ? mergeDeviceEntries(prev, d) : d);
+    }
+    // Pass 2: alias key (os + normalised hostname), with strong-identity
+    // conflict resolution so two genuinely-different machines sharing a
+    // hostname don't silently merge.
+    const byAlias = new Map();
+    for (const d of byIdentity.values()) {
+        const k = deviceAliasKey(d);
+        if (!k) {
+            byAlias.set(`id:${d.deviceId}`, d);
+            continue;
+        }
+        const prev = byAlias.get(k);
+        if (!prev) {
+            byAlias.set(k, d);
+            continue;
+        }
+        const strongConflict = (!!prev.hwid && !!d.hwid && prev.hwid !== d.hwid) ||
+            (!!prev.publicKey && !!d.publicKey && prev.publicKey !== d.publicKey);
+        if (strongConflict) {
+            const winner = pickActiveOverStaleNeedsAuth(prev, d);
+            if (winner) {
+                byAlias.set(k, winner);
+                continue;
+            }
+        }
+        byAlias.set(k, mergeDeviceEntries(prev, d));
+    }
+    // Pass 3: endpoint key (host:port) — last-chance dedup for rows
+    // that share a LAN address but slipped through identity + alias.
+    const byEndpoint = new Map();
+    for (const d of byAlias.values()) {
+        const k = deviceEndpointKey(d);
+        if (!k) {
+            byEndpoint.set(`id:${d.deviceId}`, d);
+            continue;
+        }
+        const prev = byEndpoint.get(k);
+        byEndpoint.set(k, prev ? mergeDeviceEntries(prev, d) : d);
+    }
+    return [...byEndpoint.values()];
+}
+// ── Freshness + target pick ───────────────────────────────────────────
+/**
+ * "Fresh" matches the mobile app: online + heartbeat < 90 s. Clients
+ * read Convex's `isOnline` first (backend already applies its own 90 s
+ * gate from the server clock), then use this helper when they need the
+ * phone-side freshness opinion too — e.g. for auto-connect picks.
+ */
+function isDeviceFresh(d, now = Date.now()) {
+    if (!d.isOnline)
+        return false;
+    if (!d.lastHeartbeat)
+        return true;
+    return now - d.lastHeartbeat < constants_1.HEARTBEAT_STALE_MS;
+}
+/**
+ * Choose the best candidate for an auto-connect attempt. Preference:
+ *   1. explicit `preferredDeviceId` that's 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;
+}
+// ── Probe candidate assembly ──────────────────────────────────────────
+/**
+ * Build the set of `/health` candidate URLs for a target device —
+ * `quicHost` plus every LAN IP the agent reported in `localIps`,
+ * uniqued and formatted. This is the thing that makes direct LAN
+ * reloads "just work" on multi-homed hosts (en0 + utun tailscale +
+ * docker0 etc.) — the mobile app races them in parallel via
+ * Promise.any.
+ */
+function buildProbeCandidates(target, defaultHttpPort = 18080) {
+    const port = target.httpPort ?? target.quicPort ?? defaultHttpPort;
+    const ips = new Set();
+    if (target.quicHost)
+        ips.add(target.quicHost);
+    for (const ip of target.localIps ?? []) {
+        if (ip)
+            ips.add(ip);
+    }
+    return [...ips].map((ip) => `http://${ip}:${port}`);
+}
+/**
+ * Race `/health` probes across N URLs. First 200 wins; everything else
+ * is abandoned. Older Hermes doesn't have Promise.any, so we hand-roll
+ * the same semantic.
+ */
+async function raceHealthProbes(urls, opts = {}) {
+    if (!urls || urls.length === 0)
+        return null;
+    const timeoutMs = opts.timeoutMs ?? 2500;
+    const probeOne = async (url) => {
+        const base = url.replace(/\/$/, '');
+        const start = Date.now();
+        try {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), timeoutMs);
+            const res = await fetch(`${base}/health`, {
+                method: 'GET',
+                headers: opts.headers,
+                signal: controller.signal,
+            });
+            clearTimeout(timer);
+            if (!res.ok)
+                return null;
+            const latency = Date.now() - start;
+            let hostname;
+            let version;
+            try {
+                const data = await res.json();
+                hostname = data?.hostname ?? data?.name;
+                version = data?.version;
+            }
+            catch {
+                // /health may return plain text
+            }
+            return { url: base, hostname, version, latency };
+        }
+        catch {
+            return null;
+        }
+    };
+    return new Promise((resolve) => {
+        let remaining = urls.length;
+        let settled = false;
+        for (const url of urls) {
+            probeOne(url)
+                .then((r) => {
+                if (settled)
+                    return;
+                if (r) {
+                    settled = true;
+                    resolve(r);
+                    return;
+                }
+                remaining -= 1;
+                if (remaining <= 0 && !settled) {
+                    settled = true;
+                    resolve(null);
+                }
+            })
+                .catch(() => {
+                remaining -= 1;
+                if (remaining <= 0 && !settled) {
+                    settled = true;
+                    resolve(null);
+                }
+            });
+        }
+    });
+}

package/dist/_core/index.d.ts

@@ -12,3 +12,4 @@
  */
 export * from './constants';
 export * from './endpoints';
+export * from './device';

package/dist/_core/index.js

@@ -31,3 +31,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 __exportStar(require("./constants"), exports);
 __exportStar(require("./endpoints"), exports);
+__exportStar(require("./device"), exports);

package/dist/deviceDedup.d.ts

@@ -1,45 +1,21 @@
 /**
- * Device deduplication + online-signal merging, ported from the Yaver
- * mobile app's DeviceContext.collapseAliasDevices.
+ * Re-export the canonical dedup / freshness / race-probe helpers from
+ * @yaver/client-core (mirrored into `./_core/`).
  *
- * 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.
+ * The SDK previously carried its own ~180-line copy of
+ * `collapseAliasDevices` ported by hand from mobile's
+ * DeviceContext.tsx. The copies drifted on `hwid` strong-identity,
+ * `runners` / `local` field preservation, and a few other subtle
+ * merge rules. Canonicalising via client-core eliminates that drift
+ * class — mobile's test case automatically covers the SDK's dedup
+ * behaviour too.
  *
- * 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.
+ * The shared module operates on a `CoreDevice` shape. The SDK's
+ * `RemoteDevice` is structurally compatible (same field names, same
+ * types), so the casts here are a no-op at runtime.
  */
 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 { HEARTBEAT_STALE_MS } from './_core/constants';
 export declare function collapseRemoteDevices(devices: RemoteDevice[]): RemoteDevice[];
-/**
- * Threshold for "online" based on heartbeat age, in milliseconds.
- * Re-exported from `@yaver/client-core` so mobile + SDK + backend
- * agree on one number at all times.
- */
-import { HEARTBEAT_STALE_MS } from './_core/constants';
-export { HEARTBEAT_STALE_MS };
-/**
- * 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;