claude-mpm 5.4.85__py3-none-any.whl → 5.6.76__py3-none-any.whl

claude_mpm/services/mcp_service_registry.py

@@ -0,0 +1,294 @@
+"""MCP Service Registry for claude-mpm.
+
+This module provides a registry of known MCP services with their
+installation, configuration, and runtime requirements.
+
+WHY: Centralizes MCP service definitions to enable enable/disable/list
+operations with automatic configuration generation.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import ClassVar
+
+
+class InstallMethod(str, Enum):
+    """Installation method for MCP services."""
+
+    UVX = "uvx"
+    PIPX = "pipx"
+    NPX = "npx"
+    PIP = "pip"
+
+
+@dataclass(frozen=True)
+class MCPServiceDefinition:
+    """Definition of an MCP service with all configuration requirements.
+
+    Attributes:
+        name: Unique service identifier (e.g., "kuzu-memory")
+        package: PyPI/npm package name for installation
+        install_method: How to install (uvx, pipx, npx, pip)
+        command: Command to run the service
+        args: Default command arguments
+        required_env: Environment variables that must be set
+        optional_env: Environment variables that may be set
+        description: Human-readable description
+        env_defaults: Default values for optional env vars
+        enabled_by_default: Whether service is enabled by default
+    """
+
+    name: str
+    package: str
+    install_method: InstallMethod
+    command: str
+    args: list[str] = field(default_factory=list)
+    required_env: list[str] = field(default_factory=list)
+    optional_env: list[str] = field(default_factory=list)
+    description: str = ""
+    env_defaults: dict[str, str] = field(default_factory=dict)
+    enabled_by_default: bool = False
+    oauth_provider: str | None = None  # "google", "microsoft", etc.
+    oauth_scopes: list[str] = field(default_factory=list)  # OAuth scopes if applicable
+
+
+class MCPServiceRegistry:
+    """Registry of known MCP services.
+
+    Provides service lookup, configuration generation, and
+    enable/disable state management.
+    """
+
+    # Registry of all known MCP services
+    SERVICES: ClassVar[dict[str, MCPServiceDefinition]] = {}
+
+    @classmethod
+    def register(cls, service: MCPServiceDefinition) -> None:
+        """Register a service definition."""
+        cls.SERVICES[service.name] = service
+
+    @classmethod
+    def get(cls, name: str) -> MCPServiceDefinition | None:
+        """Get a service definition by name."""
+        return cls.SERVICES.get(name)
+
+    @classmethod
+    def list_all(cls) -> list[MCPServiceDefinition]:
+        """List all registered services."""
+        return list(cls.SERVICES.values())
+
+    @classmethod
+    def list_names(cls) -> list[str]:
+        """List all registered service names."""
+        return list(cls.SERVICES.keys())
+
+    @classmethod
+    def exists(cls, name: str) -> bool:
+        """Check if a service exists in the registry."""
+        return name in cls.SERVICES
+
+    @classmethod
+    def get_default_enabled(cls) -> list[MCPServiceDefinition]:
+        """Get services that are enabled by default."""
+        return [s for s in cls.SERVICES.values() if s.enabled_by_default]
+
+    @classmethod
+    def generate_config(
+        cls,
+        service: MCPServiceDefinition,
+        env_overrides: dict[str, str] | None = None,
+    ) -> dict:
+        """Generate MCP configuration for a service.
+
+        Args:
+            service: The service definition
+            env_overrides: Environment variable overrides
+
+        Returns:
+            Configuration dict suitable for .mcp.json or ~/.claude.json
+        """
+        env = {}
+
+        # Add required env vars (must be provided or have defaults)
+        for var in service.required_env:
+            if env_overrides and var in env_overrides:
+                env[var] = env_overrides[var]
+            elif var in service.env_defaults:
+                env[var] = service.env_defaults[var]
+            # If required and not provided, leave it out - caller should validate
+
+        # Add optional env vars if provided or have defaults
+        for var in service.optional_env:
+            if env_overrides and var in env_overrides:
+                env[var] = env_overrides[var]
+            elif var in service.env_defaults:
+                env[var] = service.env_defaults[var]
+
+        config: dict = {
+            "command": service.command,
+            "args": service.args.copy(),
+        }
+
+        if env:
+            config["env"] = env
+
+        return config
+
+    @classmethod
+    def validate_env(
+        cls, service: MCPServiceDefinition, env: dict[str, str]
+    ) -> tuple[bool, list[str]]:
+        """Validate that all required env vars are provided.
+
+        Args:
+            service: The service definition
+            env: Environment variables to validate
+
+        Returns:
+            Tuple of (is_valid, list of missing required vars)
+        """
+        missing = []
+        for var in service.required_env:
+            if var not in env and var not in service.env_defaults:
+                missing.append(var)
+        return len(missing) == 0, missing
+
+
+# ============================================================================
+# Service Definitions
+# ============================================================================
+
+# KuzuMemory - Project memory and context management
+KUZU_MEMORY = MCPServiceDefinition(
+    name="kuzu-memory",
+    package="kuzu-memory",
+    install_method=InstallMethod.UVX,
+    command="uvx",
+    args=["kuzu-memory"],
+    required_env=[],
+    optional_env=["KUZU_DB_PATH", "KUZU_LOG_LEVEL"],
+    description="Project memory and context management with graph database",
+    env_defaults={},
+    enabled_by_default=True,
+)
+
+# MCP Ticketer - Ticket and project management
+MCP_TICKETER = MCPServiceDefinition(
+    name="mcp-ticketer",
+    package="mcp-ticketer",
+    install_method=InstallMethod.UVX,
+    command="uvx",
+    args=["mcp-ticketer"],
+    required_env=[],
+    optional_env=["TICKETER_BACKEND", "GITHUB_TOKEN", "LINEAR_API_KEY"],
+    description="Ticket and project management integration",
+    env_defaults={},
+    enabled_by_default=True,
+)
+
+# MCP Vector Search - Code semantic search
+MCP_VECTOR_SEARCH = MCPServiceDefinition(
+    name="mcp-vector-search",
+    package="mcp-vector-search",
+    install_method=InstallMethod.UVX,
+    command="uvx",
+    args=["mcp-vector-search"],
+    required_env=[],
+    optional_env=["VECTOR_SEARCH_INDEX_PATH"],
+    description="Semantic code search with vector embeddings",
+    env_defaults={},
+    enabled_by_default=True,
+)
+
+# Google Workspace MCP - Google Drive, Docs, Sheets integration
+# Package: https://pypi.org/project/workspace-mcp/
+GOOGLE_WORKSPACE_MCP = MCPServiceDefinition(
+    name="workspace-mcp",
+    package="workspace-mcp",
+    install_method=InstallMethod.UVX,
+    command="uvx",
+    args=["workspace-mcp", "--tool-tier", "core"],
+    required_env=["GOOGLE_OAUTH_CLIENT_ID", "GOOGLE_OAUTH_CLIENT_SECRET"],
+    optional_env=[
+        "OAUTHLIB_INSECURE_TRANSPORT",
+        "USER_GOOGLE_EMAIL",
+        "GOOGLE_PSE_API_KEY",
+        "GOOGLE_PSE_ENGINE_ID",
+    ],
+    description="Google Workspace integration (Gmail, Calendar, Drive, Docs, Sheets, Slides)",
+    env_defaults={"OAUTHLIB_INSECURE_TRANSPORT": "1"},
+    enabled_by_default=False,
+    oauth_provider="google",
+    oauth_scopes=[
+        "openid",
+        "email",
+        "profile",
+        "https://www.googleapis.com/auth/gmail.modify",
+        "https://www.googleapis.com/auth/calendar",
+        "https://www.googleapis.com/auth/drive",
+        "https://www.googleapis.com/auth/documents",
+        "https://www.googleapis.com/auth/spreadsheets",
+    ],
+)
+
+# MCP GitHub - GitHub repository integration (future)
+MCP_GITHUB = MCPServiceDefinition(
+    name="mcp-github",
+    package="@modelcontextprotocol/server-github",
+    install_method=InstallMethod.NPX,
+    command="npx",
+    args=["-y", "@modelcontextprotocol/server-github"],
+    required_env=["GITHUB_PERSONAL_ACCESS_TOKEN"],
+    optional_env=[],
+    description="GitHub repository integration",
+    env_defaults={},
+    enabled_by_default=False,
+)
+
+# MCP Filesystem - Local filesystem access (future)
+MCP_FILESYSTEM = MCPServiceDefinition(
+    name="mcp-filesystem",
+    package="@modelcontextprotocol/server-filesystem",
+    install_method=InstallMethod.NPX,
+    command="npx",
+    args=["-y", "@modelcontextprotocol/server-filesystem"],
+    required_env=[],
+    optional_env=["FILESYSTEM_ROOT_PATH"],
+    description="Local filesystem access and management",
+    env_defaults={},
+    enabled_by_default=False,
+)
+
+# MCP Skillset - Skills and knowledge management
+MCP_SKILLSET = MCPServiceDefinition(
+    name="mcp-skillset",
+    package="mcp-skillset",
+    install_method=InstallMethod.UVX,
+    command="uvx",
+    args=["mcp-skillset"],
+    required_env=[],
+    optional_env=["SKILLSET_PATH", "SKILLSET_LOG_LEVEL"],
+    description="Skills and knowledge management for Claude",
+    env_defaults={},
+    enabled_by_default=True,
+)
+
+
+# Register all services
+def _register_builtin_services() -> None:
+    """Register all built-in service definitions."""
+    services = [
+        KUZU_MEMORY,
+        MCP_TICKETER,
+        MCP_VECTOR_SEARCH,
+        GOOGLE_WORKSPACE_MCP,
+        MCP_GITHUB,
+        MCP_FILESYSTEM,
+        MCP_SKILLSET,
+    ]
+    for service in services:
+        MCPServiceRegistry.register(service)
+
+
+# Auto-register on module import
+_register_builtin_services()

claude_mpm/services/monitor/daemon_manager.py

@@ -95,10 +95,10 @@ class DaemonManager:
     def _get_default_log_file(self) -> Path:
         """Get default log file path with port number to support multiple daemons."""
         project_root = Path.cwd()
-        claude_mpm_dir = project_root / ".claude-mpm"
-        claude_mpm_dir.mkdir(exist_ok=True)
+        logs_dir = project_root / ".claude-mpm" / "logs"
+        logs_dir.mkdir(parents=True, exist_ok=True)
         # Include port in filename to support multiple daemon instances
-        return claude_mpm_dir / f"monitor-daemon-{self.port}.log"
+        return logs_dir / f"monitor-daemon-{self.port}.log"
 
     def cleanup_port_conflicts(self, max_retries: int = 3) -> bool:
         """Clean up any processes using the daemon port.
@@ -649,14 +649,24 @@ class DaemonManager:
 
                 # Wait for the subprocess to write its PID file and bind to port
                 # The subprocess will write the PID file after it starts successfully
-                max_wait = 10  # seconds
+                # Allow configuration via environment variable (default 30s to account for agent/skill sync)
+                max_wait = int(os.environ.get("CLAUDE_MPM_MONITOR_TIMEOUT", "30"))
                 start_time = time.time()
                 pid_file_found = False
                 port_bound = False
+                last_progress_log = 0.0
 
                 self.logger.debug(f"Waiting up to {max_wait}s for daemon to start...")
 
                 while time.time() - start_time < max_wait:
+                    # Log progress every 5 seconds to show we're waiting
+                    elapsed = time.time() - start_time
+                    if elapsed - last_progress_log >= 5.0:
+                        self.logger.info(
+                            f"Waiting for monitor daemon... ({int(elapsed)}s elapsed, syncing agents/skills)"
+                        )
+                        last_progress_log = elapsed
+
                     # Check if process is still running
                     returncode = process.poll()
                     if returncode is not None:
@@ -976,6 +986,7 @@ class DaemonManager:
                 os.dup2(null_in.fileno(), sys.stdin.fileno())
 
             # Redirect stdout and stderr to log file
+            # Ensure logs directory exists
             self.log_file.parent.mkdir(parents=True, exist_ok=True)
             with self.log_file.open("a") as log_out:
                 os.dup2(log_out.fileno(), sys.stdout.fileno())

claude_mpm/services/monitor/management/lifecycle.py

@@ -128,12 +128,16 @@ class DaemonLifecycle:
             # Redirect stdout and stderr
             if self.log_file:
                 # Redirect to log file
+                # Ensure logs directory exists
+                self.log_file.parent.mkdir(parents=True, exist_ok=True)
                 with self.log_file.open("a") as log_out:
                     os.dup2(log_out.fileno(), sys.stdout.fileno())
                     os.dup2(log_out.fileno(), sys.stderr.fileno())
             else:
                 # Default to a daemon log file instead of /dev/null for errors
-                default_log = Path.home() / ".claude-mpm" / "monitor-daemon.log"
+                default_log = (
+                    Path.home() / ".claude-mpm" / "logs" / "monitor-daemon.log"
+                )
                 default_log.parent.mkdir(parents=True, exist_ok=True)
                 with default_log.open("a") as log_out:
                     os.dup2(log_out.fileno(), sys.stdout.fileno())
@@ -475,7 +479,9 @@ class DaemonLifecycle:
         try:
             # If no log file specified, create a default one
             if not self.log_file:
-                default_log = Path.home() / ".claude-mpm" / "monitor-daemon.log"
+                default_log = (
+                    Path.home() / ".claude-mpm" / "logs" / "monitor-daemon.log"
+                )
                 default_log.parent.mkdir(parents=True, exist_ok=True)
                 self.log_file = default_log
 

claude_mpm/services/monitor/server.py

@@ -368,6 +368,83 @@ class UnifiedMonitorServer:
         finally:
             await self._cleanup_async()
 
+    def _categorize_event(self, event_name: str) -> str:
+        """Categorize event by name to determine Socket.IO event type.
+
+        Maps specific event names to their category for frontend filtering.
+
+        Args:
+            event_name: The raw event name (e.g., "subagent_start", "todo_updated")
+
+        Returns:
+            Category name (e.g., "hook_event", "system_event")
+        """
+        # Hook events - agent lifecycle and todo updates
+        if event_name in ("subagent_start", "subagent_stop", "todo_updated"):
+            return "hook_event"
+
+        # Tool events - both hook-style and direct tool events
+        if event_name in (
+            "pre_tool",
+            "post_tool",
+            "tool.start",
+            "tool.end",
+            "tool_use",
+            "tool_result",
+        ):
+            return "tool_event"
+
+        # Session events - session lifecycle
+        if event_name in (
+            "session.started",
+            "session.ended",
+            "session_start",
+            "session_end",
+        ):
+            return "session_event"
+
+        # Response events - API response lifecycle
+        if event_name in (
+            "response.start",
+            "response.end",
+            "response_started",
+            "response_ended",
+        ):
+            return "response_event"
+
+        # Agent events - agent delegation and returns
+        if event_name in (
+            "agent.delegated",
+            "agent.returned",
+            "agent_start",
+            "agent_end",
+        ):
+            return "agent_event"
+
+        # File events - file operations
+        if event_name in (
+            "file.read",
+            "file.write",
+            "file.edit",
+            "file_read",
+            "file_write",
+        ):
+            return "file_event"
+
+        # Claude API events
+        if event_name in ("user_prompt", "assistant_message"):
+            return "claude_event"
+
+        # System events
+        if event_name in ("system_ready", "system_shutdown"):
+            return "system_event"
+
+        # Log uncategorized events for debugging
+        self.logger.debug(f"Uncategorized event: {event_name}")
+
+        # Default to claude_event for unknown events
+        return "claude_event"
+
     def _setup_event_handlers(self):
         """Setup Socket.IO event handlers."""
         try:
@@ -474,7 +551,7 @@ class UnifiedMonitorServer:
                     )
                     if version_file.exists():
                         version = version_file.read_text().strip()
-                except Exception:
+                except Exception:  # nosec B110
                     pass
 
                 return web.json_response(
@@ -499,10 +576,28 @@ class UnifiedMonitorServer:
                     event = data.get("event", "claude_event")
                     event_data = data.get("data", {})
 
-                    # Emit to Socket.IO clients via the appropriate event
+                    # Extract actual event name from subtype or type within data
+                    actual_event = (
+                        event_data.get("subtype") or event_data.get("type") or event
+                    )
+
+                    # Categorize event and wrap in expected format
+                    event_type = self._categorize_event(actual_event)
+                    wrapped_event = {
+                        "type": event_type,
+                        "subtype": event,
+                        "data": event_data,
+                        "timestamp": event_data.get("timestamp")
+                        or datetime.now(timezone.utc).isoformat() + "Z",
+                        "session_id": event_data.get("session_id"),
+                    }
+
+                    # Emit to Socket.IO clients via the categorized event type
                     if self.sio:
-                        await self.sio.emit(event, event_data)
-                        self.logger.debug(f"HTTP event forwarded to Socket.IO: {event}")
+                        await self.sio.emit(event_type, wrapped_event)
+                        self.logger.debug(
+                            f"HTTP event forwarded to Socket.IO: {event} -> {event_type}"
+                        )
 
                     return web.Response(status=204)  # No content response
 
@@ -859,7 +954,7 @@ class UnifiedMonitorServer:
             # Configuration endpoint for dashboard initialization
             async def config_handler(request):
                 """Return configuration for dashboard initialization."""
-                import subprocess
+                import subprocess  # nosec B404
 
                 config = {
                     "workingDirectory": Path.cwd(),
@@ -870,7 +965,7 @@ class UnifiedMonitorServer:
 
                 # Try to get current git branch
                 try:
-                    result = subprocess.run(
+                    result = subprocess.run(  # nosec B603 B607
                         ["git", "branch", "--show-current"],
                         capture_output=True,
                         text=True,
@@ -880,7 +975,7 @@ class UnifiedMonitorServer:
                     )
                     if result.returncode == 0 and result.stdout.strip():
                         config["gitBranch"] = result.stdout.strip()
-                except Exception:
+                except Exception:  # nosec B110
                     pass  # Keep default "Unknown" value
 
                 return web.json_response(config)
@@ -910,7 +1005,7 @@ class UnifiedMonitorServer:
             # Git history handler
             async def git_history_handler(request: web.Request) -> web.Response:
                 """Get git history for a file."""
-                import subprocess
+                import subprocess  # nosec B404
 
                 try:
                     data = await request.json()
@@ -939,7 +1034,7 @@ class UnifiedMonitorServer:
                         )
 
                     # Get git log for file
-                    result = subprocess.run(
+                    result = subprocess.run(  # nosec B603 B607
                         [
                             "git",
                             "log",
@@ -978,7 +1073,7 @@ class UnifiedMonitorServer:
             # Git diff handler
             async def git_diff_handler(request: web.Request) -> web.Response:
                 """Get git diff for a file with optional commit selection."""
-                import subprocess
+                import subprocess  # nosec B404
 
                 try:
                     file_path = request.query.get("path", "")
@@ -1010,7 +1105,7 @@ class UnifiedMonitorServer:
                         )
 
                     # Find git repository root
-                    git_root_result = subprocess.run(
+                    git_root_result = subprocess.run(  # nosec B603 B607
                         ["git", "rev-parse", "--show-toplevel"],
                         check=False,
                         capture_output=True,
@@ -1034,7 +1129,7 @@ class UnifiedMonitorServer:
                     git_root = Path(git_root_result.stdout.strip())
 
                     # Check if file is tracked by git
-                    ls_files_result = subprocess.run(
+                    ls_files_result = subprocess.run(  # nosec B603 B607
                         ["git", "ls-files", "--error-unmatch", str(path)],
                         check=False,
                         capture_output=True,
@@ -1056,7 +1151,7 @@ class UnifiedMonitorServer:
                         )
 
                     # Get commit history for this file (last 5 commits)
-                    history_result = subprocess.run(
+                    history_result = subprocess.run(  # nosec B603 B607
                         [
                             "git",
                             "log",
@@ -1087,7 +1182,7 @@ class UnifiedMonitorServer:
                                     )
 
                     # Check for uncommitted changes
-                    uncommitted_result = subprocess.run(
+                    uncommitted_result = subprocess.run(  # nosec B603 B607
                         ["git", "diff", "HEAD", str(path)],
                         check=False,
                         capture_output=True,
@@ -1100,7 +1195,7 @@ class UnifiedMonitorServer:
                     # Get diff based on commit parameter
                     if commit_hash:
                         # Get diff for specific commit
-                        result = subprocess.run(
+                        result = subprocess.run(  # nosec B603 B607
                             ["git", "show", commit_hash, "--", str(path)],
                             check=False,
                             capture_output=True,
@@ -1469,7 +1564,7 @@ class UnifiedMonitorServer:
                 gather = asyncio.gather(*tasks_to_cancel, return_exceptions=True)
                 try:
                     loop.run_until_complete(gather)
-                except Exception:
+                except Exception:  # nosec B110
                     # Some tasks might fail to cancel, that's ok
                     pass