yaver-feedback-react-native 0.3.0 → 0.5.0

package/src/YaverFeedback.ts

@@ -3,6 +3,14 @@ import { YaverDiscovery } from './Discovery';
 import { BlackBox } from './BlackBox';
 import { P2PClient } from './P2PClient';
 import { ShakeDetector } from './ShakeDetector';
+import {
+  configureAuthEndpoints,
+  getToken,
+  getSelectedDeviceId,
+  clearToken,
+  clearSelectedDeviceId,
+  DEFAULT_CONVEX_SITE_URL,
+} from './auth';
 
 let config: FeedbackConfig | null = null;
 let enabled = false;
@@ -16,6 +24,13 @@ let maxErrors = 5;
 /** Track whether BlackBox was running before disable (to restart on enable). */
 let blackBoxWasStreaming = false;
 
+/**
+ * Flag evaluation cache — 30s TTL per `userId|key`. Prevents a
+ * tight render loop from hammering /flags/eval when the dev calls
+ * `YaverFeedback.getFlag()` every frame.
+ */
+const flagCache: Map<string, { value: unknown; at: number }> = new Map();
+
 /**
  * Main entry point for the Yaver Feedback SDK.
  * Call `YaverFeedback.init()` once at app startup.
@@ -34,9 +49,23 @@ export class YaverFeedback {
       maxRecordingDuration: 120,
       feedbackMode: 'batch',
       agentCommentaryLevel: 0,
+      autoLogin: true,
       ...cfg,
     };
 
+    // Route the in-SDK login screen to prod yaver.io by default; callers may
+    // override for staging via authConvexSiteUrl / authWebBaseUrl.
+    configureAuthEndpoints({
+      convexSiteUrl: cfg.authConvexSiteUrl,
+      webBaseUrl: cfg.authWebBaseUrl,
+    });
+    // If no explicit convexUrl was set but we have an auth site URL, use it
+    // so Discovery.discoverFromConvex() has somewhere to look up the user's
+    // machines (works for both LAN-direct and off-LAN relay paths).
+    if (!config.convexUrl) {
+      config.convexUrl = cfg.authConvexSiteUrl ?? DEFAULT_CONVEX_SITE_URL;
+    }
+
     // Default: enabled only in dev mode
     if (cfg.enabled !== undefined) {
       enabled = cfg.enabled;
@@ -44,11 +73,22 @@ export class YaverFeedback {
       enabled = typeof __DEV__ !== 'undefined' ? __DEV__ : false;
     }
 
+    // Hydrate cached auth token + preferred device from AsyncStorage so the
+    // SDK reconnects silently on subsequent launches. If autoLogin is false
+    // the caller is responsible for providing authToken themselves.
+    if (config.autoLogin !== false && enabled) {
+      void YaverFeedback.hydrateSession();
+    }
+
     // Create P2P client if we have a URL
     if (config.agentUrl) {
-      p2pClient = new P2PClient(config.agentUrl, config.authToken);
+      p2pClient = new P2PClient(config.agentUrl, config.authToken ?? '');
     } else {
       p2pClient = null;
+      // Auto-discover agent in the background when convexUrl or LAN is available
+      if (enabled && (config.authToken || config.preferredDeviceId)) {
+        YaverFeedback.discoverAgent();
+      }
     }
 
     // Set up error capture buffer size
@@ -80,21 +120,15 @@ export class YaverFeedback {
           if (cfg.onReload) {
             cfg.onReload();
           } else {
-            // Default: try DevSettings.reload() in dev mode
-            try {
-              const { DevSettings } = require('react-native');
-              if (typeof DevSettings?.reload === 'function') {
-                DevSettings.reload();
-              }
-            } catch {
-              // Not in dev mode or DevSettings unavailable
-            }
+            YaverFeedback.defaultReload();
           }
         } else if (cmd.command === 'reload_bundle' && cmd.data) {
           const bundleUrl = cmd.data.bundleUrl as string;
           const assetsUrl = cmd.data.assetsUrl as string | undefined;
           if (cfg.onReloadBundle) {
             cfg.onReloadBundle(bundleUrl, assetsUrl);
+          } else {
+            YaverFeedback.defaultReloadBundle(bundleUrl, assetsUrl);
           }
         }
       });
@@ -111,6 +145,127 @@ export class YaverFeedback {
     //     pass-through wrapper they insert into their own error chain
   }
 
+  /**
+   * Run agent discovery in the background.
+   * Called automatically from init() when no agentUrl is provided.
+   * Sets config.agentUrl and creates P2PClient on success.
+   */
+  static async discoverAgent(): Promise<void> {
+    if (!config || !enabled) return;
+    if (config.agentUrl) return; // already have a URL
+    if (!config.authToken) return; // need auth before discovery can succeed
+
+    try {
+      const result = await YaverDiscovery.discover({
+        convexUrl: config.convexUrl,
+        authToken: config.authToken,
+        preferredDeviceId: config.preferredDeviceId,
+      });
+      if (result && config) {
+        config.agentUrl = result.url;
+        p2pClient = new P2PClient(result.url, config.authToken ?? '');
+      }
+    } catch {
+      // Discovery failed — FloatingButton will show disconnected, user can retry
+    }
+  }
+
+  /**
+   * Pull a cached session token + selected device from AsyncStorage (populated
+   * by the in-SDK login + machine-picker screens). When present the SDK can
+   * reconnect silently on launch without re-prompting the user. Safe to call
+   * multiple times — it only overrides values the caller did not already set.
+   */
+  static async hydrateSession(): Promise<void> {
+    if (!config) return;
+    try {
+      if (!config.authToken) {
+        const cached = await getToken();
+        if (cached) {
+          config.authToken = cached;
+        }
+      }
+      if (!config.preferredDeviceId) {
+        const cachedDevice = await getSelectedDeviceId();
+        if (cachedDevice) {
+          config.preferredDeviceId = cachedDevice;
+        }
+      }
+      if (config.authToken && !config.agentUrl) {
+        await YaverFeedback.discoverAgent();
+      }
+    } catch {
+      // hydration best-effort
+    }
+  }
+
+  /**
+   * Update the signed-in session token (e.g. after the in-SDK login screen
+   * succeeds). Rebuilds the P2P client and kicks off agent discovery.
+   */
+  static async setAuthToken(token: string): Promise<void> {
+    if (!config) return;
+    config.authToken = token;
+    if (config.agentUrl) {
+      p2pClient = new P2PClient(config.agentUrl, token);
+    } else {
+      await YaverFeedback.discoverAgent();
+    }
+  }
+
+  /** Returns true once the SDK has a session token it can use. */
+  static isAuthed(): boolean {
+    return Boolean(config?.authToken);
+  }
+
+  /**
+   * Request the embedded FeedbackModal to show the login screen. Works by
+   * emitting an event the modal listens for — avoids forcing the host app
+   * to mount a second navigator.
+   */
+  static showLogin(): void {
+    const { DeviceEventEmitter } = require('react-native');
+    DeviceEventEmitter.emit('yaverFeedback:startLogin');
+  }
+
+  /**
+   * Request the embedded FeedbackModal to show the machine picker. Requires
+   * an active session; no-ops otherwise.
+   */
+  static showMachinePicker(): void {
+    if (!YaverFeedback.isAuthed()) return;
+    const { DeviceEventEmitter } = require('react-native');
+    DeviceEventEmitter.emit('yaverFeedback:startMachinePicker');
+  }
+
+  /**
+   * Update the selected remote device. Resets the cached agent URL so the
+   * next `startReport()` (or FloatingButton press) rediscovers against the
+   * newly-selected machine.
+   */
+  static async setPreferredDevice(deviceId: string): Promise<void> {
+    if (!config) return;
+    config.preferredDeviceId = deviceId;
+    config.agentUrl = undefined;
+    p2pClient = null;
+    await YaverFeedback.discoverAgent();
+  }
+
+  /**
+   * Sign out: clear cached token + device, tear down the P2P client. The
+   * SDK stays enabled; the next feedback trigger will re-prompt for login.
+   */
+  static async signOut(): Promise<void> {
+    await clearToken();
+    await clearSelectedDeviceId();
+    if (config) {
+      config.authToken = undefined;
+      config.preferredDeviceId = undefined;
+      config.agentUrl = undefined;
+    }
+    p2pClient = null;
+  }
+
   /**
    * Manually trigger the feedback collection flow.
    * Opens the feedback modal if the SDK is initialized and enabled.
@@ -126,6 +281,18 @@ export class YaverFeedback {
       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;
+      }
+    }
+
     // Auto-discover if no agent URL was provided
     if (!config.agentUrl) {
       try {
@@ -136,9 +303,15 @@ export class YaverFeedback {
         });
         if (result) {
           config.agentUrl = result.url;
-          p2pClient = new P2PClient(result.url, config.authToken);
+          p2pClient = new P2PClient(result.url, config.authToken ?? '');
+        } 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. Set agentUrl, convexUrl, or ensure agent is running on the network.');
+          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);
@@ -292,6 +465,103 @@ export class YaverFeedback {
     return config?.agentCommentaryLevel ?? 0;
   }
 
+  // ─── One-stop SaaS replacement methods ─────────────────────────
+  //
+  // These are the three solo-dev SaaS-replacement entry points
+  // wired into YaverFeedback so there's exactly one import path
+  // for the dev's app code: track / getFlag / checkUpdate.
+
+  /**
+   * Record a business event. Routes through BlackBox so the agent
+   * persists it to the analytics ledger (no dashboards — export
+   * via CSV or webhook into PostHog).
+   *
+   * @example
+   * ```ts
+   * YaverFeedback.track('purchase_completed', { amount: '9.99' });
+   * ```
+   */
+  static track(name: string, props?: Record<string, unknown>, route?: string): void {
+    if (!enabled) return;
+    BlackBox.track(name, props, route);
+  }
+
+  /**
+   * Evaluate a single feature flag for a user. Results are cached
+   * for 30 seconds inside YaverFeedback so a tight loop evaluating
+   * the same key doesn't hammer the agent.
+   *
+   * @param key — flag key (must exist on the agent)
+   * @param defaultValue — returned if the flag is missing / offline
+   * @param userId — stable user identifier for rollout bucketing
+   */
+  static async getFlag<T = boolean | string>(
+    key: string,
+    defaultValue: T,
+    userId: string = 'anonymous',
+  ): Promise<T> {
+    if (!enabled || !p2pClient) return defaultValue;
+    const cacheKey = `${userId}|${key}`;
+    const now = Date.now();
+    const cached = flagCache.get(cacheKey);
+    if (cached && now - cached.at < 30_000) {
+      return (cached.value as T) ?? defaultValue;
+    }
+    try {
+      const val = await p2pClient.flagsEvaluateOne<T>(key, userId);
+      flagCache.set(cacheKey, { value: val ?? defaultValue, at: now });
+      return (val as T) ?? defaultValue;
+    } catch {
+      return defaultValue;
+    }
+  }
+
+  /**
+   * Bulk evaluate every flag for a user. Cached on the same 30s
+   * window as getFlag — use this when boot needs a handful of
+   * flags in one roundtrip.
+   */
+  static async getFlags(
+    userId: string = 'anonymous',
+  ): Promise<Record<string, unknown>> {
+    if (!enabled || !p2pClient) return {};
+    const cacheKey = `all|${userId}`;
+    const now = Date.now();
+    const cached = flagCache.get(cacheKey);
+    if (cached && now - cached.at < 30_000) {
+      return (cached.value as Record<string, unknown>) ?? {};
+    }
+    try {
+      const flags = await p2pClient.flagsEvaluate(userId);
+      flagCache.set(cacheKey, { value: flags, at: now });
+      return flags;
+    } catch {
+      return {};
+    }
+  }
+
+  /**
+   * Ask what bundle this device should run. Returns the latest
+   * release manifest in the configured channel plus a rollout
+   * gate. The dev can then compare against what's currently
+   * running and prompt the user to reload.
+   *
+   * On-disk bundle swap is platform-specific — see
+   * `YaverFeedback.onUpdateAvailable` if you want a hook.
+   */
+  static async checkUpdate(
+    channel: string = 'production',
+    deviceId?: string,
+  ): Promise<Awaited<ReturnType<P2PClient['releasesLatest']>>> {
+    if (!enabled || !p2pClient) return null;
+    return p2pClient.releasesLatest(channel, deviceId);
+  }
+
+  /** Clear the in-memory flag cache. Useful for tests or after sign-out. */
+  static clearFlagCache(): void {
+    flagCache.clear();
+  }
+
   /**
    * Reporting-only mode: auto-capture screenshot + errors and send
    * to the agent's /feedback endpoint. No modal UI — just shake and go.
@@ -312,7 +582,7 @@ export class YaverFeedback {
         });
         if (result) {
           config.agentUrl = result.url;
-          p2pClient = new P2PClient(result.url, config.authToken);
+          p2pClient = new P2PClient(result.url, config.authToken ?? '');
         }
       } catch {}
     }
@@ -353,13 +623,92 @@ export class YaverFeedback {
         errors: errorBuffer.length > 0 ? [...errorBuffer] : undefined,
       };
 
-      await uploadFeedback(config.agentUrl, config.authToken, bundle);
+      await uploadFeedback(config.agentUrl, config.authToken ?? '', bundle);
       console.log('[YaverFeedback] Auto-report sent');
     } catch (err) {
       console.warn('[YaverFeedback] Auto-report failed:', err);
     }
   }
 
+  /**
+   * Default reload handler. Tries three strategies in order:
+   *
+   * 1. **YaverBundleLoader** — running inside Yaver's native container.
+   *    Pulls fresh Hermes bundle from agent and reloads the RN bridge.
+   *
+   * 2. **YaverHotReload** — standalone app with feedback SDK's native module
+   *    (added via Expo config plugin). Downloads Hermes bundle from agent,
+   *    saves to Documents, and reloads the RN bridge.
+   *
+   * 3. **DevSettings.reload()** — standalone dev build connected to Metro.
+   */
+  private static defaultReload(): void {
+    if (!config?.agentUrl) return;
+    const bundleUrl = `${config.agentUrl}/dev/native-bundle`;
+    const headers = { Authorization: `Bearer ${config.authToken ?? ''}` };
+    YaverFeedback.loadBundleAndReload(bundleUrl, headers);
+  }
+
+  /**
+   * Default reload_bundle handler. Receives a compiled Hermes bundle URL
+   * from the agent and loads it via the best available native mechanism.
+   */
+  private static defaultReloadBundle(bundleUrl: string, _assetsUrl?: string): void {
+    if (!config?.agentUrl) return;
+
+    const fullUrl = bundleUrl.startsWith('http')
+      ? bundleUrl
+      : `${config.agentUrl}${bundleUrl}`;
+    const headers = { Authorization: `Bearer ${config.authToken ?? ''}` };
+    YaverFeedback.loadBundleAndReload(fullUrl, headers);
+  }
+
+  /**
+   * Core bundle reload logic. Tries native loaders in order:
+   *
+   * 1. YaverBundleLoader (Yaver container — full validation + bridge reload)
+   * 2. YaverHotReload (SDK's own native module — download + bridge reload)
+   * 3. DevSettings.reload() (Metro dev server fallback)
+   */
+  private static loadBundleAndReload(
+    bundleUrl: string,
+    headers: Record<string, string>,
+  ): void {
+    const { NativeModules } = require('react-native');
+
+    // Strategy 1: YaverBundleLoader (running inside Yaver container)
+    if (NativeModules.YaverBundleLoader) {
+      NativeModules.YaverBundleLoader.loadBundle(bundleUrl, 'main', headers)
+        .catch((err: Error) => {
+          console.warn('[YaverFeedback] YaverBundleLoader reload failed:', err);
+        });
+      return;
+    }
+
+    // Strategy 2: YaverHotReload (SDK's native module, added by Expo config plugin)
+    if (NativeModules.YaverHotReload) {
+      NativeModules.YaverHotReload.loadBundle(bundleUrl, headers)
+        .catch((err: Error) => {
+          console.warn('[YaverFeedback] YaverHotReload reload failed:', err);
+        });
+      return;
+    }
+
+    // Strategy 3: DevSettings.reload() for Metro dev builds
+    console.warn(
+      '[YaverFeedback] No native bundle loader available. ' +
+      'Add "yaver-feedback-react-native" to your app.json plugins to enable hot reload.',
+    );
+    try {
+      const { DevSettings } = require('react-native');
+      if (typeof DevSettings?.reload === 'function') {
+        DevSettings.reload();
+      }
+    } catch {
+      // Not in dev mode
+    }
+  }
+
   /** Tear down the SDK (stop shake detector, clear state). */
   static destroy(): void {
     if (shakeDetector) {