vibesurf 0.1.32__py3-none-any.whl → 0.1.34__py3-none-any.whl

vibe_surf/chrome_extension/styles/settings-modal.css

@@ -58,12 +58,12 @@
   display: flex;
   background: var(--bg-secondary);
   border-bottom: 1px solid var(--border-color);
-  overflow-x: auto;
+  overflow: visible;
 }
 
 .settings-tab {
   flex: 1;
-  padding: 16px 24px;
+  padding: 16px 8px;
   border: none;
   background: transparent;
   color: var(--text-secondary);
@@ -73,7 +73,11 @@
   transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
   position: relative;
   white-space: nowrap;
-  min-width: 150px;
+  min-width: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  text-align: center;
 }
 
 .settings-tab::before {

vibe_surf/chrome_extension/styles/settings-responsive.css

@@ -17,9 +17,9 @@
   }
   
   .settings-tab {
-    padding: 14px 20px;
+    padding: 14px 6px;
     font-size: 14px;
-    min-width: 120px;
+    min-width: 0;
   }
   
   .settings-tab-content {
@@ -80,9 +80,41 @@
   }
   
   .settings-tab {
-    padding: 12px 16px;
-    font-size: 13px;
-    min-width: 100px;
+    padding: 12px 4px;
+    font-size: 12px;
+    min-width: 0;
+    writing-mode: horizontal-tb;
+  }
+  
+  /* Make tabs even more compact for very narrow screens */
+  @media (max-width: 400px) {
+    .settings-tab {
+      padding: 10px 2px;
+      font-size: 11px;
+      line-height: 1.2;
+    }
+    
+    .settings-tab svg {
+      display: none; /* Hide icons on very small screens */
+    }
+  }
+  
+  /* Ultra narrow screens - consider vertical text */
+  @media (max-width: 350px) {
+    .settings-tabs {
+      flex-wrap: wrap;
+      height: auto;
+    }
+    
+    .settings-tab {
+      writing-mode: vertical-rl;
+      text-orientation: mixed;
+      padding: 8px 4px;
+      min-height: 60px;
+      width: calc(20% - 2px);
+      font-size: 10px;
+      line-height: 1.1;
+    }
   }
   
   .settings-tab-content {

vibe_surf/cli.py

@@ -10,6 +10,7 @@ import glob
 import json
 import socket
 import platform
+import time
 import importlib.util
 from pathlib import Path
 from typing import Optional
@@ -39,6 +40,9 @@ console = Console()
 
 # Add logger import for the workspace directory logging
 from vibe_surf.logger import get_logger
+from vibe_surf.telemetry.service import ProductTelemetry
+from vibe_surf.telemetry.views import CLITelemetryEvent
+
 logger = get_logger(__name__)
 
 
@@ -118,6 +122,35 @@ def find_edge_browser() -> Optional[str]:
     return _find_browser_from_patterns(patterns)
 
 
+def find_brave_browser() -> Optional[str]:
+    """Find Brave browser executable."""
+    system = platform.system()
+    patterns = []
+
+    if system == 'Darwin':  # macOS
+        patterns = [
+            '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+        ]
+    elif system == 'Linux':
+        patterns = [
+            '/usr/bin/brave-browser',
+            '/usr/bin/brave',
+            '/usr/local/bin/brave',
+            '/snap/bin/brave',
+            '/usr/bin/brave-browser-stable',
+            '/usr/bin/brave-browser-beta',
+            '/usr/bin/brave-browser-dev',
+        ]
+    elif system == 'Windows':
+        patterns = [
+            r'C:\Program Files\BraveSoftware\Brave-Browser\Application\brave.exe',
+            r'C:\Program Files (x86)\BraveSoftware\Brave-Browser\Application\brave.exe',
+            r'%LOCALAPPDATA%\BraveSoftware\Brave-Browser\Application\brave.exe',
+        ]
+
+    return _find_browser_from_patterns(patterns)
+
+
 def _find_browser_from_patterns(patterns: list[str]) -> Optional[str]:
     """Helper function to find browser from patterns."""
     system = platform.system()
@@ -182,7 +215,7 @@ def find_available_port(start_port: int) -> int:
 def select_browser() -> Optional[str]:
     """Interactive browser selection."""
     console.print("\n[bold cyan]🌐 Browser Selection[/bold cyan]")
-    console.print("VibeSurf supports Chrome and Edge browsers.\n")
+    console.print("VibeSurf supports Chrome, Edge, and Brave browsers.\n")
     
     options = []
     browsers = {}
@@ -197,11 +230,19 @@ def select_browser() -> Optional[str]:
     # Check for Edge
     edge_path = find_edge_browser()
     if edge_path:
-        option_num = "2" if "1" not in options else "1" if not chrome_path else "2"
+        option_num = str(len(options) + 1)
         options.append(option_num)
         browsers[option_num] = ("Edge", edge_path)
         console.print(f"[green]{option_num}.[/green] Microsoft Edge ([dim]{edge_path}[/dim])")
     
+    # Check for Brave
+    brave_path = find_brave_browser()
+    if brave_path:
+        option_num = str(len(options) + 1)
+        options.append(option_num)
+        browsers[option_num] = ("Brave", brave_path)
+        console.print(f"[green]{option_num}.[/green] Brave Browser ([dim]{brave_path}[/dim])")
+    
     # Custom browser option
     custom_option = str(len(options) + 1)
     options.append(custom_option)
@@ -212,7 +253,7 @@ def select_browser() -> Optional[str]:
     options.append(quit_option)
     console.print(f"[red]{quit_option}.[/red] Quit")
     
-    if not chrome_path and not edge_path:
+    if not chrome_path and not edge_path and not brave_path:
         console.print("\n[yellow]⚠️  No supported browsers found automatically.[/yellow]")
     
     while True:
@@ -377,6 +418,10 @@ def get_browser_execution_path() -> Optional[str]:
 def main():
     """Main CLI entry point."""
     try:
+        # Initialize telemetry
+        telemetry = ProductTelemetry()
+        start_time = time.time()
+        
         # Display logo
         console.print(Panel(VIBESURF_LOGO, title="[bold cyan]VibeSurf CLI[/bold cyan]", border_style="cyan"))
         console.print("[dim]A powerful browser automation tool for vibe surfing 🏄‍♂️[/dim]")
@@ -384,6 +429,14 @@ def main():
         console.print(f"[dim]Version: {vibe_surf.__version__}[/dim]\n")
         console.print(f"[dim]Author: WarmShao and Community Contributors [/dim]\n")
         
+        # Capture telemetry start event
+        start_event = CLITelemetryEvent(
+            version=vibe_surf.__version__,
+            action='start',
+            mode='interactive'
+        )
+        telemetry.capture(start_event)
+        
         # Check for existing browser path from configuration
         browser_path = get_browser_execution_path()
         
@@ -405,10 +458,52 @@ def main():
         # Start backend
         start_backend(port)
         
+        # Capture telemetry completion event
+        end_time = time.time()
+        duration = end_time - start_time
+        completion_event = CLITelemetryEvent(
+            version=vibe_surf.__version__,
+            action='startup_completed',
+            mode='interactive',
+            duration_seconds=duration,
+            browser_path=browser_path
+        )
+        telemetry.capture(completion_event)
+        telemetry.flush()
+        
     except KeyboardInterrupt:
         console.print("\n[yellow]👋 Goodbye![/yellow]")
+        # Capture telemetry interruption event
+        try:
+            end_time = time.time()
+            duration = end_time - start_time
+            interrupt_event = CLITelemetryEvent(
+                version=vibe_surf.__version__,
+                action='interrupted',
+                mode='interactive',
+                duration_seconds=duration
+            )
+            telemetry.capture(interrupt_event)
+            telemetry.flush()
+        except:
+            pass
     except Exception as e:
         console.print(f"\n[red]❌ Unexpected error: {e}[/red]")
+        # Capture telemetry error event
+        try:
+            end_time = time.time()
+            duration = end_time - start_time
+            error_event = CLITelemetryEvent(
+                version=vibe_surf.__version__,
+                action='error',
+                mode='interactive',
+                duration_seconds=duration,
+                error_message=str(e)[:200]
+            )
+            telemetry.capture(error_event)
+            telemetry.flush()
+        except:
+            pass
         sys.exit(1)
 
 

vibe_surf/telemetry/__init__.py

@@ -0,0 +1,60 @@
+"""
+Telemetry for VibeSurf.
+"""
+
+from typing import TYPE_CHECKING
+
+# Type stubs for lazy imports
+if TYPE_CHECKING:
+    from vibe_surf.telemetry.service import ProductTelemetry
+    from vibe_surf.telemetry.views import (
+        BaseTelemetryEvent,
+        CLITelemetryEvent,
+        MCPClientTelemetryEvent,
+        MCPServerTelemetryEvent,
+        VibeSurfAgentTelemetryEvent,
+        ReportWriterTelemetryEvent,
+        BackendTelemetryEvent,
+    )
+
+# Lazy imports mapping
+_LAZY_IMPORTS = {
+    'ProductTelemetry': ('vibe_surf.telemetry.service', 'ProductTelemetry'),
+    'BaseTelemetryEvent': ('vibe_surf.telemetry.views', 'BaseTelemetryEvent'),
+    'CLITelemetryEvent': ('vibe_surf.telemetry.views', 'CLITelemetryEvent'),
+    'MCPClientTelemetryEvent': ('vibe_surf.telemetry.views', 'MCPClientTelemetryEvent'),
+    'MCPServerTelemetryEvent': ('vibe_surf.telemetry.views', 'MCPServerTelemetryEvent'),
+    'VibeSurfAgentTelemetryEvent': ('vibe_surf.telemetry.views', 'VibeSurfAgentTelemetryEvent'),
+    'ReportWriterTelemetryEvent': ('vibe_surf.telemetry.views', 'ReportWriterTelemetryEvent'),
+    'BackendTelemetryEvent': ('vibe_surf.telemetry.views', 'BackendTelemetryEvent'),
+}
+
+
+def __getattr__(name: str):
+    """Lazy import mechanism for telemetry components."""
+    if name in _LAZY_IMPORTS:
+        module_path, attr_name = _LAZY_IMPORTS[name]
+        try:
+            from importlib import import_module
+
+            module = import_module(module_path)
+            attr = getattr(module, attr_name)
+            # Cache the imported attribute in the module's globals
+            globals()[name] = attr
+            return attr
+        except ImportError as e:
+            raise ImportError(f'Failed to import {name} from {module_path}: {e}') from e
+
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
+__all__ = [
+    'BaseTelemetryEvent',
+    'ProductTelemetry',
+    'CLITelemetryEvent',
+    'MCPClientTelemetryEvent',
+    'MCPServerTelemetryEvent',
+    'VibeSurfAgentTelemetryEvent',
+    'ReportWriterTelemetryEvent',
+    'BackendTelemetryEvent',
+]

vibe_surf/telemetry/service.py

@@ -0,0 +1,112 @@
+import logging
+import os
+import pdb
+
+from dotenv import load_dotenv
+from posthog import Posthog
+from uuid_extensions import uuid7str
+
+from vibe_surf.telemetry.views import BaseTelemetryEvent
+from vibe_surf.utils import singleton
+from vibe_surf.logger import get_logger
+
+load_dotenv()
+
+logger = get_logger(__name__)
+
+POSTHOG_EVENT_SETTINGS = {
+    'process_person_profile': True,
+}
+
+
+@singleton
+class ProductTelemetry:
+    """
+    Service for capturing anonymized telemetry data.
+
+    If the environment variable `ANONYMIZED_TELEMETRY=False`, anonymized telemetry will be disabled.
+    """
+    WORKSPACE_DIR = os.getenv('VIBESURF_WORKSPACE', './vibesurf_workspace')
+    USER_ID_PATH = os.path.join(WORKSPACE_DIR, 'telemetry', 'userid')
+    PROJECT_API_KEY = 'phc_lCYnQqFlfNHAlh1TJGqaTvD8EFPCKR7ONsEHbbWuPVr'
+    HOST = 'https://us.i.posthog.com'
+    UNKNOWN_USER_ID = 'UNKNOWN'
+
+    _curr_user_id = None
+
+    def __init__(self) -> None:
+        telemetry_enabled = os.getenv('VIBESURF_ANONYMIZED_TELEMETRY', 'true').lower() in ("true", "1", "yes", "on")
+        self.debug_logging = os.getenv("VIBESURF_DEBUG", "false").lower() in ("true", "1", "yes", "on")
+
+        telemetry_disabled = not telemetry_enabled
+
+        if telemetry_disabled:
+            self._posthog_client = None
+        else:
+            self._posthog_client = Posthog(
+                project_api_key=self.PROJECT_API_KEY,
+                host=self.HOST,
+                disable_geoip=False,
+                enable_exception_autocapture=True,
+            )
+
+            # Silence posthog's logging
+            if not self.debug_logging:
+                posthog_logger = logging.getLogger('posthog')
+                posthog_logger.disabled = True
+
+        if self._posthog_client is None:
+            logger.debug('Telemetry disabled')
+
+    def capture(self, event: BaseTelemetryEvent) -> None:
+        if self._posthog_client is None:
+            return
+
+        self._direct_capture(event)
+
+    def _direct_capture(self, event: BaseTelemetryEvent) -> None:
+        """
+        Should not be thread blocking because posthog magically handles it
+        """
+        if self._posthog_client is None:
+            return
+
+        try:
+            self._posthog_client.capture(
+                distinct_id=self.user_id,
+                event=event.name,
+                properties={**event.properties, **POSTHOG_EVENT_SETTINGS},
+            )
+        except Exception as e:
+            logger.error(f'Failed to send telemetry event {event.name}: {e}')
+
+    def flush(self) -> None:
+        if self._posthog_client:
+            try:
+                self._posthog_client.flush()
+                logger.debug('PostHog client telemetry queue flushed.')
+            except Exception as e:
+                logger.error(f'Failed to flush PostHog client: {e}')
+        else:
+            logger.debug('PostHog client not available, skipping flush.')
+
+    @property
+    def user_id(self) -> str:
+        if self._curr_user_id:
+            return self._curr_user_id
+
+        # File access may fail due to permissions or other reasons. We don't want to
+        # crash so we catch all exceptions.
+        try:
+            if not os.path.exists(self.USER_ID_PATH):
+                os.makedirs(os.path.dirname(self.USER_ID_PATH), exist_ok=True)
+                with open(self.USER_ID_PATH, 'w') as f:
+                    new_user_id = uuid7str()
+                    f.write(new_user_id)
+                self._curr_user_id = new_user_id
+            else:
+                with open(self.USER_ID_PATH) as f:
+                    self._curr_user_id = f.read()
+        except Exception:
+            self._curr_user_id = 'UNKNOWN_USER_ID'
+        return self._curr_user_id

vibe_surf/telemetry/views.py

@@ -0,0 +1,156 @@
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from dataclasses import asdict, dataclass
+from typing import Any
+
+from browser_use.config import is_running_in_docker
+
+
+@dataclass
+class BaseTelemetryEvent(ABC):
+	@property
+	@abstractmethod
+	def name(self) -> str:
+		pass
+
+	@property
+	def properties(self) -> dict[str, Any]:
+		props = {k: v for k, v in asdict(self).items() if k != 'name'}
+		# Add Docker context if running in Docker
+		props['is_docker'] = is_running_in_docker()
+		return props
+
+
+@dataclass
+class AgentTelemetryEvent(BaseTelemetryEvent):
+	# start details
+	task: str
+	model: str
+	model_provider: str
+	max_steps: int
+	max_actions_per_step: int
+	use_vision: bool
+	version: str
+	source: str
+	cdp_url: str | None
+	# step details
+	action_errors: Sequence[str | None]
+	action_history: Sequence[list[dict] | None]
+	urls_visited: Sequence[str | None]
+	# end details
+	steps: int
+	total_input_tokens: int
+	total_duration_seconds: float
+	success: bool | None
+	final_result_response: str | None
+	error_message: str | None
+
+	name: str = 'agent_event'
+
+
+@dataclass
+class MCPClientTelemetryEvent(BaseTelemetryEvent):
+	"""Telemetry event for MCP client usage"""
+
+	server_name: str
+	command: str
+	tools_discovered: int
+	version: str
+	action: str  # 'connect', 'disconnect', 'tool_call'
+	tool_name: str | None = None
+	duration_seconds: float | None = None
+	error_message: str | None = None
+
+	name: str = 'mcp_client_event'
+
+
+@dataclass
+class MCPServerTelemetryEvent(BaseTelemetryEvent):
+	"""Telemetry event for MCP server usage"""
+
+	version: str
+	action: str  # 'start', 'stop', 'tool_call'
+	tool_name: str | None = None
+	duration_seconds: float | None = None
+	error_message: str | None = None
+	parent_process_cmdline: str | None = None
+
+	name: str = 'mcp_server_event'
+
+
+@dataclass
+class ComposioTelemetryEvent(BaseTelemetryEvent):
+	"""Telemetry event for Composio client usage"""
+
+	toolkit_slugs: list[str]
+	tools_registered: int
+	version: str
+	action: str  # 'register', 'unregister', 'tool_call'
+	toolkit_slug: str | None = None
+	tool_name: str | None = None
+	duration_seconds: float | None = None
+	error_message: str | None = None
+
+	name: str = 'composio_client_event'
+
+
+@dataclass
+class CLITelemetryEvent(BaseTelemetryEvent):
+	"""Telemetry event for CLI usage"""
+
+	version: str
+	action: str  # 'start', 'message_sent', 'task_completed', 'error'
+	mode: str  # 'interactive', 'oneshot', 'mcp_server'
+	model: str | None = None
+	model_provider: str | None = None
+	browser_path: str | None = None
+	duration_seconds: float | None = None
+	error_message: str | None = None
+
+	name: str = 'cli_event'
+
+
+@dataclass
+class VibeSurfAgentTelemetryEvent(BaseTelemetryEvent):
+	"""Telemetry event for VibeSurf Agent usage"""
+	
+	version: str
+	action: str  # 'start', 'task_completed', 'error'
+	task_description: str | None = None
+	model: str | None = None
+	model_provider: str | None = None
+	duration_seconds: float | None = None
+	success: bool | None = None
+	error_message: str | None = None
+	session_id: str | None = None
+	
+	name: str = 'vibesurf_agent_event'
+
+
+@dataclass
+class ReportWriterTelemetryEvent(BaseTelemetryEvent):
+	"""Telemetry event for Report Writer Agent usage"""
+	
+	version: str
+	action: str  # 'start', 'report_completed', 'error'
+	model: str | None = None
+	model_provider: str | None = None
+	duration_seconds: float | None = None
+	success: bool | None = None
+	error_message: str | None = None
+	report_type: str | None = None
+	
+	name: str = 'report_writer_event'
+
+
+@dataclass
+class BackendTelemetryEvent(BaseTelemetryEvent):
+	"""Telemetry event for Backend API usage"""
+	
+	version: str
+	action: str  # 'startup', 'shutdown', 'api_call'
+	api_endpoint: str | None = None
+	duration_seconds: float | None = None
+	error_message: str | None = None
+	
+	name: str = 'backend_event'