vibesurf 0.1.21__py3-none-any.whl → 0.1.23__py3-none-any.whl

vibe_surf/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.21'
-__version_tuple__ = version_tuple = (0, 1, 21)
+__version__ = version = '0.1.23'
+__version_tuple__ = version_tuple = (0, 1, 23)
 
 __commit_id__ = commit_id = None

vibe_surf/agents/browser_use_agent.py

@@ -525,7 +525,7 @@ class BrowserUseAgent(Agent):
         signal_handler.register()
 
         try:
-            self._log_agent_run()
+            await self._log_agent_run()
 
             self.logger.debug(
                 f'🔧 Agent setup: Task ID {self.task_id[-4:]}, Session ID {self.session_id[-4:]}, Browser Session ID {self.browser_session.id[-4:] if self.browser_session else "None"}'

vibe_surf/agents/prompts/vibe_surf_prompt.py

@@ -65,6 +65,15 @@ You will receive contextual information including:
 - Include file references in task descriptions when relevant
 - All file operations automatically resolve relative to the workspace directory
 
+## Skills Command Processing
+- When users input commands in `/skill_name` format, please use the corresponding skill action:
+- **Tab Targeting[Optional]**: Such as `/crawl @1234` → Execute `skill_crawl` with tab_id "1234"
+- **Parameter Processing**: Sometimes user provide uncompleted or simple prompt, please convert it to correct and optimized params. Such as convert natural language to valid JavaScript for code skill
+- **Special Cases**: `skill_deep_research` only returns guidelines only, then follow guidelines to conduct actual research
+- **Execution Policy**: Skill actions execute only once (no need to retry if errors occur), and all results - whether successful or failed - should be presented to users in structured markdown format.
+- **Follow-up Operations**: When users input skill operations without specifying additional tasks, do not automatically perform subsequent operations. Only perform additional tool operations when users specifically request actions like saving results to files or writing reports.
+- After `/search` completion, NEVER use browser agent to deeply investigate search result (unless explicitly emphasized by the user). The user usually only need the search results. Just return the search results.
+
 ## Language Adaptability
 
 **Critical**: Your output language must match the user's request language. If the user communicates in Chinese, respond in Chinese. If in English, respond in English. Maintain consistency throughout the interaction.
@@ -77,6 +86,7 @@ Before executing any action:
 3. **Plan Resource Usage**: Consider tab management and session optimization
 4. **Validate Completeness**: Ensure all user requirements are addressed
 
+
 Execute with precision, leverage concurrent capabilities for efficiency, and deliver professional results that exceed expectations.
 """
 
@@ -86,4 +96,5 @@ EXTEND_BU_SYSTEM_PROMPT = """
 * Regarding file operations, please note that you need the full relative path (including subfolders), not just the file name.
 * Especially when a file operation reports an error, please reflect whether the file path is not written correctly, such as the subfolder is not written.
 * If you are operating on files in the filesystem, be sure to use relative paths (relative to the workspace dir) instead of absolute paths.
+* If you are typing in the search box, please use Enter key to search instead of clicking.
 """

vibe_surf/agents/vibe_surf_agent.py

@@ -479,6 +479,16 @@ async def _vibesurf_agent_node_impl(state: VibeSurfState) -> VibeSurfState:
                     llm=vibesurf_agent.llm,
                     file_system=vibesurf_agent.file_system,
                 )
+                if "skill_search" in action_name or "skill_crawl" in action_name or "skill_summary" in action_name:
+                    state.current_step = "END"
+                    # Format final response
+                    final_response = f"{result.extracted_content}"
+                    await log_agent_activity(state, agent_name, "result", final_response)
+                    state.final_response = final_response
+                    logger.debug(final_response)
+                    state.is_complete = True
+                    return state
+
                 state.current_step = "vibesurf_agent"
                 if result.extracted_content:
                     vibesurf_agent.message_history.append(
@@ -1479,8 +1489,9 @@ Please continue with your assigned work, incorporating this guidance only if it'
         """
         activity_entry = {
             "agent_name": 'user',
-            "agent_status": 'request',  # working, result, error
-            "agent_msg": f"{new_task}"
+            "agent_status": 'additional_request',  # working, result, error
+            "agent_msg": f"{new_task}",
+            "timestamp": datetime.now().isoformat()
         }
         self.activity_logs.append(activity_entry)
 

vibe_surf/backend/api/agent.py

@@ -0,0 +1,38 @@
+"""
+Agent API endpoints
+"""
+from typing import List
+from fastapi import APIRouter, HTTPException
+
+from vibe_surf.logger import get_logger
+
+logger = get_logger(__name__)
+
+router = APIRouter(prefix="/agent", tags=["agent"])
+
+
+@router.get("/get_all_skills", response_model=List[str])
+async def get_all_skills():
+    """
+    Get all available skill names from the VibeSurf tools registry.
+    Returns skill names with the 'skill_' prefix removed.
+    """
+    try:
+        from ..shared_state import vibesurf_tools
+        if not vibesurf_tools:
+            raise HTTPException(status_code=500, detail="VibeSurf tools not initialized")
+        
+        # Get all action names from the registry
+        all_actions = vibesurf_tools.registry.registry.actions.keys()
+        
+        # Filter for actions that start with 'skill_' and remove the prefix
+        skill_names = [
+            action_name.replace('skill_', '') 
+            for action_name in all_actions 
+            if action_name.startswith('skill_')
+        ]
+        logger.info(skill_names)
+        return skill_names
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to get skills: {str(e)}")

vibe_surf/backend/api/task.py

@@ -287,7 +287,7 @@ async def stop_task(control_request: TaskControlRequest):
                 active_task["end_time"] = datetime.now()
 
             # Clear active task
-            # clear_active_task()
+            clear_active_task()
 
             return {
                 "success": True,

vibe_surf/backend/main.py

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

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,
@@ -406,11 +407,11 @@ class AgentBrowserSession(BrowserSession):
         self.logger.info('🚫 VibeSurfBrowserSession: AboutBlankWatchdog disabled - no DVD animation will be shown')
 
         # Initialize DownloadsWatchdog
-        DownloadsWatchdog.model_rebuild()
-        self._downloads_watchdog = DownloadsWatchdog(event_bus=self.event_bus, browser_session=self)
-        self._downloads_watchdog.attach_to_session()
-        if self.browser_profile.auto_download_pdfs:
-            self.logger.info('📄 PDF auto-download enabled for this session')
+        # DownloadsWatchdog.model_rebuild()
+        # self._downloads_watchdog = DownloadsWatchdog(event_bus=self.event_bus, browser_session=self)
+        # self._downloads_watchdog.attach_to_session()
+        # if self.browser_profile.auto_download_pdfs:
+        #     self.logger.info('📄 PDF auto-download enabled for this session')
 
         # Initialize LocalBrowserWatchdog
         LocalBrowserWatchdog.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 {
@@ -365,56 +370,35 @@ 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';
     
-    // 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 = '';
-    }
+    // 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);
+    
+    // Use the first candidate, or empty string as fallback
+    finalIconUrl = iconCandidates[0] || '';
     
     try {
       const notificationId = await chrome.notifications.create({
         type: validType,
-        iconUrl: validatedIconUrl,
+        iconUrl: finalIconUrl,
         title: title || 'VibeSurf',
         message
       });
       
       return { notificationId };
     } catch (error) {
-      console.error('[VibeSurf] Failed to create notification:', 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({
@@ -432,12 +416,17 @@ class VibeSurfBackground {
   }
 
   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) {
@@ -558,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({
@@ -567,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
       };
     }
   }

vibe_surf/chrome_extension/manifest.json

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

vibe_surf/chrome_extension/scripts/api-client.js

@@ -498,6 +498,11 @@ class VibeSurfAPIClient {
     return this.get('/browser/all-tabs');
   }
 
+  // Agent APIs - Get available skills
+  async getAllSkills() {
+    return this.get('/agent/get_all_skills');
+  }
+
   // Utility methods
   delay(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));

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

@@ -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') {
@@ -334,7 +340,7 @@ class VibeSurfApp {
             <div class="input-container">
               <div class="input-main">
                 <div class="textarea-container">
-                  <textarea id="task-input" class="task-input" placeholder="Describe your browsing task..." rows="3"></textarea>
+                  <textarea id="task-input" class="task-input" placeholder="Ask anything (/ for skills, @ to specify tab)" rows="3"></textarea>
                   <div class="input-actions">
                     <button id="attach-file-btn" class="action-btn attach-btn" title="Attach Files">
                       <svg width="16" height="16" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
@@ -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;