yaver-feedback-react-native 0.7.8 → 0.7.10

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/FeedbackModal.js

@@ -45,6 +45,7 @@ const FeedbackModal = () => {
     const [action, setAction] = (0, react_1.useState)('idle');
     const [error, setError] = (0, react_1.useState)(null);
     const [toast, setToast] = (0, react_1.useState)(null);
+    const [progress, setProgress] = (0, react_1.useState)(null);
     const [isRecordingVideo, setIsRecordingVideo] = (0, react_1.useState)(false);
     const [lastVideo, setLastVideo] = (0, react_1.useState)(null);
     const mountedRef = (0, react_1.useRef)(true);
@@ -69,6 +70,14 @@ const FeedbackModal = () => {
             const msg = payload?.message || payload?.phase || '';
             if (msg)
                 setToast(msg);
+            if (typeof payload?.progress === 'number') {
+                setProgress(payload.progress);
+            }
+            // On final phases, fade the bar to 100% so the user sees
+            // completion before the modal auto-dismisses.
+            if (payload?.phase === 'done' || payload?.phase === 'error') {
+                setProgress(1);
+            }
         });
         return () => {
             mountedRef.current = false;
@@ -141,15 +150,26 @@ const FeedbackModal = () => {
     const handleHotReload = (0, react_1.useCallback)(async () => {
         setAction('hot-reloading');
         setError(null);
+        setProgress(0);
+        setToast('Sending…');
         try {
+            // Default mode: bundle. Always rebuilds via the agent regardless
+            // of Metro state. P2PClient.reloadApp auto-resolves projectName +
+            // bundleId from expo-constants / NativeModules so the agent can
+            // map this app to its MobileProject scan entry without needing
+            // `yaver dev start` to have been run.
             await runWithReconnect(async (client) => {
-                await client.reloadApp('dev');
+                await client.reloadApp('bundle');
             });
-            setToast('Reload sent');
-            closeSoon(800);
+            // We don't auto-close here — the agent's BlackBox status pings
+            // will keep the modal updated, and the on-device YaverBundleLoader
+            // will reload the JS once the fresh bundle arrives. Modal stays
+            // up for a beat so the user sees the final progress state.
+            closeSoon(2500);
         }
         catch (err) {
             setError(err instanceof Error ? err.message : String(err));
+            setProgress(null);
         }
         finally {
             if (mountedRef.current)
@@ -387,6 +407,12 @@ const FeedbackModal = () => {
                     ? `Send Video · ${Math.round(lastVideo.duration)}s`
                     : 'Send Video'} tint="#a78bfa" onPress={handleSendVideo} disabled={busy || !lastVideo} busy={action === 'sending-video'}/>
 
+              {progress !== null && (<react_native_1.View style={styles.progressTrack}>
+                  <react_native_1.View style={[
+                    styles.progressFill,
+                    { width: `${Math.round(progress * 100)}%` },
+                ]}/>
+                </react_native_1.View>)}
               {toast && <react_native_1.Text style={styles.toast}>{toast}</react_native_1.Text>}
               {error && <react_native_1.Text style={styles.error}>{error}</react_native_1.Text>}
             </react_native_1.Pressable>
@@ -459,6 +485,18 @@ const styles = react_native_1.StyleSheet.create({
         fontSize: 15,
         fontWeight: '700',
     },
+    progressTrack: {
+        height: 6,
+        borderRadius: 3,
+        backgroundColor: 'rgba(255,255,255,0.08)',
+        overflow: 'hidden',
+        marginTop: 4,
+    },
+    progressFill: {
+        height: '100%',
+        backgroundColor: '#818cf8',
+        borderRadius: 3,
+    },
     toast: {
         color: '#22c55e',
         fontSize: 13,

package/dist/P2PClient.d.ts

@@ -65,7 +65,11 @@ export declare class P2PClient {
      * via the BlackBox command channel.
      * @param mode - "dev" for hot reload, "bundle" for native bundle rebuild
      */
-    reloadApp(mode?: 'dev' | 'bundle'): Promise<{
+    reloadApp(mode?: 'dev' | 'bundle', opts?: {
+        projectName?: string;
+        bundleId?: string;
+        projectPath?: string;
+    }): Promise<{
         ok: boolean;
     }>;
     /**

package/dist/P2PClient.js

@@ -2,6 +2,54 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.P2PClient = void 0;
 const react_native_1 = require("react-native");
+/**
+ * Try to resolve `{projectName, bundleId}` for the running app so the
+ * agent can map the reload request to a MobileProject in its scan
+ * cache. Order: caller-supplied opts → Expo Constants → react-native
+ * NativeModules. None of the lookups throw — missing data just means
+ * the agent will fall back to its own dev-server resolution.
+ */
+function resolveAppIdentity(opts) {
+    let projectName = opts?.projectName;
+    let bundleId = opts?.bundleId;
+    const projectPath = opts?.projectPath;
+    if (!projectName || !bundleId) {
+        try {
+            const Constants = require('expo-constants').default ?? require('expo-constants');
+            const cfg = Constants?.expoConfig ?? Constants?.manifest ?? {};
+            projectName = projectName || cfg?.name;
+            bundleId =
+                bundleId ||
+                    cfg?.ios?.bundleIdentifier ||
+                    cfg?.android?.package;
+        }
+        catch {
+            // expo-constants not installed (bare RN). Fall through.
+        }
+    }
+    if (!bundleId) {
+        try {
+            const { Platform, NativeModules } = require('react-native');
+            if (Platform.OS === 'ios') {
+                bundleId = NativeModules?.SettingsManager?.settings?.CFBundleIdentifier;
+            }
+            else if (Platform.OS === 'android') {
+                bundleId = NativeModules?.PlatformConstants?.Package;
+            }
+        }
+        catch {
+            // SettingsManager/PlatformConstants missing on some RN versions.
+        }
+    }
+    const out = {};
+    if (projectName)
+        out.projectName = projectName;
+    if (bundleId)
+        out.bundleId = bundleId;
+    if (projectPath)
+        out.projectPath = projectPath;
+    return out;
+}
 /**
  * Translate a raw Go-agent error into something a user can act on.
  *
@@ -215,7 +263,7 @@ class P2PClient {
      * via the BlackBox command channel.
      * @param mode - "dev" for hot reload, "bundle" for native bundle rebuild
      */
-    async reloadApp(mode = 'bundle') {
+    async reloadApp(mode = 'bundle', opts) {
         // Default path: always rebuild a fresh Hermes bundle.
         //
         // Rationale: the SDK's common caller is a phone user who's not
@@ -242,13 +290,25 @@ class P2PClient {
             // than surfacing the raw error, so the user never has to know
             // Metro wasn't running.
         }
+        // Auto-resolve identity if the caller didn't pass it. Reads from
+        // expo-constants when present (host can pin via app.json
+        // `expo.name` / `ios.bundleIdentifier` / `android.package`); falls
+        // back to react-native's NativeModules.SettingsManager.settings
+        // (iOS `CFBundleIdentifier`, `CFBundleName`) and Application
+        // (Android packageName). On the agent side these resolve to the
+        // matching MobileProject in the cached scan, so we don't need
+        // `yaver dev start` to have run on the host.
+        const identity = resolveAppIdentity(opts);
         const res = await fetch(`${this.baseUrl}/dev/reload-app`, {
             method: 'POST',
             headers: {
                 Authorization: `Bearer ${this.authToken}`,
                 'Content-Type': 'application/json',
             },
-            body: JSON.stringify({ mode: 'bundle' }),
+            body: JSON.stringify({
+                mode: 'bundle',
+                ...identity,
+            }),
         });
         if (!res.ok) {
             const text = await res.text().catch(() => '');

package/dist/YaverFeedback.js

@@ -155,18 +155,22 @@ class YaverFeedback {
                 }
                 else if (cmd.command === 'status') {
                     // Pipe agent progress pings to the UI. The FeedbackModal
-                    // subscribes to this event and renders the message while a
-                    // reload / build is in flight.
+                    // subscribes to this event and renders the message + a
+                    // progress bar while a reload / build is in flight.
                     const message = typeof cmd.data?.message === 'string'
                         ? cmd.data.message
                         : '';
                     const phase = typeof cmd.data?.phase === 'string'
                         ? cmd.data.phase
                         : '';
+                    const progress = typeof cmd.data?.progress === 'number'
+                        ? Math.max(0, Math.min(1, cmd.data.progress))
+                        : undefined;
                     const { DeviceEventEmitter } = require('react-native');
                     DeviceEventEmitter.emit('yaverFeedback:status', {
                         message,
                         phase,
+                        progress,
                         at: Date.now(),
                     });
                 }

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>;