Enhance process manager with universal bundler context fallback

This commit generalizes the foreman-specific bundler context fix to work
for ALL process managers (overmind, foreman, and any future additions).

Key improvements:
- Context-aware process detection for all processes, not just foreman
- Universal fallback mechanism using Bundler.with_unbundled_env
- Consistent API with run_process(process, args) for any process manager
- Enhanced test coverage for generalized functionality

Benefits:
- Robust handling of bundler context for any process manager
- Future-proof architecture for new process managers
- Consistent behavior across all system commands
- Eliminates bundler interceptor issues universally

Builds on previous commit to create a comprehensive solution.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: AbanoubGhadban

lib/react_on_rails/dev/process_manager.rb

@@ -4,11 +4,10 @@ module ReactOnRails
   module Dev
     class ProcessManager
       class << self
+        # Check if a process is available and usable in the current execution context
+        # This accounts for bundler context where system commands might be intercepted
         def installed?(process)
-          IO.popen([process, "-v"], &:close)
-          true
-        rescue Errno::ENOENT
-          false
+          installed_in_current_context?(process)
         end
 
         def ensure_procfile(procfile)
@@ -31,10 +30,10 @@ def run_with_process_manager(procfile)
           # Clean up stale files before starting
           FileManager.cleanup_stale_files
 
-          if installed?("overmind")
-            system("overmind", "start", "-f", procfile)
-          elsif foreman_available?
-            run_foreman(procfile)
+          if process_available?("overmind")
+            run_process("overmind", ["start", "-f", procfile])
+          elsif process_available?("foreman")
+            run_process("foreman", ["start", "-f", procfile])
           else
             show_process_manager_installation_help
             exit 1
@@ -43,50 +42,63 @@ def run_with_process_manager(procfile)
 
         private
 
-        # Check if foreman is available in either bundler context or system-wide
-        def foreman_available?
-          installed?("foreman") || foreman_available_in_system?
+        # Check if a process is actually usable in the current execution context
+        # This is important for commands that might be intercepted by bundler
+        def installed_in_current_context?(process)
+          # Try to execute the process with a simple flag to see if it works
+          # Use system() because that's how we'll actually call it later
+          system(process, "--version", out: File::NULL, err: File::NULL)
+        rescue Errno::ENOENT
+          false
+        end
+
+        # Check if a process is available in either current context or system-wide
+        def process_available?(process)
+          installed?(process) || process_available_in_system?(process)
         end
 
-        # Try to run foreman with intelligent fallback strategy
-        # First attempt: within bundler context (for projects that include foreman in Gemfile)
-        # Fallback: outside bundler context (for projects following React on Rails best practices)
-        def run_foreman(procfile)
-          success = if installed?("foreman")
-                      # Try within bundle context first
-                      system("foreman", "start", "-f", procfile)
+        # Try to run a process with intelligent fallback strategy
+        # First attempt: within current context (for processes that are in the current bundle)
+        # Fallback: outside bundler context (for system-installed processes)
+        def run_process(process, args)
+          success = if installed?(process)
+                      # Process works in current context - use it directly
+                      system(process, *args)
                     else
                       false
                     end
 
-          # If bundler context failed or foreman not in bundle, try system foreman
+          # If current context failed or process not available, try system process
           return if success
 
-          run_foreman_outside_bundle(procfile)
+          run_process_outside_bundle(process, args)
         end
 
-        # Run foreman outside of bundler context using Bundler.with_unbundled_env
-        # This allows using system-installed foreman even when it's not in the Gemfile
-        def run_foreman_outside_bundle(procfile)
+        # Run a process outside of bundler context using Bundler.with_unbundled_env
+        # This allows using system-installed processes even when they're not in the Gemfile
+        def run_process_outside_bundle(process, args)
           if defined?(Bundler)
             Bundler.with_unbundled_env do
-              system("foreman", "start", "-f", procfile)
+              system(process, *args)
             end
           else
             # Fallback if Bundler is not available
-            system("foreman", "start", "-f", procfile)
+            system(process, *args)
           end
         end
 
-        # Check if foreman is available system-wide (outside bundle context)
-        def foreman_available_in_system?
+        # Check if a process is available system-wide (outside bundle context)
+        def process_available_in_system?(process)
           if defined?(Bundler)
             Bundler.with_unbundled_env do
-              installed?("foreman")
+              # Use system() directly to check if process exists outside bundler context
+              system(process, "--version", out: File::NULL, err: File::NULL)
             end
           else
             false
           end
+        rescue Errno::ENOENT
+          false
         end
 
         # Improved error message with helpful guidance

spec/react_on_rails/dev/process_manager_spec.rb

@@ -18,15 +18,23 @@
   end
 
   describe ".installed?" do
-    it "returns true when process is available" do
-      allow(IO).to receive(:popen).with(["overmind", "-v"]).and_return("Some version info")
+    it "returns true when process is available in current context" do
+      expect_any_instance_of(Kernel).to receive(:system)
+        .with("overmind", "--version", out: File::NULL, err: File::NULL).and_return(true)
       expect(described_class).to be_installed("overmind")
     end
 
-    it "returns false when process is not available" do
-      allow(IO).to receive(:popen).with(["nonexistent", "-v"]).and_raise(Errno::ENOENT)
+    it "returns false when process is not available in current context" do
+      expect_any_instance_of(Kernel).to receive(:system)
+        .with("nonexistent", "--version", out: File::NULL, err: File::NULL).and_raise(Errno::ENOENT)
       expect(described_class.installed?("nonexistent")).to be false
     end
+
+    it "returns false when process returns false" do
+      expect_any_instance_of(Kernel).to receive(:system)
+        .with("failing_process", "--version", out: File::NULL, err: File::NULL).and_return(false)
+      expect(described_class.installed?("failing_process")).to be false
+    end
   end
 
   describe ".ensure_procfile" do
@@ -50,123 +58,134 @@
     end
 
     it "uses overmind when available" do
-      allow(described_class).to receive(:installed?).with("overmind").and_return(true)
-      expect_any_instance_of(Kernel).to receive(:system).with("overmind", "start", "-f", "Procfile.dev")
+      allow(described_class).to receive(:process_available?).with("overmind").and_return(true)
+      expect(described_class).to receive(:run_process).with("overmind", ["start", "-f", "Procfile.dev"])
 
       described_class.run_with_process_manager("Procfile.dev")
     end
 
-    it "uses foreman when overmind not available and foreman is in bundle" do
-      allow(described_class).to receive(:installed?).with("overmind").and_return(false)
-      allow(described_class).to receive(:foreman_available?).and_return(true)
-      allow(described_class).to receive(:installed?).with("foreman").and_return(true)
-      expect(described_class).to receive(:run_foreman).with("Procfile.dev")
+    it "uses foreman when overmind not available and foreman is available" do
+      allow(described_class).to receive(:process_available?).with("overmind").and_return(false)
+      allow(described_class).to receive(:process_available?).with("foreman").and_return(true)
+      expect(described_class).to receive(:run_process).with("foreman", ["start", "-f", "Procfile.dev"])
 
       described_class.run_with_process_manager("Procfile.dev")
     end
 
     it "exits with error when no process manager available" do
-      allow(described_class).to receive(:installed?).with("overmind").and_return(false)
-      allow(described_class).to receive(:foreman_available?).and_return(false)
+      allow(described_class).to receive(:process_available?).with("overmind").and_return(false)
+      allow(described_class).to receive(:process_available?).with("foreman").and_return(false)
       expect(described_class).to receive(:show_process_manager_installation_help)
       expect_any_instance_of(Kernel).to receive(:exit).with(1)
 
       described_class.run_with_process_manager("Procfile.dev")
     end
 
     it "cleans up stale files before starting" do
-      allow(described_class).to receive(:installed?).with("overmind").and_return(true)
+      allow(described_class).to receive(:process_available?).with("overmind").and_return(true)
+      allow(described_class).to receive(:run_process)
       expect(ReactOnRails::Dev::FileManager).to receive(:cleanup_stale_files)
 
       described_class.run_with_process_manager("Procfile.dev")
     end
   end
 
-  describe ".foreman_available?" do
-    it "returns true when foreman is available in bundle context" do
+  describe ".process_available?" do
+    it "returns true when process is available in current context" do
       allow(described_class).to receive(:installed?).with("foreman").and_return(true)
-      allow(described_class).to receive(:foreman_available_in_system?).and_return(false)
+      allow(described_class).to receive(:process_available_in_system?).with("foreman").and_return(false)
 
-      expect(described_class.send(:foreman_available?)).to be true
+      expect(described_class.send(:process_available?, "foreman")).to be true
     end
 
-    it "returns true when foreman is available system-wide" do
+    it "returns true when process is available system-wide" do
       allow(described_class).to receive(:installed?).with("foreman").and_return(false)
-      allow(described_class).to receive(:foreman_available_in_system?).and_return(true)
+      allow(described_class).to receive(:process_available_in_system?).with("foreman").and_return(true)
 
-      expect(described_class.send(:foreman_available?)).to be true
+      expect(described_class.send(:process_available?, "foreman")).to be true
     end
 
-    it "returns false when foreman is not available anywhere" do
+    it "returns false when process is not available anywhere" do
       allow(described_class).to receive(:installed?).with("foreman").and_return(false)
-      allow(described_class).to receive(:foreman_available_in_system?).and_return(false)
+      allow(described_class).to receive(:process_available_in_system?).with("foreman").and_return(false)
 
-      expect(described_class.send(:foreman_available?)).to be false
+      expect(described_class.send(:process_available?, "foreman")).to be false
     end
   end
 
-  describe ".run_foreman" do
+  describe ".run_process" do
     before do
       allow_any_instance_of(Kernel).to receive(:system).and_return(true)
     end
 
-    it "tries bundle context first when foreman is in bundle" do
+    it "tries current context first when process works there" do
       allow(described_class).to receive(:installed?).with("foreman").and_return(true)
       expect_any_instance_of(Kernel).to receive(:system).with("foreman", "start", "-f", "Procfile.dev").and_return(true)
-      expect(described_class).not_to receive(:run_foreman_outside_bundle)
+      expect(described_class).not_to receive(:run_process_outside_bundle)
 
-      described_class.send(:run_foreman, "Procfile.dev")
+      described_class.send(:run_process, "foreman", ["start", "-f", "Procfile.dev"])
     end
 
-    it "falls back to system foreman when bundle context fails" do
+    it "falls back to system process when current context fails" do
       allow(described_class).to receive(:installed?).with("foreman").and_return(true)
       expect_any_instance_of(Kernel).to receive(:system)
         .with("foreman", "start", "-f", "Procfile.dev").and_return(false)
-      expect(described_class).to receive(:run_foreman_outside_bundle).with("Procfile.dev")
+      expect(described_class).to receive(:run_process_outside_bundle).with("foreman", ["start", "-f", "Procfile.dev"])
 
-      described_class.send(:run_foreman, "Procfile.dev")
+      described_class.send(:run_process, "foreman", ["start", "-f", "Procfile.dev"])
     end
 
-    it "uses system foreman directly when not in bundle" do
-      allow(described_class).to receive(:installed?).with("foreman").and_return(false)
-      expect(described_class).to receive(:run_foreman_outside_bundle).with("Procfile.dev")
+    it "uses system process directly when not available in current context" do
+      allow(described_class).to receive(:installed?).with("overmind").and_return(false)
+      expect(described_class).to receive(:run_process_outside_bundle).with("overmind", ["start", "-f", "Procfile.dev"])
 
-      described_class.send(:run_foreman, "Procfile.dev")
+      described_class.send(:run_process, "overmind", ["start", "-f", "Procfile.dev"])
     end
   end
 
-  describe ".run_foreman_outside_bundle" do
+  describe ".run_process_outside_bundle" do
     it "uses Bundler.with_unbundled_env when Bundler is available" do
       bundler_double = class_double(Bundler)
       stub_const("Bundler", bundler_double)
       expect(bundler_double).to receive(:with_unbundled_env).and_yield
       expect_any_instance_of(Kernel).to receive(:system).with("foreman", "start", "-f", "Procfile.dev")
 
-      described_class.send(:run_foreman_outside_bundle, "Procfile.dev")
+      described_class.send(:run_process_outside_bundle, "foreman", ["start", "-f", "Procfile.dev"])
     end
 
     it "falls back to direct system call when Bundler is not available" do
       hide_const("Bundler")
       expect_any_instance_of(Kernel).to receive(:system).with("foreman", "start", "-f", "Procfile.dev")
 
-      described_class.send(:run_foreman_outside_bundle, "Procfile.dev")
+      described_class.send(:run_process_outside_bundle, "foreman", ["start", "-f", "Procfile.dev"])
     end
   end
 
-  describe ".foreman_available_in_system?" do
-    it "checks foreman availability outside bundle context" do
+  describe ".process_available_in_system?" do
+    it "checks process availability outside bundle context" do
       bundler_double = class_double(Bundler)
       stub_const("Bundler", bundler_double)
       expect(bundler_double).to receive(:with_unbundled_env).and_yield
-      expect(described_class).to receive(:installed?).with("foreman").and_return(true)
+      expect_any_instance_of(Kernel).to receive(:system)
+        .with("foreman", "--version", out: File::NULL, err: File::NULL).and_return(true)
 
-      expect(described_class.send(:foreman_available_in_system?)).to be true
+      expect(described_class.send(:process_available_in_system?, "foreman")).to be true
     end
 
     it "returns false when Bundler is not available" do
       hide_const("Bundler")
 
-      expect(described_class.send(:foreman_available_in_system?)).to be false
+      expect(described_class.send(:process_available_in_system?, "foreman")).to be false
+    end
+
+    it "returns false when process fails outside bundle context" do
+      bundler_double = class_double(Bundler)
+      stub_const("Bundler", bundler_double)
+      expect(bundler_double).to receive(:with_unbundled_env).and_yield
+      expect_any_instance_of(Kernel).to receive(:system)
+        .with("overmind", "--version", out: File::NULL, err: File::NULL).and_return(false)
+
+      expect(described_class.send(:process_available_in_system?, "overmind")).to be false
     end
   end