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

@@ -16,7 +16,8 @@
     "contextMenus",
     "tabs",
     "clipboardWrite",
-    "scripting"
+    "scripting",
+    "microphone"
   ],
   "host_permissions": [
     "http://localhost:*/*",
@@ -48,7 +49,15 @@
 
   "web_accessible_resources": [
     {
-      "resources": ["sidepanel.html", "styles/*", "scripts/*", "config.js", "icons/*"],
+      "resources": [
+        "sidepanel.html",
+        "permission-request.html",
+        "permission-iframe.html",
+        "styles/*",
+        "scripts/*",
+        "config.js",
+        "icons/*"
+      ],
       "matches": ["<all_urls>"]
     }
   ]

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/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() {
@@ -482,6 +482,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);
     }

vibe_surf/chrome_extension/scripts/permission-iframe-request.js

@@ -0,0 +1,188 @@
+// Permission iframe request script
+// This script runs inside the iframe to request microphone permissions
+
+(function() {
+    'use strict';
+    
+    console.log('[PermissionIframe] Permission iframe script loaded');
+    console.log('[PermissionIframe] Current URL:', window.location.href);
+    console.log('[PermissionIframe] Parent origin:', window.parent.location.origin);
+    console.log('[PermissionIframe] Is secure context:', window.isSecureContext);
+    
+    const statusEl = document.getElementById('status');
+    
+    // Function to request microphone permission
+    async function requestMicrophonePermission() {
+        try {
+            console.log('[PermissionIframe] Starting microphone permission request...');
+            console.log('[PermissionIframe] Window location:', window.location.href);
+            console.log('[PermissionIframe] Is top window:', window === window.top);
+            console.log('[PermissionIframe] Document domain:', document.domain);
+            
+            // Check if media devices are available
+            if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+                throw new Error('Media devices not supported in this context');
+            }
+            
+            console.log('[PermissionIframe] Media devices available, requesting getUserMedia...');
+            statusEl.textContent = 'Requesting microphone access...';
+            statusEl.className = 'status loading';
+            
+            // Request microphone access with minimal constraints
+            console.log('[PermissionIframe] About to call getUserMedia...');
+            const stream = await navigator.mediaDevices.getUserMedia({
+                audio: true,
+                video: false
+            });
+            
+            console.log('[PermissionIframe] Permission granted! Stream received');
+            console.log('[PermissionIframe] Stream tracks:', stream.getTracks().length);
+            
+            // Stop all tracks immediately after getting permission
+            stream.getTracks().forEach(track => {
+                console.log('[PermissionIframe] Stopping track:', track.kind);
+                track.stop();
+            });
+            
+            // Update status
+            statusEl.textContent = 'Microphone access granted!';
+            statusEl.className = 'status success';
+            
+            // Send success message to parent window
+            console.log('[PermissionIframe] Sending success message to parent...');
+            console.log('[PermissionIframe] Parent window:', window.parent);
+            
+            // First try to send to parent window
+            try {
+                window.parent.postMessage({
+                    type: 'MICROPHONE_PERMISSION_RESULT',
+                    success: true,
+                    granted: true,
+                    source: 'iframe'
+                }, '*');
+                console.log('[PermissionIframe] PostMessage to parent sent successfully');
+            } catch (postMessageError) {
+                console.error('[PermissionIframe] Failed to send postMessage to parent:', postMessageError);
+            }
+            
+            // Also try to send to extension if available
+            if (typeof chrome !== 'undefined' && chrome.runtime) {
+                try {
+                    chrome.runtime.sendMessage({
+                        type: 'MICROPHONE_PERMISSION_RESULT',
+                        success: true,
+                        granted: true,
+                        source: 'iframe'
+                    }, (response) => {
+                        if (chrome.runtime.lastError) {
+                            console.log('[PermissionIframe] Chrome runtime error:', chrome.runtime.lastError);
+                        } else {
+                            console.log('[PermissionIframe] Extension message sent successfully:', response);
+                        }
+                    });
+                } catch (e) {
+                    console.error('[PermissionIframe] Could not send to extension:', e);
+                }
+            }
+            
+            return true;
+            
+        } catch (error) {
+            console.error('[PermissionIframe] Permission request failed:', error);
+            console.error('[PermissionIframe] Error details:', {
+                name: error.name,
+                message: error.message,
+                stack: error.stack
+            });
+            
+            // Update status with error
+            let errorMessage = '';
+            let userMessage = '';
+            
+            if (error.name === 'NotAllowedError') {
+                errorMessage = 'Microphone access denied';
+                userMessage = 'Please allow microphone access when prompted by your browser';
+            } else if (error.name === 'NotFoundError') {
+                errorMessage = 'No microphone found';
+                userMessage = 'Please ensure a microphone is connected';
+            } else if (error.name === 'NotReadableError') {
+                errorMessage = 'Microphone in use';
+                userMessage = 'Please close other apps using the microphone';
+            } else if (error.name === 'SecurityError') {
+                errorMessage = 'Security restriction';
+                userMessage = 'Cannot access microphone due to security settings';
+            } else {
+                errorMessage = 'Permission failed';
+                userMessage = error.message;
+            }
+            
+            statusEl.textContent = `${errorMessage}: ${userMessage}`;
+            statusEl.className = 'status error';
+            
+            // Send error message to parent window
+            console.log('[PermissionIframe] Sending error message to parent...');
+            console.log('[PermissionIframe] Error details:', { name: error.name, message: error.message });
+            
+            // First try to send to parent window
+            try {
+                window.parent.postMessage({
+                    type: 'MICROPHONE_PERMISSION_RESULT',
+                    success: false,
+                    granted: false,
+                    error: error.message,
+                    errorName: error.name,
+                    userMessage: userMessage,
+                    source: 'iframe'
+                }, '*');
+                console.log('[PermissionIframe] Error postMessage to parent sent successfully');
+            } catch (postMessageError) {
+                console.error('[PermissionIframe] Failed to send error postMessage to parent:', postMessageError);
+            }
+            
+            // Also try to send to extension if available
+            if (typeof chrome !== 'undefined' && chrome.runtime) {
+                try {
+                    chrome.runtime.sendMessage({
+                        type: 'MICROPHONE_PERMISSION_RESULT',
+                        success: false,
+                        granted: false,
+                        error: error.message,
+                        errorName: error.name,
+                        userMessage: userMessage,
+                        source: 'iframe'
+                    }, (response) => {
+                        if (chrome.runtime.lastError) {
+                            console.log('[PermissionIframe] Chrome runtime error for error message:', chrome.runtime.lastError);
+                        } else {
+                            console.log('[PermissionIframe] Error extension message sent successfully:', response);
+                        }
+                    });
+                } catch (e) {
+                    console.error('[PermissionIframe] Could not send error to extension:', e);
+                }
+            }
+            
+            return false;
+        }
+    }
+    
+    // Start permission request when iframe loads
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', requestMicrophonePermission);
+    } else {
+        requestMicrophonePermission();
+    }
+    
+    // Also listen for messages from parent requesting permission
+    window.addEventListener('message', (event) => {
+        console.log('[PermissionIframe] Received message from parent:', event.data);
+        
+        if (event.data && event.data.type === 'REQUEST_MICROPHONE_PERMISSION') {
+            console.log('[PermissionIframe] Parent requested permission, starting request...');
+            requestMicrophonePermission();
+        }
+    });
+    
+    console.log('[PermissionIframe] Permission iframe script initialized');
+    
+})();