headless_browser_tool 0.1.1

data/lib/headless_browser_tool/tools/get_current_url_tool.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class GetCurrentUrlTool < BaseTool
+      tool_name "get_current_url"
+      description "Get the current page URL"
+
+      def execute
+        browser.get_current_url
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/get_narration_history_tool.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class GetNarrationHistoryTool < BaseTool
+      tool_name "get_narration_history"
+      description "Get the history of narrated events since auto_narrate was enabled"
+
+      def execute
+        history = browser.evaluate_script("window.getAINarration ? window.getAINarration() : []")
+
+        if history.nil? || history.empty?
+          "No narration history available. Enable auto_narrate first."
+        else
+          format_history(history)
+        end
+      end
+
+      private
+
+      def format_history(history)
+        output = ["🎬 Browser Event History:"]
+
+        history.last(20).each do |event|
+          time = Time.parse(event["timestamp"]).strftime("%H:%M:%S")
+          output << "[#{time}] #{event["message"]}"
+        end
+
+        output.join("\n")
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/get_page_context_tool.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class GetPageContextTool < BaseTool
+      tool_name "get_page_context"
+      description "Get a structured understanding of the current page"
+
+      def execute
+        context_script = <<~JS
+          (() => {
+            // Helper to generate unique selector for elements
+            const getUniqueSelector = (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(' > ');
+            };
+
+            // Identify page type
+            const identifyPageType = () => {
+              const url = window.location.href;
+              const title = document.title.toLowerCase();
+              const h1 = document.querySelector('h1')?.textContent.toLowerCase() || '';
+
+              if (url.includes('login') || title.includes('login') || h1.includes('login')) return 'login';
+              if (url.includes('search') || title.includes('search')) return 'search_results';
+              if (url.includes('cart') || title.includes('cart')) return 'shopping_cart';
+              if (url.includes('checkout')) return 'checkout';
+              if (document.querySelector('form[method="post"]')) return 'form_page';
+              if (document.querySelectorAll('article').length > 3) return 'article_list';
+              if (document.querySelector('article')) return 'article';
+              return 'general';
+            };
+
+            // Get main navigation
+            const getNavigation = () => {
+              const nav = document.querySelector('nav') || document.querySelector('[role="navigation"]');
+              if (!nav) return [];
+
+              return Array.from(nav.querySelectorAll('a')).slice(0, 10).map((a, index) => ({
+                text: a.textContent.trim(),
+                href: a.href,
+                selector: getUniqueSelector(a)
+              }));
+            };
+
+            // Get actionable elements
+            const getActions = () => {
+              const actions = [];
+
+              // Primary buttons
+              document.querySelectorAll('button[type="submit"], button.primary, button.btn-primary').forEach(btn => {
+                if (btn.offsetWidth > 0) {
+                  actions.push({
+                    type: 'primary_button',
+                    text: btn.textContent.trim(),
+                    selector: btn.className ? `.${btn.className.split(' ')[0]}` : 'button'
+                  });
+                }
+              });
+
+              // Forms
+              document.querySelectorAll('form').forEach((form, index) => {
+                const formInputs = Array.from(form.querySelectorAll('input:not([type="hidden"]), textarea, select'))
+                  .map(input => ({
+                    name: input.name || input.id,
+                    type: input.type || 'text',
+                    required: input.required,
+                    value: input.value,
+                    selector: getUniqueSelector(input)
+                  }));
+
+                if (formInputs.length > 0) {
+                  actions.push({
+                    type: 'form',
+                    action: form.action,
+                    method: form.method,
+                    selector: getUniqueSelector(form),
+                    inputs: formInputs
+                  });
+                }
+              });
+
+              return actions;
+            };
+
+            // Get key content areas
+            const getContentAreas = () => {
+              const areas = {};
+
+              // Main content
+              const main = document.querySelector('main') || document.querySelector('[role="main"]') || document.querySelector('#content');
+              if (main) {
+                areas.main = main.textContent.trim().substring(0, 200) + '...';
+              }
+
+              // Headings structure
+              areas.headings = Array.from(document.querySelectorAll('h1, h2, h3')).slice(0, 10).map(h => ({
+                level: h.tagName,
+                text: h.textContent.trim(),
+                selector: getUniqueSelector(h)
+              }));
+
+              // Errors or alerts
+              const alerts = document.querySelectorAll('[role="alert"], .error, .alert, .warning, .success');
+              if (alerts.length > 0) {
+                areas.alerts = Array.from(alerts).map(a => ({
+                  text: a.textContent.trim(),
+                  selector: getUniqueSelector(a)
+                }));
+              }
+
+              return areas;
+            };
+
+            // Get data attributes that might be useful
+            const getDataAttributes = () => {
+              const elements = document.querySelectorAll('[data-testid], [data-test], [data-cy]');
+              return Array.from(elements).slice(0, 20).map(el => ({
+                testId: el.dataset.testid || el.dataset.test || el.dataset.cy,
+                tag: el.tagName.toLowerCase(),
+                text: el.textContent.trim().substring(0, 50),
+                selector: getUniqueSelector(el)
+              }));
+            };
+
+            return {
+              url: window.location.href,
+              title: document.title,
+              pageType: identifyPageType(),
+              navigation: getNavigation(),
+              actions: getActions(),
+              contentAreas: getContentAreas(),
+              testIds: getDataAttributes(),
+              metrics: {
+                loadTime: performance.timing.loadEventEnd - performance.timing.navigationStart,
+                domElements: document.querySelectorAll('*').length,
+                images: document.images.length,
+                scripts: document.scripts.length
+              }
+            };
+          })();
+        JS
+
+        context = browser.evaluate_script(context_script)
+        return { error: "Unable to get page context" } if context.nil?
+
+        # Return raw context data instead of formatted string
+        context
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/get_page_source_tool.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class GetPageSourceTool < BaseTool
+      tool_name "get_page_source"
+      description "Get full HTML source of current page"
+
+      def execute
+        browser.get_page_source
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/get_page_title_tool.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class GetPageTitleTool < BaseTool
+      tool_name "get_page_title"
+      description "Get the page title from <title> tag"
+
+      def execute
+        browser.get_page_title
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/get_session_info_tool.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class GetSessionInfoTool < BaseTool
+      tool_name "get_session_info"
+      description "Get information about the current browser session"
+
+      def execute
+        if HeadlessBrowserTool::Server.single_session_mode
+          {
+            mode: "single_session",
+            session_id: "shared",
+            message: "Server is running in single session mode"
+          }
+        else
+          session_id = Thread.current[:hbt_session_id] || "default"
+          session_info = HeadlessBrowserTool::Server.session_manager.session_info
+
+          current_session = session_info[:session_data][session_id]
+
+          {
+            mode: "multi_session",
+            session_id: session_id,
+            created_at: current_session&.dig(:created_at),
+            last_activity: current_session&.dig(:last_activity),
+            idle_time: current_session&.dig(:idle_time),
+            active_sessions: session_info[:active_sessions],
+            total_sessions: session_info[:session_count]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/get_text_tool.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class GetTextTool < BaseTool
+      tool_name "get_text"
+      description "Get the visible text content of an element"
+
+      arguments do
+        required(:selector).filled(:string).description("CSS selector of the element")
+      end
+
+      def execute(selector:)
+        browser.get_text(selector)
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/get_value_tool.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class GetValueTool < BaseTool
+      tool_name "get_value"
+      description "Get the value of an input field"
+
+      arguments do
+        required(:selector).filled(:string).description("CSS selector of the input field")
+      end
+
+      def execute(selector:)
+        browser.get_value(selector)
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/get_window_handles_tool.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class GetWindowHandlesTool < BaseTool
+      tool_name "get_window_handles"
+      description "Get array of all window handles"
+
+      def execute
+        handles = browser.get_window_handles
+        current_handle = browser.current_window_handle
+
+        {
+          current_window: current_handle,
+          windows: handles.map.with_index do |handle, index|
+            {
+              handle: handle,
+              index: index,
+              is_current: handle == current_handle
+            }
+          end,
+          total_windows: handles.size
+        }
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/go_back_tool.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class GoBackTool < BaseTool
+      tool_name "go_back"
+      description "Navigate back in browser history"
+
+      def execute
+        url_before = browser.current_url
+        browser.title
+
+        browser.go_back
+
+        {
+          navigation: {
+            from: url_before,
+            to: browser.current_url,
+            title: browser.title,
+            navigated: browser.current_url != url_before
+          },
+          status: "navigated_back"
+        }
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/go_forward_tool.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class GoForwardTool < BaseTool
+      tool_name "go_forward"
+      description "Navigate forward in browser history"
+
+      def execute
+        url_before = browser.current_url
+        browser.title
+
+        browser.go_forward
+
+        {
+          navigation: {
+            from: url_before,
+            to: browser.current_url,
+            title: browser.title,
+            navigated: browser.current_url != url_before
+          },
+          status: "navigated_forward"
+        }
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/has_element_tool.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class HasElementTool < BaseTool
+      tool_name "has_element"
+      description "Check if an element exists on the page"
+
+      arguments do
+        required(:selector).filled(:string).description("CSS selector of the element")
+        optional(:wait_seconds).filled(:integer).description("Optional timeout in seconds")
+      end
+
+      def execute(selector:, wait_seconds: nil)
+        browser.has_element?(selector, wait_seconds)
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/has_text_tool.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class HasTextTool < BaseTool
+      tool_name "has_text"
+      description "Check if text appears on the page"
+
+      arguments do
+        required(:text).filled(:string).description("Text to search for")
+        optional(:wait_seconds).filled(:integer).description("Optional timeout in seconds")
+      end
+
+      def execute(text:, wait_seconds: nil)
+        browser.has_text?(text, wait_seconds)
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/hover_tool.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class HoverTool < BaseTool
+      tool_name "hover"
+      description "Hover over an element by CSS selector"
+
+      arguments do
+        required(:selector).filled(:string).description("CSS selector of the element to hover over")
+      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],
+            title: element[:title]
+          }.compact
+        }
+
+        browser.hover(selector)
+
+        {
+          selector: selector,
+          element: element_info,
+          status: "hovering"
+        }
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/is_visible_tool.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class IsVisibleTool < BaseTool
+      tool_name "is_visible"
+      description "Check if element is visible on page"
+
+      arguments do
+        required(:selector).filled(:string).description("CSS selector of the element to check")
+      end
+
+      def execute(selector:)
+        browser.is_visible?(selector)
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/maximize_window_tool.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class MaximizeWindowTool < BaseTool
+      tool_name "maximize_window"
+      description "Maximize the browser window"
+
+      def execute
+        # Get window size before maximizing
+        size_before = browser.current_window_size
+
+        browser.maximize_window
+
+        # Get window size after maximizing
+        size_after = browser.current_window_size
+
+        {
+          size_before: {
+            width: size_before[0],
+            height: size_before[1]
+          },
+          size_after: {
+            width: size_after[0],
+            height: size_after[1]
+          },
+          status: "maximized"
+        }
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/open_new_window_tool.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class OpenNewWindowTool < BaseTool
+      tool_name "open_new_window"
+      description "Open a new browser window/tab"
+
+      def execute
+        initial_windows = browser.windows
+        window_handle = browser.open_new_window
+
+        {
+          window_handle: window_handle,
+          total_windows: browser.windows.count,
+          previous_windows: initial_windows,
+          current_window: browser.current_window,
+          status: "opened"
+        }
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/refresh_tool.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class RefreshTool < BaseTool
+      tool_name "refresh"
+      description "Reload the current page"
+
+      def execute
+        url_before = browser.current_url
+        title_before = browser.title
+
+        browser.refresh
+
+        # Brief wait for refresh to complete
+        sleep 0.1
+
+        {
+          url: browser.current_url,
+          title: browser.title,
+          changed: {
+            url: url_before != browser.current_url,
+            title: title_before != browser.title
+          },
+          status: "success"
+        }
+      end
+    end
+  end
+end

data/lib/headless_browser_tool/tools/resize_window_tool.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "base_tool"
+
+module HeadlessBrowserTool
+  module Tools
+    class ResizeWindowTool < BaseTool
+      tool_name "resize_window"
+      description "Resize the browser window"
+
+      arguments do
+        required(:width).filled(:integer).description("Window width in pixels")
+        required(:height).filled(:integer).description("Window height in pixels")
+      end
+
+      def execute(width:, height:)
+        # Get window size before resizing
+        size_before = browser.current_window_size
+
+        browser.resize_window(width, height)
+
+        # Get actual window size after resizing
+        size_after = browser.current_window_size
+
+        {
+          requested_size: {
+            width: width,
+            height: height
+          },
+          size_before: {
+            width: size_before[0],
+            height: size_before[1]
+          },
+          size_after: {
+            width: size_after[0],
+            height: size_after[1]
+          },
+          status: "resized"
+        }
+      end
+    end
+  end
+end