claude-mpm 3.9.9__py3-none-any.whl → 4.0.3__py3-none-any.whl

claude_mpm/utils/session_logging.py

@@ -1,13 +1,14 @@
+from pathlib import Path
+
 """
 Session Logging Utilities
 
 Convenience functions for session-based response logging.
 """
 
-import os
-from typing import Optional, Dict, Any
-from pathlib import Path
 import logging
+import os
+from typing import Any, Dict, Optional
 
 from claude_mpm.services.claude_session_logger import get_session_logger
 
@@ -17,14 +18,18 @@ logger = logging.getLogger(__name__)
 def is_session_logging_enabled() -> bool:
     """
     Check if session logging is enabled.
-    
+
     Returns:
         True if session logging is enabled and configured
     """
     # Check environment variable to disable
-    if os.environ.get('CLAUDE_MPM_NO_SESSION_LOGGING', '').lower() in ('1', 'true', 'yes'):
+    if os.environ.get("CLAUDE_MPM_NO_SESSION_LOGGING", "").lower() in (
+        "1",
+        "true",
+        "yes",
+    ):
         return False
-    
+
     # Check if session logger has a valid session ID
     session_logger = get_session_logger()
     return session_logger.is_enabled()
@@ -34,44 +39,46 @@ def log_agent_response(
     agent_name: str,
     request: str,
     response: str,
-    metadata: Optional[Dict[str, Any]] = None
+    metadata: Optional[Dict[str, Any]] = None,
 ) -> Optional[Path]:
     """
     Log an agent response to the current session.
-    
+
     Args:
         agent_name: Name of the agent
         request: The request/prompt sent to the agent
         response: The agent's response
         metadata: Optional additional metadata
-        
+
     Returns:
         Path to the logged file, or None if logging is disabled
     """
     if not is_session_logging_enabled():
         return None
-    
+
     # Create request summary
-    request_summary = f"[{agent_name}] {request[:100]}..." if len(request) > 100 else f"[{agent_name}] {request}"
-    
+    request_summary = (
+        f"[{agent_name}] {request[:100]}..."
+        if len(request) > 100
+        else f"[{agent_name}] {request}"
+    )
+
     # Add agent name to metadata
     if metadata is None:
         metadata = {}
-    metadata['agent'] = agent_name
-    
+    metadata["agent"] = agent_name
+
     # Log the response
     session_logger = get_session_logger()
     return session_logger.log_response(
-        request_summary=request_summary,
-        response_content=response,
-        metadata=metadata
+        request_summary=request_summary, response_content=response, metadata=metadata
     )
 
 
 def get_current_session_id() -> Optional[str]:
     """
     Get the current session ID.
-    
+
     Returns:
         Current session ID, or None if not available
     """
@@ -82,7 +89,7 @@ def get_current_session_id() -> Optional[str]:
 def get_session_directory() -> Optional[Path]:
     """
     Get the directory for the current session.
-    
+
     Returns:
         Path to session directory, or None if not available
     """
@@ -93,7 +100,7 @@ def get_session_directory() -> Optional[Path]:
 def set_session_id(session_id: str) -> None:
     """
     Manually set the session ID.
-    
+
     Args:
         session_id: The session ID to use
     """
@@ -105,10 +112,10 @@ def set_session_id(session_id: str) -> None:
 # Environment variable helpers
 def enable_session_logging() -> None:
     """Enable session logging by removing disable flag."""
-    if 'CLAUDE_MPM_NO_SESSION_LOGGING' in os.environ:
-        del os.environ['CLAUDE_MPM_NO_SESSION_LOGGING']
+    if "CLAUDE_MPM_NO_SESSION_LOGGING" in os.environ:
+        del os.environ["CLAUDE_MPM_NO_SESSION_LOGGING"]
 
 
 def disable_session_logging() -> None:
     """Disable session logging via environment variable."""
-    os.environ['CLAUDE_MPM_NO_SESSION_LOGGING'] = '1'
+    os.environ["CLAUDE_MPM_NO_SESSION_LOGGING"] = "1"

claude_mpm/utils/subprocess_utils.py

@@ -7,20 +7,28 @@ with proper error handling, timeouts, and process cleanup.
 """
 
 import asyncio
-import os
+import logging
+import shlex
 import signal
 import subprocess
-import sys
 import time
-from typing import Dict, List, Optional, Union, Any
+from typing import Any, Dict, List, Optional, Union
+
 import psutil
 
+logger = logging.getLogger(__name__)
+
 
 class SubprocessError(Exception):
     """Unified exception for subprocess errors."""
-    
-    def __init__(self, message: str, returncode: Optional[int] = None, 
-                 stdout: Optional[str] = None, stderr: Optional[str] = None):
+
+    def __init__(
+        self,
+        message: str,
+        returncode: Optional[int] = None,
+        stdout: Optional[str] = None,
+        stderr: Optional[str] = None,
+    ):
         super().__init__(message)
         self.returncode = returncode
         self.stdout = stdout
@@ -29,18 +37,55 @@ class SubprocessError(Exception):
 
 class SubprocessResult:
     """Result object for subprocess execution."""
-    
+
     def __init__(self, returncode: int, stdout: str = "", stderr: str = ""):
         self.returncode = returncode
         self.stdout = stdout
         self.stderr = stderr
-        
+
     @property
     def success(self) -> bool:
         """True if the subprocess completed successfully."""
         return self.returncode == 0
 
 
+def run_command(command_string: str, timeout: float = 60) -> str:
+    """
+    Runs a command securely, avoiding shell injection.
+
+    Args:
+        command_string: Command string to execute
+        timeout: Maximum time to wait for completion (seconds)
+
+    Returns:
+        Command stdout output
+
+    Raises:
+        SubprocessError: If the command fails or times out
+    """
+    # Split command string into a list to avoid shell=True
+    command_parts = shlex.split(command_string)
+    try:
+        result = subprocess.run(
+            command_parts,
+            capture_output=True,
+            text=True,
+            check=True,  # Raise an exception for non-zero exit codes
+            timeout=timeout,  # Prevent the process from hanging
+        )
+        return result.stdout
+    except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as e:
+        # Log the error, including stderr for better debugging
+        stderr = e.stderr if hasattr(e, "stderr") else "N/A"
+        logger.error(f'Command "{command_string}" failed: {stderr}')
+        raise SubprocessError(
+            f'Command "{command_string}" failed: {stderr}',
+            returncode=getattr(e, "returncode", None),
+            stdout=getattr(e, "stdout", ""),
+            stderr=stderr,
+        )
+
+
 def run_subprocess(
     cmd: List[str],
     timeout: Optional[float] = None,
@@ -48,11 +93,11 @@ def run_subprocess(
     text: bool = True,
     cwd: Optional[str] = None,
     env: Optional[Dict[str, str]] = None,
-    **kwargs
+    **kwargs,
 ) -> SubprocessResult:
     """
     Run a subprocess with enhanced error handling and timeout support.
-    
+
     Args:
         cmd: Command and arguments to execute
         timeout: Maximum time to wait for completion (seconds)
@@ -61,10 +106,10 @@ def run_subprocess(
         cwd: Working directory for the subprocess
         env: Environment variables for the subprocess
         **kwargs: Additional arguments passed to subprocess.run
-        
+
     Returns:
         SubprocessResult object with returncode, stdout, stderr
-        
+
     Raises:
         SubprocessError: If the subprocess fails or times out
     """
@@ -76,28 +121,28 @@ def run_subprocess(
             text=text,
             cwd=cwd,
             env=env,
-            **kwargs
+            **kwargs,
         )
-        
+
         return SubprocessResult(
             returncode=result.returncode,
             stdout=result.stdout if capture_output else "",
-            stderr=result.stderr if capture_output else ""
+            stderr=result.stderr if capture_output else "",
         )
-        
+
     except subprocess.TimeoutExpired as e:
         raise SubprocessError(
             f"Command timed out after {timeout}s: {' '.join(cmd)}",
             returncode=None,
             stdout=e.stdout.decode() if e.stdout else "",
-            stderr=e.stderr.decode() if e.stderr else ""
+            stderr=e.stderr.decode() if e.stderr else "",
         )
     except subprocess.CalledProcessError as e:
         raise SubprocessError(
             f"Command failed with return code {e.returncode}: {' '.join(cmd)}",
             returncode=e.returncode,
             stdout=e.stdout if e.stdout else "",
-            stderr=e.stderr if e.stderr else ""
+            stderr=e.stderr if e.stderr else "",
         )
     except Exception as e:
         raise SubprocessError(f"Subprocess execution failed: {e}")
@@ -109,11 +154,11 @@ async def run_subprocess_async(
     capture_output: bool = True,
     cwd: Optional[str] = None,
     env: Optional[Dict[str, str]] = None,
-    **kwargs
+    **kwargs,
 ) -> SubprocessResult:
     """
     Run a subprocess asynchronously with timeout support.
-    
+
     Args:
         cmd: Command and arguments to execute
         timeout: Maximum time to wait for completion (seconds)
@@ -121,10 +166,10 @@ async def run_subprocess_async(
         cwd: Working directory for the subprocess
         env: Environment variables for the subprocess
         **kwargs: Additional arguments passed to asyncio.create_subprocess_exec
-        
+
     Returns:
         SubprocessResult object with returncode, stdout, stderr
-        
+
     Raises:
         SubprocessError: If the subprocess fails or times out
     """
@@ -135,35 +180,28 @@ async def run_subprocess_async(
         else:
             stdout = None
             stderr = None
-            
+
         process = await asyncio.create_subprocess_exec(
-            *cmd,
-            stdout=stdout,
-            stderr=stderr,
-            cwd=cwd,
-            env=env,
-            **kwargs
+            *cmd, stdout=stdout, stderr=stderr, cwd=cwd, env=env, **kwargs
         )
-        
+
         try:
             stdout_data, stderr_data = await asyncio.wait_for(
-                process.communicate(),
-                timeout=timeout
+                process.communicate(), timeout=timeout
             )
         except asyncio.TimeoutError:
             process.kill()
             await process.wait()
             raise SubprocessError(
-                f"Command timed out after {timeout}s: {' '.join(cmd)}",
-                returncode=None
+                f"Command timed out after {timeout}s: {' '.join(cmd)}", returncode=None
             )
-            
+
         return SubprocessResult(
             returncode=process.returncode,
             stdout=stdout_data.decode() if stdout_data else "",
-            stderr=stderr_data.decode() if stderr_data else ""
+            stderr=stderr_data.decode() if stderr_data else "",
         )
-        
+
     except Exception as e:
         if not isinstance(e, SubprocessError):
             raise SubprocessError(f"Async subprocess execution failed: {e}")
@@ -173,14 +211,14 @@ async def run_subprocess_async(
 def terminate_process_tree(pid: int, timeout: float = 5.0) -> int:
     """
     Terminate a process and all its children.
-    
+
     Args:
         pid: Process ID to terminate
         timeout: Time to wait for graceful termination before force killing
-        
+
     Returns:
         Number of processes terminated
-        
+
     Raises:
         SubprocessError: If the process cannot be terminated
     """
@@ -188,24 +226,24 @@ def terminate_process_tree(pid: int, timeout: float = 5.0) -> int:
         parent = psutil.Process(pid)
     except psutil.NoSuchProcess:
         return 0
-        
+
     # Get all child processes recursively
     children = parent.children(recursive=True)
     processes = [parent] + children
-    
+
     terminated_count = 0
-    
+
     # First, try graceful termination
     for process in processes:
         try:
             process.terminate()
         except psutil.NoSuchProcess:
             pass
-            
+
     # Wait for processes to terminate gracefully
     gone, alive = psutil.wait_procs(processes, timeout=timeout)
     terminated_count += len(gone)
-    
+
     # Force kill any remaining processes
     for process in alive:
         try:
@@ -213,17 +251,17 @@ def terminate_process_tree(pid: int, timeout: float = 5.0) -> int:
             terminated_count += 1
         except psutil.NoSuchProcess:
             pass
-            
+
     return terminated_count
 
 
 def get_process_info(pid: Optional[int] = None) -> Dict[str, Any]:
     """
     Get information about a process.
-    
+
     Args:
         pid: Process ID (defaults to current process)
-        
+
     Returns:
         Dictionary with process information
     """
@@ -237,9 +275,9 @@ def get_process_info(pid: Optional[int] = None) -> Dict[str, Any]:
             "cpu_percent": process.cpu_percent(),
             "memory_info": process.memory_info()._asdict(),
             "cmdline": process.cmdline(),
-            "cwd": process.cwd() if hasattr(process, 'cwd') else None,
+            "cwd": process.cwd() if hasattr(process, "cwd") else None,
             "num_threads": process.num_threads(),
-            "children": [child.pid for child in process.children()]
+            "children": [child.pid for child in process.children()],
         }
     except psutil.NoSuchProcess:
         return {"error": f"Process {pid} not found"}
@@ -250,17 +288,17 @@ def get_process_info(pid: Optional[int] = None) -> Dict[str, Any]:
 def monitor_process_resources(pid: int) -> Optional[Dict[str, Any]]:
     """
     Monitor resource usage of a process.
-    
+
     Args:
         pid: Process ID to monitor
-        
+
     Returns:
         Dictionary with resource information or None if process not found
     """
     try:
         process = psutil.Process(pid)
         memory_info = process.memory_info()
-        
+
         return {
             "pid": pid,
             "cpu_percent": process.cpu_percent(),
@@ -268,7 +306,7 @@ def monitor_process_resources(pid: int) -> Optional[Dict[str, Any]]:
             "memory_percent": process.memory_percent(),
             "num_threads": process.num_threads(),
             "status": process.status(),
-            "create_time": process.create_time()
+            "create_time": process.create_time(),
         }
     except psutil.NoSuchProcess:
         return None
@@ -279,27 +317,27 @@ def monitor_process_resources(pid: int) -> Optional[Dict[str, Any]]:
 def cleanup_orphaned_processes(pattern: str, max_age_hours: float = 1.0) -> int:
     """
     Clean up orphaned processes matching a pattern.
-    
+
     Args:
         pattern: String pattern to match in process command line
         max_age_hours: Maximum age in hours before considering a process orphaned
-        
+
     Returns:
         Number of processes cleaned up
     """
     current_time = time.time()
     cleanup_count = 0
-    
-    for process in psutil.process_iter(['pid', 'name', 'cmdline', 'create_time']):
+
+    for process in psutil.process_iter(["pid", "name", "cmdline", "create_time"]):
         try:
-            cmdline = ' '.join(process.info['cmdline'] or [])
+            cmdline = " ".join(process.info["cmdline"] or [])
             if pattern in cmdline:
                 # Check if process is old enough to be considered orphaned
-                age_hours = (current_time - process.info['create_time']) / 3600
+                age_hours = (current_time - process.info["create_time"]) / 3600
                 if age_hours > max_age_hours:
                     process.terminate()
                     cleanup_count += 1
         except (psutil.NoSuchProcess, psutil.AccessDenied):
             continue
-            
+
     return cleanup_count

claude_mpm/validation/__init__.py

@@ -2,4 +2,4 @@
 
 from .agent_validator import AgentValidator, ValidationResult
 
-__all__ = ['AgentValidator', 'ValidationResult']
+__all__ = ["AgentValidator", "ValidationResult"]