fast-mcp 0.1.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94b9b8af1c648e0637ad0dc3d0118c8354392bac61b0f8c30d4eb264bc7a8fda
-  data.tar.gz: 728c09e7b7848fcc1f9296e42fed083933b8c8bb9cf08d02c8708009a378f0c1
+  metadata.gz: dde8305abcf47ffc314fc95df26467f737957e1b97eecae8c2c4a88b34c76017
+  data.tar.gz: 22715faf289cd3f45090480f59585220c3bb904b2a15c9669c5b93700a85e104
 SHA512:
-  metadata.gz: 1e26886cc6c006df64e913b7d517fbcffd1c2c4e6a27787e8fccbb3e0d5c172ec1e337ada9928cff1821fca96e2fcd173e4bf7bc4f492fc9eb4404463ed3e0a8
-  data.tar.gz: c91ea6f439f68ae5f301f4cd5adb24aaebc1939cfe8f2458ec038310b294293b2eaf6b5f8518972fdef5f1bf6acdbda59ec14997d1a01cf46171d4605152cf93
+  metadata.gz: eacade9a05c17a5032bbe2ed13e68bf094e7d018f272163a70f2457971c60ed79672488ab177fe3926dc9aa51cbf738ed2e3ba70bd9ab4c309599e593659ab97
+  data.tar.gz: 390cb3617e29219da28df5c49ff7da06c36b09d341068b5bc4c20883b64dd61f33c67e0542e03f368bf686129f1338ea5af3157bac28439c824520095250adfd

data/CHANGELOG.md

@@ -5,13 +5,57 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.0] - 2025-04-13
+### Added
+- Security enhancement: Added DNS rebinding protection by validating Origin headers [#32 @yjacquin](https://github.com/yjacquin/fast-mcp/pull/32/files)
+- Added configuration options for allowed origins in rack middleware [#32 @yjacquin](https://github.com/yjacquin/fast-mcp/pull/32/files)
+- Allow to change the SSE and Messages route [#23 @pedrofurtado](https://github.com/yjacquin/fast-mcp/pull/23)
+- Fix invalid return value when processing notifications/initialized request [#31 @abMatGit](https://github.com/yjacquin/fast-mcp/pull/31)
+
+
+## [1.0.0] - 2025-03-30
+
+### Added
+- Rails integration improvements via enhanced Railtie support
+- Automatic tool and resource registration in Rails applications
+- Extended Rails autoload paths for tools and resources directories
+- Sample generator templates for resources and tools
+- MCP Client configuration documentation as reported by [#8 @sivag-csod](https://github.com/yjacquin/fast-mcp/issues/8)
+- Example Ruby on Rails app in the documentation
+- `FastMcp.server` now exposes the MCP server to apps that may need it to access resources
+- Automated Github Releases through Github Workflow
+
+### Fixed
+- Fixed bug with Rack middlewares not being initialized properly.
+- Fixed bug with STDIO logging preventing a proper connection with clients [# 11 @cs3b](https://github.com/yjacquin/fast-mcp/issues/11)
+- Fixed Rails SSE streaming detection and handling
+- Improved error handling in client reconnection scenarios
+- Namespace consistency correction (FastMCP -> FastMcp) throughout the codebase
+
+### Improved
+- ⚠️ [Breaking] Resource content declaration changes
+  - Now resources implement `content` over `default_content`
+  - `content` is dynamically called when calling a resource, this implies we can declare dynamic resource contents like:
+  ```ruby
+  class HighestScoringUsersResource < FastMcp::Resource
+  ...
+    def content
+      User.order(score: :desc).last(5).map(&:as_json)
+    end
+  end
+  ```
+- More robust SSE connection lifecycle management
+- Optimized test suite with faster execution times
+- Better logging for debugging connection issues
+- Documentation had outdated examples
+
 ## [0.1.0] - 2025-03-12
 
 ### Added
 
 - Initial release of the Fast MCP library
-- MCP::Tool class with multiple definition styles
-- MCP::Server class with STDIO transport and HTTP / SSE transport
+- FastMcp::Tool class with multiple definition styles
+- FastMcp::Server class with STDIO transport and HTTP / SSE transport
 - Rack Integration with authenticated and standard middleware options
 - Resource management with subscription capabilities
 - Binary resource support

data/README.md

@@ -28,140 +28,169 @@ Fast MCP solves all these problems by providing a clean, Ruby-focused implementa
 - 🛠️ **Tools API** - Let AI models call your Ruby functions securely, with in-depth argument validation through [Dry-Schema](https://github.com/dry-rb/dry-schema).
 - 📚 **Resources API** - Share data between your app and AI models
 - 🔄 **Multiple Transports** - Choose from STDIO, HTTP, or SSE based on your needs
-- 🧩 **Framework Integration** - Works seamlessly with Rails, Sinatra, and Hanami
-- 🔒 **Authentication Support** - Secure your AI endpoints with ease
+- 🧩 **Framework Integration** - Works seamlessly with Rails, Sinatra or any Rack app.
+- 🔒 **Authentication Support** - Secure your AI-powered endpoints with ease
 - 🚀 **Real-time Updates** - Subscribe to changes for interactive applications
 
-## 💎 What Makes FastMCP Great
 
+## 💎 What Makes FastMCP Great
 ```ruby
 # Define tools for AI models to use
-server = MCP::Server.new(name: 'recipe-ai', version: '1.0.0')
+server = FastMcp::Server.new(name: 'popular-users', version: '1.0.0')
 
-# Define a tool by inheriting from MCP::Tool
-class GetRecipesTool < MCP::Tool
-  description "Find recipes based on ingredients"
-  
-  arguments do
+# Define a tool by inheriting from FastMcp::Tool
+class CreateUserTool < FastMcp::Tool
+  description "Create a user"
     # These arguments will generate the needed JSON to be presented to the MCP Client
-    # And they will be vaidated at run time.
+    # And they will be validated at run time.
     # The validation is based off Dry-Schema, with the addition of the description.
-    required(:ingredients).array(:string).description("List of ingredients")
-    optional(:cuisine).filled(:string).description("Type of cuisine")
+  arguments do
+    required(:first_name).filled(:string).description("First name of the user")
+    optional(:age).filled(:integer).description("Age of the user")
+    required(:address).hash do
+      optional(:street).filled(:string)
+      optional(:city).filled(:string)
+      optional(:zipcode).filled(:string)
+    end
   end
-  
-  def call(ingredients:, cuisine: nil)
-    Recipe.find_by_ingredients(ingredients, cuisine: cuisine)
+
+  def call(first_name:, age: nil, address: {})
+    User.create!(first_name:, age:, address:)
   end
 end
 
 # Register the tool with the server
-server.register_tool(GetRecipesTool)
+server.register_tool(CreateUserTool)
 
-# Share data resources with AI models by inheriting from MCP::Resource
-class IngredientsResource < MCP::Resource
-  uri "food/popular_ingredients"
-  name "Popular Ingredients"
+# Share data resources with AI models by inheriting from FastMcp::Resource
+class PopularUsers < FastMcp::Resource
+  uri "file://popular_users.json"
+  resource_name "Popular Users"
   mime_type "application/json"
-  
-  def default_content
-    JSON.generate(Ingredient.popular.as_json)
+
+  def content
+    JSON.generate(User.popular.limit(5).as_json)
   end
 end
 
 # Register the resource with the server
-server.register_resource(IngredientsResource)
+server.register_resource(PopularUsers)
 
 # Accessing the resource through the server
-server.read_resource("food/popular_ingredients")
+server.read_resource(PopularUsers.uri)
 
-# Updating the resource content through the server
-server.update_resource("food/popular_ingredients", JSON.generate({id: 1, name: 'tomato'}))
+# Notify the resource content has been updated to clients
+server.notify_resource_updated(PopularUsers.uri)
+```
 
+### 🚂 Fast Ruby on Rails implementation
+```shell
+bundle add fast-mcp
+bin/rails generate fast_mcp:install
+```
 
-# Easily integrate with web frameworks
-# config/application.rb (Rails)
-config.middleware.use MCP::RackMiddleware.new(
-  name: 'recipe-ai', 
-  version: '1.0.0'
-) do |server|
-  # Register tools and resources here
-  server.register_tool(GetRecipesTool)
-end
+This will add a configurable `fast_mcp.rb` initializer
 
-# Secure your AI endpoints
-config.middleware.use MCP::AuthenticatedRackMiddleware.new(
-  name: 'recipe-ai',
-  version: '1.0.0',
-  token: ENV['MCP_AUTH_TOKEN']
-)
+```ruby
+require 'fast_mcp'
 
-# Build real-time applications
-server.on_resource_update do |resource|
-  ActionCable.server.broadcast("recipe_updates", resource.metadata)
+FastMcp.mount_in_rails(
+  Rails.application,
+  name: Rails.application.class.module_parent_name.underscore.dasherize,
+  version: '1.0.0',
+  path_prefix: '/mcp', # This is the default path prefix
+  messages_route: 'messages', # This is the default route for the messages endpoint
+  sse_route: 'sse', # This is the default route for the SSE endpoint
+  # Add allowed origins below, it defaults to Rails.application.config.hosts
+  # allowed_origins: ['localhost', '127.0.0.1', 'example.com', /.*\.example\.com/],
+  # authenticate: true,       # Uncomment to enable authentication
+  # auth_token: 'your-token' # Required if authenticate: true
+) do |server|
+  Rails.application.config.after_initialize do
+    # FastMcp will automatically discover and register:
+    # - All classes that inherit from ApplicationTool (which uses ActionTool::Base)
+    # - All classes that inherit from ApplicationResource (which uses ActionResource::Base)
+    server.register_tools(*ApplicationTool.descendants)
+    server.register_resources(*ApplicationResource.descendants)
+    # alternatively, you can register tools and resources manually:
+    # server.register_tool(MyTool)
+    # server.register_resource(MyResource)
+  end
 end
 ```
+The install script will also:
+- add app/resources folder
+- add app/tools folder
+- add app/tools/sample_tool.rb
+- add app/resources/sample_resource.rb
+- add ApplicationTool to inherit from
+- add ApplicationResource to inherit from as well
 
-## 📦 Installation
+#### Rails-friendly class naming conventions
 
-```ruby
-# In your Gemfile
-gem 'fast-mcp'
+For Rails applications, FastMCP provides Rails-style class names to better fit with Rails conventions:
 
-# Then run
-bundle install
+- `ActionTool::Base` - An alias for `FastMcp::Tool`
+- `ActionResource::Base` - An alias for `FastMcp::Resource`
 
-# Or install it yourself
-gem install fast-mcp
-```
+These are automatically set up in Rails applications. You can use either naming convention in your code:
 
-## 🚀 Quick Start
+```ruby
+# Using Rails-style naming:
+class MyTool < ActionTool::Base
+  description "My awesome tool"
 
-### Testing with the inspector
+  arguments do
+    required(:input).filled(:string)
+  end
 
-MCP has developed a very [useful inspector](https://github.com/modelcontextprotocol/inspector).
-You can use it to validate your implementation. I suggest you use the examples I provided with this project as an easy boilerplate.
-Clone this project, then give it a go !
+  def call(input:)
+    # Your implementation
+  end
+end
 
-```shell
-npx @modelcontextprotocol/inspector examples/server_with_stdio_transport.rb
-```
-Or to test with an SSE transport using a rack middleware:
-```shell
-npx @modelcontextprotocol/inspector examples/rack_middleware.rb
+# Using standard FastMcp naming:
+class AnotherTool < FastMcp::Tool
+  # Both styles work interchangeably in Rails apps
+end
 ```
 
-Or to test over SSE with an authenticated rack middleware:
-```shell
-npx @modelcontextprotocol/inspector examples/authenticated_rack_middleware.rb
-```
+When creating new tools or resources, the generators will use the Rails naming convention by default:
 
-You can test your custom implementation with the official MCP inspector by using:
-```shell
-# Test with a stdio transport:
-npx @modelcontextprotocol/inspector path/to/your_ruby_file.rb
+```ruby
+# app/tools/application_tool.rb
+class ApplicationTool < ActionTool::Base
+  # Base methods for all tools
+end
 
-# Test with an HTTP / SSE server. In the UI select SSE and input your address.
-npx @modelcontextprotocol/inspector
+# app/resources/application_resource.rb
+class ApplicationResource < ActionResource::Base
+  # Base methods for all resources
+end
 ```
 
-### Create a Server with Tools and Resources
+### Easy Sinatra setup
+I'll let you check out the dedicated [sinatra integration docs](./docs/sinatra_integration.md).
+
+## 🚀 Quick Start
+
+### Create a Server with Tools and Resources and STDIO transport
 
 ```ruby
 require 'fast_mcp'
 
 # Create an MCP server
-server = MCP::Server.new(name: 'my-ai-server', version: '1.0.0')
+server = FastMcp::Server.new(name: 'my-ai-server', version: '1.0.0')
 
-# Define a tool by inheriting from MCP::Tool
-class SummarizeTool < MCP::Tool
+# Define a tool by inheriting from FastMcp::Tool
+class SummarizeTool < FastMcp::Tool
   description "Summarize a given text"
-  
+
   arguments do
     required(:text).filled(:string).description("Text to summarize")
     optional(:max_length).filled(:integer).description("Maximum length of summary")
   end
-  
+
   def call(text:, max_length: 100)
     # Your summarization logic here
     text.split('.').first(3).join('.') + '...'
@@ -171,14 +200,14 @@ end
 # Register the tool with the server
 server.register_tool(SummarizeTool)
 
-# Create a resource by inheriting from MCP::Resource
-class StatisticsResource < MCP::Resource
+# Create a resource by inheriting from FastMcp::Resource
+class StatisticsResource < FastMcp::Resource
   uri "data/statistics"
-  name "Usage Statistics"
+  resource_name "Usage Statistics"
   description "Current system statistics"
   mime_type "application/json"
-  
-  def default_content
+
+  def content
     JSON.generate({
       users_online: 120,
       queries_per_minute: 250,
@@ -188,30 +217,38 @@ class StatisticsResource < MCP::Resource
 end
 
 # Register the resource with the server
-server.register_resource(StatisticsResource.new)
+server.register_resource(StatisticsResource)
 
 # Start the server
 server.start
 ```
 
-### Integrate with Web Frameworks
+## 🧪 Testing with the inspector
 
-#### Rails
+MCP has developed a very [useful inspector](https://github.com/modelcontextprotocol/inspector).
+You can use it to validate your implementation. I suggest you use the examples I provided with this project as an easy boilerplate.
+Clone this project, then give it a go !
 
-```ruby
-# config/application.rb
-module YourApp
-  class Application < Rails::Application
-    # ...
-    config.middleware.use MCP::RackMiddleware.new(
-      name: 'my-ai-server', 
-      version: '1.0.0'
-    ) do |server|
-      # Register tools and resources here
-      server.register_tool(SummarizeTool)
-    end
-  end
-end
+```shell
+npx @modelcontextprotocol/inspector examples/server_with_stdio_transport.rb
+```
+Or to test with an SSE transport using a rack middleware:
+```shell
+npx @modelcontextprotocol/inspector examples/rack_middleware.rb
+```
+
+Or to test over SSE with an authenticated rack middleware:
+```shell
+npx @modelcontextprotocol/inspector examples/authenticated_rack_middleware.rb
+```
+
+You can test your custom implementation with the official MCP inspector by using:
+```shell
+# Test with a stdio transport:
+npx @modelcontextprotocol/inspector path/to/your_ruby_file.rb
+
+# Test with an HTTP / SSE server. In the UI select SSE and input your address.
+npx @modelcontextprotocol/inspector
 ```
 
 #### Sinatra
@@ -221,7 +258,7 @@ end
 require 'sinatra'
 require 'fast_mcp'
 
-use MCP::RackMiddleware.new(name: 'my-ai-server', version: '1.0.0') do |server|
+use FastMcp::RackMiddleware.new(name: 'my-ai-server', version: '1.0.0') do |server|
   # Register tools and resources here
   server.register_tool(SummarizeTool)
 end
@@ -250,6 +287,9 @@ Add your server to your Claude Desktop configuration at:
 }
 ```
 
+## How to add a MCP server to Claude, Cursor, or other MCP clients?
+Please refer to [configuring_mcp_clients](docs/configuring_mcp_clients.md)
+
 ## 📊 Supported Specifications
 
 | Feature | Status |
@@ -270,17 +310,43 @@ Add your server to your Claude Desktop configuration at:
 - 📚 **Interactive Documentation**: Create AI-enhanced API documentation
 - 💬 **Chatbots and Assistants**: Build AI assistants with access to your app's data
 
+## 🔒 Security Features
+
+Fast MCP includes built-in security features to protect your applications:
+
+### DNS Rebinding Protection
+
+The HTTP/SSE transport validates the Origin header on all incoming connections to prevent DNS rebinding attacks, which could allow malicious websites to interact with local MCP servers.
+
+```ruby
+# Configure allowed origins (defaults to ['localhost', '127.0.0.1'])
+FastMcp.rack_middleware(app, 
+  allowed_origins: ['localhost', '127.0.0.1', 'your-domain.com', /.*\.your-domain\.com/],
+  # other options...
+)
+```
+
+### Authentication
+
+Fast MCP supports token-based authentication for all connections:
+
+```ruby
+# Enable authentication
+FastMcp.authenticated_rack_middleware(app,
+  auth_token: 'your-secret-token',
+  # other options...
+)
+```
+
 ## 📖 Documentation
 
 - [🚀 Getting Started Guide](docs/getting_started.md)
 - [🧩 Integration Guide](docs/integration_guide.md)
 - [🛤️ Rails Integration](docs/rails_integration.md)
 - [🌐 Sinatra Integration](docs/sinatra_integration.md)
-- [🌸 Hanami Integration](docs/hanami_integration.md)
 - [📚 Resources](docs/resources.md)
 - [🛠️ Tools](docs/tools.md)
-- [🔌 Transports](docs/transports.md)
-- [📘 API Reference](docs/api_reference.md)
+- [🔒 Security](docs/security.md)
 
 ## 💻 Examples
 

data/lib/fast_mcp.rb

@@ -4,13 +4,20 @@
 # https://modelcontextprotocol.io/introduction
 
 # Define the MCP module
-module MCP
+module FastMcp
+  class << self
+    attr_accessor :server
+  end
 end
 
 # Require the core components
 require_relative 'mcp/tool'
 require_relative 'mcp/server'
 require_relative 'mcp/resource'
+require_relative 'mcp/railtie' if defined?(Rails::Railtie)
+
+# Load generators if Rails is available
+require_relative 'generators/fast_mcp/install/install_generator' if defined?(Rails::Generators)
 
 # Require all transport files
 require_relative 'mcp/transports/base_transport'
@@ -22,28 +29,34 @@ end
 require_relative 'mcp/version'
 
 # Convenience method to create a Rack middleware
-module MCP
+module FastMcp
   # Create a Rack middleware for the MCP server
   # @param app [#call] The Rack application
   # @param options [Hash] Options for the middleware
   # @option options [String] :name The name of the server
   # @option options [String] :version The version of the server
   # @option options [String] :path_prefix The path prefix for the MCP endpoints
+  # @option options [String] :messages_route The route for the messages endpoint
+  # @option options [String] :sse_route The route for the SSE endpoint
   # @option options [Logger] :logger The logger to use
+  # @option options [Array<String,Regexp>] :allowed_origins List of allowed origins for DNS rebinding protection
   # @yield [server] A block to configure the server
-  # @yieldparam server [MCP::Server] The server to configure
+  # @yieldparam server [FastMcp::Server] The server to configure
   # @return [#call] The Rack middleware
   def self.rack_middleware(app, options = {})
     name = options.delete(:name) || 'mcp-server'
     version = options.delete(:version) || '1.0.0'
     logger = options.delete(:logger) || Logger.new
 
-    server = MCP::Server.new(name: name, version: version, logger: logger)
+    server = FastMcp::Server.new(name: name, version: version, logger: logger)
     yield server if block_given?
 
     # Store the server in the Sinatra settings if available
     app.settings.set(:mcp_server, server) if app.respond_to?(:settings) && app.settings.respond_to?(:mcp_server=)
 
+    # Store the server in the FastMcp module
+    self.server = server
+
     server.start_rack(app, options)
   end
 
@@ -53,17 +66,121 @@ module MCP
   # @option options [String] :name The name of the server
   # @option options [String] :version The version of the server
   # @option options [String] :auth_token The authentication token
+  # @option options [Array<String,Regexp>] :allowed_origins List of allowed origins for DNS rebinding protection
   # @yield [server] A block to configure the server
-  # @yieldparam server [MCP::Server] The server to configure
+  # @yieldparam server [FastMcp::Server] The server to configure
   # @return [#call] The Rack middleware
   def self.authenticated_rack_middleware(app, options = {})
     name = options.delete(:name) || 'mcp-server'
     version = options.delete(:version) || '1.0.0'
     logger = options.delete(:logger) || Logger.new
 
-    server = MCP::Server.new(name: name, version: version, logger: logger)
+    server = FastMcp::Server.new(name: name, version: version, logger: logger)
     yield server if block_given?
 
+    # Store the server in the FastMcp module
+    self.server = server
+
     server.start_authenticated_rack(app, options)
   end
+
+  # Register a tool with the MCP server
+  # @param tool [FastMcp::Tool] The tool to register
+  # @return [FastMcp::Tool] The registered tool
+  def self.register_tool(tool)
+    self.server ||= FastMcp::Server.new(name: 'mcp-server', version: '1.0.0')
+    self.server.register_tool(tool)
+  end
+
+  # Register multiple tools at once
+  # @param tools [Array<FastMcp::Tool>] The tools to register
+  # @return [Array<FastMcp::Tool>] The registered tools
+  def self.register_tools(*tools)
+    self.server ||= FastMcp::Server.new(name: 'mcp-server', version: '1.0.0')
+    self.server.register_tools(*tools)
+  end
+
+  # Register a resource with the MCP server
+  # @param resource [FastMcp::Resource] The resource to register
+  # @return [FastMcp::Resource] The registered resource
+  def self.register_resource(resource)
+    self.server ||= FastMcp::Server.new(name: 'mcp-server', version: '1.0.0')
+    self.server.register_resource(resource)
+  end
+
+  # Register multiple resources at once
+  # @param resources [Array<FastMcp::Resource>] The resources to register
+  # @return [Array<FastMcp::Resource>] The registered resources
+  def self.register_resources(*resources)
+    self.server ||= FastMcp::Server.new(name: 'mcp-server', version: '1.0.0')
+    self.server.register_resources(*resources)
+  end
+
+  # Mount the MCP middleware in a Rails application
+  # @param app [Rails::Application] The Rails application
+  # @param options [Hash] Options for the middleware
+  # @option options [String] :name The name of the server
+  # @option options [String] :version The version of the server
+  # @option options [String] :path_prefix The path prefix for the MCP endpoints
+  # @option options [String] :messages_route The route for the messages endpoint
+  # @option options [String] :sse_route The route for the SSE endpoint
+  # @option options [Logger] :logger The logger to use
+  # @option options [Boolean] :authenticate Whether to use authentication
+  # @option options [String] :auth_token The authentication token
+  # @option options [Array<String,Regexp>] :allowed_origins List of allowed origins for DNS rebinding protection
+  # @yield [server] A block to configure the server
+  # @yieldparam server [FastMcp::Server] The server to configure
+  # @return [#call] The Rack middleware
+  def self.mount_in_rails(app, options = {})
+    # Default options
+    name = options.delete(:name) || app.class.module_parent_name.underscore.dasherize
+    version = options.delete(:version) || '1.0.0'
+    logger = options[:logger] || Rails.logger
+    path_prefix = options.delete(:path_prefix) || '/mcp'
+    messages_route = options.delete(:messages_route) || 'messages'
+    sse_route = options.delete(:sse_route) || 'sse'
+    authenticate = options.delete(:authenticate) || false
+    allowed_origins = options[:allowed_origins] || default_rails_allowed_origins(app)
+
+    options[:logger] = logger
+    options[:allowed_origins] = allowed_origins
+
+    # Create or get the server
+    self.server = FastMcp::Server.new(name: name, version: version, logger: logger)
+    yield self.server if block_given?
+
+    # Choose the right middleware based on authentication
+    self.server.transport_klass = if authenticate
+                                    FastMcp::Transports::AuthenticatedRackTransport
+                                  else
+                                    FastMcp::Transports::RackTransport
+                                  end
+
+    # Insert the middleware in the Rails middleware stack
+    app.middleware.use(
+      self.server.transport_klass,
+      self.server,
+      options.merge(path_prefix: path_prefix, messages_route: messages_route, sse_route: sse_route)
+    )
+  end
+
+  def self.default_rails_allowed_origins(rail_app)
+    hosts = rail_app.config.hosts
+
+    hosts.map do |host|
+      if host.is_a?(String) && host.start_with?('.')
+        # Convert .domain to domain and *.domain
+        host_without_dot = host[1..]
+        [host_without_dot, Regexp.new(".*\.#{host_without_dot}")] # rubocop:disable Style/RedundantStringEscape
+      else
+        host
+      end
+    end.flatten.compact
+  end
+
+  # Notify the server that a resource has been updated
+  # @param uri [String] The URI of the resource
+  def self.notify_resource_updated(uri)
+    self.server.notify_resource_updated(uri)
+  end
 end