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

linux_mcp_server/logging_config.py

@@ -0,0 +1,176 @@
+"""Centralized logging configuration for Linux MCP Server.
+
+Simplified logging setup with standard Python logging infrastructure.
+Supports structured logging with extra fields for audit and diagnostic purposes.
+"""
+
+import json
+import logging
+import logging.handlers
+import os
+
+from pathlib import Path
+
+
+def get_log_directory() -> Path:
+    """Get the log directory path, creating it if necessary."""
+    env_log_dir = os.getenv("LINUX_MCP_LOG_DIR")
+    log_dir = Path(env_log_dir) if env_log_dir else Path.home() / ".local" / "share" / "linux-mcp-server" / "logs"
+    log_dir.mkdir(parents=True, exist_ok=True)
+    return log_dir
+
+
+def get_log_level() -> int:
+    """Get the log level from environment variable (defaults to INFO)."""
+    level_name = os.getenv("LINUX_MCP_LOG_LEVEL", "INFO").upper()
+    return getattr(logging, level_name, logging.INFO)
+
+
+def get_retention_days() -> int:
+    """Get the log retention days from environment variable (defaults to 10)."""
+    try:
+        return int(os.getenv("LINUX_MCP_LOG_RETENTION_DAYS", "10"))
+    except ValueError:
+        return 10
+
+
+class StructuredFormatter(logging.Formatter):
+    """
+    Structured log formatter supporting extra fields.
+
+    Format: TIMESTAMP | LEVEL | MODULE | MESSAGE | key=value ...
+    Extra fields added to LogRecord are appended as key=value pairs.
+    """
+
+    STANDARD_FIELDS = {
+        "name",
+        "msg",
+        "args",
+        "created",
+        "filename",
+        "funcName",
+        "levelname",
+        "levelno",
+        "lineno",
+        "module",
+        "msecs",
+        "message",
+        "pathname",
+        "process",
+        "processName",
+        "relativeCreated",
+        "thread",
+        "threadName",
+        "exc_info",
+        "exc_text",
+        "stack_info",
+        "asctime",
+        "taskName",
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format a log record with extra fields."""
+        # Base message
+        base_msg = super().format(record)
+
+        # Append extra fields as key=value pairs
+        extra_fields = [f"{k}={v}" for k, v in record.__dict__.items() if k not in self.STANDARD_FIELDS]
+
+        return f"{base_msg} | {' | '.join(extra_fields)}" if extra_fields else base_msg
+
+
+class JSONFormatter(logging.Formatter):
+    """JSON log formatter for machine-readable logs."""
+
+    EXCLUDE_FIELDS = {
+        "args",
+        "exc_text",
+        "exc_info",
+        "stack_info",
+        "filename",
+        "funcName",
+        "lineno",
+        "module",
+        "msecs",
+        "pathname",
+        "process",
+        "processName",
+        "relativeCreated",
+        "thread",
+        "threadName",
+        "taskName",
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format a log record as JSON."""
+        log_data = {
+            "timestamp": self.formatTime(record, self.datefmt),
+            "level": record.levelname,
+            "logger": record.name,
+            "message": record.getMessage(),
+        }
+
+        # Add exception info if present
+        if record.exc_info:
+            log_data["exception"] = self.formatException(record.exc_info)
+
+        # Add extra fields
+        for key, value in record.__dict__.items():
+            if (
+                key not in self.EXCLUDE_FIELDS
+                and key not in log_data
+                and key not in {"name", "msg", "levelname", "levelno", "created"}
+            ):
+                log_data[key] = value
+
+        return json.dumps(log_data)
+
+
+def setup_logging():
+    """Set up logging with structured formatters and rotation."""
+    log_dir = get_log_directory()
+    log_level = get_log_level()
+    retention_days = get_retention_days()
+
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(log_level)
+    root_logger.handlers.clear()  # Remove existing handlers
+
+    # Human-readable text log
+    text_handler = logging.handlers.TimedRotatingFileHandler(
+        filename=log_dir / "server.log",
+        when="midnight",
+        interval=1,
+        backupCount=retention_days,
+        encoding="utf-8",
+    )
+    text_handler.setLevel(log_level)
+    text_handler.setFormatter(
+        StructuredFormatter("%(asctime)s | %(levelname)s | %(name)s | %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+    )
+    text_handler.suffix = "%Y-%m-%d"
+    root_logger.addHandler(text_handler)
+
+    # JSON log
+    json_handler = logging.handlers.TimedRotatingFileHandler(
+        filename=log_dir / "server.json",
+        when="midnight",
+        interval=1,
+        backupCount=retention_days,
+        encoding="utf-8",
+    )
+    json_handler.setLevel(log_level)
+    json_handler.setFormatter(JSONFormatter(datefmt="%Y-%m-%dT%H:%M:%S"))
+    json_handler.suffix = "%Y-%m-%d"
+    root_logger.addHandler(json_handler)
+
+    # Console handler for development
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(log_level)
+    console_handler.setFormatter(
+        StructuredFormatter("%(asctime)s | %(levelname)s | %(name)s | %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
+    )
+    root_logger.addHandler(console_handler)
+
+    root_logger.info(f"Logging initialized: {log_dir}")

linux_mcp_server/server.py

@@ -0,0 +1,18 @@
+"""Core MCP server for Linux diagnostics using FastMCP."""
+
+import logging
+
+from mcp.server.fastmcp import FastMCP
+
+
+logger = logging.getLogger("linux-mcp-server")
+
+
+# Initialize FastMCP server
+mcp = FastMCP("linux-diagnostics")
+
+from linux_mcp_server.tools import *  # noqa: E402, F403
+
+
+def main():
+    mcp.run()

linux_mcp_server/tools/__init__.py

@@ -0,0 +1,51 @@
+# logs
+from linux_mcp_server.tools.logs import get_audit_logs
+from linux_mcp_server.tools.logs import get_journal_logs
+from linux_mcp_server.tools.logs import read_log_file
+
+# network
+from linux_mcp_server.tools.network import get_listening_ports
+from linux_mcp_server.tools.network import get_network_connections
+from linux_mcp_server.tools.network import get_network_interfaces
+
+# processes
+from linux_mcp_server.tools.processes import get_process_info
+from linux_mcp_server.tools.processes import list_processes
+
+# services
+from linux_mcp_server.tools.services import get_service_logs
+from linux_mcp_server.tools.services import get_service_status
+from linux_mcp_server.tools.services import list_services
+
+# storage
+from linux_mcp_server.tools.storage import list_block_devices
+from linux_mcp_server.tools.storage import list_directories
+
+# system_info
+from linux_mcp_server.tools.system_info import get_cpu_information
+from linux_mcp_server.tools.system_info import get_disk_usage
+from linux_mcp_server.tools.system_info import get_hardware_information
+from linux_mcp_server.tools.system_info import get_memory_information
+from linux_mcp_server.tools.system_info import get_system_information
+
+
+__all__ = [
+    "get_audit_logs",
+    "get_cpu_information",
+    "get_disk_usage",
+    "get_hardware_information",
+    "get_journal_logs",
+    "get_listening_ports",
+    "get_memory_information",
+    "get_network_connections",
+    "get_network_interfaces",
+    "get_process_info",
+    "get_service_logs",
+    "get_service_status",
+    "get_system_information",
+    "list_block_devices",
+    "list_directories",
+    "list_processes",
+    "list_services",
+    "read_log_file",
+]

linux_mcp_server/tools/logs.py

@@ -0,0 +1,221 @@
+"""Log and audit tools."""
+
+import os
+import typing as t
+
+from pathlib import Path
+
+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="Get journal logs",
+    description="Get systemd journal logs.",
+    annotations=ToolAnnotations(readOnlyHint=True),
+)
+@log_tool_call
+async def get_journal_logs(
+    unit: t.Annotated[str | None, "Systemd unit name used for filtering."] = None,
+    priority: t.Annotated[str | None, "Priority level used for filtering."] = None,
+    since: t.Annotated[str | None, "Show entries since specified time."] = None,
+    lines: t.Annotated[int, "Number of log lines to retrieve."] = 100,
+    host: Host | None = None,
+    username: Username | None = None,
+) -> str:
+    """
+    Get systemd journal logs.
+    """
+    try:
+        # Validate lines parameter (accepts floats from LLMs)
+        lines, _ = validate_line_count(lines, default=100)
+
+        cmd = ["journalctl", "-n", str(lines), "--no-pager"]
+
+        if unit:
+            cmd.extend(["-u", unit])
+
+        if priority:
+            cmd.extend(["-p", priority])
+
+        if since:
+            cmd.extend(["--since", since])
+
+        returncode, stdout, stderr = await execute_command(cmd, host=host, username=username)
+
+        if returncode != 0:
+            return f"Error reading journal logs: {stderr}"
+
+        if not stdout or stdout.strip() == "":
+            return "No journal entries found matching the criteria."
+
+        # Build filter description
+        filters = []
+        if unit:
+            filters.append(f"unit={unit}")
+        if priority:
+            filters.append(f"priority={priority}")
+        if since:
+            filters.append(f"since={since}")
+
+        filter_desc = ", ".join(filters) if filters else "no filters"
+
+        result = [f"=== Journal Logs (last {lines} entries, {filter_desc}) ===\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 reading journal logs: {str(e)}"
+
+
+@mcp.tool(
+    title="Get audit logs",
+    description="Read the system audit logs. This requires root privileges.",
+    annotations=ToolAnnotations(readOnlyHint=True),
+)
+@log_tool_call
+async def get_audit_logs(
+    lines: t.Annotated[int, "Number of log lines to retrieve."] = 100,
+    host: Host | None = None,
+    username: Username | None = None,
+) -> str:
+    """
+    Get audit logs.
+    """
+    # Validate lines parameter (accepts floats from LLMs)
+    lines, _ = validate_line_count(lines, default=100)
+
+    audit_log_path = "/var/log/audit/audit.log"
+
+    try:
+        # For local execution, check if file exists
+        if not host and not os.path.exists(audit_log_path):
+            return f"Audit log file not found at {audit_log_path}. Audit logging may not be enabled."
+
+        # Use tail to read last N lines
+        returncode, stdout, stderr = await execute_command(
+            ["tail", "-n", str(lines), audit_log_path],
+            host=host,
+            username=username,
+        )
+
+        if returncode != 0:
+            if "Permission denied" in stderr:
+                return f"Permission denied reading audit logs. This tool requires elevated privileges (root) to read {audit_log_path}."
+            return f"Error reading audit logs: {stderr}"
+
+        if not stdout or stdout.strip() == "":
+            return "No audit log entries found."
+
+        result = [f"=== Audit Logs (last {lines} entries) ===\n"]
+        result.append(stdout)
+
+        return "\n".join(result)
+    except FileNotFoundError:
+        return "Error: tail command not found."
+    except Exception as e:
+        return f"Error reading audit logs: {str(e)}"
+
+
+@mcp.tool(
+    title="Read log file",
+    description="Read a specific log file.",
+    annotations=ToolAnnotations(readOnlyHint=True),
+)
+@log_tool_call
+async def read_log_file(  # noqa: C901
+    log_path: t.Annotated[str, "Path to the log file"],
+    lines: t.Annotated[int, "Number of lines to retrieve from the end."] = 100,
+    host: Host | None = None,
+    username: Username | None = None,
+) -> str:
+    """
+    Read a specific log file.
+    """
+    try:
+        # Validate lines parameter (accepts floats from LLMs)
+        lines, _ = validate_line_count(lines, default=100)
+
+        # Get allowed log paths from environment variable
+        allowed_paths_env = os.getenv("LINUX_MCP_ALLOWED_LOG_PATHS", "")
+
+        if not allowed_paths_env:
+            return (
+                "No log files are allowed. Set LINUX_MCP_ALLOWED_LOG_PATHS environment variable "
+                "with comma-separated list of allowed log file paths."
+            )
+
+        allowed_paths = [p.strip() for p in allowed_paths_env.split(",") if p.strip()]
+
+        # For local execution, validate path
+        if not host:
+            try:
+                requested_path = Path(log_path).resolve()
+            except Exception:
+                return f"Invalid log file path: {log_path}"
+
+            # Check if the requested path is in the allowed list
+            is_allowed = False
+            for allowed_path in allowed_paths:
+                try:
+                    allowed_resolved = Path(allowed_path).resolve()
+                    if requested_path == allowed_resolved:
+                        is_allowed = True
+                        break
+                except Exception:
+                    continue
+
+            if not is_allowed:
+                return (
+                    f"Access to log file '{log_path}' is not allowed.\n"
+                    f"Allowed log files: {{', '.join(allowed_paths)}}"
+                )  # nofmt
+
+            # Check if file exists
+            if not requested_path.exists():
+                return f"Log file not found: {log_path}"
+
+            if not requested_path.is_file():
+                return f"Path is not a file: {log_path}"
+
+            log_path_str = str(requested_path)
+        else:
+            # For remote execution, just check against whitelist without resolving
+            if log_path not in allowed_paths:
+                return (
+                    f"Access to log file '{log_path}' is not allowed.\n"
+                    f"Allowed log files: {', '.join(allowed_paths)}"
+                )  # nofmt
+            log_path_str = log_path
+
+        # Read the file using tail
+        returncode, stdout, stderr = await execute_command(
+            ["tail", "-n", str(lines), log_path_str],
+            host=host,
+            username=username,
+        )
+
+        if returncode != 0:
+            if "Permission denied" in stderr:
+                return f"Permission denied reading log file: {log_path}"
+            return f"Error reading log file: {stderr}"
+
+        if not stdout or stdout.strip() == "":
+            return f"Log file is empty: {log_path}"
+
+        result = [f"=== Log File: {log_path} (last {lines} lines) ===\n"]
+        result.append(stdout)
+
+        return "\n".join(result)
+    except FileNotFoundError:
+        return "Error: tail command not found."
+    except Exception as e:
+        return f"Error reading log file: {str(e)}"