vibesurf 0.1.27__py3-none-any.whl → 0.1.29__py3-none-any.whl

vibe_surf/tools/website_api/youtube/helpers.py

@@ -0,0 +1,420 @@
+import pdb
+import re
+import json
+import html
+import random
+import time
+from typing import Dict, List, Tuple, Optional
+from enum import Enum
+from urllib.parse import parse_qs, unquote, urlparse
+
+
+class SearchType(Enum):
+    """Search type enumeration for YouTube"""
+    VIDEO = "video"
+    CHANNEL = "channel"
+    PLAYLIST = "playlist"
+    ALL = "all"
+
+
+class SortType(Enum):
+    """Sort type enumeration for YouTube search"""
+    RELEVANCE = "relevance"
+    DATE = "date"
+    VIEW_COUNT = "viewCount"
+    RATING = "rating"
+
+
+class Duration(Enum):
+    """Duration filter for YouTube search"""
+    ANY = "any"
+    SHORT = "short"  # < 4 minutes
+    MEDIUM = "medium"  # 4-20 minutes
+    LONG = "long"  # > 20 minutes
+
+
+class UploadDate(Enum):
+    """Upload date filter for YouTube search"""
+    ANY = "any"
+    HOUR = "hour"
+    TODAY = "today"
+    WEEK = "week"
+    MONTH = "month"
+    YEAR = "year"
+
+
+def generate_visitor_data() -> str:
+    """Generate a random visitor data string for YouTube requests"""
+    chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_"
+    return ''.join(random.choices(chars, k=24))
+
+
+def extract_cookies_from_browser(web_cookies: List[Dict]) -> Tuple[str, Dict[str, str]]:
+    """Extract and format cookies from browser, filtering only YouTube related cookies"""
+    cookie_dict = {}
+    cookie_parts = []
+    
+    # YouTube domain patterns to filter
+    youtube_domains = [
+        '.youtube.com',
+        # 'www.youtube.com',
+        # 'm.youtube.com',
+        # '.google.com'
+    ]
+    
+    for cookie in web_cookies:
+        if 'name' in cookie and 'value' in cookie and 'domain' in cookie:
+            domain = cookie['domain']
+            
+            # Filter only YouTube related cookies
+            if any(yt_domain in domain for yt_domain in youtube_domains):
+                name = cookie['name']
+                value = cookie['value']
+                cookie_dict[name] = value
+                cookie_parts.append(f"{name}={value}")
+    
+    cookie_string = "; ".join(cookie_parts)
+    return cookie_string, cookie_dict
+
+
+def extract_video_id_from_url(youtube_url: str) -> Optional[str]:
+    """Extract video ID from YouTube URL"""
+    patterns = [
+        r'(?:v=|\/)([0-9A-Za-z_-]{11}).*',
+        r'(?:embed\/)([0-9A-Za-z_-]{11})',
+        r'(?:youtu\.be\/)([0-9A-Za-z_-]{11})',
+        r'(?:watch\?v=)([0-9A-Za-z_-]{11})'
+    ]
+    
+    for pattern in patterns:
+        match = re.search(pattern, youtube_url)
+        if match:
+            return match.group(1)
+    
+    return None
+
+
+def extract_channel_id_from_url(channel_url: str) -> Optional[str]:
+    """Extract channel ID from YouTube channel URL"""
+    patterns = [
+        r'(?:channel\/)([UC][0-9A-Za-z_-]{22})',
+        r'(?:c\/)([^\/\?]+)',
+        r'(?:user\/)([^\/\?]+)',
+        r'(?:@)([^\/\?]+)'
+    ]
+    
+    for pattern in patterns:
+        match = re.search(pattern, channel_url)
+        if match:
+            return match.group(1)
+    
+    return None
+
+
+def extract_playlist_id_from_url(playlist_url: str) -> Optional[str]:
+    """Extract playlist ID from YouTube playlist URL"""
+    match = re.search(r'(?:list=)([0-9A-Za-z_-]+)', playlist_url)
+    if match:
+        return match.group(1)
+    return None
+
+
+def parse_youtube_duration(duration_str: str) -> int:
+    """Parse YouTube duration string (e.g., "PT4M13S") to seconds"""
+    if not duration_str:
+        return 0
+    
+    # Remove PT prefix
+    duration_str = duration_str.replace('PT', '')
+    
+    # Extract hours, minutes, seconds
+    hours = 0
+    minutes = 0
+    seconds = 0
+    
+    # Hours
+    hour_match = re.search(r'(\d+)H', duration_str)
+    if hour_match:
+        hours = int(hour_match.group(1))
+    
+    # Minutes
+    minute_match = re.search(r'(\d+)M', duration_str)
+    if minute_match:
+        minutes = int(minute_match.group(1))
+    
+    # Seconds
+    second_match = re.search(r'(\d+)S', duration_str)
+    if second_match:
+        seconds = int(second_match.group(1))
+    
+    return hours * 3600 + minutes * 60 + seconds
+
+
+def format_view_count(view_count: str) -> int:
+    """Parse YouTube view count string to integer"""
+    if not view_count:
+        return 0
+    
+    try:
+        # Remove non-numeric characters except for multipliers
+        view_count = view_count.replace(',', '').replace(' ', '').lower()
+        
+        multipliers = {
+            'k': 1000,
+            'm': 1000000,
+            'b': 1000000000,
+            't': 1000000000000
+        }
+        
+        for suffix, multiplier in multipliers.items():
+            if view_count.endswith(suffix):
+                number = float(view_count[:-1])
+                return int(number * multiplier)
+        
+        # Try to parse as regular integer
+        return int(''.join(filter(str.isdigit, view_count)))
+    
+    except (ValueError, TypeError):
+        return 0
+
+
+def parse_youtube_time(time_str: str) -> Optional[int]:
+    """Parse YouTube time string to timestamp"""
+    if not time_str:
+        return None
+    
+    try:
+        # Handle relative time like "2 hours ago", "1 day ago", etc.
+        if "ago" in time_str.lower():
+            time_str = time_str.lower().replace('ago', '').strip()
+            
+            if 'second' in time_str:
+                seconds = int(re.search(r'(\d+)', time_str).group(1))
+                return int(time.time()) - seconds
+            elif 'minute' in time_str:
+                minutes = int(re.search(r'(\d+)', time_str).group(1))
+                return int(time.time()) - minutes * 60
+            elif 'hour' in time_str:
+                hours = int(re.search(r'(\d+)', time_str).group(1))
+                return int(time.time()) - hours * 3600
+            elif 'day' in time_str:
+                days = int(re.search(r'(\d+)', time_str).group(1))
+                return int(time.time()) - days * 86400
+            elif 'week' in time_str:
+                weeks = int(re.search(r'(\d+)', time_str).group(1))
+                return int(time.time()) - weeks * 604800
+            elif 'month' in time_str:
+                months = int(re.search(r'(\d+)', time_str).group(1))
+                return int(time.time()) - months * 2592000  # Approximate
+            elif 'year' in time_str:
+                years = int(re.search(r'(\d+)', time_str).group(1))
+                return int(time.time()) - years * 31536000  # Approximate
+        
+        # Try to parse as timestamp
+        return int(time_str)
+    
+    except (ValueError, AttributeError):
+        return None
+
+
+def process_youtube_text(text: str) -> str:
+    """Process YouTube text content, remove HTML tags and clean up"""
+    if not text:
+        return ""
+    
+    # Remove HTML tags
+    text = re.sub(r'<[^>]+>', '', text)
+    
+    # Decode HTML entities
+    text = html.unescape(text)
+    
+    # Remove extra whitespace
+    text = re.sub(r'\s+', ' ', text).strip()
+    
+    return text
+
+
+def validate_youtube_data(video_data: Dict) -> bool:
+    """Validate if YouTube video data contains required fields"""
+    required_fields = ["videoId", "title"]
+    
+    for field in required_fields:
+        if field not in video_data:
+            return False
+    
+    return True
+
+
+def sanitize_filename(filename: str) -> str:
+    """Sanitize filename for file system"""
+    # Remove invalid characters
+    filename = re.sub(r'[<>:"/\\|?*]', '', filename)
+    # Remove extra spaces
+    filename = re.sub(r'\s+', ' ', filename).strip()
+    # Limit length
+    if len(filename) > 100:
+        filename = filename[:100]
+    
+    return filename or "untitled"
+
+
+def extract_ytcfg_data(html_content: str) -> Optional[Dict]:
+    """Extract ytcfg data from YouTube page HTML"""
+    try:
+        # Try to find ytcfg.set pattern
+        match = re.search(r'ytcfg\.set\s*\(\s*({.+?})\s*\)', html_content, re.DOTALL)
+        if match:
+            config_json = match.group(1)
+            return json.loads(config_json)
+    except (json.JSONDecodeError, IndexError):
+        pass
+    
+    return None
+
+
+def extract_initial_data(html_content: str) -> Optional[Dict]:
+    """Extract initial data from YouTube page HTML"""
+    try:
+        # Try to find var ytInitialData pattern
+        match = re.search(r'var ytInitialData = ({.+?});', html_content, re.DOTALL)
+        if not match:
+            # Try window.ytInitialData pattern
+            match = re.search(r'window\["ytInitialData"\] = ({.+?});', html_content, re.DOTALL)
+        
+        if match:
+            initial_data_json = match.group(1)
+            return json.loads(initial_data_json)
+    except (json.JSONDecodeError, IndexError):
+        pass
+    
+    return None
+
+
+def get_desktop_user_agent() -> str:
+    """Get a random desktop user agent for YouTube requests"""
+    ua_list = [
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:122.0) Gecko/20100101 Firefox/122.0",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2.1 Safari/605.1.15",
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36"
+    ]
+    return random.choice(ua_list)
+
+
+def build_search_url(query: str, search_type: SearchType = SearchType.ALL, 
+                    sort_by: SortType = SortType.RELEVANCE,
+                    upload_date: UploadDate = UploadDate.ANY,
+                    duration: Duration = Duration.ANY) -> str:
+    """Build YouTube search URL with filters"""
+    base_url = "https://www.youtube.com/results"
+    params = {"search_query": query}
+    
+    # Add search type filter
+    if search_type != SearchType.ALL:
+        params["sp"] = _get_search_params(search_type, sort_by, upload_date, duration)
+    
+    param_string = "&".join([f"{k}={v}" for k, v in params.items()])
+    return f"{base_url}?{param_string}"
+
+
+def _get_search_params(search_type: SearchType, sort_by: SortType, 
+                      upload_date: UploadDate, duration: Duration) -> str:
+    """Generate search parameters string for YouTube search filters"""
+    # This is a simplified version - YouTube's actual search parameters are more complex
+    # and may need to be reverse-engineered for full functionality
+    filters = []
+    
+    if search_type == SearchType.VIDEO:
+        filters.append("EgIQAQ%253D%253D")
+    elif search_type == SearchType.CHANNEL:
+        filters.append("EgIQAg%253D%253D")
+    elif search_type == SearchType.PLAYLIST:
+        filters.append("EgIQAw%253D%253D")
+    
+    return "".join(filters)
+
+
+# Exception classes
+class YouTubeError(Exception):
+    """Base exception for YouTube API errors"""
+    pass
+
+
+class NetworkError(YouTubeError):
+    """Network connection error"""
+    pass
+
+
+class DataExtractionError(YouTubeError):
+    """Data extraction error"""
+    pass
+
+
+class AuthenticationError(YouTubeError):
+    """Authentication error"""
+    pass
+
+
+class RateLimitError(YouTubeError):
+    """Rate limit exceeded error"""
+    pass
+
+
+class ContentNotFoundError(YouTubeError):
+    """Content not found error"""
+    pass
+
+
+class ValidationError(YouTubeError):
+    """Data validation error"""
+    pass
+
+
+def extract_continuation_token(data: Dict) -> Optional[str]:
+    """Extract continuation token for pagination"""
+    try:
+        # Look for continuation token in various possible locations
+        if isinstance(data, dict):
+            # Check common continuation locations
+            continuations = data.get("continuations", [])
+            if continuations and isinstance(continuations, list):
+                for continuation in continuations:
+                    if isinstance(continuation, dict):
+                        token = continuation.get("nextContinuationData", {}).get("continuation")
+                        if token:
+                            return token
+            
+            # Check other possible locations
+            reload_continuation = data.get("reloadContinuationData", {}).get("continuation")
+            if reload_continuation:
+                return reload_continuation
+    except Exception:
+        pass
+    
+    return None
+
+
+def decode_html_entities(text: str) -> str:
+    """Decode HTML entities in text"""
+    if not text:
+        return ""
+    
+    # Decode HTML entities
+    text = html.unescape(text)
+    
+    return text
+
+
+def extract_thumbnail_url(thumbnails: List[Dict]) -> str:
+    """Extract the best quality thumbnail URL from thumbnails list"""
+    if not thumbnails:
+        return ""
+    
+    # Sort by resolution and pick the highest quality
+    sorted_thumbnails = sorted(thumbnails, key=lambda x: x.get('width', 0) * x.get('height', 0), reverse=True)
+    
+    if sorted_thumbnails:
+        return sorted_thumbnails[0].get('url', '')
+    
+    return ""

{vibesurf-0.1.27.dist-info → vibesurf-0.1.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibesurf
-Version: 0.1.27
+Version: 0.1.29
 Summary: VibeSurf: A powerful browser assistant for vibe surfing
 Author: Shao Warm
 License: Apache-2.0
@@ -71,56 +71,88 @@ If you're as excited about open-source AI browsing as I am, give it a star! ⭐
 
 ## 🛠️ Installation
 
-### Step 1: Install uv
-Install uv from [https://docs.astral.sh/uv/getting-started/installation/](https://docs.astral.sh/uv/getting-started/installation/):
+Get VibeSurf up and running in just three simple steps. No complex configuration required.
 
+### 1. Install uv
+Install uv package manager from the official website
+
+**MacOS/Linux**
 ```bash
-# On macOS and Linux
 curl -LsSf https://astral.sh/uv/install.sh | sh
+```
 
-# On Windows
+**Windows**
+```bash
 powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
 ```
 
-### Step 2: Setup and Install
+### 2. Setup Environment
+Install VibeSurf
+
 ```bash
-uv venv --python 3.12
 uv pip install vibesurf -U
 ```
 
-### Step 3: Launch
+### 3. Launch VibeSurf
+Start the VibeSurf browser assistant
+
 ```bash
 uv run vibesurf
 ```
 
 ## 👩‍💻 For Contributors
 
-Want to contribute to VibeSurf? Here are two ways to set up your development environment:
+Want to contribute to VibeSurf? Follow these steps to set up your development environment:
 
-### Method 1: Direct Server Run
-Run the backend server directly using uvicorn:
+### 1. Clone Repository
 ```bash
-uvicorn vibe_surf.backend.main:app --host 127.0.0.1 --port 9335
+git clone https://github.com/vibesurf-ai/VibeSurf.git
+cd VibeSurf
 ```
 
-### Method 2: Editable Installation
-Install the package in editable mode and run using the CLI:
+### 2. Setup Environment
+**MacOS/Linux**
 ```bash
+uv venv --python 3.12
+source .venv/bin/activate
 uv pip install -e .
-uv run vibesurf
 ```
 
-Choose the method that works best for your development workflow!
-## �️ Roadmap
+**Windows**
+```bash
+uv venv --python 3.12
+.venv\Scripts\activate
+uv pip install -e .
+```
+
+### 3. Start Debugging
+**Option 1: Direct Server**
+```bash
+uvicorn vibe_surf.backend.main:app --host 127.0.0.1 --port 9335
+```
+
+**Option 2: CLI Entry**
+```bash
+uv run vibesurf
+```
+## 🗺️ Roadmap
 
 We're building VibeSurf to be your ultimate AI browser companion. Here's what's coming next:
 
-- [x] **Smart Skills System**: Add `/search` for quick information search and `/crawl` for automatic website data extraction
-- [ ] **Powerful Coding Agent**: Build a comprehensive coding assistant for data processing and analysis directly in your browser
-- [ ] **Third-Party Integrations**: Connect with n8n workflows and other tools to combine browsing with automation
-- [ ] **Custom Workflow Templates**: Create reusable templates for auto-login, data collection, and complex browser automation
-- [ ] **Smart Interaction Features**: Text selection for translation/Q&A, screenshot analysis, and voice reading capabilities
-- [ ] **Real-Time Conversation & Memory**: Add persistent chat functionality with global memory to make VibeSurf truly understand you
+- [x] **Smart Skills System** - *Completed*
+  Add `/search` for quick information search and `/crawl` for automatic website data extraction. Integrated native APIs for Xiaohongshu, Douyin, Weibo, and YouTube.
+
+- [ ] **Powerful Coding Agent** - *In Progress*
+  Build a comprehensive coding assistant for data processing and analysis directly in your browser
+
+- [ ] **Agentic Browser Workflow** - *Planned*
+  Create custom drag-and-drop workflows for auto-login, data collection, and complex browser automation tasks
+
+- [ ] **Third-Party Integrations** - *Planned*
+  Connect with n8n workflows and other tools to combine browsing with automation
+
+- [ ] **Intelligent Memory & Personalization** - *Planned*
+  Transform VibeSurf into a truly human-like companion with persistent memory that learns your preferences, habits, and browsing patterns over time
 
 
 ## 🎬 Demo

{vibesurf-0.1.27.dist-info → vibesurf-0.1.29.dist-info}/RECORD

@@ -1,5 +1,5 @@
 vibe_surf/__init__.py,sha256=WtduuMFGauMD_9dpk4fnRnLTAP6ka9Lfu0feAFNzLfo,339
-vibe_surf/_version.py,sha256=o2dyLbB_Uhc2yY2R7iheES_lRnDBGV9Hc4iNgiJ_XTo,706
+vibe_surf/_version.py,sha256=psmJDfuN2z6DlzPIrP1wLVvD7WuzzlJGAfailO2UuI0,706
 vibe_surf/cli.py,sha256=KAmUBsXfS-NkMp3ITxzNXwtFeKVmXJUDZiWqLcIC0BI,16690
 vibe_surf/common.py,sha256=_WWMxen5wFwzUjEShn3yDVC1OBFUiJ6Vccadi6tuG6w,1215
 vibe_surf/logger.py,sha256=k53MFA96QX6t9OfcOf1Zws8PP0OOqjVJfhUD3Do9lKw,3043
@@ -14,7 +14,7 @@ vibe_surf/agents/prompts/vibe_surf_prompt.py,sha256=hubN49_aD5LpkDGa0Z2AxGmUL04M
 vibe_surf/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vibe_surf/backend/llm_config.py,sha256=9V8Gg065TQALbOKQnOqFWd8RzOJjegOD8w6YOf90Q7Y,5036
 vibe_surf/backend/main.py,sha256=K57Bk7JtG1xTu2zmMZwPd5oUuReHDHzrRzsarcggCwg,7402
-vibe_surf/backend/shared_state.py,sha256=8tKfG9kHS7Rg4U0z7PSXqeS-Nr4MDJuGiCw6XrtSTqw,23478
+vibe_surf/backend/shared_state.py,sha256=eMh3W0zCJ12G9kYeqQMrCk5r-H3IR0Nce-_vUz4qaPA,23561
 vibe_surf/backend/voice_model_config.py,sha256=oee4fvOexXKzKRDv2-FEKQj7Z2OznACrj6mfWRGy7h0,567
 vibe_surf/backend/api/__init__.py,sha256=XxF1jUOORpLYCfFuPrrnUGRnOrr6ClH0_MNPU-4RnSs,68
 vibe_surf/backend/api/activity.py,sha256=_cnHusqolt5Hf3KdAf6FK-3sBc-TSaadmb5dJxGI57A,9398
@@ -46,14 +46,14 @@ vibe_surf/browser/watchdogs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 vibe_surf/browser/watchdogs/action_watchdog.py,sha256=6lM0nOR67clLzC6nVEMZ2Vam8VHDW8GRlg_jbGUHbPk,5297
 vibe_surf/browser/watchdogs/dom_watchdog.py,sha256=c0AJo2yckWFZqpgnPz7RbsRjcpwlhjD4mSIzCAbRn48,10994
 vibe_surf/chrome_extension/background.js,sha256=9YLbLmBl__PPUwN6Edf0EQfE53Br1VfjlUiIkznf4n4,30181
-vibe_surf/chrome_extension/config.js,sha256=g53UkfsaOFNC6fZG-THlBxdSjvswPsaQ9w8rxiHNq2E,1093
+vibe_surf/chrome_extension/config.js,sha256=rd4I2pyEWEYgVKIj7wEcwd8ouotm7ZlGwsRRSWMmAGY,1311
 vibe_surf/chrome_extension/content.js,sha256=cB67jK3vIE5zrpXAfi3p50H3EyTqK5xockOph0Q4kQg,13708
 vibe_surf/chrome_extension/dev-reload.js,sha256=xQpi-1Ekb5P8Ogsm6rUK09QzxafwH0H409zBKmaUFNw,1790
 vibe_surf/chrome_extension/manifest.json,sha256=B08nHuU-bPc-pUr30Y-of39TjMlrE7D5gP2sZjZ8CrE,1142
 vibe_surf/chrome_extension/permission-iframe.html,sha256=R6VM1JfrzkfXTTD5mGCKui1dDWTqHEe9n8TtVdZNPNg,948
 vibe_surf/chrome_extension/permission-request.html,sha256=ct1LTl_9euABiHcqNU6AFcvpCAfANWO0y_dDEAjtwfE,2905
 vibe_surf/chrome_extension/popup.html,sha256=n3dI_-WbILm0q8O_za6xX0WvOofz5lwT_7YXs0u9RAE,4248
-vibe_surf/chrome_extension/sidepanel.html,sha256=iivQHX867_xLDaiNCmeYveXnE6WpEV6YuMkXi9ek4qg,39706
+vibe_surf/chrome_extension/sidepanel.html,sha256=-afyeqX5BzYlp489svh22sazSyG2bgD85QHHbNeWYeY,36549
 vibe_surf/chrome_extension/icons/logo.icns,sha256=ZzY1eIKF4dNhNW4CeE1UBQloxNVC7bQx3qcClo3CnMQ,1569615
 vibe_surf/chrome_extension/icons/logo.png,sha256=PLmv1E6sCGXUE5ZDxr-pFPQd9Gvaw_f1TnYmF8VIssU,566385
 vibe_surf/chrome_extension/scripts/api-client.js,sha256=MkIKaTRU923QvHMLbhRNB1MgxIypi-Lau1wwg3lH-wU,15819
@@ -66,7 +66,7 @@ vibe_surf/chrome_extension/scripts/permission-iframe-request.js,sha256=JTin53qSN
 vibe_surf/chrome_extension/scripts/permission-request.js,sha256=9WEeTqMD0tHm1aX2ySkZgJ23siVZLZWAjVQe2dSmnoI,5168
 vibe_surf/chrome_extension/scripts/session-manager.js,sha256=rOPGDTyV1oK-qYfqJKK8mpvQFSdnz0_F0wCcbxPfTSw,21887
 vibe_surf/chrome_extension/scripts/settings-manager.js,sha256=9UGJFxQ1DbDbfndEBDv32MHfAW8YdfZmwg0vW6ABXOQ,77257
-vibe_surf/chrome_extension/scripts/ui-manager.js,sha256=1q-UFVQp_yFEtabKLtjvWegQo5d2C-zhL0e6ilVjzDI,122476
+vibe_surf/chrome_extension/scripts/ui-manager.js,sha256=A1dO6tFYoW7Ynh1eneSw_akVG_PtlioBhXhRHTVKQyU,129048
 vibe_surf/chrome_extension/scripts/user-settings-storage.js,sha256=5aGuHXwTokX5wKjdNnu3rVkZv9XoD15FmgCELRRE3Xw,14191
 vibe_surf/chrome_extension/scripts/voice-recorder.js,sha256=rIq9Rhyq-QyeCxJxxZGbnbPC0MCjQtNx6T2UC1g_al4,16852
 vibe_surf/chrome_extension/styles/activity.css,sha256=aEFa_abskrDQvwsesPVOyJW3rUQUEBQpMKPHhY94CoA,19601
@@ -96,9 +96,22 @@ vibe_surf/tools/vibesurf_registry.py,sha256=Z-8d9BrJl3RFMEK0Tw1Q5xNHX2kZGsnIGCTB
 vibe_surf/tools/vibesurf_tools.py,sha256=UY93Yft_Ni6D8k94t0afZ4x_EAbh1PGsWZ4RPr12So8,113828
 vibe_surf/tools/views.py,sha256=1b0y9Zl1GWmDFXUiZXntsWU-8U3xrOqXdpRld5efxgI,12257
 vibe_surf/tools/voice_asr.py,sha256=AJG0yq_Jq-j8ulDlbPhVFfK1jch9_ASesis73iki9II,4702
-vibesurf-0.1.27.dist-info/licenses/LICENSE,sha256=vRmTjOYvD8RLiSGYYmFHnveYNswtO1uvSk1sd-Eu7sg,2037
-vibesurf-0.1.27.dist-info/METADATA,sha256=JAb_jozN1kp1YVRowpkkoX0xx1eWm_3bo-GLST2bjPo,5836
-vibesurf-0.1.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-vibesurf-0.1.27.dist-info/entry_points.txt,sha256=UxqpvMocL-PR33S6vLF2OmXn-kVzM-DneMeZeHcPMM8,48
-vibesurf-0.1.27.dist-info/top_level.txt,sha256=VPZGHqSb6EEqcJ4ZX6bHIuWfon5f6HXl3c7BYpbRqnY,10
-vibesurf-0.1.27.dist-info/RECORD,,
+vibe_surf/tools/website_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vibe_surf/tools/website_api/douyin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vibe_surf/tools/website_api/douyin/client.py,sha256=fNAI_16kBoPgSH_kGkgO7NJs3v1UitrXmT2ChbAWphE,32868
+vibe_surf/tools/website_api/douyin/helpers.py,sha256=nxXSIYxDXn9L8xpCPojyP7ZFhlH7I81ex7dB2f50Sks,6577
+vibe_surf/tools/website_api/weibo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vibe_surf/tools/website_api/weibo/client.py,sha256=VOroVWL2IDIBaoMwc5MIA23EM3a5JM6PokxDAtGYElk,32960
+vibe_surf/tools/website_api/weibo/helpers.py,sha256=kFrbKr98Z3UydsEiNoLM0wBQhItYrpH0Q9BE-g2Y-Xg,37099
+vibe_surf/tools/website_api/xhs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vibe_surf/tools/website_api/xhs/client.py,sha256=pKtq_d78C-XqvcpmxCEGsd3zftGkfCkF66o-XTmxk00,30858
+vibe_surf/tools/website_api/xhs/helpers.py,sha256=Dq2RyYKClBQ2ha2yEfpS1mtZswx0z9gdB2Wyljc83SI,10448
+vibe_surf/tools/website_api/youtube/__init__.py,sha256=QWmZWSqo1O6XtaWP-SuL3HrBLYINjEWEyOy-KCytGDw,1145
+vibe_surf/tools/website_api/youtube/client.py,sha256=GgrAvv_DWbnLHW59PnOXEHeO05s9_Abaakk-JzJ_UTc,48887
+vibe_surf/tools/website_api/youtube/helpers.py,sha256=GPgqfNirLYjIpk1OObvoXd2Ktq-ahKOOKHO2WwQVXCw,12931
+vibesurf-0.1.29.dist-info/licenses/LICENSE,sha256=vRmTjOYvD8RLiSGYYmFHnveYNswtO1uvSk1sd-Eu7sg,2037
+vibesurf-0.1.29.dist-info/METADATA,sha256=6rV5k10cSipLQ7k5kWg4SLbU_Apua1gy6PLe7QAWIuQ,6109
+vibesurf-0.1.29.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vibesurf-0.1.29.dist-info/entry_points.txt,sha256=UxqpvMocL-PR33S6vLF2OmXn-kVzM-DneMeZeHcPMM8,48
+vibesurf-0.1.29.dist-info/top_level.txt,sha256=VPZGHqSb6EEqcJ4ZX6bHIuWfon5f6HXl3c7BYpbRqnY,10
+vibesurf-0.1.29.dist-info/RECORD,,