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

vibe_surf/chrome_extension/content.js

@@ -53,10 +53,36 @@
             sendResponse(clickResult);
             break;
             
+          case 'INJECT_MICROPHONE_PERMISSION_IFRAME':
+            this.injectMicrophonePermissionIframe()
+              .then(result => sendResponse(result))
+              .catch(error => sendResponse({ success: false, error: error.message }));
+            return true; // Will respond asynchronously
+            
+          case 'REMOVE_MICROPHONE_PERMISSION_IFRAME':
+            this.removeMicrophonePermissionIframe();
+            sendResponse({ success: true });
+            break;
+            
           default:
             console.warn('[VibeSurf Content] Unknown message type:', message.type);
         }
       });
+      
+      // Listen for postMessage from iframe
+      window.addEventListener('message', (event) => {
+        if (event.data && event.data.type === 'MICROPHONE_PERMISSION_RESULT') {
+          console.log('[VibeSurf Content] Received permission result from iframe:', event.data);
+          
+          // Forward to extension
+          chrome.runtime.sendMessage({
+            type: 'MICROPHONE_PERMISSION_RESULT',
+            ...event.data
+          }).catch(() => {
+            // Ignore if no listeners
+          });
+        }
+      });
     }
     
     collectPageContext() {
@@ -233,6 +259,127 @@
       }
     }
     
+    // Inject hidden iframe for microphone permission request
+    async injectMicrophonePermissionIframe() {
+      try {
+        console.log('[VibeSurf Content] Injecting microphone permission iframe...');
+        
+        // Check if iframe already exists
+        const existingIframe = document.getElementById('vibesurf-permission-iframe');
+        if (existingIframe) {
+          console.log('[VibeSurf Content] Permission iframe already exists');
+          return { success: true, alreadyExists: true };
+        }
+        
+        // Create the iframe element
+        const iframe = document.createElement('iframe');
+        iframe.setAttribute('id', 'vibesurf-permission-iframe');
+        iframe.setAttribute('allow', 'microphone');
+        iframe.setAttribute('hidden', 'hidden');
+        iframe.style.display = 'none';
+        iframe.style.width = '0px';
+        iframe.style.height = '0px';
+        iframe.style.border = 'none';
+        iframe.style.position = 'fixed';
+        iframe.style.top = '-9999px';
+        iframe.style.left = '-9999px';
+        iframe.style.zIndex = '-1';
+        
+        // Set the source to our permission iframe page
+        const iframeUrl = chrome.runtime.getURL('permission-iframe.html');
+        iframe.src = iframeUrl;
+        
+        console.log('[VibeSurf Content] Creating iframe with URL:', iframeUrl);
+        
+        // Return a promise that resolves when permission is granted/denied
+        return new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            console.log('[VibeSurf Content] Permission iframe timeout');
+            this.removeMicrophonePermissionIframe();
+            reject(new Error('Permission request timeout'));
+          }, 30000); // 30 second timeout
+          
+          // Listen for permission result
+          const messageHandler = (event) => {
+            if (event.data && event.data.type === 'MICROPHONE_PERMISSION_RESULT') {
+              console.log('[VibeSurf Content] Received permission result:', event.data);
+              
+              clearTimeout(timeout);
+              window.removeEventListener('message', messageHandler);
+              
+              if (event.data.success) {
+                resolve({
+                  success: true,
+                  granted: event.data.granted,
+                  source: 'iframe'
+                });
+              } else {
+                resolve({
+                  success: false,
+                  granted: false,
+                  error: event.data.error || 'Permission denied',
+                  userMessage: event.data.userMessage
+                });
+              }
+              
+              // Clean up iframe after a short delay
+              setTimeout(() => {
+                this.removeMicrophonePermissionIframe();
+              }, 1000);
+            }
+          };
+          
+          window.addEventListener('message', messageHandler);
+          
+          // Handle iframe load
+          iframe.onload = () => {
+            console.log('[VibeSurf Content] Permission iframe loaded successfully');
+            
+            // Send message to iframe to start permission request
+            setTimeout(() => {
+              if (iframe.contentWindow) {
+                iframe.contentWindow.postMessage({
+                  type: 'REQUEST_MICROPHONE_PERMISSION'
+                }, '*');
+              }
+            }, 100);
+          };
+          
+          iframe.onerror = (error) => {
+            console.error('[VibeSurf Content] Permission iframe load error:', error);
+            clearTimeout(timeout);
+            window.removeEventListener('message', messageHandler);
+            this.removeMicrophonePermissionIframe();
+            reject(new Error('Failed to load permission iframe'));
+          };
+          
+          // Append to document body
+          document.body.appendChild(iframe);
+          console.log('[VibeSurf Content] Permission iframe injected into page');
+        });
+        
+      } catch (error) {
+        console.error('[VibeSurf Content] Failed to inject permission iframe:', error);
+        throw error;
+      }
+    }
+    
+    // Remove microphone permission iframe
+    removeMicrophonePermissionIframe() {
+      try {
+        const iframe = document.getElementById('vibesurf-permission-iframe');
+        if (iframe) {
+          console.log('[VibeSurf Content] Removing permission iframe');
+          iframe.remove();
+          return true;
+        }
+        return false;
+      } catch (error) {
+        console.error('[VibeSurf Content] Error removing permission iframe:', error);
+        return false;
+      }
+    }
+    
     // Utility method to send context updates to background
     sendContextUpdate() {
       try {

vibe_surf/chrome_extension/permission-iframe.html

@@ -0,0 +1,38 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Microphone Permission Request</title>
+    <style>
+        body {
+            margin: 0;
+            padding: 10px;
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            font-size: 12px;
+            background: #f5f5f5;
+            color: #333;
+        }
+        .status {
+            padding: 8px;
+            border-radius: 4px;
+            text-align: center;
+        }
+        .loading {
+            background: #bee3f8;
+            color: #2a4365;
+        }
+        .success {
+            background: #c6f6d5;
+            color: #22543d;
+        }
+        .error {
+            background: #fed7d7;
+            color: #742a2a;
+        }
+    </style>
+</head>
+<body>
+    <div id="status" class="status loading">Requesting microphone access...</div>
+    <script src="scripts/permission-iframe-request.js"></script>
+</body>
+</html>

vibe_surf/chrome_extension/permission-request.html

@@ -0,0 +1,104 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>VibeSurf - Microphone Permission</title>
+    <style>
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            min-height: 100vh;
+            margin: 0;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: #333;
+        }
+        .container {
+            background: white;
+            padding: 40px;
+            border-radius: 12px;
+            box-shadow: 0 10px 30px rgba(0,0,0,0.2);
+            text-align: center;
+            max-width: 400px;
+        }
+        .logo {
+            width: 60px;
+            height: 60px;
+            margin-bottom: 20px;
+        }
+        h1 {
+            color: #2d3748;
+            margin-bottom: 10px;
+            font-size: 24px;
+        }
+        p {
+            color: #718096;
+            margin-bottom: 30px;
+            line-height: 1.6;
+        }
+        .button-group {
+            display: flex;
+            gap: 12px;
+            justify-content: center;
+        }
+        button {
+            padding: 12px 24px;
+            border: none;
+            border-radius: 6px;
+            font-size: 16px;
+            font-weight: 500;
+            cursor: pointer;
+            transition: all 0.2s;
+        }
+        .allow-btn {
+            background: #4299e1;
+            color: white;
+        }
+        .allow-btn:hover {
+            background: #3182ce;
+            transform: translateY(-1px);
+        }
+        .deny-btn {
+            background: #e2e8f0;
+            color: #4a5568;
+        }
+        .deny-btn:hover {
+            background: #cbd5e0;
+        }
+        #status {
+            margin-top: 20px;
+            padding: 12px;
+            border-radius: 6px;
+            font-weight: 500;
+        }
+        .success {
+            background: #c6f6d5;
+            color: #22543d;
+        }
+        .error {
+            background: #fed7d7;
+            color: #742a2a;
+        }
+        .loading {
+            background: #bee3f8;
+            color: #2a4365;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <img src="icons/logo.png" alt="VibeSurf" class="logo">
+        <h1>Microphone Permission Required</h1>
+        <p>VibeSurf needs access to your microphone to enable voice input. This permission is used only when you click the microphone button.</p>
+        <div class="button-group">
+            <button id="allowBtn" class="allow-btn">Allow Microphone</button>
+            <button id="denyBtn" class="deny-btn">Deny</button>
+        </div>
+        <div id="status"></div>
+    </div>
+
+    <script src="scripts/permission-request.js"></script>
+</body>
+</html>

vibe_surf/chrome_extension/scripts/api-client.js

@@ -410,6 +410,67 @@ class VibeSurfAPIClient {
     return this.get(`/config/llm/providers/${encodeURIComponent(providerName)}/models`);
   }
 
+  // Voice Profile Management
+  async getVoiceProfiles(activeOnly = true, voiceModelType = null, limit = 50, offset = 0) {
+    const params = { active_only: activeOnly, limit, offset };
+    if (voiceModelType) {
+      params.voice_model_type = voiceModelType;
+    }
+    return this.get('/voices/voice-profiles', { params });
+  }
+
+  async getVoiceProfile(profileName) {
+    return this.get(`/voices/${encodeURIComponent(profileName)}`);
+  }
+
+  async createVoiceProfile(profileData) {
+    return this.post('/voices/voice-profiles', profileData);
+  }
+
+  async updateVoiceProfile(profileName, updateData) {
+    return this.put(`/voices/voice-profiles/${encodeURIComponent(profileName)}`, updateData);
+  }
+
+  async deleteVoiceProfile(profileName) {
+    return this.delete(`/voices/voice-profiles/${encodeURIComponent(profileName)}`);
+  }
+
+  // Voice Models - matches the backend route @router.get("/models")
+  async getVoiceModels(modelType = null) {
+    let url = '/voices/models';
+    if (modelType) {
+      url += `?model_type=${encodeURIComponent(modelType)}`;
+    }
+    return this.get(url);
+  }
+
+  // Voice Recording API
+  async transcribeAudio(audioBlob, voiceProfileName = null) {
+    const formData = new FormData();
+    formData.append('audio_file', audioBlob, 'recording.webm');
+    
+    // Add voice profile name if provided
+    const params = {};
+    if (voiceProfileName) {
+      params.voice_profile_name = voiceProfileName;
+    }
+    
+    return this.post('/voices/asr', formData, {
+      params,
+      headers: {} // Let browser set Content-Type with boundary for FormData
+    });
+  }
+
+  // Get available ASR profiles
+  async getASRProfiles(activeOnly = true) {
+    return this.get('/voices/voice-profiles', {
+      params: {
+        voice_model_type: 'asr',
+        active_only: activeOnly
+      }
+    });
+  }
+
   // Environment Variables
   async getEnvironmentVariables() {
     return this.get('/config/environments');

vibe_surf/chrome_extension/scripts/file-manager.js

@@ -275,14 +275,28 @@ class VibeSurfFileManager {
   async handleFileLink(filePath) {
     // Prevent multiple simultaneous calls
     if (this.state.isHandlingFileLink) {
+      console.log('[FileManager] File link handling already in progress, skipping...');
       return;
     }
     
     this.state.isHandlingFileLink = true;
     
     try {
-      // First decode the URL-encoded path
-      let decodedPath = decodeURIComponent(filePath);
+      console.log('[FileManager] Handling file link:', filePath);
+      
+      // Validate input
+      if (!filePath || typeof filePath !== 'string') {
+        throw new Error('Invalid file path provided');
+      }
+      
+      // First decode the URL-encoded path safely
+      let decodedPath;
+      try {
+        decodedPath = decodeURIComponent(filePath);
+      } catch (decodeError) {
+        console.warn('[FileManager] Failed to decode URL, using original path:', decodeError);
+        decodedPath = filePath;
+      }
       
       // Remove file:// protocol prefix and normalize
       let cleanPath = decodedPath.replace(/^file:\/\/\//, '').replace(/^file:\/\//, '');
@@ -300,21 +314,28 @@ class VibeSurfFileManager {
         `file:///${cleanPath}` :
         `file:///${cleanPath.replace(/^\//, '')}`;  // Remove leading slash and add triple slash
       
+      console.log('[FileManager] Processed file URL:', fileUrl);
+      
       // Show user notification about the action
       this.emit('notification', {
         message: `Opening file: ${cleanPath}`,
         type: 'info'
       });
       
-      // Use setTimeout to prevent UI blocking
+      // Use setTimeout to prevent UI blocking and ensure proper cleanup
       setTimeout(async () => {
         try {
           // For user-clicked file links, use OPEN_FILE_URL to keep tab open
           // This prevents the auto-close behavior in OPEN_FILE_SYSTEM
-          const fileOpenResponse = await chrome.runtime.sendMessage({
-            type: 'OPEN_FILE_URL',
-            data: { fileUrl: fileUrl }
-          });
+          const fileOpenResponse = await Promise.race([
+            chrome.runtime.sendMessage({
+              type: 'OPEN_FILE_URL',
+              data: { fileUrl: fileUrl }
+            }),
+            new Promise((_, reject) =>
+              setTimeout(() => reject(new Error('File open timeout')), 5000)
+            )
+          ]);
           
           if (fileOpenResponse && fileOpenResponse.success) {
             this.emit('notification', {
@@ -322,12 +343,14 @@ class VibeSurfFileManager {
               type: 'success'
             });
             return;
+          } else if (fileOpenResponse && fileOpenResponse.error) {
+            console.warn('[FileManager] Background script file open failed:', fileOpenResponse.error);
           }
           
-          // If OPEN_FILE_URL fails, try direct browser open
+          // If OPEN_FILE_URL fails, try direct browser open with additional safety
           try {
             const opened = window.open(fileUrl, '_blank', 'noopener,noreferrer');
-            if (opened) {
+            if (opened && !opened.closed) {
               this.emit('notification', {
                 message: 'File opened in browser',
                 type: 'success'
@@ -339,14 +362,32 @@ class VibeSurfFileManager {
           }
           
           // Last resort: Copy path to clipboard
-          this.copyToClipboardFallback(fileUrl);
+          await this.copyToClipboardFallback(fileUrl);
           
         } catch (error) {
           console.error('[FileManager] Error in async file handling:', error);
+          
+          // Provide more helpful error messages
+          let userMessage = 'Unable to open file';
+          if (error.message.includes('timeout')) {
+            userMessage = 'File open operation timed out. Try copying the path manually.';
+          } else if (error.message.includes('protocol')) {
+            userMessage = 'Browser security restricts opening local files. File path copied to clipboard.';
+          } else {
+            userMessage = `Unable to open file: ${error.message}`;
+          }
+          
           this.emit('notification', {
-            message: `Unable to open file: ${error.message}`,
+            message: userMessage,
             type: 'error'
           });
+          
+          // Fallback to clipboard
+          try {
+            await this.copyToClipboardFallback(fileUrl);
+          } catch (clipboardError) {
+            console.error('[FileManager] Clipboard fallback also failed:', clipboardError);
+          }
         } finally {
           this.state.isHandlingFileLink = false;
         }
@@ -355,7 +396,7 @@ class VibeSurfFileManager {
     } catch (error) {
       console.error('[FileManager] Error handling file link:', error);
       this.emit('notification', {
-        message: `Unable to open file: ${error.message}`,
+        message: `File link processing failed: ${error.message}`,
         type: 'error'
       });
       this.state.isHandlingFileLink = false;

vibe_surf/chrome_extension/scripts/main.js

@@ -154,11 +154,11 @@ class VibeSurfApp {
 
   async initializeUIManager() {
     this.uiManager = new VibeSurfUIManager(this.sessionManager, this.apiClient);
-    
+
     // Initialize UI with loaded data
     await this.uiManager.initialize();
     
-    console.log('[VibeSurf] UI manager initialized');
+    console.log('[VibeSurf] UI manager initialized successfully');
   }
 
   setupErrorHandling() {
@@ -189,6 +189,12 @@ class VibeSurfApp {
     // Periodic backend health check
     setInterval(async () => {
       try {
+        // Check if apiClient exists and is initialized
+        if (!this.apiClient || typeof this.apiClient.healthCheck !== 'function') {
+          console.warn('[VibeSurf] Health check skipped - API client not available');
+          return;
+        }
+        
         const healthCheck = await this.apiClient.healthCheck();
         
         if (healthCheck.status === 'healthy') {
@@ -413,18 +419,37 @@ class VibeSurfApp {
 
   // Cleanup method
   destroy() {
-    console.log('[VibeSurf] Cleaning up application...');
-    
-    if (this.uiManager) {
-      this.uiManager.destroy();
+    // Prevent multiple cleanup calls
+    if (this.isDestroying || !this.isInitialized) {
+      console.log('[VibeSurf] Cleanup already in progress or app not initialized, skipping...');
+      return;
     }
     
-    if (this.sessionManager) {
-      this.sessionManager.destroy();
-    }
+    this.isDestroying = true;
+    console.log('[VibeSurf] Cleaning up application...');
     
-    this.isInitialized = false;
-    console.log('[VibeSurf] Application cleanup complete');
+    try {
+      if (this.uiManager) {
+        this.uiManager.destroy();
+        this.uiManager = null;
+      }
+      
+      if (this.sessionManager) {
+        this.sessionManager.destroy();
+        this.sessionManager = null;
+      }
+      
+      if (this.apiClient) {
+        this.apiClient = null;
+      }
+      
+      this.isInitialized = false;
+      console.log('[VibeSurf] Application cleanup complete');
+    } catch (error) {
+      console.error('[VibeSurf] Error during cleanup:', error);
+    } finally {
+      this.isDestroying = false;
+    }
   }
 
   // Get application status
@@ -456,11 +481,21 @@ document.addEventListener('DOMContentLoaded', async () => {
 
 // Handle page unload
 window.addEventListener('beforeunload', () => {
-  if (window.vibeSurfApp) {
+  if (window.vibeSurfApp && window.vibeSurfApp.isInitialized && !window.vibeSurfApp.isDestroying) {
+    console.log('[VibeSurf] Page unloading, cleaning up...');
     window.vibeSurfApp.destroy();
   }
 });
 
+// Handle visibility change to prevent unnecessary cleanup
+document.addEventListener('visibilitychange', () => {
+  if (document.visibilityState === 'hidden') {
+    console.log('[VibeSurf] Page hidden, but not cleaning up (might be tab switch)');
+  } else if (document.visibilityState === 'visible') {
+    console.log('[VibeSurf] Page visible again');
+  }
+});
+
 // Make app accessible for debugging
 if (typeof window !== 'undefined') {
   window.VibeSurfApp = VibeSurfApp;
@@ -482,6 +517,12 @@ chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
           .catch(error => sendResponse({ success: false, error: error.message }));
         return true; // Keep message channel open for async response
         
+      case 'MICROPHONE_PERMISSION_RESULT':
+        console.log('[VibeSurf] Received microphone permission result:', message);
+        // This message is typically handled by voice recorder, just acknowledge
+        sendResponse({ acknowledged: true });
+        break;
+        
       default:
         console.warn('[VibeSurf] Unknown message type:', message.type);
     }