claude-mpm 5.0.9__py3-none-any.whl → 5.6.23__py3-none-any.whl

claude_mpm/core/logging_utils.py

@@ -103,21 +103,45 @@ class LoggerFactory:
 
         # Set up root logger
         root_logger = logging.getLogger()
-        root_logger.setLevel(LoggingConfig.LEVELS.get(cls._log_level, logging.INFO))
+
+        # CRITICAL FIX: Respect existing root logger suppression
+        # If root logger is already set to CRITICAL+1 (suppressed by startup.py),
+        # don't override it. This prevents logging from appearing during startup
+        # before the CLI's setup_logging() runs.
+        current_level = root_logger.level
+        desired_level = LoggingConfig.LEVELS.get(cls._log_level, logging.INFO)
+
+        # Only set level if current is unset (0) or lower than desired
+        # CRITICAL+1 is 51, so this check preserves suppression
+        should_configure_logging = current_level == 0 or (
+            current_level < desired_level and current_level <= logging.CRITICAL
+        )
+
+        if should_configure_logging:
+            root_logger.setLevel(desired_level)
+        # else: root logger is suppressed (CRITICAL+1), keep it suppressed
 
         # Remove existing handlers
         root_logger.handlers = []
 
-        # Console handler
-        console_handler = logging.StreamHandler(sys.stdout)
-        console_handler.setLevel(LoggingConfig.LEVELS.get(cls._log_level, logging.INFO))
-        console_formatter = logging.Formatter(
-            log_format or LoggingConfig.DEFAULT_FORMAT,
-            date_format or LoggingConfig.DATE_FORMAT,
-        )
-        console_handler.setFormatter(console_formatter)
-        root_logger.addHandler(console_handler)
-        cls._handlers["console"] = console_handler
+        # CRITICAL FIX: Don't add handlers if logging is suppressed
+        # If root logger is at CRITICAL+1 (startup suppression), don't add any handlers
+        # This prevents early imports from logging before CLI setup_logging() runs
+        if should_configure_logging:
+            # Console handler - MUST use stderr to avoid corrupting hook JSON output
+            # WHY stderr: Hook handlers output JSON to stdout. Logging to stdout
+            # corrupts this JSON and causes "hook error" messages from Claude Code.
+            console_handler = logging.StreamHandler(sys.stderr)
+            console_handler.setLevel(
+                LoggingConfig.LEVELS.get(cls._log_level, logging.INFO)
+            )
+            console_formatter = logging.Formatter(
+                log_format or LoggingConfig.DEFAULT_FORMAT,
+                date_format or LoggingConfig.DATE_FORMAT,
+            )
+            console_handler.setFormatter(console_formatter)
+            root_logger.addHandler(console_handler)
+            cls._handlers["console"] = console_handler
 
         # File handler (optional)
         if log_to_file and cls._log_dir:

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/optimized_startup.py

@@ -165,6 +165,9 @@ class OptimizedStartup:
             # Just setup agent registry, load on demand
             self._setup_agent_registry()
 
+        # Verify PM skills after agent setup (non-blocking)
+        self._verify_pm_skills()
+
         elapsed = time.time() - phase_start
         self.metrics.phases["agents"] = elapsed
         self.metrics.agent_time = elapsed
@@ -198,6 +201,64 @@ class OptimizedStartup:
 
         return self.metrics
 
+    def _verify_pm_skills(self) -> None:
+        """Verify PM skills are deployed. Non-blocking with warnings."""
+        try:
+            from claude_mpm.services.pm_skills_deployer import PMSkillsDeployerService
+
+            deployer = PMSkillsDeployerService()
+            project_dir = Path.cwd()
+
+            result = deployer.verify_pm_skills(project_dir)
+
+            if not result.verified:
+                for warning in result.warnings:
+                    self.logger.warning(warning)
+
+                # Check if auto-deploy is enabled
+                if self._should_auto_deploy_pm_skills():
+                    self.logger.info("Auto-deploying PM skills...")
+                    deploy_result = deployer.deploy_pm_skills(project_dir)
+                    if deploy_result.success:
+                        self.logger.info(
+                            f"PM skills deployed: {len(deploy_result.deployed)} deployed, "
+                            f"{len(deploy_result.skipped)} skipped"
+                        )
+                    else:
+                        self.logger.warning(
+                            f"PM skills deployment had errors: {len(deploy_result.errors)}"
+                        )
+            else:
+                # Count skills from registry
+                registry = deployer._load_registry(project_dir)
+                skill_count = len(registry.get("skills", []))
+                self.logger.debug(f"PM skills verified: {skill_count} skills")
+
+        except ImportError:
+            self.logger.debug("PM skills deployer not available")
+        except Exception as e:
+            self.logger.warning(f"PM skills verification failed: {e}")
+
+    def _should_auto_deploy_pm_skills(self) -> bool:
+        """Check if auto-deploy is enabled via config.
+
+        Returns:
+            True if auto-deploy should be performed (default: True for convenience)
+        """
+        # Default to True for convenience - PM skills are essential for PM agents
+        # Users can disable by setting environment variable or config
+        import os
+
+        # Check environment variable override
+        env_disable = os.environ.get(
+            "CLAUDE_MPM_DISABLE_AUTO_DEPLOY_PM_SKILLS", ""
+        ).lower()
+        if env_disable in ("1", "true", "yes"):
+            return False
+
+        # Default to enabled
+        return True
+
     def _setup_logging(self):
         """Setup basic logging (critical path)."""
         # Minimal logging setup - already handled by logger module