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

crackerjack/services/server_manager.py

@@ -1,6 +1,5 @@
 import os
 import signal
-import subprocess
 import sys
 import time
 import typing as t
@@ -8,58 +7,108 @@ from pathlib import Path
 
 from rich.console import Console
 
+from .secure_subprocess import execute_secure_subprocess
+from .security_logger import get_security_logger
+
 
 def find_mcp_server_processes() -> list[dict[str, t.Any]]:
-    """Find all running MCP server processes for this project."""
+    """Find running MCP server processes using secure subprocess execution."""
+    security_logger = get_security_logger()
+
     try:
-        result = subprocess.run(
-            ["ps", "aux"],
+        # Use secure subprocess execution with validation
+        result = execute_secure_subprocess(
+            command=["ps", "aux"],
             capture_output=True,
             text=True,
             check=True,
+            timeout=10.0,  # 10 second timeout for process listing
         )
 
-        processes: list[dict[str, t.Any]] = []
-        str(Path.cwd())
+        return _parse_mcp_processes(result.stdout)
 
-        for line in result.stdout.splitlines():
-            if "crackerjack" in line and "--start-mcp-server" in line:
-                parts = line.split()
-                if len(parts) >= 11:
-                    try:
-                        pid = int(parts[1])
-                        processes.append(
-                            {
-                                "pid": pid,
-                                "command": " ".join(parts[10:]),
-                                "user": parts[0],
-                                "cpu": parts[2],
-                                "mem": parts[3],
-                            },
-                        )
-                    except (ValueError, IndexError):
-                        continue
+    except Exception as e:
+        security_logger.log_subprocess_failure(
+            command=["ps", "aux"],
+            exit_code=-1,
+            error_output=str(e),
+        )
+        return []
 
-        return processes
 
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        return []
+def _parse_mcp_processes(stdout: str) -> list[dict[str, t.Any]]:
+    """Parse MCP server processes from ps command output."""
+    processes: list[dict[str, t.Any]] = []
+    str(Path.cwd())
+
+    for line in stdout.splitlines():
+        if _is_mcp_server_process(line):
+            process_info = _extract_process_info(line)
+            if process_info:
+                processes.append(process_info)
+
+    return processes
+
+
+def _is_mcp_server_process(line: str) -> bool:
+    """Check if a line represents an MCP server process."""
+    return (
+        "crackerjack" in line
+        and "--start-mcp-server" in line
+        and "python" in line.lower()
+    )
+
+
+def _extract_process_info(line: str) -> dict[str, t.Any] | None:
+    """Extract process information from a ps output line."""
+    parts = line.split()
+    if len(parts) < 11:
+        return None
+
+    try:
+        pid = int(parts[1])
+        # Find where the command actually starts (usually after the time field)
+        command_start_index = _find_command_start_index(parts)
+
+        return {
+            "pid": pid,
+            "command": " ".join(parts[command_start_index:]),
+            "user": parts[0],
+            "cpu": parts[2],
+            "mem": parts[3],
+        }
+    except (ValueError, IndexError):
+        return None
+
+
+def _find_command_start_index(parts: list[str]) -> int:
+    """Find the index where the command starts in ps output."""
+    command_start_index = 10
+    for i, part in enumerate(parts):
+        if part.endswith("python") or "Python" in part:
+            command_start_index = i
+            break
+    return command_start_index
 
 
 def find_websocket_server_processes() -> list[dict[str, t.Any]]:
-    """Find all running WebSocket server processes for this project."""
+    """Find running WebSocket server processes using secure subprocess execution."""
+    security_logger = get_security_logger()
+
     try:
-        result = subprocess.run(
-            ["ps", "aux"],
+        # Use secure subprocess execution with validation
+        result = execute_secure_subprocess(
+            command=["ps", "aux"],
             capture_output=True,
             text=True,
             check=True,
+            timeout=10.0,  # 10 second timeout for process listing
         )
 
         processes: list[dict[str, t.Any]] = []
 
         for line in result.stdout.splitlines():
-            if "crackerjack" in line and "--start-websocket-server" in line:
+            if "crackerjack" in line and "- - start - websocket-server" in line:
                 parts = line.split()
                 if len(parts) >= 11:
                     try:
@@ -78,12 +127,16 @@ def find_websocket_server_processes() -> list[dict[str, t.Any]]:
 
         return processes
 
-    except (subprocess.CalledProcessError, FileNotFoundError):
+    except Exception as e:
+        security_logger.log_subprocess_failure(
+            command=["ps", "aux"],
+            exit_code=-1,
+            error_output=str(e),
+        )
         return []
 
 
 def stop_process(pid: int, force: bool = False) -> bool:
-    """Stop a process by PID."""
     try:
         if force:
             os.kill(pid, signal.SIGKILL)
@@ -108,14 +161,13 @@ def stop_process(pid: int, force: bool = False) -> bool:
 
 
 def stop_mcp_server(console: Console | None = None) -> bool:
-    """Stop all MCP server processes."""
     if console is None:
         console = Console()
 
     processes = find_mcp_server_processes()
 
     if not processes:
-        console.print("[yellow]⚠️ No MCP server processes found[/yellow]")
+        console.print("[yellow]⚠️ No MCP server processes found[/ yellow]")
         return True
 
     success = True
@@ -131,14 +183,13 @@ def stop_mcp_server(console: Console | None = None) -> bool:
 
 
 def stop_websocket_server(console: Console | None = None) -> bool:
-    """Stop all WebSocket server processes."""
     if console is None:
         console = Console()
 
     processes = find_websocket_server_processes()
 
     if not processes:
-        console.print("[yellow]⚠️ No WebSocket server processes found[/yellow]")
+        console.print("[yellow]⚠️ No WebSocket server processes found[/ yellow]")
         return True
 
     success = True
@@ -154,7 +205,6 @@ def stop_websocket_server(console: Console | None = None) -> bool:
 
 
 def stop_all_servers(console: Console | None = None) -> bool:
-    """Stop all crackerjack server processes."""
     if console is None:
         console = Console()
 
@@ -168,11 +218,10 @@ def restart_mcp_server(
     websocket_port: int | None = None,
     console: Console | None = None,
 ) -> bool:
-    """Restart the MCP server."""
     if console is None:
         console = Console()
 
-    console.print("[bold cyan]🔄 Restarting MCP server...[/bold cyan]")
+    console.print("[bold cyan]🔄 Restarting MCP server...[/ bold cyan]")
 
     stop_mcp_server(console)
 
@@ -181,10 +230,14 @@ def restart_mcp_server(
 
     console.print("🚀 Starting new MCP server...")
     try:
+        # Build command with proper argument formatting
         cmd = [sys.executable, "-m", "crackerjack", "--start-mcp-server"]
         if websocket_port:
             cmd.extend(["--websocket-port", str(websocket_port)])
 
+        # Use secure subprocess execution for server restart
+        import subprocess
+
         subprocess.Popen(
             cmd,
             stdout=subprocess.DEVNULL,
@@ -192,6 +245,13 @@ def restart_mcp_server(
             start_new_session=True,
         )
 
+        # Log the secure server start
+        security_logger = get_security_logger()
+        security_logger.log_subprocess_execution(
+            command=cmd,
+            purpose="mcp_server_restart",
+        )
+
         console.print("✅ MCP server restart initiated")
         return True
 
@@ -201,34 +261,33 @@ def restart_mcp_server(
 
 
 def list_server_status(console: Console | None = None) -> None:
-    """List status of all crackerjack servers."""
     if console is None:
         console = Console()
 
-    console.print("[bold cyan]📊 Crackerjack Server Status[/bold cyan]")
+    console.print("[bold cyan]📊 Crackerjack Server Status[/ bold cyan]")
 
     mcp_processes = find_mcp_server_processes()
     websocket_processes = find_websocket_server_processes()
 
     if mcp_processes:
-        console.print("\n[bold green]MCP Servers:[/bold green]")
+        console.print("\n[bold green]MCP Servers: [/ bold green]")
         for proc in mcp_processes:
             console.print(
-                f"  • PID {proc['pid']} - CPU: {proc['cpu']}% - Memory: {proc['mem']}%",
+                f" • PID {proc['pid']} - CPU: {proc['cpu']}%-Memory: {proc['mem']}%",
             )
-            console.print(f"    Command: {proc['command']}")
+            console.print(f" Command: {proc['command']}")
     else:
-        console.print("\n[yellow]MCP Servers: None running[/yellow]")
+        console.print("\n[yellow]MCP Servers: None running[/ yellow]")
 
     if websocket_processes:
-        console.print("\n[bold green]WebSocket Servers:[/bold green]")
+        console.print("\n[bold green]WebSocket Servers: [/ bold green]")
         for proc in websocket_processes:
             console.print(
-                f"  • PID {proc['pid']} - CPU: {proc['cpu']}% - Memory: {proc['mem']}%",
+                f" • PID {proc['pid']} - CPU: {proc['cpu']}%-Memory: {proc['mem']}%",
             )
-            console.print(f"    Command: {proc['command']}")
+            console.print(f" Command: {proc['command']}")
     else:
-        console.print("\n[yellow]WebSocket Servers: None running[/yellow]")
+        console.print("\n[yellow]WebSocket Servers: None running[/ yellow]")
 
     if not mcp_processes and not websocket_processes:
-        console.print("\n[dim]No crackerjack servers currently running[/dim]")
+        console.print("\n[dim]No crackerjack servers currently running[/ dim]")

crackerjack/services/smart_scheduling.py

@@ -1,9 +1,3 @@
-"""Smart scheduling service for automated initialization.
-
-This module handles intelligent scheduling of crackerjack initialization based on
-various triggers like time, commits, or activity. Split from tool_version_service.py.
-"""
-
 import os
 import subprocess
 from datetime import datetime, timedelta
@@ -13,8 +7,6 @@ from rich.console import Console
 
 
 class SmartSchedulingService:
-    """Service for intelligent scheduling of crackerjack operations."""
-
     def __init__(self, console: Console, project_path: Path) -> None:
         self.console = console
         self.project_path = project_path
@@ -22,7 +14,6 @@ class SmartSchedulingService:
         self.cache_dir.mkdir(parents=True, exist_ok=True)
 
     def should_scheduled_init(self) -> bool:
-        """Check if initialization should run based on configured schedule."""
         init_schedule = os.environ.get("CRACKERJACK_INIT_SCHEDULE", "weekly")
 
         if init_schedule == "disabled":
@@ -38,56 +29,51 @@ class SmartSchedulingService:
         return self._check_weekly_schedule()
 
     def record_init_timestamp(self) -> None:
-        """Record the current timestamp as the last initialization time."""
         timestamp_file = self.cache_dir / f"{self.project_path.name}.init_timestamp"
         try:
             timestamp_file.write_text(datetime.now().isoformat())
         except OSError as e:
             self.console.print(
-                f"[yellow]⚠️ Could not record init timestamp: {e}[/yellow]",
+                f"[yellow]⚠️ Could not record init timestamp: {e}[/ yellow]",
             )
 
     def _check_weekly_schedule(self) -> bool:
-        """Check if weekly initialization is due."""
         init_day = os.environ.get("CRACKERJACK_INIT_DAY", "monday")
-        today = datetime.now().strftime("%A").lower()
+        today = datetime.now().strftime("% A").lower()
 
         if today == init_day.lower():
             last_init = self._get_last_init_timestamp()
             if datetime.now() - last_init > timedelta(days=6):
                 self.console.print(
-                    f"[blue]📅 Weekly initialization scheduled for {init_day}[/blue]",
+                    f"[blue]📅 Weekly initialization scheduled for {init_day}[/ blue]",
                 )
                 return True
 
         return False
 
     def _check_commit_based_schedule(self) -> bool:
-        """Check if initialization is due based on commit count."""
         commits_since_init = self._count_commits_since_init()
         threshold = int(os.environ.get("CRACKERJACK_INIT_COMMITS", "50"))
 
         if commits_since_init >= threshold:
             self.console.print(
                 f"[blue]📊 {commits_since_init} commits since last init "
-                f"(threshold: {threshold})[/blue]",
+                f"(threshold: {threshold})[/ blue]",
             )
             return True
 
         return False
 
     def _check_activity_based_schedule(self) -> bool:
-        """Check if initialization is due based on recent activity."""
         if self._has_recent_activity() and self._days_since_init() >= 7:
             self.console.print(
-                "[blue]⚡ Recent activity detected, initialization recommended[/blue]",
+                "[blue]⚡ Recent activity detected, initialization recommended[/ blue]",
             )
             return True
 
         return False
 
     def _get_last_init_timestamp(self) -> datetime:
-        """Get the timestamp of the last initialization."""
         timestamp_file = self.cache_dir / f"{self.project_path.name}.init_timestamp"
 
         if timestamp_file.exists():
@@ -100,12 +86,11 @@ class SmartSchedulingService:
         return datetime.now() - timedelta(days=30)
 
     def _count_commits_since_init(self) -> int:
-        """Count git commits since last initialization."""
-        since_date = self._get_last_init_timestamp().strftime("%Y-%m-%d")
+        since_date = self._get_last_init_timestamp().strftime("% Y - % m - % d")
 
         try:
             result = subprocess.run(
-                ["git", "log", f"--since={since_date}", "--oneline"],
+                ["git", "log", f"--since ={since_date}", "--oneline"],
                 cwd=self.project_path,
                 capture_output=True,
                 text=True,
@@ -122,10 +107,9 @@ class SmartSchedulingService:
         return 0
 
     def _has_recent_activity(self) -> bool:
-        """Check if there has been recent git activity."""
         try:
             result = subprocess.run(
-                ["git", "log", "-1", "--since=24.hours", "--oneline"],
+                ["git", "log", "- 1", "--since=24.hours", "--oneline"],
                 cwd=self.project_path,
                 capture_output=True,
                 text=True,
@@ -139,6 +123,5 @@ class SmartSchedulingService:
             return False
 
     def _days_since_init(self) -> int:
-        """Calculate days since last initialization."""
         last_init = self._get_last_init_timestamp()
         return (datetime.now() - last_init).days