Wait for the app route before auto-opening bin/dev (#2885)

justin808 · claude · web-flow · commit b79564b5e938 · 2026-03-29T17:34:33.000-10:00
## Problem Fresh apps can open the browser as soon as Puma starts listening on `localhost:3000`, before Shakapacker has finished producing `manifest.json` and the first pack assets. That produces a temporary `Shakapacker::Manifest::MissingEntryError` page on cold boot even though the app would be fine a moment later. This is especially noisy for AI tools and browser automation that immediately inspect the first opened page. ## Summary - wait for the requested route to return a successful or redirect HTTP response before auto-opening the browser - keep the existing one-time auto-open behavior, but make it align with actual app readiness instead of raw port availability - cover the readiness checks in `ServerManager` specs ## Testing - bundle exec rspec react_on_rails/spec/react_on_rails/dev/server_manager_spec.rb - manual cold-start verification against a generated `--rsc` app after deleting `public/packs`, confirming browser open happens only after `GET /` returns `200 OK`  --- > [!NOTE] > **Low Risk** > Low risk: changes are limited to `bin/dev` developer ergonomics (browser auto-open timing) plus additional specs; runtime/production code paths are unaffected. > > **Overview** > **Improves `bin/dev` browser auto-open reliability** by polling the target *app route* over HTTP (success/redirect) instead of just checking that the port is open, reducing premature opens during cold boot. > > Refactors route handling into normalized URL/path helpers, adds HTTP probing via `Net::HTTP` across localhost addresses, and extends `ServerManager` specs to cover route normalization and readiness behavior. Also updates the Pro TanStack Router test `compatAct` helper to require `React.act` (dropping the `react-dom/test-utils` fallback). > > <sup>Written by [Cursor Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit b70d747. This will update automatically on new commits. Configure [here](https://cursor.com/dashboard?tab=bugbot).</sup>   ## Summary by CodeRabbit * **Improvements** * Development server’s browser auto-open now waits for the app route to respond over HTTP before launching the browser, reducing premature opens when the server port is reachable but the app isn’t ready. * **Bug Fixes** * Treats HTTP success/redirect responses as ready and non-success responses as not ready to avoid false positives. * **Tests** * Updated test coverage around browser auto-open readiness and route normalization; test helper behavior adjusted for newer React act availability.  --------- Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
diff --git a/CHANGELOG.md b/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
diff --git a/packages/react-on-rails-pro/tests/tanstackRouter.test.ts b/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)', () => {
diff --git a/react_on_rails/lib/react_on_rails/dev/server_manager.rb b/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)
diff --git a/react_on_rails/spec/react_on_rails/dev/server_manager_spec.rb b/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
