claude-mpm 4.0.19__py3-none-any.whl → 4.0.22__py3-none-any.whl

claude_mpm/cli/commands/mcp_command_router.py

@@ -5,6 +5,8 @@ Extracted from mcp.py to reduce complexity and improve maintainability.
 """
 
 import asyncio
+import os
+import sys
 from typing import Any
 
 from ...constants import MCPCommands
@@ -43,6 +45,9 @@ class MCPCommandRouter:
         elif args.mcp_command == MCPCommands.CONFIG.value:
             return self._manage_config(args)
 
+        elif args.mcp_command == MCPCommands.SERVER.value:
+            return self._run_server(args)
+
         elif args.mcp_command == "cleanup":
             return self._cleanup_locks(args)
 
@@ -115,11 +120,91 @@ class MCPCommandRouter:
         handler = MCPServerCommands(self.logger)
         return handler.cleanup_locks(args)
 
+    def _run_server(self, args) -> int:
+        """Run server command handler - direct server execution."""
+        try:
+            self.logger.info("Starting MCP server directly via CLI command")
+
+            # Import the server components
+            from claude_mpm.services.mcp_gateway.server.stdio_server import SimpleMCPServer
+
+            # Create server instance
+            server = SimpleMCPServer(name="claude-mpm-gateway", version="1.0.0")
+
+            if args.test:
+                self.logger.info("Running in test mode")
+                print("🧪 Starting MCP server in test mode...", file=sys.stderr)
+                print("   This will run the server with stdio communication.", file=sys.stderr)
+                print("   Press Ctrl+C to stop.\n", file=sys.stderr)
+
+            # Run the server, handling event loop properly
+            try:
+                # Check if there's already an event loop running
+                loop = asyncio.get_running_loop()
+                # If we get here, there's already a loop running
+                # We need to run in a subprocess to avoid conflicts
+                import subprocess
+                import json
+
+                # Create a simple script to run the server
+                script_content = f'''
+import asyncio
+import sys
+import os
+sys.path.insert(0, "{os.path.join(os.path.dirname(__file__), '..', '..', '..')}")
+
+async def main():
+    from claude_mpm.services.mcp_gateway.server.stdio_server import SimpleMCPServer
+    server = SimpleMCPServer(name="claude-mpm-gateway", version="1.0.0")
+    await server.run()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+'''
+
+                # Write the script to a temporary file
+                import tempfile
+                with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+                    f.write(script_content)
+                    temp_script = f.name
+
+                try:
+                    # Run the server in a subprocess
+                    result = subprocess.run([sys.executable, temp_script])
+                    return result.returncode
+                finally:
+                    # Clean up the temporary file
+                    os.unlink(temp_script)
+
+            except RuntimeError:
+                # No event loop running, we can use asyncio.run
+                async def run_async():
+                    await server.run()
+
+                asyncio.run(run_async())
+            return 0
+
+        except ImportError as e:
+            self.logger.error(f"Failed to import MCP server: {e}")
+            print(f"❌ Error: Could not import MCP server components: {e}", file=sys.stderr)
+            print("\nMake sure the MCP package is installed:", file=sys.stderr)
+            print("  pip install mcp", file=sys.stderr)
+            return 1
+        except KeyboardInterrupt:
+            self.logger.info("MCP server interrupted")
+            print("\n🛑 MCP server stopped", file=sys.stderr)
+            return 0
+        except Exception as e:
+            self.logger.error(f"Server error: {e}")
+            print(f"❌ Error running server: {e}", file=sys.stderr)
+            return 1
+
     def _show_help(self):
         """Show available MCP commands."""
         print("\nAvailable MCP commands:")
         print("  install  - Install and configure MCP Gateway")
         print("  start    - Start the MCP Gateway server (stdio mode)")
+        print("  server   - Run the MCP Gateway server directly")
         print("  stop     - Stop the MCP Gateway server")
         print("  status   - Show server and tool status")
         print("  tools    - List and manage registered tools")
@@ -132,8 +217,9 @@ class MCPCommandRouter:
         print("\nExamples:")
         print("  claude-mpm mcp install")
         print("  claude-mpm mcp start                  # Run server (for Claude Code)")
+        print("  claude-mpm mcp server                 # Run server directly")
+        print("  claude-mpm mcp server --test          # Test mode with debug output")
         print("  claude-mpm mcp start --instructions    # Show setup instructions")
-        print("  claude-mpm mcp start --test           # Test mode with debug output")
         print("  claude-mpm mcp tools")
         print("  claude-mpm mcp register my-tool")
         print("  claude-mpm mcp test my-tool")

claude_mpm/cli/commands/mcp_install_commands.py

@@ -18,17 +18,17 @@ class MCPInstallCommands:
 
     def install_gateway(self, args):
         """Install and configure MCP gateway.
-        
+
         WHY: This command installs the MCP package dependencies and configures
-        Claude Desktop to use the MCP gateway server.
-        
+        Claude Desktop to use the MCP gateway server directly via the CLI command.
+
         DESIGN DECISION: We handle both package installation and configuration
-        in one command for user convenience.
+        in one command for user convenience, using the new direct CLI approach.
         """
         self.logger.info("MCP gateway installation command called")
         print("📦 Installing and Configuring MCP Gateway")
         print("=" * 50)
-        
+
         # Step 1: Install MCP package if needed
         print("\n1️⃣  Checking MCP package installation...")
         try:
@@ -43,35 +43,216 @@ class MCPInstallCommands:
                 print(f"❌ Error installing MCP package: {e}")
                 print("\nPlease install manually with: pip install mcp")
                 return 1
-        
-        # Step 2: Run the configuration script
+
+        # Step 2: Configure Claude Desktop with the new CLI command
         print("\n2️⃣  Configuring Claude Desktop...")
-        project_root = Path(__file__).parent.parent.parent.parent.parent
-        config_script = project_root / "scripts" / "configure_mcp_server.py"
-        
-        if not config_script.exists():
-            print(f"⚠️  Configuration script not found at {config_script}")
-            print("\nPlease configure manually. See:")
-            print("  claude-mpm mcp start --instructions")
-            return 1
-        
         try:
-            result = subprocess.run(
-                [sys.executable, str(config_script)],
-                cwd=str(project_root)
-            )
-            
-            if result.returncode == 0:
+            success = self._configure_claude_desktop(args.force)
+            if success:
                 print("✅ Configuration completed successfully")
                 print("\n🎉 MCP Gateway is ready to use!")
                 print("\nNext steps:")
                 print("1. Restart Claude Desktop")
-                print("2. Check process status: python scripts/check_mcp_processes.py")
+                print("2. Test the server: claude-mpm mcp server --test")
+                print("3. Check status: claude-mpm mcp status")
                 return 0
             else:
-                print("❌ Configuration script failed")
+                print("❌ Configuration failed")
                 return 1
-                
+
         except Exception as e:
-            print(f"❌ Error running configuration: {e}")
+            print(f"❌ Error during configuration: {e}")
             return 1
+
+    def _configure_claude_desktop(self, force=False):
+        """Configure Claude Desktop to use the MCP gateway via CLI command.
+
+        Args:
+            force: Whether to overwrite existing configuration
+
+        Returns:
+            bool: True if configuration was successful
+        """
+        import json
+        import platform
+        from pathlib import Path
+        from datetime import datetime
+
+        # Determine Claude Desktop config path based on platform
+        config_path = self._get_claude_config_path()
+        if not config_path:
+            print("❌ Could not determine Claude Desktop configuration path")
+            return False
+
+        print(f"   Configuration path: {config_path}")
+
+        # Load existing configuration or create new one
+        config = self._load_or_create_config(config_path, force)
+        if config is None:
+            return False
+
+        # Configure the claude-mpm-gateway server using the CLI command
+        claude_mpm_path = self._find_claude_mpm_executable()
+        if not claude_mpm_path:
+            print("❌ Could not find claude-mpm executable")
+            return False
+
+        mcp_config = {
+            "command": claude_mpm_path,
+            "args": ["mcp", "server"],
+            "env": {
+                "PYTHONPATH": str(Path(__file__).parent.parent.parent.parent),
+                "MCP_MODE": "production"
+            }
+        }
+
+        # Update configuration
+        if "mcpServers" not in config:
+            config["mcpServers"] = {}
+
+        config["mcpServers"]["claude-mpm-gateway"] = mcp_config
+
+        print("\n✅ Configured claude-mpm-gateway server:")
+        print(f"   Command: {mcp_config['command']}")
+        print(f"   Args: {mcp_config['args']}")
+        print(f"   Environment variables: {list(mcp_config['env'].keys())}")
+
+        # Save configuration
+        return self._save_config(config, config_path)
+
+    def _get_claude_config_path(self):
+        """Get the Claude Desktop configuration file path based on platform.
+
+        Returns:
+            Path or None: Path to Claude Desktop config file
+        """
+        import platform
+        from pathlib import Path
+
+        system = platform.system()
+
+        if system == "Darwin":  # macOS
+            return Path.home() / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json"
+        elif system == "Windows":
+            return Path.home() / "AppData" / "Roaming" / "Claude" / "claude_desktop_config.json"
+        elif system == "Linux":
+            return Path.home() / ".config" / "Claude" / "claude_desktop_config.json"
+        else:
+            print(f"❌ Unsupported platform: {system}")
+            return None
+
+    def _find_claude_mpm_executable(self):
+        """Find the claude-mpm executable path.
+
+        Returns:
+            str or None: Path to claude-mpm executable
+        """
+        import shutil
+        import sys
+
+        # Try to find claude-mpm in PATH
+        claude_mpm_path = shutil.which("claude-mpm")
+        if claude_mpm_path:
+            return claude_mpm_path
+
+        # If not in PATH, try using python -m claude_mpm
+        # This works if claude-mpm is installed in the current Python environment
+        try:
+            import claude_mpm
+            return f"{sys.executable} -m claude_mpm"
+        except ImportError:
+            pass
+
+        # Last resort: try relative to current script
+        project_root = Path(__file__).parent.parent.parent.parent.parent
+        local_script = project_root / "scripts" / "claude-mpm"
+        if local_script.exists():
+            return str(local_script)
+
+        return None
+
+    def _load_or_create_config(self, config_path, force=False):
+        """Load existing configuration or create a new one.
+
+        Args:
+            config_path: Path to configuration file
+            force: Whether to overwrite existing configuration
+
+        Returns:
+            dict or None: Configuration dictionary
+        """
+        import json
+        from datetime import datetime
+
+        config = {}
+
+        if config_path.exists():
+            if not force:
+                # Check if claude-mpm-gateway already exists
+                try:
+                    with open(config_path, 'r') as f:
+                        existing_config = json.load(f)
+
+                    if (existing_config.get("mcpServers", {}).get("claude-mpm-gateway") and
+                        not force):
+                        print("⚠️  claude-mpm-gateway is already configured")
+                        response = input("Do you want to overwrite it? (y/N): ").strip().lower()
+                        if response not in ['y', 'yes']:
+                            print("❌ Configuration cancelled")
+                            return None
+
+                    config = existing_config
+
+                except (json.JSONDecodeError, IOError) as e:
+                    print(f"⚠️  Error reading existing config: {e}")
+                    print("Creating backup and starting fresh...")
+
+                    # Create backup
+                    backup_path = config_path.with_suffix(f'.backup.{datetime.now().strftime("%Y%m%d_%H%M%S")}.json')
+                    try:
+                        config_path.rename(backup_path)
+                        print(f"   Backup created: {backup_path}")
+                    except Exception as backup_error:
+                        print(f"   Warning: Could not create backup: {backup_error}")
+            else:
+                # Force mode - create backup but proceed
+                try:
+                    with open(config_path, 'r') as f:
+                        existing_config = json.load(f)
+                    config = existing_config
+                    print("   Force mode: Overwriting existing configuration")
+                except:
+                    pass  # File doesn't exist or is invalid, start fresh
+
+        # Ensure mcpServers section exists
+        if "mcpServers" not in config:
+            config["mcpServers"] = {}
+
+        return config
+
+    def _save_config(self, config, config_path):
+        """Save configuration to file.
+
+        Args:
+            config: Configuration dictionary
+            config_path: Path to save configuration
+
+        Returns:
+            bool: True if successful
+        """
+        import json
+
+        try:
+            # Ensure directory exists
+            config_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Write configuration with nice formatting
+            with open(config_path, 'w') as f:
+                json.dump(config, f, indent=2)
+
+            print(f"\n✅ Configuration saved to {config_path}")
+            return True
+
+        except Exception as e:
+            print(f"❌ Error saving configuration: {e}")
+            return False

claude_mpm/cli/commands/memory.py

@@ -280,7 +280,12 @@ def _show_basic_status(memory_manager):
         print(f"   Expected location: {memory_dir}")
         return
 
-    memory_files = list(memory_dir.glob("*_agent.md"))
+    # Support both old and new formats
+    memory_files = list(memory_dir.glob("*_memories.md"))
+    # Also check for old formats for backward compatibility
+    memory_files.extend(memory_dir.glob("*_agent.md"))
+    memory_files.extend([f for f in memory_dir.glob("*.md") 
+                        if f.name != "README.md" and not f.name.endswith("_memories.md") and not f.name.endswith("_agent.md")])
 
     if not memory_files:
         print("📭 No memory files found")
@@ -296,7 +301,13 @@ def _show_basic_status(memory_manager):
         size_kb = stat.st_size / 1024
         total_size += stat.st_size
 
-        agent_id = file_path.stem.replace("_agent", "")
+        # Extract agent name from various formats
+        if file_path.name.endswith("_memories.md"):
+            agent_id = file_path.stem[:-9]  # Remove "_memories"
+        elif file_path.name.endswith("_agent.md"):
+            agent_id = file_path.stem[:-6]  # Remove "_agent"
+        else:
+            agent_id = file_path.stem
         print(f"   {agent_id}: {size_kb:.1f} KB")
 
     print(f"💾 Total size: {total_size / 1024:.1f} KB")
@@ -395,7 +406,12 @@ def _clean_memory(args, memory_manager):
         print("📁 No memory directory found - nothing to clean")
         return
 
-    memory_files = list(memory_dir.glob("*_agent.md"))
+    # Support both old and new formats
+    memory_files = list(memory_dir.glob("*_memories.md"))
+    # Also check for old formats for backward compatibility
+    memory_files.extend(memory_dir.glob("*_agent.md"))
+    memory_files.extend([f for f in memory_dir.glob("*.md") 
+                        if f.name != "README.md" and not f.name.endswith("_memories.md") and not f.name.endswith("_agent.md")])
     if not memory_files:
         print("📭 No memory files found - nothing to clean")
         return
@@ -651,7 +667,12 @@ def _show_all_agent_memories(format_type, memory_manager):
         print("📁 No memory directory found")
         return
 
-    memory_files = list(memory_dir.glob("*_agent.md"))
+    # Support both old and new formats
+    memory_files = list(memory_dir.glob("*_memories.md"))
+    # Also check for old formats for backward compatibility
+    memory_files.extend(memory_dir.glob("*_agent.md"))
+    memory_files.extend([f for f in memory_dir.glob("*.md") 
+                        if f.name != "README.md" and not f.name.endswith("_memories.md") and not f.name.endswith("_agent.md")])
     if not memory_files:
         print("📭 No agent memories found")
         return
@@ -664,7 +685,13 @@ def _show_all_agent_memories(format_type, memory_manager):
 
     # Load all agent memories
     for file_path in sorted(memory_files):
-        agent_id = file_path.stem.replace("_agent", "")
+        # Extract agent name from various formats
+        if file_path.name.endswith("_memories.md"):
+            agent_id = file_path.stem[:-9]  # Remove "_memories"
+        elif file_path.name.endswith("_agent.md"):
+            agent_id = file_path.stem[:-6]  # Remove "_agent"
+        else:
+            agent_id = file_path.stem
         try:
             memory_content = memory_manager.load_agent_memory(agent_id)
             if memory_content:

claude_mpm/cli/commands/run.py

@@ -33,7 +33,8 @@ def filter_claude_mpm_args(claude_args):
     flags and will error if they're passed through.
 
     DESIGN DECISION: We maintain a list of known claude-mpm flags to filter out,
-    ensuring only genuine Claude CLI arguments are passed through.
+    ensuring only genuine Claude CLI arguments are passed through. We also remove
+    the '--' separator that argparse uses, as it's not needed by Claude CLI.
 
     Args:
         claude_args: List of arguments captured by argparse.REMAINDER
@@ -83,6 +84,11 @@ def filter_claude_mpm_args(claude_args):
     while i < len(claude_args):
         arg = claude_args[i]
 
+        # Skip the '--' separator used by argparse - Claude doesn't need it
+        if arg == "--":
+            i += 1
+            continue
+
         # Check if this is a claude-mpm flag
         if arg in mpm_flags:
             # Skip this flag
@@ -379,16 +385,37 @@ def run_session(args):
     # Create simple runner
     enable_tickets = not args.no_tickets
     raw_claude_args = getattr(args, "claude_args", []) or []
+    
+    # Add --resume to claude_args if the flag is set
+    resume_flag_present = getattr(args, "resume", False)
+    if resume_flag_present:
+        logger.info("📌 --resume flag detected in args")
+        if "--resume" not in raw_claude_args:
+            raw_claude_args = ["--resume"] + raw_claude_args
+            logger.info("✅ Added --resume to claude_args")
+        else:
+            logger.info("ℹ️ --resume already in claude_args")
+    
     # Filter out claude-mpm specific flags before passing to Claude CLI
+    logger.debug(f"Pre-filter claude_args: {raw_claude_args}")
     claude_args = filter_claude_mpm_args(raw_claude_args)
     monitor_mode = getattr(args, "monitor", False)
 
-    # Debug logging for argument filtering
+    # Enhanced debug logging for argument filtering
     if raw_claude_args != claude_args:
-        logger.debug(
-            f"Filtered claude-mpm args: {set(raw_claude_args) - set(claude_args)}"
-        )
-        logger.debug(f"Passing to Claude CLI: {claude_args}")
+        filtered_out = list(set(raw_claude_args) - set(claude_args))
+        logger.debug(f"Filtered out MPM-specific args: {filtered_out}")
+    
+    logger.info(f"Final claude_args being passed: {claude_args}")
+    
+    # Explicit verification of --resume flag
+    if resume_flag_present:
+        if "--resume" in claude_args:
+            logger.info("✅ CONFIRMED: --resume flag will be passed to Claude CLI")
+        else:
+            logger.error("❌ WARNING: --resume flag was filtered out! This is a bug!")
+            logger.error(f"   Original args: {raw_claude_args}")
+            logger.error(f"   Filtered args: {claude_args}")
 
     # Use the specified launch method (default: exec)
     launch_method = getattr(args, "launch_method", "exec")

claude_mpm/cli/parsers/base_parser.py

@@ -187,6 +187,11 @@ def add_top_level_run_arguments(parser: argparse.ArgumentParser) -> None:
         const="last",
         help="Resume an MPM session (last session if no ID specified, or specific session ID)",
     )
+    run_group.add_argument(
+        "--resume",
+        action="store_true",
+        help="Pass --resume flag to Claude Desktop to resume the last conversation",
+    )
     run_group.add_argument(
         "--force",
         action="store_true",

claude_mpm/cli/parsers/mcp_parser.py

@@ -149,4 +149,27 @@ def add_mcp_subparser(subparsers) -> argparse.ArgumentParser:
         help="Configuration action (default: view)",
     )
 
+    # MCP Server command (direct server execution)
+    server_mcp_parser = mcp_subparsers.add_parser(
+        MCPCommands.SERVER.value, help="Run the MCP Gateway server directly"
+    )
+    server_mcp_parser.add_argument(
+        "--mode",
+        choices=["stdio", "standalone"],
+        default="stdio",
+        help="Server mode: stdio for Claude integration, standalone for testing (default: stdio)",
+    )
+    server_mcp_parser.add_argument(
+        "--port",
+        type=int,
+        default=8766,
+        help="Port for standalone mode (default: 8766)",
+    )
+    server_mcp_parser.add_argument(
+        "--config-file", type=Path, help="Path to MCP configuration file"
+    )
+    server_mcp_parser.add_argument(
+        "--test", action="store_true", help="Run in test mode with debug output"
+    )
+
     return mcp_parser

claude_mpm/cli/parsers/run_parser.py

@@ -75,6 +75,11 @@ def add_run_arguments(parser: argparse.ArgumentParser) -> None:
         const="last",
         help="Resume an MPM session (last session if no ID specified, or specific session ID)",
     )
+    run_group.add_argument(
+        "--resume",
+        action="store_true",
+        help="Pass --resume flag to Claude Desktop to resume the last conversation",
+    )
 
     # Dependency checking options
     dep_group = parser.add_argument_group("dependency options")

claude_mpm/cli/utils.py

@@ -132,11 +132,24 @@ def list_agent_versions_at_startup() -> None:
 
     WHY: Users want to see what agents are available when they start a session.
     This provides immediate feedback about the deployed agent environment.
+    
+    DESIGN DECISION: We suppress INFO logging during this call to avoid duplicate
+    initialization messages since the deployment service will be initialized again
+    later in the ClaudeRunner.
     """
-    agent_versions = get_agent_versions_display()
-    if agent_versions:
-        print(agent_versions)
-        print()  # Extra newline after the display
+    # Temporarily suppress INFO level logging to avoid duplicate initialization messages
+    import logging
+    original_level = logging.getLogger("claude_mpm").level
+    logging.getLogger("claude_mpm").setLevel(logging.WARNING)
+    
+    try:
+        agent_versions = get_agent_versions_display()
+        if agent_versions:
+            print(agent_versions)
+            print()  # Extra newline after the display
+    finally:
+        # Restore original logging level
+        logging.getLogger("claude_mpm").setLevel(original_level)
 
 
 def setup_logging(args) -> object:

claude_mpm/constants.py

@@ -125,6 +125,7 @@ class MCPCommands(str, Enum):
     REGISTER = "register"
     TEST = "test"
     CONFIG = "config"
+    SERVER = "server"
 
 
 class TicketCommands(str, Enum):

claude_mpm/core/base_service.py

@@ -120,7 +120,13 @@ class BaseService(LoggerMixin, ABC):
             container: Optional service container for dependency injection
         """
         self.name = name
-        self.config = Config(config or {}, config_path)
+        # Use singleton Config instance to prevent duplicate configuration loading
+        # Only pass config_path if it's different from what might already be loaded
+        if config_path:
+            self.config = Config(config or {}, config_path)
+        else:
+            # Use existing singleton instance without forcing reload
+            self.config = Config(config or {})
         self._enable_enhanced = enable_enhanced_features
         self._container = container
 
@@ -159,7 +165,7 @@ class BaseService(LoggerMixin, ABC):
 
         # Only log if not in quiet mode
         if not os.environ.get("CLAUDE_PM_QUIET_MODE", "").lower() == "true":
-            self.logger.info(f"Initialized {self.name} service")
+            self.logger.debug(f"Initialized {self.name} service")
 
     def _init_enhanced_features(self):
         """Initialize enhanced features when enabled."""