vibesurf 0.1.0__py3-none-any.whl

vibe_surf/backend/utils/encryption.py

@@ -0,0 +1,164 @@
+"""
+Encryption utilities for VibeSurf Backend
+
+Uses machine MAC address for key derivation to encrypt sensitive data like API keys.
+"""
+
+import hashlib
+import uuid
+import base64
+from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+import logging
+
+logger = logging.getLogger(__name__)
+
+import psutil
+import logging
+
+
+def get_machine_id() -> str:
+    """Get unique machine identifier based on MAC address."""
+    try:
+        nics = psutil.net_if_addrs()
+
+        priority_interfaces = ['en0', 'eth0', 'en1']
+
+        for interface in priority_interfaces:
+            if interface in nics:
+                for addr in nics[interface]:
+                    if addr.family == psutil.AF_LINK:
+                        mac = addr.address
+                        if mac and mac != '00:00:00:00:00:00':
+                            return mac.replace(':', '').upper()
+
+        for interface, addrs in nics.items():
+            for addr in addrs:
+                if addr.family == psutil.AF_LINK:
+                    mac = addr.address
+                    if (mac and mac != '00:00:00:00:00:00' and
+                            not mac.startswith('02:') and
+                            not interface.startswith(('lo', 'docker', 'veth'))):
+                        return mac.replace(':', '').upper()
+
+    except Exception as e:
+        logging.warning(f"Could not get MAC address via psutil: {e}")
+
+    return "VIBESURF_WARMSHAO"
+
+
+def derive_key(machine_id: str, salt: bytes = None) -> bytes:
+    """Derive encryption key from machine ID."""
+    if salt is None:
+        # Use a fixed salt for consistency across sessions
+        salt = b'vibesurf_warmshao_2025'
+    
+    # Convert machine_id to bytes
+    password = machine_id.encode('utf-8')
+    
+    # Derive key using PBKDF2
+    kdf = PBKDF2HMAC(
+        algorithm=hashes.SHA256(),
+        length=32,
+        salt=salt,
+        iterations=100000,
+    )
+    key = base64.urlsafe_b64encode(kdf.derive(password))
+    return key
+
+def get_encryption_key() -> bytes:
+    """Get the encryption key for this machine."""
+    machine_id = get_machine_id()
+    return derive_key(machine_id)
+
+def encrypt_api_key(api_key: str) -> str:
+    """
+    Encrypt API key using machine-specific key.
+    
+    Args:
+        api_key: Plain text API key
+        
+    Returns:
+        str: Base64 encoded encrypted API key
+    """
+    if not api_key or api_key.strip() == "":
+        return ""
+    
+    try:
+        key = get_encryption_key()
+        fernet = Fernet(key)
+        encrypted_data = fernet.encrypt(api_key.encode('utf-8'))
+        return base64.urlsafe_b64encode(encrypted_data).decode('utf-8')
+    except Exception as e:
+        logger.error(f"Failed to encrypt API key: {e}")
+        raise ValueError("Encryption failed")
+
+def decrypt_api_key(encrypted_api_key: str) -> str:
+    """
+    Decrypt API key using machine-specific key.
+    
+    Args:
+        encrypted_api_key: Base64 encoded encrypted API key
+        
+    Returns:
+        str: Decrypted API key
+    """
+    if not encrypted_api_key or encrypted_api_key.strip() == "":
+        return ""
+    
+    try:
+        key = get_encryption_key()
+        fernet = Fernet(key)
+        encrypted_data = base64.urlsafe_b64decode(encrypted_api_key.encode('utf-8'))
+        decrypted_data = fernet.decrypt(encrypted_data)
+        return decrypted_data.decode('utf-8')
+    except Exception as e:
+        logger.error(f"Failed to decrypt API key: {e}")
+        raise ValueError("Decryption failed")
+
+def is_encrypted(value: str) -> bool:
+    """
+    Check if a value appears to be encrypted.
+    
+    Args:
+        value: String to check
+        
+    Returns:
+        bool: True if value appears encrypted
+    """
+    if not value:
+        return False
+    
+    try:
+        # Try to decode as base64
+        base64.urlsafe_b64decode(value.encode('utf-8'))
+        # If it's base64 and contains the Fernet token prefix, likely encrypted
+        return len(value) > 50 and '=' in value
+    except:
+        return False
+
+# Test functions
+def test_encryption():
+    """Test encryption/decryption functionality."""
+    test_api_key = "sk-test123456789"
+    
+    try:
+        # Test encryption
+        encrypted = encrypt_api_key(test_api_key)
+        print(f"Original: {test_api_key}")
+        print(f"Encrypted: {encrypted}")
+        
+        # Test decryption
+        decrypted = decrypt_api_key(encrypted)
+        print(f"Decrypted: {decrypted}")
+        
+        # Verify
+        assert test_api_key == decrypted, "Encryption/decryption failed"
+        print("✅ Encryption test passed")
+        
+    except Exception as e:
+        print(f"❌ Encryption test failed: {e}")
+
+if __name__ == "__main__":
+    test_encryption()

vibe_surf/backend/utils/llm_factory.py

@@ -0,0 +1,225 @@
+"""
+LLM Factory utilities for creating LLM instances from profiles
+"""
+
+from typing import Optional
+import logging
+from ..llm_config import get_supported_providers, is_provider_supported
+
+logger = logging.getLogger(__name__)
+
+def create_llm_from_profile(llm_profile):
+    """Create LLM instance from LLMProfile database record (dict or object)"""
+    try:
+        # Import LLM classes from browser_use and vibe_surf
+        from browser_use.llm import (
+            ChatOpenAI, ChatAnthropic, ChatGoogle, ChatAzureOpenAI, 
+            ChatGroq, ChatOllama, ChatOpenRouter, ChatDeepSeek, 
+            ChatAWSBedrock, ChatAnthropicBedrock
+        )
+        from vibe_surf.llm import ChatOpenAICompatible
+        
+        # Handle both dict and object access patterns
+        def get_attr(obj, key, default=None):
+            if isinstance(obj, dict):
+                return obj.get(key, default)
+            else:
+                return getattr(obj, key, default)
+        
+        provider = get_attr(llm_profile, 'provider')
+        model = get_attr(llm_profile, 'model')
+        api_key = get_attr(llm_profile, 'api_key')  # Should already be decrypted by queries
+        base_url = get_attr(llm_profile, 'base_url')
+        temperature = get_attr(llm_profile, 'temperature') or 0.7
+        max_tokens = get_attr(llm_profile, 'max_tokens')
+        top_p = get_attr(llm_profile, 'top_p')
+        frequency_penalty = get_attr(llm_profile, 'frequency_penalty')
+        seed = get_attr(llm_profile, 'seed')
+        provider_config = get_attr(llm_profile, 'provider_config', {})
+        
+        # Validate provider
+        if not is_provider_supported(provider):
+            raise ValueError(f"Unsupported provider: {provider}. Supported: {get_supported_providers()}")
+        
+        # Common parameters
+        common_params = {}
+        if temperature is not None:
+            common_params["temperature"] = temperature
+        if max_tokens is not None:
+            common_params["max_tokens"] = max_tokens
+        if top_p is not None:
+            common_params["top_p"] = top_p
+        if frequency_penalty is not None:
+            common_params["frequency_penalty"] = frequency_penalty
+        if seed is not None:
+            common_params["seed"] = seed
+        
+        # Add provider-specific config if available
+        if provider_config:
+            common_params.update(provider_config)
+        
+        # Create LLM instance based on provider
+        if provider == "openai":
+            params = {
+                "model": model,
+                "api_key": api_key,
+                **common_params
+            }
+            if base_url:
+                params["base_url"] = base_url
+            return ChatOpenAI(**params)
+        
+        elif provider == "anthropic":
+            return ChatAnthropic(
+                model=model,
+                api_key=api_key,
+                **common_params
+            )
+        
+        elif provider == "google":
+            return ChatGoogle(
+                model=model,
+                api_key=api_key,
+                **common_params
+            )
+        
+        elif provider == "azure_openai":
+            if not base_url:
+                raise ValueError("Azure OpenAI requires base_url (azure_endpoint)")
+            return ChatAzureOpenAI(
+                model=model,
+                api_version="2025-01-01-preview",
+                api_key=api_key,
+                azure_endpoint=base_url,
+                **common_params
+            )
+        
+        elif provider == "groq":
+            return ChatGroq(
+                model=model,
+                api_key=api_key,
+                **common_params
+            )
+        
+        elif provider == "ollama":
+            params = {
+                "model": model,
+                **common_params
+            }
+            if base_url:
+                params["host"] = base_url
+            else:
+                params["host"] = "http://localhost:11434"  # Default Ollama URL
+            return ChatOllama(**params)
+        
+        elif provider == "openrouter":
+            return ChatOpenRouter(
+                model=model,
+                api_key=api_key,
+                **common_params
+            )
+        
+        elif provider == "deepseek":
+            return ChatDeepSeek(
+                model=model,
+                api_key=api_key,
+                **common_params
+            )
+        
+        elif provider == "aws_bedrock":
+            params = {
+                "model": model,
+                "aws_access_key_id": api_key,  # AWS uses different auth
+                **common_params
+            }
+            # Add AWS-specific parameters from provider_config
+            if "aws_secret_access_key" in provider_config:
+                params["aws_secret_access_key"] = provider_config["aws_secret_access_key"]
+            if "aws_region" in provider_config:
+                params["aws_region"] = provider_config["aws_region"]
+            if 'aws_region' not in params:
+                params["aws_region"] = "us-east-1"
+            return ChatAWSBedrock(**params)
+        
+        elif provider == "anthropic_bedrock":
+            params = {
+                "model": model,
+                "aws_access_key_id": api_key,  # AWS uses different auth
+                **common_params
+            }
+            # Add AWS-specific parameters from provider_config
+            if "aws_secret_access_key" in provider_config:
+                params["aws_secret_access_key"] = provider_config["aws_secret_access_key"]
+            if "region_name" in provider_config:
+                params["region_name"] = provider_config["region_name"]
+            return ChatAnthropicBedrock(**params)
+        
+        elif provider == "openai_compatible":
+            if not base_url:
+                raise ValueError("OpenAI Compatible provider requires base_url")
+            return ChatOpenAICompatible(
+                model=model,
+                api_key=api_key,
+                base_url=base_url,
+                **common_params
+            )
+        
+        else:
+            raise ValueError(f"Unsupported provider: {provider}")
+            
+    except Exception as e:
+        logger.error(f"Failed to create LLM from profile: {e}")
+        raise RuntimeError(f"Failed to create LLM from profile: {str(e)}")
+
+def validate_llm_configuration(provider: str, model: str, api_key: str, base_url: Optional[str] = None):
+    """Validate LLM configuration parameters"""
+    if not provider:
+        raise ValueError("Provider is required")
+    
+    if not model:
+        raise ValueError("Model is required")
+    
+    if not is_provider_supported(provider):
+        raise ValueError(f"Unsupported provider: {provider}. Supported: {get_supported_providers()}")
+    
+    # Provider-specific validation
+    from ..llm_config import get_provider_metadata
+    metadata = get_provider_metadata(provider)
+    
+    if metadata.get("requires_api_key", True) and not api_key:
+        raise ValueError(f"API key is required for provider: {provider}")
+    
+    if metadata.get("requires_base_url", False) and not base_url:
+        raise ValueError(f"Base URL is required for provider: {provider}")
+    
+    return True
+
+def get_llm_creation_parameters(provider: str):
+    """Get the required and optional parameters for creating an LLM instance"""
+    from ..llm_config import get_provider_metadata
+    
+    if not is_provider_supported(provider):
+        raise ValueError(f"Unsupported provider: {provider}")
+    
+    metadata = get_provider_metadata(provider)
+    
+    required_params = ["model"]
+    optional_params = ["temperature", "max_tokens", "top_p", "frequency_penalty", "seed"]
+    
+    if metadata.get("requires_api_key", True):
+        required_params.append("api_key")
+    
+    if metadata.get("requires_base_url", False):
+        required_params.append("base_url")
+    elif metadata.get("supports_base_url", False):
+        optional_params.append("base_url")
+    
+    # Special cases for AWS Bedrock
+    if provider in ["aws_bedrock", "anthropic_bedrock"]:
+        required_params.extend(["aws_secret_access_key", "region_name"])
+    
+    return {
+        "required": required_params,
+        "optional": optional_params,
+        "metadata": metadata
+    }

vibe_surf/browser/__init__.py

@@ -0,0 +1,8 @@
+from typing import Optional, TYPE_CHECKING
+
+from vibe_surf.browser.browser_manager import BrowserManager
+from vibe_surf.browser.agent_browser_session import AgentBrowserSession
+from vibe_surf.browser.agen_browser_profile import AgentBrowserProfile
+
+
+__all__ = [ "AgentBrowserSession", "AgentBrowserProfile", "BrowserManager"]

vibe_surf/browser/agen_browser_profile.py

@@ -0,0 +1,130 @@
+import pdb
+import sys
+import tempfile
+from collections.abc import Iterable
+from enum import Enum
+from functools import cache
+from pathlib import Path
+from re import Pattern
+from typing import Annotated, Any, Literal, Self
+from urllib.parse import urlparse
+
+from pydantic import AfterValidator, AliasChoices, BaseModel, ConfigDict, Field, field_validator, model_validator
+from uuid_extensions import uuid7str
+
+from browser_use.config import CONFIG
+from browser_use.observability import observe_debug
+from browser_use.utils import _log_pretty_path, logger
+
+from browser_use.browser import BrowserProfile
+
+
+class AgentBrowserProfile(BrowserProfile):
+    custom_extensions: list = Field(
+        default=lambda: [],
+        description="Enable Custom Extensions.",
+    )
+
+    def _ensure_default_extensions_downloaded(self) -> list[str]:
+        """
+        Ensure default extensions are downloaded and cached locally.
+        Returns list of paths to extension directories.
+        """
+
+        # Extension definitions - optimized for automation and content extraction
+        extensions = [
+            # {
+            #     'name': 'uBlock Origin',
+            #     'id': 'cjpalhdlnbpafiamejdnhcphjbkeiagm',
+            #     'url': 'https://clients2.google.com/service/update2/crx?response=redirect&prodversion=130&acceptformat=crx3&x=id%3Dcjpalhdlnbpafiamejdnhcphjbkeiagm%26uc',
+            # },
+            {
+                'name': "I still don't care about cookies",
+                'id': 'edibdbjcniadpccecjdfdjjppcpchdlm',
+                'url': 'https://clients2.google.com/service/update2/crx?response=redirect&prodversion=130&acceptformat=crx3&x=id%3Dedibdbjcniadpccecjdfdjjppcpchdlm%26uc',
+            },
+            # {
+            #     'name': 'ClearURLs',
+            #     'id': 'lckanjgmijmafbedllaakclkaicjfmnk',
+            #     'url': 'https://clients2.google.com/service/update2/crx?response=redirect&prodversion=130&acceptformat=crx3&x=id%3Dlckanjgmijmafbedllaakclkaicjfmnk%26uc',
+            # },
+            # {
+            # 	'name': 'Captcha Solver: Auto captcha solving service',
+            # 	'id': 'pgojnojmmhpofjgdmaebadhbocahppod',
+            # 	'url': 'https://clients2.google.com/service/update2/crx?response=redirect&prodversion=130&acceptformat=crx3&x=id%3Dpgojnojmmhpofjgdmaebadhbocahppod%26uc',
+            # },
+            # {
+            # 	'name': 'Consent-O-Matic',
+            # 	'id': 'mdjildafknihdffpkfmmpnpoiajfjnjd',
+            # 	'url': 'https://clients2.google.com/service/update2/crx?response=redirect&prodversion=130&acceptformat=crx3&x=id%3Dmdjildafknihdffpkfmmpnpoiajfjnjd%26uc',
+            # },
+            # {
+            # 	'name': 'Privacy | Protect Your Payments',
+            # 	'id': 'hmgpakheknboplhmlicfkkgjipfabmhp',
+            # 	'url': 'https://clients2.google.com/service/update2/crx?response=redirect&prodversion=130&acceptformat=crx3&x=id%3Dhmgpakheknboplhmlicfkkgjipfabmhp%26uc',
+            # },
+        ]
+
+        # Create extensions cache directory
+        cache_dir = CONFIG.BROWSER_USE_EXTENSIONS_DIR
+        cache_dir.mkdir(parents=True, exist_ok=True)
+        # logger.debug(f'📁 Extensions cache directory: {_log_pretty_path(cache_dir)}')
+
+        extension_paths = []
+        loaded_extension_names = []
+
+        for ext in extensions:
+            ext_dir = cache_dir / ext['id']
+            crx_file = cache_dir / f'{ext["id"]}.crx'
+
+            # Check if extension is already extracted
+            if ext_dir.exists() and (ext_dir / 'manifest.json').exists():
+                # logger.debug(f'✅ Using cached {ext["name"]} extension from {_log_pretty_path(ext_dir)}')
+                extension_paths.append(str(ext_dir))
+                loaded_extension_names.append(ext['name'])
+                continue
+
+            try:
+                # Download extension if not cached
+                if not crx_file.exists():
+                    logger.info(f'📦 Downloading {ext["name"]} extension...')
+                    self._download_extension(ext['url'], crx_file)
+                else:
+                    logger.debug(f'📦 Found cached {ext["name"]} .crx file')
+
+                # Extract extension
+                logger.info(f'📂 Extracting {ext["name"]} extension...')
+                self._extract_extension(crx_file, ext_dir)
+                extension_paths.append(str(ext_dir))
+                loaded_extension_names.append(ext['name'])
+
+            except Exception as e:
+                logger.warning(f'⚠️ Failed to setup {ext["name"]} extension: {e}')
+                continue
+
+        if extension_paths:
+            logger.debug(
+                f'[BrowserProfile] 🧩 Extensions loaded ({len(extension_paths)}): [{", ".join(loaded_extension_names)}]')
+        else:
+            logger.warning('[BrowserProfile] ⚠️ No default extensions could be loaded')
+
+        return extension_paths
+
+    def _get_extension_args(self) -> list[str]:
+        """Get Chrome args for enabling default extensions (ad blocker and cookie handler)."""
+        extension_paths = self._ensure_default_extensions_downloaded()
+
+        args = [
+            '--enable-extensions',
+            '--disable-extensions-file-access-check',
+            '--disable-extensions-http-throttling',
+            '--enable-extension-activity-logging',
+            '--disable-features=DisableLoadExtensionCommandLineSwitch'
+        ]
+
+        if self.custom_extensions:
+            extension_paths.extend(self.custom_extensions)
+        if extension_paths:
+            args.append(f'--load-extension={",".join(extension_paths)}')
+        print(args)
+        return args