claude-mpm 5.6.10__py3-none-any.whl → 5.6.33__py3-none-any.whl

claude_mpm/core/constants.py

@@ -38,12 +38,36 @@ class SystemLimits:
 
 
 class NetworkConfig:
-    """Network-related configuration constants."""
+    """Network-related configuration constants.
 
-    # Port ranges
-    SOCKETIO_PORT_RANGE: Tuple[int, int] = (8765, 8785)
-    DEFAULT_SOCKETIO_PORT = 8765
-    DEFAULT_DASHBOARD_PORT = 8765
+    NOTE: Port defaults are now centralized in network_config.NetworkPorts.
+    This class maintains backward compatibility but delegates to NetworkPorts.
+    """
+
+    # Import from network_config for single source of truth
+    # Lazy import to avoid circular dependencies
+    @property
+    def SOCKETIO_PORT_RANGE(self) -> Tuple[int, int]:
+        from .network_config import NetworkPorts
+
+        return (NetworkPorts.PORT_RANGE_START, NetworkPorts.PORT_RANGE_END)
+
+    @property
+    def DEFAULT_SOCKETIO_PORT(self) -> int:
+        from .network_config import NetworkPorts
+
+        return NetworkPorts.SOCKETIO_DEFAULT
+
+    @property
+    def DEFAULT_DASHBOARD_PORT(self) -> int:
+        from .network_config import NetworkPorts
+
+        return NetworkPorts.DASHBOARD_DEFAULT
+
+    # Port ranges (module-level for backward compatibility)
+    SOCKETIO_PORT_RANGE: Tuple[int, int] = (8765, 8785)  # Will be updated at runtime
+    DEFAULT_SOCKETIO_PORT = 8768  # Updated to match new default
+    DEFAULT_DASHBOARD_PORT = 8767  # Updated to match new default
 
     # Connection timeouts (seconds)
     CONNECTION_TIMEOUT = 5.0
@@ -303,18 +327,38 @@ DEFAULT_TIMEOUT = TimeoutConfig.DEFAULT_TIMEOUT
 
 
 class NetworkPorts:
-    """Network port configuration."""
+    """Network port configuration.
+
+    DEPRECATED: Use claude_mpm.core.network_config.NetworkPorts instead.
+    This class is maintained for backward compatibility.
+    """
+
+    # Import from network_config for single source of truth
+    @classmethod
+    def _get_config(cls):
+        from .network_config import NetworkPorts as NewNetworkPorts
+
+        return NewNetworkPorts
+
+    # Delegate to new NetworkPorts
+    @property
+    def DEFAULT_SOCKETIO(self) -> int:
+        return self._get_config().SOCKETIO_DEFAULT
+
+    @property
+    def DEFAULT_DASHBOARD(self) -> int:
+        return self._get_config().DASHBOARD_DEFAULT
 
-    # Use existing values from NetworkConfig
-    DEFAULT_SOCKETIO = NetworkConfig.DEFAULT_SOCKETIO_PORT
-    DEFAULT_DASHBOARD = NetworkConfig.DEFAULT_DASHBOARD_PORT
-    PORT_RANGE_START = NetworkConfig.SOCKETIO_PORT_RANGE[0]
-    PORT_RANGE_END = NetworkConfig.SOCKETIO_PORT_RANGE[1]
+    # Keep class-level attributes for compatibility
+    DEFAULT_SOCKETIO = 8768  # Updated to match network_config
+    DEFAULT_DASHBOARD = 8767  # Updated to match network_config
+    PORT_RANGE_START = 8765
+    PORT_RANGE_END = 8785
 
     @classmethod
     def get_port_range(cls) -> range:
         """Get the valid port range."""
-        return range(cls.PORT_RANGE_START, cls.PORT_RANGE_END + 1)
+        return cls._get_config().get_port_range()
 
 
 class ProjectPaths:

claude_mpm/core/interactive_session.py

@@ -143,11 +143,12 @@ class InteractiveSession:
             Tuple of (success, environment_dict)
         """
         try:
-            # Deploy system agents
-            if not self.runner.setup_agents():
-                print("Continuing without native agents...")
+            # NOTE: System agents are deployed via reconciliation during startup.
+            # The reconciliation process respects user configuration and handles
+            # both native and custom mode deployment. No need to call setup_agents() here.
 
-            # Deploy project-specific agents
+            # Deploy project-specific agents from .claude-mpm/agents/
+            # This is separate from system agents and handles user-defined agents
             self.runner.deploy_project_agents_to_claude()
 
             # Build command

claude_mpm/core/logging_utils.py

@@ -121,8 +121,10 @@ class LoggerFactory:
             root_logger.setLevel(desired_level)
         # else: root logger is suppressed (CRITICAL+1), keep it suppressed
 
-        # Remove existing handlers
-        root_logger.handlers = []
+        # Preserve FileHandlers (e.g., hooks logging), only remove StreamHandlers
+        root_logger.handlers = [
+            h for h in root_logger.handlers if isinstance(h, logging.FileHandler)
+        ]
 
         # CRITICAL FIX: Don't add handlers if logging is suppressed
         # If root logger is at CRITICAL+1 (startup suppression), don't add any handlers

claude_mpm/core/network_config.py

@@ -0,0 +1,148 @@
+"""Centralized network port configuration for Claude MPM.
+
+This module provides the single source of truth for all network port defaults
+and environment variable names used throughout the MPM system.
+
+WHY: Previously, port defaults were hardcoded in multiple locations (config.py,
+constants.py, commander/config.py, CLI parsers), leading to inconsistencies and
+difficulty maintaining different defaults per service.
+
+USAGE:
+    from claude_mpm.core.network_config import NetworkPorts
+
+    # Get default ports
+    monitor_port = NetworkPorts.MONITOR_DEFAULT
+    commander_port = NetworkPorts.COMMANDER_DEFAULT
+
+    # Get from environment with fallback
+    port = NetworkPorts.get_monitor_port()
+"""
+
+import os
+from typing import Optional
+
+
+class NetworkPorts:
+    """Network port configuration with different defaults for each service.
+
+    Service Default Ports:
+    - Monitor: 8765 (user's preferred default)
+    - Commander: 8766
+    - Dashboard: 8767
+    - SocketIO: 8768
+
+    Port Range: 8765-8785 (21 ports available)
+
+    Environment Variables:
+    - CLAUDE_MPM_MONITOR_PORT: Override monitor port
+    - CLAUDE_MPM_COMMANDER_PORT: Override commander port
+    - CLAUDE_MPM_DASHBOARD_PORT: Override dashboard port
+    - CLAUDE_MPM_SOCKETIO_PORT: Override socketio port
+    - CLAUDE_MPM_DEFAULT_HOST: Override default host (default: 127.0.0.1)
+    """
+
+    # Default ports for each service
+    MONITOR_DEFAULT = 8765
+    COMMANDER_DEFAULT = 8766
+    DASHBOARD_DEFAULT = 8767
+    SOCKETIO_DEFAULT = 8768
+
+    # Port range configuration
+    PORT_RANGE_START = 8765
+    PORT_RANGE_END = 8785
+
+    # Default host
+    DEFAULT_HOST = "127.0.0.1"
+
+    # Environment variable names
+    ENV_MONITOR_PORT = "CLAUDE_MPM_MONITOR_PORT"
+    ENV_COMMANDER_PORT = "CLAUDE_MPM_COMMANDER_PORT"
+    ENV_DASHBOARD_PORT = "CLAUDE_MPM_DASHBOARD_PORT"
+    ENV_SOCKETIO_PORT = "CLAUDE_MPM_SOCKETIO_PORT"
+    ENV_DEFAULT_HOST = "CLAUDE_MPM_DEFAULT_HOST"
+
+    @classmethod
+    def get_monitor_port(cls, default: Optional[int] = None) -> int:
+        """Get monitor port from environment or default.
+
+        Args:
+            default: Optional override default (if not provided, uses MONITOR_DEFAULT)
+
+        Returns:
+            Port number from environment or default
+        """
+        if default is None:
+            default = cls.MONITOR_DEFAULT
+        return int(os.getenv(cls.ENV_MONITOR_PORT, default))
+
+    @classmethod
+    def get_commander_port(cls, default: Optional[int] = None) -> int:
+        """Get commander port from environment or default.
+
+        Args:
+            default: Optional override default (if not provided, uses COMMANDER_DEFAULT)
+
+        Returns:
+            Port number from environment or default
+        """
+        if default is None:
+            default = cls.COMMANDER_DEFAULT
+        return int(os.getenv(cls.ENV_COMMANDER_PORT, default))
+
+    @classmethod
+    def get_dashboard_port(cls, default: Optional[int] = None) -> int:
+        """Get dashboard port from environment or default.
+
+        Args:
+            default: Optional override default (if not provided, uses DASHBOARD_DEFAULT)
+
+        Returns:
+            Port number from environment or default
+        """
+        if default is None:
+            default = cls.DASHBOARD_DEFAULT
+        return int(os.getenv(cls.ENV_DASHBOARD_PORT, default))
+
+    @classmethod
+    def get_socketio_port(cls, default: Optional[int] = None) -> int:
+        """Get socketio port from environment or default.
+
+        Args:
+            default: Optional override default (if not provided, uses SOCKETIO_DEFAULT)
+
+        Returns:
+            Port number from environment or default
+        """
+        if default is None:
+            default = cls.SOCKETIO_DEFAULT
+        return int(os.getenv(cls.ENV_SOCKETIO_PORT, default))
+
+    @classmethod
+    def get_default_host(cls) -> str:
+        """Get default host from environment or default.
+
+        Returns:
+            Host address from environment or DEFAULT_HOST
+        """
+        return os.getenv(cls.ENV_DEFAULT_HOST, cls.DEFAULT_HOST)
+
+    @classmethod
+    def get_port_range(cls) -> range:
+        """Get the valid port range.
+
+        Returns:
+            Range object from PORT_RANGE_START to PORT_RANGE_END (inclusive)
+        """
+        return range(cls.PORT_RANGE_START, cls.PORT_RANGE_END + 1)
+
+    @classmethod
+    def is_port_in_range(cls, port: int) -> bool:
+        """Check if port is within valid range.
+
+        Args:
+            port: Port number to check
+
+        Returns:
+            True if port is in valid range, False otherwise
+        """
+        return cls.PORT_RANGE_START <= port <= cls.PORT_RANGE_END

claude_mpm/core/oneshot_session.py

@@ -11,7 +11,7 @@ defines the interface it needs.
 
 import contextlib
 import os
-import subprocess
+import subprocess  # nosec B404
 import tempfile
 import time
 import uuid
@@ -86,11 +86,12 @@ class OneshotSession:
         Returns:
             True if successful, False otherwise
         """
-        # Deploy system agents
-        if not self.runner.setup_agents():
-            print("Continuing without native agents...")
+        # NOTE: System agents are deployed via reconciliation during startup.
+        # The reconciliation process respects user configuration and handles
+        # both native and custom mode deployment. No need to call setup_agents() here.
 
-        # Deploy project-specific agents
+        # Deploy project-specific agents from .claude-mpm/agents/
+        # This is separate from system agents and handles user-defined agents
         self.runner.deploy_project_agents_to_claude()
 
         return True
@@ -225,7 +226,7 @@ class OneshotSession:
             if len(cmd) > 5:
                 self.logger.debug(f"Command has {len(cmd)} arguments total")
 
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603
                 cmd, capture_output=True, text=True, env=env, check=False
             )
 

claude_mpm/core/output_style_manager.py

@@ -297,6 +297,9 @@ class OutputStyleManager:
             target_path = style_config["target"]
             style_name = style_config["name"]
 
+            # Check if this is a fresh install (file doesn't exist yet)
+            is_fresh_install = not target_path.exists()
+
             # If content not provided, read from source
             if content is None:
                 content = self.extract_output_style_content(style=style)
@@ -310,7 +313,9 @@ class OutputStyleManager:
 
             # Activate the style if requested
             if activate:
-                self._activate_output_style(style_name)
+                self._activate_output_style(
+                    style_name, is_fresh_install=is_fresh_install
+                )
 
             return True
 
@@ -318,12 +323,21 @@ class OutputStyleManager:
             self.logger.error(f"Failed to deploy {style} style: {e}")
             return False
 
-    def _activate_output_style(self, style_name: str = "Claude MPM") -> bool:
+    def _activate_output_style(
+        self, style_name: str = "Claude MPM", is_fresh_install: bool = False
+    ) -> bool:
         """
         Update Claude Code settings to activate a specific output style.
 
+        Only activates the style if:
+        1. No active style is currently set (first deployment), OR
+        2. This is a fresh install (style file didn't exist before deployment)
+
+        This preserves user preferences if they've manually changed their active style.
+
         Args:
             style_name: Name of the style to activate (e.g., "Claude MPM", "Claude MPM Teacher")
+            is_fresh_install: Whether this is a fresh install (style file didn't exist before)
 
         Returns:
             True if activated successfully, False otherwise
@@ -342,8 +356,15 @@ class OutputStyleManager:
             # Check current active style
             current_style = settings.get("activeOutputStyle")
 
-            # Update active output style if different
-            if current_style != style_name:
+            # Only set activeOutputStyle if:
+            # 1. No active style is set (first deployment), OR
+            # 2. Current style is "default" (not a real user preference), OR
+            # 3. This is a fresh install (file didn't exist before deployment)
+            should_activate = (
+                current_style is None or current_style == "default" or is_fresh_install
+            )
+
+            if should_activate and current_style != style_name:
                 settings["activeOutputStyle"] = style_name
 
                 # Ensure settings directory exists
@@ -358,7 +379,10 @@ class OutputStyleManager:
                     f"✅ Activated {style_name} output style (was: {current_style or 'none'})"
                 )
             else:
-                self.logger.debug(f"{style_name} output style already active")
+                self.logger.debug(
+                    f"Preserving user preference: {current_style or 'none'} "
+                    f"(skipping activation of {style_name})"
+                )
 
             return True
 
@@ -452,6 +476,10 @@ class OutputStyleManager:
         """
         results: Dict[str, bool] = {}
 
+        # Check if professional style exists BEFORE deployment
+        # This determines if this is a fresh install
+        professional_style_existed = self.styles["professional"]["target"].exists()
+
         for style_type_key in self.styles:
             # Deploy without activation
             # Cast is safe because we know self.styles keys are OutputStyleType
@@ -459,9 +487,11 @@ class OutputStyleManager:
             success = self.deploy_output_style(style=style_type, activate=False)
             results[style_type] = success
 
-        # Activate the default style if requested
+        # Activate the default style if requested AND this is first deployment
         if activate_default and results.get("professional", False):
-            self._activate_output_style("Claude MPM")
+            self._activate_output_style(
+                "Claude MPM", is_fresh_install=not professional_style_existed
+            )
 
         return results
 

claude_mpm/core/socketio_pool.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 """Socket.IO connection pool for efficient client connection management.
 
 This module provides a connection pool to reuse Socket.IO client connections,
@@ -31,12 +30,21 @@ except ImportError:
 # Import constants for configuration
 try:
     from claude_mpm.core.constants import NetworkConfig
+    from claude_mpm.core.network_config import NetworkPorts
 except ImportError:
     # Fallback if constants module not available
+    class NetworkPorts:
+        MONITOR_DEFAULT = 8765
+        COMMANDER_DEFAULT = 8766
+        DASHBOARD_DEFAULT = 8767
+        SOCKETIO_DEFAULT = 8768
+        PORT_RANGE_START = 8765
+        PORT_RANGE_END = 8785
+
     class NetworkConfig:
-        DEFAULT_DASHBOARD_PORT = 8765
+        DEFAULT_DASHBOARD_PORT = 8767
         SOCKETIO_PORT_RANGE = (8765, 8785)
-        DEFAULT_SOCKETIO_PORT = 8765
+        DEFAULT_SOCKETIO_PORT = 8768
 
     socketio = None
 
@@ -309,7 +317,7 @@ class SocketIOConnectionPool:
                         self.server_url = f"http://localhost:{port}"
                         self.logger.debug(f"Detected Socket.IO server on port {port}")
                         return
-            except Exception:
+            except Exception:  # nosec B112 - intentional: skip ports that fail
                 continue
 
         # Fall back to default
@@ -579,7 +587,7 @@ class SocketIOConnectionPool:
                     loop.stop()
                     loop.run_until_complete(loop.shutdown_asyncgens())
                     loop.close()
-                except Exception:
+                except Exception:  # nosec B110 - intentional: cleanup best-effort
                     pass
 
     async def _connect_client(self, client: socketio.AsyncClient):

claude_mpm/hooks/claude_hooks/auto_pause_handler.py

@@ -56,7 +56,7 @@ except ImportError:
 logger = get_logger(__name__)
 
 # Debug mode
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
+DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
 # Warning messages for threshold crossings
 THRESHOLD_WARNINGS = {