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

crackerjack/managers/test_progress.py

@@ -1,17 +1,9 @@
-"""Test progress tracking and display functionality.
-
-This module handles real-time test execution progress tracking, including collection
-and execution phases. Split from test_manager.py for better separation of concerns.
-"""
-
 import threading
 import time
 import typing as t
 
 
 class TestProgress:
-    """Tracks test execution progress with thread-safe updates."""
-
     def __init__(self) -> None:
         self.total_tests: int = 0
         self.passed: int = 0
@@ -25,21 +17,18 @@ class TestProgress:
         self.files_discovered: int = 0
         self.collection_status: str = "Starting collection..."
         self._lock = threading.Lock()
-        self._seen_files: set[str] = set()  # Track seen files to prevent duplicates
+        self._seen_files: set[str] = set()
 
     @property
     def completed(self) -> int:
-        """Total completed tests (passed + failed + skipped + errors)."""
         return self.passed + self.failed + self.skipped + self.errors
 
     @property
     def elapsed_time(self) -> float:
-        """Elapsed time since test start."""
         return time.time() - self.start_time if self.start_time else 0
 
     @property
     def eta_seconds(self) -> float | None:
-        """Estimated time to completion based on current progress rate."""
         if self.completed <= 0 or self.total_tests <= 0:
             return None
         progress_rate = (
@@ -49,20 +38,17 @@ class TestProgress:
         return remaining / progress_rate if progress_rate > 0 else None
 
     def update(self, **kwargs: t.Any) -> None:
-        """Thread-safe update of progress attributes."""
         with self._lock:
             for key, value in kwargs.items():
                 if hasattr(self, key):
                     setattr(self, key, value)
 
     def format_progress(self) -> str:
-        """Format progress display for Rich output."""
         if self.is_collecting:
             return self._format_collection_progress()
         return self._format_execution_progress()
 
     def _format_collection_progress(self) -> str:
-        """Format test collection progress display."""
         status_parts = [self.collection_status]
 
         if self.files_discovered > 0:
@@ -70,20 +56,17 @@ class TestProgress:
 
         elapsed = self.elapsed_time
         if elapsed > 1:
-            status_parts.append(f"{elapsed:.1f}s")
+            status_parts.append(f"{elapsed: .1f}s")
 
         return " | ".join(status_parts)
 
     def _format_execution_progress(self) -> str:
-        """Format test execution progress display."""
         parts = []
 
-        # Test progress
         if self.total_tests > 0:
             progress_pct = (self.completed / self.total_tests) * 100
-            parts.append(f"{self.completed}/{self.total_tests} ({progress_pct:.1f}%)")
+            parts.append(f"{self.completed}/{self.total_tests} ({progress_pct: .1f}%)")
 
-        # Status counts
         status_parts = []
         if self.passed > 0:
             status_parts.append(f"✅ {self.passed}")
@@ -97,7 +80,6 @@ class TestProgress:
         if status_parts:
             parts.append(" ".join(status_parts))
 
-        # Current test (truncated)
         if self.current_test and not self.is_complete:
             test_name = (
                 self.current_test[:30] + "..."
@@ -106,9 +88,8 @@ class TestProgress:
             )
             parts.append(f"Running: {test_name}")
 
-        # Timing
         elapsed = self.elapsed_time
         if elapsed > 1:
-            parts.append(f"{elapsed:.1f}s")
+            parts.append(f"{elapsed: .1f}s")
 
         return " | ".join(parts)

crackerjack/mcp/cache.py

@@ -2,6 +2,7 @@ import asyncio
 import json
 import time
 import typing as t
+from contextlib import suppress
 from dataclasses import asdict, dataclass
 from pathlib import Path
 
@@ -188,8 +189,8 @@ class ErrorCache:
     def _extract_pyright_info(self, line: str) -> tuple[str, str]:
         error_code = ""
         message_pattern = line
-        if " - error: " in line:
-            parts = line.split(" - error: ")
+        if "-error: " in line:
+            parts = line.split("-error: ")
             if len(parts) >= 2:
                 message_pattern = parts[1].strip()
                 if "(" in message_pattern and ")" in message_pattern:
@@ -314,23 +315,15 @@ class ErrorCache:
                 self.fix_results = []
 
     def _save_patterns(self) -> None:
-        try:
+        with suppress(OSError, json.JSONEncodeError):
             patterns_data = {
                 pid: pattern.to_dict() for pid, pattern in self.patterns.items()
             }
             with self.patterns_file.open("w") as f:
                 json.dump(patterns_data, f, indent=2)
-        except (OSError, json.JSONEncodeError):
-            pass
-        except Exception:
-            pass
 
     def _save_fixes(self) -> None:
-        try:
+        with suppress(OSError, json.JSONEncodeError):
             fixes_data = [result.to_dict() for result in self.fix_results]
             with self.fixes_file.open("w") as f:
                 json.dump(fixes_data, f, indent=2)
-        except (OSError, json.JSONEncodeError):
-            pass
-        except Exception:
-            pass

crackerjack/mcp/client_runner.py

@@ -26,10 +26,10 @@ async def ensure_mcp_server_running() -> subprocess.Popen | None:
     console = Console()
 
     if is_mcp_server_running():
-        console.print("[green]✅ MCP server already running[/green]")
+        console.print("[green]✅ MCP server already running[/ green]")
         return None
 
-    console.print("[yellow]🚀 Starting MCP server...[/yellow]")
+    console.print("[yellow]🚀 Starting MCP server...[/ yellow]")
     server_process = subprocess.Popen(
         [sys.executable, "-m", "crackerjack", "--start-mcp-server"],
         stdout=subprocess.PIPE,
@@ -39,17 +39,17 @@ async def ensure_mcp_server_running() -> subprocess.Popen | None:
 
     for _i in range(20):
         if is_mcp_server_running():
-            console.print("[green]✅ MCP server started successfully[/green]")
+            console.print("[green]✅ MCP server started successfully[/ green]")
             return server_process
         await asyncio.sleep(0.5)
 
-    console.print("[red]❌ Failed to start MCP server[/red]")
+    console.print("[red]❌ Failed to start MCP server[/ red]")
     server_process.terminate()
     msg = "Failed to start MCP server within timeout period"
     raise RuntimeError(msg)
 
 
-async def run_with_mcp_server(command: str = "/crackerjack:run") -> None:
+async def run_with_mcp_server(command: str = "/ crackerjack: run") -> None:
     console = Console()
 
     server_process = await ensure_mcp_server_running()
@@ -70,12 +70,12 @@ async def run_with_mcp_server(command: str = "/crackerjack:run") -> None:
             try:
                 await run_crackerjack_with_progress(session, command)
             except Exception as e:
-                console.print(f"[bold red]Error: {e}[/bold red]")
+                console.print(f"[bold red]Error: {e}[/ bold red]")
                 sys.exit(1)
     finally:
         if server_process:
             console.print(
-                "[yellow]Note: MCP server continues running in background[/yellow]",
+                "[yellow]Note: MCP server continues running in background[/ yellow]",
             )
 
 
@@ -88,15 +88,15 @@ def main() -> None:
     parser.add_argument(
         "command",
         nargs="?",
-        default="/crackerjack:run",
-        help="Command to execute (default: /crackerjack:run)",
+        default="/ crackerjack: run",
+        help="Command to execute (default: / crackerjack: run)",
     )
     args = parser.parse_args()
 
     try:
         asyncio.run(run_with_mcp_server(args.command))
     except KeyboardInterrupt:
-        Console().print("\n[yellow]Operation cancelled by user[/yellow]")
+        Console().print("\n[yellow]Operation cancelled by user[/ yellow]")
         sys.exit(1)
 
 

crackerjack/mcp/context.py

@@ -12,7 +12,13 @@ from types import TracebackType
 
 from rich.console import Console
 
+from crackerjack.core.resource_manager import (
+    ResourceManager,
+    register_global_resource_manager,
+)
+from crackerjack.core.websocket_lifecycle import NetworkResourceManager
 from crackerjack.core.workflow_orchestrator import WorkflowOrchestrator
+from crackerjack.services.secure_path_utils import SecurePathValidator
 
 from .cache import ErrorCache
 from .rate_limiter import RateLimitConfig, RateLimitMiddleware
@@ -123,11 +129,31 @@ class MCPServerConfig:
     state_dir: Path | None = None
     cache_dir: Path | None = None
 
+    def __post_init__(self) -> None:
+        # Validate all paths using secure path validation
+        self.project_path = SecurePathValidator.validate_safe_path(self.project_path)
+
+        if self.progress_dir:
+            self.progress_dir = SecurePathValidator.validate_safe_path(
+                self.progress_dir
+            )
+
+        if self.state_dir:
+            self.state_dir = SecurePathValidator.validate_safe_path(self.state_dir)
+
+        if self.cache_dir:
+            self.cache_dir = SecurePathValidator.validate_safe_path(self.cache_dir)
+
 
 class MCPServerContext:
     def __init__(self, config: MCPServerConfig) -> None:
         self.config = config
 
+        # Resource management
+        self.resource_manager = ResourceManager()
+        self.network_manager = NetworkResourceManager()
+        register_global_resource_manager(self.resource_manager)
+
         self.console: Console | None = None
         self.cli_runner = None
         self.state_manager: StateManager | None = None
@@ -202,6 +228,7 @@ class MCPServerContext:
         if not self._initialized:
             return
 
+        # Run custom shutdown tasks first
         for task in reversed(self._shutdown_tasks):
             try:
                 await task()
@@ -209,19 +236,40 @@ class MCPServerContext:
                 if self.console:
                     self.console.print(f"[red]Error during shutdown: {e}[/red]")
 
+        # Cancel health check task
         if self._websocket_health_check_task:
             self._websocket_health_check_task.cancel()
             with contextlib.suppress(asyncio.CancelledError):
                 await self._websocket_health_check_task
             self._websocket_health_check_task = None
 
+        # Stop WebSocket server
         await self._stop_websocket_server()
 
+        # Stop rate limiter
         if self.rate_limiter:
             await self.rate_limiter.stop()
 
+        # Stop batched saver
         await self.batched_saver.stop()
 
+        # Clean up all managed resources
+        try:
+            await self.network_manager.cleanup_all()
+        except Exception as e:
+            if self.console:
+                self.console.print(
+                    f"[yellow]Warning: Network resource cleanup error: {e}[/yellow]"
+                )
+
+        try:
+            await self.resource_manager.cleanup_all()
+        except Exception as e:
+            if self.console:
+                self.console.print(
+                    f"[yellow]Warning: Resource cleanup error: {e}[/yellow]"
+                )
+
         self._initialized = False
 
     def add_startup_task(self, task: t.Callable[[], t.Awaitable[None]]) -> None:
@@ -241,9 +289,9 @@ class MCPServerContext:
             uuid.UUID(job_id)
             return True
 
-        import re
+        from crackerjack.services.regex_patterns import is_valid_job_id
 
-        if not re.match(r"^[a-zA-Z0-9_-]+$", job_id):
+        if not is_valid_job_id(job_id):
             return False
 
         if ".." in job_id or "/" in job_id or "\\" in job_id:
@@ -268,7 +316,7 @@ class MCPServerContext:
 
             if self.console:
                 self.console.print(
-                    f"🚀 Starting WebSocket server on localhost:{self.websocket_server_port}...",
+                    f"🚀 Starting WebSocket server on localhost: {self.websocket_server_port}...",
                 )
 
             try:
@@ -321,6 +369,13 @@ class MCPServerContext:
             start_new_session=True,
         )
 
+        # Register the process with the network resource manager for automatic cleanup
+        if self.websocket_server_process:
+            managed_process = self.network_manager.create_subprocess(
+                self.websocket_server_process, timeout=30.0
+            )
+            await managed_process.start_monitoring()
+
     async def _register_websocket_cleanup(self) -> None:
         if not self._websocket_cleanup_registered:
             self.add_shutdown_task(self._stop_websocket_server)
@@ -351,7 +406,7 @@ class MCPServerContext:
                         f"✅ WebSocket server started successfully on port {self.websocket_server_port}",
                     )
                     self.console.print(
-                        f"📊 Progress available at: ws://localhost:{self.websocket_server_port}/ws/progress/{{job_id}}",
+                        f"📊 Progress available at: ws: / / localhost: {self.websocket_server_port}/ ws / progress /{{job_id}}",
                     )
                 return True
 
@@ -512,7 +567,11 @@ class MCPServerContext:
         if not self.validate_job_id(job_id):
             msg = f"Invalid job_id: {job_id}"
             raise ValueError(msg)
-        return self.progress_dir / f"job-{job_id}.json"
+
+        # Use secure path joining to prevent directory traversal
+        return SecurePathValidator.secure_path_join(
+            self.progress_dir, f"job-{job_id}.json"
+        )
 
     async def schedule_state_save(
         self,
@@ -522,7 +581,6 @@ class MCPServerContext:
         await self.batched_saver.schedule_save(save_id, save_func)
 
     def get_current_time(self) -> str:
-        """Get current timestamp as string for progress tracking."""
         import datetime
 
         return datetime.datetime.now().isoformat()

crackerjack/mcp/dashboard.py

@@ -63,7 +63,7 @@ class MetricCard(Static):
     }
     """
 
-    value = reactive(" -- ")
+    value = reactive(" --")
     label = reactive("Metric")
     trend = reactive("")
     status = reactive("")
@@ -71,7 +71,7 @@ class MetricCard(Static):
     def __init__(
         self,
         label: str,
-        value: str = " -- ",
+        value: str = " --",
         trend: str = "",
         status: str = "",
         **kwargs,
@@ -414,7 +414,7 @@ class CrackerjackDashboard(App):
         try:
             timeout = aiohttp.ClientTimeout(total=5.0)
             async with aiohttp.ClientSession(timeout=timeout) as session:
-                async with session.get("http://localhost:8675/") as response:
+                async with session.get("http: / / localhost: 8675 /") as response:
                     return response.status == 200
         except Exception:
             return False
@@ -425,7 +425,7 @@ class CrackerjackDashboard(App):
 
             cpu_percent = psutil.cpu_percent(interval=None)
             memory = psutil.virtual_memory()
-            memory_mb = memory.used // (1024 * 1024)
+            memory_mb = memory.used / (1024 * 1024)
 
             cpu_metric = self.query_one("#cpu_metric", MetricCard)
             memory_metric = self.query_one("#memory_metric", MetricCard)
@@ -459,7 +459,9 @@ class CrackerjackDashboard(App):
         try:
             timeout = aiohttp.ClientTimeout(total=10.0)
             async with aiohttp.ClientSession(timeout=timeout) as session:
-                async with session.get("http://localhost:8675/api/jobs") as response:
+                async with session.get(
+                    "http: / / localhost: 8675 / api / jobs"
+                ) as response:
                     if response.status == 200:
                         return await response.json()
                     return {}
@@ -474,19 +476,20 @@ class CrackerjackDashboard(App):
             import tempfile
 
             temp_dir = Path(tempfile.gettempdir())
-            debug_files = temp_dir.glob("crackerjack-debug-*.log")
+            debug_files = temp_dir.glob("crackerjack - debug-*.log")
             for debug_file in debug_files:
                 try:
                     if debug_file.stat().st_mtime > (time.time() - 3600):
                         debug_file.read_text()
-                        job_id = debug_file.stem.replace("crackerjack-debug-", "")
+                        job_id = debug_file.stem.replace("crackerjack-debug -", "")
                         jobs[job_id] = {
                             "id": job_id,
                             "status": "completed",
                             "log_file": str(debug_file),
                             "timestamp": debug_file.stat().st_mtime,
                         }
-                except Exception:
+                except Exception as e:
+                    self.log(f"Could not process debug file {debug_file}: {e}")
                     continue
 
             return jobs
@@ -512,10 +515,10 @@ class CrackerjackDashboard(App):
                 reverse=True,
             ):
                 status = job_data.get("status", "unknown")
-                stage = job_data.get("current_stage", "N/A")
+                stage = job_data.get("current_stage", "N / A")
                 progress = job_data.get("progress", 0)
                 started = datetime.fromtimestamp(job_data.get("timestamp", 0)).strftime(
-                    "%H:%M:%S",
+                    "% H: % M: % S",
                 )
                 duration = self._format_duration(job_data.get("duration", 0))
                 issues = job_data.get("issues_found", 0)
@@ -577,7 +580,7 @@ class CrackerjackDashboard(App):
         try:
             log_display = self.query_one("#log_display", Log)
 
-            current_time = datetime.now().strftime("%H:%M:%S")
+            current_time = datetime.now().strftime("% H: % M: % S")
             if len(self.logs_buffer) % 10 == 0:
                 log_display.write_line(f"[{current_time}] Dashboard refresh completed")