claude-mpm 3.4.0__py3-none-any.whl → 3.4.2__py3-none-any.whl

claude_mpm/cli/commands/memory.py

@@ -10,6 +10,7 @@ with other command modules like agents.py.
 """
 
 import json
+import os
 from datetime import datetime
 from pathlib import Path
 
@@ -38,7 +39,11 @@ def manage_memory(args):
     try:
         # Load configuration for memory manager
         config = Config()
-        memory_manager = AgentMemoryManager(config)
+        # Use CLAUDE_MPM_USER_PWD if available (when called via shell script),
+        # otherwise use current working directory
+        user_pwd = os.environ.get('CLAUDE_MPM_USER_PWD', os.getcwd())
+        current_dir = Path(user_pwd)
+        memory_manager = AgentMemoryManager(config, current_dir)
         
         if not args.memory_command:
             # No subcommand - show status

claude_mpm/core/config.py

@@ -166,9 +166,38 @@ class Config:
             # Health monitoring
             "enable_health_monitoring": True,
             "health_check_interval": 30,
+            "health_history_size": 100,
+            "health_aggregation_window": 300,
             # Metrics
             "enable_metrics": True,
             "metrics_interval": 60,
+            # Advanced health monitoring thresholds
+            "health_thresholds": {
+                "cpu_percent": 80.0,
+                "memory_mb": 500,
+                "file_descriptors": 1000,
+                "max_clients": 1000,
+                "max_error_rate": 0.1,
+                "network_timeout": 2.0
+            },
+            # Automatic recovery configuration
+            "recovery": {
+                "enabled": True,
+                "check_interval": 60,
+                "max_recovery_attempts": 5,
+                "recovery_timeout": 30,
+                "circuit_breaker": {
+                    "failure_threshold": 5,
+                    "timeout_seconds": 300,
+                    "success_threshold": 3
+                },
+                "strategy": {
+                    "warning_threshold": 2,
+                    "critical_threshold": 1,
+                    "failure_window_seconds": 300,
+                    "min_recovery_interval": 60
+                }
+            },
             # Service management
             "graceful_shutdown_timeout": 30,
             "startup_timeout": 60,
@@ -247,6 +276,47 @@ class Config:
                         "auto_learning": True       # Enable auto learning
                     }
                 }
+            },
+            # Socket.IO server health and recovery configuration
+            "socketio_server": {
+                "host": "localhost",
+                "port": 8765,
+                "enable_health_monitoring": True,
+                "enable_recovery": True,
+                "health_monitoring": {
+                    "check_interval": 30,
+                    "history_size": 100,
+                    "aggregation_window": 300,
+                    "thresholds": {
+                        "cpu_percent": 80.0,
+                        "memory_mb": 500,
+                        "file_descriptors": 1000,
+                        "max_clients": 1000,
+                        "max_error_rate": 0.1
+                    }
+                },
+                "recovery": {
+                    "enabled": True,
+                    "max_attempts": 5,
+                    "timeout": 30,
+                    "circuit_breaker": {
+                        "failure_threshold": 5,
+                        "timeout_seconds": 300,
+                        "success_threshold": 3
+                    },
+                    "strategy": {
+                        "warning_threshold": 2,
+                        "critical_threshold": 1,
+                        "failure_window_seconds": 300,
+                        "min_recovery_interval": 60
+                    },
+                    "actions": {
+                        "log_warning": True,
+                        "clear_connections": True,
+                        "restart_service": True,
+                        "emergency_stop": True
+                    }
+                }
             }
         }
 
@@ -254,6 +324,9 @@ class Config:
         for key, default_value in defaults.items():
             if key not in self._config:
                 self._config[key] = default_value
+        
+        # Validate health and recovery configuration
+        self._validate_health_recovery_config()
 
     def get(self, key: str, default: Any = None) -> Any:
         """Get configuration value."""
@@ -349,6 +422,93 @@ class Config:
         """Check if configuration contains a key."""
         return self.get(key) is not None
 
+    def _validate_health_recovery_config(self) -> None:
+        """Validate health monitoring and recovery configuration."""
+        try:
+            # Validate health thresholds
+            thresholds = self.get('health_thresholds', {})
+            if thresholds.get('cpu_percent', 0) < 0 or thresholds.get('cpu_percent', 0) > 100:
+                logger.warning("CPU threshold should be between 0-100, using default 80")
+                self.set('health_thresholds.cpu_percent', 80.0)
+            
+            if thresholds.get('memory_mb', 0) <= 0:
+                logger.warning("Memory threshold should be positive, using default 500MB")
+                self.set('health_thresholds.memory_mb', 500)
+            
+            if thresholds.get('max_error_rate', 0) < 0 or thresholds.get('max_error_rate', 0) > 1:
+                logger.warning("Error rate threshold should be between 0-1, using default 0.1")
+                self.set('health_thresholds.max_error_rate', 0.1)
+            
+            # Validate recovery configuration
+            recovery_config = self.get('recovery', {})
+            if recovery_config.get('max_recovery_attempts', 0) <= 0:
+                logger.warning("Max recovery attempts should be positive, using default 5")
+                self.set('recovery.max_recovery_attempts', 5)
+            
+            # Validate circuit breaker configuration
+            cb_config = recovery_config.get('circuit_breaker', {})
+            if cb_config.get('failure_threshold', 0) <= 0:
+                logger.warning("Circuit breaker failure threshold should be positive, using default 5")
+                self.set('recovery.circuit_breaker.failure_threshold', 5)
+            
+            if cb_config.get('timeout_seconds', 0) <= 0:
+                logger.warning("Circuit breaker timeout should be positive, using default 300")
+                self.set('recovery.circuit_breaker.timeout_seconds', 300)
+            
+        except Exception as e:
+            logger.error(f"Error validating health/recovery configuration: {e}")
+    
+    def get_health_monitoring_config(self) -> Dict[str, Any]:
+        """Get health monitoring configuration with defaults."""
+        base_config = {
+            'enabled': self.get('enable_health_monitoring', True),
+            'check_interval': self.get('health_check_interval', 30),
+            'history_size': self.get('health_history_size', 100),
+            'aggregation_window': self.get('health_aggregation_window', 300),
+            'thresholds': self.get('health_thresholds', {
+                'cpu_percent': 80.0,
+                'memory_mb': 500,
+                'file_descriptors': 1000,
+                'max_clients': 1000,
+                'max_error_rate': 0.1,
+                'network_timeout': 2.0
+            })
+        }
+        
+        # Merge with socketio-specific config if available
+        socketio_config = self.get('socketio_server.health_monitoring', {})
+        if socketio_config:
+            base_config.update(socketio_config)
+        
+        return base_config
+    
+    def get_recovery_config(self) -> Dict[str, Any]:
+        """Get recovery configuration with defaults."""
+        base_config = self.get('recovery', {
+            'enabled': True,
+            'check_interval': 60,
+            'max_recovery_attempts': 5,
+            'recovery_timeout': 30,
+            'circuit_breaker': {
+                'failure_threshold': 5,
+                'timeout_seconds': 300,
+                'success_threshold': 3
+            },
+            'strategy': {
+                'warning_threshold': 2,
+                'critical_threshold': 1,
+                'failure_window_seconds': 300,
+                'min_recovery_interval': 60
+            }
+        })
+        
+        # Merge with socketio-specific config if available
+        socketio_config = self.get('socketio_server.recovery', {})
+        if socketio_config:
+            base_config = self._config_mgr.merge_configs(base_config, socketio_config)
+        
+        return base_config
+
     def __repr__(self) -> str:
         """String representation of configuration."""
         return f"<Config({len(self._config)} keys)>"

claude_mpm/hooks/claude_hooks/hook_wrapper.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # Claude Code hook wrapper for claude-mpm
 
 # Debug log (optional - comment out in production)

claude_mpm/scripts/socketio_daemon.py

@@ -43,11 +43,26 @@ def is_running():
         return False
 
 def start_server():
-    """Start the Socket.IO server as a daemon."""
+    """Start the Socket.IO server as a daemon with conflict detection."""
     if is_running():
-        print("Socket.IO server is already running.")
+        print("Socket.IO daemon server is already running.")
+        print(f"Use '{__file__} status' for details")
         return
     
+    # Check for HTTP-managed server conflict
+    try:
+        import requests
+        response = requests.get("http://localhost:8765/health", timeout=1.0)
+        if response.status_code == 200:
+            data = response.json()
+            if 'server_id' in data:
+                print(f"⚠️  HTTP-managed server already running: {data.get('server_id')}")
+                print(f"   Stop it first: socketio_server_manager.py stop --port 8765")
+                print(f"   Or diagnose: socketio_server_manager.py diagnose")
+                return
+    except:
+        pass  # No HTTP server, continue
+    
     ensure_dirs()
     
     # Fork to create daemon
@@ -96,9 +111,10 @@ def start_server():
         signal_handler(signal.SIGINT, None)
 
 def stop_server():
-    """Stop the Socket.IO server."""
+    """Stop the Socket.IO daemon server."""
     if not is_running():
-        print("Socket.IO server is not running.")
+        print("Socket.IO daemon server is not running.")
+        print(f"Check for other servers: socketio_server_manager.py status")
         return
     
     try:
@@ -125,11 +141,12 @@ def stop_server():
         print(f"Error stopping server: {e}")
 
 def status_server():
-    """Check server status."""
+    """Check server status with manager integration info."""
     if is_running():
         with open(PID_FILE) as f:
             pid = int(f.read().strip())
-        print(f"Socket.IO server is running (PID: {pid})")
+        print(f"Socket.IO daemon server is running (PID: {pid})")
+        print(f"PID file: {PID_FILE}")
         
         # Check if port is listening
         try:
@@ -138,13 +155,36 @@ def status_server():
             result = sock.connect_ex(('localhost', 8765))
             sock.close()
             if result == 0:
-                print("Server is listening on port 8765")
+                print("✅ Server is listening on port 8765")
+                print("🔧 Management style: daemon")
             else:
-                print("WARNING: Server process exists but port 8765 is not accessible")
+                print("⚠️ WARNING: Server process exists but port 8765 is not accessible")
+        except:
+            pass
+            
+        # Show management commands
+        print("\n🔧 Management Commands:")
+        print(f"   • Stop: {__file__} stop")
+        print(f"   • Restart: {__file__} restart")
+        
+        # Check for manager conflicts
+        try:
+            import requests
+            response = requests.get("http://localhost:8765/health", timeout=1.0)
+            if response.status_code == 200:
+                data = response.json()
+                if 'server_id' in data and data.get('server_id') != 'daemon-socketio':
+                    print(f"\n⚠️  POTENTIAL CONFLICT: HTTP-managed server also detected")
+                    print(f"   Server ID: {data.get('server_id')}")
+                    print(f"   Use 'socketio_server_manager.py diagnose' to resolve")
         except:
             pass
+            
     else:
-        print("Socket.IO server is not running")
+        print("Socket.IO daemon server is not running")
+        print(f"\n🔧 Start Commands:")
+        print(f"   • Daemon: {__file__} start")
+        print(f"   • HTTP-managed: socketio_server_manager.py start")
 
 def main():
     """Main entry point."""