yaver-feedback-react-native 0.5.4 → 0.6.0

package/src/ShakeDetector.ts

@@ -1,4 +1,20 @@
-import { DeviceEventEmitter, Platform } from 'react-native';
+import { DeviceEventEmitter, NativeModules, Platform } from 'react-native';
+
+// Detects that the surrounding runtime is Yaver's super-host bridge. The
+// YaverInfo native module is only registered inside Yaver's container
+// (see mobile/ios/Yaver/YaverInfo.{swift,m} and the Android equivalent),
+// so it is undefined in a standalone third-party app. When the SDK runs
+// inside Yaver we yield shake handling to Yaver's native
+// ShakeDetectingWindow — the user should only ever see the 2-button
+// "Reload / Back to Yaver" overlay, never a FeedbackModal popped from
+// inside the guest bundle.
+function isRunningInsideYaverHost(): boolean {
+  try {
+    return !!(NativeModules as any)?.YaverInfo;
+  } catch {
+    return false;
+  }
+}
 
 const SHAKE_TIMEOUT_MS = 1000; // minimum time between shakes
 const ACCEL_THRESHOLD_G = 1.8; // peak g-force that qualifies as a shake event
@@ -32,6 +48,11 @@ export class ShakeDetector {
 
   start(onShake: () => void): void {
     this.stop();
+    // When the app is loaded inside Yaver's super-host (Hermes push),
+    // Yaver owns the shake gesture and shows its own "Reload / Back to
+    // Yaver" overlay. We must not also fire the guest-side callback,
+    // otherwise the user gets both UIs at once.
+    if (isRunningInsideYaverHost()) return;
     this.subscribeDevMenu(onShake);
     this.subscribeAccelerometer(onShake);
   }

package/src/YaverFeedback.ts

@@ -1,3 +1,4 @@
+import { NativeModules } from 'react-native';
 import { FeedbackConfig, CapturedError } from './types';
 import { YaverDiscovery } from './Discovery';
 import { BlackBox } from './BlackBox';
@@ -12,6 +13,29 @@ import {
   DEFAULT_CONVEX_SITE_URL,
 } from './auth';
 
+// Is this JS runtime the Yaver mobile app's super-host bridge? The
+// YaverInfo native module is only registered inside Yaver's container
+// (mobile/ios/Yaver/YaverInfo.{swift,m} + Android counterpart); a
+// standalone app bundled by its own developer has no such module.
+// When the SDK is loaded through Yaver's Hermes-push guest runtime we
+// deliberately no-op every public entry point — Yaver owns the shake
+// gesture ("Reload / Back to Yaver" overlay), the feedback capture
+// flow, and the BlackBox streaming; running a second copy from inside
+// the guest just produces duplicate UIs and double P2P sessions.
+function isRunningInsideYaverHost(): boolean {
+  try {
+    return !!(NativeModules as any)?.YaverInfo;
+  } catch {
+    return false;
+  }
+}
+
+// Suppresses SDK activation when inside Yaver super-host. Callers of
+// YaverFeedback.init / startReport / startBatchRecording / … early-out
+// by checking this first so the SDK's side effects (accelerometer,
+// BlackBox HTTP, SSE command channel, FeedbackModal mount) never start.
+const YAVER_HOST_SUPPRESS = isRunningInsideYaverHost();
+
 let config: FeedbackConfig | null = null;
 let enabled = false;
 let p2pClient: P2PClient | null = null;
@@ -44,6 +68,11 @@ export class YaverFeedback {
    * via `YaverDiscovery` on the first `startReport()` call.
    */
   static init(cfg: FeedbackConfig): void {
+    if (YAVER_HOST_SUPPRESS) {
+      // Running inside Yaver's super-host — yield to Yaver's native UX.
+      enabled = false;
+      return;
+    }
     config = {
       trigger: 'shake',
       maxRecordingDuration: 120,

package/src/auth.ts

@@ -1,22 +1,19 @@
 /**
  * Authentication + device/agent discovery API used by the Yaver Feedback SDK.
  *
- * This module is a trimmed SDK-local port of mobile/src/lib/auth.ts. It only
- * covers what the embedded login/machine-picker flow needs:
+ * Mirrors mobile/src/lib/auth.ts:
  *
- *   - Device-code login (`POST /auth/device-code` + `GET /auth/device-code/poll`)
- *     so users can sign in via any OAuth provider (apple/google/github/gitlab/
- *     microsoft) on yaver.io without requiring deep-link wiring in the host app.
+ *   - Native Apple Sign-In (`POST /auth/apple-native`) on iOS via
+ *     `expo-apple-authentication`.
+ *   - In-app browser OAuth for Google/Microsoft/GitHub/GitLab via
+ *     `expo-web-browser`'s `openAuthSessionAsync` — same callback URL
+ *     (`yaver://oauth-callback`) the Yaver mobile app uses.
  *   - Email / password sign-up + login (no 2FA flow — for SDK simplicity).
- *   - Token validation + refresh.
+ *   - Token validation.
  *   - `/devices/list` → owned + shared (guest) remote dev machines.
  *
- * All calls target the public Yaver Convex site URL by default; callers may
- * override via `init()` config to point at staging.
- *
- * Token persistence uses `@react-native-async-storage/async-storage` (already
- * a peer dep). SecureStore is intentionally avoided to keep the SDK portable
- * to any RN host app.
+ * Mobile-only. A web equivalent will ship as a separate `yaver-web-feedback`
+ * package; do not import this module from a browser bundle.
  */
 
 // AsyncStorage is an optional peer dep — degrade gracefully if missing.
@@ -31,6 +28,41 @@ try {
   // not installed — token persistence disabled, caller must pass authToken
 }
 
+// Optional peer deps used by native sign-in and in-app browser OAuth. When
+// missing the SDK still works — Apple falls back to in-app browser OAuth, and
+// providers without expo-web-browser surface a clear error.
+type WebBrowserModule = {
+  openAuthSessionAsync: (
+    url: string,
+    redirectUrl: string,
+    options?: { showInRecents?: boolean; preferEphemeralSession?: boolean },
+  ) => Promise<{ type: string; url?: string }>;
+  maybeCompleteAuthSession: () => void;
+};
+type AppleAuthModule = {
+  isAvailableAsync: () => Promise<boolean>;
+  signInAsync: (opts: { requestedScopes: number[] }) => Promise<{
+    identityToken: string | null;
+    fullName?: { givenName?: string | null; familyName?: string | null } | null;
+  }>;
+  AppleAuthenticationScope: { FULL_NAME: number; EMAIL: number };
+};
+
+let WebBrowser: WebBrowserModule | null = null;
+try {
+  WebBrowser = require('expo-web-browser');
+  WebBrowser?.maybeCompleteAuthSession();
+} catch {
+  // optional
+}
+
+let AppleAuth: AppleAuthModule | null = null;
+try {
+  AppleAuth = require('expo-apple-authentication');
+} catch {
+  // optional — Apple sign-in falls back to in-app browser OAuth
+}
+
 const TOKEN_KEY = 'yaver_feedback_auth_token';
 const USER_KEY = 'yaver_feedback_user';
 const DEVICE_KEY = 'yaver_feedback_selected_device';
@@ -177,74 +209,119 @@ export async function validateToken(token: string): Promise<User | null> {
   }
 }
 
-// ─── Device-code flow (for OAuth via web) ─────────────────────────────
-
-export interface DeviceCodeStart {
-  userCode: string;
-  deviceCode: string;
-  expiresAt: number;
-  verificationUrl: string;
-}
+// ─── Native Apple Sign-In ─────────────────────────────────────────────
 
 /**
- * Start a device-code flow. The user opens `verificationUrl`, signs in with
- * any OAuth provider on yaver.io, and the SDK polls `pollDeviceCode` until
- * a session token is issued.
+ * Sign in with Apple using the native ASAuthorization flow. Requires
+ * `expo-apple-authentication` installed and the host app's bundle to have
+ * the "Sign in with Apple" capability enabled. iOS only.
+ *
+ * Throws `cancelled` if the user dismisses the sheet.
  */
-export async function startDeviceCode(opts?: {
-  machineName?: string;
-  platform?: string;
-  preferredProvider?: OAuthProvider;
-}): Promise<DeviceCodeStart> {
-  const res = await fetch(`${convexSiteUrl}/auth/device-code`, {
+export async function signInWithApple(): Promise<{ token: string; userId: string }> {
+  if (!AppleAuth) {
+    throw new Error(
+      'expo-apple-authentication is not installed. Add it as a peer dep to enable native Apple Sign-In.',
+    );
+  }
+  const available = await AppleAuth.isAvailableAsync();
+  if (!available) {
+    throw new Error('Apple Sign-In is not available on this device');
+  }
+
+  let credential;
+  try {
+    credential = await AppleAuth.signInAsync({
+      requestedScopes: [
+        AppleAuth.AppleAuthenticationScope.FULL_NAME,
+        AppleAuth.AppleAuthenticationScope.EMAIL,
+      ],
+    });
+  } catch (err) {
+    if ((err as { code?: string } | null)?.code === 'ERR_REQUEST_CANCELED') {
+      throw new Error('cancelled');
+    }
+    throw err;
+  }
+
+  if (!credential.identityToken) {
+    throw new Error('Apple did not return an identity token');
+  }
+
+  const fullName =
+    [credential.fullName?.givenName, credential.fullName?.familyName]
+      .filter(Boolean)
+      .join(' ') || undefined;
+
+  const res = await fetch(`${convexSiteUrl}/auth/apple-native`, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      machineName: opts?.machineName,
-      platform: opts?.platform,
-      preferredProvider: opts?.preferredProvider,
-      environment: 'feedback-sdk',
-    }),
+    body: JSON.stringify({ identityToken: credential.identityToken, fullName }),
   });
   if (!res.ok) {
-    const data = await res.json().catch(() => ({}));
-    throw new Error(data.error ?? 'Failed to start device-code');
+    const body = await res.text().catch(() => '');
+    throw new Error(body || 'Apple sign-in failed');
   }
   const data = await res.json();
-  const params = new URLSearchParams({ code: data.userCode });
-  if (opts?.preferredProvider) {
-    params.set('preferredProvider', opts.preferredProvider);
-  }
-  return {
-    userCode: data.userCode,
-    deviceCode: data.deviceCode,
-    expiresAt: data.expiresAt,
-    verificationUrl: `${webBaseUrl}/auth/device?${params.toString()}`,
-  };
+  return { token: data.token, userId: data.userId };
 }
 
-export type DeviceCodePoll =
-  | { status: 'pending' }
-  | { status: 'authorized'; token: string }
-  | { status: 'expired' };
+// ─── In-app browser OAuth (Google / GitHub / GitLab / Microsoft) ──────
 
-export async function pollDeviceCode(
-  deviceCode: string,
-): Promise<DeviceCodePoll> {
-  try {
-    const res = await fetch(
-      `${convexSiteUrl}/auth/device-code/poll?device_code=${encodeURIComponent(deviceCode)}`,
+/**
+ * Default OAuth redirect — the same callback the Yaver mobile app uses
+ * (`yaver://oauth-callback`). `WebBrowser.openAuthSessionAsync` intercepts
+ * this redirect inside the auth session, so the host app does not need to
+ * register the scheme on iOS. On Android, add an `<intent-filter>` for
+ * `yaver://oauth-callback` in the host app's AndroidManifest.xml.
+ */
+export const DEFAULT_OAUTH_REDIRECT = 'yaver://oauth-callback';
+
+/**
+ * Sign in through the in-app browser via yaver.io. Opens
+ * `https://yaver.io/api/auth/oauth/<provider>?client=mobile`, the user picks
+ * an OAuth provider, and the web callback redirects back to
+ * `yaver://oauth-callback?token=...` which `openAuthSessionAsync` captures
+ * inside the auth session. No deep-link wiring required on iOS.
+ *
+ * Throws `cancelled` if the user dismisses the browser.
+ */
+export async function signInWithOAuth(
+  provider: OAuthProvider,
+  opts?: { redirectUrl?: string; preferEphemeralSession?: boolean },
+): Promise<{ token: string }> {
+  if (!WebBrowser) {
+    throw new Error(
+      'expo-web-browser is not installed. Add it as a peer dep to enable OAuth sign-in.',
     );
-    if (!res.ok) return { status: 'expired' };
-    const data = await res.json();
-    if (data.status === 'authorized' && typeof data.token === 'string') {
-      return { status: 'authorized', token: data.token };
-    }
-    if (data.status === 'pending') return { status: 'pending' };
-    return { status: 'expired' };
+  }
+  const redirectUrl = opts?.redirectUrl ?? DEFAULT_OAUTH_REDIRECT;
+  const params = new URLSearchParams({ client: 'mobile' });
+  const authUrl = `${webBaseUrl}/api/auth/oauth/${provider}?${params.toString()}`;
+
+  const result = await WebBrowser.openAuthSessionAsync(authUrl, redirectUrl, {
+    preferEphemeralSession: opts?.preferEphemeralSession ?? false,
+    showInRecents: true,
+  });
+
+  if (result.type !== 'success' || !result.url) {
+    throw new Error('cancelled');
+  }
+
+  let token: string | null = null;
+  try {
+    const parsed = new URL(result.url);
+    token = parsed.searchParams.get('token');
   } catch {
-    return { status: 'pending' }; // network blip — let caller keep polling
+    // best-effort fallback for odd schemes
+    const match = result.url.match(/[?&]token=([^&]+)/);
+    if (match) token = decodeURIComponent(match[1]);
+  }
+
+  if (!token) {
+    throw new Error('OAuth callback did not include a token');
   }
+  return { token };
 }
 
 // ─── Email / password (no 2FA) ────────────────────────────────────────
@@ -281,10 +358,10 @@ export async function loginWithEmail(
   }
   const data = await res.json();
   if (data?.requires2fa) {
-    // SDK login surface does not handle 2FA — direct the user to complete
-    // sign-in through the web flow (device-code) which supports it.
+    // SDK login surface does not handle 2FA — direct the user to sign in
+    // through one of the OAuth providers, which complete 2FA on the web.
     throw new Error(
-      '2FA is enabled on this account. Sign in via the device-code flow instead.',
+      '2FA is enabled on this account. Sign in with Apple/Google/GitHub/GitLab/Microsoft instead.',
     );
   }
   return { token: data.token, userId: data.userId };

package/src/index.ts

@@ -52,19 +52,18 @@ export {
   saveSelectedDeviceId,
   clearSelectedDeviceId,
   validateToken,
-  startDeviceCode,
-  pollDeviceCode,
+  signInWithApple,
+  signInWithOAuth,
   signupWithEmail,
   loginWithEmail,
   listReachableDevices,
   DEFAULT_CONVEX_SITE_URL,
   DEFAULT_WEB_BASE_URL,
+  DEFAULT_OAUTH_REDIRECT,
 } from './auth';
 export type {
   OAuthProvider,
   User,
-  DeviceCodeStart,
-  DeviceCodePoll,
   RemoteDevice,
   DeviceList,
 } from './auth';

package/src/types.ts

@@ -4,7 +4,8 @@ export interface FeedbackConfig {
   /**
    * Auth token for the Yaver agent. Optional in 0.5+: if omitted, the SDK
    * will hydrate one from AsyncStorage or show its in-app login screen
-   * (device-code / email / OAuth) the first time the user triggers feedback.
+   * (Apple native / OAuth in-app browser / email) the first time the user
+   * triggers feedback.
    */
   authToken?: string;
   /**