ferrum-mcp 1.0.0 → 1.1.0

data/lib/ferrum_mcp/tools/get_title_tool.rb

@@ -2,37 +2,14 @@
 
 module FerrumMCP
   module Tools
-    # Tool to get page title
+    # Get page title
     class GetTitleTool < BaseTool
-      def self.tool_name
-        'get_title'
-      end
-
-      def self.description
-        'Get the title of the current page'
-      end
+      tool_name 'get_title'
+      description 'Get the title of the current page'
 
-      def self.input_schema
-        {
-          type: 'object',
-          properties: {
-            session_id: {
-              type: 'string',
-              description: 'Session ID to use for this operation'
-            }
-          },
-          required: ['session_id']
-        }
-      end
-
-      def execute(_params)
+      def perform(_params)
         ensure_browser_active
-        logger.info 'Getting page title'
-
-        success_response(
-          title: browser.title,
-          url: browser.url
-        )
+        success_response(title: page.title, url: page.url)
       rescue StandardError => e
         logger.error "Get title failed: #{e.message}"
         error_response("Failed to get title: #{e.message}")

data/lib/ferrum_mcp/tools/get_url_tool.rb

@@ -2,34 +2,14 @@
 
 module FerrumMCP
   module Tools
-    # Tool to get current URL
+    # Get current URL
     class GetURLTool < BaseTool
-      def self.tool_name
-        'get_url'
-      end
-
-      def self.description
-        'Get the current URL of the page'
-      end
+      tool_name 'get_url'
+      description 'Get the current page URL'
 
-      def self.input_schema
-        {
-          type: 'object',
-          properties: {
-            session_id: {
-              type: 'string',
-              description: 'Session ID to use for this operation'
-            }
-          },
-          required: ['session_id']
-        }
-      end
-
-      def execute(_params)
+      def perform(_params)
         ensure_browser_active
-
-        logger.info 'Getting current URL'
-        success_response(url: browser.url)
+        success_response(url: page.url)
       rescue StandardError => e
         logger.error "Get URL failed: #{e.message}"
         error_response("Failed to get URL: #{e.message}")

data/lib/ferrum_mcp/tools/go_back_tool.rb

@@ -2,41 +2,18 @@
 
 module FerrumMCP
   module Tools
-    # Tool to go back in browser history
+    # Go back to the previous page in browser history
     class GoBackTool < BaseTool
-      def self.tool_name
-        'go_back'
-      end
-
-      def self.description
-        'Go back to the previous page in browser history'
-      end
+      tool_name 'go_back'
+      description 'Go back to the previous page in browser history'
 
-      def self.input_schema
-        {
-          type: 'object',
-          properties: {
-            session_id: {
-              type: 'string',
-              description: 'Session ID to use for this operation'
-            }
-          },
-          required: ['session_id']
-        }
-      end
-
-      def execute(_params)
+      def perform(_params)
         ensure_browser_active
         logger.info 'Going back'
-        browser.back
-
-        # Wait for network to be idle to ensure page is loaded
-        browser.network.wait_for_idle(timeout: 30)
+        page.back
+        page.network.wait_for_idle(timeout: 30)
 
-        success_response(
-          url: browser.url,
-          title: browser.title
-        )
+        success_response(url: page.url, title: page.title)
       rescue Ferrum::TimeoutError => e
         logger.error "Go back timeout: #{e.message}"
         error_response("Go back timed out: #{e.message}")

data/lib/ferrum_mcp/tools/go_forward_tool.rb

@@ -2,41 +2,18 @@
 
 module FerrumMCP
   module Tools
-    # Tool to go forward in browser history
+    # Go forward to the next page in browser history
     class GoForwardTool < BaseTool
-      def self.tool_name
-        'go_forward'
-      end
-
-      def self.description
-        'Go forward to the next page in browser history'
-      end
+      tool_name 'go_forward'
+      description 'Go forward to the next page in browser history'
 
-      def self.input_schema
-        {
-          type: 'object',
-          properties: {
-            session_id: {
-              type: 'string',
-              description: 'Session ID to use for this operation'
-            }
-          },
-          required: ['session_id']
-        }
-      end
-
-      def execute(_params)
+      def perform(_params)
         ensure_browser_active
         logger.info 'Going forward'
-        browser.forward
-
-        # Wait for network to be idle to ensure page is loaded
-        browser.network.wait_for_idle(timeout: 30)
+        page.forward
+        page.network.wait_for_idle(timeout: 30)
 
-        success_response(
-          url: browser.url,
-          title: browser.title
-        )
+        success_response(url: page.url, title: page.title)
       rescue Ferrum::TimeoutError => e
         logger.error "Go forward timeout: #{e.message}"
         error_response("Go forward timed out: #{e.message}")

data/lib/ferrum_mcp/tools/hover_tool.rb

@@ -2,51 +2,27 @@
 
 module FerrumMCP
   module Tools
-    # Tool to hover over an element
+    # Hover over an element
     class HoverTool < BaseTool
-      def self.tool_name
-        'hover'
-      end
-
-      def self.description
-        'Hover over an element using a CSS selector'
-      end
-
-      def self.input_schema
-        {
-          type: 'object',
-          properties: {
-            selector: {
-              type: 'string',
-              description: 'CSS selector of the element to hover over'
-            },
-            session_id: {
-              type: 'string',
-              description: 'Session ID to use for this operation'
-            }
-          },
-          required: %w[selector session_id]
-        }
-      end
+      tool_name 'hover'
+      description 'Hover over an element (CSS selector, XPath or snapshot ref)'
 
-      def execute(params)
-        selector = param(params, :selector)
+      param :selector, type: :string, required: true, description: 'Selector of the element to hover over'
 
+      def perform(params)
+        selector = params[:selector]
         logger.info "Hovering over element: #{selector}"
 
-        # First ensure element exists and is ready
         element = find_element(selector)
+        element.scroll_into_view
 
-        # Scroll into view if supported
-        element.scroll_into_view if element.respond_to?(:scroll_into_view)
-
-        # Try native hover first, fallback to JavaScript
         begin
           element.hover
-          logger.debug 'Native hover successful'
         rescue StandardError => e
           logger.debug "Native hover failed, using JavaScript: #{e.message}"
-          hover_with_javascript(selector)
+          page.execute(<<~JS, element)
+            arguments[0].dispatchEvent(new MouseEvent('mouseover', { bubbles: true, cancelable: true, view: window }));
+          JS
         end
 
         success_response(message: "Hovered over #{selector}")
@@ -54,23 +30,6 @@ module FerrumMCP
         logger.error "Hover failed: #{e.message}"
         error_response("Failed to hover: #{e.message}")
       end
-
-      private
-
-      def hover_with_javascript(selector)
-        # Use inspect to properly escape the selector for JavaScript (prevents XSS)
-        script = <<~JS
-          const element = document.querySelector(#{selector.inspect});
-          if (!element) {
-            throw new Error('Element not found: ' + #{selector.inspect});
-          }
-          const event = new MouseEvent('mouseover', { bubbles: true, cancelable: true, view: window });
-          element.dispatchEvent(event);
-        JS
-
-        browser.execute(script)
-        logger.debug 'JavaScript hover successful'
-      end
     end
   end
 end

data/lib/ferrum_mcp/tools/list_sessions_tool.rb

@@ -2,28 +2,14 @@
 
 module FerrumMCP
   module Tools
+    # List all active sessions
     class ListSessionsTool < SessionTool
-      def self.tool_name
-        'list_sessions'
-      end
-
-      def self.description
-        'List all active browser sessions with their information (id, status, type, uptime, etc.)'
-      end
-
-      def self.input_schema
-        {
-          type: 'object',
-          properties: {}
-        }
-      end
+      tool_name 'list_sessions'
+      description 'List all active browser sessions with their information (id, status, type, uptime, etc.)'
 
-      def execute(_params)
+      def perform(_params)
         sessions = session_manager.list_sessions
-        success_response(
-          count: sessions.size,
-          sessions: sessions
-        )
+        success_response(count: sessions.size, sessions: sessions)
       rescue StandardError => e
         logger.error "Failed to list sessions: #{e.message}"
         error_response("Failed to list sessions: #{e.message}")

data/lib/ferrum_mcp/tools/list_tabs_tool.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module FerrumMCP
+  module Tools
+    # List open tabs
+    class ListTabsTool < TabTool
+      tool_name 'list_tabs'
+      description 'List the open tabs of the session with their tab_id, url and title; marks the current one'
+
+      def perform(_params)
+        ensure_browser_active
+        list = tabs.map.with_index { |tab, index| describe(tab, index) }
+        success_response(count: list.length, tabs: list)
+      rescue StandardError => e
+        logger.error "List tabs failed: #{e.message}"
+        error_response("Failed to list tabs: #{e.message}")
+      end
+    end
+  end
+end

data/lib/ferrum_mcp/tools/navigate_tool.rb

@@ -2,51 +2,31 @@
 
 module FerrumMCP
   module Tools
-    # Tool to navigate to a URL
+    # Navigate to a URL
     class NavigateTool < BaseTool
-      def self.tool_name
-        'navigate'
-      end
-
-      def self.description
-        'Navigate to a specific URL in the browser'
-      end
+      tool_name 'navigate'
+      description 'Navigate to a specific URL in the browser and wait for the network to settle'
 
-      def self.input_schema
-        {
-          type: 'object',
-          properties: {
-            url: {
-              type: 'string',
-              description: 'The URL to navigate to (must include protocol: http:// or https://)'
-            },
-            session_id: {
-              type: 'string',
-              description: 'Session ID to use for this operation'
-            }
-          },
-          required: %w[url session_id]
-        }
-      end
+      param :url, type: :string, required: true,
+                  description: 'The URL to navigate to (must include protocol: http:// or https://)'
+      param :wait_for_idle, type: :boolean, default: true,
+                            description: 'Wait for network idle after navigation (default: true)'
+      param :timeout, type: :number, default: 30,
+                      description: 'Seconds to wait for the network to become idle (default: 30)'
 
-      def execute(params)
+      def perform(params)
         ensure_browser_active
-        url = param(params, :url)
+        url = params[:url].to_s
 
-        # Validate URL format
-        raise ToolError, 'URL must start with http:// or https://' unless %r{^https?://}.match?(url)
+        raise ToolError, 'URL must start with http:// or https://' unless %r{\Ahttps?://}.match?(url)
 
-        logger.info "Navigating to: #{url}"
-        browser.goto(url)
+        @browser_manager.config.url_policy.check!(url)
 
-        # Wait for network to be idle to ensure page is loaded
-        # This prevents race conditions with subsequent tool calls
-        browser.network.wait_for_idle(timeout: 30)
+        logger.info "Navigating to: #{url}"
+        page.goto(url)
+        page.network.wait_for_idle(timeout: params[:timeout]) if params[:wait_for_idle]
 
-        success_response(
-          url: browser.url,
-          title: browser.title
-        )
+        success_response(url: page.url, title: page.title)
       rescue Ferrum::TimeoutError => e
         logger.error "Navigation timeout: #{e.message}"
         error_response("Navigation timed out: #{e.message}")

data/lib/ferrum_mcp/tools/new_tab_tool.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module FerrumMCP
+  module Tools
+    # Open a new tab
+    class NewTabTool < TabTool
+      tool_name 'new_tab'
+      description 'Open a new tab (optionally at a URL) and make it the current tab'
+
+      param :url, type: :string, description: 'Optional: URL to open in the new tab'
+
+      def perform(params)
+        ensure_browser_active
+        url = params[:url]
+        if url
+          raise ToolError, 'URL must start with http:// or https://' unless %r{\Ahttps?://}.match?(url)
+
+          @browser_manager.config.url_policy.check!(url)
+        end
+
+        logger.info "Opening new tab#{" at #{url}" if url}"
+        tab = @browser_manager.create_page
+        @browser_manager.select_page(tab)
+        if url
+          tab.goto(url)
+          tab.network.wait_for_idle(timeout: 30)
+        end
+
+        success_response(tab_id: tab.target_id, url: tab.url, title: tab.title, count: tabs.length)
+      rescue StandardError => e
+        logger.error "New tab failed: #{e.message}"
+        error_response("Failed to open tab: #{e.message}")
+      end
+    end
+  end
+end

data/lib/ferrum_mcp/tools/press_key_tool.rb

@@ -2,53 +2,33 @@
 
 module FerrumMCP
   module Tools
-    # Tool to press keyboard keys
+    # Press keyboard keys
     class PressKeyTool < BaseTool
-      def self.tool_name
-        'press_key'
-      end
+      tool_name 'press_key'
+      description 'Press a keyboard key (e.g. Enter, Tab, Escape, ArrowDown) or type a character'
 
-      def self.description
-        'Press keyboard keys (e.g., Enter, Tab, Escape)'
-      end
+      param :key, type: :string, required: true, description: 'Key to press (Enter, Tab, Escape, ArrowDown, etc.)'
+      param :selector, type: :string, description: 'Optional: selector of the element to focus before pressing the key'
 
-      def self.input_schema
-        {
-          type: 'object',
-          properties: {
-            key: {
-              type: 'string',
-              description: 'Key to press (Enter, Tab, Escape, ArrowDown, etc.)'
-            },
-            selector: {
-              type: 'string',
-              description: 'Optional: CSS selector to focus before pressing key'
-            },
-            session_id: {
-              type: 'string',
-              description: 'Session ID to use for this operation'
-            }
-          },
-          required: %w[key session_id]
-        }
-      end
+      KEY_ALIASES = {
+        'enter' => :Enter, 'return' => :Enter, 'tab' => :Tab, 'escape' => :Escape, 'esc' => :Escape,
+        'backspace' => :Backspace, 'delete' => :Delete, 'del' => :Delete,
+        'arrowdown' => :Down, 'down' => :Down, 'arrowup' => :Up, 'up' => :Up,
+        'arrowleft' => :Left, 'left' => :Left, 'arrowright' => :Right, 'right' => :Right,
+        'space' => ' ', 'pageup' => :PageUp, 'pagedown' => :PageDown, 'home' => :Home, 'end' => :End
+      }.freeze
 
-      def execute(params)
-        key = param(params, :key)
-        selector = param(params, :selector)
+      def perform(params)
+        key = params[:key].to_s
+        selector = params[:selector]
 
         if selector
           logger.info "Focusing element: #{selector}"
-          element = find_element(selector)
-          element.focus
+          find_element(selector).focus
         end
 
         logger.info "Pressing key: #{key}"
-        normalized_key = normalize_key(key)
-
-        # Use keyboard.type for key presses
-        # This handles both special keys and regular characters correctly
-        browser.keyboard.type(normalized_key)
+        page.keyboard.type(normalize_key(key))
 
         success_response(message: "Pressed key: #{key}")
       rescue StandardError => e
@@ -59,32 +39,7 @@ module FerrumMCP
       private
 
       def normalize_key(key)
-        # Convert common key names to Ferrum format
-        case key.to_s.downcase
-        when 'enter', 'return'
-          :Enter
-        when 'tab'
-          :Tab
-        when 'escape', 'esc'
-          :Escape
-        when 'backspace'
-          :Backspace
-        when 'delete', 'del'
-          :Delete
-        when 'arrowdown', 'down'
-          :Down
-        when 'arrowup', 'up'
-          :Up
-        when 'arrowleft', 'left'
-          :Left
-        when 'arrowright', 'right'
-          :Right
-        when 'space'
-          ' '
-        else
-          # If already a symbol, return as-is, otherwise try to convert
-          key.is_a?(Symbol) ? key : key.to_sym
-        end
+        KEY_ALIASES.fetch(key.downcase) { key.length == 1 ? key : key.to_sym }
       end
     end
   end