crackerjack 0.31.10__py3-none-any.whl → 0.31.12__py3-none-any.whl

crackerjack/mcp/websocket/websocket_handler.py

@@ -1,8 +1,12 @@
+import asyncio
+from contextlib import suppress
 from pathlib import Path
 
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect
 from rich.console import Console
 
+from crackerjack.core.timeout_manager import TimeoutStrategy, get_timeout_manager
+
 from .jobs import JobManager
 
 console = Console()
@@ -12,58 +16,162 @@ class WebSocketHandler:
     def __init__(self, job_manager: JobManager, progress_dir: Path) -> None:
         self.job_manager = job_manager
         self.progress_dir = progress_dir
+        self.timeout_manager = get_timeout_manager()
 
     async def handle_connection(self, websocket: WebSocket, job_id: str) -> None:
         if not self.job_manager.validate_job_id(job_id):
             await websocket.close(code=1008, reason="Invalid job ID")
             return
 
+        try:
+            # Add timeout to the entire connection handling
+            async with self.timeout_manager.timeout_context(
+                "websocket_connection",
+                timeout=3600.0,  # 1 hour max connection time
+                strategy=TimeoutStrategy.GRACEFUL_DEGRADATION,
+            ):
+                await self._establish_connection(websocket, job_id)
+                await self._send_initial_progress(websocket, job_id)
+                await self._handle_message_loop(websocket, job_id)
+
+        except TimeoutError:
+            await self._handle_timeout_error(websocket, job_id)
+        except WebSocketDisconnect:
+            console.print(f"[yellow]WebSocket disconnected for job: {job_id}[/yellow]")
+        except Exception as e:
+            await self._handle_connection_error(websocket, job_id, e)
+        finally:
+            await self._cleanup_connection(job_id, websocket)
+
+    async def _establish_connection(self, websocket: WebSocket, job_id: str) -> None:
+        """Establish WebSocket connection and add to job manager."""
         await websocket.accept()
         self.job_manager.add_connection(job_id, websocket)
-
         console.print(f"[green]WebSocket connected for job: {job_id}[/green]")
 
+    async def _send_initial_progress(self, websocket: WebSocket, job_id: str) -> None:
+        """Send initial progress data to the connected WebSocket."""
         try:
-            initial_progress = self.job_manager.get_job_progress(job_id)
-            if initial_progress:
-                await websocket.send_json(initial_progress)
-            else:
-                await websocket.send_json(
-                    {
-                        "job_id": job_id,
-                        "status": "waiting",
-                        "message": "Waiting for job to start...",
-                        "overall_progress": 0,
-                        "iteration": 0,
-                        "max_iterations": 10,
-                        "current_stage": "Initializing",
-                    },
+            async with self.timeout_manager.timeout_context(
+                "websocket_broadcast",
+                timeout=5.0,
+                strategy=TimeoutStrategy.FAIL_FAST,
+            ):
+                initial_progress = self.job_manager.get_job_progress(job_id)
+                if initial_progress:
+                    await websocket.send_json(initial_progress)
+                else:
+                    await websocket.send_json(
+                        self._create_initial_progress_message(job_id)
+                    )
+        except Exception as e:
+            console.print(
+                f"[red]Failed to send initial progress for {job_id}: {e}[/red]"
+            )
+
+    def _create_initial_progress_message(self, job_id: str) -> dict:
+        """Create initial progress message for new jobs."""
+        return {
+            "job_id": job_id,
+            "status": "waiting",
+            "message": "Waiting for job to start...",
+            "overall_progress": 0,
+            "iteration": 0,
+            "max_iterations": 10,
+            "current_stage": "Initializing",
+        }
+
+    async def _handle_message_loop(self, websocket: WebSocket, job_id: str) -> None:
+        """Handle the main message processing loop."""
+        message_count = 0
+        max_messages = 10000  # Prevent infinite message loops
+
+        while message_count < max_messages:
+            try:
+                should_continue = await self._process_single_message(
+                    websocket, job_id, message_count + 1
+                )
+                if not should_continue:
+                    break
+                message_count += 1
+            except (TimeoutError, WebSocketDisconnect, Exception):
+                break
+
+        if message_count >= max_messages:
+            console.print(
+                f"[yellow]WebSocket connection limit reached for {job_id}: {max_messages} messages[/yellow]"
+            )
+
+    async def _process_single_message(
+        self, websocket: WebSocket, job_id: str, message_count: int
+    ) -> bool:
+        """Process a single WebSocket message. Returns False to break the loop."""
+        try:
+            # Add timeout to individual message operations
+            async with self.timeout_manager.timeout_context(
+                "websocket_message",
+                timeout=30.0,  # 30 second timeout per message
+                strategy=TimeoutStrategy.FAIL_FAST,
+            ):
+                # Use asyncio.wait_for for additional protection
+                data = await asyncio.wait_for(
+                    websocket.receive_text(),
+                    timeout=25.0,  # Slightly less than timeout context
                 )
 
-            while True:
-                try:
-                    data = await websocket.receive_text()
-                    console.print(
-                        f"[blue]Received message for {job_id}: {data[:100]}...[/blue]",
-                    )
+                console.print(
+                    f"[blue]Received message {message_count} for {job_id}: {data[:100]}...[/blue]",
+                )
 
-                    await websocket.send_json(
+                # Respond with timeout protection
+                await asyncio.wait_for(
+                    websocket.send_json(
                         {
                             "type": "echo",
                             "message": f"Received: {data}",
                             "job_id": job_id,
-                        },
-                    )
+                            "message_count": message_count,
+                        }
+                    ),
+                    timeout=5.0,
+                )
 
-                except WebSocketDisconnect:
-                    break
+                return True
 
+        except TimeoutError:
+            console.print(
+                f"[yellow]Message timeout for {job_id} after {message_count} messages[/yellow]"
+            )
+            return False
         except WebSocketDisconnect:
             console.print(f"[yellow]WebSocket disconnected for job: {job_id}[/yellow]")
+            return False
         except Exception as e:
-            console.print(f"[red]WebSocket error for job {job_id}: {e}[/red]")
-        finally:
+            console.print(f"[red]WebSocket message error for job {job_id}: {e}[/red]")
+            return False
+
+    async def _handle_timeout_error(self, websocket: WebSocket, job_id: str) -> None:
+        """Handle timeout errors during connection."""
+        console.print(
+            f"[yellow]WebSocket connection timeout for job: {job_id}[/yellow]"
+        )
+        with suppress(Exception):
+            await websocket.close(code=1001, reason="Connection timeout")
+
+    async def _handle_connection_error(
+        self, websocket: WebSocket, job_id: str, error: Exception
+    ) -> None:
+        """Handle connection errors."""
+        console.print(f"[red]WebSocket error for job {job_id}: {error}[/red]")
+        with suppress(Exception):
+            await websocket.close(code=1011, reason="Internal error")
+
+    async def _cleanup_connection(self, job_id: str, websocket: WebSocket) -> None:
+        """Clean up the connection."""
+        try:
             self.job_manager.remove_connection(job_id, websocket)
+        except Exception as e:
+            console.print(f"[red]Error removing connection for {job_id}: {e}[/red]")
 
 
 def register_websocket_routes(
@@ -73,6 +181,6 @@ def register_websocket_routes(
 ) -> None:
     handler = WebSocketHandler(job_manager, progress_dir)
 
-    @app.websocket(" / ws / progress / {job_id}")
+    @app.websocket("/ws/progress/{job_id}")
     async def websocket_progress_endpoint(websocket: WebSocket, job_id: str) -> None:
         await handler.handle_connection(websocket, job_id)

crackerjack/models/config_adapter.py

@@ -1,8 +1,3 @@
-"""Adapter for converting between the old OptionsProtocol and new WorkflowOptions.
-
-This provides backward compatibility during the migration period.
-"""
-
 import typing as t
 
 from .config import (
@@ -21,11 +16,8 @@ from .protocols import OptionsProtocol
 
 
 class OptionsAdapter:
-    """Adapter to convert between old and new configuration formats."""
-
     @staticmethod
     def from_options_protocol(options: OptionsProtocol) -> WorkflowOptions:
-        """Convert OptionsProtocol to WorkflowOptions."""
         return WorkflowOptions(
             cleaning=CleaningConfig(
                 clean=getattr(options, "clean", True),
@@ -60,7 +52,7 @@ class OptionsAdapter:
             ),
             ai=AIConfig(
                 ai_agent=getattr(options, "ai_agent", False),
-                autofix=getattr(options, "autofix", True),  # Default true per CLAUDE.md
+                autofix=getattr(options, "autofix", True),
                 ai_agent_autofix=getattr(options, "ai_agent_autofix", False),
                 start_mcp_server=getattr(options, "start_mcp_server", False),
                 max_iterations=getattr(options, "max_iterations", 10),
@@ -85,18 +77,13 @@ class OptionsAdapter:
     def to_options_protocol(
         workflow_options: WorkflowOptions,
     ) -> "LegacyOptionsWrapper":
-        """Convert WorkflowOptions back to OptionsProtocol for backward compatibility."""
         return LegacyOptionsWrapper(workflow_options)
 
 
 class LegacyOptionsWrapper:
-    """Wrapper that provides OptionsProtocol interface over WorkflowOptions."""
-
     def __init__(self, workflow_options: WorkflowOptions) -> None:
         self._options = workflow_options
 
-    # All the original OptionsProtocol attributes, delegating to the focused configs
-
     @property
     def commit(self) -> bool:
         return self._options.git.commit
@@ -223,8 +210,8 @@ class LegacyOptionsWrapper:
 
     @property
     def enterprise_batch(self) -> str | None:
-        return None  # Deprecated field
+        return None
 
     @property
     def monitor_dashboard(self) -> str | None:
-        return None  # Deprecated field
+        return None

crackerjack/models/protocols.py

@@ -1,5 +1,6 @@
 import subprocess
 import typing as t
+from pathlib import Path
 
 
 @t.runtime_checkable
@@ -45,7 +46,11 @@ class OptionsProtocol(t.Protocol):
     comp: bool = False
     enterprise_batch: str | None = None
     monitor_dashboard: str | None = None
-    coverage: bool = False
+    skip_config_merge: bool = False
+    disable_global_locks: bool = False
+    global_lock_timeout: int = 600
+    global_lock_cleanup: bool = True
+    global_lock_dir: str | None = None
 
 
 @t.runtime_checkable
@@ -98,11 +103,11 @@ class HookManager(t.Protocol):
 class TestManagerProtocol(t.Protocol):
     def run_tests(self, options: OptionsProtocol) -> bool: ...
 
-    def get_coverage(self) -> dict[str, t.Any]: ...
+    def get_test_failures(self) -> list[str]: ...
 
     def validate_test_environment(self) -> bool: ...
 
-    def get_test_failures(self) -> list[str]: ...
+    def get_coverage(self) -> dict[str, t.Any]: ...
 
 
 @t.runtime_checkable
@@ -116,3 +121,157 @@ class PublishManager(t.Protocol):
     def create_git_tag(self, version: str) -> bool: ...
 
     def cleanup_old_releases(self, keep_releases: int) -> None: ...
+
+
+@t.runtime_checkable
+class ConfigMergeServiceProtocol(t.Protocol):
+    """Protocol for smart configuration file merging."""
+
+    def smart_merge_pyproject(
+        self,
+        source_content: dict[str, t.Any],
+        target_path: str | t.Any,
+        project_name: str,
+    ) -> dict[str, t.Any]: ...
+
+    def smart_merge_pre_commit_config(
+        self,
+        source_content: dict[str, t.Any],
+        target_path: str | t.Any,
+        project_name: str,
+    ) -> dict[str, t.Any]: ...
+
+    def smart_append_file(
+        self,
+        source_content: str,
+        target_path: str | t.Any,
+        start_marker: str,
+        end_marker: str,
+        force: bool = False,
+    ) -> str: ...
+
+    def smart_merge_gitignore(
+        self,
+        patterns: list[str],
+        target_path: str | t.Any,
+    ) -> str: ...
+
+    def write_pyproject_config(
+        self,
+        config: dict[str, t.Any],
+        target_path: str | t.Any,
+    ) -> None: ...
+
+    def write_pre_commit_config(
+        self,
+        config: dict[str, t.Any],
+        target_path: str | t.Any,
+    ) -> None: ...
+
+
+@t.runtime_checkable
+class HookLockManagerProtocol(t.Protocol):
+    """Protocol for managing hook-specific locks to prevent concurrent execution."""
+
+    def requires_lock(self, hook_name: str) -> bool:
+        """Check if a hook requires sequential execution.
+
+        Args:
+            hook_name: Name of the hook to check
+
+        Returns:
+            True if the hook requires a lock for sequential execution
+        """
+        ...
+
+    async def acquire_hook_lock(self, hook_name: str) -> t.AsyncContextManager[None]:
+        """Acquire a lock for the specified hook if it requires one.
+
+        Args:
+            hook_name: Name of the hook to lock
+
+        Returns:
+            Async context manager for lock acquisition
+        """
+        ...
+
+    def get_lock_stats(self) -> dict[str, t.Any]:
+        """Get statistics about lock usage for monitoring.
+
+        Returns:
+            Dict containing lock statistics per hook
+        """
+        ...
+
+    def add_hook_to_lock_list(self, hook_name: str) -> None:
+        """Add a hook to the list requiring sequential execution.
+
+        Args:
+            hook_name: Name of the hook to add
+        """
+        ...
+
+    def remove_hook_from_lock_list(self, hook_name: str) -> None:
+        """Remove a hook from the list requiring sequential execution.
+
+        Args:
+            hook_name: Name of the hook to remove
+        """
+        ...
+
+    def is_hook_currently_locked(self, hook_name: str) -> bool:
+        """Check if a hook is currently locked.
+
+        Args:
+            hook_name: Name of the hook to check
+
+        Returns:
+            True if the hook is currently locked
+        """
+        ...
+
+    def enable_global_lock(self, enabled: bool = True) -> None:
+        """Enable or disable global lock functionality.
+
+        Args:
+            enabled: Whether to enable global locking
+        """
+        ...
+
+    def is_global_lock_enabled(self) -> bool:
+        """Check if global lock functionality is enabled.
+
+        Returns:
+            True if global locking is enabled
+        """
+        ...
+
+    def get_global_lock_path(self, hook_name: str) -> Path:
+        """Get the filesystem path for a hook's global lock file.
+
+        Args:
+            hook_name: Name of the hook
+
+        Returns:
+            Path to the lock file for the hook
+        """
+        ...
+
+    def cleanup_stale_locks(self, max_age_hours: float = 2.0) -> int:
+        """Clean up stale lock files older than max_age_hours.
+
+        Args:
+            max_age_hours: Maximum age in hours before a lock is considered stale
+
+        Returns:
+            Number of stale locks cleaned up
+        """
+        ...
+
+    def get_global_lock_stats(self) -> dict[str, t.Any]:
+        """Get comprehensive statistics about global lock usage.
+
+        Returns:
+            Dictionary containing global lock statistics and metrics
+        """
+        ...