openclaw-node-harness 2.0.0

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

@@ -0,0 +1,324 @@
+use crate::{dom::{AriaChild, AriaNode, yaml_escape_key_if_needed, yaml_escape_value_if_needed},
+            error::Result,
+            tools::{Tool, ToolContext, ToolResult}};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Parameters for the snapshot tool
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, Default)]
+pub struct SnapshotParams {
+    /// Whether to include full snapshot or incremental
+    #[serde(default)]
+    pub incremental: bool,
+}
+
+/// Tool for getting an ARIA snapshot of the page in YAML format
+#[derive(Default)]
+pub struct SnapshotTool;
+
+impl Tool for SnapshotTool {
+    type Params = SnapshotParams;
+
+    fn name(&self) -> &str {
+        "snapshot"
+    }
+
+    fn execute_typed(&self, params: SnapshotParams, context: &mut ToolContext) -> Result<ToolResult> {
+        // Get or extract the DOM tree
+        let dom = context.get_dom()?;
+
+        // Generate YAML snapshot
+        let yaml_snapshot = render_aria_tree(&dom.root, RenderMode::Ai, None);
+
+        // Count interactive elements
+        let interactive_count = dom.count_interactive();
+
+        let result = if params.incremental {
+            // TODO: Implement incremental snapshots
+            serde_json::json!({
+                "full": yaml_snapshot,
+                "interactive_count": interactive_count,
+            })
+        } else {
+            serde_json::json!({
+                "snapshot": yaml_snapshot,
+                "interactive_count": interactive_count,
+            })
+        };
+
+        Ok(ToolResult::success_with(result))
+    }
+}
+
+/// Rendering mode for ARIA tree
+#[derive(Debug, Clone, Copy)]
+pub enum RenderMode {
+    /// AI consumption mode (includes refs, cursor, active markers)
+    Ai,
+    /// Expect mode (for testing)
+    Expect,
+}
+
+/// Render an ARIA tree to YAML format
+/// Based on Playwright's renderAriaTree function
+pub fn render_aria_tree(root: &AriaNode, mode: RenderMode, previous: Option<&AriaNode>) -> String {
+    let mut lines = Vec::new();
+
+    let render_cursor_pointer = matches!(mode, RenderMode::Ai);
+    let render_active = matches!(mode, RenderMode::Ai);
+
+    // Do not render the root fragment, just its children
+    let nodes_to_render = if root.role == "fragment" {
+        &root.children
+    } else {
+        // Single root node case - wrap it
+        return render_single_node(root, mode, previous);
+    };
+
+    for node in nodes_to_render {
+        match node {
+            AriaChild::Text(text) => {
+                visit_text(text, "", &mut lines);
+            }
+            AriaChild::Node(node) => {
+                visit(node, "", render_cursor_pointer, render_active, &mut lines, previous);
+            }
+        }
+    }
+
+    lines.join("\n")
+}
+
+fn render_single_node(root: &AriaNode, mode: RenderMode, previous: Option<&AriaNode>) -> String {
+    let mut lines = Vec::new();
+    let render_cursor_pointer = matches!(mode, RenderMode::Ai);
+    let render_active = matches!(mode, RenderMode::Ai);
+
+    visit(root, "", render_cursor_pointer, render_active, &mut lines, previous);
+
+    lines.join("\n")
+}
+
+fn visit_text(text: &str, indent: &str, lines: &mut Vec<String>) {
+    let escaped = yaml_escape_value_if_needed(text);
+    if !escaped.is_empty() {
+        lines.push(format!("{}- text: {}", indent, escaped));
+    }
+}
+
+fn visit(
+    aria_node: &AriaNode,
+    indent: &str,
+    render_cursor_pointer: bool,
+    render_active: bool,
+    lines: &mut Vec<String>,
+    _previous: Option<&AriaNode>,
+) {
+    // Create the key (role + name + attributes)
+    let key = create_key(aria_node, render_cursor_pointer, render_active);
+    let escaped_key = format!("{}- {}", indent, yaml_escape_key_if_needed(&key));
+
+    // Get single inlined text child if applicable
+    let single_text_child = get_single_inlined_text_child(aria_node);
+
+    if aria_node.children.is_empty() && aria_node.props.is_empty() {
+        // Leaf node without children or props
+        lines.push(escaped_key);
+    } else if let Some(text) = single_text_child {
+        // Leaf node with just text inside
+        lines.push(format!("{}: {}", escaped_key, yaml_escape_value_if_needed(&text)));
+    } else {
+        // Node with props and/or children
+        lines.push(format!("{}:", escaped_key));
+
+        // Render props
+        for (name, value) in &aria_node.props {
+            lines.push(format!("{}  - /{}: {}", indent, name, yaml_escape_value_if_needed(value)));
+        }
+
+        // Render children
+        let child_indent = format!("{}  ", indent);
+        let in_cursor_pointer = aria_node.index.is_some() && render_cursor_pointer && aria_node.has_pointer_cursor();
+
+        for child in &aria_node.children {
+            match child {
+                AriaChild::Text(text) => {
+                    visit_text(text, &child_indent, lines);
+                }
+                AriaChild::Node(child_node) => {
+                    visit(
+                        child_node,
+                        &child_indent,
+                        render_cursor_pointer && !in_cursor_pointer,
+                        render_active,
+                        lines,
+                        None,
+                    );
+                }
+            }
+        }
+    }
+}
+
+fn create_key(aria_node: &AriaNode, render_cursor_pointer: bool, render_active: bool) -> String {
+    let mut key = aria_node.role.clone();
+
+    // Add name if present and not too long
+    if !aria_node.name.is_empty() && aria_node.name.len() <= 900 {
+        // YAML has a limit of 1024 characters per key
+        let name = &aria_node.name;
+        // Simple stringification (no regex handling for now)
+        key.push(' ');
+        key.push_str(&format!("{:?}", name)); // JSON-style quoting
+    }
+
+    // Add ARIA state attributes
+    if let Some(checked) = &aria_node.checked {
+        match checked {
+            crate::dom::element::AriaChecked::Bool(true) => key.push_str(" [checked]"),
+            crate::dom::element::AriaChecked::Bool(false) => {}
+            crate::dom::element::AriaChecked::Mixed(_) => key.push_str(" [checked=mixed]"),
+        }
+    }
+
+    if aria_node.disabled == Some(true) {
+        key.push_str(" [disabled]");
+    }
+
+    if aria_node.expanded == Some(true) {
+        key.push_str(" [expanded]");
+    }
+
+    if render_active && aria_node.active == Some(true) {
+        key.push_str(" [active]");
+    }
+
+    if let Some(level) = aria_node.level {
+        key.push_str(&format!(" [level={}]", level));
+    }
+
+    if let Some(pressed) = &aria_node.pressed {
+        match pressed {
+            crate::dom::element::AriaPressed::Bool(true) => key.push_str(" [pressed]"),
+            crate::dom::element::AriaPressed::Bool(false) => {}
+            crate::dom::element::AriaPressed::Mixed(_) => key.push_str(" [pressed=mixed]"),
+        }
+    }
+
+    if aria_node.selected == Some(true) {
+        key.push_str(" [selected]");
+    }
+
+    // Add index attribute
+    if let Some(index) = aria_node.index {
+        key.push_str(&format!(" [index={}]", index));
+
+        if render_cursor_pointer && aria_node.has_pointer_cursor() {
+            key.push_str(" [cursor=pointer]");
+        }
+    }
+
+    key
+}
+
+fn get_single_inlined_text_child(aria_node: &AriaNode) -> Option<String> {
+    if aria_node.children.len() == 1 && aria_node.props.is_empty() {
+        if let AriaChild::Text(text) = &aria_node.children[0] {
+            return Some(text.clone());
+        }
+    }
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_render_simple_tree() {
+        let mut root = AriaNode::fragment();
+        root.children.push(AriaChild::Node(Box::new(
+            AriaNode::new("button", "Click me").with_index(0).with_box(true, Some("pointer".to_string())),
+        )));
+
+        let yaml = render_aria_tree(&root, RenderMode::Ai, None);
+        assert!(yaml.contains("button"));
+        assert!(yaml.contains("Click me"));
+        assert!(yaml.contains("[index=0]"));
+        assert!(yaml.contains("[cursor=pointer]"));
+    }
+
+    #[test]
+    fn test_render_tree_with_text() {
+        let mut root = AriaNode::fragment();
+        root.children.push(AriaChild::Text("Hello world".to_string()));
+
+        let yaml = render_aria_tree(&root, RenderMode::Ai, None);
+        eprintln!("YAML output:\n{}", yaml);
+        assert!(yaml.contains("text:"));
+        assert!(yaml.contains("Hello world"));
+    }
+
+    #[test]
+    fn test_render_nested_tree() {
+        let mut root = AriaNode::fragment();
+        let mut div = AriaNode::new("generic", "");
+        div.children.push(AriaChild::Text("Parent text".to_string()));
+        div.children.push(AriaChild::Node(Box::new(AriaNode::new("button", "Child button").with_index(0))));
+
+        root.children.push(AriaChild::Node(Box::new(div)));
+
+        let yaml = render_aria_tree(&root, RenderMode::Ai, None);
+        assert!(yaml.contains("generic"));
+        assert!(yaml.contains("Parent text"));
+        assert!(yaml.contains("button"));
+        assert!(yaml.contains("Child button"));
+    }
+
+    #[test]
+    fn test_render_with_props() {
+        let mut root = AriaNode::fragment();
+        root.children.push(AriaChild::Node(Box::new(
+            AriaNode::new("link", "Go to page").with_index(0).with_prop("url", "https://example.com"),
+        )));
+
+        let yaml = render_aria_tree(&root, RenderMode::Ai, None);
+        eprintln!("YAML output:\n{}", yaml);
+        assert!(yaml.contains("link"));
+        assert!(yaml.contains("[index=0]"));
+        assert!(yaml.contains("/url:"));
+        assert!(yaml.contains("https://example.com"));
+    }
+
+    #[test]
+    fn test_render_with_aria_states() {
+        let mut root = AriaNode::fragment();
+        root.children.push(AriaChild::Node(Box::new(
+            AriaNode::new("checkbox", "Accept terms").with_index(0).with_checked(true).with_disabled(false),
+        )));
+
+        let yaml = render_aria_tree(&root, RenderMode::Ai, None);
+        assert!(yaml.contains("checkbox"));
+        assert!(yaml.contains("[checked]"));
+        // disabled=false should not appear
+        assert!(!yaml.contains("[disabled]"));
+    }
+
+    #[test]
+    fn test_render_heading_with_level() {
+        let mut root = AriaNode::fragment();
+        root.children.push(AriaChild::Node(Box::new(AriaNode::new("heading", "Page Title").with_level(1))));
+
+        let yaml = render_aria_tree(&root, RenderMode::Ai, None);
+        assert!(yaml.contains("heading"));
+        assert!(yaml.contains("Page Title"));
+        assert!(yaml.contains("[level=1]"));
+    }
+
+    #[test]
+    fn test_empty_snapshot() {
+        let root = AriaNode::fragment();
+        let yaml = render_aria_tree(&root, RenderMode::Ai, None);
+        assert_eq!(yaml.trim(), "");
+    }
+}

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

@@ -0,0 +1,69 @@
+use crate::{error::Result,
+            tools::{Tool, ToolContext, ToolResult}};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Parameters for the switch_tab tool
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct SwitchTabParams {
+    /// Tab index to switch to
+    pub index: usize,
+}
+
+/// Tool for switching to a specific tab
+#[derive(Default)]
+pub struct SwitchTabTool;
+
+impl Tool for SwitchTabTool {
+    type Params = SwitchTabParams;
+
+    fn name(&self) -> &str {
+        "switch_tab"
+    }
+
+    fn execute_typed(&self, params: SwitchTabParams, context: &mut ToolContext) -> Result<ToolResult> {
+        // Get all tabs to validate index
+        let tabs = context.session.get_tabs()?;
+
+        if params.index >= tabs.len() {
+            return Ok(ToolResult::failure(format!(
+                "Invalid tab index: {}. Valid range: 0-{}",
+                params.index,
+                tabs.len() - 1
+            )));
+        }
+
+        // Note: We can't directly call session.switch_tab() because we only have &BrowserSession
+        // Instead, we'll need to work with the browser directly
+        // However, since this requires mutable access to the session, we need to handle this differently
+
+        // Get the tab at the specified index
+        let target_tab = tabs[params.index].clone();
+
+        // Activate the tab
+        target_tab.activate().map_err(|e| {
+            crate::error::BrowserError::TabOperationFailed(format!("Failed to activate tab {}: {}", params.index, e))
+        })?;
+
+        // Get updated tab info
+        let title = target_tab.get_title().unwrap_or_default();
+        let url = target_tab.get_url();
+
+        // Build tab list summary
+        let mut tab_list_str = String::new();
+        for (idx, tab) in tabs.iter().enumerate() {
+            let tab_title = tab.get_title().unwrap_or_default();
+            let tab_url = tab.get_url();
+            tab_list_str.push_str(&format!("[{}] {} ({})\n", idx, tab_title, tab_url));
+        }
+
+        let summary = format!("Switched to tab {}\nAll Tabs:\n{}", params.index, tab_list_str);
+
+        Ok(ToolResult::success_with(serde_json::json!({
+            "index": params.index,
+            "title": title,
+            "url": url,
+            "message": summary
+        })))
+    }
+}

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

@@ -0,0 +1,76 @@
+use crate::{error::Result,
+            tools::{Tool, ToolContext, ToolResult}};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+/// Information about a browser tab
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct TabInfo {
+    /// Tab index
+    pub index: usize,
+    /// Whether this is the active tab
+    pub active: bool,
+    /// Tab title
+    pub title: String,
+    /// Tab URL
+    pub url: String,
+}
+
+/// Parameters for the tab_list tool (no parameters needed)
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct TabListParams {}
+
+/// Tool for listing all browser tabs
+#[derive(Default)]
+pub struct TabListTool;
+
+impl Tool for TabListTool {
+    type Params = TabListParams;
+
+    fn name(&self) -> &str {
+        "tab_list"
+    }
+
+    fn execute_typed(&self, _params: TabListParams, context: &mut ToolContext) -> Result<ToolResult> {
+        // Get all tabs
+        let tabs = context.session.get_tabs()?;
+        let active_tab = context.session.tab()?;
+
+        // Build tab info list
+        let mut tab_list = Vec::new();
+        for (index, tab) in tabs.iter().enumerate() {
+            // Check if this is the active tab by comparing Arc pointers
+            let is_active = std::sync::Arc::ptr_eq(tab, &active_tab);
+
+            // Get tab title (fallback to empty string on error)
+            let title = tab.get_title().unwrap_or_default();
+
+            // Get tab URL (not a Result, returns String directly)
+            let url = tab.get_url();
+
+            tab_list.push(TabInfo { index, active: is_active, title, url });
+        }
+
+        // Build summary text
+        let active_index = tab_list.iter().position(|t| t.active).unwrap_or(0);
+        let active_info = &tab_list[active_index];
+
+        let summary = if !tab_list.is_empty() {
+            let all_tabs_str = tab_list
+                .iter()
+                .map(|tab| format!("[{}] Title: {} (URL: {})", tab.index, tab.title, tab.url))
+                .collect::<Vec<_>>()
+                .join("\n");
+
+            format!("Current Tab: [{}] {}\nAll Tabs:\n{}", active_index, active_info.title, all_tabs_str)
+        } else {
+            "No tabs available".to_string()
+        };
+
+        Ok(ToolResult::success_with(serde_json::json!({
+            "tab_list": tab_list,
+            "count": tab_list.len(),
+            "summary": summary
+        })))
+    }
+}

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

@@ -0,0 +1,92 @@
+/// Normalize an incomplete URL by adding missing protocol and handling common patterns
+pub fn normalize_url(url: &str) -> String {
+    let trimmed = url.trim();
+
+    // If already has a protocol, return as-is
+    if trimmed.starts_with("http://")
+        || trimmed.starts_with("https://")
+        || trimmed.starts_with("file://")
+        || trimmed.starts_with("data:")
+        || trimmed.starts_with("about:")
+        || trimmed.starts_with("chrome://")
+        || trimmed.starts_with("chrome-extension://")
+    {
+        return trimmed.to_string();
+    }
+
+    // Relative path - return as-is
+    if trimmed.starts_with('/') || trimmed.starts_with("./") || trimmed.starts_with("../") {
+        return trimmed.to_string();
+    }
+
+    // localhost special case - use http by default
+    if trimmed.starts_with("localhost") || trimmed.starts_with("127.0.0.1") {
+        return format!("http://{}", trimmed);
+    }
+
+    // Check if it looks like a domain (contains dot or is a known TLD)
+    if trimmed.contains('.') {
+        // Looks like a domain - add https://
+        return format!("https://{}", trimmed);
+    }
+
+    // Single word - assume it's a domain name, add www. prefix and https://
+    // This handles cases like "google" -> "https://www.google.com"
+    format!("https://www.{}.com", trimmed)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_normalize_url_complete() {
+        assert_eq!(normalize_url("https://example.com"), "https://example.com");
+        assert_eq!(normalize_url("http://example.com"), "http://example.com");
+        assert_eq!(normalize_url("https://example.com/path"), "https://example.com/path");
+    }
+
+    #[test]
+    fn test_normalize_url_missing_protocol() {
+        assert_eq!(normalize_url("example.com"), "https://example.com");
+        assert_eq!(normalize_url("example.com/path"), "https://example.com/path");
+        assert_eq!(normalize_url("sub.example.com"), "https://sub.example.com");
+    }
+
+    #[test]
+    fn test_normalize_url_partial_domain() {
+        assert_eq!(normalize_url("google"), "https://www.google.com");
+        assert_eq!(normalize_url("github"), "https://www.github.com");
+        assert_eq!(normalize_url("amazon"), "https://www.amazon.com");
+    }
+
+    #[test]
+    fn test_normalize_url_localhost() {
+        assert_eq!(normalize_url("localhost"), "http://localhost");
+        assert_eq!(normalize_url("localhost:3000"), "http://localhost:3000");
+        assert_eq!(normalize_url("127.0.0.1"), "http://127.0.0.1");
+        assert_eq!(normalize_url("127.0.0.1:8080"), "http://127.0.0.1:8080");
+    }
+
+    #[test]
+    fn test_normalize_url_special_protocols() {
+        assert_eq!(normalize_url("about:blank"), "about:blank");
+        assert_eq!(normalize_url("file:///path/to/file"), "file:///path/to/file");
+        assert_eq!(normalize_url("data:text/html,<h1>Test</h1>"), "data:text/html,<h1>Test</h1>");
+        assert_eq!(normalize_url("chrome://settings"), "chrome://settings");
+    }
+
+    #[test]
+    fn test_normalize_url_relative_paths() {
+        assert_eq!(normalize_url("/path"), "/path");
+        assert_eq!(normalize_url("/path/to/page"), "/path/to/page");
+        assert_eq!(normalize_url("./relative"), "./relative");
+        assert_eq!(normalize_url("../parent"), "../parent");
+    }
+
+    #[test]
+    fn test_normalize_url_whitespace() {
+        assert_eq!(normalize_url("  example.com  "), "https://example.com");
+        assert_eq!(normalize_url("  https://example.com  "), "https://example.com");
+    }
+}

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

@@ -0,0 +1,53 @@
+use crate::{error::{BrowserError, Result},
+            tools::{Tool, ToolContext, ToolResult}};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use std::time::Duration;
+
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+pub struct WaitParams {
+    /// CSS selector to wait for
+    pub selector: String,
+
+    /// Timeout in milliseconds (default: 30000)
+    #[serde(default = "default_timeout")]
+    pub timeout_ms: u64,
+}
+
+fn default_timeout() -> u64 {
+    30000
+}
+
+#[derive(Default)]
+pub struct WaitTool;
+
+impl Tool for WaitTool {
+    type Params = WaitParams;
+
+    fn name(&self) -> &str {
+        "wait"
+    }
+
+    fn execute_typed(&self, params: WaitParams, context: &mut ToolContext) -> Result<ToolResult> {
+        let start = std::time::Instant::now();
+
+        context
+            .session
+            .tab()?
+            .wait_for_element_with_custom_timeout(&params.selector, Duration::from_millis(params.timeout_ms))
+            .map_err(|e| {
+                BrowserError::Timeout(format!(
+                    "Element '{}' not found within {} ms: {}",
+                    params.selector, params.timeout_ms, e
+                ))
+            })?;
+
+        let elapsed = start.elapsed().as_millis() as u64;
+
+        Ok(ToolResult::success_with(serde_json::json!({
+            "selector": params.selector,
+            "found": true,
+            "elapsed_ms": elapsed
+        })))
+    }
+}

package/skills/fast-browser-use/test_auth.json

@@ -0,0 +1,3 @@
+{
+  "cookies": []
+}

package/skills/fast-browser-use/test_state.json

@@ -0,0 +1,6 @@
+- generic [index=1]:
+  - heading [level=1] [index=2]: Example Domain
+  - paragraph: This domain is for use in documentation examples without needing permission. Avoid use in operations.
+  - paragraph:
+    - 'link "Learn more" [index=3] [cursor=pointer]':
+      - /url: https://iana.org/domains/example