Skip to content
Back to search

rails-mcp-server

A Ruby gem implementation of a Model Context Protocol (MCP) server for Rails projects. This server allows LLMs (Large Language Models) to interact with Rails projects through the Model Context Protocol.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/maquina-app--rails-mcp-server/badge.svg)](/listings/maquina-app--rails-mcp-server)

HTML

<a href="/listings/maquina-app--rails-mcp-server"><img src="/api/listings/maquina-app--rails-mcp-server/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Install the gem:

gem install rails-mcp-server

After installation, the following executables will be available in your PATH:

- `rails-mcp-server` - The MCP server itself - `rails-mcp-config` - Interactive configuration tool (recommended) - `rails-mcp-setup-claude` - Legacy Claude Desktop setup script - `rails-mcp-server-download-resources` - Legacy resource download script

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 612 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Rails MCP Server
  2. A Ruby implementation of a Model Context Protocol (MCP) server for Rails projects. This server allows LLMs (Large Language Models) to interact with Rails projects through the Model Context Protocol, providing capabilities for code analysis, exploration, and development assistance.
  3. ## What is MCP?
  4. The Model Context Protocol (MCP) is a standardized way for AI models to interact with their environment. It defines a structured method for models to request and use tools, access resources, and maintain context during interactions.
  5. This Rails MCP Server implements the MCP specification to give AI models access to Rails projects for code analysis, exploration, and assistance.
  6. ## Features
  7. - Manage multiple Rails projects
  8. - Browse project files and structures
  9. - View Rails routes with filtering options
  10. - Inspect model information and relationships (with Prism static analysis)
  11. - Get database schema information
  12. - Analyze controller-view relationships
  13. - Analyze environment configurations
  14. - Access comprehensive Rails, Turbo, Stimulus, and Kamal documentation
  15. - Context-efficient architecture with progressive tool discovery
  16. - Seamless integration with LLM clients
  17. ## Installation
  18. Install the gem:
  19. ```bash
  20. gem install rails-mcp-server
  21. ```
  22. After installation, the following executables will be available in your PATH:
  23. - `rails-mcp-server` - The MCP server itself
  24. - `rails-mcp-config` - Interactive configuration tool (recommended)
  25. - `rails-mcp-setup-claude` - Legacy Claude Desktop setup script
  26. - `rails-mcp-server-download-resources` - Legacy resource download script
  27. ## Configuration
  28. ### Using the Configuration Tool (Recommended)
  29. The easiest way to configure the Rails MCP Server is using the interactive configuration tool:
  30. ```bash
  31. rails-mcp-config
  32. ```
  33. This provides a user-friendly TUI (Terminal User Interface) for:
  34. - **Managing Projects**: Add, edit, remove, and validate Rails projects
  35. - **Downloading Guides**: Download Rails, Turbo, Stimulus, and Kamal documentation
  36. - **Importing Custom Guides**: Add your own markdown documentation
  37. - **Claude Desktop Integration**: Automatically configure Claude Desktop
  38. The tool uses [Gum](https://github.com/charmbracelet/gum) for an enhanced experience if installed, but works with a basic terminal fallback.
  39. ```bash
  40. # Install Gum for best experience (optional)
  41. brew install gum # macOS
  42. sudo apt install gum # Debian/Ubuntu
  43. yay -S gum # Arch Linux
  44. ```
  45. ### Manual Configuration
  46. The Rails MCP Server follows the XDG Base Directory Specification for configuration files:
  47. - On macOS: `$XDG_CONFIG_HOME/rails-mcp` or `~/.config/rails-mcp` if XDG_CONFIG_HOME is not set
  48. - On Windows: `%APPDATA%\rails-mcp`
  49. The server will automatically create these directories and an empty `projects.yml` file the first time it runs.
  50. To configure your projects manually:
  51. 1. Edit the `projects.yml` file in your config directory to include your Rails projects:
  52. ```yaml
  53. store: "~/projects/store"
  54. blog: "~/projects/rails-blog"
  55. ecommerce: "/full/path/to/ecommerce-app"
  56. ```
  57. Each key in the YAML file is a project name (which will be used with the `switch_project` tool), and each value is the path to the project directory.
  58. ## Usage
  59. ### Starting the server
  60. The Rails MCP Server can run in two modes:
  61. 1. **STDIO mode (default)**: Communicates over standard input/output for direct integration with clients like Claude Desktop.
  62. 2. **HTTP mode**: Runs as an HTTP server with JSON-RPC and Server-Sent Events (SSE) endpoints.
  63. ```bash
  64. # Start in default STDIO mode
  65. rails-mcp-server
  66. # Start in HTTP mode on the default port (6029)
  67. rails-mcp-server --mode http
  68. # Start in HTTP mode on a custom port
  69. rails-mcp-server --mode http -p 8080
  70. # Start in HTTP mode binding to all interfaces (for local network access)
  71. rails-mcp-server --mode http --bind-all
  72. ```
  73. When running in HTTP mode, the server provides two endpoints:
  74. - JSON-RPC endpoint: `http://localhost:<port>/mcp/messages`
  75. - SSE endpoint: `http://localhost:<port>/mcp/sse`
  76. ### Network Access (HTTP Mode)
  77. By default, the HTTP server only binds to localhost for security. If you need to access the server from other machines on your local network (e.g., for testing with multiple devices), you can use the `--bind-all` flag:
  78. ```bash
  79. # Allow access from any machine on your local network
  80. rails-mcp-server --mode http --bind-all
  81. # With a custom port
  82. rails-mcp-server --mode http --bind-all -p 8080
  83. ```
  84. When using `--bind-all`:
  85. - The server binds to `0.0.0.0` instead of `localhost`
  86. - Access is allowed from local network IP ranges (192.168.x.x, 10.x.x.x)
  87. - The server accepts connections from `.local` domain names (e.g., `my-computer.local`)
  88. - Security features remain active to prevent unauthorized access
  89. **Security Note**: Only use `--bind-all` on trusted networks. The server includes built-in security features to validate origins and IP addresses, but exposing any service to your network increases the attack surface.
  90. ### Logging Options
  91. The server logs to a file in the `./log` directory by default. You can customize logging with these options:
  92. ```bash
  93. # Set the log level (debug, info, error)
  94. rails-mcp-server --log-level debug
  95. ```
  96. ## Claude Desktop Integration
  97. The Rails MCP Server can be used with Claude Desktop. There are multiple options to set this up:
  98. ### Option 1: Use the configuration tool (recommended)
  99. Run the interactive configuration tool and select "Claude Desktop integration":
  100. ```bash
  101. rails-mcp-config
  102. ```
  103. The tool will:
  104. - Detect your current Claude Desktop configuration
  105. - Let you choose between STDIO or HTTP mode
  106. - Automatically find the correct Ruby and server paths
  107. - Create a backup before making changes
  108. - Update the Claude Desktop configuration
  109. ### Option 2: Use the setup script (legacy)
  110. Run the setup script which will automatically configure Claude Desktop:
  111. ```bash
  112. rails-mcp-setup-claude
  113. ```
  114. The script will:
  115. - Create the appropriate config directory for your platform
  116. - Create an empty `projects.yml` file if it doesn't exist
  117. - Update the Claude Desktop configuration
  118. After running the script, restart Claude Desktop to apply the changes.
  119. ### Option 3: Direct Configuration
  120. 1. Create the appropriate config directory for your platform:
  121. - macOS: `$XDG_CONFIG_HOME/rails-mcp` or `~/.config/rails-mcp` if XDG_CONFIG_HOME is not set
  122. - Windows: `%APPDATA%\rails-mcp`
  123. 2. Create a `projects.yml` file in that directory with your Rails projects.
  124. 3. Find or create the Claude Desktop configuration file:
  125. - macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
  126. - Windows: `%APPDATA%\Claude\claude_desktop_config.json`
  127. 4. Add or update the MCP server configuration:
  128. ```json
  129. {
  130. "mcpServers": {
  131. "railsMcpServer": {
  132. "command": "ruby",
  133. "args": ["/full/path/to/rails-mcp-server/exe/rails-mcp-server"]
  134. }
  135. }
  136. }
  137. ```
  138. 5. Restart Claude Desktop to apply the changes.
  139. ### Ruby Version Manager Users
  140. Two different Rubies are involved, and the server handles them differently.
  141. #### 1. The Ruby that runs the MCP server
  142. Your MCP client (e.g. Claude Desktop) launches the server using your system's default Ruby, bypassing version-manager initialization. The server must run on the Ruby where its gem is installed, or startup fails. Point the client's `command` at that Ruby's absolute path — for a version manager, its shim works:
  143. ```json
  144. {
  145. "mcpServers": {
  146. "railsMcpServer": {
  147. "command": "/home/your_user/.rbenv/shims/ruby",
  148. "args": ["/full/path/to/rails-mcp-server/exe/rails-mcp-server"]
  149. }
  150. }
  151. }
  152. ```
  153. Replace `/home/your_user/.rbenv/shims/ruby` with your actual Ruby path (an rbenv/mise/asdf shim, or your `rvm`/`chruby` Ruby).
  154. **Tip**: The `rails-mcp-config` tool detects this Ruby automatically (via `RbConfig.ruby`) and writes the correct absolute path when configuring Claude Desktop.
  155. #### 2. The Ruby used to introspect each Rails project
  156. Tools that boot your app — `get_schema`, `get_routes`, and the introspection half of `analyze_models` / `analyze_controller_views` — run `bin/rails` inside the project directory. The server selects the **project's** Ruby automatically and is agnostic to your version manager: it prepends the active manager's shims (**mise**, **asdf**, **rbenv**) to the subprocess `PATH` and sources **rvm** when present, then uses a non-login shell so macOS `path_helper` cannot substitute the system Ruby. The version is taken from the project's `.ruby-version` / `.tool-versions` / `.mise.toml`, so different projects can use different Rubies with no extra configuration.
  157. > No manual `PATH` workaround is needed. Previously these tools could fall back to the system Ruby on mise/asdf machines, where the app's Bundler then failed to boot.
  158. ### Using an MCP Proxy (Advanced)
  159. Claude Desktop and many other LLM clients only support STDIO mode communication, but you might want to use the HTTP/SSE capabilities of the server. An MCP proxy can bridge this gap:
  160. 1. Start the Rails MCP Server in HTTP mode:
  161. ```bash
  162. rails-mcp-server --mode http
  163. ```
  164. 2. Install and run an MCP proxy. There are several implementations available in different languages. An MCP proxy allows a client that only supports STDIO communication to communicate via HTTP SSE. Here's an example using a JavaScript-based MCP proxy:
  165. ```bash
  166. # Install the Node.js based MCP proxy
  167. npm install -g mcp-remote
  168. # Run the proxy, pointing to your running Rails MCP Server
  169. npx mcp-remote http://localhost:6029/mcp/sse
  170. ```
  171. 3. Configure Claude Desktop (or other LLM client) to use the proxy instead of connecting directly to the server:
  172. ```json
  173. {
  174. "mcpServers": {
  175. "railsMcpServer": {
  176. "command": "npx",
  177. "args": ["mcp-remote", "http://localhost:6029/mcp/sse"]
  178. }
  179. }
  180. }
  181. ```
  182. This setup allows STDIO-only clients to communicate with the Rails MCP Server through the proxy, benefiting from the HTTP/SSE capabilities while maintaining client compatibility.
  183. **Tip**: The `rails-mcp-config` tool can configure HTTP mode with mcp-remote automatically.
  184. ## GitHub Copilot Agent Integration
  185. Rails MCP Server works with GitHub Copilot coding agent out of the box. The server auto-detects Rails projects when started from a Rails directory or when configured with environment variables.
  186. ### Quick Setup
  187. 1. **Configure MCP** - Create `.github/copilot/mcp.json` in your repository:
  188. ```json
  189. {
  190. "mcpServers": {
  191. "rails": {
  192. "type": "local",
  193. "command": "rails-mcp-server",
  194. "args": ["--single-project"],
  195. "tools": ["switch_project", "search_tools", "execute_tool"]
  196. }
  197. }
  198. }
  199. ```
  200. 2. **Setup Steps** - Create `.github/workflows/copilot-setup-steps.yml`:
  201. ```yaml
  202. name: "Copilot Setup Steps"
  203. on: workflow_dispatch
  204. jobs:
  205. copilot-setup-steps:
  206. runs-on: ubuntu-latest
  207. permissions:
  208. contents: read
  209. steps:
  210. - name: Checkout
  211. uses: actions/checkout@v4
  212. - name: Set up Ruby
  213. uses: ruby/setup-ruby@v1
  214. with:
  215. ruby-version: '3.3'
  216. bundler-cache: true
  217. - name: Install Rails MCP Server
  218. run: gem install rails-mcp-server
  219. ```
  220. ### Alternative: Environment Variable
  221. You can also use the `RAILS_MCP_PROJECT_PATH` environment variable:
  222. ```json
  223. {
  224. "mcpServers": {
  225. "rails": {
  226. "type": "local",
  227. "command": "rails-mcp-server",
  228. "env": {
  229. "RAILS_MCP_PROJECT_PATH": "."
  230. },
  231. "tools": ["switch_project", "search_tools", "execute_tool"]
  232. }
  233. }
  234. }
  235. ```
  236. ### Limitations
  237. - GitHub Copilot Agent only supports MCP **tools**, not resources or prompts
  238. - The `load_guide` analyzer works via `execute_tool`, but requires guides to be downloaded during setup
  239. For detailed instructions, see [docs/COPILOT_AGENT.md](docs/COPILOT_AGENT.md).
  240. ## How the Server Works
  241. The Rails MCP Server implements the Model Context Protocol using either:
  242. - **STDIO mode**: Reads JSON-RPC 2.0 requests from standard input and returns responses to standard output.
  243. - **HTTP mode**: Provides HTTP endpoints for JSON-RPC 2.0 requests and Server-Sent Events.
  244. Each request includes a sequence number to match requests with responses, as defined in the MCP specification. The server maintains project context and provides Rails-specific analysis capabilities across multiple codebases.
  245. ### Context-Efficient Architecture
  246. The server uses a progressive tool discovery architecture to minimize context usage. Instead of exposing all tools upfront, it provides 3 bootstrap tools that allow LLMs to discover and invoke the introspection analyzers on-demand:
  247. - **`switch_project`** - Select the active Rails project
  248. - **`search_tools`** - Discover available tools by category or keyword
  249. - **`execute_tool`** - Invoke internal analyzers with parameters
  250. This design keeps initial context small while exposing the full set of analyzers on demand.
  251. ## AI Agent Guide
  252. For AI agents (Claude, GPT, etc.) using this server, see the comprehensive **[AI Agent Guide](docs/AGENT.md)** which covers:
  253. - Quick start workflow
  254. - Tool selection guide for common tasks
  255. - Common pitfalls and how to avoid them
  256. - Error handling and fallback strategies
  257. - Integration with other MCP servers (e.g., Neovim MCP)
  258. ## Available Tools
  259. The server provides 3 registered tools plus internal analyzers accessible via `execute_tool`.
  260. ### Registered Tools
  261. #### 1. `switch_project`
  262. **Description:** Change the active Rails project. Must be called before using other tools.
  263. **Parameters:**
  264. - `project_name`: (String, required) Name of the project as defined in projects.yml
  265. After switching, you'll see a Quick Start guide with common commands.
  266. #### 2. `search_tools`
  267. **Description:** Discover available tools by category or keyword.
  268. **Parameters:**
  269. - `query`: (String, optional) Search term (e.g., 'routes', 'model', 'schema')
  270. - `category`: (String, optional) Filter by category: models, database, routing, controllers, files, project, guides
  271. - `detail_level`: (String, optional) Output detail: 'names', 'summary', or 'full' (default: 'summary')
  272. #### 3. `execute_tool`
  273. **Description:** Invoke internal analyzers by name.
  274. **Parameters:**
  275. - `tool_name`: (String, required) Name of the analyzer (e.g., 'get_routes', 'analyze_models')
  276. - `params`: (Hash, optional) Parameters for the analyzer
  277. ### Internal Analyzers (via execute_tool)
  278. #### `project_info`
  279. Retrieve comprehensive project information including Rails version, directory structure, and organization.
  280. ```
  281. execute_tool(tool_name: "project_info")
  282. ```
  283. #### `list_files`
  284. List files matching a pattern in a directory.
  285. ```
  286. execute_tool(tool_name: "list_files", params: { directory: "app/models", pattern: "*.rb" })
  287. ```
  288. #### `get_file`
  289. Retrieve the content of a specific file.
  290. ```
  291. execute_tool(tool_name: "get_file", params: { path: "app/models/user.rb" })
  292. ```
  293. #### `get_routes`
  294. Retrieve Rails routes with optional filtering.
  295. ```
  296. execute_tool(tool_name: "get_routes")
  297. execute_tool(tool_name: "get_routes", params: { controller: "users" })
  298. execute_tool(tool_name: "get_routes", params: { verb: "POST" })
  299. execute_tool(tool_name: "get_routes", params: { path_contains: "api" })
  300. ```
  301. #### `analyze_models`
  302. Analyze Active Record models with associations, validations, and optional Prism static analysis.
  303. ```
  304. execute_tool(tool_name: "analyze_models")
  305. execute_tool(tool_name: "analyze_models", params: { model_name: "User" })
  306. execute_tool(tool_name: "analyze_models", params: { model_name: "User", analysis_type: "full" })
  307. execute_tool(tool_name: "analyze_models", params: { detail_level: "names" })
  308. ```
  309. **Parameters:**
  310. - `model_name`: Specific model to analyze
  311. - `model_names`: Array of models to analyze
  312. - `detail_level`: 'names', 'summary', or 'full'
  313. - `analysis_type`: 'introspection', 'static', or 'full' (includes Prism AST analysis)
  314. #### `get_schema`
  315. Retrieve database schema information.
  316. ```
  317. execute_tool(tool_name: "get_schema")
  318. execute_tool(tool_name: "get_schema", params: { table_name: "users" })
  319. execute_tool(tool_name: "get_schema", params: { detail_level: "tables" })
  320. ```
  321. #### `analyze_controller_views`
  322. Analyze controller-view relationships with optional Prism static analysis.
  323. ```
  324. execute_tool(tool_name: "analyze_controller_views")
  325. execute_tool(tool_name: "analyze_controller_views", params: { controller_name: "users" })
  326. execute_tool(tool_name: "analyze_controller_views", params: { controller_name: "users", analysis_type: "full" })
  327. ```
  328. #### `analyze_environment_config`
  329. Analyze environment configurations for inconsistencies and security issues.
  330. ```
  331. execute_tool(tool_name: "analyze_environment_config")
  332. ```
  333. #### `load_guide`
  334. Load documentation guides from Rails, Turbo, Stimulus, Kamal, or Custom.
  335. ```
  336. execute_tool(tool_name: "load_guide", params: { library: "rails" })
  337. execute_tool(tool_name: "load_guide", params: { library: "rails", guide: "getting_started" })
  338. execute_tool(tool_name: "load_guide", params: { library: "turbo" })
  339. execute_tool(tool_name: "load_guide", params: { library: "stimulus" })
  340. execute_tool(tool_name: "load_guide", params: { library: "custom", guide: "tailwind" })
  341. ```
  342. ## Resources and Documentation
  343. The Rails MCP Server provides access to comprehensive documentation through both the `load_guide` tool and direct MCP resource access. You can access official guides for Rails, Turbo, Stimulus, and Kamal, as well as import your own custom documentation.
  344. ### Available Resource Categories
  345. - **Rails Guides**: Official Ruby on Rails 8.0.2 documentation
  346. - **Turbo Guides**: Official Turbo (Hotwire) framework documentation
  347. - **Stimulus Guides**: Official Stimulus JavaScript framework documentation
  348. - **Kamal Guides**: Official Kamal deployment tool documentation
  349. - **Custom Guides**: Your imported markdown files
  350. ### Getting Started with Resources
  351. The easiest way to manage resources is using the configuration tool:
  352. ```bash
  353. rails-mcp-config
  354. ```
  355. Then select "Download guides" or "Import custom guides" from the menu.
  356. Alternatively, you can use the legacy command-line tools:
  357. ```bash
  358. # Download Rails guides
  359. rails-mcp-server-download-resources rails
  360. # Download Turbo guides
  361. rails-mcp-server-download-resources turbo
  362. # Import custom markdown files
  363. rails-mcp-server-download-resources --file /path/to/your/docs/
  364. ```
  365. ### Resource Access Methods
  366. 1. **Tool-based access**: Use the `load_guide` tool in conversations
  367. 2. **Direct resource access**: MCP clients can query resources using URI patterns like `rails://guides/{guide_name}`
  368. For complete information about downloading, managing, and using resources, see the [Resources Guide](docs/RESOURCES.md).
  369. ## Testing and Debugging
  370. The easiest way to test and debug the Rails MCP Server is by using the MCP Inspector, a developer tool designed specifically for testing and debugging MCP servers.
  371. To use MCP Inspector with Rails MCP Server:
  372. ```bash
  373. # Install and run MCP Inspector
  374. npm -g install @modelcontextprotocol/inspector
  375. npx @modelcontextprotocol/inspector /path/to/rails-mcp-server
  376. ```
  377. This will:
  378. 1. Start your Rails MCP Server in HTTP mode
  379. 2. Launch the MCP Inspector UI in your browser (default port: 6274)
  380. 3. Set up an MCP Proxy server (default port: 6277)
  381. In the MCP Inspector UI, you can:
  382. - See all available tools (you should see 3 registered tools)
  383. - Execute tool calls interactively
  384. - View request and response details
  385. - Debug issues in real-time
  386. The Inspector UI provides an intuitive interface to interact with your MCP server, making it easy to test and debug your Rails MCP Server implementation.
  387. ### Testing Workflow
  388. 1. **Switch to a project:** `switch_project` with your project name
  389. 2. **Discover tools:** `search_tools` to see available analyzers
  390. 3. **Test analyzers:** `execute_tool` to invoke specific analyzers (e.g. `get_routes`, `get_schema`)
  391. 4. **Read a file:** `execute_tool` with `get_file`, e.g. `{ "path": "Gemfile" }`
  392. ## Integration with LLM Clients
  393. This server is designed to be integrated with LLM clients that support the Model Context Protocol, such as Claude Desktop or other MCP-compatible applications.
  394. To use with an MCP client:
  395. 1. Start the Rails MCP Server (it will use STDIO mode by default)
  396. 2. Connect your MCP-compatible client to the server
  397. 3. The client will be able to use the available tools to interact with your Rails projects
  398. For teams using a governed AI client or control plane for tool access, approvals, audit trails, and cost reporting, see [Governed MCP Clients](docs/GOVERNED_CLIENTS.md).
  399. ## Security
  400. For security concerns, please see [SECURITY.md](SECURITY.md).
  401. ## License
  402. This Rails MCP server is released under the MIT License, a permissive open-source license that allows for free use, modification, distribution, and private use.
  403. Copyright (c) 2025 Mario Alberto Chávez Cárdenas
  404. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
  405. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
  406. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  407. ## Contributing
  408. Bug reports and pull requests are welcome on GitHub at <https://github.com/maquina-app/rails-mcp-server>.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.