vibesurf 0.1.21__py3-none-any.whl → 0.2.6__py3-none-any.whl

vibe_surf/workflows/Browser/browser_upload_file.py

@@ -0,0 +1,178 @@
+import asyncio
+from typing import Any, List
+from uuid import uuid4
+from browser_use.llm.base import BaseChatModel
+from typing import Optional
+from vibe_surf.langflow.custom import Component
+from vibe_surf.langflow.inputs import MessageTextInput, HandleInput, DropdownInput, FileInput
+from vibe_surf.langflow.io import BoolInput, IntInput, Output
+from vibe_surf.browser.agent_browser_session import AgentBrowserSession
+from vibe_surf.langflow.schema.message import Message
+from browser_use.actor.element import Element, ElementInfo
+from vibe_surf.langflow.field_typing import LanguageModel
+
+class BrowserUploadFileComponent(Component):
+    display_name = "Upload File"
+    description = "Browser upload file"
+    icon = "upload"
+
+    inputs = [
+        HandleInput(
+            name="browser_session",
+            display_name="Browser Session",
+            info="Browser Session defined by VibeSurf",
+            input_types=["AgentBrowserSession"],
+            required=True
+        ),
+        FileInput(
+            name="file",
+            display_name="File",
+            info="File to upload",
+            required=True,
+            fileTypes=['json', 'md', 'csv', 'pdf', 'png', 'jpg', 'jpeg', 'txt', 'py', 'js'],
+        ),
+        MessageTextInput(
+            name="element_text",
+            display_name="Element Text",
+            info="Element Text you want to find and operate."
+        ),
+        MessageTextInput(
+            name="element_hints",
+            display_name="Element Hints",
+            info="List of context hints like ['form', 'contact', 'personal info'] for finding this element. "
+                 "Useful to distinguish when there are multiple elements with same text. ",
+            list=True
+        ),
+        MessageTextInput(
+            name="css_selector",
+            display_name="CSS Selector",
+            info="CSS Selector. Prioritize to use CSS Selector is you know it.",
+        ),
+        IntInput(
+            name="backend_node_id",
+            display_name="Backend Node ID",
+            info="Backend Node ID",
+            advanced=True
+        ),
+        MessageTextInput(
+            name="element_prompt",
+            display_name="Element Prompt",
+            info="Element Prompt",
+            advanced=True
+        ),
+        HandleInput(
+            name="llm",
+            display_name="LLM Model",
+            info="LLM Model defined by VibeSurf",
+            input_types=["LanguageModel"],
+            advanced=True
+        ),
+    ]
+
+    outputs = [
+        Output(
+            display_name="Browser Session",
+            name="output_browser_session",
+            method="browser_upload_file",
+            types=["AgentBrowserSession"]
+        )
+    ]
+
+    async def browser_upload_file(self) -> AgentBrowserSession:
+        try:
+            await self.browser_session._wait_for_stable_network()
+
+            element: Optional[Element] = None
+            if self.element_text:
+                from vibe_surf.browser.find_page_element import SemanticExtractor
+                from vibe_surf.browser.page_operations import _try_direct_selector, _wait_for_element
+
+                semantic_extractor = SemanticExtractor()
+                element_mappings = await semantic_extractor.extract_semantic_mapping(self.browser_session)
+                element_info = semantic_extractor.find_element_by_hierarchy(element_mappings,
+                                                                            target_text=self.element_text,
+                                                                            context_hints=self.element_hints)
+                direct_selector = await _try_direct_selector(self.browser_session, self.element_text)
+                selector_to_use = None
+                if direct_selector:
+                    selector_to_use = direct_selector
+                elif element_info:
+                    # Use hierarchical selector if it's more specific than the basic selector
+                    hierarchical = element_info.get('hierarchical_selector', '')
+                    basic = element_info.get('selectors', '')
+
+                    # Prefer hierarchical if it has positional info (nth-of-type) or IDs
+                    if hierarchical and ('#' in hierarchical or ':nth-of-type' in hierarchical):
+                        selector_to_use = hierarchical
+                    else:
+                        selector_to_use = basic
+
+                if selector_to_use:
+                    page = await self.browser_session.get_current_page()
+
+                    fallback_selectors = []
+                    if element_info:
+                        # Add hierarchical selector as first fallback
+                        hierarchical_selector = element_info.get('hierarchical_selector')
+                        if hierarchical_selector and hierarchical_selector != selector_to_use:
+                            fallback_selectors.append(hierarchical_selector)
+
+                        # Add original fallback selector
+                        fallback_selector = element_info.get('fallback_selector')
+                        if fallback_selector and fallback_selector not in fallback_selectors:
+                            fallback_selectors.append(fallback_selector)
+
+                        # Add XPath selector as final fallback
+                        xpath_selector = element_info.get('text_xpath')
+                        if xpath_selector:
+                            fallback_selectors.append(f'xpath={xpath_selector}')
+
+                    success, actual_selector = await _wait_for_element(self.browser_session, selector_to_use,
+                                                                       fallback_selectors=fallback_selectors)
+                    if not success:
+                        raise ValueError("Failed to find selector")
+                    else:
+                        self.status = f"Get actual selector: {actual_selector}"
+                        elements = await page.get_elements_by_css_selector(actual_selector)
+                        if elements:
+                            element = elements[0]
+
+            elif self.css_selector:
+                page = await self.browser_session.get_current_page()
+                elements = await page.get_elements_by_css_selector(self.css_selector)
+                self.log(f"Found {len(elements)} elements with CSS selector {self.css_selector}")
+                self.log(elements)
+                if elements:
+                    element = elements[0]
+            elif self.backend_node_id:
+                page = await self.browser_session.get_current_page()
+                element = await page.get_element(self.backend_node_id)
+            elif self.element_prompt and self.llm:
+                page = await self.browser_session.get_current_page()
+                element = await page.get_element_by_prompt(self.element_prompt, self.llm)
+
+            if not element:
+                self.status = "No element found!"
+                raise ValueError("No element found!")
+
+            element_info: ElementInfo = await element.get_basic_info()
+            if element_info["nodeName"] != 'INPUT' and element_info["attributes"].get('type', '').lower() != 'file':
+                raise ValueError(f"{element} does not support file upload!")
+
+            # Get CDP client and session
+            cdp_client = self.browser_session.cdp_client
+            # Set file(s) to upload
+            await cdp_client.send.DOM.setFileInputFiles(
+                params={
+                    'files': [self.file],
+                    'backendNodeId': element._backend_node_id,
+                },
+                session_id=element._session_id,
+            )
+            self.status = f"Upload file: {self.file} on element {element}"
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            raise e
+        finally:
+            return self.browser_session

vibe_surf/workflows/Browser/browser_wait.py

@@ -0,0 +1,46 @@
+import asyncio
+import os
+from typing import Any, List
+from uuid import uuid4
+from typing import Optional
+
+from vibe_surf.langflow.custom import Component
+from vibe_surf.langflow.inputs import MessageTextInput, HandleInput
+from vibe_surf.langflow.io import BoolInput, IntInput, Output
+from vibe_surf.browser.agent_browser_session import AgentBrowserSession
+from vibe_surf.langflow.schema.message import Message
+
+class BrowserWaitComponent(Component):
+    display_name = "Wait"
+    description = "Wait seconds for stable browser page."
+    icon = "clock"
+
+    inputs = [
+        HandleInput(
+            name="browser_session",
+            display_name="Browser Session",
+            info="Browser Session defined by VibeSurf",
+            input_types=["AgentBrowserSession"],
+            required=True
+        ),
+        IntInput(
+            name="seconds",
+            display_name="Seconds",
+            info="Seconds to wait for stable browser page",
+            value=1
+        )
+    ]
+
+    outputs = [
+        Output(
+            display_name="Browser Session",
+            name="output_browser_session",
+            method="pass_browser_session",
+            types=["AgentBrowserSession"],
+            group_outputs=True,
+        ),
+    ]
+
+    async def pass_browser_session(self) -> AgentBrowserSession:
+        await asyncio.sleep(self.seconds)
+        return self.browser_session

vibe_surf/workflows/Browser/close_browser_session.py

@@ -0,0 +1,51 @@
+import asyncio
+from typing import Any, List
+from uuid import uuid4
+
+from vibe_surf.langflow.custom import Component
+from vibe_surf.langflow.inputs import MessageTextInput, HandleInput
+from vibe_surf.langflow.io import BoolInput, IntInput, Output
+from vibe_surf.browser.agent_browser_session import AgentBrowserSession
+from vibe_surf.langflow.schema.message import Message
+
+class CloseBrowserSessionComponent(Component):
+    display_name = "Close Browser Session"
+    description = "Close browser sessions"
+    icon = "circle-x"
+
+    inputs = [
+        HandleInput(
+            name="browser_session",
+            display_name="Browser Session",
+            info="Browser Session defined by VibeSurf",
+            input_types=["AgentBrowserSession"],
+            required=True
+        )
+    ]
+
+    outputs = [
+        Output(
+            display_name="Result",
+            name="result",
+            method="close_browser_session",
+            types=["Message"]
+        )
+    ]
+
+    async def close_browser_session(self) -> Message | None:
+        """Close a specific session."""
+        if self.browser_session is None:
+            raise RuntimeError("Browser session not found")
+        if self.browser_session.main_browser_session is None:
+            self.status = "Current Browser Session is main browser session. We can not close it."
+            return Message(text=self.status)
+        else:
+            try:
+                from vibe_surf.backend.shared_state import browser_manager
+                await browser_manager.unregister_agent(self.browser_session.id, close_tabs=True)
+                self.status = "Successfully closed browser session."
+                return Message(text=self.status)
+            except Exception as e:
+                import traceback
+                traceback.print_exc()
+                self.status = "Failed to close browser session. {}".format(e)

vibe_surf/workflows/FileSystem/extract_content_from_file.py

@@ -0,0 +1,112 @@
+import asyncio
+from pathlib import Path
+from typing import Any
+from browser_use.llm.base import BaseChatModel
+
+from vibe_surf.langflow.custom import Component
+from vibe_surf.langflow.io import FileInput, MessageTextInput, MultilineInput, Output, HandleInput
+from vibe_surf.langflow.schema import Data
+from vibe_surf.langflow.schema.message import Message
+from vibe_surf.tools.file_system import CustomFileSystem
+from vibe_surf.tools.utils import extract_file_content_with_llm
+from vibe_surf.langflow.field_typing import LanguageModel
+
+class ExtractContentFromFileComponent(Component):
+    display_name = "Extract Content From File"
+    description = "Extract content from a file using LLM. Supports both image and text files."
+    icon = "file-search"
+    name = "ExtractContentFromFile"
+
+    inputs = [
+        HandleInput(
+            name="llm",
+            display_name="LLM Model",
+            info="Language model for content extraction",
+            input_types=["LanguageModel"],
+            required=True
+        ),
+        MultilineInput(
+            name="query",
+            display_name="Query",
+            info="Query or instruction for content extraction",
+            required=True,
+        ),
+        FileInput(
+            name="file",
+            display_name="File",
+            fileTypes=["pdf", "md", "txt", "json", "csv", "png", "jpg", "jpeg", "gif", "bmp", "webp"],
+            info="File to extract content from",
+            required=False,
+        ),
+        MessageTextInput(
+            name="file_path",
+            display_name="File Path",
+            info="Path to the file (alternative to file upload)",
+            required=False,
+            advanced=True
+        ),
+    ]
+
+    outputs = [
+        Output(
+            name="extracted_content",
+            display_name="Extracted Content",
+            method="extract_content",
+            types=["Message"],
+        ),
+    ]
+
+    async def extract_content(self) -> Message:
+        """Extract content from file using LLM"""
+        try:
+            # Validate inputs
+            if not self.file and not self.file_path:
+                raise ValueError("Please provide either a file upload or file path")
+            
+            if self.file and self.file_path:
+                raise ValueError("Please provide either a file upload or file path, not both")
+
+            # Get session_id for file system initialization
+            if hasattr(self, "graph"):
+                session_id = self.graph.session_id
+            elif hasattr(self, "_session_id"):
+                session_id = self._session_id
+            else:
+                session_id = "default"
+
+            # Initialize file system using workspace/workflows/session_id structure
+            from vibe_surf.common import get_workspace_dir
+            import os
+            
+            workspace_dir = get_workspace_dir()
+            workflows_dir = Path(workspace_dir) / "workflows" / session_id
+            os.makedirs(workflows_dir, exist_ok=True)
+            
+            file_system = CustomFileSystem(base_dir=workflows_dir, create_default_files=False)
+
+            # Determine file path
+            if self.file:
+                # Handle uploaded file
+                file_path = self.file
+                # If it's an uploaded file, we might need to copy it to our file system
+                if hasattr(self, 'resolve_path'):
+                    resolved_path = self.resolve_path(self.file)
+                    file_path = resolved_path
+            else:
+                # Handle file path
+                file_path = self.file_path
+
+            # Extract content using the utility function
+            extracted_content = await extract_file_content_with_llm(
+                file_path=file_path,
+                query=self.query,
+                llm=self.llm,
+                file_system=file_system
+            )
+
+            return Message(text=extracted_content)
+
+        except Exception as e:
+            error_message = f"Error extracting content from file: {str(e)}"
+            self.status = error_message
+            raise ValueError(error_message) from e

vibe_surf/workflows/FileSystem/load_json.py

@@ -0,0 +1,136 @@
+import json
+from pathlib import Path
+from typing import Any
+
+from json_repair import repair_json
+from vibe_surf.langflow.custom import Component
+from vibe_surf.langflow.io import FileInput, MessageTextInput, MultilineInput, Output, BoolInput
+from vibe_surf.langflow.schema import Data, DataFrame
+from vibe_surf.langflow.io import Output, MessageTextInput
+
+
+class LoadJSONComponent(Component):
+    display_name = "Load JSON"
+    description = "Convert a JSON file or a JSON string to Data or Data list."
+    icon = "braces"
+    name = "LoadJSON"
+
+    inputs = [
+        FileInput(
+            name="json_file",
+            display_name="JSON File",
+            fileTypes=["json"],
+            info="Import a valid JSON file",
+        ),
+        MessageTextInput(
+            name="json_path",
+            display_name="JSON File Path",
+            info="File path to the JSON file",
+            advanced=True
+        ),
+        MultilineInput(
+            name="json_string",
+            display_name="JSON String",
+            info="Enter a valid JSON string",
+        ),
+        BoolInput(
+            name="is_list",
+            display_name="Is List",
+            info="If true, return DataFrame instead of Data",
+            value=False,
+            real_time_refresh=True
+        )
+
+    ]
+
+    outputs = [
+        Output(
+            name="data",
+            display_name="Data",
+            method="convert_json_to_data",
+            types=['Data'],
+        ),
+    ]
+
+    def update_outputs(self, frontend_node: dict, field_name: str, field_value: Any) -> dict:
+        """Dynamically show only the relevant output based on the selected output type."""
+        if field_name == "is_list":
+            frontend_node["outputs"] = []
+            # Add only the selected output type
+            if field_value:
+                frontend_node["outputs"].append(
+                    Output(
+                        name="data",
+                        display_name="Data Frame",
+                        method="convert_json_to_data",
+                        types=['DataFrame'],
+                    ).to_dict()
+                )
+            else:
+                frontend_node["outputs"].append(
+                    Output(
+                        name="data",
+                        display_name="Data",
+                        method="convert_json_to_data",
+                        types=['Data'],
+                    ).to_dict()
+                )
+
+        return frontend_node
+
+    def convert_json_to_data(self) -> Data | DataFrame:
+        if sum(bool(field) for field in [self.json_file, self.json_path, self.json_string]) != 1:
+            msg = "Please provide exactly one of: JSON file, file path, or JSON string."
+            self.status = msg
+            raise ValueError(msg)
+
+        json_data = None
+
+        try:
+            if self.json_file:
+                resolved_path = self.resolve_path(self.json_file)
+                file_path = Path(resolved_path)
+                if file_path.suffix.lower() != ".json":
+                    self.status = "The provided file must be a JSON file."
+                else:
+                    json_data = file_path.read_text(encoding="utf-8")
+
+            elif self.json_path:
+                file_path = Path(self.json_path)
+                if file_path.suffix.lower() != ".json":
+                    self.status = "The provided file must be a JSON file."
+                else:
+                    json_data = file_path.read_text(encoding="utf-8")
+
+            else:
+                json_data = self.json_string
+
+            if json_data:
+                # Try to parse the JSON string
+                try:
+                    parsed_data = json.loads(json_data)
+                except json.JSONDecodeError:
+                    # If JSON parsing fails, try to repair the JSON string
+                    repaired_json_string = repair_json(json_data)
+                    parsed_data = json.loads(repaired_json_string)
+
+                # Check if the parsed data is a list
+                if isinstance(parsed_data, list):
+                    result = DataFrame([Data(data=item) for item in parsed_data])
+                else:
+                    result = Data(data=parsed_data)
+                self.status = result
+                return result
+
+        except (json.JSONDecodeError, SyntaxError, ValueError) as e:
+            error_message = f"Invalid JSON or Python literal: {e}"
+            self.status = error_message
+            raise ValueError(error_message) from e
+
+        except Exception as e:
+            error_message = f"An error occurred: {e}"
+            self.status = error_message
+            raise ValueError(error_message) from e
+
+        # An error occurred
+        raise ValueError(self.status)