crucible 0.1.2

data/lib/crucible/tools/interaction.rb

@@ -0,0 +1,355 @@
+# frozen_string_literal: true
+
+require 'mcp'
+
+module Crucible
+  module Tools
+    # Interaction tools: click, type, fill_form, select_option, scroll, hover
+    module Interaction
+      class << self
+        def tools(sessions, _config)
+          [
+            click_tool(sessions),
+            type_tool(sessions),
+            fill_form_tool(sessions),
+            select_option_tool(sessions),
+            scroll_tool(sessions),
+            hover_tool(sessions)
+          ]
+        end
+
+        private
+
+        def click_tool(sessions)
+          MCP::Tool.define(
+            name: 'click',
+            description: 'Click an element on the page',
+            input_schema: {
+              type: 'object',
+              properties: {
+                session: {
+                  type: 'string',
+                  description: 'Session name',
+                  default: 'default'
+                },
+                selector: {
+                  type: 'string',
+                  description: 'CSS selector for the element to click'
+                },
+                button: {
+                  type: 'string',
+                  description: 'Mouse button to use',
+                  enum: %w[left right middle],
+                  default: 'left'
+                },
+                count: {
+                  type: 'integer',
+                  description: 'Number of clicks (1 for single, 2 for double)',
+                  default: 1
+                }
+              },
+              required: ['selector']
+            }
+          ) do |selector:, session: 'default', button: 'left', count: 1, **|
+            page = sessions.page(session)
+            element = page.at_css(selector)
+
+            raise ElementNotFoundError, "Element not found: #{selector}" unless element
+
+            # Ferrum uses mode: for click type - :left, :right, or :double
+            mode = if count == 2
+                     :double
+                   else
+                     button.to_sym
+                   end
+
+            element.click(mode: mode)
+
+            MCP::Tool::Response.new([{ type: 'text', text: "Clicked: #{selector}" }])
+          rescue ElementNotFoundError => e
+            MCP::Tool::Response.new([{ type: 'text', text: e.message }], error: true)
+          rescue Ferrum::Error => e
+            MCP::Tool::Response.new([{ type: 'text', text: "Click failed: #{e.message}" }], error: true)
+          end
+        end
+
+        def type_tool(sessions)
+          MCP::Tool.define(
+            name: 'type',
+            description: 'Type text into an input element',
+            input_schema: {
+              type: 'object',
+              properties: {
+                session: {
+                  type: 'string',
+                  description: 'Session name',
+                  default: 'default'
+                },
+                selector: {
+                  type: 'string',
+                  description: 'CSS selector for the input element'
+                },
+                text: {
+                  type: 'string',
+                  description: 'Text to type'
+                },
+                clear: {
+                  type: 'boolean',
+                  description: 'Clear the field before typing',
+                  default: false
+                },
+                submit: {
+                  type: 'boolean',
+                  description: 'Press Enter after typing',
+                  default: false
+                }
+              },
+              required: %w[selector text]
+            }
+          ) do |selector:, text:, session: 'default', clear: false, submit: false, **|
+            page = sessions.page(session)
+            element = page.at_css(selector)
+
+            raise ElementNotFoundError, "Element not found: #{selector}" unless element
+
+            element.focus
+
+            if clear
+              # Select all and delete (use meta on macOS, control elsewhere)
+              modifier = RUBY_PLATFORM.include?('darwin') ? :meta : :control
+              element.type([modifier, 'a'], [:backspace])
+            end
+
+            if submit
+              element.type(text, :Enter)
+            else
+              element.type(text)
+            end
+
+            MCP::Tool::Response.new([{ type: 'text', text: "Typed into: #{selector}" }])
+          rescue ElementNotFoundError => e
+            MCP::Tool::Response.new([{ type: 'text', text: e.message }], error: true)
+          rescue Ferrum::Error => e
+            MCP::Tool::Response.new([{ type: 'text', text: "Type failed: #{e.message}" }], error: true)
+          end
+        end
+
+        def fill_form_tool(sessions)
+          MCP::Tool.define(
+            name: 'fill_form',
+            description: 'Fill multiple form fields at once',
+            input_schema: {
+              type: 'object',
+              properties: {
+                session: {
+                  type: 'string',
+                  description: 'Session name',
+                  default: 'default'
+                },
+                fields: {
+                  type: 'array',
+                  description: 'Array of fields to fill',
+                  items: {
+                    type: 'object',
+                    properties: {
+                      selector: {
+                        type: 'string',
+                        description: 'CSS selector for the field'
+                      },
+                      value: {
+                        type: 'string',
+                        description: 'Value to enter'
+                      }
+                    },
+                    required: %w[selector value]
+                  }
+                }
+              },
+              required: ['fields']
+            }
+          ) do |fields:, session: 'default', **|
+            page = sessions.page(session)
+            filled = []
+            errors = []
+
+            fields.each do |field|
+              field_selector = field[:selector] || field['selector']
+              value = field[:value] || field['value']
+
+              element = page.at_css(field_selector)
+              if element
+                element.focus
+                # Clear first (use meta on macOS, control elsewhere)
+                modifier = RUBY_PLATFORM.include?('darwin') ? :meta : :control
+                element.type([modifier, 'a'], [:backspace])
+                element.type(value)
+                filled << field_selector
+              else
+                errors << field_selector
+              end
+            end
+
+            message = "Filled #{filled.size} field(s)"
+            message += ". Not found: #{errors.join(', ')}" if errors.any?
+
+            if errors.any? && filled.empty?
+              MCP::Tool::Response.new([{ type: 'text', text: message }], error: true)
+            else
+              MCP::Tool::Response.new([{ type: 'text', text: message }])
+            end
+          rescue Ferrum::Error => e
+            MCP::Tool::Response.new([{ type: 'text', text: "Fill form failed: #{e.message}" }], error: true)
+          end
+        end
+
+        def select_option_tool(sessions)
+          MCP::Tool.define(
+            name: 'select_option',
+            description: 'Select an option from a dropdown/select element',
+            input_schema: {
+              type: 'object',
+              properties: {
+                session: {
+                  type: 'string',
+                  description: 'Session name',
+                  default: 'default'
+                },
+                selector: {
+                  type: 'string',
+                  description: 'CSS selector for the select element'
+                },
+                value: {
+                  type: 'string',
+                  description: 'Value or text of the option to select'
+                },
+                by: {
+                  type: 'string',
+                  description: 'How to match the option',
+                  enum: %w[value text],
+                  default: 'value'
+                }
+              },
+              required: %w[selector value]
+            }
+          ) do |selector:, value:, session: 'default', by: 'value', **|
+            _ = by # TODO: Implement selection by text/index
+
+            page = sessions.page(session)
+            select = page.at_css(selector)
+
+            raise ElementNotFoundError, "Select element not found: #{selector}" unless select
+
+            select.select(value)
+
+            MCP::Tool::Response.new([{ type: 'text', text: "Selected '#{value}' in: #{selector}" }])
+          rescue ElementNotFoundError => e
+            MCP::Tool::Response.new([{ type: 'text', text: e.message }], error: true)
+          rescue Ferrum::Error => e
+            MCP::Tool::Response.new([{ type: 'text', text: "Select failed: #{e.message}" }], error: true)
+          end
+        end
+
+        def scroll_tool(sessions)
+          MCP::Tool.define(
+            name: 'scroll',
+            description: 'Scroll the page or scroll an element into view',
+            input_schema: {
+              type: 'object',
+              properties: {
+                session: {
+                  type: 'string',
+                  description: 'Session name',
+                  default: 'default'
+                },
+                selector: {
+                  type: 'string',
+                  description: 'CSS selector to scroll into view (optional)'
+                },
+                x: {
+                  type: 'integer',
+                  description: 'Horizontal scroll amount in pixels',
+                  default: 0
+                },
+                y: {
+                  type: 'integer',
+                  description: 'Vertical scroll amount in pixels',
+                  default: 0
+                },
+                direction: {
+                  type: 'string',
+                  description: 'Scroll direction shortcut',
+                  enum: %w[up down left right top bottom]
+                }
+              },
+              required: []
+            }
+          ) do |session: 'default', selector: nil, x: 0, y: 0, direction: nil, **|
+            page = sessions.page(session)
+
+            if selector
+              # Scroll element into view
+              element = page.at_css(selector)
+              raise ElementNotFoundError, "Element not found: #{selector}" unless element
+
+              element.scroll_into_view
+              MCP::Tool::Response.new([{ type: 'text', text: "Scrolled into view: #{selector}" }])
+            else
+              # Scroll by coordinates or direction
+              scroll_x, scroll_y = case direction
+                                   when 'up' then [0, -500]
+                                   when 'down' then [0, 500]
+                                   when 'left' then [-500, 0]
+                                   when 'right' then [500, 0]
+                                   when 'top' then [0, -100_000]
+                                   when 'bottom' then [0, 100_000]
+                                   else [x, y]
+                                   end
+
+              page.execute("window.scrollBy(#{scroll_x}, #{scroll_y})")
+              MCP::Tool::Response.new([{ type: 'text', text: "Scrolled by (#{scroll_x}, #{scroll_y})" }])
+            end
+          rescue ElementNotFoundError => e
+            MCP::Tool::Response.new([{ type: 'text', text: e.message }], error: true)
+          rescue Ferrum::Error => e
+            MCP::Tool::Response.new([{ type: 'text', text: "Scroll failed: #{e.message}" }], error: true)
+          end
+        end
+
+        def hover_tool(sessions)
+          MCP::Tool.define(
+            name: 'hover',
+            description: 'Hover over an element',
+            input_schema: {
+              type: 'object',
+              properties: {
+                session: {
+                  type: 'string',
+                  description: 'Session name',
+                  default: 'default'
+                },
+                selector: {
+                  type: 'string',
+                  description: 'CSS selector for the element to hover'
+                }
+              },
+              required: ['selector']
+            }
+          ) do |selector:, session: 'default', **|
+            page = sessions.page(session)
+            element = page.at_css(selector)
+
+            raise ElementNotFoundError, "Element not found: #{selector}" unless element
+
+            element.hover
+
+            MCP::Tool::Response.new([{ type: 'text', text: "Hovering over: #{selector}" }])
+          rescue ElementNotFoundError => e
+            MCP::Tool::Response.new([{ type: 'text', text: e.message }], error: true)
+          rescue Ferrum::Error => e
+            MCP::Tool::Response.new([{ type: 'text', text: "Hover failed: #{e.message}" }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/crucible/tools/navigation.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'mcp'
+
+module Crucible
+  module Tools
+    # Navigation tools: navigate, wait_for, back, forward, refresh
+    module Navigation
+      class << self
+        def tools(sessions, _config)
+          [
+            navigate_tool(sessions),
+            wait_for_tool(sessions),
+            back_tool(sessions),
+            forward_tool(sessions),
+            refresh_tool(sessions)
+          ]
+        end
+
+        private
+
+        def navigate_tool(sessions)
+          MCP::Tool.define(
+            name: 'navigate',
+            description: "Navigate browser to a URL. Creates a new session if it doesn't exist.",
+            input_schema: {
+              type: 'object',
+              properties: {
+                session: {
+                  type: 'string',
+                  description: 'Session name for managing multiple browsers',
+                  default: 'default'
+                },
+                url: {
+                  type: 'string',
+                  description: 'URL to navigate to'
+                }
+              },
+              required: ['url']
+            }
+          ) do |url:, session: 'default', **|
+            page = sessions.page(session)
+            page.go_to(url)
+
+            MCP::Tool::Response.new(
+              [{
+                type: 'text',
+                text: "Navigated to #{url} (session: #{session})"
+              }]
+            )
+          rescue Ferrum::Error => e
+            MCP::Tool::Response.new([{ type: 'text', text: "Navigation failed: #{e.message}" }], error: true)
+          end
+        end
+
+        def wait_for_tool(sessions)
+          MCP::Tool.define(
+            name: 'wait_for',
+            description: 'Wait for an element to appear on the page',
+            input_schema: {
+              type: 'object',
+              properties: {
+                session: {
+                  type: 'string',
+                  description: 'Session name',
+                  default: 'default'
+                },
+                selector: {
+                  type: 'string',
+                  description: 'CSS selector to wait for'
+                },
+                timeout: {
+                  type: 'number',
+                  description: 'Maximum wait time in seconds',
+                  default: 30
+                }
+              },
+              required: ['selector']
+            }
+          ) do |selector:, session: 'default', timeout: 30, **|
+            page = sessions.page(session)
+
+            # Poll for element with timeout
+            start_time = Time.now
+            element = nil
+            loop do
+              element = page.at_css(selector)
+              break if element
+
+              if Time.now - start_time > timeout
+                return MCP::Tool::Response.new([{ type: 'text', text: "Timeout waiting for: #{selector}" }],
+                                               error: true)
+              end
+
+              sleep 0.1
+            end
+
+            MCP::Tool::Response.new([{ type: 'text', text: "Found element: #{selector}" }])
+          rescue Ferrum::Error => e
+            MCP::Tool::Response.new([{ type: 'text', text: "Wait failed: #{e.message}" }], error: true)
+          end
+        end
+
+        def back_tool(sessions)
+          MCP::Tool.define(
+            name: 'back',
+            description: 'Navigate back in browser history',
+            input_schema: {
+              type: 'object',
+              properties: {
+                session: {
+                  type: 'string',
+                  description: 'Session name',
+                  default: 'default'
+                }
+              },
+              required: []
+            }
+          ) do |session: 'default', **|
+            page = sessions.page(session)
+            page.back
+
+            MCP::Tool::Response.new([{ type: 'text', text: 'Navigated back' }])
+          rescue Ferrum::Error => e
+            MCP::Tool::Response.new([{ type: 'text', text: "Back navigation failed: #{e.message}" }], error: true)
+          end
+        end
+
+        def forward_tool(sessions)
+          MCP::Tool.define(
+            name: 'forward',
+            description: 'Navigate forward in browser history',
+            input_schema: {
+              type: 'object',
+              properties: {
+                session: {
+                  type: 'string',
+                  description: 'Session name',
+                  default: 'default'
+                }
+              },
+              required: []
+            }
+          ) do |session: 'default', **|
+            page = sessions.page(session)
+            page.forward
+
+            MCP::Tool::Response.new([{ type: 'text', text: 'Navigated forward' }])
+          rescue Ferrum::Error => e
+            MCP::Tool::Response.new([{ type: 'text', text: "Forward navigation failed: #{e.message}" }], error: true)
+          end
+        end
+
+        def refresh_tool(sessions)
+          MCP::Tool.define(
+            name: 'refresh',
+            description: 'Refresh the current page',
+            input_schema: {
+              type: 'object',
+              properties: {
+                session: {
+                  type: 'string',
+                  description: 'Session name',
+                  default: 'default'
+                }
+              },
+              required: []
+            }
+          ) do |session: 'default', **|
+            page = sessions.page(session)
+            page.refresh
+
+            MCP::Tool::Response.new([{ type: 'text', text: 'Page refreshed' }])
+          rescue Ferrum::Error => e
+            MCP::Tool::Response.new([{ type: 'text', text: "Refresh failed: #{e.message}" }], error: true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/crucible/tools/sessions.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'mcp'
+require 'json'
+
+module Crucible
+  module Tools
+    # Session management tools: list_sessions, close_session
+    module Sessions
+      class << self
+        def tools(sessions, _config)
+          [
+            list_sessions_tool(sessions),
+            close_session_tool(sessions)
+          ]
+        end
+
+        private
+
+        def list_sessions_tool(sessions)
+          MCP::Tool.define(
+            name: 'list_sessions',
+            description: 'List all active browser sessions',
+            input_schema: {
+              type: 'object',
+              properties: {},
+              required: []
+            }
+          ) do |**|
+            session_list = sessions.list
+
+            if session_list.empty?
+              MCP::Tool::Response.new([{ type: 'text', text: 'No active sessions' }])
+            else
+              result = {
+                count: session_list.size,
+                sessions: session_list
+              }
+              MCP::Tool::Response.new([{ type: 'text', text: JSON.pretty_generate(result) }])
+            end
+          end
+        end
+
+        def close_session_tool(sessions)
+          MCP::Tool.define(
+            name: 'close_session',
+            description: 'Close a browser session and free resources',
+            input_schema: {
+              type: 'object',
+              properties: {
+                session: {
+                  type: 'string',
+                  description: 'Session name to close'
+                },
+                all: {
+                  type: 'boolean',
+                  description: 'Close all sessions',
+                  default: false
+                }
+              },
+              required: []
+            }
+          ) do |session: nil, all: false, **|
+            if all
+              count = sessions.count
+              sessions.close_all
+              MCP::Tool::Response.new([{ type: 'text', text: "Closed #{count} session(s)" }])
+            elsif session
+              if sessions.close(session)
+                MCP::Tool::Response.new([{ type: 'text', text: "Closed session: #{session}" }])
+              else
+                MCP::Tool::Response.new([{ type: 'text', text: "Session not found: #{session}" }], error: true)
+              end
+            else
+              MCP::Tool::Response.new([{
+                                        type: 'text',
+                                        text: 'Please specify a session name or use all: true to close all sessions'
+                                      }], error: true)
+            end
+          end
+        end
+      end
+    end
+  end
+end