pulse-updates 1.0.16 → 1.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pulse-updates",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "OTA updates for React Native - lightweight alternative to expo-updates",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",

package/scripts/publish.mjs

@@ -157,12 +157,15 @@ function getMimeType(ext) {
  */
 function findHermesc(platform) {
   const possiblePaths = [
-    // iOS paths
+    // iOS paths (present once Pods are installed)
     'ios/Pods/hermes-engine/destroot/bin/hermesc',
+    // hermesc as shipped inside react-native itself (host-arch dirs vary by RN version)
     'node_modules/react-native/sdks/hermesc/osx-bin/hermesc',
     'node_modules/react-native/sdks/hermesc/linux64-bin/hermesc',
-    // Android paths
+    'node_modules/react-native/sdks/hermesc/win64-bin/hermesc.exe',
+    // Android paths (present once an Android build has run)
     'node_modules/react-native/ReactAndroid/hermes-engine/build/hermes/bin/hermesc',
+    'node_modules/react-native/ReactAndroid/hermes-engine/build/hermes/tools/hermesc/hermesc',
   ];
 
   for (const p of possiblePaths) {
@@ -172,12 +175,61 @@ function findHermesc(platform) {
     }
   }
 
-  // Try to find via which
+  // Try to find via PATH
   try {
-    return execSync('which hermesc', { encoding: 'utf8' }).trim();
+    const viaPath = execSync('command -v hermesc', { encoding: 'utf8' }).trim();
+    if (viaPath) return viaPath;
   } catch {
-    return null;
+    /* not on PATH */
+  }
+  return null;
+}
+
+/**
+ * Locate hermesc, and if it isn't there yet, try to materialize it.
+ * Only used when the caller has REQUIRED Hermes (config.requireHermes / --require-hermes).
+ * A React Native app may only carry hermesc inside the installed CocoaPods (it
+ * does not always ship in node_modules for every RN version), so on macOS a
+ * missing compiler often means "Pods aren't installed" — which we fix by running
+ * pod-install once, then re-checking. If it still can't be found we throw, rather
+ * than silently shipping a plain-JS OTA bundle (readable source over the air).
+ * Apps that intentionally run without Hermes must NOT set requireHermes — they get
+ * the default best-effort path (compile if hermesc is present, plain JS otherwise).
+ */
+function ensureHermesc(platform) {
+  let hermesc = findHermesc(platform);
+  if (hermesc) return hermesc;
+
+  const onMac = process.platform === 'darwin';
+  const hasPodfile = fs.existsSync(path.resolve('ios/Podfile'));
+  if (onMac && hasPodfile) {
+    logWarning('Hermes compiler not found — installing iOS Pods to obtain it (one-shot)...');
+    try {
+      // Prefer a repo pod-install helper if the app provides one, else npx pod-install.
+      const repoHelper = path.resolve('scripts/pod-install-if-mac.js');
+      const cmd = fs.existsSync(repoHelper)
+        ? `node ${repoHelper}`
+        : 'npx pod-install ios';
+      execSync(cmd, { stdio: 'inherit' });
+    } catch (error) {
+      throw new Error(
+        `Hermes compiler not found and automatic pod install failed (${error.message}). ` +
+        'Run `npx pod-install ios` (or `cd ios && pod install`) and publish again.'
+      );
+    }
+    hermesc = findHermesc(platform);
+  }
+
+  if (!hermesc) {
+    throw new Error(
+      'Hermes compiler (hermesc) could not be located. Pulse publishes Hermes bytecode only — ' +
+      'a plain-JS OTA bundle must never be shipped. Install it before publishing:\n' +
+      '  • macOS: `npx pod-install ios` (materializes ios/Pods/hermes-engine/.../hermesc)\n' +
+      '  • or ensure react-native ships hermesc under node_modules/react-native/sdks/hermesc/\n' +
+      '  • or put hermesc on PATH.'
+    );
   }
+  return hermesc;
 }
 
 /**
@@ -210,11 +262,26 @@ function createBundle(platform, bundleDir, entryFile = 'index.ts') {
 }
 
 /**
- * Compile bundle with Hermes
+ * Compile bundle with Hermes.
+ *
+ * Default (best-effort): if hermesc is found, compile to bytecode; if not, warn and
+ * ship the plain JS bundle — this is correct for apps that don't run Hermes (JSC,
+ * or an intentionally plain-JS runtime), which is why it stays the default.
+ *
+ * With options.requireHermes (config.requireHermes / --require-hermes): the app has
+ * declared it runs on Hermes, so a plain-JS OTA would be both readable source and a
+ * runtime mismatch. In that mode we locate-or-materialize hermesc (throwing if we
+ * can't), pass -fstrip-function-names to shrink the string table, and assert the
+ * output is bytecode before returning. eSound and Lyra run in this mode.
  */
-function compileWithHermes(bundlePath, platform) {
-  const hermesc = findHermesc(platform);
+function compileWithHermes(bundlePath, platform, options = {}) {
+  const requireHermes = !!options.requireHermes;
+
+  // In required mode, ensureHermesc throws if it can't obtain a compiler.
+  // Otherwise fall back to best-effort discovery.
+  const hermesc = requireHermes ? ensureHermesc(platform) : findHermesc(platform);
   if (!hermesc) {
+    // Only reachable when Hermes is NOT required.
     logWarning('Hermes compiler not found, using plain JS bundle');
     return bundlePath;
   }
@@ -223,33 +290,49 @@ function compileWithHermes(bundlePath, platform) {
 
   log(`  Compiling with Hermes...`, colors.dim);
 
-  try {
-    // Use spawnSync with larger buffer to avoid ENOBUFS error
-    const result = spawnSync(hermesc, ['-emit-binary', '-out', hbcPath, bundlePath], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-      maxBuffer: 100 * 1024 * 1024, // 100MB buffer
-      encoding: 'utf8',
-    });
-
-    if (result.error) {
-      throw result.error;
-    }
+  // -emit-binary: Hermes bytecode.
+  // -fstrip-function-names (required mode only): drop JS function names from the
+  //   bytecode string table (smaller bundle, less readable). Trade-off: JS function
+  //   names disappear from crash stack traces, so it stays opt-in via requireHermes.
+  //   Does NOT touch string literals.
+  const hermesArgs = ['-emit-binary'];
+  if (requireHermes) hermesArgs.push('-fstrip-function-names');
+  hermesArgs.push('-out', hbcPath, bundlePath);
+
+  // Use spawnSync with larger buffer to avoid ENOBUFS error
+  const result = spawnSync(hermesc, hermesArgs, {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    maxBuffer: 100 * 1024 * 1024, // 100MB buffer
+    encoding: 'utf8',
+  });
 
-    if (result.status !== 0) {
-      const stderr = result.stderr || '';
-      throw new Error(`Hermes exited with code ${result.status}: ${stderr.slice(0, 500)}`);
-    }
+  if (result.error) {
+    if (requireHermes) throw result.error;
+    logWarning(`Hermes compilation failed: ${result.error.message}`);
+    return bundlePath;
+  }
 
-    // Remove the plain JS bundle, keep only HBC
-    fs.unlinkSync(bundlePath);
-    // Rename .hbc to .bundle for compatibility
-    const finalPath = bundlePath;
-    fs.renameSync(hbcPath, finalPath);
-    return finalPath;
-  } catch (error) {
-    logWarning(`Hermes compilation failed: ${error.message}`);
+  if (result.status !== 0) {
+    const stderr = result.stderr || '';
+    const message = `Hermes exited with code ${result.status}: ${stderr.slice(0, 500)}`;
+    if (requireHermes) throw new Error(message);
+    logWarning(`Hermes compilation failed: ${message}`);
     return bundlePath;
   }
+
+  // Remove the plain JS bundle, keep only HBC
+  fs.unlinkSync(bundlePath);
+  // Rename .hbc to .bundle for compatibility
+  const finalPath = bundlePath;
+  fs.renameSync(hbcPath, finalPath);
+
+  // In required mode, belt-and-suspenders: the launch asset MUST be Hermes bytecode.
+  if (requireHermes && !isHermesBytecode(finalPath)) {
+    throw new Error(
+      'Post-compile check failed: launch bundle is not Hermes bytecode. Refusing to publish a plain-JS OTA bundle.'
+    );
+  }
+  return finalPath;
 }
 
 /**
@@ -656,6 +739,12 @@ function loadConfig(options) {
     skipBundle: options['skip-bundle'] || false,
     build: options.build || process.env.PULSE_BUILD || fileConfig.build || null,
     message: options.message || fileConfig.message || null,
+    // Opt-in: the app runs on Hermes, so a plain-JS OTA must never be shipped.
+    // Makes a missing/failing hermesc fatal (with a one-shot pod-install attempt on
+    // macOS), enables -fstrip-function-names, and asserts bytecode output.
+    // Leave unset for apps that intentionally run plain JS (best-effort default).
+    requireHermes: options['require-hermes'] || process.env.PULSE_REQUIRE_HERMES === '1' ||
+      fileConfig.requireHermes || false,
   };
 }
 
@@ -705,7 +794,7 @@ async function publish(options) {
 
     // Step 2: Compile with Hermes
     logStep('2/6', 'Compiling with Hermes...');
-    compileWithHermes(bundlePath, config.platform);
+    compileWithHermes(bundlePath, config.platform, { requireHermes: config.requireHermes });
     logSuccess('Hermes compilation complete');
   } else {
     logStep('1/6', 'Skipping bundle creation (--skip-bundle)');