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

linux_mcp_server/tools/network.py

@@ -0,0 +1,288 @@
+"""Network diagnostic tools."""
+
+import socket
+
+import psutil
+
+from mcp.types import ToolAnnotations
+
+from linux_mcp_server.audit import log_tool_call
+from linux_mcp_server.connection.ssh import execute_command
+from linux_mcp_server.server import mcp
+from linux_mcp_server.utils import format_bytes
+from linux_mcp_server.utils.types import Host
+from linux_mcp_server.utils.types import Username
+
+
+@mcp.tool(
+    title="Get network interfaces",
+    description="Get detailed information about network interfaces including address and traffic statistics.",
+    annotations=ToolAnnotations(readOnlyHint=True),
+)
+@log_tool_call
+async def get_network_interfaces(  # noqa: C901
+    host: Host | None = None,
+    username: Username | None = None,
+) -> str:
+    """
+    Get 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)}"
+
+
+@mcp.tool(
+    title="Get network connections",
+    description="Get detailed information about active network connections.",
+    annotations=ToolAnnotations(readOnlyHint=True),
+)
+@log_tool_call
+async def get_network_connections(
+    host: Host | None = None,
+    username: Username | None = None,
+) -> str:
+    """
+    Get 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)}"
+
+
+@mcp.tool(
+    title="Get listening ports",
+    description="Get details on listening port, protocols, and services.",
+    annotations=ToolAnnotations(readOnlyHint=True),
+)
+@log_tool_call
+async def get_listening_ports(
+    host: Host | None = None,
+    username: Username | None = None,
+) -> str:
+    """
+    Get 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,273 @@
+"""Process management tools."""
+
+import typing as t
+
+from datetime import datetime
+
+import psutil
+
+from mcp.types import ToolAnnotations
+
+from linux_mcp_server.audit import log_tool_call
+from linux_mcp_server.connection.ssh import execute_command
+from linux_mcp_server.server import mcp
+from linux_mcp_server.utils import format_bytes
+from linux_mcp_server.utils.types import Host
+from linux_mcp_server.utils.types import Username
+from linux_mcp_server.utils.validation import validate_pid
+
+
+@mcp.tool(
+    title="List processes",
+    description="List running processes",
+    annotations=ToolAnnotations(readOnlyHint=True),
+)
+@log_tool_call
+async def list_processes(
+    host: Host | None = None,
+    username: Username | None = None,
+) -> str:
+    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("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("Showing: Top 100 by CPU usage")
+
+            return "\n".join(info)
+    except Exception as e:
+        return f"Error listing processes: {str(e)}"
+
+
+@mcp.tool(
+    title="Process details",
+    description="Get information about a specific process.",
+    annotations=ToolAnnotations(readOnlyHint=True),
+)
+@log_tool_call
+async def get_process_info(  # noqa: C901
+    pid: t.Annotated[int, "Process ID"],
+    host: Host | None = None,
+    username: Username | None = None,
+) -> str:
+    # Validate PID (accepts floats from LLMs)
+    validated_pid, error = validate_pid(pid)
+    if error:
+        return error
+
+    if validated_pid is None:
+        return "Invalid PID"
+
+    try:
+        if host:
+            # Remote execution - use ps command
+            returncode, stdout, _ = await execute_command(
+                ["ps", "-p", str(validated_pid), "-o", "pid,user,stat,pcpu,pmem,vsz,rss,etime,comm,args"],
+                host=host,
+                username=username,
+            )
+
+            if returncode != 0:
+                return f"Process with PID {validated_pid} does not exist on remote host."
+
+            if stdout:
+                info = []
+                info.append(f"=== Process Information for PID {validated_pid} ===\n")
+                info.append(stdout)
+
+                # Try to get more details with /proc
+                returncode, stdout, _ = await execute_command(
+                    ["cat", f"/proc/{validated_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 {validated_pid} does not exist on remote host."
+        else:
+            # Local execution - use psutil
+            # Check if process exists
+            if not psutil.pid_exists(validated_pid):
+                return f"Process with PID {validated_pid} does not exist."
+
+            proc = psutil.Process(validated_pid)
+            info = []
+
+            info.append(f"=== Process Information for PID {validated_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("\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("\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 _, 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 {validated_pid} does not exist."
+    except psutil.AccessDenied:
+        return f"Access denied to process with PID {validated_pid}. Try running with elevated privileges."
+    except Exception as e:
+        return f"Error getting process information: {str(e)}"