fix: validate bundle path before hash computation, and harden paths

- Move validate_bundle_exists! inside RendererCacheHelpers.bundle_sources so
  the guard runs before pool.server_bundle_hash / pool.rsc_bundle_hash are
  invoked. Hash computation eventually calls Digest::MD5.file / File.mtime on
  the bundle path, which raises raw Errno::ENOENT if the file is missing —
  bypassing the friendly ReactOnRailsPro::Error. Drop the now-redundant
  validate_bundle_exists! calls in both callers. Add a regression spec that
  un-stubs server_bundle_hash so the real hash-computation path runs on a
  missing bundle and asserts ReactOnRailsPro::Error (not Errno::ENOENT).
- Expand asset paths against Rails.root rather than Dir.pwd in both
  required_rsc_asset_paths and the per-asset lookups in copy_assets /
  symlink_assets. This keeps the Set comparison consistent when the rake
  task runs from a different cwd (e.g. inside a Docker RUN step).
- Snapshot ReactOnRailsPro.configuration once at the top of collect_assets
  so both reads see the same value and the method makes one dispatch.
- Remove dead `extend FileUtils` in PrepareNodeRenderBundles (no longer
  used after the refactor to explicit FileUtils. prefixes).
- Add symmetric RENDERER_BUNDLE_PATH deprecation spec in
  prepare_node_renderer_bundles_spec.rb.

All 20 dummy specs pass; rubocop clean.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: justin808

react_on_rails_pro/lib/react_on_rails_pro/pre_seed_renderer_cache.rb

@@ -21,8 +21,7 @@ def self.call
       assets = RendererCacheHelpers.collect_assets
       rsc_required_paths = RendererCacheHelpers.required_rsc_asset_paths
 
-      RendererCacheHelpers.bundle_sources(pool).each do |src_bundle_path, bundle_hash|
-        RendererCacheHelpers.validate_bundle_exists!(src_bundle_path, "pre-seeding")
+      RendererCacheHelpers.bundle_sources(pool, "pre-seeding").each do |src_bundle_path, bundle_hash|
         seed_bundle(src_bundle_path, bundle_hash, cache_dir)
         # The Node Renderer serves manifests from whichever bundle dir it loaded,
         # so both server and RSC dirs need the manifests present.
@@ -48,10 +47,12 @@ def self.seed_bundle(src_path, bundle_hash, cache_dir)
     # the renderer to fail at runtime with a hard-to-diagnose error. User-configured
     # assets_to_copy are optional and only produce a warning. Required assets are
     # matched by expanded path rather than basename so a same-named unrelated entry
-    # in assets_to_copy cannot trigger a false-positive "required" error.
+    # in assets_to_copy cannot trigger a false-positive "required" error. Expand
+    # against Rails.root to match how RendererCacheHelpers.required_rsc_asset_paths
+    # builds its Set.
     def self.copy_assets(assets, bundle_dir, rsc_required_paths)
       assets.each do |asset_path|
-        expanded = File.expand_path(asset_path.to_s)
+        expanded = File.expand_path(asset_path.to_s, Rails.root)
         unless File.exist?(expanded)
           if rsc_required_paths.include?(expanded)
             raise ReactOnRailsPro::Error, "Required RSC asset not found: #{asset_path}. " \

react_on_rails_pro/lib/react_on_rails_pro/prepare_node_renderer_bundles.rb

@@ -10,8 +10,6 @@ module ReactOnRailsPro
   # restores. The staged layout matches the renderer's runtime cache contract:
   # <cache>/<bundleHash>/<bundleHash>.js
   class PrepareNodeRenderBundles
-    extend FileUtils
-
     def self.make_relative_symlink(source, destination)
       destination_dir = Pathname.new(destination).dirname
       FileUtils.mkdir_p(destination_dir)
@@ -39,8 +37,7 @@ def self.call
       assets = RendererCacheHelpers.collect_assets
       rsc_required_paths = RendererCacheHelpers.required_rsc_asset_paths
 
-      RendererCacheHelpers.bundle_sources(pool).each do |src_bundle_path, bundle_hash|
-        RendererCacheHelpers.validate_bundle_exists!(src_bundle_path, "pre-staging")
+      RendererCacheHelpers.bundle_sources(pool, "pre-staging").each do |src_bundle_path, bundle_hash|
         bundle_dir = File.join(cache_dir, bundle_hash.to_s)
         bundle_dest_path = File.join(bundle_dir, "#{bundle_hash}.js")
         make_relative_symlink(src_bundle_path, bundle_dest_path)
@@ -50,10 +47,11 @@ def self.call
 
     # Required assets are matched by expanded path rather than basename so a
     # same-named unrelated entry in assets_to_copy cannot trigger a false-
-    # positive "required" error.
+    # positive "required" error. Expand against Rails.root to match how
+    # RendererCacheHelpers.required_rsc_asset_paths builds its Set.
     def self.symlink_assets(assets, bundle_dir, rsc_required_paths)
       assets.each do |asset_path|
-        expanded = File.expand_path(asset_path.to_s)
+        expanded = File.expand_path(asset_path.to_s, Rails.root)
         unless File.exist?(expanded)
           if rsc_required_paths.include?(expanded)
             raise ReactOnRailsPro::Error, "Required RSC asset not found: #{asset_path}. " \

react_on_rails_pro/lib/react_on_rails_pro/renderer_cache_helpers.rb

@@ -10,23 +10,28 @@ module RendererCacheHelpers
     module_function
 
     def collect_assets
-      assets = Array(ReactOnRailsPro.configuration.assets_to_copy).dup
+      config = ReactOnRailsPro.configuration
+      assets = Array(config.assets_to_copy).dup
 
-      if ReactOnRailsPro.configuration.enable_rsc_support
+      if config.enable_rsc_support
         assets << ReactOnRailsPro::Utils.react_client_manifest_file_path
         assets << ReactOnRailsPro::Utils.react_server_client_manifest_file_path
       end
 
       assets.compact_blank
     end
 
+    # Must expand against Rails.root so that callers who expand per-asset paths
+    # against the same base produce Set-comparable strings. Without an explicit
+    # base, File.expand_path uses Dir.pwd, which differs in Docker RUN steps
+    # and would make the Set lookup miss.
     def required_rsc_asset_paths
       return Set.new unless ReactOnRailsPro.configuration.enable_rsc_support
 
       Set.new(
         [
-          File.expand_path(ReactOnRailsPro::Utils.react_client_manifest_file_path.to_s),
-          File.expand_path(ReactOnRailsPro::Utils.react_server_client_manifest_file_path.to_s)
+          File.expand_path(ReactOnRailsPro::Utils.react_client_manifest_file_path.to_s, Rails.root),
+          File.expand_path(ReactOnRailsPro::Utils.react_server_client_manifest_file_path.to_s, Rails.root)
         ]
       )
     end
@@ -42,12 +47,21 @@ def validate_bundle_exists!(path, action_description)
     # Resolves bundle sources as [path, hash] pairs so callers can iterate
     # without needing to re-call pool methods. `pool` must respond to
     # `server_bundle_hash` and (when RSC is enabled) `rsc_bundle_hash`.
-    def bundle_sources(pool)
-      sources = [[ReactOnRails::Utils.server_bundle_js_file_path, pool.server_bundle_hash]]
+    #
+    # Validates each bundle path exists *before* computing its hash, because
+    # `pool.server_bundle_hash` eventually calls `Digest::MD5.file` / `File.mtime`
+    # on the bundle path, which raises raw `Errno::ENOENT` if the file is
+    # missing — bypassing the friendly `ReactOnRailsPro::Error` message.
+    def bundle_sources(pool, action_description)
+      server_bundle_path = ReactOnRails::Utils.server_bundle_js_file_path
+      validate_bundle_exists!(server_bundle_path, action_description)
+      sources = [[server_bundle_path, pool.server_bundle_hash]]
 
       return sources unless ReactOnRailsPro.configuration.enable_rsc_support
 
-      sources << [ReactOnRailsPro::Utils.rsc_bundle_js_file_path, pool.rsc_bundle_hash]
+      rsc_bundle_path = ReactOnRailsPro::Utils.rsc_bundle_js_file_path
+      validate_bundle_exists!(rsc_bundle_path, action_description)
+      sources << [rsc_bundle_path, pool.rsc_bundle_hash]
       sources
     end
   end

react_on_rails_pro/spec/dummy/spec/prepare_node_renderer_bundles_spec.rb

@@ -96,6 +96,23 @@
     end
   end
 
+  # Regression: bundle existence must be validated before pool.server_bundle_hash
+  # is invoked, since the hash computation calls File.mtime / Digest::MD5.file on
+  # the bundle path and would otherwise leak a raw Errno::ENOENT.
+  context "when server bundle doesn't exist and server_bundle_hash is not stubbed" do
+    before do
+      FileUtils.rm_f(server_bundle_path)
+      pool = ReactOnRailsPro::ServerRenderingPool::NodeRenderingPool
+      allow(pool).to receive(:server_bundle_hash).and_call_original
+      pool.instance_variable_set(:@server_bundle_hash, nil)
+      ReactOnRailsPro::Utils.instance_variable_set(:@bundle_hash, nil)
+    end
+
+    it "raises ReactOnRailsPro::Error rather than a raw Errno::ENOENT" do
+      expect { pre_stage_cache }.to raise_error(ReactOnRailsPro::Error, /Bundle not found/)
+    end
+  end
+
   context "with RENDERER_SERVER_BUNDLE_CACHE_PATH env var" do
     let(:custom_cache_dir) { Dir.mktmpdir("renderer-cache-test") }
 
@@ -116,6 +133,24 @@
     end
   end
 
+  context "with deprecated RENDERER_BUNDLE_PATH env var" do
+    let(:custom_cache_dir) { Dir.mktmpdir("renderer-cache-test") }
+
+    before do
+      ENV["RENDERER_BUNDLE_PATH"] = custom_cache_dir
+      allow(ReactOnRailsPro.configuration).to receive(:assets_to_copy).and_return(nil)
+    end
+
+    after { FileUtils.rm_rf(custom_cache_dir) }
+
+    it "uses the deprecated env var with a warning" do
+      expect { pre_stage_cache }.to output(/RENDERER_BUNDLE_PATH is deprecated/).to_stderr
+
+      dest_file = File.join(custom_cache_dir, bundle_hash, "#{bundle_hash}.js")
+      expect(File.exist?(dest_file)).to be(true)
+    end
+  end
+
   context "when RSC support is enabled" do
     let(:rsc_bundle_path) { Rails.root.join("public", "webpack", "production", "rsc-bundle.js").to_s }
     let(:rsc_bundle_hash) { "rsc-bundle-hash-xyz789" }