vibesurf 0.1.20__py3-none-any.whl → 0.1.22__py3-none-any.whl

vibe_surf/backend/database/queries.py

@@ -8,7 +8,7 @@ from typing import List, Optional, Dict, Any
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select, update, delete, func, desc, and_, or_
 from sqlalchemy.orm import selectinload
-from .models import Task, TaskStatus, LLMProfile, UploadedFile, McpProfile
+from .models import Task, TaskStatus, LLMProfile, UploadedFile, McpProfile, VoiceProfile, VoiceModelType
 from ..utils.encryption import encrypt_api_key, decrypt_api_key
 import logging
 import json
@@ -929,3 +929,191 @@ class UploadedFileQueries:
         except Exception as e:
             logger.error(f"Failed to cleanup deleted files: {e}")
             raise
+
+
+class VoiceProfileQueries:
+    """Query operations for VoiceProfile model"""
+
+    @staticmethod
+    async def create_profile(
+            db: AsyncSession,
+            voice_profile_name: str,
+            voice_model_type: str,
+            voice_model_name: str,
+            api_key: Optional[str] = None,
+            voice_meta_params: Optional[Dict[str, Any]] = None,
+            description: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Create a new Voice profile with encrypted API key"""
+        try:
+            # Encrypt API key if provided
+            encrypted_api_key = encrypt_api_key(api_key) if api_key else None
+
+            profile = VoiceProfile(
+                voice_profile_name=voice_profile_name,
+                voice_model_type=VoiceModelType(voice_model_type),
+                voice_model_name=voice_model_name,
+                encrypted_api_key=encrypted_api_key,
+                voice_meta_params=voice_meta_params or {},
+                description=description
+            )
+
+            db.add(profile)
+            await db.flush()
+            await db.refresh(profile)
+
+            # Extract data immediately to avoid greenlet issues
+            profile_data = {
+                "profile_id": profile.profile_id,
+                "voice_profile_name": profile.voice_profile_name,
+                "voice_model_type": profile.voice_model_type.value,
+                "voice_model_name": profile.voice_model_name,
+                "voice_meta_params": profile.voice_meta_params,
+                "description": profile.description,
+                "is_active": profile.is_active,
+                "created_at": profile.created_at,
+                "updated_at": profile.updated_at,
+                "last_used_at": profile.last_used_at
+            }
+
+            return profile_data
+        except Exception as e:
+            logger.error(f"Failed to create Voice profile {voice_profile_name}: {e}")
+            raise
+
+    @staticmethod
+    async def get_profile(db: AsyncSession, voice_profile_name: str) -> Optional[VoiceProfile]:
+        """Get Voice profile by name"""
+        try:
+            result = await db.execute(
+                select(VoiceProfile).where(VoiceProfile.voice_profile_name == voice_profile_name)
+            )
+            profile = result.scalar_one_or_none()
+            if profile:
+                # Ensure all attributes are loaded by accessing them
+                _ = (profile.profile_id, profile.created_at, profile.updated_at,
+                     profile.last_used_at, profile.is_active)
+            return profile
+        except Exception as e:
+            logger.error(f"Failed to get Voice profile {voice_profile_name}: {e}")
+            raise
+
+    @staticmethod
+    async def get_profile_with_decrypted_key(db: AsyncSession, voice_profile_name: str) -> Optional[Dict[str, Any]]:
+        """Get Voice profile with decrypted API key"""
+        try:
+            profile = await VoiceProfileQueries.get_profile(db, voice_profile_name)
+            if not profile:
+                return None
+
+            # Decrypt API key
+            decrypted_api_key = decrypt_api_key(profile.encrypted_api_key) if profile.encrypted_api_key else None
+
+            return {
+                "profile_id": profile.profile_id,
+                "voice_profile_name": profile.voice_profile_name,
+                "voice_model_type": profile.voice_model_type.value,
+                "voice_model_name": profile.voice_model_name,
+                "api_key": decrypted_api_key,  # Decrypted for use
+                "voice_meta_params": profile.voice_meta_params,
+                "description": profile.description,
+                "is_active": profile.is_active,
+                "created_at": profile.created_at,
+                "updated_at": profile.updated_at,
+                "last_used_at": profile.last_used_at
+            }
+        except Exception as e:
+            logger.error(f"Failed to get Voice profile with decrypted key {voice_profile_name}: {e}")
+            raise
+
+    @staticmethod
+    async def list_profiles(
+            db: AsyncSession,
+            voice_model_type: Optional[str] = None,
+            active_only: bool = True,
+            limit: int = 50,
+            offset: int = 0
+    ) -> List[VoiceProfile]:
+        """List Voice profiles"""
+        try:
+            query = select(VoiceProfile)
+
+            if active_only:
+                query = query.where(VoiceProfile.is_active == True)
+            
+            if voice_model_type:
+                query = query.where(VoiceProfile.voice_model_type == VoiceModelType(voice_model_type))
+
+            query = query.order_by(desc(VoiceProfile.last_used_at), desc(VoiceProfile.created_at))
+            query = query.limit(limit).offset(offset)
+
+            result = await db.execute(query)
+            profiles = result.scalars().all()
+
+            # Ensure all attributes are loaded for each profile
+            for profile in profiles:
+                _ = (profile.profile_id, profile.created_at, profile.updated_at,
+                     profile.last_used_at, profile.is_active)
+
+            return profiles
+        except Exception as e:
+            logger.error(f"Failed to list Voice profiles: {e}")
+            raise
+
+    @staticmethod
+    async def update_profile(
+            db: AsyncSession,
+            voice_profile_name: str,
+            updates: Dict[str, Any]
+    ) -> bool:
+        """Update Voice profile"""
+        try:
+            # Handle API key encryption if present
+            if "api_key" in updates:
+                api_key = updates.pop("api_key")
+                if api_key:
+                    updates["encrypted_api_key"] = encrypt_api_key(api_key)
+                else:
+                    updates["encrypted_api_key"] = None
+
+            # Handle voice_model_type enum conversion
+            if "voice_model_type" in updates:
+                updates["voice_model_type"] = VoiceModelType(updates["voice_model_type"])
+
+            result = await db.execute(
+                update(VoiceProfile)
+                .where(VoiceProfile.voice_profile_name == voice_profile_name)
+                .values(**updates)
+            )
+
+            return result.rowcount > 0
+        except Exception as e:
+            logger.error(f"Failed to update Voice profile {voice_profile_name}: {e}")
+            raise
+
+    @staticmethod
+    async def delete_profile(db: AsyncSession, voice_profile_name: str) -> bool:
+        """Delete Voice profile"""
+        try:
+            result = await db.execute(
+                delete(VoiceProfile).where(VoiceProfile.voice_profile_name == voice_profile_name)
+            )
+            return result.rowcount > 0
+        except Exception as e:
+            logger.error(f"Failed to delete Voice profile {voice_profile_name}: {e}")
+            raise
+
+
+    @staticmethod
+    async def update_last_used(db: AsyncSession, voice_profile_name: str) -> bool:
+        """Update the last_used_at timestamp for a profile"""
+        try:
+            result = await db.execute(
+                update(VoiceProfile)
+                .where(VoiceProfile.voice_profile_name == voice_profile_name)
+                .values(last_used_at=func.now())
+            )
+            return result.rowcount > 0
+        except Exception as e:
+            logger.error(f"Failed to update last_used for Voice profile {voice_profile_name}: {e}")
+            raise

vibe_surf/backend/main.py

@@ -20,6 +20,7 @@ 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
+from .api.voices import router as voices_router
 
 # Import shared state
 from . import shared_state
@@ -51,6 +52,7 @@ 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"])
+app.include_router(voices_router, prefix="/api", tags=["voices"])
 
 # Global variable to control browser monitoring task
 browser_monitor_task = None

vibe_surf/backend/shared_state.py

@@ -174,7 +174,7 @@ async def execute_task_background(
                     db_session,
                     task_id=task_id,
                     task_result=result,
-                    task_status=active_task.get("status", "completed"),
+                    task_status=active_task.get("status", "completed") if active_task else "completed",
                     report_path=report_path
                 )
                 await db_session.commit()

vibe_surf/backend/voice_model_config.py

@@ -0,0 +1,25 @@
+"""
+Voice Model Configuration
+
+Centralized configuration for all supported voice providers and their models.
+"""
+
+# Voice Providers and their supported models
+VOICE_MODELS = {
+    "qwen-asr": {
+        "model_type": "asr",
+        "requires_api_key": True,
+        "provider": "qwen",
+    },
+    "openai-asr": {
+        "model_type": "asr",
+        "requires_api_key": True,
+        "provider": "openai",
+        "supports_base_url": True,
+    },
+    "gemini-asr": {
+        "model_type": "asr",
+        "requires_api_key": True,
+        "provider": "gemini",
+    }
+}

vibe_surf/browser/agen_browser_profile.py

@@ -17,6 +17,8 @@ from browser_use.observability import observe_debug
 from browser_use.utils import _log_pretty_path, logger
 
 from browser_use.browser import BrowserProfile
+from browser_use.browser.profile import CHROME_DEFAULT_ARGS, CHROME_DOCKER_ARGS, CHROME_HEADLESS_ARGS, \
+    CHROME_DETERMINISTIC_RENDERING_ARGS, CHROME_DISABLE_SECURITY_ARGS, BrowserLaunchArgs
 
 
 class AgentBrowserProfile(BrowserProfile):

vibe_surf/browser/agent_browser_session.py

@@ -43,6 +43,7 @@ from browser_use.browser.events import (
     TabClosedEvent,
     TabCreatedEvent,
 )
+from browser_use.browser.profile import BrowserProfile, ProxySettings
 
 DEFAULT_BROWSER_PROFILE = AgentBrowserProfile()
 
@@ -94,7 +95,7 @@ class AgentBrowserSession(BrowserSession):
             deterministic_rendering: bool | None = None,
             allowed_domains: list[str] | None = None,
             keep_alive: bool | None = None,
-            proxy: any | None = None,
+            proxy: ProxySettings | None = None,
             enable_default_extensions: bool | None = None,
             window_size: dict | None = None,
             window_position: dict | None = None,
@@ -428,9 +429,9 @@ class AgentBrowserSession(BrowserSession):
         self._popups_watchdog.attach_to_session()
 
         # Initialize PermissionsWatchdog (handles granting and revoking browser permissions like clipboard, microphone, camera, etc.)
-        PermissionsWatchdog.model_rebuild()
-        self._permissions_watchdog = PermissionsWatchdog(event_bus=self.event_bus, browser_session=self)
-        self._permissions_watchdog.attach_to_session()
+        # PermissionsWatchdog.model_rebuild()
+        # self._permissions_watchdog = PermissionsWatchdog(event_bus=self.event_bus, browser_session=self)
+        # self._permissions_watchdog.attach_to_session()
 
         # Initialize DefaultActionWatchdog (handles all default actions like click, type, scroll, go back, go forward, refresh, wait, send keys, upload file, scroll to text, etc.)
         CustomActionWatchdog.model_rebuild()

vibe_surf/chrome_extension/background.js

@@ -135,12 +135,17 @@ class VibeSurfBackground {
       console.error('[VibeSurf] Failed to open side panel:', error);
       
       // Show notification with helpful message
-      await chrome.notifications.create({
-        type: 'basic',
-        iconUrl: chrome.runtime.getURL('icons/icon48.png') || '',
-        title: 'VibeSurf',
-        message: 'Side panel failed. Please update Chrome to the latest version or try right-clicking the extension icon.'
-      });
+      try {
+        await chrome.notifications.create({
+          type: 'basic',
+          iconUrl: '', // Use empty string to avoid icon issues
+          title: 'VibeSurf',
+          message: 'Side panel failed. Please update Chrome to the latest version or try right-clicking the extension icon.'
+        });
+      } catch (notifError) {
+        console.warn('[VibeSurf] Notification failed:', notifError);
+        // Don't throw, just log the warning
+      }
       
       // Fallback: try to open in new tab
       try {
@@ -155,12 +160,14 @@ class VibeSurfBackground {
   }
 
   handleMessage(message, sender, sendResponse) {
+    console.log('[VibeSurf] Received message:', message.type);
     
     // Handle async messages properly
     (async () => {
       try {
         let result;
         
+        console.log('[VibeSurf] Processing message type:', message.type);
         switch (message.type) {
           case 'GET_CURRENT_TAB':
             result = await this.getCurrentTabInfo();
@@ -206,9 +213,56 @@ class VibeSurfBackground {
             result = await this.getAllTabs();
             break;
             
+          case 'REQUEST_MICROPHONE_PERMISSION':
+            result = await this.requestMicrophonePermission();
+            break;
+            
+          case 'REQUEST_MICROPHONE_PERMISSION_WITH_UI':
+            console.log('[VibeSurf] Handling REQUEST_MICROPHONE_PERMISSION_WITH_UI');
+            result = await this.requestMicrophonePermissionWithUI();
+            break;
+            
+          case 'MICROPHONE_PERMISSION_RESULT':
+            console.log('[VibeSurf] Received MICROPHONE_PERMISSION_RESULT:', message);
+            console.log('[VibeSurf] Permission granted:', message.granted);
+            console.log('[VibeSurf] Permission error:', message.error);
+            
+            // Handle permission result from URL parameter approach
+            if (message.granted !== undefined) {
+              console.log('[VibeSurf] Processing permission result with granted:', message.granted);
+              
+              // Store the result for the original tab to retrieve
+              chrome.storage.local.set({
+                microphonePermissionResult: {
+                  granted: message.granted,
+                  error: message.error,
+                  timestamp: Date.now()
+                }
+              });
+              
+              // Also send to any waiting listeners
+              console.log('[VibeSurf] Broadcasting permission result to all tabs...');
+              chrome.runtime.sendMessage({
+                type: 'MICROPHONE_PERMISSION_RESULT',
+                granted: message.granted,
+                error: message.error
+              }).then(() => {
+                console.log('[VibeSurf] Permission result broadcast successful');
+              }).catch((err) => {
+                console.log('[VibeSurf] Permission result broadcast failed (no listeners):', err);
+              });
+            }
+            result = { acknowledged: true };
+            break;
+            
           default:
-            console.warn('[VibeSurf] Unknown message type:', message.type);
-            result = { error: 'Unknown message type' };
+            console.warn('[VibeSurf] Unknown message type:', message.type, 'Available handlers:', [
+              'GET_CURRENT_TAB', 'UPDATE_BADGE', 'SHOW_NOTIFICATION', 'COPY_TO_CLIPBOARD',
+              'HEALTH_CHECK', 'GET_BACKEND_STATUS', 'STORE_SESSION_DATA', 'GET_SESSION_DATA',
+              'OPEN_FILE_URL', 'OPEN_FILE_SYSTEM', 'GET_ALL_TABS', 'REQUEST_MICROPHONE_PERMISSION',
+              'REQUEST_MICROPHONE_PERMISSION_WITH_UI', 'MICROPHONE_PERMISSION_RESULT'
+            ]);
+            result = { error: 'Unknown message type', receivedType: message.type };
         }
         
         sendResponse(result);
@@ -316,28 +370,63 @@ class VibeSurfBackground {
   }
 
   async showNotification(data) {
-    const { title, message, type = 'info', iconUrl = 'icons/icon48.png' } = data;
+    const { title, message, type = 'info', iconUrl } = data;
     
     // Map custom types to valid Chrome notification types
     const validType = ['basic', 'image', 'list', 'progress'].includes(type) ? type : 'basic';
     
-    const notificationId = await chrome.notifications.create({
-      type: validType,
-      iconUrl,
-      title: title || 'VibeSurf',
-      message
-    });
+    // Simplified icon handling - try available icons without validation
+    let finalIconUrl = '';
+    
+    // Try to use extension icons in order of preference, but don't validate with fetch
+    const iconCandidates = [
+      iconUrl ? chrome.runtime.getURL(iconUrl) : null,
+      chrome.runtime.getURL('icons/icon48.png'),
+      chrome.runtime.getURL('icons/logo.png')
+    ].filter(Boolean);
     
-    return { notificationId };
+    // Use the first candidate, or empty string as fallback
+    finalIconUrl = iconCandidates[0] || '';
+    
+    try {
+      const notificationId = await chrome.notifications.create({
+        type: validType,
+        iconUrl: finalIconUrl,
+        title: title || 'VibeSurf',
+        message
+      });
+      
+      return { notificationId };
+    } catch (error) {
+      console.warn('[VibeSurf] Notification with icon failed, trying without icon:', error);
+      // Try once more with empty icon URL
+      try {
+        const notificationId = await chrome.notifications.create({
+          type: validType,
+          iconUrl: '', // Empty string will use browser default
+          title: title || 'VibeSurf',
+          message
+        });
+        return { notificationId };
+      } catch (fallbackError) {
+        console.error('[VibeSurf] Fallback notification also failed:', fallbackError);
+        throw new Error(`Failed to create notification: ${error.message}`);
+      }
+    }
   }
 
   async showWelcomeNotification() {
-    await chrome.notifications.create({
-      type: 'basic',
-      iconUrl: 'icons/icon48.png',
-      title: 'Welcome to VibeSurf!',
-      message: 'Click the VibeSurf icon in the toolbar to start automating your browsing tasks.'
-    });
+    try {
+      await chrome.notifications.create({
+        type: 'basic',
+        iconUrl: '', // Use empty string to avoid icon issues
+        title: 'Welcome to VibeSurf!',
+        message: 'Click the VibeSurf icon in the toolbar to start automating your browsing tasks.'
+      });
+    } catch (error) {
+      console.warn('[VibeSurf] Welcome notification failed:', error);
+      // Don't throw, just log the warning
+    }
   }
 
   async checkBackendStatus(backendUrl = null) {
@@ -458,7 +547,40 @@ class VibeSurfBackground {
       return { success: false, error: 'No file URL provided' };
     }
 
+    // Add a unique request ID to track duplicate calls
+    const requestId = Date.now() + Math.random();
+    console.log(`[VibeSurf] openFileUrl called with ID: ${requestId}, URL: ${fileUrl}`);
+
     try {
+      // Validate URL format before attempting to open
+      try {
+        new URL(fileUrl);
+      } catch (urlError) {
+        console.warn('[VibeSurf] Invalid URL format:', fileUrl, urlError);
+        return { success: false, error: 'Invalid file URL format' };
+      }
+      
+      // Check if this is an HTTP/HTTPS URL and handle it appropriately
+      if (fileUrl.startsWith('http://') || fileUrl.startsWith('https://')) {
+        console.log(`[VibeSurf] Detected HTTP(S) URL, creating tab for: ${fileUrl}`);
+        
+        // Try to create a new tab with the URL
+        const tab = await chrome.tabs.create({
+          url: fileUrl,
+          active: true
+        });
+        
+        if (tab && tab.id) {
+          console.log(`[VibeSurf] Successfully opened HTTP(S) URL in tab: ${tab.id} (request: ${requestId})`);
+          return { success: true, tabId: tab.id };
+        } else {
+          console.warn(`[VibeSurf] Tab creation returned but no tab ID for request: ${requestId}`);
+          return { success: false, error: 'Failed to create tab - no tab ID returned' };
+        }
+      }
+      
+      // For file:// URLs, try the original approach
+      console.log(`[VibeSurf] Attempting to open file URL: ${fileUrl} (request: ${requestId})`);
       
       // Try to create a new tab with the file URL
       const tab = await chrome.tabs.create({
@@ -467,16 +589,25 @@ class VibeSurfBackground {
       });
       
       if (tab && tab.id) {
+        console.log(`[VibeSurf] Successfully opened file in tab: ${tab.id} (request: ${requestId})`);
         return { success: true, tabId: tab.id };
       } else {
-        return { success: false, error: 'Failed to create tab' };
+        console.warn(`[VibeSurf] Tab creation returned but no tab ID for request: ${requestId}`);
+        return { success: false, error: 'Failed to create tab - no tab ID returned' };
       }
       
     } catch (error) {
-      console.error('[VibeSurf] Error opening file URL:', error);
+      console.error(`[VibeSurf] Error opening file URL (request: ${requestId}):`, error);
+      
+      // Provide more specific error messages
+      let errorMessage = error.message || 'Unknown error opening file';
+      if (error.message && error.message.includes('file://')) {
+        errorMessage = 'Browser security restricts opening local files. Try copying the file path and opening manually.';
+      }
+      
       return {
         success: false,
-        error: error.message || 'Unknown error opening file'
+        error: errorMessage
       };
     }
   }
@@ -624,6 +755,121 @@ class VibeSurfBackground {
     }
   }
 
+  // Request microphone permission through background script
+  async requestMicrophonePermission() {
+    try {
+      console.log('[VibeSurf] Requesting microphone permission through background script');
+      
+      // Get the active tab to inject script
+      const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
+      
+      if (!tab) {
+        throw new Error('No active tab found');
+      }
+      
+      // Check if we can inject script into this tab
+      if (tab.url.startsWith('chrome://') || tab.url.startsWith('chrome-extension://') ||
+          tab.url.startsWith('edge://') || tab.url.startsWith('moz-extension://')) {
+        throw new Error('Cannot access microphone from this type of page');
+      }
+      
+      // Inject script to request microphone permission
+      const results = await chrome.scripting.executeScript({
+        target: { tabId: tab.id },
+        func: () => {
+          return new Promise((resolve, reject) => {
+            try {
+              // Check if mediaDevices is available
+              if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+                reject(new Error('Media devices not supported'));
+                return;
+              }
+              
+              // Request microphone with minimal constraints
+              const constraints = { audio: true, video: false };
+              
+              navigator.mediaDevices.getUserMedia(constraints)
+                .then(stream => {
+                  // Stop the stream immediately after getting permission
+                  stream.getTracks().forEach(track => track.stop());
+                  resolve({ success: true, hasPermission: true });
+                })
+                .catch(error => {
+                  reject(new Error(`Microphone permission denied: ${error.name} - ${error.message}`));
+                });
+            } catch (error) {
+              reject(new Error(`Failed to request microphone permission: ${error.message}`));
+            }
+          });
+        }
+      });
+      
+      const result = await results[0].result;
+      console.log('[VibeSurf] Microphone permission result:', result);
+      return result;
+      
+    } catch (error) {
+      console.error('[VibeSurf] Failed to request microphone permission:', error);
+      return { success: false, error: error.message };
+    }
+  }
+
+  // Create a proper permission request page that opens in a new tab
+  async requestMicrophonePermissionWithUI() {
+    try {
+      console.log('[VibeSurf] Opening permission request page in new tab');
+      
+      // Use the existing permission-request.html file
+      const permissionPageUrl = chrome.runtime.getURL('permission-request.html');
+      
+      // Create a tab with the permission page
+      const permissionTab = await chrome.tabs.create({
+        url: permissionPageUrl,
+        active: true
+      });
+      
+      console.log('[VibeSurf] Created permission tab:', permissionTab.id);
+      
+      // Return a promise that resolves when we get the permission result
+      return new Promise((resolve) => {
+        const messageHandler = (message, sender, sendResponse) => {
+          if (message.type === 'MICROPHONE_PERMISSION_RESULT') {
+            console.log('[VibeSurf] Received permission result:', message);
+            
+            // Clean up the message listener
+            chrome.runtime.onMessage.removeListener(messageHandler);
+            
+            // Close the permission tab
+            chrome.tabs.remove(permissionTab.id).catch(() => {
+              // Tab might already be closed
+            });
+            
+            // Resolve the promise
+            if (message.granted) {
+              resolve({ success: true, hasPermission: true });
+            } else {
+              resolve({ success: false, error: message.error || 'Permission denied by user' });
+            }
+          }
+        };
+        
+        // Add the message listener
+        chrome.runtime.onMessage.addListener(messageHandler);
+        
+        // Set a timeout to clean up if the tab is closed without response
+        setTimeout(() => {
+          chrome.runtime.onMessage.removeListener(messageHandler);
+          chrome.tabs.remove(permissionTab.id).catch(() => {});
+          resolve({ success: false, error: 'Permission request timed out' });
+        }, 30000); // 30 second timeout
+      });
+      
+    } catch (error) {
+      console.error('[VibeSurf] Failed to create permission UI:', error);
+      return { success: false, error: error.message };
+    }
+  }
+
   // Cleanup method for extension unload
   async cleanup() {