crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/services/regex_utils.py

@@ -126,6 +126,59 @@ def find_safe_pattern_for_text(text: str) -> list[str]:
     return matches
 
 
+def _determine_suggested_name(original_pattern: str) -> str:
+    """Determine a suggested name for the pattern based on its content.
+
+    Args:
+        original_pattern: The regex pattern to analyze
+
+    Returns:
+        Suggested pattern name
+    """
+    if "python.*-.*m" in original_pattern:
+        return "fix_python_command_spacing"
+    if r"\-\s*\-" in original_pattern:
+        return "fix_double_dash_spacing"
+    if "token" in original_pattern.lower():
+        return "fix_token_pattern"
+    if "password" in original_pattern.lower():
+        return "fix_password_pattern"
+
+    keyword_pattern = CompiledPatternCache.get_compiled_pattern(r"[a-zA-Z]+")
+    keywords = keyword_pattern.findall(original_pattern)
+    if keywords:
+        return f"fix_{'_'.join(keywords[:3])}_pattern".lower()
+
+    return "fix_custom_pattern"
+
+
+def _build_test_cases(original_pattern: str, sample_text: str) -> list[tuple[str, str]]:
+    """Build test cases based on pattern and sample text.
+
+    Args:
+        original_pattern: The regex pattern
+        sample_text: Optional sample text to include
+
+    Returns:
+        List of (input, expected_output) test case tuples
+    """
+    test_cases = []
+
+    if sample_text:
+        test_cases.append((sample_text, "Expected output needed"))
+
+    if "-" in original_pattern:
+        test_cases.extend(
+            [
+                ("word - word", "word-word"),
+                ("already-good", "already-good"),
+                ("multiple - word - spacing", "multiple-word - spacing"),
+            ]
+        )
+
+    return test_cases
+
+
 def suggest_migration_for_re_sub(
     original_pattern: str, original_replacement: str, sample_text: str = ""
 ) -> dict[str, t.Any]:
@@ -157,35 +210,8 @@ def suggest_migration_for_re_sub(
         if matches:
             suggestion["needs_new_pattern"] = False
 
-    if "python.*-.*m" in original_pattern:
-        suggestion["suggested_name"] = "fix_python_command_spacing"
-    elif r"\-\s*\-" in original_pattern:
-        suggestion["suggested_name"] = "fix_double_dash_spacing"
-    elif "token" in original_pattern.lower():
-        suggestion["suggested_name"] = "fix_token_pattern"
-    elif "password" in original_pattern.lower():
-        suggestion["suggested_name"] = "fix_password_pattern"
-    else:
-        keyword_pattern = CompiledPatternCache.get_compiled_pattern(r"[a-zA-Z]+")
-        keywords = keyword_pattern.findall(original_pattern)
-        if keywords:
-            suggestion["suggested_name"] = (
-                f"fix_{'_'.join(keywords[:3])}_pattern".lower()
-            )
-        else:
-            suggestion["suggested_name"] = "fix_custom_pattern"
-
-    if sample_text:
-        suggestion["test_cases_needed"].append((sample_text, "Expected output needed"))
-
-    if "-" in original_pattern:
-        suggestion["test_cases_needed"].extend(
-            [
-                ("word - word", "word-word"),
-                ("already-good", "already-good"),
-                ("multiple - word - spacing", "multiple-word - spacing"),
-            ]
-        )
+    suggestion["suggested_name"] = _determine_suggested_name(original_pattern)
+    suggestion["test_cases_needed"] = _build_test_cases(original_pattern, sample_text)
 
     return suggestion
 

crackerjack/services/secure_status_formatter.py

@@ -1,8 +1,13 @@
 import tempfile
+import time
 import typing as t
+from contextlib import suppress
 from enum import Enum
 from pathlib import Path
 
+from crackerjack.models.protocols import SecureStatusFormatterProtocol, ServiceProtocol
+
+from .regex_patterns import SAFE_PATTERNS, CompiledPatternCache, sanitize_internal_urls
 from .security_logger import get_security_logger
 
 
@@ -13,7 +18,7 @@ class StatusVerbosity(str, Enum):
     FULL = "full"
 
 
-class SecureStatusFormatter:
+class SecureStatusFormatter(SecureStatusFormatterProtocol, ServiceProtocol):
     SENSITIVE_PATTERNS = {
         "absolute_paths": [
             r"(/[^/\s]*){2, }",
@@ -64,6 +69,42 @@ class SecureStatusFormatter:
         self.project_root = project_root or Path.cwd()
         self.security_logger = get_security_logger()
 
+    def initialize(self) -> None:
+        pass
+
+    def cleanup(self) -> None:
+        pass
+
+    def health_check(self) -> bool:
+        return True
+
+    def shutdown(self) -> None:
+        pass
+
+    def metrics(self) -> dict[str, t.Any]:
+        return {}
+
+    def is_healthy(self) -> bool:
+        return True
+
+    def register_resource(self, resource: t.Any) -> None:
+        pass
+
+    def cleanup_resource(self, resource: t.Any) -> None:
+        pass
+
+    def record_error(self, error: Exception) -> None:
+        pass
+
+    def increment_requests(self) -> None:
+        pass
+
+    def get_custom_metric(self, name: str) -> t.Any:
+        return None
+
+    def set_custom_metric(self, name: str, value: t.Any) -> None:
+        pass
+
     def format_status(
         self,
         status_data: dict[str, t.Any],
@@ -181,8 +222,6 @@ class SecureStatusFormatter:
         return text
 
     def _sanitize_paths(self, text: str) -> str:
-        from .regex_patterns import SAFE_PATTERNS
-
         unix_path_pattern = SAFE_PATTERNS.get("detect_absolute_unix_paths")
 
         if not unix_path_pattern:
@@ -202,10 +241,6 @@ class SecureStatusFormatter:
         return text
 
     def _process_path_pattern(self, text: str, pattern_str: str) -> str:
-        from contextlib import suppress
-
-        from .regex_patterns import CompiledPatternCache
-
         with suppress(Exception):
             compiled = CompiledPatternCache.get_compiled_pattern(pattern_str)
             matches = compiled.findall(text)
@@ -236,8 +271,6 @@ class SecureStatusFormatter:
             return text.replace(match, "[REDACTED_PATH]")
 
     def _sanitize_internal_urls(self, text: str) -> str:
-        from .regex_patterns import sanitize_internal_urls
-
         return sanitize_internal_urls(text)
 
     def _mask_potential_secrets(self, text: str) -> str:
@@ -254,8 +287,6 @@ class SecureStatusFormatter:
         return "[INTERNAL_URL]" in text or "[REDACTED_PATH]" in text
 
     def _get_validated_secret_patterns(self) -> list[t.Any]:
-        from .regex_patterns import SAFE_PATTERNS
-
         patterns = []
         long_alphanumeric = SAFE_PATTERNS.get("detect_long_alphanumeric_tokens")
         base64_like = SAFE_PATTERNS.get("detect_base64_like_strings")
@@ -278,8 +309,6 @@ class SecureStatusFormatter:
     def _apply_fallback_secret_patterns(self, text: str) -> str:
         for pattern_str in self.SENSITIVE_PATTERNS["secrets"]:
             try:
-                from .regex_patterns import CompiledPatternCache
-
                 compiled = CompiledPatternCache.get_compiled_pattern(pattern_str)
                 text = self._mask_pattern_matches(text, compiled.findall(text))
             except Exception:
@@ -317,8 +346,6 @@ class SecureStatusFormatter:
         return obj
 
     def _get_timestamp(self) -> float:
-        import time
-
         return time.time()
 
     def format_error_response(

crackerjack/services/secure_subprocess.py

@@ -445,9 +445,42 @@ class SecureSubprocessExecutor:
         try:
             resolved_path = cwd_path.resolve()
 
+            # Get the original path's components to check for path traversal patterns
+            original_path_obj = Path(cwd)
+            original_parts = original_path_obj.parts
+            if ".." in original_parts or any(
+                part.startswith("../") for part in original_parts
+            ):
+                # Check if the resolved path is within the safe base (project directory or temp)
+                safe_root = (
+                    Path.cwd().parent.resolve()
+                )  # Use parent of project root as broader safe root
+                try:
+                    resolved_path.relative_to(safe_root)
+                except ValueError:
+                    # If relative_to raises ValueError, path is outside safe root
+                    path_str = str(resolved_path)
+                    self.security_logger.log_path_traversal_attempt(
+                        attempted_path=path_str,
+                        base_directory=str(safe_root),
+                    )
+                    raise CommandValidationError(
+                        f"Dangerous working directory: {path_str}"
+                    )
+
             path_str = str(resolved_path)
-            if ".." in path_str or path_str.startswith(
-                ("/etc", "/usr/bin", "/bin", "/sbin")
+            # Check for system directories, including macOS /private variants
+            if path_str.startswith(
+                (
+                    "/etc",
+                    "/usr/bin",
+                    "/bin",
+                    "/sbin",
+                    "/private/etc",
+                    "/private/usr/bin",
+                    "/private/bin",
+                    "/private/sbin",
+                )
             ):
                 self.security_logger.log_path_traversal_attempt(
                     attempted_path=path_str,

crackerjack/services/security.py

@@ -5,14 +5,15 @@ from contextlib import suppress
 from pathlib import Path
 
 from crackerjack.errors import FileError, SecurityError
+from crackerjack.models.protocols import SecurityServiceProtocol
 from crackerjack.services.regex_patterns import SAFE_PATTERNS
 
 
-class SecurityService:
+class SecurityService(SecurityServiceProtocol):
     TOKEN_PATTERN_NAMES = [
         "mask_pypi_token",
         "mask_github_token",
-        "mask_generic_long_token",
+        "mask_generic_long_token",  # Changed from "mask_github_long_token" to correct name
         "mask_token_assignment",
         "mask_password_assignment",
     ]
@@ -188,21 +189,28 @@ class SecurityService:
         secrets = []
 
         patterns = {
-            "api_key": r'api[_-]?key["\s]*[: =]["\s]*([a-zA-Z0-9_-]{20, })',
-            "password": r'password["\s]*[: =]["\s]*([^\s"]{8, })',
-            "token": r'token["\s]*[: =]["\s]*([a-zA-Z0-9_-]{20, })',
+            "api_key": r"(?i)(?:api[_-]?key)[\s]*[=:][\s]*[\"']([A-Za-z0-9_-]{20,})[\"']",
+            "password": r"(?i)(?:password)[\s]*[=:][\s]*[\"']([^\"'\s]{8,})[\"']",
+            "token": r"(?i)(?:token)[\s]*[=:][\s]*[\"']([A-Za-z0-9_-]{20,})[\"']",
         }
 
         import re
 
         for secret_type, pattern in patterns.items():
-            matches = re.finditer(pattern, content, re.IGNORECASE)
+            matches = re.finditer(pattern, content)
             for match in matches:
+                # Extract the captured group (the secret value)
+                secret_value = match.group(1)
+
+                # Calculate line number where the match occurs
+                line_start_pos = match.start()
+                line_num = content[:line_start_pos].count("\n") + 1
+
                 secrets.append(
                     {
                         "type": secret_type,
-                        "value": match.group(1)[:10] + "...",
-                        "line": content[: match.start()].count("\n") + 1,
+                        "value": secret_value[:10] + "...",
+                        "line": line_num,
                     }
                 )
         return secrets

crackerjack/services/server_manager.py

@@ -5,9 +5,10 @@ import time
 import typing as t
 from pathlib import Path
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
+from mcp_common.ui import ServerPanels
 
-from ..ui.server_panels import create_server_panels
 from .secure_subprocess import execute_secure_subprocess
 from .security_logger import get_security_logger
 
@@ -198,18 +199,17 @@ def stop_process(pid: int, force: bool = False) -> bool:
         return True
 
 
-def stop_mcp_server(console: Console | None = None) -> bool:
-    if console is None:
-        console = Console()
-
-    panels = create_server_panels(console)
+@depends.inject
+def stop_mcp_server(console: Inject[Console]) -> bool:
     processes = find_mcp_server_processes()
 
     if not processes:
         console.print("[yellow]⚠️ No MCP server processes found[/ yellow]")
         return True
 
-    panels.stop_servers(len(processes))
+    ServerPanels.info(
+        title="MCP Server", message=f"Stopping {len(processes)} process(es)"
+    )
 
     success = True
     for proc in processes:
@@ -221,15 +221,16 @@ def stop_mcp_server(console: Console | None = None) -> bool:
             success = False
 
     if success:
-        panels.stop_complete(len(processes))
+        ServerPanels.info(
+            title="MCP Server",
+            message=f"Successfully stopped {len(processes)} process(es)",
+        )
 
     return success
 
 
-def stop_websocket_server(console: Console | None = None) -> bool:
-    if console is None:
-        console = Console()
-
+@depends.inject
+def stop_websocket_server(console: Inject[Console]) -> bool:
     processes = find_websocket_server_processes()
 
     if not processes:
@@ -248,11 +249,9 @@ def stop_websocket_server(console: Console | None = None) -> bool:
     return success
 
 
-def stop_zuban_lsp(console: Console | None = None) -> bool:
+@depends.inject
+def stop_zuban_lsp(console: Inject[Console]) -> bool:
     """Stop running zuban LSP server processes."""
-    if console is None:
-        console = Console()
-
     processes = find_zuban_lsp_processes()
 
     if not processes:
@@ -271,33 +270,30 @@ def stop_zuban_lsp(console: Console | None = None) -> bool:
     return success
 
 
-def stop_all_servers(console: Console | None = None) -> bool:
-    if console is None:
-        console = Console()
-
-    mcp_success = stop_mcp_server(console)
-    websocket_success = stop_websocket_server(console)
-    zuban_lsp_success = stop_zuban_lsp(console)
+@depends.inject
+def stop_all_servers(console: Inject[Console]) -> bool:
+    mcp_success = stop_mcp_server()
+    websocket_success = stop_websocket_server()
+    zuban_lsp_success = stop_zuban_lsp()
 
     return mcp_success and websocket_success and zuban_lsp_success
 
 
+@depends.inject
 def restart_mcp_server(
     websocket_port: int | None = None,
-    console: Console | None = None,
+    console: Inject[Console] = None,
 ) -> bool:
-    if console is None:
-        console = Console()
-
-    panels = create_server_panels(console)
-    panels.restart_header()
+    ServerPanels.info(
+        title="MCP Server", message="Restarting Crackerjack MCP Server..."
+    )
 
-    stop_mcp_server(console)
+    stop_mcp_server()
 
-    panels.cleanup_wait()
+    ServerPanels.simple_message("⏳ Waiting for cleanup...", style="dim")
     time.sleep(2)
 
-    panels.starting_server()
+    ServerPanels.simple_message("🚀 Starting new server instance...", style="green")
     try:
         cmd = [sys.executable, "-m", "crackerjack", "--start-mcp-server"]
         if websocket_port:
@@ -323,35 +319,30 @@ def restart_mcp_server(
 
         # Display success panel with server details
         http_endpoint = "http://127.0.0.1:8676/mcp"
-        websocket_monitor = (
-            f"ws://127.0.0.1:{websocket_port or 8675}" if websocket_port else None
-        )
 
-        panels.success_panel(
-            http_endpoint=http_endpoint,
-            websocket_monitor=websocket_monitor,
+        ServerPanels.startup_success(
+            server_name="Crackerjack MCP",
+            endpoint=http_endpoint,
             process_id=process.pid,
         )
         return True
 
     except Exception as e:
-        panels.failure_panel(str(e))
+        ServerPanels.error(title="MCP Restart Error", message=str(e))
         return False
 
 
-def restart_zuban_lsp(console: Console | None = None) -> bool:
+@depends.inject
+def restart_zuban_lsp(console: Inject[Console]) -> bool:
     """Restart zuban LSP server."""
-    if console is None:
-        console = Console()
-
     console.print("[bold cyan]🔄 Restarting Zuban LSP server...[/ bold cyan]")
 
-    stop_zuban_lsp(console)
+    stop_zuban_lsp()
 
-    console.print("⏳ Waiting for cleanup...")
+    console.print("⏳ Waiting for cleanup")
     time.sleep(2)
 
-    console.print("🚀 Starting new Zuban LSP server...")
+    console.print("🚀 Starting new Zuban LSP server")
     try:
         cmd = [sys.executable, "-m", "crackerjack", "--start-zuban-lsp"]
 
@@ -378,10 +369,8 @@ def restart_zuban_lsp(console: Console | None = None) -> bool:
         return False
 
 
-def list_server_status(console: Console | None = None) -> None:
-    if console is None:
-        console = Console()
-
+@depends.inject
+def list_server_status(console: Inject[Console]) -> None:
     console.print("[bold cyan]📊 Crackerjack Server Status[/ bold cyan]")
 
     mcp_processes = find_mcp_server_processes()

crackerjack/services/smart_scheduling.py

@@ -1,18 +1,60 @@
 import os
 import subprocess
+import typing as t
+from contextlib import suppress
 from datetime import datetime, timedelta
 from pathlib import Path
 
-from rich.console import Console
+from acb.console import Console
+from acb.depends import Inject, depends
 
+from crackerjack.models.protocols import ServiceProtocol, SmartSchedulingServiceProtocol
 
-class SmartSchedulingService:
-    def __init__(self, console: Console, project_path: Path) -> None:
+
+class SmartSchedulingService(SmartSchedulingServiceProtocol, ServiceProtocol):
+    @depends.inject
+    def __init__(self, console: Inject[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 initialize(self) -> None:
+        pass
+
+    def cleanup(self) -> None:
+        pass
+
+    def health_check(self) -> bool:
+        return True
+
+    def shutdown(self) -> None:
+        pass
+
+    def metrics(self) -> dict[str, t.Any]:
+        return {}
+
+    def is_healthy(self) -> bool:
+        return True
+
+    def register_resource(self, resource: t.Any) -> None:
+        pass
+
+    def cleanup_resource(self, resource: t.Any) -> None:
+        pass
+
+    def record_error(self, error: Exception) -> None:
+        pass
+
+    def increment_requests(self) -> None:
+        pass
+
+    def get_custom_metric(self, name: str) -> t.Any:
+        return None
+
+    def set_custom_metric(self, name: str, value: t.Any) -> None:
+        pass
+
     def should_scheduled_init(self) -> bool:
         init_schedule = os.environ.get("CRACKERJACK_INIT_SCHEDULE", "weekly")
 
@@ -77,8 +119,6 @@ class SmartSchedulingService:
         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)
@@ -109,7 +149,7 @@ class SmartSchedulingService:
     def _has_recent_activity(self) -> bool:
         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,

crackerjack/services/status_authentication.py

@@ -18,9 +18,9 @@ class AccessLevel(str, Enum):
 
 
 class AuthenticationMethod(str, Enum):
-    API_KEY = "api_key"
-    JWT_TOKEN = "jwt_token"
-    HMAC_SIGNATURE = "hmac_signature"
+    API_KEY = "api_key"  # nosec B105
+    JWT_TOKEN = "jwt_token"  # nosec B105
+    HMAC_SIGNATURE = "hmac_signature"  # nosec B105
     LOCAL_ONLY = "local_only"
 
 

crackerjack/services/thread_safe_status_collector.py

@@ -6,6 +6,7 @@ import typing as t
 from contextlib import asynccontextmanager
 from dataclasses import dataclass, field
 
+from ..mcp.context import MCPServerContext
 from .security_logger import SecurityEventLevel, SecurityEventType, get_security_logger