Wait for the app route before auto-opening bin/dev

CHANGELOG.md

@@ -28,6 +28,10 @@ After a release, run `/update-changelog` in Claude Code to analyze commits, writ
 
 - **Fresh app onboarding for `create-react-on-rails-app`**: New apps now land on a generated root page with links to the local demos, docs, OSS vs Pro guidance, the Pro quick start, and the marketplace RSC demo. `bin/dev` opens that page on first boot, `--rsc` scaffolds the same fresh-app experience, and the generated app records step-by-step educational git commits for each scaffold phase. [PR 2849](https://github.com/shakacode/react_on_rails/pull/2849) by [justin808](https://github.com/justin808).
 
+#### Fixed
+
+- **`bin/dev` browser auto-open now waits for route readiness**: `--open-browser` and `--open-browser-once` now poll the target app route and open the browser only after receiving a success or redirect response, reducing premature opens during boot. [PR 2885](https://github.com/shakacode/react_on_rails/pull/2885) by [justin808](https://github.com/justin808).
+
 ### [16.5.1] - 2026-03-27
 
 #### Fixed

packages/react-on-rails-pro/tests/tanstackRouter.test.ts

@@ -40,13 +40,10 @@ type ActCallback = () => void | Promise<void>;
 
 async function compatAct(callback: ActCallback): Promise<void> {
   const reactAct = (React as typeof React & { act?: (cb: ActCallback) => Promise<unknown> | unknown }).act;
-  if (typeof reactAct === 'function') {
-    await reactAct(callback);
-    return;
+  if (typeof reactAct !== 'function') {
+    throw new Error('React.act is not available — React 18.3+ or 19+ is required');
   }
-
-  const { act } = await import('react-dom/test-utils');
-  await act(callback);
+  await reactAct(callback);
 }
 
 describe('tanstack-router integration (Pro)', () => {

react_on_rails/lib/react_on_rails/dev/server_manager.rb

@@ -2,6 +2,7 @@
 
 require "English"
 require "fileutils"
+require "net/http"
 require "open3"
 require "optparse"
 require "rainbow"
@@ -864,19 +865,31 @@ def schedule_browser_open_if_requested(procfile, route:, open_browser:, open_bro
         end
 
         def build_local_url(port, route)
-          normalized_route = route.to_s.strip
-          return "http://localhost:#{port}" if normalized_route.empty? || normalized_route == "/"
+          path = normalize_route_path(route)
+          path = "" if path == "/"
+          "http://localhost:#{port}#{path}"
+        end
+
+        def build_request_path(route)
+          normalize_route_path(route)
+        end
+
+        def normalize_route_path(route)
+          stripped = route.to_s.strip
+          return "/" if stripped.empty? || stripped == "/"
 
-          normalized_route = normalized_route.sub(%r{\A/+}, "")
-          "http://localhost:#{port}/#{normalized_route}"
+          stripped = stripped.sub(%r{\A/+}, "")
+          "/#{stripped}"
         end
 
         def schedule_browser_open(port, route:, once:)
           return unless browser_auto_open_allowed?
 
           url = build_local_url(port, route)
+          request_path = build_request_path(route)
           Thread.new do
-            next unless wait_for_server_on_port(port)
+            Thread.current.report_on_exception = false if Thread.current.respond_to?(:report_on_exception=)
+            next unless wait_for_app_route(port, request_path)
 
             marker_state = prepare_browser_open_once_marker(once)
             next if marker_state == :already_opened
@@ -896,25 +909,35 @@ def browser_auto_open_allowed?
           !ENV.key?("CI") && $stdin.tty? && $stdout.tty?
         end
 
-        def wait_for_server_on_port(port)
+        def wait_for_app_route(port, request_path)
           deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + OPEN_BROWSER_WAIT_TIMEOUT
 
           loop do
-            return true if localhost_port_open?(port)
+            return true if app_route_ready?(port, request_path)
             return false if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
 
             sleep OPEN_BROWSER_POLL_INTERVAL
           end
         end
 
-        def localhost_port_open?(port)
-          %w[127.0.0.1 ::1].any? do |host|
-            Socket.tcp(host, port, connect_timeout: 1) do
-              true
+        LOCALHOST_ADDRESSES = %w[127.0.0.1 ::1].freeze
+        private_constant :LOCALHOST_ADDRESSES
+
+        def app_route_ready?(port, request_path)
+          response = http_get_localhost(port, request_path)
+          response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
+        end
+
+        def http_get_localhost(port, request_path)
+          LOCALHOST_ADDRESSES.each do |host|
+            response = Net::HTTP.start(host, port, open_timeout: 1, read_timeout: 1) do |http|
+              http.get(request_path)
             end
+            return response if response
           rescue StandardError
-            false
+            next
           end
+          nil
         end
 
         def open_browser(url)

react_on_rails/spec/react_on_rails/dev/server_manager_spec.rb

@@ -256,6 +256,49 @@ def mock_system_calls
     end
   end
 
+  describe "browser auto-open readiness" do
+    it "normalizes routes to request paths" do
+      expect(described_class.send(:build_request_path, nil)).to eq("/")
+      expect(described_class.send(:build_request_path, "/")).to eq("/")
+      expect(described_class.send(:build_request_path, "hello_world")).to eq("/hello_world")
+      expect(described_class.send(:build_request_path, "/hello_server")).to eq("/hello_server")
+    end
+
+    it "treats a successful response as ready" do
+      response = Net::HTTPOK.new("1.1", "200", "OK")
+      allow(described_class).to receive(:http_get_localhost).with(3000, "/").and_return(response)
+
+      expect(described_class.send(:app_route_ready?, 3000, "/")).to be true
+    end
+
+    it "treats a redirect response as ready" do
+      response = Net::HTTPFound.new("1.1", "302", "Found")
+      allow(described_class).to receive(:http_get_localhost).with(3000, "/").and_return(response)
+
+      expect(described_class.send(:app_route_ready?, 3000, "/")).to be true
+    end
+
+    it "does not treat a server error response as ready" do
+      response = Net::HTTPInternalServerError.new("1.1", "500", "Internal Server Error")
+      allow(described_class).to receive(:http_get_localhost).with(3000, "/").and_return(response)
+
+      expect(described_class.send(:app_route_ready?, 3000, "/")).to be false
+    end
+
+    it "waits for the route to respond successfully before opening the browser" do
+      allow(described_class).to receive(:browser_auto_open_allowed?).and_return(true)
+      original_report_on_exception = Thread.current.report_on_exception
+      allow(Thread).to receive(:new).and_yield
+      allow(described_class).to receive(:wait_for_app_route).with(3000, "/").and_return(true)
+      allow(described_class).to receive(:prepare_browser_open_once_marker).with(true).and_return(:claimed)
+      expect(described_class).to receive(:open_browser).with("http://localhost:3000").and_return(true)
+
+      described_class.send(:schedule_browser_open, 3000, route: "/", once: true)
+    ensure
+      Thread.current.report_on_exception = original_report_on_exception
+    end
+  end
+
   describe ".kill_processes" do
     before do
       allow_any_instance_of(Kernel).to receive(:`).and_return("")
@@ -1011,7 +1054,7 @@ def mock_system_calls
       stub_const("#{described_class}::OPEN_BROWSER_ONCE_MARKER", File.join(marker_dir, "browser_opened_once"))
       allow(described_class).to receive_messages(
         browser_auto_open_allowed?: true,
-        wait_for_server_on_port: true
+        wait_for_app_route: true
       )
     end
 
@@ -1025,7 +1068,7 @@ def mock_system_calls
     end
 
     it "warns when the browser-open thread raises unexpectedly" do
-      allow(described_class).to receive(:wait_for_server_on_port).and_raise(SocketError, "boom")
+      allow(described_class).to receive(:wait_for_app_route).and_raise(SocketError, "boom")
       expect(described_class).to receive(:warn).with("[react_on_rails] Browser auto-open failed: boom")
 
       described_class.send(:schedule_browser_open, 3000, route: "/", once: false).join