Add timeout protection for version checking operations

This commit adds a 5-second timeout to all version checking operations to
prevent the development setup from hanging indefinitely on unresponsive
process managers.

Safety improvements:
- Timeout protection for installed_in_current_context? checks
- Timeout protection for process_available_in_system? checks
- Graceful handling of Timeout::Error alongside Errno::ENOENT
- Prevents hanging development setup on problematic installations

Implementation details:
- Uses Ruby's Timeout module with 5-second limit
- Only applied to version checking, not main process execution
- Main process execution remains unlimited (expected for dev servers)
- Comprehensive test coverage for timeout scenarios

The timeout is conservative (5 seconds) to account for slow systems while
still preventing indefinite hangs that would block developer workflow.

🤖 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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "timeout"
+
 module ReactOnRails
   module Dev
     class ProcessManager
@@ -46,9 +48,12 @@ def installed_in_current_context?(process)
           # Try to execute the process with version flags to see if it works
           # Use system() because that's how we'll actually call it later
           version_flags_for(process).any? do |flag|
-            system(process, flag, out: File::NULL, err: File::NULL)
+            # Add timeout to prevent hanging on version checks
+            Timeout.timeout(5) do
+              system(process, flag, out: File::NULL, err: File::NULL)
+            end
           end
-        rescue Errno::ENOENT
+        rescue Errno::ENOENT, Timeout::Error
           false
         end
 
@@ -97,10 +102,13 @@ def process_available_in_system?(process)
           Bundler.with_unbundled_env do
             # Try version flags to check if process exists outside bundler context
             version_flags_for(process).any? do |flag|
-              system(process, flag, out: File::NULL, err: File::NULL)
+              # Add timeout to prevent hanging on version checks
+              Timeout.timeout(5) do
+                system(process, flag, out: File::NULL, err: File::NULL)
+              end
             end
           end
-        rescue Errno::ENOENT
+        rescue Errno::ENOENT, Timeout::Error
           false
         end
 

spec/react_on_rails/dev/process_manager_spec.rb

@@ -19,18 +19,19 @@
 
   describe ".installed?" do
     it "returns true when process is available in current context" do
+      expect(Timeout).to receive(:timeout).with(5).and_yield
       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 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(Timeout).to receive(:timeout).with(5).and_raise(Errno::ENOENT)
       expect(described_class.installed?("nonexistent")).to be false
     end
 
     it "returns false when all version flags fail" do
+      expect(Timeout).to receive(:timeout).with(5).exactly(3).times.and_yield
       expect_any_instance_of(Kernel).to receive(:system)
         .with("failing_process", "--version", out: File::NULL, err: File::NULL).and_return(false)
       expect_any_instance_of(Kernel).to receive(:system)
@@ -41,12 +42,18 @@
     end
 
     it "returns true when second version flag succeeds" do
+      expect(Timeout).to receive(:timeout).with(5).twice.and_yield
       expect_any_instance_of(Kernel).to receive(:system)
         .with("foreman", "--version", out: File::NULL, err: File::NULL).and_return(false)
       expect_any_instance_of(Kernel).to receive(:system)
         .with("foreman", "-v", out: File::NULL, err: File::NULL).and_return(true)
       expect(described_class.installed?("foreman")).to be true
     end
+
+    it "returns false when version check times out" do
+      expect(Timeout).to receive(:timeout).with(5).and_raise(Timeout::Error)
+      expect(described_class.installed?("hanging_process")).to be false
+    end
   end
 
   describe ".ensure_procfile" do
@@ -155,6 +162,7 @@
       bundler_double = class_double(Bundler)
       stub_const("Bundler", bundler_double)
       expect(bundler_double).to receive(:with_unbundled_env).and_yield
+      expect(Timeout).to receive(:timeout).with(5).and_yield
       expect_any_instance_of(Kernel).to receive(:system)
         .with("foreman", "--version", out: File::NULL, err: File::NULL).and_return(true)
 
@@ -171,13 +179,23 @@
       bundler_double = class_double(Bundler)
       stub_const("Bundler", bundler_double)
       expect(bundler_double).to receive(:with_unbundled_env).and_yield
+      expect(Timeout).to receive(:timeout).with(5).twice.and_yield
       expect_any_instance_of(Kernel).to receive(:system)
         .with("foreman", "--version", out: File::NULL, err: File::NULL).and_return(false)
       expect_any_instance_of(Kernel).to receive(:system)
         .with("foreman", "-v", out: File::NULL, err: File::NULL).and_return(true)
 
       expect(described_class.send(:process_available_in_system?, "foreman")).to be true
     end
+
+    it "returns false when version check times out in system context" do
+      bundler_double = class_double(Bundler)
+      stub_const("Bundler", bundler_double)
+      expect(bundler_double).to receive(:with_unbundled_env).and_yield
+      expect(Timeout).to receive(:timeout).with(5).and_raise(Timeout::Error)
+
+      expect(described_class.send(:process_available_in_system?, "hanging_process")).to be false
+    end
   end
 
   describe ".version_flags_for" do