code-puppy 0.0.130__py3-none-any.whl → 0.0.132__py3-none-any.whl

code_puppy/command_line/mcp_commands.py

@@ -15,8 +15,9 @@ from rich.table import Table
 from rich.console import Console
 from rich.text import Text
 from rich.panel import Panel
-from rich.columns import Columns
 
+from code_puppy.state_management import is_tui_mode
+from code_puppy.messaging import emit_prompt
 from code_puppy.mcp.manager import get_mcp_manager, ServerInfo
 from code_puppy.mcp.managed_server import ServerConfig, ServerState
 from code_puppy.messaging import emit_info, emit_system_message
@@ -671,10 +672,8 @@ class MCPCommandHandler:
                     emit_info(f"Failed to add server '{name}'", message_group=group_id)
                     
             else:
-                # No arguments - launch interactive wizard
-                from code_puppy.mcp.config_wizard import run_add_wizard
-                
-                success = run_add_wizard()
+                # No arguments - launch interactive wizard with server templates
+                success = self._run_interactive_install_wizard(group_id)
                 
                 if success:
                     # Reload the agent to pick up new server
@@ -688,6 +687,398 @@ class MCPCommandHandler:
             logger.error(f"Error adding server: {e}")
             emit_info(f"Failed to add server: {e}", message_group=group_id)
     
+    def _run_interactive_install_wizard(self, group_id: str) -> bool:
+        """Run the interactive MCP server installation wizard using server templates."""
+        try:
+            from code_puppy.mcp.server_registry_catalog import catalog
+            from code_puppy.mcp.system_tools import detector
+            from code_puppy.messaging import emit_prompt
+            import os
+            import json
+            
+            emit_info("🧙 Interactive MCP Server Installation Wizard", message_group=group_id)
+            emit_info("", message_group=group_id)
+            
+            # Step 1: Browse and select server
+            selected_server = self._interactive_server_selection(group_id)
+            if not selected_server:
+                return False
+            
+            # Step 2: Get custom server name
+            server_name = self._interactive_get_server_name(selected_server, group_id)
+            if not server_name:
+                return False
+            
+            # Step 3: Handle requirements and configuration
+            success = self._interactive_configure_server(selected_server, server_name, group_id)
+            return success
+            
+        except ImportError:
+            emit_info("Server catalog not available, falling back to basic wizard", message_group=group_id)
+            # Fall back to the old wizard
+            from code_puppy.mcp.config_wizard import run_add_wizard
+            return run_add_wizard(group_id)
+        except Exception as e:
+            emit_info(f"Installation wizard failed: {e}", message_group=group_id)
+            return False
+    
+    def _interactive_server_selection(self, group_id: str):
+        """Interactive server selection from catalog."""
+        from code_puppy.mcp.server_registry_catalog import catalog
+        from code_puppy.messaging import emit_prompt
+        
+        while True:
+            emit_info("📦 Available MCP Servers:", message_group=group_id)
+            emit_info("", message_group=group_id)
+            
+            # Show popular servers first
+            popular = catalog.get_popular(5)
+            if popular:
+                emit_info("[bold]Popular Servers:[/bold]", message_group=group_id)
+                for i, server in enumerate(popular):
+                    indicators = []
+                    if server.verified:
+                        indicators.append("✓")
+                    if server.popular:
+                        indicators.append("⭐")
+                    
+                    emit_info(f"  {i+1}. {server.display_name} {''.join(indicators)}", message_group=group_id)
+                    emit_info(f"     {server.description[:80]}...", message_group=group_id)
+                emit_info("", message_group=group_id)
+            
+            # Prompt for selection
+            choice = emit_prompt("Enter server number (1-5), 'search <term>' to search, or 'list' to see all categories: ")
+            
+            if not choice.strip():
+                if emit_prompt("Cancel installation? [y/N]: ").lower().startswith('y'):
+                    return None
+                continue
+            
+            choice = choice.strip()
+            
+            # Handle numeric selection
+            if choice.isdigit():
+                try:
+                    index = int(choice) - 1
+                    if 0 <= index < len(popular):
+                        return popular[index]
+                    else:
+                        emit_info("Invalid selection. Please try again.", message_group=group_id)
+                        continue
+                except ValueError:
+                    pass
+            
+            # Handle search
+            if choice.lower().startswith('search '):
+                search_term = choice[7:].strip()
+                results = catalog.search(search_term)
+                if results:
+                    emit_info(f"\n🔍 Search results for '{search_term}':", message_group=group_id)
+                    for i, server in enumerate(results[:10]):
+                        indicators = []
+                        if server.verified:
+                            indicators.append("✓")
+                        if server.popular:
+                            indicators.append("⭐")
+                        emit_info(f"  {i+1}. {server.display_name} {''.join(indicators)}", message_group=group_id)
+                        emit_info(f"     {server.description[:80]}...", message_group=group_id)
+                    
+                    selection = emit_prompt(f"\nSelect server (1-{min(len(results), 10)}): ")
+                    if selection.isdigit():
+                        try:
+                            index = int(selection) - 1
+                            if 0 <= index < len(results):
+                                return results[index]
+                        except ValueError:
+                            pass
+                else:
+                    emit_info(f"No servers found for '{search_term}'", message_group=group_id)
+                continue
+            
+            # Handle list categories
+            if choice.lower() == 'list':
+                categories = catalog.list_categories()
+                emit_info("\n📂 Categories:", message_group=group_id)
+                for i, category in enumerate(categories):
+                    servers_count = len(catalog.get_by_category(category))
+                    emit_info(f"  {i+1}. {category} ({servers_count} servers)", message_group=group_id)
+                
+                cat_choice = emit_prompt(f"\nSelect category (1-{len(categories)}): ")
+                if cat_choice.isdigit():
+                    try:
+                        index = int(cat_choice) - 1
+                        if 0 <= index < len(categories):
+                            category_servers = catalog.get_by_category(categories[index])
+                            emit_info(f"\n📦 {categories[index]} Servers:", message_group=group_id)
+                            for i, server in enumerate(category_servers):
+                                indicators = []
+                                if server.verified:
+                                    indicators.append("✓")
+                                if server.popular:
+                                    indicators.append("⭐")
+                                emit_info(f"  {i+1}. {server.display_name} {''.join(indicators)}", message_group=group_id)
+                                emit_info(f"     {server.description[:80]}...", message_group=group_id)
+                            
+                            server_choice = emit_prompt(f"\nSelect server (1-{len(category_servers)}): ")
+                            if server_choice.isdigit():
+                                try:
+                                    index = int(server_choice) - 1
+                                    if 0 <= index < len(category_servers):
+                                        return category_servers[index]
+                                except ValueError:
+                                    pass
+                    except ValueError:
+                        pass
+                continue
+            
+            emit_info("Invalid choice. Please try again.", message_group=group_id)
+    
+    def _interactive_get_server_name(self, selected_server, group_id: str) -> str:
+        """Get custom server name from user."""
+        from code_puppy.messaging import emit_prompt
+        
+        emit_info(f"\n🏷️  Server: {selected_server.display_name}", message_group=group_id)
+        emit_info(f"Description: {selected_server.description}", message_group=group_id)
+        emit_info("", message_group=group_id)
+        
+        while True:
+            name = emit_prompt(f"Enter custom name for this server [{selected_server.name}]: ").strip()
+            
+            if not name:
+                name = selected_server.name
+            
+            # Validate name
+            if not name.replace('-', '').replace('_', '').replace('.', '').isalnum():
+                emit_info("Name must contain only letters, numbers, hyphens, underscores, and dots", message_group=group_id)
+                continue
+            
+            # Check if name already exists
+            existing_server = self._find_server_id_by_name(name)
+            if existing_server:
+                override = emit_prompt(f"Server '{name}' already exists. Override it? [y/N]: ")
+                if not override.lower().startswith('y'):
+                    continue
+            
+            return name
+    
+    def _interactive_configure_server(self, selected_server, server_name: str, group_id: str) -> bool:
+        """Configure the server with requirements validation."""
+        from code_puppy.mcp.system_tools import detector
+        from code_puppy.messaging import emit_prompt
+        import os
+        import json
+        
+        requirements = selected_server.get_requirements()
+        
+        emit_info(f"\n⚙️  Configuring server: {server_name}", message_group=group_id)
+        emit_info("", message_group=group_id)
+        
+        # Step 1: Check system requirements
+        if not self._interactive_check_system_requirements(requirements, group_id):
+            return False
+        
+        # Step 2: Collect environment variables
+        env_vars = self._interactive_collect_env_vars(requirements, group_id)
+        
+        # Step 3: Collect command line arguments
+        cmd_args = self._interactive_collect_cmd_args(requirements, group_id)
+        
+        # Step 4: Show summary and confirm
+        if not self._interactive_confirm_installation(selected_server, server_name, env_vars, cmd_args, group_id):
+            return False
+        
+        # Step 5: Install the server
+        return self._interactive_install_server(selected_server, server_name, env_vars, cmd_args, group_id)
+    
+    def _interactive_check_system_requirements(self, requirements, group_id: str) -> bool:
+        """Check and validate system requirements."""
+        from code_puppy.mcp.system_tools import detector
+        
+        required_tools = requirements.required_tools
+        if not required_tools:
+            return True
+        
+        emit_info("🔧 Checking system requirements...", message_group=group_id)
+        
+        tool_status = detector.detect_tools(required_tools)
+        all_good = True
+        
+        for tool_name, tool_info in tool_status.items():
+            if tool_info.available:
+                status_text = f"✅ {tool_name}"
+                if tool_info.version:
+                    status_text += f" ({tool_info.version})"
+                emit_info(status_text, message_group=group_id)
+            else:
+                status_text = f"❌ {tool_name} - {tool_info.error or 'Not found'}"
+                emit_info(status_text, message_group=group_id)
+                
+                # Show installation suggestions
+                suggestions = detector.get_installation_suggestions(tool_name)
+                if suggestions:
+                    emit_info(f"   Install: {suggestions[0]}", message_group=group_id)
+                all_good = False
+        
+        if not all_good:
+            emit_info("", message_group=group_id)
+            cont = emit_prompt("Some tools are missing. Continue anyway? [y/N]: ")
+            if not cont.lower().startswith('y'):
+                emit_info("Installation cancelled", message_group=group_id)
+                return False
+        
+        emit_info("", message_group=group_id)
+        return True
+    
+    def _interactive_collect_env_vars(self, requirements, group_id: str) -> dict:
+        """Collect environment variables from user."""
+        from code_puppy.messaging import emit_prompt
+        import os
+        
+        env_vars = {}
+        required_env_vars = requirements.environment_vars
+        
+        if not required_env_vars:
+            return env_vars
+        
+        emit_info("🔐 Environment Variables:", message_group=group_id)
+        
+        for var in required_env_vars:
+            # Check if already set
+            current_value = os.environ.get(var, "")
+            
+            if current_value:
+                emit_info(f"✅ {var} (already set)", message_group=group_id)
+                env_vars[var] = current_value
+            else:
+                value = emit_prompt(f"📝 Enter value for {var}: ").strip()
+                if value:
+                    env_vars[var] = value
+                    # Set in current environment too
+                    os.environ[var] = value
+                else:
+                    emit_info(f"⚠️  {var} left empty", message_group=group_id)
+        
+        emit_info("", message_group=group_id)
+        return env_vars
+    
+    def _interactive_collect_cmd_args(self, requirements, group_id: str) -> dict:
+        """Collect command line arguments from user."""
+        from code_puppy.messaging import emit_prompt
+        
+        cmd_args = {}
+        required_args = requirements.command_line_args
+        
+        if not required_args:
+            return cmd_args
+        
+        emit_info("⚡ Command Line Arguments:", message_group=group_id)
+        
+        for arg_config in required_args:
+            name = arg_config.get("name", "")
+            prompt_text = arg_config.get("prompt", name)
+            default = arg_config.get("default", "")
+            required = arg_config.get("required", True)
+            
+            indicator = "⚡" if required else "🔧"
+            label = f"{indicator} {prompt_text}"
+            if not required:
+                label += " (optional)"
+            if default:
+                label += f" [{default}]"
+            
+            value = emit_prompt(f"{label}: ").strip()
+            
+            if not value and default:
+                value = default
+            
+            if value:
+                cmd_args[name] = value
+            elif required:
+                emit_info(f"⚠️  Required argument '{name}' left empty", message_group=group_id)
+        
+        emit_info("", message_group=group_id)
+        return cmd_args
+    
+    def _interactive_confirm_installation(self, selected_server, server_name: str, env_vars: dict, cmd_args: dict, group_id: str) -> bool:
+        """Show summary and confirm installation."""
+        from code_puppy.messaging import emit_prompt
+        
+        emit_info("📋 Installation Summary:", message_group=group_id)
+        emit_info(f"  Server: {selected_server.display_name}", message_group=group_id)
+        emit_info(f"  Name: {server_name}", message_group=group_id)
+        emit_info(f"  Type: {selected_server.type}", message_group=group_id)
+        
+        if env_vars:
+            emit_info(f"  Environment variables: {len(env_vars)} set", message_group=group_id)
+        
+        if cmd_args:
+            emit_info(f"  Command arguments: {len(cmd_args)} configured", message_group=group_id)
+        
+        emit_info("", message_group=group_id)
+        
+        confirm = emit_prompt("Install this server configuration? [Y/n]: ")
+        return not confirm.lower().startswith('n')
+    
+    def _interactive_install_server(self, selected_server, server_name: str, env_vars: dict, cmd_args: dict, group_id: str) -> bool:
+        """Actually install and register the server."""
+        try:
+            # Get server config with command line argument overrides
+            config_dict = selected_server.to_server_config(server_name, **cmd_args)
+            
+            # Update the config with actual environment variable values
+            if 'env' in config_dict:
+                for env_key, env_value in config_dict['env'].items():
+                    # If it's a placeholder like $GITHUB_TOKEN, replace with actual value
+                    if env_value.startswith('$'):
+                        var_name = env_value[1:]  # Remove the $
+                        if var_name in env_vars:
+                            config_dict['env'][env_key] = env_vars[var_name]
+            
+            # Create and register the server
+            from code_puppy.mcp import ServerConfig
+            
+            server_config = ServerConfig(
+                id=server_name,
+                name=server_name,
+                type=config_dict.pop('type'),
+                enabled=True,
+                config=config_dict
+            )
+            
+            server_id = self.manager.register_server(server_config)
+            
+            if server_id:
+                # Save to mcp_servers.json for persistence
+                from code_puppy.config import MCP_SERVERS_FILE
+                import json
+                import os
+                
+                if os.path.exists(MCP_SERVERS_FILE):
+                    with open(MCP_SERVERS_FILE, 'r') as f:
+                        data = json.load(f)
+                        servers = data.get("mcp_servers", {})
+                else:
+                    servers = {}
+                    data = {"mcp_servers": servers}
+                
+                servers[server_name] = config_dict
+                servers[server_name]['type'] = server_config.type
+                
+                os.makedirs(os.path.dirname(MCP_SERVERS_FILE), exist_ok=True)
+                with open(MCP_SERVERS_FILE, 'w') as f:
+                    json.dump(data, f, indent=2)
+                
+                emit_info(f"✅ Successfully installed '{server_name}' from {selected_server.display_name}!", message_group=group_id)
+                emit_info(f"Use '/mcp start {server_name}' to start the server", message_group=group_id)
+                return True
+            else:
+                emit_info(f"❌ Failed to register server", message_group=group_id)
+                return False
+                
+        except Exception as e:
+            emit_info(f"❌ Installation failed: {str(e)}", message_group=group_id)
+            return False
+    
     def cmd_remove(self, args: List[str]) -> None:
         """
         Remove an MCP server.
@@ -990,116 +1381,119 @@ class MCPCommandHandler:
             group_id = str(uuid.uuid4())
         
         try:
-            from code_puppy.mcp.server_registry_catalog import catalog
-            from code_puppy.mcp import ServerConfig
-            import json
+            # If in TUI mode, show message to use Ctrl+T
+            if is_tui_mode():
+                emit_info("In TUI mode, use Ctrl+T to open the MCP Install Wizard", message_group=group_id)
+                return
             
+            # In interactive mode, use the new comprehensive installer
             if not args:
-                emit_info("Usage: /mcp install <server-id> [custom-name]", message_group=group_id)
-                emit_info("Use '/mcp search' to find available servers", message_group=group_id)
+                # No args - launch interactive wizard
+                success = self._run_interactive_install_wizard(group_id)
+                if success:
+                    from code_puppy.agent import reload_mcp_servers
+                    reload_mcp_servers()
                 return
             
+            # Has args - install directly from catalog
             server_id = args[0]
-            custom_name = args[1] if len(args) > 1 else None
+            success = self._install_from_catalog(server_id, group_id)
+            if success:
+                from code_puppy.agent import reload_mcp_servers
+                reload_mcp_servers()
+            return
             
-            # Find server in registry
-            template = catalog.get_by_id(server_id)
-            if not template:
-                emit_info(f"Server '{server_id}' not found in registry", message_group=group_id)
-                
-                # Suggest similar servers
-                suggestions = catalog.search(server_id)
-                if suggestions:
-                    emit_info("Did you mean one of these?", message_group=group_id)
-                    for s in suggestions[:5]:
-                        emit_info(f"  • {s.id} - {s.display_name}", message_group=group_id)
-                return
+        except ImportError:
+            emit_info("Server registry not available", message_group=group_id)
+        except Exception as e:
+            logger.error(f"Error installing server: {e}")
+            emit_info(f"Installation failed: {e}", message_group=group_id)
+    
+    def _install_from_catalog(self, server_name_or_id: str, group_id: str) -> bool:
+        """Install a server directly from the catalog by name or ID."""
+        try:
+            from code_puppy.mcp.server_registry_catalog import catalog
             
-            # Show server details
-            emit_info(f"[bold cyan]Installing: {template.display_name}[/bold cyan]", message_group=group_id)
-            emit_info(f"[dim]{template.description}[/dim]", message_group=group_id)
+            # Try to find server by ID first, then by name/search
+            selected_server = catalog.get_by_id(server_name_or_id)
+            
+            if not selected_server:
+                # Try searching by name
+                results = catalog.search(server_name_or_id)
+                if not results:
+                    emit_info(f"❌ No server found matching '{server_name_or_id}'", message_group=group_id)
+                    emit_info("Try '/mcp add' to browse available servers", message_group=group_id)
+                    return False
+                elif len(results) == 1:
+                    selected_server = results[0]
+                else:
+                    # Multiple matches, show them
+                    emit_info(f"🔍 Multiple servers found matching '{server_name_or_id}':", message_group=group_id)
+                    for i, server in enumerate(results[:5]):
+                        indicators = []
+                        if server.verified:
+                            indicators.append("✓")
+                        if server.popular:
+                            indicators.append("⭐")
+                        
+                        indicator_str = ''
+                        if indicators:
+                            indicator_str = ' ' + ''.join(indicators)
+                        
+                        emit_info(f"  {i+1}. {server.display_name}{indicator_str}", message_group=group_id)
+                        emit_info(f"     ID: {server.id}", message_group=group_id)
+                    
+                    emit_info(f"Please use the exact server ID: '/mcp add <server_id>'", message_group=group_id)
+                    return False
             
-            # Check requirements
-            if template.requires:
-                emit_info(f"[yellow]Requirements:[/yellow] {', '.join(template.requires)}", message_group=group_id)
+            # Show what we're installing
+            emit_info(f"📦 Installing: {selected_server.display_name}", message_group=group_id)
+            description = selected_server.description if selected_server.description else "No description available"
+            emit_info(f"Description: {description}", message_group=group_id)
+            emit_info("", message_group=group_id)
             
-            # Use custom name or generate one
-            if not custom_name:
-                # Check if default name exists
-                existing = self.manager.registry.get_by_name(template.name)
-                if existing:
-                    # Generate unique name
-                    import time
-                    custom_name = f"{template.name}-{int(time.time()) % 10000}"
-                    emit_info(f"[dim]Using name: {custom_name} (original already exists)[/dim]", message_group=group_id)
-                else:
-                    custom_name = template.name
+            # Get custom name (default to server name)
+            from code_puppy.messaging import emit_prompt
+            server_name = emit_prompt(f"Enter custom name for this server [{selected_server.name}]: ").strip()
+            if not server_name:
+                server_name = selected_server.name
+            
+            # Check if name already exists
+            existing_server = self._find_server_id_by_name(server_name)
+            if existing_server:
+                override = emit_prompt(f"Server '{server_name}' already exists. Override it? [y/N]: ")
+                if not override.lower().startswith('y'):
+                    emit_info("Installation cancelled", message_group=group_id)
+                    return False
+            
+            # Configure the server with requirements
+            requirements = selected_server.get_requirements()
+            
+            # Check system requirements
+            if not self._interactive_check_system_requirements(requirements, group_id):
+                return False
             
-            # Convert template to server config
-            config_dict = template.to_server_config(custom_name)
+            # Collect environment variables
+            env_vars = self._interactive_collect_env_vars(requirements, group_id)
             
-            # Create ServerConfig
-            server_config = ServerConfig(
-                id=f"{custom_name}_{hash(custom_name)}",
-                name=custom_name,
-                type=config_dict.pop('type'),
-                enabled=True,
-                config=config_dict
-            )
+            # Collect command line arguments  
+            cmd_args = self._interactive_collect_cmd_args(requirements, group_id)
             
-            # Register the server
-            server_id = self.manager.register_server(server_config)
+            # Show summary and confirm
+            if not self._interactive_confirm_installation(selected_server, server_name, env_vars, cmd_args, group_id):
+                return False
+            
+            # Install the server
+            return self._interactive_install_server(selected_server, server_name, env_vars, cmd_args, group_id)
             
-            if server_id:
-                emit_info(f"✅ Installed '{custom_name}' from {template.display_name}", message_group=group_id)
-                
-                # Save to mcp_servers.json
-                from code_puppy.config import MCP_SERVERS_FILE
-                import os
-                
-                if os.path.exists(MCP_SERVERS_FILE):
-                    with open(MCP_SERVERS_FILE, 'r') as f:
-                        data = json.load(f)
-                        servers = data.get("mcp_servers", {})
-                else:
-                    servers = {}
-                    data = {"mcp_servers": servers}
-                
-                servers[custom_name] = config_dict
-                servers[custom_name]['type'] = server_config.type
-                
-                os.makedirs(os.path.dirname(MCP_SERVERS_FILE), exist_ok=True)
-                with open(MCP_SERVERS_FILE, 'w') as f:
-                    json.dump(data, f, indent=2)
-                
-                # Show next steps
-                if template.example_usage:
-                    emit_info(f"[yellow]Example:[/yellow] {template.example_usage}", message_group=group_id)
-                
-                # Check for environment variables
-                env_vars = []
-                if 'env' in config_dict:
-                    for key, value in config_dict['env'].items():
-                        if value.startswith('$'):
-                            env_vars.append(value[1:])
-                
-                if env_vars:
-                    emit_info(f"[yellow]Required environment variables:[/yellow] {', '.join(env_vars)}", message_group=group_id)
-                    emit_info("Set these before starting the server", message_group=group_id)
-                
-                emit_info(f"Use '/mcp start {custom_name}' to start the server", message_group=group_id)
-                
-                # Reload MCP servers
-                from code_puppy.agent import reload_mcp_servers
-                reload_mcp_servers()
-            else:
-                emit_info(f"Failed to install server", message_group=group_id)
-                
         except ImportError:
-            emit_info("Server registry not available", message_group=group_id)
+            emit_info("Server catalog not available", message_group=group_id)
+            return False
         except Exception as e:
-            logger.error(f"Error installing server: {e}")
-            emit_info(f"Installation failed: {e}", message_group=group_id)
+            import traceback
+            emit_info(f"❌ Installation failed: {str(e)}", message_group=group_id)
+            emit_info(f"[dim]Error details: {traceback.format_exc()}[/dim]", message_group=group_id)
+            return False
     
     def _find_server_id_by_name(self, server_name: str) -> Optional[str]:
         """
@@ -1173,20 +1567,20 @@ class MCPCommandHandler:
         
         display, color = state_map.get(state, ("? Unk", "dim"))
         return Text(display, style=color)
-    
+
     def _format_uptime(self, uptime_seconds: Optional[float]) -> str:
         """
         Format uptime in a human-readable format.
-        
+
         Args:
             uptime_seconds: Uptime in seconds, or None
-            
+
         Returns:
             Formatted uptime string
         """
         if uptime_seconds is None or uptime_seconds <= 0:
             return "-"
-        
+
         # Convert to readable format
         if uptime_seconds < 60:
             return f"{int(uptime_seconds)}s"
@@ -1198,7 +1592,7 @@ class MCPCommandHandler:
             hours = int(uptime_seconds // 3600)
             minutes = int((uptime_seconds % 3600) // 60)
             return f"{hours}h {minutes}m"
-    
+
     def _show_detailed_server_status(self, server_id: str, server_name: str, group_id: str = None) -> None:
         """
         Show comprehensive status information for a specific server.
@@ -1295,4 +1689,95 @@ class MCPCommandHandler:
         
         except Exception as e:
             logger.error(f"Error showing detailed status for server '{server_name}': {e}")
-            emit_info(f"Failed to get detailed status: {e}", message_group=group_id)
+            emit_info(f"Failed to get detailed status: {e}", message_group=group_id)
+    
+    def _handle_interactive_requirements(self, template, custom_name: str, group_id: str) -> Dict:
+        """Handle comprehensive requirements in interactive mode."""
+        from code_puppy.messaging import emit_prompt
+        
+        requirements = template.get_requirements()
+        config_overrides = {}
+        
+        # 1. Check system requirements
+        if requirements.required_tools:
+            emit_info("[bold cyan]Checking system requirements...[/bold cyan]", message_group=group_id)
+            from code_puppy.mcp.system_tools import detector
+            
+            tool_status = detector.detect_tools(requirements.required_tools)
+            missing_tools = []
+            
+            for tool_name, tool_info in tool_status.items():
+                if tool_info.available:
+                    emit_info(f"✅ {tool_name} ({tool_info.version or 'found'})", message_group=group_id)
+                else:
+                    emit_info(f"❌ {tool_name} - {tool_info.error}", message_group=group_id)
+                    missing_tools.append(tool_name)
+            
+            if missing_tools:
+                emit_info(f"[red]Missing required tools: {', '.join(missing_tools)}[/red]", message_group=group_id)
+                
+                # Show installation suggestions
+                for tool in missing_tools:
+                    suggestions = detector.get_installation_suggestions(tool)
+                    emit_info(f"Install {tool}: {suggestions[0]}", message_group=group_id)
+                
+                proceed = emit_prompt("Continue installation anyway? (y/N): ")
+                if proceed.lower() not in ['y', 'yes']:
+                    raise Exception("Installation cancelled due to missing requirements")
+        
+        # 2. Environment variables
+        env_vars = template.get_environment_vars()
+        if env_vars:
+            emit_info("[bold yellow]Environment Variables:[/bold yellow]", message_group=group_id)
+            
+            for var in env_vars:
+                import os
+                if var in os.environ:
+                    emit_info(f"✅ {var} (already set)", message_group=group_id)
+                else:
+                    try:
+                        value = emit_prompt(f"Enter {var}: ")
+                        if value.strip():
+                            os.environ[var] = value.strip()
+                            emit_info(f"[green]Set {var}[/green]", message_group=group_id)
+                        else:
+                            emit_info(f"[yellow]Skipped {var} (empty value)[/yellow]", message_group=group_id)
+                    except Exception as e:
+                        emit_info(f"[yellow]Failed to get {var}: {e}[/yellow]", message_group=group_id)
+        
+        # 3. Command line arguments
+        cmd_args = requirements.command_line_args
+        if cmd_args:
+            emit_info("[bold green]Command Line Arguments:[/bold green]", message_group=group_id)
+            
+            for arg_config in cmd_args:
+                name = arg_config.get("name", "")
+                prompt_text = arg_config.get("prompt", name)
+                default = arg_config.get("default", "")
+                required = arg_config.get("required", True)
+                
+                try:
+                    if default:
+                        value = emit_prompt(f"{prompt_text} (default: {default}): ")
+                        value = value.strip() or default
+                    else:
+                        value = emit_prompt(f"{prompt_text}: ")
+                        value = value.strip()
+                    
+                    if value:
+                        config_overrides[name] = value
+                        emit_info(f"[green]Set {name}={value}[/green]", message_group=group_id)
+                    elif required:
+                        emit_info(f"[yellow]Required argument {name} not provided[/yellow]", message_group=group_id)
+                    
+                except Exception as e:
+                    emit_info(f"[yellow]Failed to get {name}: {e}[/yellow]", message_group=group_id)
+        
+        # 4. Package dependencies (informational)
+        packages = requirements.package_dependencies
+        if packages:
+            emit_info("[bold magenta]Package Dependencies:[/bold magenta]", message_group=group_id)
+            emit_info(f"This server requires: {', '.join(packages)}", message_group=group_id)
+            emit_info("These will be installed automatically when the server starts.", message_group=group_id)
+        
+        return config_overrides