claude-mpm 4.1.8__py3-none-any.whl → 4.1.10__py3-none-any.whl

claude_mpm/hooks/claude_hooks/installer.py

@@ -7,10 +7,12 @@ claude-mpm hooks in the Claude Code environment.
 
 import json
 import os
+import re
 import shutil
 import stat
+import subprocess
 from pathlib import Path
-from typing import Dict, List, Tuple
+from typing import Dict, List, Optional, Tuple
 
 from ...core.logger import get_logger
 
@@ -18,11 +20,11 @@ from ...core.logger import get_logger
 class HookInstaller:
     """Manages installation and configuration of Claude MPM hooks."""
 
-    # Smart hook script template
+    # Note: SMART_HOOK_SCRIPT is deprecated - we now use deployment-root script
+    # Keep for backward compatibility during transition
     SMART_HOOK_SCRIPT = """#!/bin/bash
-# Claude MPM Smart Hook Handler
-# This script dynamically finds and routes hook events to claude-mpm
-# Works with pip installations, local development, and virtual environments
+# DEPRECATED: This script is no longer used
+# Claude MPM now uses deployment-root script at src/claude_mpm/scripts/claude-hook-handler.sh
 
 # Function to find claude-mpm installation
 find_claude_mpm() {
@@ -41,7 +43,7 @@ find_claude_mpm() {
             return 0
         fi
     fi
-    
+
     # Method 2: Check common development locations
     local dev_locations=(
         "$HOME/Projects/claude-mpm"
@@ -55,14 +57,14 @@ find_claude_mpm() {
         "$(pwd)/claude-mpm"
         "$(pwd)"
     )
-    
+
     for loc in "${dev_locations[@]}"; do
         if [ -f "$loc/src/claude_mpm/__init__.py" ]; then
             echo "$loc"
             return 0
         fi
     done
-    
+
     # Method 3: Try to find via Python import
     local python_path=$(python3 -c "
 try:
@@ -86,12 +88,12 @@ try:
 except:
     pass
 " 2>/dev/null)
-    
+
     if [ -n "$python_path" ]; then
         echo "$python_path"
         return 0
     fi
-    
+
     # Method 4: Search in PATH for claude-mpm installations
     local IFS=':'
     for path_dir in $PATH; do
@@ -104,14 +106,14 @@ except:
             fi
         fi
     done
-    
+
     return 1
 }
 
 # Function to setup Python environment
 setup_python_env() {
     local project_dir="$1"
-    
+
     # Check for virtual environment in the project
     if [ -f "$project_dir/venv/bin/activate" ]; then
         source "$project_dir/venv/bin/activate"
@@ -127,7 +129,7 @@ setup_python_env() {
     else
         export PYTHON_CMD="python"
     fi
-    
+
     # Set PYTHONPATH for development installs
     if [ -d "$project_dir/src" ]; then
         export PYTHONPATH="$project_dir/src:$PYTHONPATH"
@@ -140,10 +142,10 @@ main() {
     if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
         echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Smart hook starting..." >> /tmp/claude-mpm-hook.log
     fi
-    
+
     # Find claude-mpm installation
     PROJECT_DIR=$(find_claude_mpm)
-    
+
     if [ -z "$PROJECT_DIR" ]; then
         # Claude MPM not found - return continue to not block Claude
         if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
@@ -152,23 +154,23 @@ main() {
         echo '{"action": "continue"}'
         exit 0
     fi
-    
+
     if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
         echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Found claude-mpm at: $PROJECT_DIR" >> /tmp/claude-mpm-hook.log
     fi
-    
+
     # Setup Python environment
     setup_python_env "$PROJECT_DIR"
-    
+
     # Debug logging
     if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
         echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] PYTHON_CMD: $PYTHON_CMD" >> /tmp/claude-mpm-hook.log
         echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] PYTHONPATH: $PYTHONPATH" >> /tmp/claude-mpm-hook.log
     fi
-    
+
     # Set Socket.IO configuration for hook events
     export CLAUDE_MPM_SOCKETIO_PORT="${CLAUDE_MPM_SOCKETIO_PORT:-8765}"
-    
+
     # Run the hook handler
     if ! "$PYTHON_CMD" -m claude_mpm.hooks.claude_hooks.hook_handler "$@" 2>/tmp/claude-mpm-hook-error.log; then
         # If the Python handler fails, always return continue to not block Claude
@@ -179,7 +181,7 @@ main() {
         echo '{"action": "continue"}'
         exit 0
     fi
-    
+
     # Success
     exit 0
 }
@@ -188,12 +190,161 @@ main() {
 main "$@"
 """
 
+    # Minimum Claude Code version required for hook monitoring
+    MIN_CLAUDE_VERSION = "1.0.92"
+
     def __init__(self):
         """Initialize the hook installer."""
         self.logger = get_logger(__name__)
         self.claude_dir = Path.home() / ".claude"
-        self.hooks_dir = self.claude_dir / "hooks"
+        self.hooks_dir = self.claude_dir / "hooks"  # Kept for backward compatibility
+        # Use settings.json for hooks (Claude Code reads from this file)
         self.settings_file = self.claude_dir / "settings.json"
+        # Keep reference to old file for migration
+        self.old_settings_file = self.claude_dir / "settings.json"
+        self._claude_version: Optional[str] = None
+        self._hook_script_path: Optional[Path] = None
+
+    def get_claude_version(self) -> Optional[str]:
+        """
+        Get the installed Claude Code version.
+
+        Returns:
+            Version string (e.g., "1.0.92") or None if not detected
+        """
+        if self._claude_version is not None:
+            return self._claude_version
+
+        try:
+            # Run claude --version command
+            result = subprocess.run(
+                ["claude", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+
+            if result.returncode == 0:
+                # Parse version from output (e.g., "1.0.92 (Claude Code)")
+                version_text = result.stdout.strip()
+                # Extract version number using regex
+                match = re.match(r"^([\d\.]+)", version_text)
+                if match:
+                    self._claude_version = match.group(1)
+                    self.logger.info(
+                        f"Detected Claude Code version: {self._claude_version}"
+                    )
+                    return self._claude_version
+            else:
+                self.logger.warning(f"Failed to get Claude version: {result.stderr}")
+
+        except FileNotFoundError:
+            self.logger.warning("Claude Code command not found in PATH")
+        except subprocess.TimeoutExpired:
+            self.logger.warning("Claude version check timed out")
+        except Exception as e:
+            self.logger.warning(f"Error detecting Claude version: {e}")
+
+        return None
+
+    def is_version_compatible(self) -> Tuple[bool, str]:
+        """
+        Check if the installed Claude Code version meets minimum requirements.
+
+        Returns:
+            Tuple of (is_compatible, message)
+        """
+        version = self.get_claude_version()
+
+        if version is None:
+            return (
+                False,
+                "Could not detect Claude Code version. Hooks require Claude Code to be installed.",
+            )
+
+        # Parse version numbers for comparison
+        def parse_version(v: str) -> List[int]:
+            """Parse semantic version string to list of integers."""
+            try:
+                return [int(x) for x in v.split(".")]
+            except (ValueError, AttributeError):
+                return [0]
+
+        current = parse_version(version)
+        required = parse_version(self.MIN_CLAUDE_VERSION)
+
+        # Compare versions (semantic versioning)
+        for i in range(max(len(current), len(required))):
+            curr_part = current[i] if i < len(current) else 0
+            req_part = required[i] if i < len(required) else 0
+
+            if curr_part < req_part:
+                return (
+                    False,
+                    f"Claude Code {version} does not support matcher-based hooks. "
+                    f"Version {self.MIN_CLAUDE_VERSION} or higher is required for hook monitoring. "
+                    f"Please upgrade Claude Code to enable dashboard monitoring features.",
+                )
+            if curr_part > req_part:
+                # Current version is higher, compatible
+                break
+
+        return (True, f"Claude Code {version} is compatible with hook monitoring.")
+
+    def get_hook_script_path(self) -> Path:
+        """Get the path to the hook handler script based on installation method.
+
+        Returns:
+            Path to the claude-hook-handler.sh script
+
+        Raises:
+            FileNotFoundError: If the script cannot be found
+        """
+        if self._hook_script_path and self._hook_script_path.exists():
+            return self._hook_script_path
+
+        import claude_mpm
+
+        # Get the claude_mpm package directory
+        package_dir = Path(claude_mpm.__file__).parent
+
+        # Check if we're in a development environment (src structure)
+        if "src/claude_mpm" in str(package_dir):
+            # Development install - script is in src/claude_mpm/scripts
+            script_path = package_dir / "scripts" / "claude-hook-handler.sh"
+        else:
+            # Pip install - script should be in package/scripts
+            script_path = package_dir / "scripts" / "claude-hook-handler.sh"
+
+        # Verify the script exists
+        if not script_path.exists():
+            # Try alternative location for editable installs
+            project_root = package_dir.parent.parent
+            alt_path = (
+                project_root
+                / "src"
+                / "claude_mpm"
+                / "scripts"
+                / "claude-hook-handler.sh"
+            )
+            if alt_path.exists():
+                script_path = alt_path
+            else:
+                raise FileNotFoundError(
+                    f"Hook handler script not found. Searched:\n"
+                    f"  - {script_path}\n"
+                    f"  - {alt_path}"
+                )
+
+        # Make sure it's executable
+        if script_path.exists():
+            st = os.stat(script_path)
+            os.chmod(script_path, st.st_mode | stat.S_IEXEC)
+            self._hook_script_path = script_path
+            return script_path
+
+        raise FileNotFoundError(f"Hook handler script not found at {script_path}")
 
     def install_hooks(self, force: bool = False) -> bool:
         """
@@ -208,25 +359,44 @@ main "$@"
         try:
             self.logger.info("Starting hook installation...")
 
-            # Create directories
+            # Check Claude Code version compatibility
+            is_compatible, version_message = self.is_version_compatible()
+            self.logger.info(version_message)
+
+            if not is_compatible:
+                self.logger.warning(
+                    "Claude Code version is incompatible with hook monitoring. "
+                    "Skipping hook installation to avoid configuration errors."
+                )
+                print(f"\n[Warning] {version_message}")
+                print(
+                    "Hook-based monitoring features will be disabled. "
+                    "The dashboard and other features will still work without real-time monitoring."
+                )
+                return False
+
+            # Create Claude directory (hooks_dir no longer needed)
             self.claude_dir.mkdir(exist_ok=True)
-            self.hooks_dir.mkdir(exist_ok=True)
 
-            # Install smart hook script
-            hook_script_path = self.hooks_dir / "claude-mpm-hook.sh"
-            if hook_script_path.exists() and not force:
+            # Get the deployment-root hook script path
+            try:
+                hook_script_path = self.get_hook_script_path()
                 self.logger.info(
-                    "Hook script already exists. Use --force to overwrite."
+                    f"Using deployment-root hook script: {hook_script_path}"
                 )
-            else:
-                self._install_smart_hook_script(hook_script_path)
+            except FileNotFoundError as e:
+                self.logger.error(f"Failed to locate hook script: {e}")
+                return False
 
-            # Update Claude settings
+            # Update Claude settings to use deployment-root script
             self._update_claude_settings(hook_script_path)
 
             # Install commands if available
             self._install_commands()
 
+            # Clean up old deployed scripts if they exist
+            self._cleanup_old_deployment()
+
             self.logger.info("Hook installation completed successfully!")
             return True
 
@@ -234,61 +404,100 @@ main "$@"
             self.logger.error(f"Hook installation failed: {e}")
             return False
 
-    def _install_smart_hook_script(self, hook_script_path: Path) -> None:
-        """Install the smart hook script that dynamically finds claude-mpm."""
-        self.logger.info(f"Installing smart hook script to {hook_script_path}")
+    def _cleanup_old_deployment(self) -> None:
+        """Clean up old deployed hook scripts if they exist."""
+        old_script = self.hooks_dir / "claude-mpm-hook.sh"
+        if old_script.exists():
+            try:
+                old_script.unlink()
+                self.logger.info(f"Removed old deployed script: {old_script}")
+            except Exception as e:
+                self.logger.warning(f"Could not remove old script {old_script}: {e}")
 
-        # Write the smart hook script
-        with open(hook_script_path, "w") as f:
-            f.write(self.SMART_HOOK_SCRIPT)
+        # Clean up hooks directory if empty
+        if self.hooks_dir.exists() and not any(self.hooks_dir.iterdir()):
+            try:
+                self.hooks_dir.rmdir()
+                self.logger.info(f"Removed empty hooks directory: {self.hooks_dir}")
+            except Exception as e:
+                self.logger.debug(f"Could not remove hooks directory: {e}")
+
+    def _cleanup_old_settings(self) -> None:
+        """Remove hooks from old settings.json file if present."""
+        if not self.old_settings_file.exists():
+            return
+
+        try:
+            with open(self.old_settings_file) as f:
+                old_settings = json.load(f)
 
-        # Make it executable
-        st = os.stat(hook_script_path)
-        os.chmod(hook_script_path, st.st_mode | stat.S_IEXEC)
+            # Remove hooks section if present
+            if "hooks" in old_settings:
+                del old_settings["hooks"]
+                self.logger.info(f"Removing hooks from {self.old_settings_file}")
 
-        self.logger.info("Smart hook script installed and made executable")
+                # Write back the cleaned settings
+                with open(self.old_settings_file, "w") as f:
+                    json.dump(old_settings, f, indent=2)
+
+                self.logger.info(f"Cleaned up hooks from {self.old_settings_file}")
+        except Exception as e:
+            self.logger.warning(f"Could not clean up old settings file: {e}")
 
     def _update_claude_settings(self, hook_script_path: Path) -> None:
         """Update Claude settings to use the installed hook."""
         self.logger.info("Updating Claude settings...")
 
-        # Load existing settings or create new
+        # Load existing settings.json or create new
         if self.settings_file.exists():
             with open(self.settings_file) as f:
                 settings = json.load(f)
-            self.logger.info("Found existing Claude settings")
+            self.logger.info(f"Found existing Claude settings at {self.settings_file}")
         else:
             settings = {}
-            self.logger.info("Creating new Claude settings")
+            self.logger.info(f"Creating new Claude settings at {self.settings_file}")
 
-        # Configure hooks
-        hook_config = {
-            "matcher": "*",
-            "hooks": [{"type": "command", "command": str(hook_script_path.absolute())}],
-        }
+        # Preserve existing permissions and mcpServers if present
+        if "permissions" not in settings:
+            settings["permissions"] = {"allow": []}
+        if "enableAllProjectMcpServers" not in settings:
+            settings["enableAllProjectMcpServers"] = False
 
-        # Update settings
+        # Update hooks section
         if "hooks" not in settings:
             settings["hooks"] = {}
 
-        # Add hooks for all event types
-        event_types = [
-            "UserPromptSubmit",
-            "PreToolUse",
-            "PostToolUse",
-            "Stop",
-            "SubagentStop",
-        ]
-
-        for event_type in event_types:
-            settings["hooks"][event_type] = [hook_config]
-
-        # Write settings
+        # Hook configuration for each event type
+        hook_command = {"type": "command", "command": str(hook_script_path.absolute())}
+
+        # Tool-related events need a matcher string
+        tool_events = ["PreToolUse", "PostToolUse"]
+        for event_type in tool_events:
+            settings["hooks"][event_type] = [
+                {
+                    "matcher": "*",  # String value to match all tools
+                    "hooks": [hook_command],
+                }
+            ]
+
+        # Non-tool events don't need a matcher
+        non_tool_events = ["UserPromptSubmit", "Stop", "SubagentStop", "SubagentStart"]
+        for event_type in non_tool_events:
+            settings["hooks"][event_type] = [
+                {
+                    "hooks": [hook_command],
+                }
+            ]
+
+        # Write settings to settings.json
         with open(self.settings_file, "w") as f:
             json.dump(settings, f, indent=2)
 
         self.logger.info(f"Updated Claude settings at {self.settings_file}")
 
+        # Clean up hooks from old settings.json if present
+        self._cleanup_old_settings()
+
     def _install_commands(self) -> None:
         """Install custom commands for Claude Code."""
         # Find commands directory in the package
@@ -322,14 +531,23 @@ main "$@"
         """
         issues = []
 
-        # Check hook script exists
-        hook_script_path = self.hooks_dir / "claude-mpm-hook.sh"
-        if not hook_script_path.exists():
-            issues.append(f"Hook script not found at {hook_script_path}")
+        # Check version compatibility first
+        is_compatible, version_message = self.is_version_compatible()
+        if not is_compatible:
+            issues.append(version_message)
+            # If version is incompatible, skip other checks as hooks shouldn't be installed
+            return False, issues
 
-        # Check hook script is executable
-        elif not os.access(hook_script_path, os.X_OK):
-            issues.append(f"Hook script is not executable: {hook_script_path}")
+        # Check hook script exists at deployment root
+        try:
+            hook_script_path = self.get_hook_script_path()
+            if not hook_script_path.exists():
+                issues.append(f"Hook script not found at {hook_script_path}")
+            # Check hook script is executable
+            elif not os.access(hook_script_path, os.X_OK):
+                issues.append(f"Hook script is not executable: {hook_script_path}")
+        except FileNotFoundError as e:
+            issues.append(str(e))
 
         # Check Claude settings
         if not self.settings_file.exists():
@@ -343,7 +561,13 @@ main "$@"
                     issues.append("No hooks configured in Claude settings")
                 else:
                     # Check for required event types
-                    required_events = ["Stop", "SubagentStop"]
+                    required_events = [
+                        "Stop",
+                        "SubagentStop",
+                        "SubagentStart",
+                        "PreToolUse",
+                        "PostToolUse",
+                    ]
                     for event in required_events:
                         if event not in settings["hooks"]:
                             issues.append(
@@ -372,47 +596,59 @@ main "$@"
         try:
             self.logger.info("Uninstalling hooks...")
 
-            # Remove hook script
-            hook_script_path = self.hooks_dir / "claude-mpm-hook.sh"
-            if hook_script_path.exists():
-                hook_script_path.unlink()
-                self.logger.info(f"Removed hook script: {hook_script_path}")
-
-            # Remove from Claude settings
-            if self.settings_file.exists():
-                with open(self.settings_file) as f:
-                    settings = json.load(f)
-
-                if "hooks" in settings:
-                    # Remove claude-mpm hooks
-                    for event_type in list(settings["hooks"].keys()):
-                        hooks = settings["hooks"][event_type]
-                        # Filter out claude-mpm hooks
-                        filtered_hooks = [
-                            h
-                            for h in hooks
-                            if not (
-                                isinstance(h, dict)
-                                and h.get("hooks", [{}])[0]
-                                .get("command", "")
-                                .endswith("claude-mpm-hook.sh")
-                            )
-                        ]
-
-                        if filtered_hooks:
-                            settings["hooks"][event_type] = filtered_hooks
-                        else:
-                            del settings["hooks"][event_type]
+            # Clean up old deployed scripts if they still exist
+            old_script = self.hooks_dir / "claude-mpm-hook.sh"
+            if old_script.exists():
+                old_script.unlink()
+                self.logger.info(f"Removed old deployed script: {old_script}")
 
-                    # Clean up empty hooks section
-                    if not settings["hooks"]:
-                        del settings["hooks"]
+            # Remove from Claude settings (both old and new locations)
+            for settings_path in [self.settings_file, self.old_settings_file]:
+                if settings_path.exists():
+                    with open(settings_path) as f:
+                        settings = json.load(f)
 
-                    # Write back settings
-                    with open(self.settings_file, "w") as f:
-                        json.dump(settings, f, indent=2)
-
-                    self.logger.info("Removed hooks from Claude settings")
+                    if "hooks" in settings:
+                        # Remove claude-mpm hooks
+                        for event_type in list(settings["hooks"].keys()):
+                            hooks = settings["hooks"][event_type]
+                            # Filter out claude-mpm hooks
+                            filtered_hooks = []
+                            for h in hooks:
+                                # Check if this is a claude-mpm hook
+                                is_claude_mpm = False
+                                if isinstance(h, dict) and "hooks" in h:
+                                    # Check each hook command in the hooks array
+                                    for hook_cmd in h.get("hooks", []):
+                                        if (
+                                            isinstance(hook_cmd, dict)
+                                            and hook_cmd.get("type") == "command"
+                                        ):
+                                            cmd = hook_cmd.get("command", "")
+                                            if (
+                                                "claude-hook-handler.sh" in cmd
+                                                or cmd.endswith("claude-mpm-hook.sh")
+                                            ):
+                                                is_claude_mpm = True
+                                                break
+
+                                if not is_claude_mpm:
+                                    filtered_hooks.append(h)
+
+                            if filtered_hooks:
+                                settings["hooks"][event_type] = filtered_hooks
+                            else:
+                                del settings["hooks"][event_type]
+
+                        # Clean up empty hooks section
+                        if not settings["hooks"]:
+                            del settings["hooks"]
+
+                        # Write back settings
+                        with open(settings_path, "w") as f:
+                            json.dump(settings, f, indent=2)
+
+                        self.logger.info(f"Removed hooks from {settings_path}")
 
             self.logger.info("Hook uninstallation completed")
             return True
@@ -428,28 +664,65 @@ main "$@"
         Returns:
             Dictionary with status information
         """
+        # Check version compatibility
+        claude_version = self.get_claude_version()
+        is_compatible, version_message = self.is_version_compatible()
+
         is_valid, issues = self.verify_hooks()
 
-        hook_script_path = self.hooks_dir / "claude-mpm-hook.sh"
+        # Try to get deployment-root script path
+        try:
+            hook_script_path = self.get_hook_script_path()
+            hook_script_str = str(hook_script_path)
+            script_exists = hook_script_path.exists()
+        except FileNotFoundError:
+            hook_script_str = None
+            script_exists = False
 
         status = {
-            "installed": hook_script_path.exists(),
+            "installed": script_exists and self.settings_file.exists(),
             "valid": is_valid,
             "issues": issues,
-            "hook_script": str(hook_script_path) if hook_script_path.exists() else None,
+            "hook_script": hook_script_str,
             "settings_file": (
                 str(self.settings_file) if self.settings_file.exists() else None
             ),
+            "claude_version": claude_version,
+            "version_compatible": is_compatible,
+            "version_message": version_message,
+            "deployment_type": "deployment-root",  # New field to indicate new architecture
         }
 
         # Check Claude settings for hook configuration
+        # Check both settings files to understand current state
+        configured_in_local = False
+
         if self.settings_file.exists():
             try:
                 with open(self.settings_file) as f:
                     settings = json.load(f)
                     if "hooks" in settings:
                         status["configured_events"] = list(settings["hooks"].keys())
+                        configured_in_local = True
             except:
                 pass
 
+        # Also check old settings file
+        if self.old_settings_file.exists():
+            try:
+                with open(self.old_settings_file) as f:
+                    old_settings = json.load(f)
+                    if "hooks" in old_settings:
+                        status["old_file_has_hooks"] = True
+                        if not configured_in_local:
+                            status["warning"] = (
+                                "Hooks found in settings.local.json but Claude Code reads from settings.json"
+                            )
+            except:
+                pass
+
+        status["settings_location"] = (
+            "settings.json" if configured_in_local else "not configured"
+        )
+
         return status