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

claude_mpm/cli/commands/run_config_checker.py

@@ -0,0 +1,160 @@
+"""Configuration checking functionality for run commands.
+
+This module provides configuration health checking and memory validation.
+Extracted from run.py to reduce complexity and improve maintainability.
+"""
+
+import os
+from pathlib import Path
+
+from ...core.config import Config
+
+
+class RunConfigChecker:
+    """Handles configuration checking for run commands."""
+
+    def __init__(self, logger):
+        """Initialize the config checker."""
+        self.logger = logger
+
+    def check_claude_json_memory(self, args):
+        """Check .claude.json file size and warn about memory issues.
+
+        WHY: Large .claude.json files (>500KB) cause significant memory issues when
+        using --resume. Claude Desktop loads the entire conversation history into
+        memory, leading to 2GB+ memory consumption.
+        """
+        try:
+            # Only check if --resume is being used
+            if not getattr(args, "resume", False):
+                return
+
+            claude_json_path = Path.cwd() / ".claude.json"
+            if not claude_json_path.exists():
+                self.logger.debug("No .claude.json file found")
+                return
+
+            file_size = claude_json_path.stat().st_size
+
+            def format_size(size_bytes):
+                """Format file size in human readable format."""
+                if size_bytes < 1024:
+                    return f"{size_bytes} B"
+                elif size_bytes < 1024 * 1024:
+                    return f"{size_bytes / 1024:.1f} KB"
+                else:
+                    return f"{size_bytes / (1024 * 1024):.1f} MB"
+
+            # Warn if file is larger than 500KB
+            if file_size > 500 * 1024:  # 500KB threshold
+                print(
+                    f"\n⚠️  WARNING: Large .claude.json file detected ({format_size(file_size)})"
+                )
+                print("   This may cause memory issues when using --resume")
+                print(
+                    "   💡 Consider running 'claude-mpm cleanup-memory' to archive old conversations\n"
+                )
+                # Just warn, don't block execution
+
+            self.logger.info(f".claude.json size: {format_size(file_size)}")
+
+        except Exception as e:
+            self.logger.warning(f"Failed to check .claude.json size: {e}")
+            # Just warn, don't block execution
+
+    def check_configuration_health(self):
+        """Check configuration health at startup and warn about issues.
+
+        WHY: Configuration errors can cause silent failures, especially for response
+        logging. This function proactively checks configuration at startup and warns
+        users about any issues, providing actionable guidance.
+
+        DESIGN DECISIONS:
+        - Non-blocking: Issues are logged as warnings, not errors
+        - Actionable: Provides specific commands to fix issues
+        - Focused: Only checks critical configuration that affects runtime
+        """
+        try:
+            config = Config()
+
+            # Check response logging configuration
+            response_logging = config.get("response_logging", {})
+            if response_logging.get("enabled", False):
+                log_dir = response_logging.get("directory")
+                if log_dir:
+                    log_path = Path(log_dir)
+                    if not log_path.exists():
+                        self.logger.warning(
+                            f"Response logging directory does not exist: {log_path}"
+                        )
+                        print(f"⚠️  Response logging directory missing: {log_path}")
+                        print(f"   Run: mkdir -p {log_path}")
+                    elif not log_path.is_dir():
+                        self.logger.warning(
+                            f"Response logging path is not a directory: {log_path}"
+                        )
+                        print(
+                            f"⚠️  Response logging path is not a directory: {log_path}"
+                        )
+                    elif not os.access(log_path, os.W_OK):
+                        self.logger.warning(
+                            f"Response logging directory is not writable: {log_path}"
+                        )
+                        print(
+                            f"⚠️  Response logging directory is not writable: {log_path}"
+                        )
+                        print(f"   Run: chmod 755 {log_path}")
+
+            # Check agent deployment configuration
+            agent_deployment = config.get("agent_deployment", {})
+            excluded_agents = agent_deployment.get("excluded_agents", [])
+            if excluded_agents:
+                self.logger.info(f"Agent exclusions configured: {excluded_agents}")
+
+            # Check memory management configuration
+            memory_config = config.get("memory_management", {})
+            if memory_config.get("auto_cleanup", False):
+                cleanup_threshold = memory_config.get("cleanup_threshold_mb", 100)
+                if cleanup_threshold < 50:
+                    self.logger.warning(
+                        f"Memory cleanup threshold very low: {cleanup_threshold}MB"
+                    )
+                    print(
+                        f"⚠️  Memory cleanup threshold is very low: {cleanup_threshold}MB"
+                    )
+                    print(f"   Consider increasing to at least 50MB")
+
+            # Check for common configuration issues
+            self._check_common_config_issues(config)
+
+        except Exception as e:
+            self.logger.warning(f"Configuration health check failed: {e}")
+            # Don't block execution for config check failures
+
+    def _check_common_config_issues(self, config):
+        """Check for common configuration issues."""
+        try:
+            import os
+
+            # Check if config file exists and is readable
+            config_file = config.config_file
+            if config_file and Path(config_file).exists():
+                if not os.access(config_file, os.R_OK):
+                    self.logger.warning(
+                        f"Configuration file is not readable: {config_file}"
+                    )
+                    print(f"⚠️  Configuration file is not readable: {config_file}")
+                    print(f"   Run: chmod 644 {config_file}")
+
+            # Check for deprecated configuration keys
+            deprecated_keys = ["legacy_mode", "old_agent_format", "deprecated_logging"]
+
+            for key in deprecated_keys:
+                if config.get(key) is not None:
+                    self.logger.warning(f"Deprecated configuration key found: {key}")
+                    print(f"⚠️  Deprecated configuration key: {key}")
+                    print(f"   Consider removing this key from your configuration")
+
+        except Exception as e:
+            self.logger.debug(f"Common config issues check failed: {e}")
+            # Don't propagate errors from this check

claude_mpm/cli/commands/socketio_monitor.py

@@ -0,0 +1,235 @@
+"""Socket.IO monitoring functionality for run commands.
+
+This module provides Socket.IO server management and monitoring dashboard functionality.
+Extracted from run.py to reduce complexity and improve maintainability.
+"""
+
+import os
+import subprocess
+import sys
+import time
+import webbrowser
+from pathlib import Path
+
+from ...core.unified_paths import get_package_root
+from ...services.port_manager import PortManager
+
+
+class SocketIOMonitor:
+    """Handles Socket.IO monitoring and server management."""
+
+    def __init__(self, logger):
+        """Initialize the Socket.IO monitor."""
+        self.logger = logger
+
+    def launch_monitor(self, port):
+        """
+        Launch the Socket.IO monitoring dashboard using static HTML file.
+
+        Returns:
+            tuple: (success: bool, browser_opened: bool)
+        """
+        try:
+            # Verify Socket.IO dependencies are available
+            try:
+                import aiohttp
+                import engineio
+                import socketio
+
+                self.logger.debug("Socket.IO dependencies verified")
+            except ImportError as e:
+                self.logger.error(f"Socket.IO dependencies not available: {e}")
+                print(f"❌ Socket.IO dependencies missing: {e}")
+                print("  This is unexpected - dependency installation may have failed.")
+                return False, False
+
+            print(f"🚀 Setting up Socket.IO monitor...")
+            self.logger.info(f"Launching Socket.IO monitor (requested port: {port})")
+
+            # First, check if there's already a running SocketIO server
+            port_manager = PortManager()
+            port_manager.cleanup_dead_instances()
+            active_instances = port_manager.list_active_instances()
+
+            if active_instances:
+                # Use the first active instance (prefer port 8765 if available)
+                socketio_port = None
+                for instance in active_instances:
+                    if instance.get("port") == 8765:
+                        socketio_port = 8765
+                        break
+                if not socketio_port:
+                    socketio_port = active_instances[0].get("port")
+
+                print(f"🔍 Found existing SocketIO server on port {socketio_port}")
+                server_running = True
+            else:
+                # No existing server, use requested port
+                socketio_port = port
+                server_running = self.check_server_running(socketio_port)
+
+            # Use HTTP URL to access dashboard from Socket.IO server
+            dashboard_url = f"http://localhost:{socketio_port}"
+
+            if server_running:
+                print(f"✅ Socket.IO server already running on port {socketio_port}")
+                print(f"📊 Dashboard: {dashboard_url}")
+
+                # Open browser with static HTML file
+                try:
+                    # Check if we should suppress browser opening (for tests)
+                    if os.environ.get("CLAUDE_MPM_NO_BROWSER") != "1":
+                        print(f"🌐 Opening dashboard in browser...")
+                        self.open_in_browser_tab(dashboard_url)
+                        self.logger.info(f"Socket.IO dashboard opened: {dashboard_url}")
+                    else:
+                        print(f"🌐 Browser opening suppressed (CLAUDE_MPM_NO_BROWSER=1)")
+                        self.logger.info(
+                            f"Browser opening suppressed by environment variable"
+                        )
+                    return True, True
+                except Exception as e:
+                    self.logger.warning(f"Failed to open browser: {e}")
+                    print(f"⚠️  Could not open browser automatically")
+                    print(f"📊 Please open manually: {dashboard_url}")
+                    return True, False
+            else:
+                # Start standalone Socket.IO server
+                print(f"🔧 Starting Socket.IO server...")
+                server_started = self.start_standalone_server(socketio_port)
+
+                if server_started:
+                    print(f"✅ Socket.IO server started successfully")
+                    print(f"📊 Dashboard: {dashboard_url}")
+
+                    # Open browser
+                    try:
+                        if os.environ.get("CLAUDE_MPM_NO_BROWSER") != "1":
+                            print(f"🌐 Opening dashboard in browser...")
+                            self.open_in_browser_tab(dashboard_url)
+                            self.logger.info(
+                                f"Socket.IO dashboard opened: {dashboard_url}"
+                            )
+                        else:
+                            print(
+                                f"🌐 Browser opening suppressed (CLAUDE_MPM_NO_BROWSER=1)"
+                            )
+                        return True, True
+                    except Exception as e:
+                        self.logger.warning(f"Failed to open browser: {e}")
+                        print(f"⚠️  Could not open browser automatically")
+                        print(f"📊 Please open manually: {dashboard_url}")
+                        return True, False
+                else:
+                    print(f"❌ Failed to start Socket.IO server")
+                    print(f"💡 Troubleshooting tips:")
+                    print(f"   - Check if port {socketio_port} is already in use")
+                    print(
+                        f"   - Verify Socket.IO dependencies: pip install python-socketio aiohttp"
+                    )
+                    print(f"   - Try a different port with --websocket-port")
+                    return False, False
+
+        except Exception as e:
+            self.logger.error(f"Failed to launch Socket.IO monitor: {e}")
+            print(f"❌ Failed to launch Socket.IO monitor: {e}")
+            return False, False
+
+    def check_server_running(self, port):
+        """Check if a Socket.IO server is running on the specified port."""
+        try:
+            import socket
+            import urllib.error
+            import urllib.request
+
+            # First, do a basic TCP connection check
+            try:
+                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                    s.settimeout(2.0)
+                    result = s.connect_ex(("127.0.0.1", port))
+                    if result != 0:
+                        self.logger.debug(f"TCP connection to port {port} failed")
+                        return False
+            except Exception as e:
+                self.logger.debug(f"TCP socket check failed for port {port}: {e}")
+                return False
+
+            # If TCP connection succeeds, try HTTP health check
+            try:
+                response = urllib.request.urlopen(
+                    f"http://localhost:{port}/status", timeout=5
+                )
+                if response.getcode() == 200:
+                    self.logger.debug(
+                        f"✅ Socket.IO server health check passed on port {port}"
+                    )
+                    return True
+            except Exception as e:
+                self.logger.debug(f"HTTP health check failed for port {port}: {e}")
+
+        except Exception as e:
+            self.logger.debug(
+                f"❌ Unexpected error checking Socket.IO server on port {port}: {e}"
+            )
+
+        return False
+
+    def start_standalone_server(self, port):
+        """Start a standalone Socket.IO server using the Python daemon."""
+        try:
+            daemon_script = get_package_root() / "scripts" / "socketio_daemon.py"
+            if not daemon_script.exists():
+                self.logger.error(f"Daemon script not found: {daemon_script}")
+                return False
+
+            # Start the daemon
+            result = subprocess.run(
+                [sys.executable, str(daemon_script), "start", "--port", str(port)],
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+
+            if result.returncode == 0:
+                self.logger.info(
+                    f"Socket.IO daemon started successfully on port {port}"
+                )
+                return True
+            else:
+                self.logger.error(f"Failed to start Socket.IO daemon: {result.stderr}")
+                return False
+
+        except Exception as e:
+            self.logger.error(f"Failed to start standalone Socket.IO server: {e}")
+            return False
+
+    def open_in_browser_tab(self, url):
+        """Open URL in browser, attempting to reuse existing tabs when possible."""
+        try:
+            # Try different methods based on platform
+            import platform
+
+            system = platform.system().lower()
+
+            if system == "darwin":  # macOS
+                try:
+                    # Try to open in existing tab
+                    subprocess.run(["open", "-g", url], check=True, timeout=5)
+                    return
+                except Exception:
+                    pass
+            elif system == "linux":
+                try:
+                    # Try xdg-open
+                    subprocess.run(["xdg-open", url], check=True, timeout=5)
+                    return
+                except Exception:
+                    pass
+
+            # Fallback to standard webbrowser
+            webbrowser.open(url)
+
+        except Exception as e:
+            self.logger.warning(f"Browser opening failed: {e}")
+            # Final fallback
+            webbrowser.open(url)