vibesurf 0.1.26__py3-none-any.whl → 0.1.28__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.26.dist-info → vibesurf-0.1.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibesurf
-Version: 0.1.26
+Version: 0.1.28
 Summary: VibeSurf: A powerful browser assistant for vibe surfing
 Author: Shao Warm
 License: Apache-2.0
@@ -44,16 +44,19 @@ Requires-Dist: markdownify>=1.2.0
 Requires-Dist: pathvalidate>=3.3.1
 Requires-Dist: dashscope>=1.24.5
 Requires-Dist: yfinance>=0.2.66
+Requires-Dist: pyexecjs>=1.5.1
 Dynamic: license-file
 
 # VibeSurf: A powerful browser assistant for vibe surfing
-[![Discord](https://img.shields.io/discord/1303749220842340412?color=7289DA&label=Discord&logo=discord&logoColor=white)](https://discord.gg/TXNnP9gJ)
+[![Discord](https://img.shields.io/discord/1303749220842340412?color=7289DA&label=Discord&logo=discord&logoColor=white)](https://discord.gg/EZ2YnUXP)
 [![WarmShao](https://img.shields.io/twitter/follow/warmshao?style=social)](https://x.com/warmshao)
 
 VibeSurf is an open-source AI agentic browser that revolutionizes browser automation and research.
 
 If you're as excited about open-source AI browsing as I am, give it a star! ⭐
 
+[中文](README_zh.md) | [English](README.md)
+
 ## ✨ Key Features
 
 - 🧠 **Advanced AI Automation**: Beyond browser automation, VibeSurf performs deep research, intelligent crawling, content summarization, and more to exploration.
@@ -90,11 +93,29 @@ uv pip install vibesurf -U
 uv run vibesurf
 ```
 
-## 🗺️ Roadmap
+## 👩‍💻 For Contributors
+
+Want to contribute to VibeSurf? Here are two ways to set up your development environment:
+
+### Method 1: Direct Server Run
+Run the backend server directly using uvicorn:
+```bash
+uvicorn vibe_surf.backend.main:app --host 127.0.0.1 --port 9335
+```
+
+### Method 2: Editable Installation
+Install the package in editable mode and run using the CLI:
+```bash
+uv pip install -e .
+uv run vibesurf
+```
+
+Choose the method that works best for your development workflow!
+## �️ Roadmap
 
 We're building VibeSurf to be your ultimate AI browser companion. Here's what's coming next:
 
-- [ ] **Smart Skills System**: Add `/search` for quick information search and `/crawl` for automatic website data extraction
+- [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
@@ -113,7 +134,7 @@ We're building VibeSurf to be your ultimate AI browser companion. Here's what's
 
 ## 📝 License
 
-Licensed under the [Apache License 2.0](LICENSE).
+This repository is licensed under the [VibeSurf Open Source License](./LICENSE), based on Apache 2.0 with additional conditions.
 
 ## 👏 Acknowledgments
 

{vibesurf-0.1.26.dist-info → vibesurf-0.1.28.dist-info}/RECORD

@@ -1,12 +1,12 @@
 vibe_surf/__init__.py,sha256=WtduuMFGauMD_9dpk4fnRnLTAP6ka9Lfu0feAFNzLfo,339
-vibe_surf/_version.py,sha256=Y9o7KiJWiG6n9XbSpMICgNgajFRbL4an-gN1BQc-jwM,706
+vibe_surf/_version.py,sha256=1F4XTGwwdJozvgbsUgvu0kddraJ7P8oKbqLP8wGuYI8,706
 vibe_surf/cli.py,sha256=KAmUBsXfS-NkMp3ITxzNXwtFeKVmXJUDZiWqLcIC0BI,16690
 vibe_surf/common.py,sha256=_WWMxen5wFwzUjEShn3yDVC1OBFUiJ6Vccadi6tuG6w,1215
 vibe_surf/logger.py,sha256=k53MFA96QX6t9OfcOf1Zws8PP0OOqjVJfhUD3Do9lKw,3043
 vibe_surf/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vibe_surf/agents/browser_use_agent.py,sha256=jeUYV7yk6vyycw6liju_597GdjB3CW_B2wEhn2F0ekk,45957
 vibe_surf/agents/report_writer_agent.py,sha256=pCF2k6VLyO-sSviGBqqIyVD3SLqaZtSqiW3kvNfPY1I,20967
-vibe_surf/agents/vibe_surf_agent.py,sha256=sTUO4xAiznr7RRzdrRYzXENos9XovicZw8ow2UuJsyI,74286
+vibe_surf/agents/vibe_surf_agent.py,sha256=cOQvZJrE4WBnirgN_PW-GfVSnPKI5G5FwW2AA5bTqew,74162
 vibe_surf/agents/views.py,sha256=yHjNJloa-aofVTGyuRy08tBYP_Y3XLqt1DUWOUmHRng,4825
 vibe_surf/agents/prompts/__init__.py,sha256=l4ieA0D8kLJthyNN85FKLNe4ExBa3stY3l-aImLDRD0,36
 vibe_surf/agents/prompts/report_writer_prompt.py,sha256=sZE8MUT1CDLmRzbnbEQzAvTwJjpITgh2Q8g1_eXmkzE,4454
@@ -39,7 +39,7 @@ vibe_surf/backend/utils/encryption.py,sha256=CjLNh_n0Luhfa-6BB-icfzkiiDqj5b4Gu6M
 vibe_surf/backend/utils/llm_factory.py,sha256=XIJYc9Lh_L2vbwlAe96PrjptlzJtLOjCGNdHEx6fThk,9047
 vibe_surf/browser/__init__.py,sha256=_UToO2fZfSCrfjOcxhn4Qq7ZLbYeyPuUUEmqIva-Yv8,325
 vibe_surf/browser/agen_browser_profile.py,sha256=J06hCBJSJ-zAFVM9yDFz8UpmiLuFyWke1EMekpU45eo,5871
-vibe_surf/browser/agent_browser_session.py,sha256=xV0nHo_TCb7b7QYhIee4cLzH-1rqJswYwH7GEwyQmqc,33980
+vibe_surf/browser/agent_browser_session.py,sha256=9bCQkPNEy88-04gB9njBrbuoFBhIYF_SxueZfFe5RCM,35662
 vibe_surf/browser/browser_manager.py,sha256=PFJ9flmqR2uokuRZ3PDh_Dy6_6qcQ6kH_eRc1yT6Iq8,11257
 vibe_surf/browser/utils.py,sha256=bBtpMiyz2ixWOr31GbJwZ8pVYcnxztKjTJJO92z1BDY,35742
 vibe_surf/browser/watchdogs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -87,18 +87,31 @@ vibe_surf/chrome_extension/styles/variables.css,sha256=enjyhsa0PeU3b-3uiXa-VkV-1
 vibe_surf/llm/__init__.py,sha256=_vDVPo6STf343p1SgMQrF5023hicAx0g83pK2Gbk4Ek,601
 vibe_surf/llm/openai_compatible.py,sha256=i0a5OLaL6QIlacVyctOG09vKr3KOi8T8Izp1v7xkD5I,16112
 vibe_surf/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vibe_surf/tools/browser_use_tools.py,sha256=tacxKUJL6uOt04f52_iIw1cs-FT-mBgIPmAsIc4Hww0,23730
+vibe_surf/tools/browser_use_tools.py,sha256=ALJOoPiwG3HSR_UZZpi_1f8cQngcAEKiap8ojIgdQlo,31586
 vibe_surf/tools/file_system.py,sha256=Tw_6J5QjCahQ3fd26CXziF1zPvRxhYM0889oK4bDhlU,19304
 vibe_surf/tools/finance_tools.py,sha256=E8rmblp57e_cp0tFbdZ7BY3_upNlk4Whk0bYc_SFCJE,27284
 vibe_surf/tools/mcp_client.py,sha256=OeCoTgyx4MoY7JxXndK6pGHIoyFOhf5r7XCbx25y1Ec,2446
 vibe_surf/tools/report_writer_tools.py,sha256=2CyTTXOahTKZo7XwyWDDhJ--1mRA0uTtUWxu_DACAY0,776
 vibe_surf/tools/vibesurf_registry.py,sha256=Z-8d9BrJl3RFMEK0Tw1Q5xNHX2kZGsnIGCTBZ3RM-pw,2159
-vibe_surf/tools/vibesurf_tools.py,sha256=O8y1noWyY8y-j8I7vF4oOaVDybINNXiNXWNwGJJ5xsM,91500
-vibe_surf/tools/views.py,sha256=AEAPzML-lqWJ7dBMjXTl7o-rk4hp5PGaPRqLyilJUl8,7789
+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.26.dist-info/licenses/LICENSE,sha256=czn6QYya0-jhLnStD9JqnMS-hwP5wRByipkrGTvoXLI,11355
-vibesurf-0.1.26.dist-info/METADATA,sha256=8Bdh3-15Hl0KbmB0ghk9KNQiveDnVGnhzZ-4Dv0MVjc,5190
-vibesurf-0.1.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-vibesurf-0.1.26.dist-info/entry_points.txt,sha256=UxqpvMocL-PR33S6vLF2OmXn-kVzM-DneMeZeHcPMM8,48
-vibesurf-0.1.26.dist-info/top_level.txt,sha256=VPZGHqSb6EEqcJ4ZX6bHIuWfon5f6HXl3c7BYpbRqnY,10
-vibesurf-0.1.26.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.28.dist-info/licenses/LICENSE,sha256=vRmTjOYvD8RLiSGYYmFHnveYNswtO1uvSk1sd-Eu7sg,2037
+vibesurf-0.1.28.dist-info/METADATA,sha256=U6C7JrFMHsY3tm1XEF9KqU4LCTEvxOuRO1eAL2Gyj5c,5836
+vibesurf-0.1.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vibesurf-0.1.28.dist-info/entry_points.txt,sha256=UxqpvMocL-PR33S6vLF2OmXn-kVzM-DneMeZeHcPMM8,48
+vibesurf-0.1.28.dist-info/top_level.txt,sha256=VPZGHqSb6EEqcJ4ZX6bHIuWfon5f6HXl3c7BYpbRqnY,10
+vibesurf-0.1.28.dist-info/RECORD,,

vibesurf-0.1.28.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+# Open Source License
+
+VibeSurf is licensed under a modified version of the Apache License 2.0, with the following additional conditions:
+
+1. VibeSurf may be utilized commercially, including as a backend service for other applications or as an application development platform for enterprises. Should the conditions below be met, a commercial license must be obtained from the producer:
+
+a. Multi-tenant service: Unless explicitly authorized by VibeSurf in writing, you may not use the VibeSurf source code to operate a multi-tenant environment.
+    - Tenant Definition: Within the context of VibeSurf, one tenant corresponds to one workspace. The workspace provides a separated area for each tenant's data and configurations.
+
+b. LOGO and copyright information: In the process of using VibeSurf's frontend, you may not remove or modify the LOGO or copyright information in the VibeSurf console or applications. This restriction is inapplicable to uses of VibeSurf that do not involve its frontend.
+    - Frontend Definition: For the purposes of this license, the "frontend" of VibeSurf includes all components located in the `vibe_surf/chrome_extension/` directory when running VibeSurf from the raw source code, or the corresponding frontend container/image when running VibeSurf with Docker or other containerization.
+
+2. As a contributor, you should agree that:
+
+a. The producer can adjust the open-source agreement to be more strict or relaxed as deemed necessary.
+b. Your contributed code may be used for commercial purposes, including but not limited to its cloud business operations.
+
+Apart from the specific conditions mentioned above, all other rights and restrictions follow the Apache License 2.0. Detailed information about the Apache License 2.0 can be found at http://www.apache.org/licenses/LICENSE-2.0.
+
+The interactive design of this product is protected by appearance patent.
+
+© 2025 VibeSurf Authors. This repository is licensed under the VibeSurf Open Source License, based on Apache 2.0 with additional conditions.