Greptile Summary

This PR eliminates noisy Ruby interrupt backtraces when pressing Ctrl-C to stop bin/dev by addressing the problem at two levels: a new bin/shakapacker-watch shell wrapper that traps INT/TERM and exits cleanly, and a rescue Interrupt in ProcessManager.run_process_if_available that treats Ctrl-C during process-manager shutdown as a successful exit.

• Added bin/shakapacker-watch shell script that backgrounds bin/shakapacker, traps INT/TERM signals, forwards TERM to the child, and exits with status 0 on interrupt
• Added rescue Interrupt in ProcessManager.run_process_if_available so the Ruby side also exits cleanly on Ctrl-C
• Updated all Procfile templates and spec/dummy Procfiles to use bin/shakapacker-watch --watch instead of bin/shakapacker --watch
• Updated RSC setup to reference the new watcher wrapper in both the Procfile insertion and the manual-setup warning message
• Replaced expect_any_instance_of(Kernel) with expect(described_class) stubs in process_manager_spec.rb — a welcome test quality improvement
• Added new test cases for the Interrupt rescue path and for asserting the watcher wrapper is generated correctly

Confidence Score: 5/5

• This PR is safe to merge — it only adds signal handling for clean shutdown with no behavioral changes to the build pipeline.
• The changes are focused, well-tested, and low-risk. The shell script follows standard POSIX signal-handling patterns. The Ruby rescue is narrowly scoped. The generator already handles chmod on all bin/ scripts via Dir.glob. Test improvements (replacing expect_any_instance_of) are strictly better. No functional behavior of the build process is altered.
• No files require special attention.

Important Files Changed

Sequence Diagram

sequenceDiagram
    participant User
    participant bin/dev
    participant ProcessManager
    participant Overmind/Foreman
    participant shakapacker-watch
    participant shakapacker

    User->>bin/dev: Start
    bin/dev->>ProcessManager: run_with_process_manager("Procfile.dev")
    ProcessManager->>Overmind/Foreman: system("overmind", "start", ...)
    Overmind/Foreman->>shakapacker-watch: Launch watcher process
    shakapacker-watch->>shakapacker: bin/shakapacker "$@" & (backgrounded)
    shakapacker-watch->>shakapacker-watch: wait $child_pid

    User->>Overmind/Foreman: Ctrl-C (SIGINT)
    Overmind/Foreman->>shakapacker-watch: SIGINT/SIGTERM
    shakapacker-watch->>shakapacker-watch: trap fires cleanup()
    shakapacker-watch->>shakapacker: kill -TERM
    shakapacker-->>shakapacker-watch: exits
    shakapacker-watch->>shakapacker-watch: exit 0 (clean)
    Overmind/Foreman-->>ProcessManager: Interrupt raised
    ProcessManager->>ProcessManager: rescue Interrupt → true
    ProcessManager-->>bin/dev: Clean exit (no backtrace)

_{Last reviewed commit: ddf61ce}

No actionable comments were generated in the recent review. 🎉

Walkthrough

The PR introduces a shakapacker-watch wrapper script to manage the shakapacker process with proper signal handling for graceful shutdown. All Procfile references across templates and specs are updated to invoke this wrapper instead of calling shakapacker directly. The process manager is also updated to handle Interrupt exceptions gracefully.

Changes

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20 minutes

Poem

🐰 A wrapper hops in with signals so keen,
To catch INT and TERM in between,
Child processes managed with grace and care,
Procfiles updated everywhere!
Shutdown cleanup now polished and bright,
Dev processes exit just right! 🌟

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

CLAUDE.md

Tool-specific guidance for Claude Code in this repository.

Source of Truth

AGENTS.md is the canonical policy for:

• Commands, tests, and lint workflow
• Formatting and style requirements
• Git/PR safety boundaries
• Project directory boundaries

If this file conflicts with AGENTS.md, follow AGENTS.md.

Behavioral Defaults

• When confident in your changes, commit and push without asking for permission. Always monitor CI after pushing.

Git Safety

• NEVER force-push (--force, --force-with-lease) unless the user explicitly requests it. Force-pushing destroys commit history that may represent significant prior work.
• NEVER git reset --hard on a branch that has existing commits (yours or others'). This destroys work.
• When you need to start fresh or test something without affecting an existing branch, use a git worktree (git worktree add) or create a new branch instead of resetting the current one.
• If a rebase has conflicts, abort and ask the user how to proceed rather than force-pushing a rewritten history.

Claude-Specific Workflow

Use these docs for Claude-oriented operational guidance:

• .claude/docs/avoiding-ci-failure-cycles.md
• .claude/docs/replicating-ci-failures.md
• .claude/docs/playwright-e2e-testing.md
• .claude/docs/merge-conflict-workflow.md
• .claude/docs/pr-splitting-strategy.md
• .claude/docs/changelog-guidelines.md
• .claude/docs/project-architecture.md
• .claude/docs/rails-engine-nuances.md
• .claude/docs/debugging-webpack.md
• .claude/docs/rbs-type-checking.md
• .claude/docs/conductor-compatibility.md
• .claude/docs/testing-build-scripts.md
• .claude/docs/master-health-monitoring.md
• .claude/docs/managing-file-paths.md

For Pro-package specifics, also read react_on_rails_pro/CLAUDE.md.

AGENTS.md

Instructions for AI coding agents working on the React on Rails codebase.

React on Rails is a Ruby gem + npm package that integrates React with Ruby on Rails, providing server-side rendering (SSR) via Node.js or ExecJS. This is a monorepo: the open-source gem lives at react_on_rails/, the npm package at packages/react-on-rails/, and the Pro package at react_on_rails_pro/.

Canonical Agent Policy

AGENTS.md is the canonical source for repository-wide agent rules:

• Commands and test/lint workflow
• Code style and formatting expectations
• Git/PR boundaries and safety rules
• Directory and documentation boundaries

Other agent-facing docs (for example CLAUDE.md) should contain only tool-specific workflow notes and link back here.
If there is a conflict, AGENTS.md wins.

Commands

# Install dependencies
bundle && pnpm install

# Build TypeScript → JavaScript
pnpm run build

# Lint (MANDATORY before every commit)
bundle exec rubocop                  # Ruby — must pass with zero offenses
pnpm run lint                        # JS/TS via ESLint
pnpm start format.listDifferent      # Check Prettier formatting
rake lint                            # All linting (Ruby + JS + formatting)

# Auto-fix formatting
rake autofix                         # Preferred for all formatting

# Run tests
rake run_rspec:gem                   # Ruby unit tests (gem code)
rake run_rspec:dummy                 # Ruby integration tests (dummy Rails app)
pnpm run test                        # JavaScript/TypeScript tests
rake                                 # Full suite (lint + all tests except examples)

# Type checking
pnpm run type-check                  # TypeScript
bundle exec rake rbs:validate        # RBS signatures

# Additional test subsets
rake run_rspec                       # All Ruby tests
rake all_but_examples                # All tests except generated examples
rake run_rspec:shakapacker_examples_basic  # Single example test

# Full initial setup
bundle && pnpm install && rake shakapacker_examples:gen_all && rake node_package && rake

# CI/workflow linting
actionlint                           # GitHub Actions lint
yamllint .github/                    # YAML lint (do NOT run RuboCop on .yml files)

# Dependency version updates
rake shakapacker:update_version[9.6.1]  # Update shakapacker across the monorepo

Updating Shakapacker

Use rake shakapacker:update_version[VERSION] to update shakapacker across the entire monorepo. This single command updates all Gemfiles, package.json files, Gemfile.lock files, and pnpm-lock.yaml. Do not manually edit individual version references — always use the rake task to keep everything in sync.

The task handles Ruby version switching for apps that require a different Ruby version (set RUBY_VERSION_MANAGER to rvm, rbenv, asdf, or mise if needed; defaults to rvm). It continues gracefully if a single lock file update fails (e.g., due to a missing Ruby version).

Testing

• Prefer local testing over CI iteration — don't push "hopeful" fixes. Apply the 15-minute rule: if 15 more minutes of local testing would catch the issue before CI does, spend the 15 minutes.
• Never claim a test is "fixed" without running it locally first. Use "This SHOULD fix..." or "Proposed fix (UNTESTED)" for unverified changes.
• Ruby: RSpec. Unit tests in react_on_rails/spec/react_on_rails/, integration tests via a dummy Rails app in react_on_rails/spec/dummy/.
• JavaScript/TypeScript: Jest. Tests in packages/react-on-rails/tests/.
• E2E: Playwright. Tests in react_on_rails/spec/dummy/e2e/playwright/e2e/. Run with cd react_on_rails/spec/dummy && pnpm test:e2e.
• The dummy app (react_on_rails/spec/dummy/) is a full Rails application used for integration testing. Many tests require it.

Run specific test files:

bundle exec rspec react_on_rails/spec/react_on_rails/path/to/spec.rb
cd react_on_rails/spec/dummy && bundle exec rspec spec/path/to/spec.rb

Project Structure

Code Style

Ruby (RuboCop)

Line length max 120 characters. Run bundle exec rubocop [file] to check.

Line length — break long chains:

# Bad
content = pack_content.gsub(/import.*from.*['"];/, "").gsub(/ReactOnRails\.register.*/, "")

# Good
content = pack_content.gsub(/import.*from.*['"];/, "")
                      .gsub(/ReactOnRails\.register.*/, "")

Named subjects in RSpec:

# Bad
subject { instance.method_name(arg) }

# Good
subject(:method_result) { instance.method_name(arg) }

Security violations — scope disable comments tightly:

# rubocop:disable Security/Eval
expect { evaluate(sanitized_content) }.not_to raise_error
# rubocop:enable Security/Eval

JavaScript/TypeScript

Prettier handles all formatting. Never manually format — run rake autofix instead.

Git Workflow

Branch naming: type/descriptive-name (e.g., fix/ssr-hydration-mismatch)

Commit messages: Explain why, not what. One logical change per commit.

PR creation: Use gh pr create with a clear title, summary, and test plan.

Review Workflow

For small, focused PRs (roughly 5 files changed or fewer and one clear purpose):

• Use at most one AI reviewer that leaves inline comments. Additional AI tools should be summary-only or used manually.
• Wait for the first full review pass to finish before pushing follow-up commits.
• Batch review fixes into one follow-up push when practical. Do not create a new commit for each minor comment.
• Treat as blocking only: correctness bugs, failing tests, regressions, and clear inconsistencies with adjacent code. Nits and style suggestions are optional unless a maintainer asks for them.
• Verify language, runtime, and library claims locally before changing code in response to AI review comments.
• Deduplicate repeated bot comments before acting on them. Fix the underlying issue once, then resolve the duplicates.
• Rebase or merge master once, near the end of the review cycle. For CHANGELOG.md conflicts, prefer resolving them as the final step before merge.
• When asking an agent to address review comments, instruct it to classify comments into blocking, optional, and noise, then apply only the blocking items plus any explicitly selected optional items.

Boundaries

Always

• Run bundle exec rubocop before committing — CI will reject violations
• Use pnpm for all JS operations — never npm or yarn
• Use bundle exec for Ruby commands
• Ensure all files end with a newline
• Let Prettier and RuboCop handle formatting — never format manually

Ask First

• Destructive git operations (force push, reset --hard, branch deletion)
• Changes to CI workflows (.github/workflows/)
• Changes to build configuration (package.json scripts, webpack config)
• Modifying the Pro package (react_on_rails_pro/)

Never

• Skip pre-commit hooks (--no-verify)
• Commit secrets, credentials, or .env files
• Commit package-lock.json, yarn.lock, or other non-pnpm lock files
• Add files to the docs/ root — OSS docs go in docs/oss/ subdirectories (getting-started/, core-concepts/, building-features/, configuration/, api-reference/, deployment/, migrating/, upgrading/, misc/); Pro docs go in docs/pro/
• Force push to main or master

Key Concept: File Suffixes vs. RSC Directive

React on Rails has two independent systems that both use "client" and "server" terminology. Do not confuse them.

1. Bundle Placement (.client. / .server. file suffixes)

A React on Rails auto-bundling feature that controls which webpack bundle imports a file. This exists independently of React Server Components and is used with or without RSC:

• Component.client.jsx → imported only in the client bundle (browser)
• Component.server.jsx → imported only in the server bundle (and RSC bundle when RSC enabled)
• Component.jsx (no suffix) → imported in both bundles

This controls where the source file is loaded, nothing more. A .server.jsx file is NOT a React Server Component — it is simply a file that webpack includes in the server bundle (and the RSC bundle when RSC is enabled). These suffixes only make sense for client components, as server components exist only in the RSC bundle.

2. RSC Classification ('use client' directive)

The 'use client' directive is part of the React Server Components architecture. It marks a component as a React Client Component. Components without it are treated as React Server Components.

When auto-bundling is enabled with RSC support (Pro feature), React on Rails uses this directive to control:

• Registration: 'use client' → ReactOnRails.register(), no 'use client' → registerServerComponent()
• RSC bundling: The RSC webpack loader uses this directive to decide whether a component is included in the RSC bundle or replaced with a client reference in that bundle

The client_entrypoint? method in packs_generator.rb checks for this directive.

They Are Orthogonal

A .client.jsx file can be a React Server Component (if it lacks 'use client'), and a .server.jsx file can be a React Client Component (if it has 'use client'). In practice, paired .client./.server. files should have consistent 'use client' status because the client and server must agree on the component's RSC role for hydration to work.

Changelog

Update /CHANGELOG.md for user-visible changes only (features, bug fixes, breaking changes, deprecations, performance improvements). Do not add entries for linting, formatting, refactoring, tests, or doc fixes.

• Format: [PR 1818](https://github.com/shakacode/react_on_rails/pull/1818) by [username](https://github.com/username) (no hash before PR number)
• Pro-only changes use an inline **[Pro]** tag prefix within the standard category sections (e.g., - **[Pro]** **Feature name**: Description...); do NOT create separate #### Pro subsections

test single line

React on Rails

React on Rails integrates React with Ruby on Rails, providing server-side rendering (SSR), component registration, and seamless Rails view integration. React on Rails Pro adds advanced features: a high-performance Node.js rendering server, fragment caching, prerender caching, React Server Components (RSC), and streaming SSR.

Package Relationships

React on Rails consists of Ruby gems and npm packages that must be paired correctly:

Open-Source (base):

• Ruby gem: react_on_rails
• npm package: react-on-rails

Pro (commercial, extends base):

• Ruby gem: react_on_rails_pro (depends on react_on_rails)
• npm package: react-on-rails-pro (REPLACES react-on-rails, do NOT use both)
• npm package: react-on-rails-pro-node-renderer (standalone Fastify SSR server, optional)

IMPORTANT: When using the react_on_rails_pro gem, you MUST use the react-on-rails-pro npm package. The base react-on-rails npm package will be rejected at runtime.

Quick Setup

Base (open-source):

rails generate react_on_rails:install

Pro with Node Renderer:

bundle add react_on_rails_pro
rails generate react_on_rails:install --pro

Pro with React Server Components:

bundle add react_on_rails_pro
rails generate react_on_rails:install --rsc

Node Renderer API

The Node Renderer is a Fastify-based Node.js server for high-performance SSR.

Correct usage:

const { reactOnRailsProNodeRenderer } = require('react-on-rails-pro-node-renderer');

reactOnRailsProNodeRenderer({
  serverBundleCachePath: path.resolve(__dirname, '.node-renderer-bundles'),
  port: 3800,
  supportModules: true,
  password: process.env.RENDERER_PASSWORD,
  workersCount: 3,
  logLevel: 'info',
});

The function name is reactOnRailsProNodeRenderer (NOT createServer or startRenderer).
The config key for the bundle cache directory is serverBundleCachePath (NOT bundlePath, which is deprecated).

Rails-side configuration:

# config/initializers/react_on_rails_pro.rb
ReactOnRailsPro.configure do |config|
  config.server_renderer = "NodeRenderer"
  config.renderer_url = ENV.fetch("REACT_RENDERER_URL", "http://localhost:3800")
  config.renderer_password = ENV.fetch("RENDERER_PASSWORD", "devPassword")
  config.prerender_caching = true
end

Key attributes: server_renderer, renderer_url, renderer_password, prerender_caching, ssr_timeout, renderer_use_fallback_exec_js, throw_js_errors, tracing, dependency_globs.

Webpack server config requirements (for Pro Node Renderer):

// serverWebpackConfig.js output section
libraryTarget: 'commonjs2',

// after output section
serverWebpackConfig.target = 'node';

Client-Side Component Registration

// With base package
import ReactOnRails from 'react-on-rails';
ReactOnRails.register({ MyComponent });

// With Pro package (use this when react_on_rails_pro gem is installed)
import ReactOnRails from 'react-on-rails-pro';
ReactOnRails.register({ MyComponent });

Pro-Exclusive Imports

import { RSCRoute } from 'react-on-rails-pro/RSCRoute';
import registerServerComponent from 'react-on-rails-pro/registerServerComponent/client';
import { wrapServerComponentRenderer } from 'react-on-rails-pro/wrapServerComponentRenderer/client';

Documentation Links

• Docs: https://www.shakacode.com/react-on-rails/docs/
• Pro Docs: https://www.shakacode.com/react-on-rails-pro/docs/
• Pro Installation: https://www.shakacode.com/react-on-rails-pro/docs/installation/
• Pro Configuration: https://www.shakacode.com/react-on-rails-pro/docs/configuration/
• Node Renderer Basics: https://www.shakacode.com/react-on-rails-pro/docs/node-renderer/basics/
• Node Renderer JS Config: https://www.shakacode.com/react-on-rails-pro/docs/node-renderer/js-configuration/
• RSC Tutorial: https://www.shakacode.com/react-on-rails-pro/docs/react-server-components/tutorial/
• GitHub: https://github.com/shakacode/react_on_rails

test 2

Review: Quiet bin/dev shutdown on Ctrl-C

Overall this is a clean, well-scoped fix for a real first-run UX problem. The two-pronged approach (shell-level signal forwarding in bin/shakapacker-watch + Ruby-level rescue Interrupt in ProcessManager) is the right architecture. The test cleanup replacing expect_any_instance_of(Kernel) with expect(described_class) is a nice improvement in its own right.

Issues

1. cleanup() always exits 0 — no comment explaining why (inline)
The shell script exits 0 on both INT and TERM. This is intentional but unconventional (Unix norm is 128+signal). Any tool that inspects watcher exit codes for health monitoring will see a clean exit even on TERM. A comment explaining the deliberate choice is needed; see the inline note on line 12 of bin/shakapacker-watch.

2. rescue Interrupt scope is wider than the comment implies (inline)
The rescue covers the entire run_process_if_available method, including the installed? version-check phase before the process manager starts. This is almost certainly fine, but the current comment only mentions "overmind/foreman shutdown" and should also cover the startup case. See inline on process_manager.rb:102.

3. Relative bin/shakapacker path is implicit (inline)
The wrapper assumes it is run from the Rails root, which is standard for Procfile processes but nowhere documented. See inline on bin/shakapacker-watch:17.

Observations (no action needed)

• Executable bit: Handled correctly. install_generator.rb already does Dir.glob over the template bin dir and File.chmod(0o755) on all results, so bin/shakapacker-watch will be made executable automatically on generation.
• Procfile.dev.no.turbolinks update: The compound command is semantically unchanged; the || true ensures the && clause always runs. Correct.
• Test coverage: The new install_generator_spec block and the Interrupt spec are good additions.
• Stacking on Improve create/install validation flows and migration docs #2650: Worth calling out in the merge checklist that this should not be merged before Improve create/install validation flows and migration docs #2650 lands, or the base Procfile references will be orphaned.

size-limit report 📦

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

Review: Quiet bin/dev shutdown on Ctrl-C

Overall this is a clean, well-scoped fix. The two-pronged approach (Ruby-level rescue Interrupt + a POSIX wrapper script for the shakapacker watcher) is solid. Tests are improved by replacing expect_any_instance_of(Kernel) with expect(described_class), which is strictly better.

Three things to address:

Bug — duplicate PostgreSQL entry in docs

docs/oss/getting-started/create-react-on-rails-app.md now lists PostgreSQL twice in the prerequisites block. The new bare bullet lands above npm or pnpm, while the existing bullet with the parenthetical clarification about bin/rails db:prepare is still there. The bare new line should be removed — the existing more-informative line should be kept.

Line 81 currently reads: "If any of the first four are missing…" — this text was accurate before (Node.js, Ruby, Rails, npm/pnpm). With the duplicate PostgreSQL entry the list appears to have five CLI-checked items, which contradicts the prose. Removing the duplicate restores consistency.

Minor — template bin/shakapacker-watch committed without executable bit

Every other file in react_on_rails/lib/generators/react_on_rails/templates/base/base/bin/ is committed -rwxr-xr-x. The new shakapacker-watch is -rw-r--r--. The generator's add_bin_scripts already calls File.chmod(0o755, ...) on all files in that directory, so the generated file will be executable at install time — no runtime bug. But the inconsistency is misleading. Worth running chmod +x on the template and amending the commit.

Minor — rescue Interrupt scope is wider than the comment implies

The rescue at the bottom of run_process_if_available catches Interrupt raised anywhere in the method, including during the installed?(process) version-check calls, not just during the long-running system(process, *args) call. The comment says "Ctrl-C during overmind/foreman shutdown" which implies the signal arrives while the process manager is running. Silently exiting on Ctrl-C is always correct here, so there is no real bug — but the comment is misleading. A small wording tweak such as "Ctrl-C at any point — treat as a clean exit" would make the intent clearer.

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

Review

Overall this is a clean, well-scoped fix. The approach is sound and the added test coverage is solid.

rescue Interrupt in process_manager.rb

Returning true on Interrupt works correctly (Ctrl-C should produce a clean exit), but the rescue guard covers the entire method body including the version-check probes, not just the actual system call that runs the process manager. See the inline note for a suggestion on making this explicit in the comment.

bin/shakapacker-watch shell script

The signal-trap-then-wait pattern is idiomatic and correct for the target platforms (macOS/Ubuntu). Two minor observations via inline comments:

• cleanup hardcodes exit 0 — intentional but worth a comment so the next reader understands why the child's real exit status is discarded on signal.
• The POSIX wait-plus-trap interaction is platform-dependent; works correctly on the likely target shells (bash, dash), but worth noting for portability.

Test refactoring

The shift from expect_any_instance_of(Kernel).to receive(:system) to expect(described_class).to receive(:system) is a clear improvement. The any_instance_of(Kernel) approach intercepts all Kernel method dispatch globally, which is fragile in a shared test run. The new form targets only ProcessManager's own method resolution — more precise and more reliable.

No issues found

• No security concerns: the valid_procfile_path? guard is untouched; the new wrapper script never interpolates user input into shell commands.
• No performance concerns: the wrapper adds a single fork with negligible overhead.
• Generator template and spec fixture updates are consistent with each other.

Overall this is clean, well-motivated work. The two-layer fix is the right approach, and the test improvements replacing expect_any_instance_of(Kernel) with expect(described_class) are a genuine quality uplift.

bin/shakapacker-watch is emitted by the generator via Thor's directory action in install_generator.rb line 347, which bulk-copies everything under templates/base/base/bin/. bin_scripts_to_chmod uses Dir.children on that same path (line 400) so the file is also chmod 755 automatically. No changes to the explicit base_files list in base_generator.rb are needed.

Three inline issues flagged:

1. Race window before trap: the trap is set after the child is backgrounded; moving it above the ampersand eliminates the window (comment on bin/shakapacker-watch line 17).
2. cleanup() always exits 0: harmless for Ctrl-C but silently swallows TERM-triggered failures from other Procfile processes (comment on bin/shakapacker-watch line 12).
3. rescue Interrupt coverage: the rescue also fires if Interrupt arrives during the installed? check, before the process manager launches; the true return value could mislead future callers (comment on process_manager.rb line 110).

None of these block merging.

The bin/shakapacker-watch wrapper script belongs in shakapacker since shakapacker already generates bin/shakapacker, bin/shakapacker-dev-server, and bin/shakapacker-config. I've opened shakacode/shakapacker#1026 to add it there.

With that merged, this PR can drop the bin/shakapacker-watch template from react_on_rails and just rely on the shakapacker-generated binstub. The Procfile changes to reference bin/shakapacker-watch --watch would still be needed here, but the script itself would come from shakapacker's install.