yaver-feedback-react-native 0.4.0 → 0.5.2

package/src/ShakeDetector.ts

@@ -1,57 +1,117 @@
 import { DeviceEventEmitter, Platform } from 'react-native';
 
-const SHAKE_THRESHOLD = 1.5; // g-force threshold
 const SHAKE_TIMEOUT_MS = 1000; // minimum time between shakes
-const SHAKE_REQUIRED_EVENTS = 3; // number of threshold-exceeding events to trigger
+const ACCEL_THRESHOLD_G = 1.8; // peak g-force that qualifies as a shake event
+const ACCEL_MIN_HITS = 3; // peaks within the window before we fire
+const ACCEL_WINDOW_MS = 800; // rolling window
+const ACCEL_SAMPLE_INTERVAL_MS = 80; // ≈12Hz — cheap but catches shakes
 
 /**
  * Detects device shake gestures.
  *
- * On iOS, listens to the native 'shakeEvent' emitted by RCTDeviceEventEmitter.
- * On Android, uses accelerometer data with threshold-based detection as a fallback.
+ * Two detection paths run in parallel so shake works in both Debug and
+ * Release / TestFlight builds:
+ *
+ *   1. React Native's built-in `shakeEvent` (iOS) / `ShakeEvent` (Android)
+ *      on `DeviceEventEmitter`. RN emits `shakeEvent` only in Debug mode
+ *      on iOS, which is why TestFlight builds never saw a shake prior to
+ *      SDK 0.5.1.
+ *   2. Accelerometer-based fallback via `expo-sensors` (optional peer
+ *      dep). When the host app has `expo-sensors` installed we subscribe
+ *      to the accelerometer and fire on a burst of above-threshold peaks.
+ *      This path works identically in Debug, Release, and TestFlight.
+ *
+ * Both paths share a 1-second debounce so a single shake never fires the
+ * callback twice.
  */
 export class ShakeDetector {
-  private subscription: any = null;
+  private devMenuSub: { remove(): void } | null = null;
+  private accelSub: { remove(): void } | null = null;
   private lastShakeTime = 0;
+  private peakTimestamps: number[] = [];
 
-  /**
-   * Start listening for shake gestures.
-   * @param onShake - Callback invoked when a shake is detected.
-   */
   start(onShake: () => void): void {
     this.stop();
+    this.subscribeDevMenu(onShake);
+    this.subscribeAccelerometer(onShake);
+  }
 
-    // React Native emits a 'shakeEvent' on iOS when the device is shaken
-    // (available via DeviceEventEmitter in debug builds)
-    if (Platform.OS === 'ios') {
-      this.subscription = DeviceEventEmitter.addListener('shakeEvent', () => {
-        const now = Date.now();
-        if (now - this.lastShakeTime > SHAKE_TIMEOUT_MS) {
-          this.lastShakeTime = now;
-          onShake();
-        }
-      });
-      return;
+  stop(): void {
+    if (this.devMenuSub) {
+      this.devMenuSub.remove();
+      this.devMenuSub = null;
     }
+    if (this.accelSub) {
+      this.accelSub.remove();
+      this.accelSub = null;
+    }
+    this.peakTimestamps = [];
+  }
 
-    // Android: listen for accelerometer-based shake detection
-    // Uses the same DeviceEventEmitter pattern — if a native module or
-    // react-native-shake is installed, it will emit 'ShakeEvent'.
-    // Otherwise this is a no-op (manual trigger or floating button can be used).
-    this.subscription = DeviceEventEmitter.addListener('ShakeEvent', () => {
-      const now = Date.now();
-      if (now - this.lastShakeTime > SHAKE_TIMEOUT_MS) {
-        this.lastShakeTime = now;
-        onShake();
-      }
+  private fire(onShake: () => void): void {
+    const now = Date.now();
+    if (now - this.lastShakeTime <= SHAKE_TIMEOUT_MS) return;
+    this.lastShakeTime = now;
+    this.peakTimestamps = [];
+    onShake();
+  }
+
+  /**
+   * Dev-menu / platform-native event listener. On iOS this is the
+   * `shakeEvent` RN posts from RCTDevMenu (Debug only). On Android it is
+   * the `ShakeEvent` name a handful of third-party shake libraries emit.
+   */
+  private subscribeDevMenu(onShake: () => void): void {
+    const eventName = Platform.OS === 'ios' ? 'shakeEvent' : 'ShakeEvent';
+    this.devMenuSub = DeviceEventEmitter.addListener(eventName, () => {
+      this.fire(onShake);
     });
   }
 
-  /** Stop listening for shake gestures. */
-  stop(): void {
-    if (this.subscription) {
-      this.subscription.remove();
-      this.subscription = null;
+  /**
+   * Accelerometer-based detection. Uses `expo-sensors` when available —
+   * the host app's own dependency, not the SDK's, so apps that don't
+   * want the extra native surface get the Dev-menu path only.
+   */
+  private subscribeAccelerometer(onShake: () => void): void {
+    let Accelerometer: {
+      setUpdateInterval: (ms: number) => void;
+      addListener: (cb: (d: { x: number; y: number; z: number }) => void) => {
+        remove(): void;
+      };
+    } | null = null;
+    try {
+      // Optional peer dep — if it isn't installed, we simply skip this path.
+      Accelerometer = require('expo-sensors').Accelerometer;
+    } catch {
+      return;
+    }
+    if (!Accelerometer) return;
+
+    try {
+      Accelerometer.setUpdateInterval(ACCEL_SAMPLE_INTERVAL_MS);
+    } catch {
+      // Some platforms reject zero-value intervals; fall through with defaults
     }
+
+    this.accelSub = Accelerometer.addListener(({ x, y, z }) => {
+      // Magnitude of acceleration vector (in g). Subtract 1 so a stationary
+      // device reports ~0 rather than the 1g of gravity.
+      const mag = Math.sqrt(x * x + y * y + z * z);
+      if (mag - 1 < ACCEL_THRESHOLD_G - 1) return;
+
+      const now = Date.now();
+      this.peakTimestamps.push(now);
+      // Drop peaks that fell out of the rolling window.
+      while (
+        this.peakTimestamps.length > 0 &&
+        now - this.peakTimestamps[0] > ACCEL_WINDOW_MS
+      ) {
+        this.peakTimestamps.shift();
+      }
+      if (this.peakTimestamps.length >= ACCEL_MIN_HITS) {
+        this.fire(onShake);
+      }
+    });
   }
 }

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,13 +73,20 @@ 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) {
+      if (enabled && (config.authToken || config.preferredDeviceId)) {
         YaverFeedback.discoverAgent();
       }
     }
@@ -117,6 +153,7 @@ export class YaverFeedback {
   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({
@@ -126,13 +163,109 @@ export class YaverFeedback {
       });
       if (result && config) {
         config.agentUrl = result.url;
-        p2pClient = new P2PClient(result.url, config.authToken);
+        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.
@@ -148,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 {
@@ -158,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);
@@ -314,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.
@@ -334,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 {}
     }
@@ -375,7 +623,7 @@ 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);
@@ -397,7 +645,7 @@ export class YaverFeedback {
   private static defaultReload(): void {
     if (!config?.agentUrl) return;
     const bundleUrl = `${config.agentUrl}/dev/native-bundle`;
-    const headers = { Authorization: `Bearer ${config.authToken}` };
+    const headers = { Authorization: `Bearer ${config.authToken ?? ''}` };
     YaverFeedback.loadBundleAndReload(bundleUrl, headers);
   }
 
@@ -411,7 +659,7 @@ export class YaverFeedback {
     const fullUrl = bundleUrl.startsWith('http')
       ? bundleUrl
       : `${config.agentUrl}${bundleUrl}`;
-    const headers = { Authorization: `Bearer ${config.authToken}` };
+    const headers = { Authorization: `Bearer ${config.authToken ?? ''}` };
     YaverFeedback.loadBundleAndReload(fullUrl, headers);
   }