entari-plugin-hyw 4.0.0rc6__py3-none-any.whl → 4.0.0rc8__py3-none-any.whl

hyw_core/browser_control/engines/__init__.py

@@ -0,0 +1,17 @@
+"""
+Search Engines Package
+
+Provides search engine adapters for different search providers.
+"""
+
+from .base import SearchEngine
+from .google import GoogleEngine
+from .duckduckgo import DuckDuckGoEngine
+from .default import DefaultEngine
+
+__all__ = [
+    "SearchEngine",
+    "GoogleEngine", 
+    "DuckDuckGoEngine",
+    "DefaultEngine",
+]

hyw_core/browser_control/engines/default.py

@@ -0,0 +1,166 @@
+
+import urllib.parse
+import re
+from typing import List, Dict, Any
+from loguru import logger
+from .base import SearchEngine
+
+
+class DefaultEngine(SearchEngine):
+    """
+    Default browser address bar search engine.
+    Uses the browser's address bar to search (Ctrl+L -> type -> Enter).
+    This uses whatever default search engine the browser is configured with.
+    """
+    
+    # Special marker to indicate this engine uses address bar input
+    USE_ADDRESS_BAR = True
+    
+    def build_url(self, query: str, limit: int = 10) -> str:
+        """
+        For address bar search, we don't build a URL.
+        Return the raw query - SearchService will handle the address bar input.
+        """
+        # Return a special marker so SearchService knows to use address bar
+        return f"__ADDRESS_BAR_SEARCH__:{query}"
+
+    def parse(self, content: str) -> List[Dict[str, Any]]:
+        """
+        Parse search results from whatever search engine the browser uses.
+        We detect the engine from the HTML and use appropriate parsing.
+        """
+        results = []
+        seen_urls = set()
+        
+        # Detect which search engine based on content
+        is_google = 'google' in content.lower() and ('class="g"' in content or 'data-hveid' in content)
+        is_bing = 'bing' in content.lower() and 'b_algo' in content
+        is_duckduckgo = 'duckduckgo' in content.lower()
+        
+        if is_google:
+            results = self._parse_google(content, seen_urls)
+        elif is_bing:
+            results = self._parse_bing(content, seen_urls)
+        elif is_duckduckgo:
+            results = self._parse_duckduckgo(content, seen_urls)
+        else:
+            # Generic fallback
+            results = self._parse_generic(content, seen_urls)
+        
+        logger.info(f"DefaultEngine parsed {len(results)} results (detected: {'google' if is_google else 'bing' if is_bing else 'ddg' if is_duckduckgo else 'generic'})")
+        return results
+    
+    def _parse_google(self, content: str, seen_urls: set) -> List[Dict[str, Any]]:
+        """Parse Google search results."""
+        results = []
+        # Look for result links
+        link_regex = re.compile(
+            r'<a[^>]+href="(https?://(?!google\.com|accounts\.google)[^"]+)"[^>]*>([^<]+)</a>',
+            re.IGNORECASE
+        )
+        
+        for match in link_regex.finditer(content):
+            if len(results) >= 15:
+                break
+            href = match.group(1)
+            title = match.group(2).strip()
+            
+            if href in seen_urls or not title or len(title) < 3:
+                continue
+            if any(x in href for x in ['google.com', 'gstatic.com', 'youtube.com/redirect']):
+                continue
+                
+            seen_urls.add(href)
+            results.append({
+                "title": re.sub(r'<[^>]+>', '', title),
+                "url": href,
+                "domain": urllib.parse.urlparse(href).hostname or "",
+                "content": "",
+            })
+        return results
+    
+    def _parse_bing(self, content: str, seen_urls: set) -> List[Dict[str, Any]]:
+        """Parse Bing search results."""
+        results = []
+        link_regex = re.compile(
+            r'<a[^>]+href="(https?://(?!bing\.com|microsoft\.com)[^"]+)"[^>]*>(.*?)</a>',
+            re.IGNORECASE | re.DOTALL
+        )
+        
+        for match in link_regex.finditer(content):
+            if len(results) >= 15:
+                break
+            href = match.group(1)
+            title_html = match.group(2)
+            title = re.sub(r'<[^>]+>', '', title_html).strip()
+            
+            if href in seen_urls or not title or len(title) < 3:
+                continue
+            if any(x in href for x in ['bing.com', 'microsoft.com', 'msn.com']):
+                continue
+                
+            seen_urls.add(href)
+            results.append({
+                "title": title,
+                "url": href,
+                "domain": urllib.parse.urlparse(href).hostname or "",
+                "content": "",
+            })
+        return results
+    
+    def _parse_duckduckgo(self, content: str, seen_urls: set) -> List[Dict[str, Any]]:
+        """Parse DuckDuckGo results."""
+        results = []
+        link_regex = re.compile(
+            r'<a[^>]+href="(https?://(?!duckduckgo\.com)[^"]+)"[^>]*>(.*?)</a>',
+            re.IGNORECASE | re.DOTALL
+        )
+        
+        for match in link_regex.finditer(content):
+            if len(results) >= 15:
+                break
+            href = match.group(1)
+            title_html = match.group(2)
+            title = re.sub(r'<[^>]+>', '', title_html).strip()
+            
+            if href in seen_urls or not title or len(title) < 3:
+                continue
+                
+            seen_urls.add(href)
+            results.append({
+                "title": title,
+                "url": href,
+                "domain": urllib.parse.urlparse(href).hostname or "",
+                "content": "",
+            })
+        return results
+    
+    def _parse_generic(self, content: str, seen_urls: set) -> List[Dict[str, Any]]:
+        """Generic link parser for unknown search engines."""
+        results = []
+        link_regex = re.compile(
+            r'<a[^>]+href="(https?://[^"]+)"[^>]*>([^<]+)</a>',
+            re.IGNORECASE
+        )
+        
+        for match in link_regex.finditer(content):
+            if len(results) >= 15:
+                break
+            href = match.group(1)
+            title = match.group(2).strip()
+            
+            if href in seen_urls or not title or len(title) < 5:
+                continue
+            # Skip common non-result URLs
+            if any(x in href for x in ['javascript:', 'mailto:', '#', 'login', 'signin', 'account']):
+                continue
+                
+            seen_urls.add(href)
+            results.append({
+                "title": title,
+                "url": href,
+                "domain": urllib.parse.urlparse(href).hostname or "",
+                "content": "",
+            })
+        return results
+

{entari_plugin_hyw/browser → hyw_core/browser_control}/engines/duckduckgo.py

@@ -31,8 +31,10 @@ class DuckDuckGoEngine(SearchEngine):
         results = []
         seen_urls = set()
         
-        # Simple regex for DDG Lite / SearXNG HTML structure
-        link_regex = re.compile(r'<a[^>]+href=["\'](http[^"\']+)["\'][^>]*>(.*?)</a>', re.IGNORECASE | re.DOTALL)
+        # More robust regex: capture ANY href, not just http
+        # Matches: <a ... href="..." ...>(...)</a>
+        # We capture the full hook to extract title + url
+        link_regex = re.compile(r'<a[^>]+href=["\']([^"\']+)["\'][^>]*>(.*?)</a>', re.IGNORECASE | re.DOTALL)
         
         pos = 0
         while True:
@@ -40,7 +42,7 @@ class DuckDuckGoEngine(SearchEngine):
             if not match:
                 break
             
-            href = match.group(1)
+            raw_href = match.group(1)
             title_html = match.group(2)
             
             # Clean title
@@ -48,17 +50,49 @@ class DuckDuckGoEngine(SearchEngine):
             
             pos = match.end()
             
+            # 1. Resolve relative URLs (DDG Lite uses /l/?uddg=...)
+            if raw_href.startswith('/'):
+                href = "https://lite.duckduckgo.com" + raw_href
+            else:
+                href = raw_href
+                
+            # 2. Decode DDG redirect (uddg=...)
+            # e.g. /l/?uddg=http%3A%2F%2Fexample.com&rut=...
+            if "uddg=" in href:
+                try:
+                    parsed = urllib.parse.urlparse(href)
+                    qs = urllib.parse.parse_qs(parsed.query)
+                    if 'uddg' in qs:
+                        href = qs['uddg'][0]
+                except: pass
+            
             # Filter junk
+            if not href.startswith("http"): continue
             if "search" in href and "q=" in href: continue 
             if "google.com" in href or "bing.com" in href: continue
+            if "duckduckgo.com" in href: continue # Filter self links
             if href in seen_urls: continue
             
-            # Look ahead for snippet
-            snippet_chunk = content[pos:pos+1000]
-            snippet_match = re.search(r'(.*?)<a', snippet_chunk, re.DOTALL | re.IGNORECASE)
-            raw_snippet = snippet_match.group(1) if snippet_match else snippet_chunk
+            # Improved Snippet Extraction:
+            # The structure is consistently:
+            # <a ... class="result-link">...</a>
+            # ...
+            # <td class="result-snippet">...</td>
             
-            # Clean HTML tags from snippet
+            # Search for the snippet cell specifically associated with this result
+            # We search in a reasonable window after the title link
+            snippet_window = content[pos:pos+2000]
+            snippet_match = re.search(r'class=["\']result-snippet["\'][^>]*>(.*?)</td>', snippet_window, re.IGNORECASE | re.DOTALL)
+            
+            if snippet_match:
+                raw_snippet = snippet_match.group(1)
+            else:
+                # Fallback to old behavior if structural match fails (e.g. slight layout change)
+                # But stop at 'link-text' span or next anchor to avoid junk
+                fallback_match = re.search(r'(.*?)(?:<a|<span class=["\']link-text)', snippet_window, re.DOTALL | re.IGNORECASE)
+                raw_snippet = fallback_match.group(1) if fallback_match else ""
+
+            # Clean HTML tags
             snippet = re.sub(r'<[^>]+>', ' ', raw_snippet)
             snippet = re.sub(r'\s+', ' ', snippet).strip()
             

{entari_plugin_hyw/browser → hyw_core/browser_control}/engines/google.py

@@ -14,7 +14,7 @@ class GoogleEngine(SearchEngine):
     
     def build_url(self, query: str, limit: int = 10) -> str:
         encoded_query = urllib.parse.quote(query)
-        return f"https://www.google.com/search?q={encoded_query}"
+        return f"https://www.google.com/search?q={encoded_query}&udm=14"
 
     def parse(self, content: str) -> List[Dict[str, Any]]:
         results = []

{entari_plugin_hyw/browser → hyw_core/browser_control}/manager.py

@@ -65,7 +65,7 @@ class SharedBrowserManager:
             # Hide scrollbars globally
             co.set_argument('--hide-scrollbars')
             # 十万的原因是滚动条屏蔽(大概吧)
-            co.set_argument('--window-size=1280,20000')
+            co.set_argument('--window-size=1280,800')
             self._page = ChromiumPage(addr_or_opts=co)
             
             # Show Landing Page
@@ -94,13 +94,20 @@ class SharedBrowserManager:
             self.start()
         return self._page
 
-    def new_tab(self, url: str) -> Any:
-        """Thread-safe tab creation."""
-        with self._tab_lock:
-            page = self.page
-            if not page:
-                raise RuntimeError("Browser not available")
-            return page.new_tab(url)
+    def new_tab(self, url: str = None) -> Any:
+        """
+        Thread-safe tab creation.
+        DrissionPage is thread-safe for tab creation, so we call it directly
+        to allow atomic creation+navigation (Target.createTarget with url)
+        without blocking other threads.
+        """
+        page = self.page
+        if not page:
+             raise RuntimeError("Browser not available")
+        
+        # Direct call allows Chrome to handle creation and navigation atomically and concurrently
+        return page.new_tab(url)
+
     
     def close(self):
         """Shutdown the browser."""

entari_plugin_hyw/render_vue.py → hyw_core/browser_control/renderer.py

@@ -12,7 +12,7 @@ from typing import List, Dict, Any, Optional
 from concurrent.futures import ThreadPoolExecutor
 
 from loguru import logger
-from .browser.manager import SharedBrowserManager
+from .manager import SharedBrowserManager, get_shared_browser_manager
 
 
 class ContentRenderer:
@@ -23,6 +23,7 @@ class ContentRenderer:
         
         if template_path is None:
             current_dir = Path(__file__).parent
+            # Use card-dist which has properly inlined JS (viteSingleFile)
             template_path = current_dir / "assets" / "card-dist" / "index.html"
         
         self.template_path = Path(template_path)
@@ -42,7 +43,6 @@ class ContentRenderer:
     def _ensure_manager(self):
         """Ensure shared browser manager exists."""
         if not self._manager:
-            from .browser.manager import get_shared_browser_manager
             self._manager = get_shared_browser_manager(headless=self.headless)
 
     async def start(self, timeout: int = 6000):
@@ -55,6 +55,18 @@ class ContentRenderer:
         loop = asyncio.get_running_loop()
         return await loop.run_in_executor(self._executor, self._prepare_tab_sync)
 
+    def _wait_for_render_finished(self, tab, timeout: float = 3.0):
+        """Wait for window.RENDER_FINISHED to be true in the tab."""
+        import time as pytime
+        start = pytime.time()
+        while pytime.time() - start < timeout:
+            is_finished = tab.run_js("return window.RENDER_FINISHED")
+            if is_finished:
+                return True
+            pytime.sleep(0.05) # Fast polling
+        logger.warning(f"ContentRenderer: Wait for RENDER_FINISHED timed out after {timeout}s")
+        return False
+
     def _prepare_tab_sync(self) -> str:
         """Create and warm up a new tab, return its ID."""
         import time as pytimeout
@@ -64,10 +76,10 @@ class ContentRenderer:
             tab = self._manager.new_tab(self.template_path.as_uri())
             tab_id = tab.tab_id
             
-            # Basic wait
-            tab.wait(1)
+            # Wait for app to mount instead of fixed 1s
+            tab.ele('#app', timeout=5)
             
-            # Pre-warm
+            # Pre-warm with data to trigger Vue render
             warmup_data = {
                 "markdown": "# Ready",
                 "total_time": 0,
@@ -77,8 +89,11 @@ class ContentRenderer:
                 "theme_color": "#ef4444",
             }
             
-            if tab.ele('#app', timeout=5):
-                tab.run_js(f"window.updateRenderData({json.dumps(warmup_data)})")
+            tab.run_js(f"window.updateRenderData({json.dumps(warmup_data)})")
+            self._wait_for_render_finished(tab, timeout=5.0)
+            
+            # Wait for main-container after warmup (Vue needs to render it)
+            tab.ele('#main-container', timeout=3)
             
             elapsed = pytimeout.time() - start
             logger.info(f"ContentRenderer: Prepared tab {tab_id} in {elapsed:.2f}s")
@@ -186,9 +201,9 @@ class ContentRenderer:
                 "theme_color": theme_color,
             }
             
-            # 1. Update Data & Settle
+            # 1. Update Data & Wait for Finished flag
             tab.run_js(f"window.updateRenderData({json.dumps(render_data)})")
-            tab.wait(0.5) # Since images are Base64, decoding is nearly instant once injected
+            self._wait_for_render_finished(tab)
 
             # 2. Dynamic Resize
             # Get actual content height to prevent clipping
@@ -196,7 +211,7 @@ class ContentRenderer:
             viewport_height = int(scroll_height) + 200
             
             tab.run_cdp('Emulation.setDeviceMetricsOverride', 
-                width=1920, height=viewport_height, deviceScaleFactor=1, mobile=False
+                width=1440, height=viewport_height, deviceScaleFactor=1, mobile=False
             )
             
             # 3. Hide Scrollbars (Now that viewport is large enough, overflow:hidden won't clip)
@@ -297,7 +312,7 @@ class ContentRenderer:
             if not tab:
                 logger.warning("ContentRenderer: Pre-warmed tab not found, creating new.")
                 tab = page.new_tab(self.template_path.as_uri())
-                tab.wait(0.5)
+                tab.ele('#app', timeout=5)
             
             resolved_output_path = Path(output_path).resolve()
             resolved_output_path.parent.mkdir(parents=True, exist_ok=True)
@@ -317,15 +332,15 @@ class ContentRenderer:
             
             tab.run_js(f"window.updateRenderData({json.dumps(render_data)})")
 
-            # Brief settle wait for masonry/images
-            tab.wait(0.6)
+            # Wait for event-driven finish
+            self._wait_for_render_finished(tab, timeout=5.0)
             
             # Dynamic Resize
             scroll_height = tab.run_js('return Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);')
             viewport_height = int(scroll_height) + 200
             
             tab.run_cdp('Emulation.setDeviceMetricsOverride', 
-                width=1920, height=viewport_height, deviceScaleFactor=1, mobile=False
+                width=1440, height=viewport_height, deviceScaleFactor=1, mobile=False
             )
             
             # Hide scrollbars