headless_browser_tool 0.1.1

data/lib/headless_browser_tool/tools/click_link_tool.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class ClickLinkTool < BaseTool
+      tool_name "click_link"
+      description "Click link by text or selector"
+
+      arguments do
+        required(:link_text_or_selector).filled(:string).description("Link text or CSS selector")
+      end
+
+      def execute(link_text_or_selector:)
+        url_before = browser.current_url
+        browser.title
+
+        # Find the link element first
+        link = begin
+          browser.find_link(link_text_or_selector)
+        rescue Capybara::ElementNotFound
+          browser.find(link_text_or_selector)
+        end
+
+        link_info = {
+          text: link.text.strip,
+          href: link[:href],
+          target: link[:target]
+        }.compact
+
+        browser.click_link(link_text_or_selector)
+
+        {
+          link: link_text_or_selector,
+          element: link_info,
+          navigation: {
+            navigated: browser.current_url != url_before,
+            from: url_before,
+            to: browser.current_url,
+            title: browser.title
+          },
+          status: "clicked"
+        }
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/click_tool.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class ClickTool < BaseTool
+      tool_name "click"
+      description "Click an element by CSS selector"
+
+      arguments do
+        required(:selector).filled(:string).description("CSS selector of the element to click")
+      end
+
+      def execute(selector:)
+        # Capture state before click
+        url_before = browser.current_url
+
+        # Get element info before clicking
+        element = browser.find_element(selector)
+        element_text = element[:text]
+        tag_name = element[:tag_name]
+
+        # Perform click
+        browser.click(selector)
+
+        # Brief wait to allow page changes
+        sleep 0.1
+
+        {
+          selector: selector,
+          element: {
+            tag_name: tag_name,
+            text: element_text
+          },
+          navigation: {
+            url_before: url_before,
+            url_after: browser.current_url,
+            navigated: url_before != browser.current_url
+          }
+        }
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/close_window_tool.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class CloseWindowTool < BaseTool
+      tool_name "close_window"
+      description "Close specific browser window/tab"
+
+      arguments do
+        required(:window_handle).filled(:string).description("Handle of the window to close")
+      end
+
+      def execute(window_handle:)
+        initial_windows = browser.windows
+        current_window = browser.current_window
+        browser.close_window(window_handle)
+
+        {
+          closed_window: window_handle,
+          was_current: window_handle == current_window,
+          previous_windows: initial_windows,
+          remaining_windows: browser.windows,
+          current_window: browser.current_window,
+          status: "closed"
+        }
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/double_click_tool.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class DoubleClickTool < BaseTool
+      tool_name "double_click"
+      description "Double-click an element by CSS selector"
+
+      arguments do
+        required(:selector).filled(:string).description("CSS selector of the element to double-click")
+      end
+
+      def execute(selector:)
+        element = browser.find(selector)
+        element_info = {
+          tag_name: element.tag_name,
+          text: element.text.strip,
+          visible: element.visible?,
+          attributes: {
+            id: element[:id],
+            class: element[:class]
+          }.compact
+        }
+
+        browser.double_click(selector)
+
+        {
+          selector: selector,
+          element: element_info,
+          status: "double_clicked"
+        }
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/drag_tool.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class DragTool < BaseTool
+      tool_name "drag"
+      description "Drag an element to another element"
+
+      arguments do
+        required(:source_selector).filled(:string).description("CSS selector of the element to drag")
+        required(:target_selector).filled(:string).description("CSS selector of the target element")
+      end
+
+      def execute(source_selector:, target_selector:)
+        source = browser.find(source_selector)
+        target = browser.find(target_selector)
+
+        source_info = {
+          tag_name: source.tag_name,
+          text: source.text.strip,
+          id: source[:id],
+          class: source[:class]
+        }.compact
+
+        target_info = {
+          tag_name: target.tag_name,
+          text: target.text.strip,
+          id: target[:id],
+          class: target[:class]
+        }.compact
+
+        browser.drag(source_selector, target_selector)
+
+        {
+          source_selector: source_selector,
+          target_selector: target_selector,
+          source: source_info,
+          target: target_info,
+          status: "dragged"
+        }
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/evaluate_script_tool.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class EvaluateScriptTool < BaseTool
+      tool_name "evaluate_script"
+      description "Run JavaScript and return the result"
+
+      arguments do
+        required(:javascript_code).filled(:string).description("JavaScript code to evaluate")
+      end
+
+      def execute(javascript_code:)
+        browser.evaluate_script(javascript_code)
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/execute_script_tool.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class ExecuteScriptTool < BaseTool
+      tool_name "execute_script"
+      description "Run JavaScript without return value"
+
+      arguments do
+        required(:javascript_code).filled(:string).description("JavaScript code to execute")
+      end
+
+      def execute(javascript_code:)
+        start_time = Time.now
+        browser.execute_script(javascript_code)
+        execution_time = Time.now - start_time
+
+        {
+          javascript_code: javascript_code,
+          execution_time: execution_time,
+          timestamp: Time.now.iso8601,
+          status: "executed"
+        }
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/fill_in_tool.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class FillInTool < BaseTool
+      tool_name "fill_in"
+      description "Fill in an input field"
+
+      arguments do
+        required(:field).filled(:string).description("Field name, id, or label")
+        required(:value).filled(:string).description("Value to fill in")
+      end
+
+      def execute(field:, value:)
+        # Try to find the field to get more info
+        field_info = begin
+          # Try different selectors
+          element = begin
+            browser.find_element("input[name='#{field}']")
+          rescue StandardError
+            nil
+          end
+          element ||= begin
+            browser.find_element("input##{field}")
+          rescue StandardError
+            nil
+          end
+          element ||= begin
+            browser.find_element("textarea[name='#{field}']")
+          rescue StandardError
+            nil
+          end
+          element ||= begin
+            browser.find_element("textarea##{field}")
+          rescue StandardError
+            nil
+          end
+
+          if element
+            {
+              type: element[:attributes]["type"] || "text",
+              name: element[:attributes]["name"],
+              id: element[:attributes]["id"],
+              placeholder: element[:attributes]["placeholder"]
+            }.compact
+          else
+            {}
+          end
+        rescue StandardError
+          {}
+        end
+
+        browser.fill_in(field, value)
+
+        {
+          field: field,
+          value: value,
+          field_info: field_info,
+          status: "success"
+        }
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/find_all_tool.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class FindAllTool < BaseTool
+      tool_name "find_all"
+      description "Find all matching elements, returns array"
+
+      arguments do
+        required(:selector).filled(:string).description("CSS selector to find all matching elements")
+      end
+
+      def execute(selector:)
+        elements = browser.find_all(selector)
+
+        {
+          selector: selector,
+          count: elements.size,
+          elements: elements.map.with_index do |element, index|
+            result = {
+              index: index,
+              selector: "#{selector}:nth-of-type(#{index + 1})",
+              tag_name: element[:tag_name],
+              text: element[:text].strip,
+              visible: element[:visible]
+            }
+
+            # Include attributes if present
+            result[:attributes] = element[:attributes] unless element[:attributes].empty?
+
+            # Include value for form elements
+            result[:value] = element[:value] if element[:value] && !element[:value].empty?
+
+            result
+          end
+        }
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/find_element_tool.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class FindElementTool < BaseTool
+      tool_name "find_element"
+      description "Find single element, errors if not found"
+
+      arguments do
+        required(:selector).filled(:string).description("CSS selector of the element to find")
+      end
+
+      def execute(selector:)
+        browser.find_element(selector)
+        "Found element: #{selector}"
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/find_elements_containing_text_tool.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class FindElementsContainingTextTool < BaseTool
+      tool_name "find_elements_containing_text"
+      description "Find all elements containing specified text and return their selectors"
+
+      arguments do
+        required(:text).filled(:string).description("Text to search for in elements")
+        optional(:exact_match).filled(:bool).description("Require exact text match (default: false)")
+        optional(:case_sensitive).filled(:bool).description("Case sensitive search (default: false)")
+        optional(:visible_only).filled(:bool).description("Only return visible elements (default: true)")
+      end
+
+      def execute(text:, exact_match: false, case_sensitive: false, visible_only: true)
+        script = build_search_script(text, exact_match, case_sensitive, visible_only)
+        elements_data = browser.execute_script(script)
+
+        # Ensure we have an array to work with
+        elements_data = [] if elements_data.nil?
+        elements_data = [elements_data] unless elements_data.is_a?(Array)
+
+        # Process and enrich the results
+        results = elements_data.map do |element|
+          # Skip if element is not a hash
+          next unless element.is_a?(Hash)
+
+          # Safely extract values with defaults
+          {
+            tag: element["tag"] || "unknown",
+            text: (element["text"] || "").to_s,
+            selector: element["selector"] || "",
+            xpath: element["xpath"] || "",
+            attributes: element["attributes"] || {},
+            parent: element["parent"] || nil,
+            clickable: element["clickable"] == true,
+            visible: element["visible"] == true,
+            position: element["position"] || {}
+          }
+        end.compact
+
+        {
+          query: text,
+          total_found: results.size,
+          elements: results
+        }
+      end
+
+      private
+
+      def build_search_script(text, exact_match, case_sensitive, visible_only)
+        <<~JS
+          (function() {
+            const searchText = #{text.to_json};
+            const exactMatch = #{exact_match};
+            const caseSensitive = #{case_sensitive};
+            const visibleOnly = #{visible_only};
+
+            // Helper to check if element is visible
+            function isVisible(elem) {
+              if (!elem) return false;
+              const style = window.getComputedStyle(elem);
+              return style.display !== 'none' &&
+                     style.visibility !== 'hidden' &&
+                     style.opacity !== '0' &&
+                     elem.offsetWidth > 0 &&
+                     elem.offsetHeight > 0;
+            }
+
+            // Helper to generate unique selector
+            function getSelector(elem) {
+              if (elem.id) {
+                return '#' + CSS.escape(elem.id);
+              }
+
+              if (elem.className && typeof elem.className === 'string') {
+                const classes = elem.className.trim().split(/\\s+/)
+                  .filter(c => c.length > 0)
+                  .map(c => '.' + CSS.escape(c))
+                  .join('');
+                if (classes && document.querySelectorAll(elem.tagName + classes).length === 1) {
+                  return elem.tagName.toLowerCase() + classes;
+                }
+              }
+
+              // Build path from root
+              const path = [];
+              let current = elem;
+              while (current && current.nodeType === Node.ELEMENT_NODE) {
+                let selector = current.tagName.toLowerCase();
+                if (current.id) {
+                  selector = '#' + CSS.escape(current.id);
+                  path.unshift(selector);
+                  break;
+                } else {
+                  let sibling = current;
+                  let nth = 1;
+                  while (sibling.previousElementSibling) {
+                    sibling = sibling.previousElementSibling;
+                    if (sibling.tagName === current.tagName) nth++;
+                  }
+                  if (nth > 1) selector += ':nth-of-type(' + nth + ')';
+                }
+                path.unshift(selector);
+                current = current.parentElement;
+              }
+              return path.join(' > ');
+            }
+
+            // Helper to get XPath
+            function getXPath(elem) {
+              const path = [];
+              let current = elem;
+              while (current && current.nodeType === Node.ELEMENT_NODE) {
+                let index = 0;
+                let sibling = current;
+                while (sibling) {
+                  if (sibling.nodeType === Node.ELEMENT_NODE && sibling.tagName === current.tagName) {
+                    index++;
+                  }
+                  sibling = sibling.previousSibling;
+                  if (sibling === current) break;
+                }
+                path.unshift(current.tagName.toLowerCase() + '[' + index + ']');
+                current = current.parentElement;
+              }
+              return '//' + path.join('/');
+            }
+
+            // Helper to check if text matches
+            function textMatches(elementText, searchText) {
+              if (!caseSensitive) {
+                elementText = elementText.toLowerCase();
+                searchText = searchText.toLowerCase();
+              }
+
+              if (exactMatch) {
+                return elementText.trim() === searchText.trim();
+              } else {
+                return elementText.includes(searchText);
+              }
+            }
+
+            // Helper to check if element is clickable
+            function isClickable(elem) {
+              const tag = elem.tagName.toLowerCase();
+              return tag === 'a' || tag === 'button' ||
+                     elem.onclick !== null ||
+                     elem.hasAttribute('onclick') ||
+                     elem.style.cursor === 'pointer' ||
+                     elem.role === 'button' ||
+                     elem.role === 'link';
+            }
+
+            // Find all text nodes and their parent elements
+            const results = [];
+            const processed = new Set();
+            const walker = document.createTreeWalker(
+              document.body,
+              NodeFilter.SHOW_TEXT,
+              {
+                acceptNode: function(node) {
+                  if (node.textContent.trim().length === 0) {
+                    return NodeFilter.FILTER_REJECT;
+                  }
+                  return NodeFilter.FILTER_ACCEPT;
+                }
+              }
+            );
+
+            let node;
+            while (node = walker.nextNode()) {
+              const parent = node.parentElement;
+              if (!parent || processed.has(parent)) continue;
+
+              const text = parent.textContent;
+              if (textMatches(text, searchText)) {
+                if (visibleOnly && !isVisible(parent)) continue;
+
+                processed.add(parent);
+
+                // Get element attributes
+                const attributes = {};
+                if (parent.attributes && parent.attributes.length) {
+                  for (let i = 0; i < parent.attributes.length; i++) {
+                    const attr = parent.attributes[i];
+                    attributes[attr.name] = attr.value;
+                  }
+                }
+
+                // Get position
+                const rect = parent.getBoundingClientRect();
+
+                results.push({
+                  tag: parent.tagName.toLowerCase(),
+                  text: text.trim().substring(0, 200), // Limit text length
+                  selector: getSelector(parent),
+                  xpath: getXPath(parent),
+                  attributes: attributes,
+                  parent: parent.parentElement ? parent.parentElement.tagName.toLowerCase() : null,
+                  clickable: isClickable(parent),
+                  visible: isVisible(parent),
+                  position: {
+                    top: rect.top + window.scrollY,
+                    left: rect.left + window.scrollX,
+                    width: rect.width,
+                    height: rect.height
+                  }
+                });
+              }
+            }
+
+            // Also search in input values
+            document.querySelectorAll('input, textarea, select').forEach(elem => {
+              if (processed.has(elem)) return;
+
+              const value = elem.value || elem.textContent;
+              if (value && textMatches(value, searchText)) {
+                if (visibleOnly && !isVisible(elem)) return;
+
+                const attributes = {};
+                if (elem.attributes && elem.attributes.length) {
+                  for (let i = 0; i < elem.attributes.length; i++) {
+                    const attr = elem.attributes[i];
+                    attributes[attr.name] = attr.value;
+                  }
+                }
+
+                const rect = elem.getBoundingClientRect();
+
+                results.push({
+                  tag: elem.tagName.toLowerCase(),
+                  text: value.trim().substring(0, 200),
+                  selector: getSelector(elem),
+                  xpath: getXPath(elem),
+                  attributes: attributes,
+                  parent: elem.parentElement ? elem.parentElement.tagName.toLowerCase() : null,
+                  clickable: true,
+                  visible: isVisible(elem),
+                  position: {
+                    top: rect.top + window.scrollY,
+                    left: rect.left + window.scrollX,
+                    width: rect.width,
+                    height: rect.height
+                  }
+                });
+              }
+            });
+
+            return results;
+          })();
+        JS
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/get_attribute_tool.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class GetAttributeTool < BaseTool
+      tool_name "get_attribute"
+      description "Get an attribute value from an element"
+
+      arguments do
+        required(:selector).filled(:string).description("CSS selector of the element")
+        required(:attribute_name).filled(:string).description("Name of the attribute to get")
+      end
+
+      def execute(selector:, attribute_name:)
+        browser.get_attribute(selector, attribute_name)
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/get_current_path_tool.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class GetCurrentPathTool < BaseTool
+      tool_name "get_current_path"
+      description "Get current path without domain"
+
+      def execute
+        browser.get_current_path
+      end
+    end
+  end
+end