yaver-feedback-react-native 0.7.11 → 0.7.13

package/android/src/main/java/io/yaver/feedback/YaverHotReloadModule.java

@@ -42,6 +42,9 @@ public class YaverHotReloadModule extends ReactContextBaseJavaModule {
     private static final String BUNDLE_FILE = "index.android.bundle";
     private static final String PREFS_NAME = "yaver_hot_reload";
     private static final String PREFS_KEY_BUNDLE = "bundle_path";
+    private static final String PREFS_KEY_BOOT_ATTEMPTS = "boot_attempts";
+    private static final String PREFS_KEY_BUNDLE_MTIME = "bundle_mtime";
+    private static final int MAX_BOOT_ATTEMPTS = 3;
 
     public YaverHotReloadModule(ReactApplicationContext context) {
         super(context);
@@ -173,16 +176,72 @@ public class YaverHotReloadModule extends ReactContextBaseJavaModule {
     // MARK: - Static helpers for Application/MainApplication
 
     /**
-     * Returns the hot-reloaded bundle file if it exists.
-     * Call from MainApplication.getJSBundleFile() to load the hot bundle on startup.
+     * Returns the hot-reloaded bundle file if it exists AND has not
+     * crashed on boot {@link #MAX_BOOT_ATTEMPTS} times in a row.
+     * Call from MainApplication.getJSBundleFile() to load the hot bundle
+     * on startup.
+     *
+     * Safety net for the vibe-coding loop: if a pushed bundle crashes
+     * on boot, without this guard the saved bundle persists across
+     * cold starts and bricks the app. Counter increments on each cold
+     * start, resets on {@link #markBootSuccessful(Context)} (called
+     * from MainApplication's ReactInstanceEventListener after JS
+     * context init, and a 10-s fallback timer). If the counter hits
+     * {@link #MAX_BOOT_ATTEMPTS}, delete the saved bundle and return
+     * null so MainApplication falls back to the APK-bundled bundle.
+     * See YaverHotReload.swift for the matching iOS implementation.
      */
     public static File getSavedBundleFile(Context context) {
         SharedPreferences prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
         String path = prefs.getString(PREFS_KEY_BUNDLE, null);
-        if (path != null) {
-            File f = new File(path);
-            if (f.exists()) return f;
+        if (path == null) return null;
+        File f = new File(path);
+        if (!f.exists()) return null;
+
+        long currentMtime = f.lastModified();
+        long lastMtime = prefs.getLong(PREFS_KEY_BUNDLE_MTIME, 0);
+        SharedPreferences.Editor editor = prefs.edit();
+
+        // Fresh bundle since the counter was last reset → start over.
+        if (currentMtime != lastMtime) {
+            editor.putInt(PREFS_KEY_BOOT_ATTEMPTS, 0);
+            editor.putLong(PREFS_KEY_BUNDLE_MTIME, currentMtime);
         }
-        return null;
+
+        int attempts = prefs.getInt(PREFS_KEY_BOOT_ATTEMPTS, 0);
+        if (attempts >= MAX_BOOT_ATTEMPTS) {
+            Log.w(TAG, "hot bundle failed " + attempts + " consecutive boot attempts — reverting to APK-bundled bundle.");
+            File dir = new File(context.getFilesDir(), BUNDLE_DIR);
+            if (dir.exists()) {
+                File[] list = dir.listFiles();
+                if (list != null) for (File child : list) child.delete();
+                dir.delete();
+            }
+            editor.remove(PREFS_KEY_BOOT_ATTEMPTS)
+                  .remove(PREFS_KEY_BUNDLE_MTIME)
+                  .remove(PREFS_KEY_BUNDLE)
+                  .apply();
+            return null;
+        }
+
+        // Pre-increment: this boot counts as a failure unless the JS
+        // side reaches context-initialized and calls markBootSuccessful.
+        editor.putInt(PREFS_KEY_BOOT_ATTEMPTS, attempts + 1).apply();
+        Log.i(TAG, "loading hot bundle (boot attempt " + (attempts + 1) + "/" + MAX_BOOT_ATTEMPTS + ")");
+        return f;
+    }
+
+    /**
+     * Clear the boot-attempt counter. MainApplication should call this
+     * from a ReactInstanceEventListener after JS context init, AND via
+     * a 10-s fallback Handler in case the listener never fires.
+     */
+    public static void markBootSuccessful(Context context) {
+        SharedPreferences prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
+        int attempts = prefs.getInt(PREFS_KEY_BOOT_ATTEMPTS, 0);
+        if (attempts > 0) {
+            Log.i(TAG, "boot confirmed successful — reset boot-attempt counter.");
+        }
+        prefs.edit().putInt(PREFS_KEY_BOOT_ATTEMPTS, 0).apply();
     }
 }

package/app.plugin.js

@@ -70,16 +70,24 @@ function withYaverFeedbackAndroid(config) {
 }
 
 /**
- * Copy YaverHotReload native module files into the iOS project directory.
- * Uses withDangerousMod to copy files during prebuild. The files are
- * automatically picked up by Xcode since they're in the project directory.
+ * Copy YaverHotReload native module files into the iOS project directory
+ * AND register them in project.pbxproj so Xcode actually compiles them.
+ *
+ * The file-copy step uses withDangerousMod; the project registration
+ * uses withXcodeProject. Both are needed — if we only copy the files
+ * they sit in the filesystem unreferenced, Xcode ignores them, the
+ * final .ipa has no `YaverHotReload` class, and the agent's
+ * `reload_bundle` broadcast silently fails to load a new Hermes bundle.
+ * This is a bug we've hit repeatedly; keep both steps wired.
  */
 function withYaverHotReloadNativeModule(config) {
-  return withDangerousMod(config, [
+  // Step 1 — copy source files onto disk.
+  config = withDangerousMod(config, [
     "ios",
     (config) => {
       const sdkIosDir = path.resolve(__dirname, "ios");
-      const appName = config.modRequest.projectName || "SFMG";
+      const appName = config.modRequest.projectName;
+      if (!appName) return config;
       const targetDir = path.join(
         config.modRequest.platformProjectRoot,
         appName
@@ -89,7 +97,10 @@ function withYaverHotReloadNativeModule(config) {
       for (const fileName of filesToCopy) {
         const src = path.join(sdkIosDir, fileName);
         const dst = path.join(targetDir, fileName);
-        if (fs.existsSync(src) && !fs.existsSync(dst)) {
+        if (fs.existsSync(src)) {
+          // Always overwrite so bumping the SDK version actually
+          // picks up the new native code on the next prebuild
+          // instead of silently keeping a stale copy.
           fs.copyFileSync(src, dst);
         }
       }
@@ -97,6 +108,53 @@ function withYaverHotReloadNativeModule(config) {
       return config;
     },
   ]);
+
+  // Step 2 — register the files in project.pbxproj so Xcode compiles
+  // them into the app target. Without this, the files exist on disk
+  // but are invisible to the build system.
+  config = withXcodeProject(config, (config) => {
+    const proj = config.modResults;
+    const appName = config.modRequest.projectName;
+    if (!appName) return config;
+
+    // Look up the group key for the app's source folder (same group
+    // that holds AppDelegate.swift). Expo's naming is consistent —
+    // projectName === group name in the tree.
+    const groupKey =
+      proj.findPBXGroupKey({ name: appName }) ||
+      proj.findPBXGroupKey({ path: appName });
+    if (!groupKey) return config;
+
+    // Target UUID — getFirstTarget is the app target in a standard
+    // Expo project. For multi-target projects, users can opt out via
+    // enableHotReload: false.
+    const target = proj.getFirstTarget();
+    if (!target || !target.uuid) return config;
+
+    const filesToAdd = ["YaverHotReload.swift", "YaverHotReload.m"];
+    for (const fileName of filesToAdd) {
+      const relPath = `${appName}/${fileName}`;
+      // addSourceFile registers PBXFileReference + PBXBuildFile, adds
+      // the file to the group, and wires it into the target's
+      // Sources build phase — which is exactly what we need. It's
+      // idempotent in practice because the sdk-level copyFileSync
+      // step always writes the file, and addSourceFile is a no-op if
+      // the reference already exists.
+      if (!proj.hasFile || !proj.hasFile(relPath)) {
+        try {
+          proj.addSourceFile(relPath, { target: target.uuid }, groupKey);
+        } catch (e) {
+          // If a duplicate slips through, xcode-lib throws; safe to
+          // ignore since the file already being registered is the
+          // desired state.
+        }
+      }
+    }
+
+    return config;
+  });
+
+  return config;
 }
 
 /**
@@ -146,6 +204,20 @@ function withYaverAppDelegateHook(config) {
       name: Notification.Name("YaverHotReloadBundle"),
       object: nil
     )
+    // Crash-revert safety net: clear the boot-attempt counter once
+    // RN renders its first frame, OR after 10 s of uptime — whichever
+    // fires first. If neither fires (bundle crashes before render),
+    // YaverHotReload.bundleURL() will eventually revert to the
+    // TestFlight-installed bundle after 3 failed boots. See
+    // YaverHotReload.swift for the full state machine.
+    NotificationCenter.default.addObserver(
+      forName: NSNotification.Name(rawValue: "RCTContentDidAppearNotification"),
+      object: nil,
+      queue: .main
+    ) { _ in YaverHotReload.markBootSuccessful() }
+    DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
+      YaverHotReload.markBootSuccessful()
+    }
   }
 
   @objc private func yaverHandleHotReload(_ notification: Notification) {
@@ -297,6 +369,44 @@ function withYaverAndroidHotReload(config) {
         contents.slice(methodStart);
     }
 
+    // Crash-revert safety net: clear the boot-attempt counter once
+    // the React context initializes (bundle loaded successfully), AND
+    // via a 10-s fallback Handler in case that listener never fires
+    // (e.g. infinite loop in root component). If neither fires,
+    // YaverHotReloadModule.getSavedBundleFile() reverts to the
+    // APK-bundled bundle after 3 failed cold starts. Parity with
+    // YaverHotReload.swift on iOS.
+    if (contents.includes("onCreate()") && !contents.includes("yaverHotReloadBootListener")) {
+      const onCreateIdx = contents.indexOf("onCreate()");
+      const braceIdx = contents.indexOf("{", onCreateIdx);
+      const insertionPoint = braceIdx + 1;
+      const bootGuard = `
+    // Yaver Feedback SDK hot-reload crash-revert safety net
+    final android.content.Context yaverHotReloadCtx = getApplicationContext();
+    new android.os.Handler(android.os.Looper.getMainLooper()).postDelayed(
+        new Runnable() {
+          @Override public void run() {
+            io.yaver.feedback.YaverHotReloadModule.markBootSuccessful(yaverHotReloadCtx);
+          }
+        },
+        10000
+    );
+    try {
+      com.facebook.react.ReactInstanceManager yaverRim = getReactNativeHost().getReactInstanceManager();
+      yaverRim.addReactInstanceEventListener(new com.facebook.react.ReactInstanceEventListener() {
+        @Override public void onReactContextInitialized(com.facebook.react.bridge.ReactContext ctx) {
+          io.yaver.feedback.YaverHotReloadModule.markBootSuccessful(yaverHotReloadCtx);
+        }
+      });
+    } catch (Throwable yaverHotReloadBootListener) {
+      // Older/newer RN versions may not expose ReactInstanceEventListener
+      // exactly like this; the 10-s fallback above still covers us.
+    }
+`;
+      contents =
+        contents.slice(0, insertionPoint) + bootGuard + contents.slice(insertionPoint);
+    }
+
     config.modResults.contents = contents;
     return config;
   });
@@ -308,10 +418,15 @@ function withYaverFeedback(config, props) {
   config = withYaverFeedbackIOS(config);
   config = withYaverFeedbackAndroid(config);
 
-  // Hot reload native module is opt-in via enableHotReload: true
-  // Skip by default — apps running inside Yaver container get hot reload
-  // via YaverBundleLoader, standalone dev builds use DevSettings.reload()
-  const enableHotReload = props?.enableHotReload === true;
+  // Hot reload native module is ON by default — it's the SDK's whole
+  // point. TestFlight / Play Store standalone builds have no Metro
+  // dev server, so without the YaverHotReload native module the
+  // agent's `reload_bundle` broadcast silently no-ops: the SDK falls
+  // through to DevSettings.reload() which does nothing in Release
+  // builds. Apps that specifically don't want the plugin mutating
+  // their AppDelegate / MainApplication can opt out with
+  //   ["yaver-feedback-react-native", { "enableHotReload": false }]
+  const enableHotReload = props?.enableHotReload !== false;
   if (enableHotReload) {
     config = withYaverHotReloadNativeModule(config);
     config = withYaverAppDelegateHook(config);

package/dist/LoginScreen.js

@@ -43,6 +43,10 @@ const PROVIDER_THEME = {
     github: { ion: 'logo-github', letter: 'G', fg: '#FFFFFF', bg: 'transparent' },
     gitlab: { ion: 'logo-gitlab', letter: 'G', fg: '#FC6D26', bg: 'transparent' },
     microsoft: { ion: 'logo-microsoft', letter: 'M', fg: '#00A4EF', bg: 'transparent' },
+    // Email is the universal fallback option — render a mail glyph so
+    // it visually matches the OAuth rows instead of being a naked
+    // label in a row of iconed buttons.
+    email: { ion: 'mail-outline', letter: '@', fg: '#E0E0E0', bg: 'transparent' },
 };
 const ProviderLogo = ({ provider, }) => {
     const theme = PROVIDER_THEME[provider] ?? PROVIDER_THEME.apple;
@@ -194,7 +198,10 @@ const YaverLoginScreen = ({ onLoggedIn, onCancel, }) => {
                 styles.button,
                 pressed && styles.buttonPressed,
             ]} onPress={() => setShowEmailForm(true)} disabled={busyProvider !== null}>
-                <react_native_1.Text style={styles.buttonText}>Continue with Email</react_native_1.Text>
+                <react_native_1.View style={styles.buttonContent}>
+                  <ProviderLogo provider="email"/>
+                  <react_native_1.Text style={[styles.buttonText, styles.buttonTextWithIcon]}>Continue with Email</react_native_1.Text>
+                </react_native_1.View>
               </react_native_1.Pressable>) : (<>
                 <react_native_1.View style={styles.divider}>
                   <react_native_1.View style={styles.dividerLine}/>

package/ios/YaverHotReload.swift

@@ -104,9 +104,68 @@ class YaverHotReload: NSObject {
       .appendingPathComponent(bundleFile)
   }
 
-  /// Returns the hot-reloaded bundle URL if one exists on disk.
+  /// Returns the hot-reloaded bundle URL if one exists AND hasn't
+  /// crashed on boot N times in a row.
+  ///
+  /// Vibe-coding loop: a developer pushes dozens of Hermes bundles over
+  /// the course of a session; eventually one of them crashes on boot
+  /// (missing native module, syntax error, TurboModule assert). Without
+  /// this guard, the crashing bundle persists across cold starts and
+  /// bricks the app — user has to delete + reinstall from TestFlight.
+  ///
+  /// Guard: on each cold-start bundleURL() call, increment a boot
+  /// counter. Reset it on first successful render (RCTContentDidAppear)
+  /// or after 10 s of uptime. If the counter hits kMaxBootAttempts
+  /// without being reset, the bundle has crashed every boot so far —
+  /// delete it and return nil so the app falls back to the
+  /// TestFlight-installed bundle.
+  ///
+  /// Bundle mtime is tracked separately: pushing a NEW bundle resets
+  /// the counter so each pushed bundle gets its own 3 attempts.
   @objc static func bundleURL() -> URL? {
     let path = savedBundlePath()
-    return FileManager.default.fileExists(atPath: path.path) ? path : nil
+    guard FileManager.default.fileExists(atPath: path.path) else { return nil }
+
+    let defaults = UserDefaults.standard
+    let attrs = try? FileManager.default.attributesOfItem(atPath: path.path)
+    let currentMtime = (attrs?[.modificationDate] as? Date)?.timeIntervalSince1970 ?? 0
+    let lastMtime = defaults.double(forKey: kKeyBundleMtime)
+
+    // Fresh bundle pushed since the counter was last reset → start over.
+    if currentMtime != lastMtime {
+      defaults.set(0, forKey: kKeyBootAttempts)
+      defaults.set(currentMtime, forKey: kKeyBundleMtime)
+    }
+
+    let attempts = defaults.integer(forKey: kKeyBootAttempts)
+    if attempts >= kMaxBootAttempts {
+      NSLog("[YaverHotReload] hot bundle failed %d consecutive boot attempts — reverting to app-bundled TestFlight bundle.", attempts)
+      let dir = path.deletingLastPathComponent()
+      try? FileManager.default.removeItem(at: dir)
+      defaults.removeObject(forKey: kKeyBootAttempts)
+      defaults.removeObject(forKey: kKeyBundleMtime)
+      return nil
+    }
+
+    // Pre-increment: this boot will count as a failure unless the JS
+    // side reaches first render and calls markBootSuccessful().
+    defaults.set(attempts + 1, forKey: kKeyBootAttempts)
+    NSLog("[YaverHotReload] loading hot bundle (boot attempt %d/%d)", attempts + 1, kMaxBootAttempts)
+    return path
   }
+
+  /// Clear the boot-attempt counter. Call this from AppDelegate after
+  /// first successful RN render (RCTContentDidAppearNotification) or
+  /// after a short uptime safety timer — whichever fires first.
+  @objc static func markBootSuccessful() {
+    let defaults = UserDefaults.standard
+    if defaults.integer(forKey: kKeyBootAttempts) > 0 {
+      NSLog("[YaverHotReload] boot confirmed successful — reset boot-attempt counter.")
+    }
+    defaults.set(0, forKey: kKeyBootAttempts)
+  }
+
+  static let kKeyBootAttempts = "yaverHotReloadBootAttempts"
+  static let kKeyBundleMtime = "yaverHotReloadBundleMtime"
+  static let kMaxBootAttempts = 3
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yaver-feedback-react-native",
-  "version": "0.7.11",
+  "version": "0.7.13",
   "description": "Visual feedback SDK for Yaver — bug reports, screen recording, voice annotations, and local-first developer workflows",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/LoginScreen.tsx

@@ -42,15 +42,21 @@ type ProviderTheme = {
   bg: string;
 };
 
-const PROVIDER_THEME: Record<OAuthProvider | 'apple', ProviderTheme> = {
+type LoginOption = OAuthProvider | 'apple' | 'email';
+
+const PROVIDER_THEME: Record<LoginOption, ProviderTheme> = {
   apple:     { ion: 'logo-apple',     letter: '', fg: '#FFFFFF', bg: 'transparent' },
   google:    { ion: 'logo-google',    letter: 'G', fg: '#EA4335', bg: 'transparent' },
   github:    { ion: 'logo-github',    letter: 'G', fg: '#FFFFFF', bg: 'transparent' },
   gitlab:    { ion: 'logo-gitlab',    letter: 'G', fg: '#FC6D26', bg: 'transparent' },
   microsoft: { ion: 'logo-microsoft', letter: 'M', fg: '#00A4EF', bg: 'transparent' },
+  // Email is the universal fallback option — render a mail glyph so
+  // it visually matches the OAuth rows instead of being a naked
+  // label in a row of iconed buttons.
+  email:     { ion: 'mail-outline',   letter: '@', fg: '#E0E0E0', bg: 'transparent' },
 };
 
-const ProviderLogo: React.FC<{ provider: OAuthProvider | 'apple' }> = ({
+const ProviderLogo: React.FC<{ provider: LoginOption }> = ({
   provider,
 }) => {
   const theme = PROVIDER_THEME[provider] ?? PROVIDER_THEME.apple;
@@ -263,7 +269,10 @@ export const YaverLoginScreen: React.FC<YaverLoginScreenProps> = ({
                 onPress={() => setShowEmailForm(true)}
                 disabled={busyProvider !== null}
               >
-                <Text style={styles.buttonText}>Continue with Email</Text>
+                <View style={styles.buttonContent}>
+                  <ProviderLogo provider="email" />
+                  <Text style={[styles.buttonText, styles.buttonTextWithIcon]}>Continue with Email</Text>
+                </View>
               </Pressable>
             ) : (
               <>