claude-mpm 3.4.10__py3-none-any.whl → 5.4.55__py3-none-any.whl

claude_mpm/config/socketio_config.py

@@ -1,3 +1,5 @@
+from pathlib import Path
+
 """Socket.IO server configuration for different deployment scenarios.
 
 This module provides configuration management for Socket.IO servers
@@ -8,67 +10,102 @@ WHY configuration management:
 - Supports multiple deployment scenarios (local, PyPI, Docker, etc.)
 - Provides environment-specific defaults
 - Allows runtime configuration overrides
+
+CRITICAL: Ping/pong settings MUST match between client and server to prevent disconnections!
 """
 
 import os
 from dataclasses import dataclass
-from pathlib import Path
-from typing import Dict, Any, List, Optional
+from typing import Any, Dict, List, Optional
+
+# Import constants for default values
+from claude_mpm.core.constants import NetworkConfig, RetryConfig, SystemLimits
+
+# Connection stability settings - MUST be consistent between client and server
+CONNECTION_CONFIG = {
+    # Ping/pong intervals (milliseconds for client, seconds for server)
+    "ping_interval_ms": 25000,  # 25 seconds (for client JavaScript)
+    "ping_interval": 25,  # 25 seconds (for server Python) - reduced for stability
+    "ping_timeout_ms": 20000,  # 20 seconds (for client JavaScript)
+    "ping_timeout": 20,  # 20 seconds (for server Python)
+    # Connection management
+    "stale_timeout": 90,  # 90 seconds before considering connection stale (was 180)
+    "health_check_interval": 30,  # Health check every 30 seconds
+    "event_ttl": 300,  # Keep events for 5 minutes for replay
+    "connection_timeout": 10,  # 10 seconds for initial connection timeout
+    # Client reconnection settings
+    "reconnection_attempts": 5,  # Number of reconnection attempts
+    "reconnection_delay": 1000,  # Initial delay in ms
+    "reconnection_delay_max": 5000,  # Maximum delay in ms
+    # Feature flags
+    "enable_extra_heartbeat": False,  # Disable redundant heartbeats
+    "enable_health_monitoring": True,  # Enable connection health monitoring
+    # Buffer settings
+    "max_events_buffer": 1000,  # Maximum events to buffer per client
+    "max_http_buffer_size": 1e8,  # 100MB max buffer for large payloads
+}
 
 
 @dataclass
 class SocketIOConfig:
     """Configuration for Socket.IO server instances."""
-    
+
     # Server settings
     host: str = "localhost"
-    port: int = 8765
+    port: int = NetworkConfig.DEFAULT_DASHBOARD_PORT
     server_id: Optional[str] = None
-    
-    # Connection settings
+
+    # Connection settings - Use centralized config for consistency
     cors_allowed_origins: str = "*"  # Configure properly for production
-    ping_timeout: int = 60
-    ping_interval: int = 25
-    max_http_buffer_size: int = 1000000
-    
+    ping_timeout: int = CONNECTION_CONFIG["ping_timeout"]  # 20 seconds
+    ping_interval: int = CONNECTION_CONFIG["ping_interval"]  # 25 seconds (was 45)
+    max_http_buffer_size: int = int(CONNECTION_CONFIG["max_http_buffer_size"])
+    connection_timeout: int = CONNECTION_CONFIG.get(
+        "connection_timeout", 10
+    )  # 10 seconds
+
     # Compatibility settings
     min_client_version: str = "0.7.0"
-    max_history_size: int = 10000
-    
+    max_history_size: int = SystemLimits.MAX_EVENT_HISTORY
+
     # Deployment settings
     deployment_mode: str = "auto"  # auto, standalone, embedded, client
     auto_start: bool = True
     persistent: bool = True
-    
+
     # Logging settings
     log_level: str = "INFO"
     log_to_file: bool = False
     log_file_path: Optional[str] = None
-    
+
     # Health monitoring
     health_check_interval: int = 30
-    max_connection_attempts: int = 3
+    max_connection_attempts: int = RetryConfig.MAX_CONNECTION_RETRIES
     reconnection_delay: int = 1
-    
+
     @classmethod
-    def from_env(cls) -> 'SocketIOConfig':
+    def from_env(cls) -> "SocketIOConfig":
         """Create configuration from environment variables."""
         return cls(
-            host=os.getenv('CLAUDE_MPM_SOCKETIO_HOST', 'localhost'),
-            port=int(os.getenv('CLAUDE_MPM_SOCKETIO_PORT', '8765')),
-            server_id=os.getenv('CLAUDE_MPM_SOCKETIO_SERVER_ID'),
-            cors_allowed_origins=os.getenv('CLAUDE_MPM_SOCKETIO_CORS', '*'),
-            ping_timeout=int(os.getenv('CLAUDE_MPM_SOCKETIO_PING_TIMEOUT', '60')),
-            ping_interval=int(os.getenv('CLAUDE_MPM_SOCKETIO_PING_INTERVAL', '25')),
-            deployment_mode=os.getenv('CLAUDE_MPM_SOCKETIO_MODE', 'auto'),
-            auto_start=os.getenv('CLAUDE_MPM_SOCKETIO_AUTO_START', 'true').lower() == 'true',
-            persistent=os.getenv('CLAUDE_MPM_SOCKETIO_PERSISTENT', 'true').lower() == 'true',
-            log_level=os.getenv('CLAUDE_MPM_SOCKETIO_LOG_LEVEL', 'INFO'),
-            max_history_size=int(os.getenv('CLAUDE_MPM_SOCKETIO_HISTORY_SIZE', '10000'))
+            host=os.getenv("CLAUDE_MPM_SOCKETIO_HOST", "localhost"),
+            port=int(os.getenv("CLAUDE_MPM_SOCKETIO_PORT", "8765")),
+            server_id=os.getenv("CLAUDE_MPM_SOCKETIO_SERVER_ID"),
+            cors_allowed_origins=os.getenv("CLAUDE_MPM_SOCKETIO_CORS", "*"),
+            ping_timeout=int(os.getenv("CLAUDE_MPM_SOCKETIO_PING_TIMEOUT", "60")),
+            ping_interval=int(os.getenv("CLAUDE_MPM_SOCKETIO_PING_INTERVAL", "25")),
+            deployment_mode=os.getenv("CLAUDE_MPM_SOCKETIO_MODE", "auto"),
+            auto_start=os.getenv("CLAUDE_MPM_SOCKETIO_AUTO_START", "true").lower()
+            == "true",
+            persistent=os.getenv("CLAUDE_MPM_SOCKETIO_PERSISTENT", "true").lower()
+            == "true",
+            log_level=os.getenv("CLAUDE_MPM_SOCKETIO_LOG_LEVEL", "INFO"),
+            max_history_size=int(
+                os.getenv("CLAUDE_MPM_SOCKETIO_HISTORY_SIZE", "10000")
+            ),
         )
-    
+
     @classmethod
-    def for_development(cls) -> 'SocketIOConfig':
+    def for_development(cls) -> "SocketIOConfig":
         """Configuration optimized for development."""
         return cls(
             host="localhost",
@@ -77,11 +114,11 @@ class SocketIOConfig:
             log_level="DEBUG",
             ping_timeout=30,
             ping_interval=10,
-            max_history_size=5000
+            max_history_size=5000,
         )
-    
+
     @classmethod
-    def for_production(cls) -> 'SocketIOConfig':
+    def for_production(cls) -> "SocketIOConfig":
         """Configuration optimized for production."""
         return cls(
             host="0.0.0.0",  # Bind to all interfaces in production
@@ -94,11 +131,11 @@ class SocketIOConfig:
             log_file_path="/var/log/claude-mpm-socketio.log",
             ping_timeout=120,
             ping_interval=30,
-            max_history_size=20000
+            max_history_size=20000,
         )
-    
+
     @classmethod
-    def for_docker(cls) -> 'SocketIOConfig':
+    def for_docker(cls) -> "SocketIOConfig":
         """Configuration optimized for Docker deployment."""
         return cls(
             host="0.0.0.0",
@@ -108,36 +145,36 @@ class SocketIOConfig:
             log_level="INFO",
             ping_timeout=90,
             ping_interval=25,
-            max_history_size=15000
+            max_history_size=15000,
         )
-    
+
     def to_dict(self) -> Dict[str, Any]:
         """Convert configuration to dictionary."""
         return {
-            'host': self.host,
-            'port': self.port,
-            'server_id': self.server_id,
-            'cors_allowed_origins': self.cors_allowed_origins,
-            'ping_timeout': self.ping_timeout,
-            'ping_interval': self.ping_interval,
-            'max_http_buffer_size': self.max_http_buffer_size,
-            'min_client_version': self.min_client_version,
-            'max_history_size': self.max_history_size,
-            'deployment_mode': self.deployment_mode,
-            'auto_start': self.auto_start,
-            'persistent': self.persistent,
-            'log_level': self.log_level,
-            'log_to_file': self.log_to_file,
-            'log_file_path': self.log_file_path,
-            'health_check_interval': self.health_check_interval,
-            'max_connection_attempts': self.max_connection_attempts,
-            'reconnection_delay': self.reconnection_delay
+            "host": self.host,
+            "port": self.port,
+            "server_id": self.server_id,
+            "cors_allowed_origins": self.cors_allowed_origins,
+            "ping_timeout": self.ping_timeout,
+            "ping_interval": self.ping_interval,
+            "max_http_buffer_size": self.max_http_buffer_size,
+            "min_client_version": self.min_client_version,
+            "max_history_size": self.max_history_size,
+            "deployment_mode": self.deployment_mode,
+            "auto_start": self.auto_start,
+            "persistent": self.persistent,
+            "log_level": self.log_level,
+            "log_to_file": self.log_to_file,
+            "log_file_path": self.log_file_path,
+            "health_check_interval": self.health_check_interval,
+            "max_connection_attempts": self.max_connection_attempts,
+            "reconnection_delay": self.reconnection_delay,
         }
 
 
 class ConfigManager:
     """Manages Socket.IO configuration across different environments."""
-    
+
     def __init__(self):
         self.config_file_name = "socketio_config.json"
         self.config_search_paths = [
@@ -145,34 +182,38 @@ class ConfigManager:
             Path.home() / ".claude-mpm" / self.config_file_name,  # User home
             Path("/etc/claude-mpm") / self.config_file_name,  # System config
         ]
-    
+
     def detect_environment(self) -> str:
         """Detect the current deployment environment."""
         # Check for Docker
-        if os.path.exists('/.dockerenv') or os.getenv('DOCKER_CONTAINER'):
+        if Path("/.dockerenv").exists() or os.getenv("DOCKER_CONTAINER"):
             return "docker"
-        
+
         # Check for production indicators
-        if os.getenv('ENVIRONMENT') == 'production' or os.getenv('NODE_ENV') == 'production':
+        if (
+            os.getenv("ENVIRONMENT") == "production"
+            or os.getenv("NODE_ENV") == "production"
+        ):
             return "production"
-        
+
         # Check if running from installed package
         try:
             import claude_mpm
+
             pkg_path = Path(claude_mpm.__file__).parent
-            if 'site-packages' in str(pkg_path) or 'dist-packages' in str(pkg_path):
+            if "site-packages" in str(pkg_path) or "dist-packages" in str(pkg_path):
                 return "installed"
         except ImportError:
             pass
-        
+
         # Default to development
         return "development"
-    
-    def get_config(self, environment: str = None) -> SocketIOConfig:
+
+    def get_config(self, environment: Optional[str] = None) -> SocketIOConfig:
         """Get configuration for the specified environment."""
         if environment is None:
             environment = self.detect_environment()
-        
+
         # Start with environment-specific defaults
         if environment == "production":
             config = SocketIOConfig.for_production()
@@ -182,49 +223,51 @@ class ConfigManager:
             config = SocketIOConfig.for_development()
         else:
             config = SocketIOConfig()
-        
+
         # Override with environment variables
         env_config = SocketIOConfig.from_env()
         for field in config.__dataclass_fields__:
             env_value = getattr(env_config, field)
-            if env_value != getattr(SocketIOConfig(), field):  # Only if different from default
+            if env_value != getattr(
+                SocketIOConfig(), field
+            ):  # Only if different from default
                 setattr(config, field, env_value)
-        
+
         # Override with config file if available
         config_file_data = self._load_config_file()
         if config_file_data:
             for key, value in config_file_data.items():
                 if hasattr(config, key):
                     setattr(config, key, value)
-        
+
         return config
-    
+
     def _load_config_file(self) -> Optional[Dict[str, Any]]:
         """Load configuration from file if available."""
         import json
-        
+
         for config_path in self.config_search_paths:
             if config_path.exists():
                 try:
-                    with open(config_path, 'r') as f:
+                    with config_path.open() as f:
                         return json.load(f)
                 except Exception as e:
                     print(f"Warning: Failed to load config from {config_path}: {e}")
-        
+
         return None
-    
-    def save_config(self, config: SocketIOConfig, path: str = None) -> bool:
+
+    def save_config(self, config: SocketIOConfig, path: Optional[str] = None) -> bool:
         """Save configuration to file."""
         import json
-        
+
         if path is None:
             # Use user config directory
             config_dir = Path.home() / ".claude-mpm"
             config_dir.mkdir(exist_ok=True)
             path = config_dir / self.config_file_name
-        
+
         try:
-            with open(path, 'w') as f:
+            with path.open("w") as f:
                 json.dump(config.to_dict(), f, indent=2)
             return True
         except Exception as e:
@@ -236,7 +279,7 @@ class ConfigManager:
 _config_manager = ConfigManager()
 
 
-def get_config(environment: str = None) -> SocketIOConfig:
+def get_config(environment: Optional[str] = None) -> SocketIOConfig:
     """Get Socket.IO configuration for the current or specified environment."""
     return _config_manager.get_config(environment)
 
@@ -252,5 +295,4 @@ def get_discovery_hosts(config: SocketIOConfig) -> List[str]:
     if config.host == "0.0.0.0":
         # If server binds to all interfaces, try localhost and 127.0.0.1 for discovery
         return ["localhost", "127.0.0.1"]
-    else:
-        return [config.host, "localhost", "127.0.0.1"]
+    return [config.host, "localhost", "127.0.0.1"]

claude_mpm/constants.py

@@ -1,57 +1,77 @@
-"""Constants for Claude MPM."""
+"""Constants for Claude MPM.
+
+Build number tracking is now enabled for all builds.
+"""
 
 from enum import Enum
 
 
 class CLIPrefix(str, Enum):
     """CLI command prefix constants."""
+
     MPM = "--mpm:"
-    
+
     def __add__(self, other: str) -> str:
         """Allow prefix + command concatenation."""
         return self.value + other
-    
+
     def wrap(self, flag: str) -> str:
         """Wrap a flag with the prefix."""
         if flag.startswith("--"):
             return f"--mpm:{flag[2:]}"
-        elif flag.startswith("-"):
+        if flag.startswith("-"):
             return f"-mpm:{flag[1:]}"
         return self.value + flag
 
 
 class CLICommands(str, Enum):
     """CLI command constants."""
+
     RUN = "run"
+    RUN_GUARDED = "run-guarded"
     TICKETS = "tickets"
     INFO = "info"
     AGENTS = "agents"
-    UI = "ui"
+    AGENT_MANAGER = "agent-manager"
     MEMORY = "memory"
     MONITOR = "monitor"
-    
+    CONFIG = "config"
+    CONFIGURE = "configure"
+    AGGREGATE = "aggregate"
+    ANALYZE = "analyze"
+    ANALYZE_CODE = "analyze-code"
+    CLEANUP = "cleanup-memory"
+    MCP = "mcp"
+    DOCTOR = "doctor"
+    DASHBOARD = "dashboard"
+    UPGRADE = "upgrade"
+    SKILLS = "skills"
+
     def with_prefix(self, prefix: CLIPrefix = CLIPrefix.MPM) -> str:
         """Get command with prefix."""
         return prefix + self.value
-    
+
     @classmethod
     def get_mpm_commands(cls) -> list[str]:
         """Get list of MPM-specific commands with prefix."""
         return [cmd.with_prefix() for cmd in cls]
-    
+
     @classmethod
     def is_mpm_command(cls, command: str) -> bool:
         """Check if a command is an MPM command."""
         # Check both with and without prefix
         if command.startswith(CLIPrefix.MPM.value):
-            base_command = command[len(CLIPrefix.MPM.value):]
+            base_command = command[len(CLIPrefix.MPM.value) :]
             return base_command in [cmd.value for cmd in cls]
         return command in [cmd.value for cmd in cls]
 
 
 class AgentCommands(str, Enum):
     """Agent subcommand constants."""
+
     LIST = "list"
+    VIEW = "view"
+    FIX = "fix"
     DEPLOY = "deploy"
     FORCE_DEPLOY = "force-deploy"
     CLEAN = "clean"
@@ -59,6 +79,7 @@ class AgentCommands(str, Enum):
 
 class MemoryCommands(str, Enum):
     """Memory subcommand constants."""
+
     INIT = "init"
     STATUS = "status"
     VIEW = "view"
@@ -73,41 +94,125 @@ class MemoryCommands(str, Enum):
 
 class MonitorCommands(str, Enum):
     """Monitor subcommand constants."""
+
     START = "start"
     STOP = "stop"
     RESTART = "restart"
+    STATUS = "status"
     PORT = "port"
 
 
+class DashboardCommands(str, Enum):
+    """Dashboard subcommand constants."""
+
+    START = "start"
+    STOP = "stop"
+    STATUS = "status"
+    OPEN = "open"
+
+
+class ConfigCommands(str, Enum):
+    """Config subcommand constants."""
+
+    VALIDATE = "validate"
+    VIEW = "view"
+    STATUS = "status"
+
+
+class AggregateCommands(str, Enum):
+    """Event aggregator subcommand constants."""
+
+    START = "start"
+    STOP = "stop"
+    STATUS = "status"
+    SESSIONS = "sessions"
+    VIEW = "view"
+    EXPORT = "export"
+
+
+class MCPCommands(str, Enum):
+    """MCP Gateway subcommand constants."""
+
+    INSTALL = "install"
+    START = "start"
+    STOP = "stop"
+    STATUS = "status"
+    TOOLS = "tools"
+    REGISTER = "register"
+    TEST = "test"
+    CONFIG = "config"
+    SERVER = "server"
+    EXTERNAL = "external"
+
+
+class TicketCommands(str, Enum):
+    """Ticket subcommand constants."""
+
+    CREATE = "create"
+    LIST = "list"
+    VIEW = "view"
+    UPDATE = "update"
+    DELETE = "delete"
+    CLOSE = "close"
+    SEARCH = "search"
+    COMMENT = "comment"
+    WORKFLOW = "workflow"
+
+
+class SkillsCommands(str, Enum):
+    """Skills subcommand constants."""
+
+    LIST = "list"
+    DEPLOY = "deploy"
+    VALIDATE = "validate"
+    UPDATE = "update"
+    INFO = "info"
+    CONFIG = "config"
+    CONFIGURE = "configure"  # Interactive skills selection (like agents configure)
+    # GitHub deployment commands
+    DEPLOY_FROM_GITHUB = "deploy-github"
+    LIST_AVAILABLE = "list-available"
+    CHECK_DEPLOYED = "check-deployed"
+    REMOVE = "remove"
+    # Collection management commands
+    COLLECTION_LIST = "collection-list"
+    COLLECTION_ADD = "collection-add"
+    COLLECTION_REMOVE = "collection-remove"
+    COLLECTION_ENABLE = "collection-enable"
+    COLLECTION_DISABLE = "collection-disable"
+    COLLECTION_SET_DEFAULT = "collection-set-default"
+
+
 class CLIFlags(str, Enum):
     """CLI flag constants (without prefix)."""
+
     # Logging flags
     DEBUG = "debug"
     LOGGING = "logging"
     LOG_DIR = "log-dir"
-    
+
     # Framework flags
     FRAMEWORK_PATH = "framework-path"
     AGENTS_DIR = "agents-dir"
-    
+
     # Hook flags
     NO_HOOKS = "no-hooks"
-    
+
     # Ticket flags
     NO_TICKETS = "no-tickets"
-    
+
     # Input/output flags
     INPUT = "input"
     NON_INTERACTIVE = "non-interactive"
-    
+
     # Orchestration flags
     SUBPROCESS = "subprocess"
     INTERACTIVE_SUBPROCESS = "interactive-subprocess"
     TODO_HIJACK = "todo-hijack"
-    
+
     # Agent flags
     NO_NATIVE_AGENTS = "no-native-agents"
-    
+
     def with_prefix(self, short: bool = False) -> str:
         """Get flag with MPM prefix."""
         prefix = CLIPrefix.MPM.value
@@ -119,6 +224,7 @@ class CLIFlags(str, Enum):
 
 class LogLevel(str, Enum):
     """Logging level constants."""
+
     OFF = "OFF"
     INFO = "INFO"
     DEBUG = "DEBUG"
@@ -126,6 +232,7 @@ class LogLevel(str, Enum):
 
 class OrchestratorMode(str, Enum):
     """Orchestrator mode constants."""
+
     SYSTEM_PROMPT = "system_prompt"
     SUBPROCESS = "subprocess"
     INTERACTIVE_SUBPROCESS = "interactive_subprocess"
@@ -133,11 +240,12 @@ class OrchestratorMode(str, Enum):
 
 class EnvironmentVars(str, Enum):
     """Environment variable constants."""
+
     CLAUDE_CONFIG_DIR = "CLAUDE_CONFIG_DIR"
     CLAUDE_MAX_PARALLEL_SUBAGENTS = "CLAUDE_MAX_PARALLEL_SUBAGENTS"
     CLAUDE_TIMEOUT = "CLAUDE_TIMEOUT"
     CLAUDE_MPM_DEBUG = "CLAUDE_MPM_DEBUG"
-    
+
     # Default values
     DEFAULT_MAX_AGENTS = "10"
     DEFAULT_TIMEOUT = "600000"  # 10 minutes in milliseconds
@@ -145,15 +253,17 @@ class EnvironmentVars(str, Enum):
 
 class Paths(str, Enum):
     """Path constants."""
+
     CLAUDE_AGENTS_DIR = ".claude/agents"
     CLAUDE_CONFIG_DIR = ".claude"
-    MPM_LOG_DIR = ".claude-mpm/logs"
+    MPM_LOG_DIR = ".claude-mpm/logs/mpm"
     MPM_SESSION_DIR = ".claude-mpm/session"
     MPM_PROMPTS_DIR = ".claude-mpm/prompts"
-    
-    
+
+
 class AgentMetadata(str, Enum):
     """Agent metadata field constants."""
+
     NAME = "name"
     DESCRIPTION = "description"
     VERSION = "version"
@@ -164,11 +274,11 @@ class AgentMetadata(str, Enum):
     TIMEOUT = "timeout"
     MAX_TOKENS = "max_tokens"
     TEMPERATURE = "temperature"
-    
+
     # Default values
     DEFAULT_AUTHOR = "claude-mpm"
     DEFAULT_VERSION = "1.0.0"
     DEFAULT_PRIORITY = "medium"
     DEFAULT_TIMEOUT = 600
     DEFAULT_MAX_TOKENS = 8192
-    DEFAULT_TEMPERATURE = 0.5
+    DEFAULT_TEMPERATURE = 0.5