vibesurf 0.1.9a6__py3-none-any.whl → 0.1.11__py3-none-any.whl

vibe_surf/backend/database/schemas.py

@@ -58,7 +58,7 @@ class McpServerConfig(BaseModel):
     mcpServers: Dict[str, McpServerParams] = Field(default_factory=dict)
 
 class ControllerConfiguration(BaseModel):
-    """Schema for Task.mcp_server_config JSON field (legacy controller config)"""
+    """Schema for Task.mcp_server_config JSON field (legacy tools config)"""
     
     # Action control
     exclude_actions: List[str] = Field(default_factory=list)

vibe_surf/backend/main.py

@@ -11,6 +11,7 @@ from fastapi.middleware.cors import CORSMiddleware
 import logging
 import argparse
 import os
+import asyncio
 from datetime import datetime
 
 # Import routers
@@ -18,13 +19,16 @@ from .api.task import router as agents_router
 from .api.files import router as files_router
 from .api.activity import router as activity_router
 from .api.config import router as config_router
+from .api.browser import router as browser_router
 
 # Import shared state
 from . import shared_state
 
 # Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__name__)
 
 app = FastAPI(
     title="VibeSurf Backend API",
@@ -46,18 +50,86 @@ app.include_router(agents_router, prefix="/api", tags=["tasks"])
 app.include_router(files_router, prefix="/api", tags=["files"])
 app.include_router(activity_router, prefix="/api", tags=["activity"])
 app.include_router(config_router, prefix="/api", tags=["config"])
+app.include_router(browser_router, prefix="/api", tags=["browser"])
+
+# Global variable to control browser monitoring task
+browser_monitor_task = None
+
+async def monitor_browser_connection():
+    """Background task to monitor browser connection"""
+    while True:
+        try:
+            await asyncio.sleep(2)  # Check every 1 second
+            
+            if shared_state.browser_manager:
+                is_connected = await shared_state.browser_manager.check_browser_connected()
+                if not is_connected:
+                    logger.error("No Available Browser, Exiting...")
+                    
+                    # Schedule a graceful shutdown using os.kill in a separate thread
+                    import threading
+                    import signal
+                    import os
+                    
+                    def trigger_shutdown():
+                        try:
+                            # Give a brief moment for any cleanup
+                            import time
+                            time.sleep(0.5)
+                            # Send SIGTERM to current process for graceful shutdown
+                            os.kill(os.getpid(), signal.SIGTERM)
+                        except Exception as e:
+                            logger.error(f"Error during shutdown trigger: {e}")
+                            # Fallback to SIGKILL if SIGTERM doesn't work
+                            try:
+                                os.kill(os.getpid(), signal.SIGKILL)
+                            except:
+                                pass
+                    
+                    # Start shutdown in a separate thread to avoid blocking the async loop
+                    shutdown_thread = threading.Thread(target=trigger_shutdown)
+                    shutdown_thread.daemon = True
+                    shutdown_thread.start()
+                    
+                    # Exit the monitoring loop
+                    break
+                    
+        except asyncio.CancelledError:
+            logger.info("Browser monitor task cancelled")
+            break
+        except Exception as e:
+            logger.warning(f"Browser monitor error: {e}")
+            # Continue monitoring even if there's an error
 
 @app.on_event("startup")
 async def startup_event():
     """Initialize database and VibeSurf components on startup"""
+    global browser_monitor_task
+    
     # Initialize VibeSurf components and update shared state
     await shared_state.initialize_vibesurf_components()
 
+    # Start browser monitoring task
+    browser_monitor_task = asyncio.create_task(monitor_browser_connection())
+    logger.info("🔍 Started browser connection monitor")
+
     logger.info("🚀 VibeSurf Backend API started with single-task execution model")
 
 @app.on_event("shutdown")
 async def shutdown_event():
     """Cleanup on shutdown"""
+    global browser_monitor_task
+    
+    logger.info("🛑 Starting graceful shutdown...")
+    
+    # Cancel browser monitor task
+    if browser_monitor_task and not browser_monitor_task.done():
+        browser_monitor_task.cancel()
+        try:
+            await asyncio.wait_for(browser_monitor_task, timeout=2.0)
+        except (asyncio.CancelledError, asyncio.TimeoutError):
+            pass
+        logger.info("✅ Browser monitor task stopped")
     
     # Cleanup VibeSurf components
     if shared_state.browser_manager:
@@ -70,7 +142,12 @@ async def shutdown_event():
     
     # Close database
     if shared_state.db_manager:
-        await shared_state.db_manager.close()
+        try:
+            await shared_state.db_manager.close()
+            logger.info("✅ Database manager closed")
+        except Exception as e:
+            logger.error(f"❌ Error closing database manager: {e}")
+    
     logger.info("🛑 VibeSurf Backend API stopped")
 
 # Health check endpoint

vibe_surf/backend/shared_state.py

@@ -15,7 +15,8 @@ from pathlib import Path
 
 # VibeSurf components
 from vibe_surf.agents.vibe_surf_agent import VibeSurfAgent
-from vibe_surf.controller.vibesurf_tools import VibeSurfController
+from vibe_surf.tools.browser_use_tools import BrowserUseTools
+from vibe_surf.tools.vibesurf_tools import VibeSurfTools
 from vibe_surf.browser.browser_manager import BrowserManager
 from browser_use.llm.base import BaseChatModel
 from browser_use.llm.openai.chat import ChatOpenAI
@@ -29,7 +30,7 @@ logger = logging.getLogger(__name__)
 # Global VibeSurf components
 vibesurf_agent: Optional[VibeSurfAgent] = None
 browser_manager: Optional[BrowserManager] = None
-controller: Optional[VibeSurfController] = None
+vibesurf_tools: Optional[VibeSurfTools] = None
 llm: Optional[BaseChatModel] = None
 db_manager: Optional['DatabaseManager'] = None
 
@@ -50,10 +51,13 @@ active_task: Optional[Dict[str, Any]] = None
 
 def get_all_components():
     """Get all components as a dictionary"""
+    global vibesurf_agent, browser_manager, vibesurf_tools, llm, db_manager
+    global workspace_dir, browser_execution_path, browser_user_data, active_mcp_server, envs
+
     return {
         "vibesurf_agent": vibesurf_agent,
         "browser_manager": browser_manager,
-        "controller": controller,
+        "tools": vibesurf_tools,
         "llm": llm,
         "db_manager": db_manager,
         "workspace_dir": workspace_dir,
@@ -67,15 +71,15 @@ def get_all_components():
 
 def set_components(**kwargs):
     """Update global components"""
-    global vibesurf_agent, browser_manager, controller, llm, db_manager
+    global vibesurf_agent, browser_manager, vibesurf_tools, llm, db_manager
     global workspace_dir, browser_execution_path, browser_user_data, active_mcp_server, envs
 
     if "vibesurf_agent" in kwargs:
         vibesurf_agent = kwargs["vibesurf_agent"]
     if "browser_manager" in kwargs:
         browser_manager = kwargs["browser_manager"]
-    if "controller" in kwargs:
-        controller = kwargs["controller"]
+    if "tools" in kwargs:
+        vibesurf_tools = kwargs["tools"]
     if "llm" in kwargs:
         llm = kwargs["llm"]
     if "db_manager" in kwargs:
@@ -223,8 +227,8 @@ def clear_active_task():
 
 
 async def _check_and_update_mcp_servers(db_session):
-    """Check if MCP server configuration has changed and update controller if needed"""
-    global controller, active_mcp_server
+    """Check if MCP server configuration has changed and update tools if needed"""
+    global vibesurf_tools, active_mcp_server
 
     try:
         if not db_session:
@@ -238,21 +242,21 @@ async def _check_and_update_mcp_servers(db_session):
 
         # Compare with shared state
         if current_active_servers != active_mcp_server:
-            logger.info(f"MCP server configuration changed. Updating controller...")
+            logger.info(f"MCP server configuration changed. Updating tools...")
             logger.info(f"Old config: {active_mcp_server}")
             logger.info(f"New config: {current_active_servers}")
 
             # Update shared state
             active_mcp_server = current_active_servers.copy()
 
-            # Create new MCP server config for controller
+            # Create new MCP server config for tools
             mcp_server_config = await _build_mcp_server_config(active_profiles)
 
             # Unregister old MCP clients and register new ones
-            if controller:
-                await controller.unregister_mcp_clients()
-                controller.mcp_server_config = mcp_server_config
-                await controller.register_mcp_clients()
+            if vibesurf_tools:
+                await vibesurf_tools.unregister_mcp_clients()
+                vibesurf_tools.mcp_server_config = mcp_server_config
+                await vibesurf_tools.register_mcp_clients()
                 logger.info("✅ Controller MCP configuration updated successfully")
 
     except Exception as e:
@@ -310,25 +314,13 @@ async def _load_active_mcp_servers():
 
 async def initialize_vibesurf_components():
     """Initialize VibeSurf components from environment variables and default LLM profile"""
-    global vibesurf_agent, browser_manager, controller, llm, db_manager
+    global vibesurf_agent, browser_manager, vibesurf_tools, llm, db_manager
     global workspace_dir, browser_execution_path, browser_user_data, envs
+    from vibe_surf import common
 
     try:
         # Load environment variables
-        env_workspace_dir = os.getenv("VIBESURF_WORKSPACE", "")
-        if not env_workspace_dir or not env_workspace_dir.strip():
-            # Set default workspace directory based on OS
-            if platform.system() == "Windows":
-                default_workspace = os.path.join(os.environ.get("APPDATA", ""), "VibeSurf")
-            elif platform.system() == "Darwin":  # macOS
-                default_workspace = os.path.join(os.path.expanduser("~"), "Library", "Application Support", "VibeSurf")
-            else:  # Linux and others
-                default_workspace = os.path.join(os.path.expanduser("~"), ".vibesurf")
-            workspace_dir = default_workspace
-        else:
-            workspace_dir = env_workspace_dir
-        workspace_dir = os.path.abspath(workspace_dir)
-        os.makedirs(workspace_dir, exist_ok=True)
+        workspace_dir = common.get_workspace_dir()
         logger.info("WorkSpace directory: {}".format(workspace_dir))
 
         # Load environment configuration from envs.json
@@ -422,6 +414,8 @@ async def initialize_vibesurf_components():
                 user_data_dir=browser_user_data,
                 headless=False,
                 keep_alive=True,
+                auto_download_pdfs=False,
+                highlight_elements=True,
                 custom_extensions=[envs["VIBESURF_EXTENSION"]],
                 window_size={"width": primary_monitor.width, "height": primary_monitor.height}
             )
@@ -436,19 +430,19 @@ async def initialize_vibesurf_components():
         # Load active MCP servers from database
         mcp_server_config = await _load_active_mcp_servers()
 
-        # Initialize vibesurf controller with MCP server config
-        controller = VibeSurfController(mcp_server_config=mcp_server_config)
+        # Initialize vibesurf tools with MCP server config
+        vibesurf_tools = VibeSurfTools(mcp_server_config=mcp_server_config)
 
         # Register MCP clients if there are any active MCP servers
         if mcp_server_config and mcp_server_config.get("mcpServers"):
-            await controller.register_mcp_clients()
+            await vibesurf_tools.register_mcp_clients()
             logger.info(f"✅ Registered {len(mcp_server_config['mcpServers'])} MCP servers")
 
         # Initialize VibeSurfAgent
         vibesurf_agent = VibeSurfAgent(
             llm=llm,
             browser_manager=browser_manager,
-            controller=controller,
+            tools=vibesurf_tools,
             workspace_dir=workspace_dir
         )
 
@@ -530,8 +524,9 @@ async def update_llm_from_profile(profile_name: str):
 
                 # Update global state
                 llm = new_llm
-                if vibesurf_agent:
-                    vibesurf_agent.llm = new_llm
+                if vibesurf_agent and vibesurf_agent.token_cost_service:
+                    # FIX: Register new LLM with token cost service to maintain tracking
+                    vibesurf_agent.llm = vibesurf_agent.token_cost_service.register_llm(new_llm)
 
                 logger.info(f"✅ LLM updated to profile: {profile_name}")
                 return True

vibe_surf/backend/utils/encryption.py

@@ -15,7 +15,9 @@ from getmac import get_mac_address
 
 import logging
 
-logger = logging.getLogger(__name__)
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 def derive_key(machine_id: str, salt: bytes = None) -> bytes:

vibe_surf/backend/utils/llm_factory.py

@@ -6,26 +6,29 @@ from typing import Optional
 import logging
 from ..llm_config import get_supported_providers, is_provider_supported
 
-logger = logging.getLogger(__name__)
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__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, 
+            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
@@ -36,11 +39,11 @@ def create_llm_from_profile(llm_profile):
         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()}")
-        
+
         # Define provider-specific parameter support
         provider_param_support = {
             "openai": ["temperature"],
@@ -55,11 +58,11 @@ def create_llm_from_profile(llm_profile):
             "anthropic_bedrock": ["temperature"],
             "openai_compatible": ["temperature"]
         }
-        
+
         # Build common parameters based on provider support
         supported_params = provider_param_support.get(provider, [])
         common_params = {}
-        
+
         if temperature is not None and "temperature" in supported_params:
             common_params["temperature"] = temperature
         if max_tokens is not None and "max_tokens" in supported_params:
@@ -70,11 +73,11 @@ def create_llm_from_profile(llm_profile):
             common_params["frequency_penalty"] = frequency_penalty
         if seed is not None and "seed" in supported_params:
             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 = {
@@ -85,21 +88,21 @@ def create_llm_from_profile(llm_profile):
             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)")
@@ -110,14 +113,14 @@ def create_llm_from_profile(llm_profile):
                 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,
@@ -128,21 +131,21 @@ def create_llm_from_profile(llm_profile):
             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,
@@ -157,7 +160,7 @@ def create_llm_from_profile(llm_profile):
             if 'aws_region' not in params:
                 params["aws_region"] = "us-east-1"
             return ChatAWSBedrock(**params)
-        
+
         elif provider == "anthropic_bedrock":
             params = {
                 "model": model,
@@ -170,7 +173,7 @@ def create_llm_from_profile(llm_profile):
             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")
@@ -180,61 +183,63 @@ def create_llm_from_profile(llm_profile):
                 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,