Update app.py

app.py

@@ -21,7 +21,22 @@ class MCPClient:
             "linux": {
                 "name": "MCP Linux", 
                 "space_url": "https://chrissacrumcor-mcp-linux.hf.space",
-                "description": "Linux system operations"
+                "description": "Linux system operations",
+                # Known tools from the Linux server code
+                "tools": [
+                    {
+                        "name": "user_management",
+                        "description": "Generate Linux user management commands for creating, deleting, and managing users and groups"
+                    },
+                    {
+                        "name": "file_permissions", 
+                        "description": "Generate file permission and ownership commands for chmod, chown, and permission discovery"
+                    },
+                    {
+                        "name": "system_commands",
+                        "description": "Generate common Linux system administration commands for processes, disk, network, services, and firewall"
+                    }
+                ]
             },
             "cisco": {
                 "name": "MCP Cisco",
@@ -32,8 +47,431 @@ class MCPClient:
         
         self.conversation_history = []
     
+    def check_server_health(self, server_key: str) -> Dict[str, Any]:
+        """Check if MCP server is responsive"""
+        try:
+            server_config = self.mcp_servers[server_key]
+            
+            # Try health endpoints
+            health_endpoints = ["/health", "/", "/docs"]
+            
+            for endpoint in health_endpoints:
+                try:
+                    url = f"{server_config['space_url']}{endpoint}"
+                    response = requests.get(url, timeout=10)
+                    
+                    if response.status_code == 200:
+                        return {
+                            "success": True,
+                            "status": "online",
+                            "endpoint": endpoint,
+                            "response": response.json() if endpoint in ["/health", "/"] else {"status": "docs_available"}
+                        }
+                    elif response.status_code in [404, 422]:
+                        return {
+                            "success": True,
+                            "status": "online_different_structure",
+                            "endpoint": endpoint
+                        }
+                except requests.RequestException:
+                    continue
+            
+            return {"success": False, "status": "offline", "error": "No responsive endpoints"}
+            
+        except Exception as e:
+            return {"success": False, "status": "error", "error": str(e)}
+    
+    def execute_linux_tool(self, tool_name: str, arguments: Dict[str, Any]) -> str:
+        """Execute Linux MCP tools - recreated from server logic"""
+        
+        if tool_name == "user_management":
+            action = arguments.get("action", "")
+            username = arguments.get("username", "example_user")
+            groupname = arguments.get("groupname", "example_group")
+            
+            if action == "add_user_to_group":
+                return f"""**Add User to Group Commands:**
+
+```bash
+# Add user '{username}' to group '{groupname}'
+sudo usermod -a -G {groupname} {username}
+
+# Alternative methods:
+sudo gpasswd -a {username} {groupname}
+sudo adduser {username} {groupname}  # Ubuntu/Debian
+
+# Verify group membership:
+groups {username}
+id {username}
+getent group {groupname}
+```"""
+            
+            elif action == "create_user":
+                return f"""**Create User Commands:**
+
+```bash
+# Create new user '{username}'
+sudo useradd -m -s /bin/bash {username}
+sudo passwd {username}
+
+# Create user with specific group:
+sudo useradd -m -g {groupname} -s /bin/bash {username}
+
+# Add to sudo group (Ubuntu/Debian):
+sudo usermod -a -G sudo {username}
+
+# Add to wheel group (RHEL/CentOS):
+sudo usermod -a -G wheel {username}
+
+# Verify user creation:
+id {username}
+getent passwd {username}
+```"""
+            
+            elif action == "delete_user":
+                return f"""**Delete User Commands:**
+
+```bash
+# Delete user '{username}'
+sudo userdel {username}
+
+# Delete user and home directory:
+sudo userdel -r {username}
+
+# Remove user from all groups first (if needed):
+sudo gpasswd -d {username} groupname
+
+# Verify user deletion:
+getent passwd {username}
+# Should return no results if deleted successfully
+```"""
+            
+            elif action == "list_groups":
+                return """**List Groups and Users Commands:**
+
+```bash
+# List all groups:
+cat /etc/group
+getent group
+
+# List groups for current user:
+groups $USER
+id $USER
+
+# List groups for specific user:
+groups username
+id username
+
+# List users in specific group:
+getent group sudo
+getent group wheel
+
+# List all users:
+cut -d: -f1 /etc/passwd
+getent passwd
+```"""
+            
+            else:
+                return f"❌ Unknown user management action: {action}. Available: add_user_to_group, create_user, delete_user, list_groups"
+        
+        elif tool_name == "file_permissions":
+            action = arguments.get("action", "")
+            path = arguments.get("path", "/path/to/file")
+            permissions = arguments.get("permissions", "755")
+            owner = arguments.get("owner", "username")
+            recursive = arguments.get("recursive", False)
+            
+            recursive_flag = "-R " if recursive else ""
+            
+            if action == "chmod":
+                return f"""**Change File Permissions Commands:**
+
+```bash
+# Change permissions for {path}
+chmod {recursive_flag}{permissions} {path}
+
+# Common permission examples:
+# 755 = rwxr-xr-x (executable for owner, readable for others)
+# 644 = rw-r--r-- (readable/writable for owner, readable for others)
+# 600 = rw------- (readable/writable for owner only)
+# 777 = rwxrwxrwx (full permissions for all - use with caution!)
+
+# Symbolic notation examples:
+chmod {recursive_flag}u+x {path}    # Add execute for owner
+chmod {recursive_flag}g-w {path}    # Remove write for group
+chmod {recursive_flag}o-r {path}    # Remove read for others
+
+# Verify permissions:
+ls -la {path}
+stat {path}
+```"""
+            
+            elif action == "chown":
+                return f"""**Change File Ownership Commands:**
+
+```bash
+# Change ownership for {path}
+sudo chown {recursive_flag}{owner} {path}
+
+# Change owner and group:
+sudo chown {recursive_flag}{owner}:{owner} {path}
+sudo chown {recursive_flag}{owner}:users {path}
+
+# Change only group:
+sudo chgrp {recursive_flag}{owner} {path}
+
+# Verify ownership:
+ls -la {path}
+stat {path}
+```"""
+            
+            elif action == "find_permissions":
+                return f"""**Find Files by Permissions:**
+
+```bash
+# Find files with specific permissions in {path}
+find {path} -type f -perm {permissions}
+find {path} -type f -perm -{permissions}  # At least these permissions
+
+# Find files by owner:
+find {path} -user {owner}
+find {path} -group {owner}
+
+# Find files with dangerous permissions:
+find {path} -type f -perm -002  # World-writable files
+find {path} -type f -perm -004  # World-readable files
+
+# Find SUID/SGID files:
+find {path} -type f -perm -4000  # SUID files
+find {path} -type f -perm -2000  # SGID files
+
+# Find world-writable directories:
+find {path} -type d -perm 777
+```"""
+            
+            else:
+                return f"❌ Unknown file permission action: {action}. Available: chmod, chown, find_permissions"
+        
+        elif tool_name == "system_commands":
+            category = arguments.get("category", "")
+            target = arguments.get("target", "nginx")
+            
+            if category == "process":
+                return f"""**Process Management Commands:**
+
+```bash
+# List and analyze processes:
+ps aux                    # List all processes with details
+ps -ef                    # Alternative process listing
+pstree                    # Show process tree
+top                       # Real-time process monitor
+htop                      # Enhanced process monitor
+
+# Find and manage specific processes:
+ps aux | grep {target}       # Find specific process
+pgrep -f {target}           # Get PID by name
+pkill -f {target}           # Kill process by name
+killall {target}            # Kill all processes by name
+
+# Process control:
+kill -15 PID              # Graceful termination (SIGTERM)
+kill -9 PID               # Force kill (SIGKILL)
+kill -HUP PID             # Reload configuration (SIGHUP)
+
+# Background processes:
+nohup command &           # Run command in background
+screen -S session_name    # Start screen session
+tmux new -s session_name  # Start tmux session
+```"""
+            
+            elif category == "service":
+                return f"""**Service Management Commands (systemd):**
+
+```bash
+# Service status and control:
+systemctl status {target}   # Check service status
+systemctl start {target}    # Start service
+systemctl stop {target}     # Stop service
+systemctl restart {target}  # Restart service
+systemctl reload {target}   # Reload configuration
+
+# Service persistence:
+systemctl enable {target}   # Enable at boot
+systemctl disable {target}  # Disable at boot
+systemctl is-enabled {target}  # Check if enabled
+
+# Service discovery:
+systemctl list-units      # List all active services
+systemctl list-units --failed  # List failed services
+systemctl list-unit-files     # List all unit files
+
+# Service logs:
+journalctl -u {target}      # View service logs
+journalctl -u {target} -f   # Follow service logs
+journalctl -u {target} --since today  # Today's logs
+```"""
+            
+            elif category == "network":
+                return f"""**Network Diagnostic Commands:**
+
+```bash
+# Network interface information:
+ip addr show              # Show IP addresses
+ip link show              # Show network interfaces
+ip route show             # Show routing table
+ip neigh show             # Show ARP table
+
+# Port and connection analysis:
+ss -tuln                  # Show listening ports
+ss -tulpn                 # Show ports with process names
+netstat -tuln             # Alternative port listing
+netstat -rn               # Show routing table
+
+# Connectivity testing:
+ping -c 4 {target}     # Test connectivity
+traceroute {target}    # Trace network path
+mtr {target}           # Network diagnostic tool
+nslookup {target}      # DNS lookup
+dig {target}           # DNS information
+
+# Network utilities:
+wget -O- ifconfig.me      # Get public IP
+curl -s ifconfig.me       # Alternative public IP
+curl -s ipinfo.io         # Detailed IP information
+```"""
+            
+            elif category == "disk":
+                return f"""**Disk Usage and Management Commands:**
+
+```bash
+# Disk usage analysis:
+df -h                     # Show disk usage (human readable)
+df -i                     # Show inode usage
+du -sh /*                 # Show directory sizes in root
+du -sh /var/log/* | sort -hr      # Sort by size
+
+# Disk and filesystem information:
+lsblk                     # List block devices
+lsblk -f                  # Show filesystems
+blkid                     # Show UUIDs and labels
+fdisk -l                  # List disk partitions
+parted -l                 # Alternative partition listing
+
+# Mount management:
+mount                     # Show mounted filesystems
+findmnt                   # Tree view of mounts
+mount /dev/sdb1 /mnt/backup  # Mount filesystem
+umount /mnt/backup           # Unmount filesystem
+
+# Cleanup commands:
+apt autoremove            # Remove unused packages (Debian/Ubuntu)
+yum autoremove            # Remove unused packages (RHEL/CentOS)
+journalctl --disk-usage   # Check journal disk usage
+journalctl --vacuum-time=3d  # Clean old journal entries
+```"""
+            
+            elif category == "firewall":
+                return f"""**Firewall Management Commands:**
+
+```bash
+# UFW (Uncomplicated Firewall):
+sudo ufw status verbose   # Check UFW status (detailed)
+sudo ufw enable           # Enable UFW
+sudo ufw disable          # Disable UFW
+
+# UFW rule management:
+sudo ufw allow {target}        # Allow port/service
+sudo ufw deny {target}         # Block port/service
+sudo ufw allow ssh        # Allow SSH service
+sudo ufw allow 80/tcp     # Allow HTTP
+sudo ufw allow 443/tcp    # Allow HTTPS
+sudo ufw allow from 192.168.1.0/24  # Allow from subnet
+
+# UFW advanced operations:
+sudo ufw delete allow 80  # Remove rule
+sudo ufw insert 1 allow 22  # Insert rule at position
+sudo ufw logging on       # Enable logging
+
+# iptables (advanced):
+sudo iptables -L          # List iptables rules
+sudo iptables -L -n       # List with numeric output
+sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT  # Allow HTTP
+sudo iptables-save > /etc/iptables/rules.v4  # Save rules
+```"""
+            
+            else:
+                return f"❌ Unknown system command category: {category}. Available: process, service, network, disk, firewall"
+        
+        else:
+            return f"❌ Unknown tool: {tool_name}. Available: user_management, file_permissions, system_commands"
+    
+    def select_linux_tool_and_args(self, user_input: str) -> Dict[str, Any]:
+        """Analyze user input to select appropriate Linux tool and arguments"""
+        user_lower = user_input.lower()
+        
+        # User management keywords
+        if any(word in user_lower for word in ["user", "group", "adduser", "useradd", "usermod"]):
+            if "add" in user_lower and "group" in user_lower:
+                return {"tool": "user_management", "args": {"action": "add_user_to_group", "username": "example_user", "groupname": "example_group"}}
+            elif "create" in user_lower or ("add" in user_lower and "user" in user_lower):
+                return {"tool": "user_management", "args": {"action": "create_user", "username": "new_user"}}
+            elif "delete" in user_lower and "user" in user_lower:
+                return {"tool": "user_management", "args": {"action": "delete_user", "username": "old_user"}}
+            else:
+                return {"tool": "user_management", "args": {"action": "list_groups"}}
+        
+        # File permission keywords
+        elif any(word in user_lower for word in ["permission", "chmod", "chown", "file", "ownership"]):
+            if "chmod" in user_lower:
+                return {"tool": "file_permissions", "args": {"action": "chmod", "path": "/path/to/file", "permissions": "755"}}
+            elif "chown" in user_lower or "ownership" in user_lower:
+                return {"tool": "file_permissions", "args": {"action": "chown", "path": "/path/to/file", "owner": "username"}}
+            elif "find" in user_lower:
+                return {"tool": "file_permissions", "args": {"action": "find_permissions", "path": "/", "permissions": "777"}}
+            else:
+                return {"tool": "file_permissions", "args": {"action": "chmod", "path": "/path/to/file", "permissions": "644"}}
+        
+        # System command keywords  
+        elif any(word in user_lower for word in ["process", "service", "network", "disk", "firewall", "systemctl", "ps"]):
+            if any(word in user_lower for word in ["process", "ps", "top", "kill"]):
+                return {"tool": "system_commands", "args": {"category": "process"}}
+            elif any(word in user_lower for word in ["service", "systemctl", "daemon"]):
+                return {"tool": "system_commands", "args": {"category": "service"}}
+            elif any(word in user_lower for word in ["network", "ping", "ip", "interface"]):
+                return {"tool": "system_commands", "args": {"category": "network"}}
+            elif any(word in user_lower for word in ["disk", "df", "mount", "storage"]):
+                return {"tool": "system_commands", "args": {"category": "disk"}}
+            elif any(word in user_lower for word in ["firewall", "ufw", "iptables"]):
+                return {"tool": "system_commands", "args": {"category": "firewall"}}
+            else:
+                return {"tool": "system_commands", "args": {"category": "process"}}
+        
+        # Default - show help
+        else:
+            return {"tool": "help", "args": {}}
+    
+    def get_available_tools(self, server_key: str) -> List[Dict[str, Any]]:
+        """Get available tools from an MCP server"""
+        if server_key == "linux":
+            # Return known tools for Linux server
+            return self.mcp_servers["linux"]["tools"]
+        
+        # For other servers, try to call them (though they might not have HTTP endpoints)
+        try:
+            result = self.call_mcp_server(server_key, "tools/list", {})
+            if result["success"]:
+                data = result["data"]
+                if isinstance(data, dict):
+                    return data.get("tools", data.get("result", []))
+                elif isinstance(data, list):
+                    return data
+        except:
+            pass
+        
+        return []
+    
     def call_mcp_server(self, server_key: str, endpoint: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-        """Make a call to an MCP server (FastAPI-based)"""
+        """Make a call to an MCP server (for non-Linux servers)"""
         try:
             server_config = self.mcp_servers[server_key]
             
@@ -73,18 +511,6 @@ class MCPClient:
         except Exception as e:
             return {"success": False, "error": f"Unexpected error: {str(e)}", "server": server_config['name']}
     
-    def get_available_tools(self, server_key: str) -> List[Dict[str, Any]]:
-        """Get available tools from an MCP server"""
-        result = self.call_mcp_server(server_key, "tools/list", {})
-        if result["success"]:
-            data = result["data"]
-            # Handle different response formats
-            if isinstance(data, dict):
-                return data.get("tools", data.get("result", []))
-            elif isinstance(data, list):
-                return data
-        return []
-    
     def execute_tool(self, server_key: str, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
         """Execute a tool on an MCP server"""
         payload = {
@@ -233,35 +659,96 @@ class MCPClient:
                 
                 status = f"[{timestamp}] Using: {self.mcp_servers[selected_server]['name']}"
             
-            # Get available tools for the selected server
-            tools = self.get_available_tools(selected_server)
-            
-            if not tools:
-                # Try to get more info about the server
-                server_check = self.call_mcp_server(selected_server, "", {})
-                if not server_check["success"]:
-                    response = f"⚠️ Cannot connect to {self.mcp_servers[selected_server]['name']} server: {server_check.get('error', 'Unknown error')}"
-                else:
-                    response = f"⚠️ No tools available from {self.mcp_servers[selected_server]['name']} server (but server is responsive)"
-                
+            # Check server health
+            health_check = self.check_server_health(selected_server)
+            if not health_check["success"]:
+                response = f"⚠️ Cannot connect to {self.mcp_servers[selected_server]['name']} server: {health_check.get('error', 'Server offline')}"
                 self.conversation_history.append({"role": "assistant", "content": response})
-                return response, status + " - Connection/Tools issue"
+                return response, status + " - Server offline"
             
-            # For now, just show available tools and generate a helpful response
-            # In a full implementation, you'd use OpenAI to select and execute appropriate tools
-            tools_info = "\n".join([f"- {tool.get('name', 'Unknown')}: {tool.get('description', 'No description')}" 
-                                  for tool in tools[:5]])  # Show first 5 tools
+            # Handle Linux server specifically (full functionality)
+            if selected_server == "linux":
+                tool_selection = self.select_linux_tool_and_args(user_input)
+                
+                if tool_selection["tool"] == "help":
+                    response = """**Available Linux MCP Tools:**
+
+🔧 **user_management**: Create, delete, and manage users and groups
+📁 **file_permissions**: Change file permissions and ownership (chmod, chown)  
+⚙️ **system_commands**: System administration commands (processes, services, network, disk, firewall)
+
+**Example commands you can ask for:**
+- "Show me user management commands"
+- "How do I change file permissions?"
+- "Give me process management commands" 
+- "Show network diagnostic commands"
+- "Help with service management"
+- "Configure firewall rules"
+- "Check disk usage commands"
+"""
+                else:
+                    # Execute the selected Linux tool
+                    result = self.execute_linux_tool(tool_selection["tool"], tool_selection["args"])
+                    response = result
             
-            server_info = {
-                "server": self.mcp_servers[selected_server]['name'],
-                "available_tools": len(tools),
-                "sample_tools": tools_info
-            }
+            # Handle other servers (Terraform, Cisco)
+            else:
+                # Get available tools for the selected server
+                tools = self.get_available_tools(selected_server)
+                
+                if tools:
+                    # Show available tools and generate helpful response
+                    tools_info = "\n".join([f"- {tool.get('name', 'Unknown')}: {tool.get('description', 'No description')}" 
+                                          for tool in tools[:5]])
+                    
+                    server_info = {
+                        "server": self.mcp_servers[selected_server]['name'],
+                        "available_tools": len(tools),
+                        "sample_tools": tools_info
+                    }
+                    
+                    response = self.generate_response(user_input, server_info)
+                else:
+                    # Provide guidance for servers without direct HTTP tool access
+                    if selected_server == "terraform":
+                        response = f"""**Terraform MCP Server**
+
+I can help you with Terraform infrastructure management, but this server uses MCP protocol over SSE.
+
+**Common Terraform operations:**
+- Plan infrastructure changes (`terraform plan`)
+- Apply configurations (`terraform apply`) 
+- Destroy resources (`terraform destroy`)
+- Validate configurations (`terraform validate`)
+- Import existing resources (`terraform import`)
+
+**Server Status**: {health_check['status']}
+**MCP Endpoint**: {self.mcp_servers[selected_server]['space_url']}/mcp/sse
+
+*Note: For full functionality, this server requires MCP protocol connection.*
+"""
+                    
+                    elif selected_server == "cisco":
+                        response = f"""**Cisco MCP Server**
+
+I can help you with Cisco network device management, but this server uses MCP protocol over SSE.
+
+**Common Cisco operations:**
+- Show interface configurations
+- Configure VLANs 
+- Set up routing protocols
+- Manage access control lists
+- Check device status
+- Configure port settings
+
+**Server Status**: {health_check['status']}
+**MCP Endpoint**: {self.mcp_servers[selected_server]['space_url']}/mcp/sse
+
+*Note: For full functionality, this server requires MCP protocol connection.*
+"""
             
-            response = self.generate_response(user_input, server_info)
             self.conversation_history.append({"role": "assistant", "content": response})
-            
-            return response, status + f" - {len(tools)} tools available"
+            return response, status + f" - {health_check['status']}"
             
         except Exception as e:
             error_response = f"❌ Error processing request: {str(e)}"
@@ -318,44 +805,42 @@ def create_gradio_interface():
             return history, ""
     
     def get_server_status():
+        if not mcp_client:
+            return "Please initialize the OpenAI client first."
+        
         status_info = "## MCP Servers Status\n\n"
-        for key, config in (mcp_client.mcp_servers.items() if mcp_client else []):
-            try:
-                # Try multiple health check endpoints
-                health_urls = [
-                    f"{config['space_url']}/health",
-                    f"{config['space_url']}/",
-                    f"{config['space_url']}/docs"
-                ]
-                
-                status = "🔴 Offline"
-                for url in health_urls:
-                    try:
-                        response = requests.get(url, timeout=5)
-                        if response.status_code == 200:
-                            status = "🟢 Online"
-                            break
-                        elif response.status_code in [404, 422]:  # Common for FastAPI
-                            status = "🟡 Running (different endpoint structure)"
-                            break
-                    except:
-                        continue
-                        
-            except:
-                status = "🔴 Offline"
-            
-            status_info += f"**{config['name']}**: {status}\n"
+        
+        for key, config in mcp_client.mcp_servers.items():
+            health_check = mcp_client.check_server_health(key)
+            
+            if health_check["success"]:
+                if health_check["status"] == "online":
+                    status_icon = "🟢"
+                    status_text = "Online"
+                else:
+                    status_icon = "🟡" 
+                    status_text = "Online (Different Structure)"
+            else:
+                status_icon = "🔴"
+                status_text = "Offline"
+            
+            status_info += f"**{config['name']}**: {status_icon} {status_text}\n"
             status_info += f"- URL: {config['space_url']}\n"
             status_info += f"- Description: {config['description']}\n"
             
-            # Try to get tools info for additional status
-            if mcp_client:
-                try:
-                    tools = mcp_client.get_available_tools(key)
-                    tools_count = len(tools) if tools else 0
-                    status_info += f"- Available Tools: {tools_count}\n"
-                except:
-                    status_info += f"- Available Tools: Unable to fetch\n"
+            # Show tools for Linux server
+            if key == "linux" and "tools" in config:
+                status_info += f"- Available Tools: {len(config['tools'])}\n"
+                for tool in config['tools']:
+                    status_info += f"  - **{tool['name']}**: {tool['description']}\n"
+            
+            # Show MCP endpoint info
+            status_info += f"- MCP Endpoint: {config['space_url']}/mcp/sse\n"
+            
+            if health_check["success"] and "response" in health_check:
+                response_data = health_check["response"]
+                if isinstance(response_data, dict) and "service" in response_data:
+                    status_info += f"- Service: {response_data.get('service', 'Unknown')}\n"
             
             status_info += "\n"
         
@@ -385,7 +870,7 @@ def create_gradio_interface():
                 
                 # Server selection
                 server_choice = gr.Dropdown(
-                    choices=["Auto-detect", "terraform", "linux", "cisco"],
+                    choices=["Auto-detect", "linux", "terraform", "cisco"],
                     value="Auto-detect",
                     label="Select MCP Server"
                 )
@@ -414,17 +899,23 @@ def create_gradio_interface():
                 
                 gr.Markdown("## 💡 Example Queries")
                 gr.Markdown("""
-                **Terraform:**
-                - "Show me the current infrastructure state"
-                - "Plan a new deployment"
+                **Linux (Full Support):**
+                - "Show me user management commands"
+                - "How do I change file permissions?"
+                - "Give me process management commands"
+                - "Show network diagnostic commands"
+                - "Help with service management"
+                - "Configure firewall rules"
                 
-                **Linux:**
-                - "Check system resources"
-                - "List running processes"
+                **Terraform:**
+                - "Show me terraform commands"
+                - "Plan infrastructure deployment"
+                - "Help with terraform apply"
                 
                 **Cisco:**
-                - "Show interface status"
-                - "Check network configuration"
+                - "Show interface configuration"
+                - "Configure VLAN commands"
+                - "Help with port configuration"
                 """)
         
         # Event handlers