linux-mcp-server 0.1.0.dev0__py3-none-any.whl

linux_mcp_server/tools/network.py

@@ -0,0 +1,281 @@
+"""Network diagnostic tools."""
+
+import psutil
+import socket
+from typing import Optional
+
+from .ssh_executor import execute_command
+from .utils import format_bytes
+
+
+async def get_network_interfaces(host: Optional[str] = None, username: Optional[str] = None) -> str:
+    """
+    Get network interface information.
+    
+    Args:
+        host: Optional remote host to connect to
+        username: Optional SSH username (required if host is provided)
+        
+    Returns:
+        Formatted string with network interface information
+    """
+    try:
+        if host:
+            # Remote execution - use ip command
+            info = []
+            info.append("=== Network Interfaces ===\n")
+            
+            # Get interface info
+            returncode, stdout, _ = await execute_command(
+                ["ip", "-brief", "address"],
+                host=host,
+                username=username
+            )
+            
+            if returncode == 0 and stdout:
+                info.append(stdout)
+            
+            # Get detailed interface info
+            returncode, stdout, _ = await execute_command(
+                ["ip", "address"],
+                host=host,
+                username=username
+            )
+            
+            if returncode == 0 and stdout:
+                info.append("\n=== Detailed Interface Information ===")
+                info.append(stdout)
+            
+            # Get network statistics using netstat or ss
+            returncode, stdout, _ = await execute_command(
+                ["cat", "/proc/net/dev"],
+                host=host,
+                username=username
+            )
+            
+            if returncode == 0 and stdout:
+                info.append("\n=== Network I/O Statistics ===")
+                info.append(stdout)
+            
+            return "\n".join(info)
+        else:
+            # Local execution - use psutil
+            info = []
+            info.append("=== Network Interfaces ===\n")
+            
+            # Get network interface addresses
+            net_if_addrs = psutil.net_if_addrs()
+            net_if_stats = psutil.net_if_stats()
+            
+            for interface, addrs in sorted(net_if_addrs.items()):
+                info.append(f"\n{interface}:")
+                
+                # Get interface stats
+                if interface in net_if_stats:
+                    stats = net_if_stats[interface]
+                    status = "UP" if stats.isup else "DOWN"
+                    info.append(f"  Status: {status}")
+                    info.append(f"  Speed: {stats.speed} Mbps")
+                    info.append(f"  MTU: {stats.mtu}")
+                
+                # Get addresses
+                for addr in addrs:
+                    if addr.family == socket.AF_INET:
+                        info.append(f"  IPv4 Address: {addr.address}")
+                        if addr.netmask:
+                            info.append(f"    Netmask: {addr.netmask}")
+                        if addr.broadcast:
+                            info.append(f"    Broadcast: {addr.broadcast}")
+                    elif addr.family == socket.AF_INET6:
+                        info.append(f"  IPv6 Address: {addr.address}")
+                        if addr.netmask:
+                            info.append(f"    Netmask: {addr.netmask}")
+                    elif addr.family == psutil.AF_LINK:
+                        info.append(f"  MAC Address: {addr.address}")
+            
+            # Network I/O statistics
+            net_io = psutil.net_io_counters()
+            info.append("\n\n=== Network I/O Statistics (total) ===")
+            info.append(f"Bytes Sent: {format_bytes(net_io.bytes_sent)}")
+            info.append(f"Bytes Received: {format_bytes(net_io.bytes_recv)}")
+            info.append(f"Packets Sent: {net_io.packets_sent}")
+            info.append(f"Packets Received: {net_io.packets_recv}")
+            info.append(f"Errors In: {net_io.errin}")
+            info.append(f"Errors Out: {net_io.errout}")
+            info.append(f"Drops In: {net_io.dropin}")
+            info.append(f"Drops Out: {net_io.dropout}")
+            
+            return "\n".join(info)
+    except Exception as e:
+        return f"Error getting network interface information: {str(e)}"
+
+
+async def get_network_connections(host: Optional[str] = None, username: Optional[str] = None) -> str:
+    """
+    Get active network connections.
+    
+    Args:
+        host: Optional remote host to connect to
+        username: Optional SSH username (required if host is provided)
+        
+    Returns:
+        Formatted string with active network connections
+    """
+    try:
+        if host:
+            # Remote execution - use ss or netstat command
+            # Try ss first (modern tool)
+            returncode, stdout, _ = await execute_command(
+                ["ss", "-tunap"],
+                host=host,
+                username=username
+            )
+            
+            if returncode == 0 and stdout:
+                info = []
+                info.append("=== Active Network Connections ===\n")
+                info.append(stdout)
+                
+                # Count connections
+                lines = stdout.strip().split('\n')
+                info.append(f"\n\nTotal connections: {len(lines) - 1}")  # -1 for header
+                
+                return "\n".join(info)
+            else:
+                # Fallback to netstat
+                returncode, stdout, _ = await execute_command(
+                    ["netstat", "-tunap"],
+                    host=host,
+                    username=username
+                )
+                
+                if returncode == 0 and stdout:
+                    info = []
+                    info.append("=== Active Network Connections ===\n")
+                    info.append(stdout)
+                    return "\n".join(info)
+                else:
+                    return "Error: Neither ss nor netstat command available on remote host"
+        else:
+            # Local execution - use psutil
+            info = []
+            info.append("=== Active Network Connections ===\n")
+            info.append(f"{'Proto':<8} {'Local Address':<30} {'Remote Address':<30} {'Status':<15} {'PID/Program'}")
+            info.append("-" * 110)
+            
+            # Get all network connections
+            connections = psutil.net_connections(kind='inet')
+            
+            for conn in connections:
+                proto = "TCP" if conn.type == socket.SOCK_STREAM else "UDP"
+                
+                local_addr = f"{conn.laddr.ip}:{conn.laddr.port}" if conn.laddr else "N/A"
+                remote_addr = f"{conn.raddr.ip}:{conn.raddr.port}" if conn.raddr else "N/A"
+                status = conn.status if conn.status else "N/A"
+                
+                # Try to get process info
+                pid_info = str(conn.pid) if conn.pid else "N/A"
+                if conn.pid:
+                    try:
+                        proc = psutil.Process(conn.pid)
+                        pid_info = f"{conn.pid}/{proc.name()}"
+                    except (psutil.NoSuchProcess, psutil.AccessDenied):
+                        pass
+                
+                info.append(
+                    f"{proto:<8} {local_addr:<30} {remote_addr:<30} {status:<15} {pid_info}"
+                )
+            
+            info.append(f"\n\nTotal connections: {len(connections)}")
+            
+            return "\n".join(info)
+    except psutil.AccessDenied:
+        return "Permission denied. This tool requires elevated privileges to view all network connections."
+    except Exception as e:
+        return f"Error getting network connections: {str(e)}"
+
+
+async def get_listening_ports(host: Optional[str] = None, username: Optional[str] = None) -> str:
+    """
+    Get listening ports.
+    
+    Args:
+        host: Optional remote host to connect to
+        username: Optional SSH username (required if host is provided)
+        
+    Returns:
+        Formatted string with listening ports
+    """
+    try:
+        if host:
+            # Remote execution - use ss or netstat command
+            # Try ss first (modern tool)
+            returncode, stdout, _ = await execute_command(
+                ["ss", "-tulnp"],
+                host=host,
+                username=username
+            )
+            
+            if returncode == 0 and stdout:
+                info = []
+                info.append("=== Listening Ports ===\n")
+                info.append(stdout)
+                
+                # Count listening ports
+                lines = stdout.strip().split('\n')
+                info.append(f"\n\nTotal listening ports: {len(lines) - 1}")  # -1 for header
+                
+                return "\n".join(info)
+            else:
+                # Fallback to netstat
+                returncode, stdout, _ = await execute_command(
+                    ["netstat", "-tulnp"],
+                    host=host,
+                    username=username
+                )
+                
+                if returncode == 0 and stdout:
+                    info = []
+                    info.append("=== Listening Ports ===\n")
+                    info.append(stdout)
+                    return "\n".join(info)
+                else:
+                    return "Error: Neither ss nor netstat command available on remote host"
+        else:
+            # Local execution - use psutil
+            info = []
+            info.append("=== Listening Ports ===\n")
+            info.append(f"{'Proto':<8} {'Local Address':<30} {'Status':<15} {'PID/Program'}")
+            info.append("-" * 80)
+            
+            # Get connections in LISTEN state
+            connections = psutil.net_connections(kind='inet')
+            listening = [c for c in connections if c.status == 'LISTEN' or c.type == socket.SOCK_DGRAM]
+            
+            for conn in listening:
+                proto = "TCP" if conn.type == socket.SOCK_STREAM else "UDP"
+                
+                local_addr = f"{conn.laddr.ip}:{conn.laddr.port}" if conn.laddr else "N/A"
+                status = conn.status if conn.status else "LISTENING"
+                
+                # Try to get process info
+                pid_info = str(conn.pid) if conn.pid else "N/A"
+                if conn.pid:
+                    try:
+                        proc = psutil.Process(conn.pid)
+                        pid_info = f"{conn.pid}/{proc.name()}"
+                    except (psutil.NoSuchProcess, psutil.AccessDenied):
+                        pass
+                
+                info.append(
+                    f"{proto:<8} {local_addr:<30} {status:<15} {pid_info}"
+                )
+            
+            info.append(f"\n\nTotal listening ports: {len(listening)}")
+            
+            return "\n".join(info)
+    except psutil.AccessDenied:
+        return "Permission denied. This tool requires elevated privileges to view all listening ports."
+    except Exception as e:
+        return f"Error getting listening ports: {str(e)}"
+

linux_mcp_server/tools/processes.py

@@ -0,0 +1,257 @@
+"""Process management tools."""
+
+import psutil
+from datetime import datetime
+from typing import Optional
+
+from .validation import validate_pid
+from .ssh_executor import execute_command
+from .utils import format_bytes
+
+
+async def list_processes(host: Optional[str] = None, username: Optional[str] = None) -> str:
+    """
+    List running processes.
+    
+    Args:
+        host: Optional remote host to connect to
+        username: Optional SSH username (required if host is provided)
+        
+    Returns:
+        Formatted string with process list
+    """
+    try:
+        if host:
+            # Remote execution - use ps command
+            returncode, stdout, _ = await execute_command(
+                ["ps", "aux", "--sort=-%cpu"],
+                host=host,
+                username=username
+            )
+            
+            if returncode == 0 and stdout:
+                info = []
+                info.append("=== Running Processes ===\n")
+                
+                lines = stdout.strip().split('\n')
+                # Take header and top 100 processes
+                if len(lines) > 101:
+                    info.append('\n'.join(lines[:101]))
+                    info.append(f"\n\nTotal processes: {len(lines) - 1}")
+                    info.append(f"Showing: Top 100 by CPU usage")
+                else:
+                    info.append(stdout)
+                    info.append(f"\n\nTotal processes: {len(lines) - 1}")
+                
+                return "\n".join(info)
+            else:
+                return "Error executing ps command on remote host"
+        else:
+            # Local execution - use psutil
+            info = []
+            info.append("=== Running Processes ===\n")
+            info.append(f"{'PID':<8} {'User':<12} {'CPU%':<8} {'Memory%':<10} {'Status':<12} {'Name':<30} {'Command'}")
+            info.append("-" * 120)
+            
+            # Get all processes
+            processes = []
+            for proc in psutil.process_iter(['pid', 'name', 'username', 'cpu_percent', 'memory_percent', 'status', 'cmdline']):
+                try:
+                    processes.append(proc.info)
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    pass
+            
+            # Sort by CPU usage (descending)
+            processes.sort(key=lambda x: x.get('cpu_percent', 0) or 0, reverse=True)
+            
+            # Show top processes (limit to reasonable number)
+            for proc_info in processes[:100]:  # Show top 100 processes
+                pid = proc_info.get('pid', 'N/A')
+                username_val = proc_info.get('username', 'N/A')
+                if username_val and len(username_val) > 12:
+                    username_val = username_val[:9] + '...'
+                
+                cpu = proc_info.get('cpu_percent', 0) or 0
+                mem = proc_info.get('memory_percent', 0) or 0
+                status = proc_info.get('status', 'N/A')
+                name = proc_info.get('name', 'N/A')
+                if name and len(name) > 30:
+                    name = name[:27] + '...'
+                
+                cmdline = proc_info.get('cmdline', [])
+                if cmdline:
+                    cmd = ' '.join(cmdline)
+                    if len(cmd) > 40:
+                        cmd = cmd[:37] + '...'
+                else:
+                    cmd = name
+                
+                info.append(
+                    f"{pid:<8} {username_val:<12} {cpu:<8.1f} {mem:<10.1f} {status:<12} {name:<30} {cmd}"
+                )
+            
+            # Add summary
+            total_processes = len(list(psutil.process_iter()))
+            info.append(f"\n\nTotal processes: {total_processes}")
+            info.append(f"Showing: Top 100 by CPU usage")
+            
+            return "\n".join(info)
+    except Exception as e:
+        return f"Error listing processes: {str(e)}"
+
+
+async def get_process_info(pid: int, host: Optional[str] = None, username: Optional[str] = None) -> str:
+    """
+    Get information about a specific process.
+    
+    Args:
+        pid: Process ID
+        host: Optional remote host to connect to
+        username: Optional SSH username (required if host is provided)
+        
+    Returns:
+        Formatted string with process information
+    """
+    try:
+        # Validate PID (accepts floats from LLMs)
+        pid, error = validate_pid(pid)
+        if error:
+            return error
+        
+        if host:
+            # Remote execution - use ps command
+            returncode, stdout, _ = await execute_command(
+                ["ps", "-p", str(pid), "-o", "pid,user,stat,pcpu,pmem,vsz,rss,etime,comm,args"],
+                host=host,
+                username=username
+            )
+            
+            if returncode != 0:
+                return f"Process with PID {pid} does not exist on remote host."
+            
+            if stdout:
+                info = []
+                info.append(f"=== Process Information for PID {pid} ===\n")
+                info.append(stdout)
+                
+                # Try to get more details with /proc
+                returncode, stdout, _ = await execute_command(
+                    ["cat", f"/proc/{pid}/status"],
+                    host=host,
+                    username=username
+                )
+                
+                if returncode == 0 and stdout:
+                    info.append("\n=== Detailed Status (/proc) ===")
+                    # Filter to show most relevant fields
+                    relevant_fields = ['Name:', 'State:', 'Tgid:', 'Pid:', 'PPid:', 'Threads:', 'VmPeak:', 'VmSize:', 'VmRSS:']
+                    for line in stdout.split('\n'):
+                        if any(field in line for field in relevant_fields):
+                            info.append(line)
+                
+                return "\n".join(info)
+            else:
+                return f"Process with PID {pid} does not exist on remote host."
+        else:
+            # Local execution - use psutil
+            # Check if process exists
+            if not psutil.pid_exists(pid):
+                return f"Process with PID {pid} does not exist."
+            
+            proc = psutil.Process(pid)
+            info = []
+            
+            info.append(f"=== Process Information for PID {pid} ===\n")
+            
+            # Basic info
+            try:
+                info.append(f"Name: {proc.name()}")
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                pass
+            
+            try:
+                info.append(f"Executable: {proc.exe()}")
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                info.append("Executable: [Access Denied]")
+            
+            try:
+                info.append(f"Command Line: {' '.join(proc.cmdline())}")
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                pass
+            
+            try:
+                info.append(f"Status: {proc.status()}")
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                pass
+            
+            try:
+                info.append(f"User: {proc.username()}")
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                pass
+            
+            # Process IDs
+            try:
+                info.append(f"\nPID: {proc.pid}")
+                info.append(f"Parent PID: {proc.ppid()}")
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                pass
+            
+            # Resource usage
+            try:
+                info.append(f"\n=== Resource Usage ===")
+                cpu_percent = proc.cpu_percent(interval=0.1)
+                info.append(f"CPU Percent: {cpu_percent}%")
+                
+                mem_info = proc.memory_info()
+                info.append(f"Memory RSS: {format_bytes(mem_info.rss)}")
+                info.append(f"Memory VMS: {format_bytes(mem_info.vms)}")
+                info.append(f"Memory Percent: {proc.memory_percent():.2f}%")
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                info.append("Resource usage: [Access Denied]")
+            
+            # Timing
+            try:
+                create_time = datetime.fromtimestamp(proc.create_time())
+                info.append(f"\n=== Timing ===")
+                info.append(f"Created: {create_time.strftime('%Y-%m-%d %H:%M:%S')}")
+                
+                cpu_times = proc.cpu_times()
+                info.append(f"CPU Time (user): {cpu_times.user:.2f}s")
+                info.append(f"CPU Time (system): {cpu_times.system:.2f}s")
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                pass
+            
+            # Threads
+            try:
+                num_threads = proc.num_threads()
+                info.append(f"\nThreads: {num_threads}")
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                pass
+            
+            # File descriptors
+            try:
+                num_fds = proc.num_fds()
+                info.append(f"Open File Descriptors: {num_fds}")
+            except (psutil.NoSuchProcess, psutil.AccessDenied, AttributeError):
+                pass  # Not available on all systems
+            
+            # Connections
+            try:
+                connections = proc.connections()
+                if connections:
+                    info.append(f"\n=== Network Connections ({len(connections)}) ===")
+                    for i, conn in enumerate(connections[:10]):  # Show first 10
+                        info.append(f"  {conn.type.name}: {conn.laddr} -> {conn.raddr if conn.raddr else 'N/A'} [{conn.status}]")
+                    if len(connections) > 10:
+                        info.append(f"  ... and {len(connections) - 10} more")
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                pass
+            
+            return "\n".join(info)
+    except psutil.NoSuchProcess:
+        return f"Process with PID {pid} does not exist."
+    except psutil.AccessDenied:
+        return f"Access denied to process with PID {pid}. Try running with elevated privileges."
+    except Exception as e:
+        return f"Error getting process information: {str(e)}"
+

linux_mcp_server/tools/services.py

@@ -0,0 +1,147 @@
+"""Service management tools."""
+
+from typing import Optional
+
+from .validation import validate_line_count
+from .ssh_executor import execute_command
+
+
+async def list_services(host: Optional[str] = None, username: Optional[str] = None) -> str:
+    """
+    List all systemd services.
+    
+    Args:
+        host: Optional remote host to connect to
+        username: Optional SSH username (required if host is provided)
+        
+    Returns:
+        Formatted string with service list
+    """
+    try:
+        # Run systemctl to list all services
+        returncode, stdout, stderr = await execute_command(
+            ["systemctl", "list-units", "--type=service", "--all", "--no-pager"],
+            host=host,
+            username=username
+        )
+        
+        if returncode != 0:
+            return f"Error listing services: {stderr}"
+        
+        # Format the output
+        result = ["=== System Services ===\n"]
+        result.append(stdout)
+        
+        # Get summary
+        returncode_summary, stdout_summary, _ = await execute_command(
+            ["systemctl", "list-units", "--type=service", "--state=running", "--no-pager"],
+            host=host,
+            username=username
+        )
+        
+        if returncode_summary == 0:
+            running_count = len([l for l in stdout_summary.split('\n') if '.service' in l])
+            result.append(f"\n\nSummary: {running_count} services currently running")
+        
+        return "\n".join(result)
+    except FileNotFoundError:
+        return "Error: systemctl command not found. This tool requires systemd."
+    except Exception as e:
+        return f"Error listing services: {str(e)}"
+
+
+async def get_service_status(
+    service_name: str,
+    host: Optional[str] = None,
+    username: Optional[str] = None
+) -> str:
+    """
+    Get status of a specific service.
+    
+    Args:
+        service_name: Name of the service
+        host: Optional remote host to connect to
+        username: Optional SSH username (required if host is provided)
+        
+    Returns:
+        Formatted string with service status
+    """
+    try:
+        # Ensure service name has .service suffix if not present
+        if not service_name.endswith('.service') and '.' not in service_name:
+            service_name = f"{service_name}.service"
+        
+        # Run systemctl status
+        returncode, stdout, stderr = await execute_command(
+            ["systemctl", "status", service_name, "--no-pager", "--full"],
+            host=host,
+            username=username
+        )
+        
+        # Note: systemctl status returns non-zero for inactive services, but that's expected
+        if not stdout and stderr:
+            # Service not found
+            if "not found" in stderr.lower() or "could not be found" in stderr.lower():
+                return f"Service '{service_name}' not found on this system."
+            return f"Error getting service status: {stderr}"
+        
+        result = [f"=== Status of {service_name} ===\n"]
+        result.append(stdout)
+        
+        return "\n".join(result)
+    except FileNotFoundError:
+        return "Error: systemctl command not found. This tool requires systemd."
+    except Exception as e:
+        return f"Error getting service status: {str(e)}"
+
+
+async def get_service_logs(
+    service_name: str,
+    lines: int = 50,
+    host: Optional[str] = None,
+    username: Optional[str] = None
+) -> str:
+    """
+    Get logs for a specific service.
+    
+    Args:
+        service_name: Name of the service
+        lines: Number of log lines to retrieve (default: 50)
+        host: Optional remote host to connect to
+        username: Optional SSH username (required if host is provided)
+        
+    Returns:
+        Formatted string with service logs
+    """
+    try:
+        # Validate lines parameter (accepts floats from LLMs)
+        lines, _ = validate_line_count(lines, default=50)
+        
+        # Ensure service name has .service suffix if not present
+        if not service_name.endswith('.service') and '.' not in service_name:
+            service_name = f"{service_name}.service"
+        
+        # Run journalctl for the service
+        returncode, stdout, stderr = await execute_command(
+            ["journalctl", "-u", service_name, "-n", str(lines), "--no-pager"],
+            host=host,
+            username=username
+        )
+        
+        if returncode != 0:
+            if "not found" in stderr.lower() or "no entries" in stderr.lower():
+                return f"No logs found for service '{service_name}'. The service may not exist or has no log entries."
+            return f"Error getting service logs: {stderr}"
+        
+        if not stdout or stdout.strip() == "":
+            return f"No log entries found for service '{service_name}'."
+        
+        result = [f"=== Last {lines} log entries for {service_name} ===\n"]
+        result.append(stdout)
+        
+        return "\n".join(result)
+    except FileNotFoundError:
+        return "Error: journalctl command not found. This tool requires systemd."
+    except Exception as e:
+        return f"Error getting service logs: {str(e)}"
+