crackerjack 0.30.3__py3-none-any.whl → 0.31.7__py3-none-any.whl

crackerjack/services/security.py

@@ -0,0 +1,163 @@
+import os
+import re
+import tempfile
+from contextlib import suppress
+from pathlib import Path
+
+from crackerjack.errors import FileError, SecurityError
+
+
+class SecurityService:
+    TOKEN_PATTERNS = [
+        (r"pypi-[a-zA-Z0-9_-]{12,}", "pypi-****"),
+        (r"ghp_[a-zA-Z0-9]{20,}", "ghp_****"),
+        (r"[a-zA-Z0-9_-]{20,}", "****"),
+        (r"(token[=:]\s*)['\"][^'\"]+['\"]", r"\1'****'"),
+        (r"(password[=:]\s*)['\"][^'\"]+['\"]", r"\1'****'"),
+    ]
+
+    SENSITIVE_ENV_VARS = {
+        "UV_PUBLISH_TOKEN",
+        "PYPI_TOKEN",
+        "GITHUB_TOKEN",
+        "AUTH_TOKEN",
+        "API_KEY",
+        "SECRET_KEY",
+        "PASSWORD",
+    }
+
+    def mask_tokens(self, text: str) -> str:
+        if not text:
+            return text
+        masked_text = text
+        for pattern, replacement in self.TOKEN_PATTERNS:
+            masked_text = re.sub(pattern, replacement, masked_text, flags=re.IGNORECASE)
+        for env_var in self.SENSITIVE_ENV_VARS:
+            value = os.getenv(env_var)
+            if value and len(value) > 8:
+                masked_value = (
+                    f"{value[:4]}...{value[-4:]}" if len(value) > 12 else "****"
+                )
+                masked_text = masked_text.replace(value, masked_value)
+
+        return masked_text
+
+    def mask_command_output(self, stdout: str, stderr: str) -> tuple[str, str]:
+        return self.mask_tokens(stdout), self.mask_tokens(stderr)
+
+    def create_secure_token_file(
+        self,
+        token: str,
+        prefix: str = "crackerjack_token",
+    ) -> Path:
+        if not token:
+            raise SecurityError(
+                message="Invalid token provided",
+                details="Token must be a non-empty string",
+                recovery="Provide a valid authentication token",
+            )
+        if len(token) < 8:
+            raise SecurityError(
+                message="Token appears too short to be valid",
+                details=f"Token length: {len(token)} characters",
+                recovery="Ensure you're using a full authentication token",
+            )
+        try:
+            fd, temp_path = tempfile.mkstemp(
+                prefix=f"{prefix}_",
+                suffix=".token",
+                text=True,
+            )
+            temp_file = Path(temp_path)
+            try:
+                temp_file.chmod(0o600)
+            except OSError as e:
+                with suppress(OSError):
+                    temp_file.unlink()
+                raise FileError(
+                    message="Failed to set secure file permissions",
+                    details=str(e),
+                    recovery="Check file system permissions and try again",
+                ) from e
+            try:
+                with os.fdopen(fd, "w") as f:
+                    f.write(token)
+            except OSError as e:
+                with suppress(OSError):
+                    temp_file.unlink()
+                raise FileError(
+                    message="Failed to write token to secure file",
+                    details=str(e),
+                    recovery="Check disk space and file system integrity",
+                ) from e
+
+            return temp_file
+        except OSError as e:
+            raise FileError(
+                message="Failed to create secure token file",
+                details=str(e),
+                recovery="Check temporary directory permissions and disk space",
+            ) from e
+
+    def cleanup_token_file(self, token_file: Path) -> None:
+        if not token_file or not token_file.exists():
+            return
+        with suppress(OSError):
+            if token_file.is_file():
+                with token_file.open("w") as f:
+                    f.write("0" * max(1024, token_file.stat().st_size))
+                    f.flush()
+                    os.fsync(f.fileno())
+            token_file.unlink()
+
+    def get_masked_env_summary(self) -> dict[str, str]:
+        env_summary = {}
+        for key, value in os.environ.items():
+            if any(sensitive in key.upper() for sensitive in self.SENSITIVE_ENV_VARS):
+                if value:
+                    env_summary[key] = (
+                        "****" if len(value) <= 8 else f"{value[:2]}...{value[-2:]}"
+                    )
+                else:
+                    env_summary[key] = "(empty)"
+            elif key.startswith(("PATH", "HOME", "USER", "SHELL", "TERM")):
+                env_summary[key] = value
+
+        return env_summary
+
+    def validate_token_format(self, token: str, token_type: str | None = None) -> bool:
+        if not token:
+            return False
+        if len(token) < 8:
+            return False
+        if token_type and token_type.lower() == "pypi":
+            return token.startswith("pypi-") and len(token) >= 16
+        if token_type and token_type.lower() == "github":
+            return token.startswith("ghp_") and len(token) == 40
+        return len(token) >= 16 and not token.isspace()
+
+    def create_secure_command_env(
+        self,
+        base_env: dict[str, str] | None = None,
+        additional_vars: dict[str, str] | None = None,
+    ) -> dict[str, str]:
+        if base_env is None:
+            base_env = os.environ.copy()
+
+        secure_env = base_env.copy()
+
+        if additional_vars:
+            secure_env.update(additional_vars)
+
+        dangerous_vars = [
+            "LD_PRELOAD",
+            "LD_LIBRARY_PATH",
+            "DYLD_INSERT_LIBRARIES",
+            "DYLD_LIBRARY_PATH",
+            "PYTHONPATH",
+        ]
+
+        for var in dangerous_vars:
+            secure_env.pop(var, None)
+
+        return secure_env

crackerjack/services/server_manager.py

@@ -0,0 +1,234 @@
+import os
+import signal
+import subprocess
+import sys
+import time
+import typing as t
+from pathlib import Path
+
+from rich.console import Console
+
+
+def find_mcp_server_processes() -> list[dict[str, t.Any]]:
+    """Find all running MCP server processes for this project."""
+    try:
+        result = subprocess.run(
+            ["ps", "aux"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        processes: list[dict[str, t.Any]] = []
+        str(Path.cwd())
+
+        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
+
+        return processes
+
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return []
+
+
+def find_websocket_server_processes() -> list[dict[str, t.Any]]:
+    """Find all running WebSocket server processes for this project."""
+    try:
+        result = subprocess.run(
+            ["ps", "aux"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+        processes: list[dict[str, t.Any]] = []
+
+        for line in result.stdout.splitlines():
+            if "crackerjack" in line and "--start-websocket-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
+
+        return processes
+
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return []
+
+
+def stop_process(pid: int, force: bool = False) -> bool:
+    """Stop a process by PID."""
+    try:
+        if force:
+            os.kill(pid, signal.SIGKILL)
+        else:
+            os.kill(pid, signal.SIGTERM)
+
+        for _ in range(10):
+            try:
+                os.kill(pid, 0)
+                time.sleep(0.5)
+            except OSError:
+                return True
+
+        if not force:
+            os.kill(pid, signal.SIGKILL)
+            time.sleep(1)
+
+        return True
+
+    except (OSError, ProcessLookupError):
+        return True
+
+
+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]")
+        return True
+
+    success = True
+    for proc in processes:
+        console.print(f"🛑 Stopping MCP server process {proc['pid']}")
+        if stop_process(proc["pid"]):
+            console.print(f"✅ Stopped process {proc['pid']}")
+        else:
+            console.print(f"❌ Failed to stop process {proc['pid']}")
+            success = False
+
+    return success
+
+
+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]")
+        return True
+
+    success = True
+    for proc in processes:
+        console.print(f"🛑 Stopping WebSocket server process {proc['pid']}")
+        if stop_process(proc["pid"]):
+            console.print(f"✅ Stopped process {proc['pid']}")
+        else:
+            console.print(f"❌ Failed to stop process {proc['pid']}")
+            success = False
+
+    return success
+
+
+def stop_all_servers(console: Console | None = None) -> bool:
+    """Stop all crackerjack server processes."""
+    if console is None:
+        console = Console()
+
+    mcp_success = stop_mcp_server(console)
+    websocket_success = stop_websocket_server(console)
+
+    return mcp_success and websocket_success
+
+
+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]")
+
+    stop_mcp_server(console)
+
+    console.print("⏳ Waiting for cleanup...")
+    time.sleep(2)
+
+    console.print("🚀 Starting new MCP server...")
+    try:
+        cmd = [sys.executable, "-m", "crackerjack", "--start-mcp-server"]
+        if websocket_port:
+            cmd.extend(["--websocket-port", str(websocket_port)])
+
+        subprocess.Popen(
+            cmd,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+
+        console.print("✅ MCP server restart initiated")
+        return True
+
+    except Exception as e:
+        console.print(f"❌ Failed to restart MCP server: {e}")
+        return False
+
+
+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]")
+
+    mcp_processes = find_mcp_server_processes()
+    websocket_processes = find_websocket_server_processes()
+
+    if mcp_processes:
+        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']}%",
+            )
+            console.print(f"    Command: {proc['command']}")
+    else:
+        console.print("\n[yellow]MCP Servers: None running[/yellow]")
+
+    if websocket_processes:
+        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']}%",
+            )
+            console.print(f"    Command: {proc['command']}")
+    else:
+        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]")

crackerjack/services/smart_scheduling.py

@@ -0,0 +1,144 @@
+"""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
+from pathlib import Path
+
+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
+        self.cache_dir = Path.home() / ".cache" / "crackerjack"
+        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":
+            return False
+
+        if init_schedule == "weekly":
+            return self._check_weekly_schedule()
+        if init_schedule == "commit-based":
+            return self._check_commit_based_schedule()
+        if init_schedule == "activity-based":
+            return self._check_activity_based_schedule()
+
+        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]",
+            )
+
+    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()
+
+        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]",
+                )
+                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]",
+            )
+            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]",
+            )
+            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():
+            from contextlib import suppress
+
+            with suppress(OSError, ValueError):
+                timestamp_str = timestamp_file.read_text().strip()
+                return datetime.fromisoformat(timestamp_str)
+
+        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")
+
+        try:
+            result = subprocess.run(
+                ["git", "log", f"--since={since_date}", "--oneline"],
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=10,
+                check=False,
+            )
+
+            if result.returncode == 0:
+                return len([line for line in result.stdout.strip().split("\n") if line])
+
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            pass
+
+        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"],
+                cwd=self.project_path,
+                capture_output=True,
+                text=True,
+                timeout=10,
+                check=False,
+            )
+
+            return result.returncode == 0 and bool(result.stdout.strip())
+
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            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

crackerjack/services/tool_version_service.py

@@ -0,0 +1,61 @@
+"""Tool version service - unified facade for version and configuration management.
+
+This module provides a unified interface to various tool and configuration services.
+The implementation has been split into focused modules following single responsibility principle.
+
+REFACTORING NOTE: This file was reduced from 1353 lines to ~50 lines by splitting into:
+- version_checker.py: Core version checking and comparison
+- config_integrity.py: Configuration file integrity checking
+- smart_scheduling.py: Intelligent scheduling for automated initialization
+- (Additional services extracted into separate files)
+"""
+
+from pathlib import Path
+
+from rich.console import Console
+
+from .config_integrity import ConfigIntegrityService
+from .smart_scheduling import SmartSchedulingService
+from .version_checker import VersionChecker, VersionInfo
+
+# Re-export for backward compatibility
+__all__ = [
+    "VersionInfo",
+    "ToolVersionService",
+    "ConfigIntegrityService",
+    "SmartSchedulingService",
+]
+
+
+class ToolVersionService:
+    """Facade for tool version management services."""
+
+    def __init__(self, console: Console, project_path: Path | None = None) -> None:
+        self.console = console
+        self.project_path = project_path or Path.cwd()
+
+        # Initialize component services
+        self._version_checker = VersionChecker(console)
+        self._config_integrity = ConfigIntegrityService(console, self.project_path)
+        self._scheduling = SmartSchedulingService(console, self.project_path)
+
+    async def check_tool_updates(self) -> dict[str, VersionInfo]:
+        """Check for tool updates using the version checker service."""
+        return await self._version_checker.check_tool_updates()
+
+    def check_config_integrity(self) -> bool:
+        """Check configuration integrity using the config integrity service."""
+        return self._config_integrity.check_config_integrity()
+
+    def should_scheduled_init(self) -> bool:
+        """Check if scheduled initialization should run."""
+        return self._scheduling.should_scheduled_init()
+
+    def record_init_timestamp(self) -> None:
+        """Record initialization timestamp."""
+        self._scheduling.record_init_timestamp()
+
+
+# For backward compatibility, maintain the other services here if needed
+# They are primarily accessed through the facade now
+ToolManager = ToolVersionService  # Alias for compatibility