openclaw-node-harness 2.0.0

package/skills/fast-browser-use/src/tools/markdown.rs

@@ -0,0 +1,181 @@
+use crate::{error::{BrowserError, Result},
+            tools::{Tool, ToolContext, ToolResult, html_to_markdown::convert_html_to_markdown,
+                    readability_script::READABILITY_SCRIPT}};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Parameters for getting markdown content with pagination support
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct GetMarkdownParams {
+    /// Page number to extract (1-based index, default: 1)
+    #[serde(default = "default_page")]
+    pub page: usize,
+
+    /// Maximum characters per page (default: 100000)
+    #[serde(default = "default_page_size")]
+    pub page_size: usize,
+}
+
+fn default_page() -> usize {
+    1
+}
+
+fn default_page_size() -> usize {
+    100_000
+}
+
+impl Default for GetMarkdownParams {
+    fn default() -> Self {
+        Self { page: default_page(), page_size: default_page_size() }
+    }
+}
+
+#[derive(Default)]
+pub struct GetMarkdownTool;
+
+impl Tool for GetMarkdownTool {
+    type Params = GetMarkdownParams;
+
+    fn name(&self) -> &str {
+        "get_markdown"
+    }
+
+    fn execute_typed(&self, params: GetMarkdownParams, context: &mut ToolContext) -> Result<ToolResult> {
+        // Wait for network idle with a timeout
+        // Since headless_chrome doesn't have a direct network idle wait,
+        // we add a small delay to let dynamic content load
+        std::thread::sleep(std::time::Duration::from_millis(1000));
+
+        // Inject Readability.js script and the conversion script
+        // Use 'var' instead of 'const' to allow redeclaration on subsequent calls
+        // This prevents "identifier already declared" errors when calling get_markdown multiple times
+        let js_code = format!(
+            "var READABILITY_SCRIPT = {};\n{}",
+            serde_json::to_string(READABILITY_SCRIPT).unwrap(),
+            include_str!("convert_to_markdown.js")
+        );
+
+        // Execute the JavaScript to extract and convert content
+        let result = context
+            .session
+            .tab()?
+            .evaluate(&js_code, false)
+            .map_err(|e| BrowserError::EvaluationFailed(e.to_string()))?;
+
+        // Parse the result
+        let result_value = result.value.ok_or_else(|| {
+            // Capture description if available
+            let description = result
+                .description
+                .map(|d| format!("Description: {}", d))
+                .unwrap_or_else(|| format!("Type: {:?}", result.Type));
+
+            BrowserError::ToolExecutionFailed {
+                tool: "get_markdown".to_string(),
+                reason: format!("No value returned from JavaScript. {}", description),
+            }
+        })?;
+
+        // The JavaScript returns a JSON string, so we need to parse it
+        let extraction_result: ExtractionResult = if let Some(json_str) = result_value.as_str() {
+            serde_json::from_str(json_str).map_err(|e| BrowserError::ToolExecutionFailed {
+                tool: "get_markdown".to_string(),
+                reason: format!("Failed to parse extraction result: {}", e),
+            })?
+        } else {
+            // If it's already an object, try to deserialize directly
+            serde_json::from_value(result_value).map_err(|e| BrowserError::ToolExecutionFailed {
+                tool: "get_markdown".to_string(),
+                reason: format!("Failed to deserialize extraction result: {}", e),
+            })?
+        };
+
+        // Check if Readability failed
+        if extraction_result.readability_failed {
+            return Err(BrowserError::ToolExecutionFailed {
+                tool: "get_markdown".to_string(),
+                reason: extraction_result.error.unwrap_or_else(|| "Readability extraction failed".to_string()),
+            });
+        }
+
+        // Convert the extracted HTML content to Markdown
+        let full_markdown = convert_html_to_markdown(&extraction_result.content);
+
+        // Calculate pagination information
+        let total_pages =
+            if full_markdown.is_empty() { 1 } else { (full_markdown.len() + params.page_size - 1) / params.page_size };
+
+        // Clamp page number to valid range
+        let current_page = params.page.clamp(1, total_pages.max(1));
+
+        // Calculate start and end indices for the requested page
+        let start_idx = (current_page - 1) * params.page_size;
+        let end_idx = (start_idx + params.page_size).min(full_markdown.len());
+
+        // Extract the content for the current page
+        let mut page_content =
+            if start_idx < full_markdown.len() { full_markdown[start_idx..end_idx].to_string() } else { String::new() };
+
+        // Add title to the first page only
+        if current_page == 1 && !extraction_result.title.is_empty() {
+            page_content = format!("# {}\n\n{}", extraction_result.title, page_content);
+        }
+
+        // Add pagination information if there are multiple pages
+        if total_pages > 1 {
+            let pagination_info = if current_page < total_pages {
+                format!(
+                    "\n\n---\n\n*Page {} of {}. There are {} more page(s) with additional content.*\n",
+                    current_page,
+                    total_pages,
+                    total_pages - current_page
+                )
+            } else {
+                format!("\n\n---\n\n*Page {} of {}. This is the last page.*\n", current_page, total_pages)
+            };
+            page_content.push_str(&pagination_info);
+        }
+
+        // Return the result with pagination metadata
+        Ok(ToolResult::success_with(serde_json::json!({
+            "markdown": page_content,
+            "title": extraction_result.title,
+            "url": extraction_result.url,
+            "currentPage": current_page,
+            "totalPages": total_pages,
+            "hasMorePages": current_page < total_pages,
+            "length": page_content.len(),
+            "byline": extraction_result.byline,
+            "excerpt": extraction_result.excerpt,
+            "siteName": extraction_result.site_name,
+        })))
+    }
+}
+
+/// Structure for extraction result returned from JavaScript
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct ExtractionResult {
+    title: String,
+    content: String,
+    text_content: String,
+    url: String,
+    #[serde(default)]
+    excerpt: String,
+    #[serde(default)]
+    byline: String,
+    #[serde(default)]
+    site_name: String,
+    #[serde(default)]
+    length: usize,
+    #[serde(default)]
+    lang: String,
+    #[serde(default)]
+    dir: String,
+    #[serde(default)]
+    published_time: String,
+    #[serde(default)]
+    readability_failed: bool,
+    #[serde(default)]
+    error: Option<String>,
+}

package/skills/fast-browser-use/src/tools/mod.rs

@@ -0,0 +1,326 @@
+//! Browser automation tools module
+//!
+//! This module provides a framework for browser automation tools and
+//! includes implementations of common browser operations.
+
+pub mod click;
+pub mod close;
+pub mod close_tab;
+pub mod cookies;
+pub mod debug;
+pub mod evaluate;
+pub mod extract;
+pub mod go_back;
+pub mod go_forward;
+pub mod hover;
+pub mod html_to_markdown;
+pub mod input;
+pub mod local_storage;
+pub mod markdown;
+pub mod navigate;
+pub mod new_tab;
+pub mod press_key;
+pub mod read_links;
+pub mod readability_script;
+pub mod screenshot;
+pub mod scroll;
+pub mod select;
+pub mod sitemap;
+pub mod snapshot;
+pub mod switch_tab;
+pub mod tab_list;
+pub mod annotate;
+mod utils;
+pub mod wait;
+
+// Re-export Params types for use by MCP layer
+pub use click::ClickParams;
+pub use close::CloseParams;
+pub use close_tab::CloseTabParams;
+pub use cookies::{GetCookiesParams, SetCookiesParams};
+pub use debug::{GetConsoleLogsParams, GetNetworkErrorsParams};
+pub use evaluate::EvaluateParams;
+pub use extract::ExtractParams;
+pub use go_back::GoBackParams;
+pub use go_forward::GoForwardParams;
+pub use hover::HoverParams;
+pub use input::InputParams;
+pub use local_storage::{
+    ClearLocalStorageParams, GetLocalStorageParams, RemoveLocalStorageParams, SetLocalStorageParams,
+};
+pub use markdown::GetMarkdownParams;
+pub use navigate::NavigateParams;
+pub use new_tab::NewTabParams;
+pub use press_key::PressKeyParams;
+pub use read_links::ReadLinksParams;
+pub use screenshot::ScreenshotParams;
+pub use scroll::ScrollParams;
+pub use select::SelectParams;
+pub use sitemap::{SitemapParams, SitemapResult, PageStructure, Heading, NavLink, Section, MainContent, Meta};
+pub use snapshot::SnapshotParams;
+pub use switch_tab::SwitchTabParams;
+pub use tab_list::TabListParams;
+pub use annotate::AnnotateParams;
+pub use wait::WaitParams;
+
+use crate::{browser::BrowserSession, dom::DomTree, error::Result};
+use serde_json::Value;
+use std::{collections::HashMap, sync::Arc};
+
+/// Tool execution context
+pub struct ToolContext<'a> {
+    /// Browser session
+    pub session: &'a BrowserSession,
+
+    /// Optional DOM tree (extracted on demand)
+    pub dom_tree: Option<DomTree>,
+}
+
+impl<'a> ToolContext<'a> {
+    /// Create a new tool context
+    pub fn new(session: &'a BrowserSession) -> Self {
+        Self { session, dom_tree: None }
+    }
+
+    /// Create a context with a pre-extracted DOM tree
+    pub fn with_dom(session: &'a BrowserSession, dom_tree: DomTree) -> Self {
+        Self { session, dom_tree: Some(dom_tree) }
+    }
+
+    /// Get or extract the DOM tree
+    pub fn get_dom(&mut self) -> Result<&DomTree> {
+        if self.dom_tree.is_none() {
+            self.dom_tree = Some(self.session.extract_dom()?);
+        }
+        Ok(self.dom_tree.as_ref().unwrap())
+    }
+}
+
+/// Result of tool execution
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct ToolResult {
+    /// Whether the tool execution was successful
+    pub success: bool,
+
+    /// Result data (JSON value)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub data: Option<Value>,
+
+    /// Error message if execution failed
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error: Option<String>,
+
+    /// Additional metadata
+    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
+    pub metadata: HashMap<String, Value>,
+}
+
+impl ToolResult {
+    /// Create a successful result
+    pub fn success(data: Option<Value>) -> Self {
+        Self { success: true, data, error: None, metadata: HashMap::new() }
+    }
+
+    /// Create a successful result with data
+    pub fn success_with<T: serde::Serialize>(data: T) -> Self {
+        Self { success: true, data: serde_json::to_value(data).ok(), error: None, metadata: HashMap::new() }
+    }
+
+    /// Create a failure result
+    pub fn failure(error: impl Into<String>) -> Self {
+        Self { success: false, data: None, error: Some(error.into()), metadata: HashMap::new() }
+    }
+
+    /// Add metadata to the result
+    pub fn with_metadata(mut self, key: impl Into<String>, value: Value) -> Self {
+        self.metadata.insert(key.into(), value);
+        self
+    }
+}
+
+/// Trait for browser automation tools with associated parameter types
+pub trait Tool: Send + Sync + Default {
+    /// Associated parameter type for this tool
+    type Params: serde::Serialize + for<'de> serde::Deserialize<'de> + schemars::JsonSchema;
+
+    /// Get tool name
+    fn name(&self) -> &str;
+
+    /// Get tool parameter schema (JSON Schema)
+    fn parameters_schema(&self) -> Value {
+        serde_json::to_value(schemars::schema_for!(Self::Params)).unwrap_or_default()
+    }
+
+    /// Execute the tool with strongly-typed parameters
+    fn execute_typed(&self, params: Self::Params, context: &mut ToolContext) -> Result<ToolResult>;
+
+    /// Execute the tool with JSON parameters (default implementation)
+    fn execute(&self, params: Value, context: &mut ToolContext) -> Result<ToolResult> {
+        let typed_params: Self::Params = serde_json::from_value(params)
+            .map_err(|e| crate::error::BrowserError::InvalidArgument(format!("Invalid parameters: {}", e)))?;
+        self.execute_typed(typed_params, context)
+    }
+}
+
+/// Type-erased tool trait for dynamic dispatch
+pub trait DynTool: Send + Sync {
+    fn name(&self) -> &str;
+    fn parameters_schema(&self) -> Value;
+    fn execute(&self, params: Value, context: &mut ToolContext) -> Result<ToolResult>;
+}
+
+/// Blanket implementation to convert any Tool into DynTool
+impl<T: Tool> DynTool for T {
+    fn name(&self) -> &str {
+        Tool::name(self)
+    }
+
+    fn parameters_schema(&self) -> Value {
+        Tool::parameters_schema(self)
+    }
+
+    fn execute(&self, params: Value, context: &mut ToolContext) -> Result<ToolResult> {
+        Tool::execute(self, params, context)
+    }
+}
+
+/// Tool registry for managing and accessing tools
+pub struct ToolRegistry {
+    tools: HashMap<String, Arc<dyn DynTool>>,
+}
+
+impl ToolRegistry {
+    /// Create a new empty tool registry
+    pub fn new() -> Self {
+        Self { tools: HashMap::new() }
+    }
+
+    /// Create a registry with default tools
+    pub fn with_defaults() -> Self {
+        let mut registry = Self::new();
+
+        // Register navigation tools
+        registry.register(navigate::NavigateTool);
+        registry.register(go_back::GoBackTool);
+        registry.register(go_forward::GoForwardTool);
+        registry.register(wait::WaitTool);
+
+        // Register interaction tools
+        registry.register(click::ClickTool);
+        registry.register(input::InputTool);
+        registry.register(select::SelectTool);
+        registry.register(hover::HoverTool);
+        registry.register(press_key::PressKeyTool);
+        registry.register(scroll::ScrollTool);
+
+        // Register tab management tools
+        registry.register(new_tab::NewTabTool);
+        registry.register(tab_list::TabListTool);
+        registry.register(switch_tab::SwitchTabTool);
+        registry.register(close_tab::CloseTabTool);
+
+        // Register reading and extraction tools
+        registry.register(extract::ExtractContentTool);
+        registry.register(markdown::GetMarkdownTool);
+        registry.register(read_links::ReadLinksTool);
+        registry.register(snapshot::SnapshotTool);
+
+        // Register utility tools
+        registry.register(screenshot::ScreenshotTool);
+        registry.register(annotate::AnnotateTool);
+        registry.register(evaluate::EvaluateTool);
+        registry.register(close::CloseTool);
+        
+        // Register cookie tools
+        registry.register(cookies::GetCookiesTool);
+        registry.register(cookies::SetCookiesTool);
+
+        // Register debug tools
+        registry.register(debug::GetConsoleLogsTool);
+        registry.register(debug::GetNetworkErrorsTool);
+        
+        // Register local storage tools
+        registry.register(local_storage::GetLocalStorageTool);
+        registry.register(local_storage::SetLocalStorageTool);
+        registry.register(local_storage::RemoveLocalStorageTool);
+        registry.register(local_storage::ClearLocalStorageTool);
+
+        // Register sitemap tool
+        registry.register(sitemap::SitemapTool);
+
+        registry
+    }
+
+    /// Register a tool
+    pub fn register<T: Tool + 'static>(&mut self, tool: T) {
+        let name = tool.name().to_string();
+        self.tools.insert(name, Arc::new(tool));
+    }
+
+    /// Get a tool by name
+    pub fn get(&self, name: &str) -> Option<&Arc<dyn DynTool>> {
+        self.tools.get(name)
+    }
+
+    /// Check if a tool exists
+    pub fn has(&self, name: &str) -> bool {
+        self.tools.contains_key(name)
+    }
+
+    /// List all tool names
+    pub fn list_names(&self) -> Vec<String> {
+        self.tools.keys().cloned().collect()
+    }
+
+    /// Get all tools
+    pub fn all_tools(&self) -> Vec<Arc<dyn DynTool>> {
+        self.tools.values().cloned().collect()
+    }
+
+    /// Execute a tool by name
+    pub fn execute(&self, name: &str, params: Value, context: &mut ToolContext) -> Result<ToolResult> {
+        match self.get(name) {
+            Some(tool) => tool.execute(params, context),
+            None => Ok(ToolResult::failure(format!("Tool '{}' not found", name))),
+        }
+    }
+
+    /// Get the number of registered tools
+    pub fn count(&self) -> usize {
+        self.tools.len()
+    }
+}
+
+impl Default for ToolRegistry {
+    fn default() -> Self {
+        Self::with_defaults()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_tool_result_success() {
+        let result = ToolResult::success(Some(serde_json::json!({"url": "https://example.com"})));
+        assert!(result.success);
+        assert!(result.data.is_some());
+        assert!(result.error.is_none());
+    }
+
+    #[test]
+    fn test_tool_result_failure() {
+        let result = ToolResult::failure("Test error");
+        assert!(!result.success);
+        assert!(result.data.is_none());
+        assert_eq!(result.error, Some("Test error".to_string()));
+    }
+
+    #[test]
+    fn test_tool_result_with_metadata() {
+        let result = ToolResult::success(None).with_metadata("duration_ms", serde_json::json!(100));
+
+        assert!(result.metadata.contains_key("duration_ms"));
+    }
+}

package/skills/fast-browser-use/src/tools/navigate.rs

@@ -0,0 +1,55 @@
+use crate::{error::Result,
+            tools::{Tool, ToolContext, ToolResult,
+                    snapshot::{RenderMode, render_aria_tree},
+                    utils::normalize_url}};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Parameters for the navigate tool
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct NavigateParams {
+    /// URL to navigate to
+    pub url: String,
+
+    /// Wait for navigation to complete (default: true)
+    #[serde(default = "default_wait")]
+    pub wait_for_load: bool,
+}
+
+fn default_wait() -> bool {
+    true
+}
+
+/// Tool for navigating to a URL
+#[derive(Default)]
+pub struct NavigateTool;
+
+impl Tool for NavigateTool {
+    type Params = NavigateParams;
+
+    fn name(&self) -> &str {
+        "navigate"
+    }
+
+    fn execute_typed(&self, params: NavigateParams, context: &mut ToolContext) -> Result<ToolResult> {
+        // Normalize the URL
+        let normalized_url = normalize_url(&params.url);
+
+        // Navigate to normalized URL
+        context.session.navigate(&normalized_url)?;
+
+        // Wait for navigation if requested
+        if params.wait_for_load {
+            context.session.wait_for_navigation()?;
+        }
+
+        let snapshot = {
+            let dom = context.get_dom()?;
+            render_aria_tree(&dom.root, RenderMode::Ai, None)
+        };
+
+        Ok(ToolResult::success_with(serde_json::json!({
+            "snapshot": snapshot
+        })))
+    }
+}

package/skills/fast-browser-use/src/tools/new_tab.rs

@@ -0,0 +1,60 @@
+use crate::{error::Result,
+            tools::{Tool, ToolContext, ToolResult,
+                    snapshot::{RenderMode, render_aria_tree},
+                    utils::normalize_url}};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Parameters for the new_tab tool
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct NewTabParams {
+    /// URL to open in the new tab
+    pub url: String,
+}
+
+/// Tool for opening a new tab
+#[derive(Default)]
+pub struct NewTabTool;
+
+impl Tool for NewTabTool {
+    type Params = NewTabParams;
+
+    fn name(&self) -> &str {
+        "new_tab"
+    }
+
+    fn execute_typed(&self, params: NewTabParams, context: &mut ToolContext) -> Result<ToolResult> {
+        let normalized_url = normalize_url(&params.url);
+        let tab = context
+            .session
+            .browser()
+            .new_tab()
+            .map_err(|e| crate::error::BrowserError::TabOperationFailed(format!("Failed to create tab: {}", e)))?;
+
+        // Navigate to the normalized URL
+        tab.navigate_to(&normalized_url).map_err(|e| {
+            crate::error::BrowserError::NavigationFailed(format!("Failed to navigate to {}: {}", normalized_url, e))
+        })?;
+
+        // Wait for navigation to complete
+        tab.wait_until_navigated().map_err(|e| {
+            crate::error::BrowserError::NavigationFailed(format!(
+                "Navigation to {} did not complete: {}",
+                normalized_url, e
+            ))
+        })?;
+
+        // Bring the new tab to front
+        tab.activate()
+            .map_err(|e| crate::error::BrowserError::TabOperationFailed(format!("Failed to activate tab: {}", e)))?;
+
+        let snapshot = {
+            let dom = context.get_dom()?;
+            render_aria_tree(&dom.root, RenderMode::Ai, None)
+        };
+
+        Ok(ToolResult::success_with(serde_json::json!({
+            "snapshot": snapshot
+        })))
+    }
+}

package/skills/fast-browser-use/src/tools/press_key.rs

@@ -0,0 +1,78 @@
+use crate::{error::{BrowserError, Result},
+            tools::{Tool, ToolContext, ToolResult}};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Parameters for the press_key tool
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct PressKeyParams {
+    /// Name of the key to press (e.g., "Enter", "Tab", "Escape", "ArrowDown", "F1", etc.)
+    pub key: String,
+}
+
+/// Tool for pressing keyboard keys
+#[derive(Default)]
+pub struct PressKeyTool;
+
+impl Tool for PressKeyTool {
+    type Params = PressKeyParams;
+
+    fn name(&self) -> &str {
+        "press_key"
+    }
+
+    fn execute_typed(&self, params: PressKeyParams, context: &mut ToolContext) -> Result<ToolResult> {
+        context
+            .session
+            .tab()?
+            .press_key(&params.key)
+            .map_err(|e| BrowserError::ToolExecutionFailed { tool: "press_key".to_string(), reason: e.to_string() })?;
+
+        Ok(ToolResult::success_with(serde_json::json!({
+            "key": params.key
+        })))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_press_key_tool_metadata() {
+        let tool = PressKeyTool;
+        assert_eq!(tool.name(), "press_key");
+        let schema = tool.parameters_schema();
+        assert!(schema.is_object());
+    }
+
+    #[test]
+    fn test_press_key_params_various_keys() {
+        let test_keys = vec![
+            "Enter",
+            "Tab",
+            "Escape",
+            "Backspace",
+            "Delete",
+            "ArrowLeft",
+            "ArrowRight",
+            "ArrowUp",
+            "ArrowDown",
+            "Home",
+            "End",
+            "PageUp",
+            "PageDown",
+            "F1",
+            "F12",
+            "ShiftLeft",
+            "MetaLeft",
+            "Space",
+        ];
+
+        for key in test_keys {
+            let json = serde_json::json!({ "key": key });
+            let params: PressKeyParams = serde_json::from_value(json).unwrap();
+            assert_eq!(params.key, key);
+        }
+    }
+}