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

vibe_surf/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.9a6'
-__version_tuple__ = version_tuple = (0, 1, 9, 'a6')
+__version__ = version = '0.1.10'
+__version_tuple__ = version_tuple = (0, 1, 10)
 
 __commit_id__ = commit_id = None

vibe_surf/agents/vibe_surf_agent.py

@@ -473,7 +473,12 @@ async def _supervisor_agent_node_impl(state: VibeSurfState) -> VibeSurfState:
     browser_tabs_md = format_browser_tabs(browser_tabs)
     if browser_tabs_md:
         supervisor_message_history.append(UserMessage(
-            content=f"Available Browser Tabs:\n{browser_tabs_md}"))
+            content=f"Available Browser Tabs:\n{browser_tabs_md}\n"))
+    active_browser_tab = await state.browser_manager.get_activate_tab()
+    if active_browser_tab:
+        active_tab_md = f"Page Title: {active_browser_tab.title}, Page Url: {active_browser_tab.url}, Page ID: {active_browser_tab.target_id}"
+        supervisor_message_history.append(UserMessage(
+            content=f"Current Active Browser Tab:\n{active_tab_md}\n"))
 
     # Reset prev_browser_results
     state.prev_browser_results = []
@@ -536,23 +541,28 @@ async def _supervisor_agent_node_impl(state: VibeSurfState) -> VibeSurfState:
             if tasks_to_execute:
                 tasks_to_execute_new = []
                 todo_indices = []  # Track which todo items are being executed
-                
                 for task_item in tasks_to_execute:
                     if isinstance(task_item, list):
                         # Format: [page_index, todo_index]
                         page_index, todo_index = task_item
-                        if todo_index < len(state.todo_list):
-                            task_description = state.todo_list[todo_index].task
-                            tasks_to_execute_new.append([browser_tabs[page_index].target_id, task_description])
-                            todo_indices.append(todo_index)
+                        if isinstance(todo_index, int):
+                            if todo_index < len(state.todo_list):
+                                task_description = state.todo_list[todo_index].task
+                                tasks_to_execute_new.append([browser_tabs[page_index].target_id, task_description])
+                                todo_indices.append(todo_index)
+                        elif isinstance(todo_index, str):
+                            tasks_to_execute_new.append([browser_tabs[page_index].target_id, todo_index])
                     else:
                         # Format: todo_index
                         todo_index = task_item
-                        if todo_index < len(state.todo_list):
-                            task_description = state.todo_list[todo_index].task
-                            tasks_to_execute_new.append(task_description)
-                            todo_indices.append(todo_index)
-                
+                        if isinstance(todo_index, int):
+                            if todo_index < len(state.todo_list):
+                                task_description = state.todo_list[todo_index].task
+                                tasks_to_execute_new.append(task_description)
+                                todo_indices.append(todo_index)
+                        elif isinstance(todo_index, str):
+                            tasks_to_execute_new.append(todo_index)
+                logger.info(f"tasks_to_execute: {tasks_to_execute}")
                 state.execution_mode = ExecutionMode(
                     mode=task_type,
                     reason=reasoning
@@ -795,7 +805,7 @@ async def execute_parallel_browser_tasks(state: VibeSurfState) -> List[BrowserTa
                 browser_session=agent_browser_sessions[i],
                 controller=state.vibesurf_controller,
                 task_id=f"{state.task_id}-{i + 1}",
-                file_system_path=state.task_dir,
+                file_system_path=os.path.join(state.task_dir, f"{state.task_id}-{i + 1}"),
                 register_new_step_callback=step_callback,
                 extend_system_message="Please make sure the language of your output in JSON value should remain the same as the user's request or task.",
             )
@@ -867,17 +877,17 @@ async def execute_single_browser_tasks(state: VibeSurfState) -> List[BrowserTask
     for i, task in enumerate(state.pending_tasks):
         if isinstance(task, list):
             target_id, task_description = task
+            await state.browser_manager.main_browser_session.get_or_create_cdp_session(target_id, focus=True)
         else:
             task_description = task
+            await state.browser_manager.get_activate_tab()
         logger.info(f"🔄 Executing task ({i + 1}/{len(state.pending_tasks)}): {task_description}")
 
         agent_id = f"agent-single-{state.task_id[-4:]}-{i}"
 
         # Log agent activity
         log_agent_activity(state, f"browser_use_agent-{state.task_id[-4:]}", "working", f"{task_description}")
-
         try:
-            await state.browser_manager._get_active_target()
             if state.upload_files:
                 upload_files_md = format_upload_files_list(state.upload_files)
                 bu_task = task_description + f"\nAvailable user uploaded files:\n{upload_files_md}\n"
@@ -893,7 +903,7 @@ async def execute_single_browser_tasks(state: VibeSurfState) -> List[BrowserTask
                 browser_session=state.browser_manager.main_browser_session,
                 controller=state.vibesurf_controller,
                 task_id=f"{state.task_id}-{i}",
-                file_system_path=state.task_dir,
+                file_system_path=os.path.join(state.task_dir, f"{state.task_id}-{i}"),
                 register_new_step_callback=step_callback,
                 extend_system_message="Please make sure the language of your output in JSON values should remain the same as the user's request or task."
             )

vibe_surf/backend/api/browser.py

@@ -0,0 +1,66 @@
+"""
+Browser Tabs Router
+
+Handles retrieval of browser tab information including active tab and all tabs.
+"""
+
+from fastapi import APIRouter, HTTPException
+from typing import Dict, Any, Optional
+import logging
+
+# Import global variables from shared_state
+from ..shared_state import browser_manager
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/browser", tags=["browser"])
+
+
+@router.get("/active-tab")
+async def get_active_tab() -> Dict[str, Dict[str, str]]:
+    """Get the current active tab information"""
+    if not browser_manager:
+        raise HTTPException(status_code=503, detail="Browser manager not initialized")
+
+    try:
+        # Get active tab info using browser manager
+        active_tab_info = await browser_manager.get_activate_tab()
+
+        if not active_tab_info:
+            return {}
+
+        # Return dict format: {tab_id: {url: , title: }}
+        return {
+            active_tab_info.target_id: {
+                "url": active_tab_info.url,
+                "title": active_tab_info.title
+            }
+        }
+
+    except Exception as e:
+        logger.error(f"Failed to get active tab: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get active tab: {str(e)}")
+
+
+@router.get("/all-tabs")
+async def get_all_tabs() -> Dict[str, Dict[str, str]]:
+    """Get all browser tabs information"""
+    if not browser_manager:
+        raise HTTPException(status_code=503, detail="Browser manager not initialized")
+
+    try:
+        all_tab_infos = await browser_manager.get_all_tabs()
+
+        # Filter only page targets and build result dict
+        result = {}
+        for tab_info in all_tab_infos:
+            result[tab_info.target_id] = {
+                "url": tab_info.url,
+                "title": tab_info.title
+            }
+
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to get all tabs: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to get all tabs: {str(e)}")

vibe_surf/backend/api/task.py

@@ -21,7 +21,8 @@ from ..shared_state import (
     execute_task_background,
     is_task_running,
     get_active_task_info,
-    clear_active_task
+    clear_active_task,
+    browser_manager
 )
 
 logger = logging.getLogger(__name__)

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,6 +19,7 @@ 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
@@ -46,18 +48,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 +140,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

@@ -422,6 +422,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}
             )