unrealon 1.1.1__py3-none-any.whl → 1.1.4__py3-none-any.whl

unrealon-1.1.4.dist-info/RECORD

@@ -0,0 +1,54 @@
+unrealon/__init__.py,sha256=EEqg3RwVJZpXddYS8ANBYoOLa2hE2B-JDY8VUxHdvno,922
+unrealon_browser/README.md,sha256=9pP6RrfMGHtdT5uDLFAUB1e4nNGzZudXViEo1940gKw,396
+unrealon_browser/__init__.py,sha256=kvp3aZApfvP__iAnFzsHI25XKS9IWnt9znUI9YZbgAk,1428
+unrealon_browser/cli/__init__.py,sha256=b3r88oeCYsqZF8EU8EZXP9v54Q8cIimN7UmxJsXcB84,264
+unrealon_browser/cli/browser_cli.py,sha256=SRRCGbNXaEg1ZN04-jPo9GOWcP2b6Bkalu6PYVOOt5k,8342
+unrealon_browser/cli/cookies_cli.py,sha256=yhZvGrg8bknlH4zlySdi8ue-25Ue-1rI_u1G06OIMg4,13304
+unrealon_browser/cli/interactive_mode.py,sha256=iYt9PNaIBhNjZ9aUa1ZxeeneV2u1VTSkYQ6rsyio-o8,11730
+unrealon_browser/cli/main.py,sha256=XCYcTxJUqaz320KCU_JPKizYMk6bdljb8Boyok3uO-4,1353
+unrealon_browser/core/__init__.py,sha256=uVL_t4sZelUzflWPdgrwoXGnAkSV1WNQ98-eu0QB2eM,151
+unrealon_browser/core/browser_manager.py,sha256=uCr0VYjLCep9Nr1b60wtUDEqLEdvqWae0sAZYzH61vo,26334
+unrealon_browser/dto/__init__.py,sha256=p9mG2QwnXEdHUHYK67vGD6aameM8RkiVATzz8y0u5EE,1206
+unrealon_browser/dto/models/config.py,sha256=XSUkWyam-LWRbqlx1qE9GPosaJZo1ZsW-o_ARyaQ--Q,1019
+unrealon_browser/dto/models/core.py,sha256=HvbwYG27rmmWtp401uws7lfalN_9QPad0M6ceCiN5iQ,2741
+unrealon_browser/dto/models/dataclasses.py,sha256=zqhJVyzp4CvtuTBsZwm6n6TodVWrZf9gkdDG-0_tgeA,2571
+unrealon_browser/dto/models/detection.py,sha256=ma9ZNIjPR7HnjqZaAj6ZoskiewPFiSn_FgFXSkgiQc8,2715
+unrealon_browser/dto/models/enums.py,sha256=Q4WzHdfSKf7dhKyX00i_Pvl2U8w3lBsxOYfSIoaQY3Q,1219
+unrealon_browser/dto/models/statistics.py,sha256=aIzJNV5r23VBxjhEoja4tXwI1Z7_UCw5zOaxuPya2E8,2728
+unrealon_browser/managers/__init__.py,sha256=JuH9FW_kTzVv71jCDp6wOT4SXT6HGSBpyNAb4tD7-ck,456
+unrealon_browser/managers/captcha.py,sha256=KGBO7sfq9XusAlcPByUFdIg-v6rlruzS2oHx-Zx28wo,21453
+unrealon_browser/managers/cookies.py,sha256=r4VVnKLXH82vhU7qgtY-dF7KPf0Ie3QxGD3FEi6geFA,15085
+unrealon_browser/managers/logger_bridge.py,sha256=GSxFSE7I596NQ8zFvWtf5IF9YADexHwvBP2-5FK8wrY,11066
+unrealon_browser/managers/profile.py,sha256=HjddlSeUry_65WPtF8CMkT7cfJ6X3Jap9kJaaZpwtAA,18956
+unrealon_browser/managers/stealth.py,sha256=-ge67IAueO6zRa0SSffi8Fpd2mhG_2IyRvZADzxJbfk,14651
+unrealon_driver/__init__.py,sha256=S0s4m-MpDXGVuQVfcqZ-PccFixGwKgww065LfnK-4fE,1532
+unrealon_driver/exceptions.py,sha256=5b7ndK-UROfVvON3qf9YVXK4tq8PZzgtBSHTkiA1Oos,437
+unrealon_driver/html_analyzer/__init__.py,sha256=sDrhKYJ9I3OdgbL60w92WxfiHD_Jhcw0vgV2XYkKQwg,1007
+unrealon_driver/html_analyzer/cleaner.py,sha256=77umjQojIl9BMSFpe4j6x3_5TMQh7Jk5GXUhuempu3k,25198
+unrealon_driver/html_analyzer/config.py,sha256=BnAUKIr2sLX8XtJ0CC0PxTQieR2eA4SJJ_DM22IhwrY,3021
+unrealon_driver/html_analyzer/manager.py,sha256=0y8EBEJeW3LuWWBLt--W0czs_-UZ-4j5btLS8cigb6E,10734
+unrealon_driver/html_analyzer/models.py,sha256=EXiGJC3i8O-rjqGH4YKVuyS0vqp0s8BmvNZ78qevt50,4854
+unrealon_driver/html_analyzer/websocket_analyzer.py,sha256=MXqtEdV2K4CF4I1Z0zKexf1uqDdwmuguzuAkjV2tyAA,5768
+unrealon_driver/models/__init__.py,sha256=ugsaGIJWH5QU7FduoCoV7S9AxKzYCPisAqow6oV89JQ,620
+unrealon_driver/models/websocket.py,sha256=zmz_J8vER-Y4BCwDXCUbnc-eoUpbFcRLXJRsp_8xFbs,4271
+unrealon_driver/parser/__init__.py,sha256=QW1u5zju71o7mtvINpdz7dO8ZltylrtXUkSm4xzWDwo,949
+unrealon_driver/parser/cli_manager.py,sha256=l0Kk7zm1KGvnjjyydtXxcULmwFerEE03_ZZp4dkN7nc,5124
+unrealon_driver/parser/daemon_manager.py,sha256=0GQ4_ZffJQKcEpw3kyPLXu8up1LGptLbly0BQxwXz5M,15945
+unrealon_driver/parser/parser_manager.py,sha256=URq1xZ7Uyw5CM4TXYWVc1n3IzylyLUfmK5iO2HDYLL8,17923
+unrealon_driver/parser/managers/__init__.py,sha256=DChR17AOEabrIuSNElEzA8kmjmc33rcB1n_RTo3QOaU,616
+unrealon_driver/parser/managers/config.py,sha256=H0MM8FOx_2JQESY9AujrTvsslC9NCTs7sayDIGq3TBs,9897
+unrealon_driver/parser/managers/error.py,sha256=EnJkZLlZihXeKZdHauvnqaSby05caxHOYYIuiLoelkw,14555
+unrealon_driver/parser/managers/result.py,sha256=yIoDTx6e1YzhKmJ2yJPD8_eAAkrjtm7ofN3DFEOLdUU,10236
+unrealon_driver/smart_logging/__init__.py,sha256=sC0Bzzvx73V2iAj7-AH3-H_WFKGRH04eajodREIuwgg,544
+unrealon_driver/smart_logging/models.py,sha256=lGqCxjBp18mA35-VMn7GRUCJvISMw-p1cGUtD8Im3Qo,1079
+unrealon_driver/smart_logging/smart_logger.py,sha256=BVLjA2FTZfFiY97AE3mZh0Ds8rtCj97yIKFcHP56afU,13039
+unrealon_driver/smart_logging/unified_logger.py,sha256=4DfDFNQE1I555Gk1HAxsrd5MFyLID_FyYiqgVRslNvE,18284
+unrealon_driver/websocket/__init__.py,sha256=qwOOIKEcwvP_0GYW6fTAmNdiUMHaotG_IL56g3wi_aU,1008
+unrealon_driver/websocket/client.py,sha256=NvfbeDe_uDfLniS2q6Qzd5p4UnhSqvdSzUaUXNMtzLw,9179
+unrealon_driver/websocket/config.py,sha256=ez6EjAOPjDMoQeXHEkulT90o2vpeC34eShgNFLX2g1E,6500
+unrealon_driver/websocket/manager.py,sha256=8RAq3NuBFfV2y0ThAZVD7IhO_t7OAJV9phvnZooaLlc,2779
+unrealon-1.1.4.dist-info/METADATA,sha256=xwBrCFv9aUhu3QQYBK5irSMuZnP--zleZQZBB3zhip4,21402
+unrealon-1.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+unrealon-1.1.4.dist-info/entry_points.txt,sha256=s-tuFkQDg3TQ3U5k0yzt6oWGUhTLum0BLdCQEIDnpiU,431
+unrealon-1.1.4.dist-info/licenses/LICENSE,sha256=uTZpktXKUsE0IzS5RdSV398HHI74ssbGKTdCbv7U9l0,1070
+unrealon-1.1.4.dist-info/RECORD,,

{unrealon-1.1.1.dist-info → unrealon-1.1.4.dist-info}/entry_points.txt

@@ -4,6 +4,6 @@ browser-interactive = unrealon_browser.cli.interactive_mode:main
 browser-profiles = unrealon_browser.cli.main:profiles_command
 browser-stealth = unrealon_browser.cli.main:stealth_command
 unrealon = unrealon_driver.cli:main
-unrealon-bridge = unrealon_bridge.cli:main
+unrealon-bridge = unrealon_server.cli:main
 unrealon-browser = unrealon_browser.cli.main:cli
 unrealon-rpc = unrealon_rpc.cli.main:main

unrealon_browser/__init__.py

@@ -5,12 +5,8 @@ Enterprise-grade browser automation with stealth capabilities and proxy integrat
 Based on proven patterns from unrealparser with modular architecture.
 """
 
-from importlib.metadata import version
-
-try:
-    __version__ = version("unrealon")
-except Exception:
-    __version__ = "0.1.0"
+from unrealon import VersionInfo
+__version__ = VersionInfo().version
 
 # Core browser management
 from .core import BrowserManager
@@ -47,6 +43,7 @@ from .dto import (
 )
 
 __all__ = [
+    "__version__",
     # Core
     "BrowserManager",
     # Managers

unrealon_browser/core/browser_manager.py

@@ -10,7 +10,9 @@ import uuid
 from datetime import datetime, timezone
 from typing import Optional, Dict, Any, Union
 from pathlib import Path
-
+import subprocess
+import platform
+from playwright.async_api import async_playwright
 from unrealon_browser.dto import (
     BrowserConfig,
     BrowserSession,
@@ -18,7 +20,6 @@ from unrealon_browser.dto import (
     BrowserStatistics,
     BrowserManagerStatistics,
     BrowserType,
-    # 🔥 StealthLevel removed - STEALTH ALWAYS ON!
     PageResult,
     ProxyInfo,
 )
@@ -42,9 +43,10 @@ class BrowserManager:
     - Basic statistics
     """
 
-    def __init__(self, config: BrowserConfig):
+    def __init__(self, config: BrowserConfig, parser_id: Optional[str] = None):
         """Initialize browser manager with configuration"""
         self.config = config
+        self.parser_id = parser_id or config.parser_id or config.parser_name
         self.session_metadata: Optional[BrowserSession] = None
         self._browser = None
         self._context = None
@@ -59,9 +61,7 @@ class BrowserManager:
         self.profile_manager = None
         self.cookie_manager = None
         self.captcha_manager = CaptchaDetector()
-        self.logger_bridge = create_browser_logger_bridge(
-            session_id=self._generate_session_id(), enable_console=True
-        )
+        self.logger_bridge = create_browser_logger_bridge(session_id=self._generate_session_id(), parser_id=self.parser_id, enable_console=True)  # Use resolved parser_id
 
         # Signal handlers for graceful shutdown
         self._setup_signal_handlers()
@@ -70,7 +70,7 @@ class BrowserManager:
         """Setup signal handlers for graceful shutdown"""
 
         def signal_handler(signum, frame):
-            print(f"\n🔄 Received signal {signum}, shutting down gracefully...")
+            self.logger_bridge.log_info(f"\n🔄 Received signal {signum}, shutting down gracefully...")
             if self._initialized:
                 try:
                     loop = asyncio.get_event_loop()
@@ -82,8 +82,8 @@ class BrowserManager:
                         # If no event loop running, use asyncio.run
                         asyncio.run(self.close_async())
                 except Exception as e:
-                    print(f"⚠️ Error during shutdown: {e}")
-            print("🔄 Browser cleanup completed")
+                    self.logger_bridge.log_warning(f"⚠️ Error during shutdown: {e}")
+            self.logger_bridge.log_info("🔄 Browser cleanup completed")
             sys.exit(0)
 
         signal.signal(signal.SIGINT, signal_handler)
@@ -95,11 +95,11 @@ class BrowserManager:
             # Try graceful cleanup with timeout
             await asyncio.wait_for(self.close_async(), timeout=3.0)
         except asyncio.TimeoutError:
-            print("⚠️ Cleanup timeout - forcing exit")
+            self.logger_bridge.log_warning("⚠️ Cleanup timeout - forcing exit")
         except Exception as e:
-            print(f"⚠️ Cleanup error: {e}")
+            self.logger_bridge.log_warning(f"⚠️ Cleanup error: {e}")
         finally:
-            print("🔄 Browser cleanup completed")
+            self.logger_bridge.log_info("🔄 Browser cleanup completed")
             # Force exit from the event loop
             try:
                 loop = asyncio.get_event_loop()
@@ -115,13 +115,33 @@ class BrowserManager:
         """Generate unique session ID"""
         return f"browser_session_{uuid.uuid4().hex[:8]}"
 
+    async def _force_cleanup_chromium_processes(self) -> None:
+        """Force cleanup of any remaining Chromium processes."""
+        try:
+
+            if platform.system() == "Darwin":  # macOS
+                # Kill playwright chromium processes
+                subprocess.run(["pkill", "-f", "playwright.*chromium"], capture_output=True, check=False)
+
+            elif platform.system() == "Linux":
+                # Kill playwright chromium processes on Linux
+                subprocess.run(["pkill", "-f", "playwright.*chromium"], capture_output=True, check=False)
+
+            elif platform.system() == "Windows":
+                # Kill chromium processes on Windows
+                subprocess.run(["taskkill", "/F", "/IM", "chrome.exe"], capture_output=True, check=False)
+                subprocess.run(["taskkill", "/F", "/IM", "chromium.exe"], capture_output=True, check=False)
+
+        except Exception as e:
+            self.logger_bridge.log_warning(f"⚠️ Could not force cleanup Chromium processes: {e}")
+            # Don't raise - this is a best-effort cleanup
+
     async def initialize_async(self) -> None:
         """Initialize browser with Playwright"""
         if self._initialized:
             return
 
         try:
-            from playwright.async_api import async_playwright
 
             # Create session metadata
             self.session_metadata = BrowserSession(
@@ -135,10 +155,10 @@ class BrowserManager:
                 browser_type=self.config.browser_type.value,
             )
 
-            print(f"🚀 Initializing browser session: {self.session_metadata.session_id}")
-            print(f"   Parser: {self.config.parser_name}")
-            print(f"   Browser: {self.config.browser_type.value}")
-            print(f"   Stealth: ALWAYS ON")
+            self.logger_bridge.log_info(f"🚀 Initializing browser session: {self.session_metadata.session_id}")
+            self.logger_bridge.log_info(f"   Parser: {self.config.parser_name}")
+            self.logger_bridge.log_info(f"   Browser: {self.config.browser_type.value}")
+            self.logger_bridge.log_info(f"   Stealth: ALWAYS ON")
 
             # Log initialization through bridge
             self.logger_bridge.log_browser_initialized(self.session_metadata)
@@ -160,7 +180,7 @@ class BrowserManager:
 
             # ✅ FIX: Use launch_persistent_context for profiles, regular launch otherwise
             if profile_path:
-                print(f"   📂 Using profile: {profile_path}")
+                self.logger_bridge.log_info(f"   📂 Using profile: {profile_path}")
 
                 # Combine args for persistent context (different structure than regular launch)
                 persistent_args = {
@@ -174,23 +194,17 @@ class BrowserManager:
 
                 # Use persistent context with user_data_dir for profiles
                 if self.config.browser_type == BrowserType.CHROMIUM:
-                    self._context = await self._playwright.chromium.launch_persistent_context(
-                        **persistent_args
-                    )
+                    self._context = await self._playwright.chromium.launch_persistent_context(**persistent_args)
                 elif self.config.browser_type == BrowserType.FIREFOX:
-                    self._context = await self._playwright.firefox.launch_persistent_context(
-                        **persistent_args
-                    )
+                    self._context = await self._playwright.firefox.launch_persistent_context(**persistent_args)
                 elif self.config.browser_type == BrowserType.WEBKIT:
-                    self._context = await self._playwright.webkit.launch_persistent_context(
-                        **persistent_args
-                    )
+                    self._context = await self._playwright.webkit.launch_persistent_context(**persistent_args)
                 else:
                     raise ValueError(f"Unsupported browser type: {self.config.browser_type}")
 
                 # For persistent context, browser is accessed via context.browser
                 self._browser = self._context.browser
-                print(f"   ✅ Persistent context created with profile: {profile_path}")
+                self.logger_bridge.log_info(f"✅ Persistent context created with profile: {profile_path}")
             else:
                 # Regular browser launch without profile
                 if self.config.browser_type == BrowserType.CHROMIUM:
@@ -206,7 +220,7 @@ class BrowserManager:
                 self._context = await self._browser.new_context(**context_options)
 
             # 🔥 STEALTH ALWAYS ON - NO CONFIG NEEDED!
-            self.stealth_manager.apply_webdriver_removal(self._context)
+            await self.stealth_manager.apply_webdriver_removal(self._context)
 
             # Create page
             self._page = await self._context.new_page()
@@ -217,7 +231,7 @@ class BrowserManager:
 
             # 🔥 CRITICAL: If stealth fails, CLOSE BROWSER WITH ERROR!
             if not stealth_success:
-                print("❌ STEALTH FAILED - CLOSING BROWSER!")
+                self.logger_bridge.log_error("❌ STEALTH FAILED - CLOSING BROWSER!")
                 await self.close_async()
                 raise RuntimeError("🔥 STEALTH MANDATORY: Browser closed due to stealth application failure")
 
@@ -226,13 +240,13 @@ class BrowserManager:
             self._statistics.set_session_start()
             self._initialized = True
 
-            print(f"✅ Browser initialized successfully")
-            print(f"   Session ID: {self.session_metadata.session_id}")
+            self.logger_bridge.log_info(f"✅ Browser initialized successfully")
+            self.logger_bridge.log_info(f"   Session ID: {self.session_metadata.session_id}")
 
         except Exception as e:
             if self.session_metadata:
                 self.session_metadata.current_status = BrowserSessionStatus.ERROR
-            print(f"❌ Failed to initialize browser: {e}")
+            self.logger_bridge.log_error(f"❌ Failed to initialize browser: {e}")
             raise
 
     def _get_browser_args(self) -> Dict[str, Any]:
@@ -283,7 +297,7 @@ class BrowserManager:
         self._statistics.increment_total()
 
         try:
-            print(f"🌐 Navigating to: {url}")
+            self.logger_bridge.log_info(f"🌐 Navigating to: {url}")
 
             # Navigate with timeout
             response = await self._page.goto(
@@ -294,10 +308,8 @@ class BrowserManager:
 
             # Wait for additional selector if specified
             if wait_for:
-                print(f"⏳ Waiting for: {wait_for}")
-                await self._page.wait_for_selector(
-                    wait_for, timeout=self.config.page_load_timeout_seconds * 1000
-                )
+                self.logger_bridge.log_info(f"⏳ Waiting for: {wait_for}")
+                await self._page.wait_for_selector(wait_for, timeout=self.config.page_load_timeout_seconds * 1000)
 
             # Check response status
             if response and response.status >= 400:
@@ -310,9 +322,7 @@ class BrowserManager:
                 self.profile_manager.mark_session_success(True)
 
             # Calculate duration
-            duration_ms = (
-                datetime.now(timezone.utc) - datetime.now(timezone.utc).replace(microsecond=0)
-            ).total_seconds() * 1000
+            duration_ms = (datetime.now(timezone.utc) - datetime.now(timezone.utc).replace(microsecond=0)).total_seconds() * 1000
 
             # Log successful navigation
             title = await self._page.title()
@@ -322,7 +332,7 @@ class BrowserManager:
             captcha_result = await self.captcha_manager.detect_captcha(self._page)
             if captcha_result.detected:
                 self.logger_bridge.log_captcha_detected(captcha_result)
-                print(f"⚠️ Captcha detected: {captcha_result.captcha_type.value}")
+                self.logger_bridge.log_warning(f"⚠️ Captcha detected: {captcha_result.captcha_type.value}")
                 # Update session status to indicate captcha is required
                 self.session_metadata.current_status = BrowserSessionStatus.CAPTCHA_REQUIRED
 
@@ -336,16 +346,14 @@ class BrowserManager:
 
         except Exception as e:
             self._statistics.increment_failed()
-            print(f"❌ Navigation failed: {e}")
+            self.logger_bridge.log_error(f"❌ Navigation failed: {e}")
 
             # Mark profile session as failure
             if self.profile_manager:
                 self.profile_manager.mark_session_success(False)
 
             # Calculate duration
-            duration_ms = (
-                datetime.now(timezone.utc) - datetime.now(timezone.utc).replace(microsecond=0)
-            ).total_seconds() * 1000
+            duration_ms = (datetime.now(timezone.utc) - datetime.now(timezone.utc).replace(microsecond=0)).total_seconds() * 1000
 
             # Log failed navigation
             self.logger_bridge.log_navigation_failed(url, str(e), duration_ms)
@@ -366,7 +374,7 @@ class BrowserManager:
         try:
             return await self._page.content()
         except Exception as e:
-            print(f"❌ Failed to get page content: {e}")
+            self.logger_bridge.log_error(f"❌ Failed to get page content: {e}")
             return None
 
     async def execute_script_async(self, script: str) -> Any:
@@ -377,7 +385,7 @@ class BrowserManager:
         try:
             return await self._page.evaluate(script)
         except Exception as e:
-            print(f"❌ Script execution failed: {e}")
+            self.logger_bridge.log_error(f"❌ Script execution failed: {e}")
             raise
 
     def get_statistics(self) -> Dict[str, Any]:
@@ -387,14 +395,10 @@ class BrowserManager:
 
         if self._statistics.session_start_time:
             current_time = datetime.now(timezone.utc)
-            stats_dict["session_duration_seconds"] = (
-                current_time - self._statistics.session_start_time
-            ).total_seconds()
+            stats_dict["session_duration_seconds"] = (current_time - self._statistics.session_start_time).total_seconds()
 
         if self._statistics.total_navigations > 0:
-            stats_dict["success_rate"] = (
-                self._statistics.successful_navigations / self._statistics.total_navigations
-            )
+            stats_dict["success_rate"] = self._statistics.successful_navigations / self._statistics.total_navigations
         else:
             stats_dict["success_rate"] = 0.0
 
@@ -404,15 +408,13 @@ class BrowserManager:
         """Print session statistics"""
         stats = self.get_statistics()
 
-        print("\n📊 Browser Session Statistics:")
-        print(
-            f"   Session ID: {self.session_metadata.session_id if self.session_metadata else 'N/A'}"
-        )
-        print(f"   Total navigations: {stats['total_navigations']}")
-        print(f"   Successful: {stats['successful_navigations']}")
-        print(f"   Failed: {stats['failed_navigations']}")
-        print(f"   Success rate: {stats['success_rate']:.1%}")
-        print(f"   Duration: {stats['session_duration_seconds']:.1f}s")
+        self.logger_bridge.log_info("\n📊 Browser Session Statistics:")
+        self.logger_bridge.log_info(f"   Session ID: {self.session_metadata.session_id if self.session_metadata else 'N/A'}")
+        self.logger_bridge.log_info(f"   Total navigations: {stats['total_navigations']}")
+        self.logger_bridge.log_info(f"   Successful: {stats['successful_navigations']}")
+        self.logger_bridge.log_info(f"   Failed: {stats['failed_navigations']}")
+        self.logger_bridge.log_info(f"   Success rate: {stats['success_rate']:.1%}")
+        self.logger_bridge.log_info(f"   Duration: {stats['session_duration_seconds']:.1f}s")
 
         # Print stealth status
         self.stealth_manager.print_stealth_status()
@@ -470,12 +472,10 @@ class BrowserManager:
             if not detection_result.detected:
                 return {"success": False, "error": "No captcha detected", "should_continue": True}
 
-            print(f"\n🤖 Starting interactive captcha resolution...")
+            self.logger_bridge.log_info(f"\n🤖 Starting interactive captcha resolution...")
 
             # Handle captcha interactively
-            resolution_result = await self.captcha_manager.handle_captcha_interactive(
-                self, detection_result, timeout_seconds
-            )
+            resolution_result = await self.captcha_manager.handle_captcha_interactive(self, detection_result, timeout_seconds)
 
             if resolution_result["success"]:
                 # Log successful captcha resolution
@@ -514,7 +514,7 @@ class BrowserManager:
 
         try:
             # Step 1: Navigate to URL
-            print(f"🚀 Starting automation workflow for: {url}")
+            self.logger_bridge.log_info(f"🚀 Starting automation workflow for: {url}")
             navigation_result = await self.navigate_async(url)
             workflow_result["steps_completed"].append("navigation")
 
@@ -528,7 +528,7 @@ class BrowserManager:
                 workflow_result["captcha_encountered"] = True
                 workflow_result["steps_completed"].append("captcha_detection")
 
-                print(f"🤖 Captcha detected: {captcha_result['captcha_type']}")
+                self.logger_bridge.log_info(f"🤖 Captcha detected: {captcha_result['captcha_type']}")
 
                 # Step 3: Handle captcha interactively
                 resolution_result = await self.handle_captcha_interactive_async(timeout_seconds=300)
@@ -536,11 +536,9 @@ class BrowserManager:
 
                 if resolution_result["success"]:
                     workflow_result["captcha_resolved"] = True
-                    print("✅ Captcha resolved successfully!")
+                    self.logger_bridge.log_info("✅ Captcha resolved successfully!")
                 else:
-                    workflow_result["error"] = (
-                        f"Captcha resolution failed: {resolution_result.get('error')}"
-                    )
+                    workflow_result["error"] = f"Captcha resolution failed: {resolution_result.get('error')}"
                     return workflow_result
 
             # Step 4: Save cookies if we have a proxy
@@ -550,25 +548,26 @@ class BrowserManager:
                 workflow_result["steps_completed"].append("cookie_saving")
 
                 if cookies_saved:
-                    print("💾 Cookies saved successfully!")
+                    self.logger_bridge.log_info("💾 Cookies saved successfully!")
 
             workflow_result["success"] = True
-            print("🎉 Automation workflow completed successfully!")
+            self.logger_bridge.log_info("🎉 Automation workflow completed successfully!")
 
             return workflow_result
 
         except Exception as e:
             workflow_result["error"] = str(e)
-            print(f"❌ Automation workflow failed: {e}")
+            self.logger_bridge.log_error(f"❌ Automation workflow failed: {e}")
             return workflow_result
 
     async def close_async(self) -> None:
         """Close browser and cleanup resources"""
+
         if not self._initialized:
             return
 
         try:
-            print("🔄 Closing browser session...")
+            self.logger_bridge.log_info("🔄 Closing browser session...")
 
             if self.session_metadata:
                 self.session_metadata.current_status = BrowserSessionStatus.CLOSED
@@ -579,7 +578,7 @@ class BrowserManager:
                     if not self._page.is_closed():
                         await self._page.close()
                 except Exception as e:
-                    print(f"⚠️ Page already closed: {e}")
+                    self.logger_bridge.log_warning(f"⚠️ Page already closed: {e}")
                 finally:
                     self._page = None
 
@@ -589,7 +588,7 @@ class BrowserManager:
                     # Check if context is still valid before closing
                     await self._context.close()
                 except Exception as e:
-                    print(f"⚠️ Context already closed: {e}")
+                    self.logger_bridge.log_warning(f"⚠️ Context already closed: {e}")
                 finally:
                     self._context = None
 
@@ -599,7 +598,7 @@ class BrowserManager:
                     if self._browser.is_connected():
                         await self._browser.close()
                 except Exception as e:
-                    print(f"⚠️ Browser already closed: {e}")
+                    self.logger_bridge.log_warning(f"⚠️ Browser already closed: {e}")
                 finally:
                     self._browser = None
 
@@ -608,18 +607,21 @@ class BrowserManager:
                 try:
                     await self._playwright.stop()
                 except Exception as e:
-                    print(f"⚠️ Playwright already stopped: {e}")
+                    self.logger_bridge.log_warning(f"⚠️ Playwright already stopped: {e}")
                 finally:
                     self._playwright = None
 
+            # Force cleanup of any remaining Chromium processes
+            await self._force_cleanup_chromium_processes()
+
             self._initialized = False
 
-            # Print final statistics
+            # Log final statistics
             self.print_statistics()
-            print("✅ Browser closed successfully")
+            self.logger_bridge.log_info("✅ Browser closed successfully")
 
         except Exception as e:
-            print(f"❌ Error closing browser: {e}")
+            self.logger_bridge.log_error(f"❌ Error closing browser: {e}")
             # Don't re-raise - we want graceful shutdown even with errors
 
     @property

unrealon_browser/dto/models/config.py

@@ -4,6 +4,7 @@ Browser DTOs - Configuration Models
 Configuration models for browser automation.
 """
 
+from typing import Optional
 from pydantic import BaseModel, Field, ConfigDict
 from .enums import BrowserType, BrowserMode
 
@@ -25,6 +26,7 @@ class BrowserConfig(BaseModel):
     use_proxy_rotation: bool = Field(default=True)
     realistic_ports_only: bool = Field(default=False)
     parser_name: str = Field(default="default_parser")
+    parser_id: Optional[str] = Field(default=None, description="Optional parser ID for logging")
 
     # Performance
     disable_images: bool = Field(default=False)