cursorflow 2.6.1__py3-none-any.whl → 2.6.2__py3-none-any.whl

cursorflow/core/browser_controller.py

@@ -189,165 +189,205 @@ class BrowserController:
         
     def _handle_console_message(self, msg):
         """Handle console messages from any framework with enhanced error context collection"""
-        log_entry = {
-            "timestamp": time.time(),
-            "type": msg.type,
-            "text": msg.text,
-            "location": {
-                "url": msg.location.get("url", "") if msg.location else "",
-                "line": msg.location.get("lineNumber", 0) if msg.location else 0,
-                "column": msg.location.get("columnNumber", 0) if msg.location else 0
-            },
-            "args": [str(arg) for arg in msg.args] if msg.args else [],
-            "stack_trace": getattr(msg, 'stackTrace', None)
-        }
-        self.console_logs.append(log_entry)
-        
-        # Enhanced logging for better correlation
-        if msg.type == "error":
-            self.logger.error(f"Console Error: {msg.text} at {msg.location}")
-            
-            # v2.0 Enhancement: Trigger error context collection for console errors
-            if self.error_context_collector:
-                error_event = {
-                    'type': 'console_error',
-                    'message': msg.text,
-                    'location': log_entry['location'],
-                    'stack_trace': log_entry['stack_trace'],
-                    'timestamp': log_entry['timestamp']
-                }
-                # Capture context asynchronously (don't block the event handler)
-                asyncio.create_task(self._collect_error_context_async(error_event))
-            
-        elif msg.type == "warning":
-            self.logger.warning(f"Console Warning: {msg.text}")
-        elif msg.type in ["log", "info"] and any(keyword in msg.text.lower() for keyword in ["error", "failed", "exception"]):
-            # Catch application logs that indicate errors
-            self.logger.warning(f"App Error Log: {msg.text}")
+        try:
+            log_entry = {
+                "timestamp": time.time(),
+                "type": msg.type,
+                "text": msg.text,
+                "location": {
+                    "url": msg.location.get("url", "") if msg.location else "",
+                    "line": msg.location.get("lineNumber", 0) if msg.location else 0,
+                    "column": msg.location.get("columnNumber", 0) if msg.location else 0
+                },
+                "args": [str(arg) for arg in msg.args] if msg.args else [],
+                "stack_trace": getattr(msg, 'stackTrace', None)
+            }
+            self.console_logs.append(log_entry)
             
-            # v2.0 Enhancement: Collect context for application error logs too
-            if self.error_context_collector:
-                error_event = {
-                    'type': 'app_error_log',
-                    'message': msg.text,
-                    'timestamp': log_entry['timestamp']
-                }
-                asyncio.create_task(self._collect_error_context_async(error_event))
+            # Enhanced logging for better correlation
+            if msg.type == "error":
+                self.logger.error(f"Console Error: {msg.text} at {msg.location}")
+                
+                # v2.0 Enhancement: Trigger error context collection for console errors
+                if self.error_context_collector:
+                    error_event = {
+                        'type': 'console_error',
+                        'message': msg.text,
+                        'location': log_entry['location'],
+                        'stack_trace': log_entry['stack_trace'],
+                        'timestamp': log_entry['timestamp']
+                    }
+                    # Capture context asynchronously (don't block the event handler)
+                    asyncio.create_task(self._collect_error_context_async(error_event))
+                
+            elif msg.type == "warning":
+                self.logger.warning(f"Console Warning: {msg.text}")
+            elif msg.type in ["log", "info"] and any(keyword in msg.text.lower() for keyword in ["error", "failed", "exception"]):
+                # Catch application logs that indicate errors
+                self.logger.warning(f"App Error Log: {msg.text}")
+                
+                # v2.0 Enhancement: Collect context for application error logs too
+                if self.error_context_collector:
+                    error_event = {
+                        'type': 'app_error_log',
+                        'message': msg.text,
+                        'timestamp': log_entry['timestamp']
+                    }
+                    asyncio.create_task(self._collect_error_context_async(error_event))
+        except Exception as e:
+            # Defensive error handling - don't let console message parsing break tests
+            self.logger.debug(f"Console message handler error: {e}")
+            # Continue test execution despite error
     
     def _handle_request(self, request):
         """Handle network requests - framework agnostic"""
-        # Capture complete request data
-        request_data = {
-            "timestamp": time.time(),
-            "type": "request",
-            "url": request.url,
-            "method": request.method,
-            "headers": dict(request.headers),
-            "resource_type": request.resource_type,  # document, xhr, fetch, etc.
-            "is_navigation_request": request.is_navigation_request()
-        }
-        
-        # Capture complete payload data for all request types
-        if request.post_data:
-            request_data["post_data"] = request.post_data
-            request_data["post_data_size"] = len(request.post_data)
+        try:
+            # Capture complete request data
+            request_data = {
+                "timestamp": time.time(),
+                "type": "request",
+                "url": request.url,
+                "method": request.method,
+                "headers": dict(request.headers),
+                "resource_type": request.resource_type,  # document, xhr, fetch, etc.
+                "is_navigation_request": request.is_navigation_request()
+            }
             
-            # Try to parse JSON payloads for better debugging
-            content_type = request.headers.get("content-type", "")
-            if "application/json" in content_type:
-                try:
-                    import json
-                    request_data["parsed_json"] = json.loads(request.post_data)
-                except:
-                    pass
-            elif "application/x-www-form-urlencoded" in content_type:
-                try:
-                    from urllib.parse import parse_qs
-                    request_data["parsed_form"] = parse_qs(request.post_data)
-                except:
-                    pass
-        
-        # Capture query parameters
-        from urllib.parse import urlparse, parse_qs
-        parsed_url = urlparse(request.url)
-        if parsed_url.query:
-            request_data["query_params"] = parse_qs(parsed_url.query)
-            
-        # Capture file uploads
-        if "multipart/form-data" in request.headers.get("content-type", ""):
-            request_data["has_file_upload"] = True
-            # Note: Actual file content not captured for performance/privacy
-            
-        self.network_requests.append(request_data)
-        
-        # Enhanced logging for correlation
-        if request.resource_type in ["xhr", "fetch"] or "/api/" in request.url:
-            payload_info = ""
-            if request.post_data:
-                payload_info = f" (payload: {len(request.post_data)} bytes)"
-            self.logger.debug(f"API Request: {request.method} {request.url}{payload_info}")
-            
-            # Log critical data for immediate debugging
-            if request.post_data and len(request.post_data) < 500:  # Only log small payloads
-                self.logger.debug(f"Request payload: {request.post_data}")
+            # Capture complete payload data for all request types
+            # Wrap in try/except to handle gzip-compressed data gracefully
+            try:
+                if request.post_data:
+                    request_data["post_data"] = request.post_data
+                    request_data["post_data_size"] = len(request.post_data)
+                    
+                    # Try to parse JSON payloads for better debugging
+                    content_type = request.headers.get("content-type", "")
+                    if "application/json" in content_type:
+                        try:
+                            import json
+                            request_data["parsed_json"] = json.loads(request.post_data)
+                        except:
+                            pass
+                    elif "application/x-www-form-urlencoded" in content_type:
+                        try:
+                            from urllib.parse import parse_qs
+                            request_data["parsed_form"] = parse_qs(request.post_data)
+                        except:
+                            pass
+            except UnicodeDecodeError:
+                # Handle gzip-compressed or binary data gracefully
+                # This happens when Playwright can't decode the post_data (e.g., gzip magic bytes 0x1f 0x8b)
+                request_data["post_data"] = "[binary/compressed data]"
+                request_data["post_data_size"] = 0
+                self.logger.debug(f"Binary/compressed POST data detected for {request.url}")
+            except Exception as e:
+                # Graceful degradation - don't let post_data parsing break request tracking
+                request_data["post_data"] = None
+                request_data["post_data_size"] = 0
+                self.logger.debug(f"Could not capture post_data for {request.url}: {e}")
+            
+            # Capture query parameters
+            from urllib.parse import urlparse, parse_qs
+            parsed_url = urlparse(request.url)
+            if parsed_url.query:
+                request_data["query_params"] = parse_qs(parsed_url.query)
+                
+            # Capture file uploads
+            if "multipart/form-data" in request.headers.get("content-type", ""):
+                request_data["has_file_upload"] = True
+                # Note: Actual file content not captured for performance/privacy
+                
+            self.network_requests.append(request_data)
+            
+            # Enhanced logging for correlation
+            if request.resource_type in ["xhr", "fetch"] or "/api/" in request.url:
+                payload_info = ""
+                post_data_value = request_data.get("post_data")
+                post_data_size = request_data.get("post_data_size", 0)
+                if post_data_value and post_data_size > 0:
+                    payload_info = f" (payload: {post_data_size} bytes)"
+                self.logger.debug(f"API Request: {request.method} {request.url}{payload_info}")
+                
+                # Log critical data for immediate debugging
+                if post_data_value and post_data_size > 0 and post_data_size < 500:  # Only log small payloads
+                    self.logger.debug(f"Request payload: {post_data_value}")
+        except Exception as e:
+            # Top-level defensive error handling - don't let request handler break event listeners
+            self.logger.debug(f"Request handler error: {e}")
+            # Continue test execution despite error
     
     def _handle_response(self, response):
         """Handle network responses with enhanced error context collection"""
-        response_data = {
-            "timestamp": time.time(),
-            "type": "response", 
-            "url": response.url,
-            "status": response.status,
-            "status_text": response.status_text,
-            "headers": dict(response.headers),
-            "size": 0,  # Will be populated by _capture_response_body if needed
-            "from_cache": response.from_service_worker or False
-        }
-        self.network_requests.append(response_data)
-        
-        # Capture response body asynchronously (Phase 1.4: Network Response Body Capture)
-        asyncio.create_task(self._capture_response_body_async(response, response_data))
-        
-        # Log failed requests for correlation
-        if response.status >= 400:
-            self.logger.warning(f"Failed Response: {response.status} {response.url}")
+        try:
+            response_data = {
+                "timestamp": time.time(),
+                "type": "response", 
+                "url": response.url,
+                "status": response.status,
+                "status_text": response.status_text,
+                "headers": dict(response.headers),
+                "size": 0,  # Will be populated by _capture_response_body if needed
+                "from_cache": response.from_service_worker or False
+            }
+            self.network_requests.append(response_data)
             
-            # v2.0 Enhancement: Trigger error context collection for failed requests
-            if self.error_context_collector:
-                error_event = {
-                    'type': 'network_error',
-                    'url': response.url,
-                    'status': response.status,
-                    'status_text': response.status_text,
-                    'headers': dict(response.headers),
-                    'timestamp': response_data['timestamp']
-                }
-                # Capture context asynchronously
-                asyncio.create_task(self._collect_error_context_async(error_event))
-        
-        # Capture response body for important requests
-        should_capture_body = (
-            response.status >= 400 or  # All error responses
-            any(api_path in response.url for api_path in ["/api/", "/ajax", ".json"]) or  # API calls
-            "application/json" in response.headers.get("content-type", "")  # JSON responses
-        )
-        
-        if should_capture_body:
-            asyncio.create_task(self._capture_response_body(response))
+            # Capture response body asynchronously (Phase 1.4: Network Response Body Capture)
+            asyncio.create_task(self._capture_response_body_async(response, response_data))
+            
+            # Log failed requests for correlation
+            if response.status >= 400:
+                self.logger.warning(f"Failed Response: {response.status} {response.url}")
+                
+                # v2.0 Enhancement: Trigger error context collection for failed requests
+                if self.error_context_collector:
+                    error_event = {
+                        'type': 'network_error',
+                        'url': response.url,
+                        'status': response.status,
+                        'status_text': response.status_text,
+                        'headers': dict(response.headers),
+                        'timestamp': response_data['timestamp']
+                    }
+                    # Capture context asynchronously
+                    asyncio.create_task(self._collect_error_context_async(error_event))
+            
+            # Capture response body for important requests
+            should_capture_body = (
+                response.status >= 400 or  # All error responses
+                any(api_path in response.url for api_path in ["/api/", "/ajax", ".json"]) or  # API calls
+                "application/json" in response.headers.get("content-type", "")  # JSON responses
+            )
+            
+            if should_capture_body:
+                asyncio.create_task(self._capture_response_body(response))
+        except Exception as e:
+            # Defensive error handling - don't let response handler break event listeners
+            self.logger.debug(f"Response handler error: {e}")
+            # Continue test execution despite error
     
     def _handle_page_error(self, error):
         """Handle page errors from any framework"""
-        self.console_logs.append({
-            "timestamp": time.time(),
-            "type": "pageerror",
-            "text": str(error),
-            "location": None
-        })
-        self.logger.error(f"Page error: {error}")
+        try:
+            self.console_logs.append({
+                "timestamp": time.time(),
+                "type": "pageerror",
+                "text": str(error),
+                "location": None
+            })
+            self.logger.error(f"Page error: {error}")
+        except Exception as e:
+            # Defensive error handling - don't let page error handler break event listeners
+            self.logger.debug(f"Page error handler error: {e}")
+            # Continue test execution despite error
     
     def _handle_page_crash(self, page):
         """Handle page crashes"""
-        self.logger.error("Page crashed - attempting recovery")
+        try:
+            self.logger.error("Page crashed - attempting recovery")
+        except Exception as e:
+            # Defensive error handling - don't let crash handler break event listeners
+            self.logger.debug(f"Page crash handler error: {e}")
+            # Continue test execution despite error
     
     async def navigate(self, path: str, wait_for_load: bool = True):
         """Navigate to URL - works with any web framework"""
@@ -2481,15 +2521,28 @@ class BrowserController:
                                 resource_analysis: Dict = None, storage_analysis: Dict = None) -> Dict[str, Any]:
         """Enhanced analysis summary with v2.0 comprehensive data"""
         try:
+            # Safe value extraction with null-safety
+            error_count = console_data.get("console_summary", {}).get("error_count") or 0
+            failed_requests = network_data.get("failed_requests", {}).get("count") or 0
+            page_load_time = performance_data.get("performance_summary", {}).get("page_load_time") or 0
+            
+            # Ensure numeric values are actually numeric (not None)
+            if not isinstance(error_count, (int, float)):
+                error_count = 0
+            if not isinstance(failed_requests, (int, float)):
+                failed_requests = 0
+            if not isinstance(page_load_time, (int, float)):
+                page_load_time = 0
+            
             # Base summary (v1.x compatibility)
             summary = {
                 "page_health": {
                     "dom_elements_count": dom_analysis.get("totalElements", 0),
-                    "has_errors": console_data.get("console_summary", {}).get("error_count", 0) > 0,
-                    "error_count": console_data.get("console_summary", {}).get("error_count", 0),
+                    "has_errors": error_count > 0,
+                    "error_count": error_count,
                     "warning_count": console_data.get("console_summary", {}).get("warning_count", 0),
                     "failed_requests": network_data.get("network_summary", {}).get("failed_requests", 0),
-                    "page_load_time_ms": performance_data.get("performance_summary", {}).get("page_load_time", 0)
+                    "page_load_time_ms": page_load_time
                 },
                 "interaction_readiness": {
                     "interactive_elements": dom_analysis.get("pageStructure", {}).get("interactiveElements", 0),
@@ -2505,12 +2558,12 @@ class BrowserController:
                 },
                 "quality_indicators": {
                     "has_console_errors": console_data.get("console_summary", {}).get("has_recent_errors", False),
-                    "has_failed_requests": network_data.get("failed_requests", {}).get("count", 0) > 0,
+                    "has_failed_requests": failed_requests > 0,
                     "performance_score": self._calculate_performance_score(performance_data),
                     "overall_health": "good" if (
-                        console_data.get("console_summary", {}).get("error_count", 0) == 0 and
-                        network_data.get("failed_requests", {}).get("count", 0) == 0 and
-                        performance_data.get("performance_summary", {}).get("page_load_time", 0) < 3000
+                        error_count == 0 and
+                        failed_requests == 0 and
+                        page_load_time < 3000
                     ) else "needs_attention"
                 }
             }

{cursorflow-2.6.1.dist-info → cursorflow-2.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cursorflow
-Version: 2.6.1
+Version: 2.6.2
 Summary: 🔥 Complete page intelligence for AI-driven development with Hot Reload Intelligence - captures DOM, network, console, performance, HMR events, and comprehensive page analysis
 Author-email: GeekWarrior Development <rbush@cooltheory.com>
 License-Expression: MIT

{cursorflow-2.6.1.dist-info → cursorflow-2.6.2.dist-info}/RECORD

@@ -8,7 +8,7 @@ cursorflow/updater.py,sha256=SroSQHQi5cYyzcOK_bf-WzmQmE7yeOs8qo3r__j-Z6E,19583
 cursorflow/core/action_validator.py,sha256=SCk3w_62D1y0cCRDOajK8L44-abSj_KpnUBgR_yNVW4,6846
 cursorflow/core/agent.py,sha256=f3lecgEzDRDdGTVccAtorpLGfNJJ49bbsQAmgr0vNGg,10136
 cursorflow/core/auth_handler.py,sha256=oRafO6ZdxoHryBIvHsrNV8TECed4GXpJsdEiH0KdPPk,17149
-cursorflow/core/browser_controller.py,sha256=sTEHdBAFCy-gxwAXCMPA9cyMU3uu0gE-hXfjMJqQnnQ,147003
+cursorflow/core/browser_controller.py,sha256=RDIqIwmSAJxtOgGplHjr5h2s6LdL1I3ZVTEvrNM4h9s,150282
 cursorflow/core/browser_engine.py,sha256=7N9hPOyDrEhLWYgZW2981N9gKlHF6Lbp7D7h0zBzuz8,14851
 cursorflow/core/config_validator.py,sha256=HRtONSOmM0Xxt3-ok3xwnBADRiNnI0nNOMaS2OqOkDk,7286
 cursorflow/core/css_iterator.py,sha256=whLCIwbHZEWaH1HCbmqhNX5zrh_fL-r3hsxKjYsukcE,16478
@@ -31,9 +31,9 @@ cursorflow/log_sources/ssh_remote.py,sha256=_Kwh0bhRpKgq-0c98oaX2hN6h9cT-wCHlqY5
 cursorflow/rules/__init__.py,sha256=gPcA-IkhXj03sl7cvZV0wwo7CtEkcyuKs4y0F5oQbqE,458
 cursorflow/rules/cursorflow-installation.mdc,sha256=D55pzzDPAVVbE3gAtKPUGoT-2fvB-FI2l6yrTdzUIEo,10208
 cursorflow/rules/cursorflow-usage.mdc,sha256=W56Qydfb4jqSBTrki7cNyFPfOe_b89mzniRtKSrMlz4,24138
-cursorflow-2.6.1.dist-info/licenses/LICENSE,sha256=e4QbjAsj3bW-xgQOvQelr8sGLYDoqc48k6cKgCr_pBU,1080
-cursorflow-2.6.1.dist-info/METADATA,sha256=sEpz3x3bNm4mY80xU_O6BfM1SVD0o6rXgHs6rQKUXCE,15011
-cursorflow-2.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cursorflow-2.6.1.dist-info/entry_points.txt,sha256=-Ed_n4Uff7wClEtWS-Py6xmQabecB9f0QAOjX0w7ljA,51
-cursorflow-2.6.1.dist-info/top_level.txt,sha256=t1UZwRyZP4u-ng2CEcNHmk_ZT4ibQxoihB2IjTF7ovc,11
-cursorflow-2.6.1.dist-info/RECORD,,
+cursorflow-2.6.2.dist-info/licenses/LICENSE,sha256=e4QbjAsj3bW-xgQOvQelr8sGLYDoqc48k6cKgCr_pBU,1080
+cursorflow-2.6.2.dist-info/METADATA,sha256=wT7QRz67l6T69kWE8kFRlGbane6AgmEp1J3mb-56C5g,15011
+cursorflow-2.6.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cursorflow-2.6.2.dist-info/entry_points.txt,sha256=-Ed_n4Uff7wClEtWS-Py6xmQabecB9f0QAOjX0w7ljA,51
+cursorflow-2.6.2.dist-info/top_level.txt,sha256=t1UZwRyZP4u-ng2CEcNHmk_ZT4ibQxoihB2IjTF7ovc,11
+cursorflow-2.6.2.dist-info/RECORD,,