vibesurf 0.1.20__py3-none-any.whl → 0.1.21__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

@@ -428,9 +428,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

@@ -155,12 +155,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 +208,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);
@@ -321,14 +370,65 @@ class VibeSurfBackground {
     // 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
-    });
+    // Validate icon URL and provide fallback
+    let validatedIconUrl = iconUrl;
+    try {
+      // Check if icon URL is accessible
+      if (iconUrl && iconUrl !== 'icons/icon48.png') {
+        // For custom icons, validate they exist
+        const response = await fetch(iconUrl, { method: 'HEAD' });
+        if (!response.ok) {
+          validatedIconUrl = 'icons/icon48.png';
+        }
+      } else {
+        // Use default icon, check if it exists
+        const defaultIconUrl = chrome.runtime.getURL('icons/icon48.png');
+        const response = await fetch(defaultIconUrl, { method: 'HEAD' });
+        if (response.ok) {
+          validatedIconUrl = defaultIconUrl;
+        } else {
+          // Fallback to logo.png if icon48.png doesn't exist
+          const logoUrl = chrome.runtime.getURL('icons/logo.png');
+          const logoResponse = await fetch(logoUrl, { method: 'HEAD' });
+          if (logoResponse.ok) {
+            validatedIconUrl = logoUrl;
+          } else {
+            // If no icons work, use empty string (browser will use default)
+            validatedIconUrl = '';
+          }
+        }
+      }
+    } catch (error) {
+      console.warn('[VibeSurf] Icon validation failed, using fallback:', error);
+      // Use empty string as fallback (browser will use default icon)
+      validatedIconUrl = '';
+    }
     
-    return { notificationId };
+    try {
+      const notificationId = await chrome.notifications.create({
+        type: validType,
+        iconUrl: validatedIconUrl,
+        title: title || 'VibeSurf',
+        message
+      });
+      
+      return { notificationId };
+    } catch (error) {
+      console.error('[VibeSurf] Failed to create notification:', 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() {
@@ -624,6 +724,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() {