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

linux_mcp_server/tools/services.py

@@ -0,0 +1,149 @@
+"""Service management tools."""
+
+import typing as t
+
+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.types import Host
+from linux_mcp_server.utils.types import Username
+from linux_mcp_server.utils.validation import validate_line_count
+
+
+@mcp.tool(
+    title="List services",
+    description="List all systemd services.",
+    annotations=ToolAnnotations(readOnlyHint=True),
+)
+@log_tool_call
+async def list_services(
+    host: Host | None = None,
+    username: Username | None = None,
+) -> str:
+    """
+    List all systemd services.
+    """
+    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([line for line in stdout_summary.split("\n") if ".service" in line])
+            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)}"
+
+
+@mcp.tool(
+    title="Get service status",
+    description="Get detailed status of a specific systemd service.",
+    annotations=ToolAnnotations(readOnlyHint=True),
+)
+@log_tool_call
+async def get_service_status(
+    service_name: t.Annotated[str, "Name of the service"],
+    host: Host | None = None,
+    username: Username | None = None,
+) -> str:
+    """
+    Get status of a specific service.
+    """
+    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
+        _, 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)}"
+
+
+@mcp.tool(
+    title="Get service logs",
+    description="Get recent logs for a specific systemd service.",
+    annotations=ToolAnnotations(readOnlyHint=True),
+)
+@log_tool_call
+async def get_service_logs(
+    service_name: t.Annotated[str, "Name of the service"],
+    lines: t.Annotated[int, "Number of log lines to retrieve."] = 50,
+    host: Host | None = None,
+    username: Username | None = None,
+) -> str:
+    """
+    Get logs for a specific service.
+    """
+    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)}"

linux_mcp_server/tools/storage.py

@@ -0,0 +1,194 @@
+"""Storage and hardware tools."""
+
+import os
+import typing as t
+
+from pathlib import Path
+
+import psutil
+
+from mcp.server.fastmcp.exceptions import ToolError
+from mcp.types import ToolAnnotations
+from pydantic import BaseModel
+from pydantic import Field
+
+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 import StrEnum
+from linux_mcp_server.utils.types import Host
+from linux_mcp_server.utils.types import Username
+
+
+class DirectoryEntry(BaseModel):
+    size: int = 0
+    modified: float = 0.0
+    name: str = ""
+
+
+class OrderBy(StrEnum):
+    SIZE = "size"
+    NAME = "name"
+    MODIFIED = "modified"
+
+
+class SortBy(StrEnum):
+    ASCENDING = "ascending"
+    DESCENDING = "descending"
+
+
+@mcp.tool(
+    title="List block devices",
+    description="List block devices on the system",
+    annotations=ToolAnnotations(readOnlyHint=True),
+)
+@log_tool_call
+async def list_block_devices(
+    host: Host | None = None,
+    username: Username | None = None,
+) -> str:
+    """
+    List block devices.
+    """
+    try:
+        # Try using lsblk first (most readable)
+        returncode, stdout, _ = await execute_command(
+            ["lsblk", "-o", "NAME,SIZE,TYPE,MOUNTPOINT,FSTYPE,MODEL", "--no-pager"],
+            host=host,
+            username=username,
+        )
+
+        if returncode == 0:
+            result = ["=== Block Devices ===\n"]
+            result.append(stdout)
+
+            # Add disk I/O per-disk stats if available (only for local execution)
+            if not host:
+                try:
+                    disk_io_per_disk = psutil.disk_io_counters(perdisk=True)
+                    if disk_io_per_disk:
+                        result.append("\n=== Disk I/O Statistics (per disk) ===")
+                        for disk, stats in sorted(disk_io_per_disk.items()):
+                            result.append(f"\n{disk}:")
+                            result.append(f"  Read: {format_bytes(stats.read_bytes)}")
+                            result.append(f"  Write: {format_bytes(stats.write_bytes)}")
+                            result.append(f"  Read Count: {stats.read_count}")
+                            result.append(f"  Write Count: {stats.write_count}")
+                except Exception:
+                    pass
+
+            return "\n".join(result)
+        else:
+            # Fallback to listing partitions with psutil
+            result = ["=== Block Devices (fallback) ===\n"]
+            partitions = psutil.disk_partitions(all=True)
+
+            for partition in partitions:
+                result.append(f"\nDevice: {partition.device}")
+                result.append(f"  Mountpoint: {partition.mountpoint}")
+                result.append(f"  Filesystem: {partition.fstype}")
+                result.append(f"  Options: {partition.opts}")
+
+            return "\n".join(result)
+    except FileNotFoundError:
+        # If lsblk is not available, use psutil
+        result = ["=== Block Devices ===\n"]
+        partitions = psutil.disk_partitions(all=True)
+
+        for partition in partitions:
+            result.append(f"\nDevice: {partition.device}")
+            result.append(f"  Mountpoint: {partition.mountpoint}")
+            result.append(f"  Filesystem: {partition.fstype}")
+            result.append(f"  Options: {partition.opts}")
+
+        return "\n".join(result)
+    except Exception as e:
+        return f"Error listing block devices: {str(e)}"
+
+
+@mcp.tool(
+    title="List directories",
+    description="List directories under a specified path with flexible sorting options.",
+    annotations=ToolAnnotations(readOnlyHint=True),
+)
+@log_tool_call
+async def list_directories(  # noqa: C901
+    path: t.Annotated[str, "The directory path to analyze"],
+    order_by: t.Annotated[OrderBy, "Sort order - 'size', 'name', or 'modified' (default: 'name')"] = OrderBy.NAME,
+    sort: t.Annotated[SortBy, "Sort direction - 'ascending' or 'descending' (default: 'ascending')"] = SortBy.ASCENDING,
+    top_n: t.Annotated[
+        int | None,
+        Field(
+            description="Optional limit on number of directories to return (1-1000, only used with size ordering)",
+            gt=0,
+            le=1_000,
+        ),
+    ] = None,
+    host: Host | None = None,
+    username: Username | None = None,
+) -> t.Annotated[
+    list[DirectoryEntry],
+    "List of directories with size or modified timestamp",
+]:
+    # For local execution, validate path
+    if not host:
+        try:
+            path_obj = Path(path).resolve(strict=True)
+        except (OSError, RuntimeError):
+            raise ToolError(f"Path does not exist or cannot be resolved: {path}")
+
+        if not path_obj.is_dir():
+            raise ToolError(f"Path is not a directory: {path}")
+
+        if not os.access(path_obj, os.R_OK):
+            raise ToolError(f"Permission denied to read directory: {path}")
+
+        path = str(path_obj)
+
+    match order_by:
+        case OrderBy.SIZE:
+            # Use du command to get directory sizes efficiently
+            command = ["du", "-b", "--max-depth=1", path]
+        case OrderBy.NAME:
+            # Use find to list only immediate subdirectories
+            command = ["find", path, "-mindepth", "1", "-maxdepth", "1", "-type", "d", "-printf", "%f\\n"]
+        case OrderBy.MODIFIED:  # pragma: no branch
+            # Use find with modification time
+            command = ["find", path, "-mindepth", "1", "-maxdepth", "1", "-type", "d", "-printf", "%T@\\t%f\\n"]
+
+    returncode, stdout, _ = await execute_command(
+        command,
+        host=host,
+        username=username,
+    )
+
+    if returncode != 0:
+        raise ToolError(f"Error running {command[0]} command: command failed with return code {returncode}")
+
+    lines = [line.strip() for line in stdout.strip().splitlines() if line]
+
+    match order_by:
+        case OrderBy.SIZE:
+            directories = [
+                DirectoryEntry(size=int(size), name=Path(dir_path_str).name)
+                for line in lines
+                for size, dir_path_str in [line.split("\t", 1)]
+                if dir_path_str != path
+            ]
+        case OrderBy.NAME:
+            directories = [DirectoryEntry(name=line) for line in lines]
+        case OrderBy.MODIFIED:  # pragma: no branch
+            directories = [
+                DirectoryEntry(modified=float(timestamp), name=dir_name)
+                for line in lines
+                for timestamp, dir_name in [line.split("\t", 1)]
+            ]
+
+    # Sort by the order_by field
+    directories.sort(key=lambda x: getattr(x, order_by), reverse=sort == SortBy.DESCENDING)
+
+    if top_n:
+        return directories[:top_n]
+
+    return directories