linux-admin-mcp-server 0.1.0__py3-none-any.whl

linux_admin_mcp_server-0.1.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: linux-admin-mcp-server
+Version: 0.1.0
+Summary: MCP server for Linux system administration — manage services, processes, disk, network and logs via AI agents
+Project-URL: Homepage, https://github.com/AiAgentKarl/linux-admin-mcp-server
+Project-URL: Repository, https://github.com/AiAgentKarl/linux-admin-mcp-server
+Author-email: AiAgentKarl <coach1916@gmail.com>
+License: MIT
+Keywords: admin,claude,devops,linux,mcp,server,sysadmin,systemd
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.10
+Requires-Dist: fastmcp>=0.1.0
+Requires-Dist: mcp[cli]>=1.0.0
+Description-Content-Type: text/markdown
+
+# linux-admin-mcp-server
+
+**Linux system administration via AI agents** — MCP server for managing services, processes, disk, network and logs on Linux systems.
+
+## Features
+
+- **14 tools** for complete Linux system management
+- **System info**: CPU, RAM, Uptime, Kernel, OS-Release
+- **Disk & Memory**: Usage statistics with warnings for high utilization
+- **Health Check**: Automated system health assessment (OK/WARNING)
+- **Systemd Services**: List, status, start/stop/restart, enable/disable, logs
+- **Process Management**: List processes sorted by CPU/memory, search by name
+- **Network**: Interfaces, open ports, active connections, DNS lookup
+- **Safety**: Only predefined commands, no arbitrary shell execution
+
+## Installation
+
+```bash
+pip install linux-admin-mcp-server
+```
+
+## Usage with Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "linux-admin": {
+      "command": "linux-admin-mcp-server"
+    }
+  }
+}
+```
+
+> **Note:** Run Claude Desktop on your Linux machine, or use this server on a Linux system where you want AI-assisted administration.
+
+## Available Tools
+
+| Tool | Description | Sudo Required |
+|------|-------------|---------------|
+| `system_info` | Hostname, kernel, CPU, RAM, uptime | No |
+| `disk_usage` | Disk usage for all mounted filesystems | No |
+| `memory_usage` | RAM and swap usage details | No |
+| `health_check` | Full system health assessment | No |
+| `services_list` | List systemd services (all/running/failed) | No |
+| `service_status` | Detailed status of a specific service | No |
+| `service_manage` | Start/stop/restart/enable/disable a service | Yes |
+| `service_logs` | Last N log lines via journalctl | No |
+| `processes_list` | Running processes sorted by CPU/memory | No |
+| `process_find` | Find processes by name | No |
+| `top_consumers` | Top 5 CPU and memory consumers | No |
+| `network_interfaces` | Network interfaces and IP addresses | No |
+| `open_ports` | Listening ports (LISTEN state) | No |
+| `active_connections` | Established network connections | No |
+| `dns_lookup` | Resolve hostname to IP address | No |
+
+## Example Prompts
+
+- "Show me the system health status"
+- "What services are currently failing?"
+- "Restart the nginx service"
+- "Show the last 100 lines of the postgres logs"
+- "Which processes are consuming the most memory?"
+- "What ports is this server listening on?"
+- "What's the disk usage on this machine?"
+
+## Requirements
+
+- Linux operating system (Ubuntu, Debian, CentOS, Fedora, etc.)
+- Python 3.10+
+- systemd (for service management tools)
+- `ss` or `netstat` (for network tools)
+- sudo access (only for service start/stop/enable/disable)
+
+## Compared to ssh-mcp-server
+
+| Feature | linux-admin-mcp-server | ssh-mcp-server |
+|---------|------------------------|----------------|
+| Use case | Local Linux admin | Remote via SSH |
+| SSH required | No | Yes |
+| systemd support | Full (14 tools) | Basic |
+| Health check | Yes | No |
+| Network tools | 4 tools | Limited |
+
+## License
+
+MIT License — AiAgentKarl 2026

linux_admin_mcp_server-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/server.py,sha256=0HDiZrlGQOE4_hYx1IPdfGO1Cnabto_vi3XsRtAStXc,5758
+src/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/tools/network.py,sha256=PhlkQVvp38W8IhvIBwkLnnmB2NRGqkIRiC-OyTB_Big,4563
+src/tools/processes.py,sha256=KIxtPa0D_YIWeHvbHssnfRTTaHRvP1MSoPtPpWXWqjg,4407
+src/tools/services.py,sha256=Dzs2EUBjJGukI1Sc3f0zDTnrLiS6RNMqV96m-Y5Sk8k,5234
+src/tools/system.py,sha256=8d2g9IjdznKadahWBxFnuR275t7-46ShuzNSiQoBXKQ,5439
+linux_admin_mcp_server-0.1.0.dist-info/METADATA,sha256=vwC6rL3KleDX8wawZVNd9q-rPXayt5dAdWbOD-ckDtk,4007
+linux_admin_mcp_server-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+linux_admin_mcp_server-0.1.0.dist-info/entry_points.txt,sha256=Jr1cvgaAgdEG0vrchsSDEWZ1dh3zdHge7cVWGm92BkQ,59
+linux_admin_mcp_server-0.1.0.dist-info/RECORD,,

linux_admin_mcp_server-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

linux_admin_mcp_server-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+linux-admin-mcp-server = src.server:main

src/server.py

@@ -0,0 +1,213 @@
+"""Linux Admin MCP Server — AI-Zugriff auf Linux-Systemverwaltung"""
+import sys
+from fastmcp import FastMCP
+
+from src.tools.system import (
+    get_system_info,
+    get_disk_usage,
+    get_memory_usage,
+    run_health_check,
+)
+from src.tools.services import (
+    list_services,
+    get_service_status,
+    manage_service,
+    get_service_logs,
+)
+from src.tools.processes import (
+    list_processes,
+    find_process,
+    get_top_consumers,
+)
+from src.tools.network import (
+    get_network_interfaces,
+    get_open_ports,
+    get_active_connections,
+    check_dns_resolution,
+)
+
+# FastMCP Server initialisieren
+mcp = FastMCP(
+    "linux-admin-mcp-server",
+    instructions=(
+        "Linux system administration MCP server. Provides tools for managing "
+        "systemd services, monitoring processes, checking disk/memory usage, "
+        "inspecting network configuration, and running system health checks. "
+        "Requires root/sudo for service management actions (start/stop/enable/disable). "
+        "All other tools work as a regular user."
+    ),
+)
+
+
+# --- System-Tools ---
+
+@mcp.tool()
+def system_info() -> dict:
+    """
+    Gibt allgemeine System-Informationen zurück.
+    Enthält: Hostname, Kernel-Version, CPU-Modell, RAM, Uptime, Architektur, OS-Release.
+    Kein sudo erforderlich.
+    """
+    return get_system_info()
+
+
+@mcp.tool()
+def disk_usage() -> dict:
+    """
+    Zeigt Festplatten-Belegung aller gemounteten Laufwerke.
+    Enthält: Filesystem, Größe, Belegung, verfügbar, Auslastungsprozent, Mountpoint.
+    Kein sudo erforderlich.
+    """
+    return get_disk_usage()
+
+
+@mcp.tool()
+def memory_usage() -> dict:
+    """
+    Zeigt detaillierte RAM- und Swap-Nutzung.
+    Enthält: Gesamt, verwendet, frei, verfügbar für RAM und Swap.
+    Kein sudo erforderlich.
+    """
+    return get_memory_usage()
+
+
+@mcp.tool()
+def health_check() -> dict:
+    """
+    Führt einen vollständigen System-Health-Check durch.
+    Prüft: Disk-Belegung über 80%, CPU-Load, RAM-Verfügbarkeit, Uptime.
+    Gibt status='OK' oder 'WARNING' mit einer Liste der gefundenen Probleme zurück.
+    Kein sudo erforderlich.
+    """
+    return run_health_check()
+
+
+# --- Service-Tools ---
+
+@mcp.tool()
+def services_list(filter_state: str = "all") -> dict:
+    """
+    Listet systemd-Services auf.
+    filter_state: 'all' (Standard), 'running', 'failed', 'inactive'
+    Gibt max. 50 Services zurück mit Name, Status, Beschreibung.
+    Kein sudo erforderlich.
+    """
+    return list_services(filter_state=filter_state)
+
+
+@mcp.tool()
+def service_status(service_name: str) -> dict:
+    """
+    Gibt den detaillierten Status eines systemd-Services zurück.
+    service_name: Name des Services (z.B. 'nginx', 'postgresql', 'sshd')
+    Enthält: aktiv/inaktiv, enabled/disabled, letzten Log-Output.
+    Kein sudo erforderlich.
+    """
+    return get_service_status(service_name=service_name)
+
+
+@mcp.tool()
+def service_manage(service_name: str, action: str) -> dict:
+    """
+    Verwaltet einen systemd-Service.
+    service_name: Name des Services (z.B. 'nginx', 'postgresql')
+    action: 'start', 'stop', 'restart', 'reload', 'enable', 'disable'
+    HINWEIS: Erfordert sudo-Rechte. Server muss als root laufen oder sudoers-Eintrag haben.
+    """
+    return manage_service(service_name=service_name, action=action)
+
+
+@mcp.tool()
+def service_logs(service_name: str, lines: int = 50) -> dict:
+    """
+    Gibt die letzten Log-Zeilen eines Services über journalctl zurück.
+    service_name: Name des Services
+    lines: Anzahl der Log-Zeilen (Standard: 50, max: 500)
+    Kein sudo erforderlich.
+    """
+    return get_service_logs(service_name=service_name, lines=lines)
+
+
+# --- Prozess-Tools ---
+
+@mcp.tool()
+def processes_list(sort_by: str = "cpu", limit: int = 20) -> dict:
+    """
+    Listet laufende Prozesse auf.
+    sort_by: 'cpu' (Standard), 'memory', 'pid'
+    limit: Anzahl der Prozesse (Standard: 20, max: 100)
+    Kein sudo erforderlich.
+    """
+    return list_processes(sort_by=sort_by, limit=limit)
+
+
+@mcp.tool()
+def process_find(name: str) -> dict:
+    """
+    Sucht nach laufenden Prozessen anhand eines Namens oder Befehlsteils.
+    name: Suchbegriff (z.B. 'nginx', 'python', 'postgres')
+    Gibt PID und vollständigen Befehl zurück.
+    Kein sudo erforderlich.
+    """
+    return find_process(name=name)
+
+
+@mcp.tool()
+def top_consumers() -> dict:
+    """
+    Zeigt die Top-5 CPU- und Memory-Verbraucher.
+    Nützlich für schnelle Performance-Diagnose.
+    Kein sudo erforderlich.
+    """
+    return get_top_consumers()
+
+
+# --- Netzwerk-Tools ---
+
+@mcp.tool()
+def network_interfaces() -> dict:
+    """
+    Listet alle Netzwerk-Interfaces mit IP-Adressen auf.
+    Enthält: Interface-Name, IPv4/IPv6-Adressen, Flags.
+    Kein sudo erforderlich.
+    """
+    return get_network_interfaces()
+
+
+@mcp.tool()
+def open_ports() -> dict:
+    """
+    Listet alle Ports auf, die auf eingehende Verbindungen warten (LISTEN).
+    Nützlich um zu sehen welche Services aktiv Verbindungen annehmen.
+    Kein sudo erforderlich (ohne Prozess-Info).
+    """
+    return get_open_ports()
+
+
+@mcp.tool()
+def active_connections() -> dict:
+    """
+    Zeigt aktive Netzwerkverbindungen (ESTABLISHED).
+    Gibt lokale und Remote-Adressen für bis zu 50 Verbindungen zurück.
+    Kein sudo erforderlich.
+    """
+    return get_active_connections()
+
+
+@mcp.tool()
+def dns_lookup(hostname: str) -> dict:
+    """
+    Löst einen Hostnamen per DNS auf und gibt die IP-Adresse zurück.
+    hostname: Zu auflösender Hostname (z.B. 'google.com', 'api.example.com')
+    Kein sudo erforderlich.
+    """
+    return check_dns_resolution(hostname=hostname)
+
+
+def main():
+    """Server-Einstiegspunkt."""
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

src/tools/network.py

@@ -0,0 +1,139 @@
+"""Netzwerk-Tools: Interfaces, Verbindungen, Ports, DNS"""
+import subprocess
+from typing import Any
+
+
+def _run(cmd: list[str], timeout: int = 10) -> tuple[int, str, str]:
+    """Führt einen Befehl sicher aus."""
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+        )
+        return result.returncode, result.stdout.strip(), result.stderr.strip()
+    except subprocess.TimeoutExpired:
+        return 1, "", "Timeout"
+    except FileNotFoundError:
+        return 1, "", f"Befehl nicht gefunden: {cmd[0]}"
+    except Exception as e:
+        return 1, "", str(e)
+
+
+def get_network_interfaces() -> dict[str, Any]:
+    """Gibt alle Netzwerk-Interfaces mit IP-Adressen zurück."""
+    rc, stdout, stderr = _run(["ip", "addr", "show"])
+    if rc != 0:
+        # Fallback auf ifconfig
+        rc, stdout, stderr = _run(["ifconfig", "-a"])
+
+    interfaces = []
+    current_iface = None
+
+    for line in stdout.split("\n"):
+        # Neue Interface-Zeile (beginnt mit Zahl und Doppelpunkt)
+        if line and line[0].isdigit() and ": " in line:
+            parts = line.split(": ")
+            if len(parts) >= 2:
+                current_iface = {
+                    "name": parts[1].split("@")[0].split(" ")[0],
+                    "flags": line.split("<")[1].split(">")[0] if "<" in line else "",
+                    "addresses": [],
+                }
+                interfaces.append(current_iface)
+        elif current_iface and "inet " in line:
+            parts = line.strip().split()
+            if len(parts) >= 2:
+                current_iface["addresses"].append({
+                    "type": "ipv4",
+                    "address": parts[1],
+                })
+        elif current_iface and "inet6 " in line:
+            parts = line.strip().split()
+            if len(parts) >= 2:
+                current_iface["addresses"].append({
+                    "type": "ipv6",
+                    "address": parts[1],
+                })
+
+    return {
+        "interfaces": interfaces,
+        "count": len(interfaces),
+        "raw": stdout[:2000],  # Roh-Ausgabe kürzen
+    }
+
+
+def get_open_ports() -> dict[str, Any]:
+    """Listet alle offenen Ports (LISTEN) auf."""
+    # ss bevorzugen (moderner), Fallback auf netstat
+    rc, stdout, stderr = _run(["ss", "-tlnp"])
+    if rc != 0:
+        rc, stdout, stderr = _run(["netstat", "-tlnp"])
+
+    ports = []
+    for line in stdout.split("\n"):
+        if "LISTEN" in line or (rc != 0 and "tcp" in line.lower()):
+            parts = line.split()
+            if len(parts) >= 4:
+                local_addr = parts[3] if rc == 0 else parts[3]
+                ports.append({
+                    "local_address": local_addr,
+                    "raw": line.strip(),
+                })
+
+    return {
+        "listening_ports": ports,
+        "count": len(ports),
+        "raw": stdout[:3000],
+    }
+
+
+def get_active_connections() -> dict[str, Any]:
+    """Zeigt aktive Netzwerkverbindungen (ESTABLISHED)."""
+    rc, stdout, stderr = _run(["ss", "-tnp", "state", "established"])
+    if rc != 0:
+        rc, stdout, stderr = _run(["netstat", "-tnp"])
+
+    connections = []
+    for line in stdout.split("\n")[1:]:  # Header überspringen
+        if line.strip():
+            parts = line.split()
+            if len(parts) >= 5:
+                connections.append({
+                    "local": parts[3] if len(parts) > 3 else "",
+                    "remote": parts[4] if len(parts) > 4 else "",
+                    "raw": line.strip(),
+                })
+
+    return {
+        "connections": connections[:50],
+        "count": len(connections),
+    }
+
+
+def check_dns_resolution(hostname: str) -> dict[str, Any]:
+    """Löst einen Hostnamen per DNS auf."""
+    # Sicherheitscheck
+    safe_chars = set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._")
+    if not all(c in safe_chars for c in hostname):
+        return {"error": f"Ungültiger Hostname: {hostname}"}
+
+    rc, stdout, stderr = _run(["getent", "hosts", hostname])
+    if rc == 0 and stdout:
+        parts = stdout.split()
+        return {
+            "hostname": hostname,
+            "resolved": True,
+            "ip": parts[0] if parts else "unbekannt",
+            "aliases": parts[1:],
+        }
+
+    # Fallback: nslookup
+    rc2, stdout2, _ = _run(["nslookup", hostname])
+    return {
+        "hostname": hostname,
+        "resolved": rc2 == 0,
+        "output": stdout2[:500] if stdout2 else stderr[:200],
+    }

src/tools/processes.py

@@ -0,0 +1,151 @@
+"""Prozess-Management-Tools: Laufende Prozesse, Top-Verbraucher, Suche"""
+import subprocess
+from typing import Any
+
+
+def _run(cmd: list[str], timeout: int = 10) -> tuple[int, str, str]:
+    """Führt einen Befehl sicher aus."""
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+        )
+        return result.returncode, result.stdout.strip(), result.stderr.strip()
+    except subprocess.TimeoutExpired:
+        return 1, "", "Timeout"
+    except FileNotFoundError:
+        return 1, "", f"Befehl nicht gefunden: {cmd[0]}"
+    except Exception as e:
+        return 1, "", str(e)
+
+
+def list_processes(sort_by: str = "cpu", limit: int = 20) -> dict[str, Any]:
+    """
+    Listet laufende Prozesse auf.
+    sort_by: 'cpu', 'memory', 'pid'
+    limit: Anzahl der zurückgegebenen Prozesse (max 100)
+    """
+    limit = min(max(1, limit), 100)
+
+    # Sortier-Option festlegen
+    sort_map = {
+        "cpu": "-k3",
+        "memory": "-k4",
+        "pid": "-k1",
+    }
+    sort_flag = sort_map.get(sort_by, "-k3")
+
+    rc, stdout, stderr = _run([
+        "ps", "aux", "--no-headers"
+    ])
+
+    if rc != 0:
+        return {"error": stderr, "processes": []}
+
+    processes = []
+    lines = stdout.split("\n")
+
+    # Nach CPU oder Memory sortieren
+    def sort_key(line):
+        parts = line.split(None, 10)
+        if len(parts) < 4:
+            return 0.0
+        try:
+            if sort_by == "memory":
+                return float(parts[3])
+            elif sort_by == "pid":
+                return int(parts[1])
+            else:  # cpu
+                return float(parts[2])
+        except ValueError:
+            return 0.0
+
+    lines.sort(key=sort_key, reverse=(sort_by != "pid"))
+
+    for line in lines[:limit]:
+        parts = line.split(None, 10)
+        if len(parts) >= 11:
+            processes.append({
+                "user": parts[0],
+                "pid": parts[1],
+                "cpu_pct": parts[2],
+                "mem_pct": parts[3],
+                "vsz": parts[4],
+                "rss": parts[5],
+                "stat": parts[7],
+                "start": parts[8],
+                "time": parts[9],
+                "command": parts[10][:100],  # Befehl kürzen
+            })
+
+    return {
+        "sort_by": sort_by,
+        "count": len(processes),
+        "processes": processes,
+    }
+
+
+def find_process(name: str) -> dict[str, Any]:
+    """Sucht nach Prozessen mit einem bestimmten Namen."""
+    # Sicherheitscheck: Name darf keine Shell-Sonderzeichen enthalten
+    safe_chars = set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_. /")
+    if not all(c in safe_chars for c in name):
+        return {"error": f"Ungültiger Prozessname: {name}"}
+
+    rc, stdout, stderr = _run(["pgrep", "-a", "-f", name])
+
+    processes = []
+    if rc == 0 and stdout:
+        for line in stdout.split("\n"):
+            parts = line.split(None, 1)
+            if len(parts) == 2:
+                processes.append({"pid": parts[0], "command": parts[1]})
+
+    return {
+        "search": name,
+        "found": len(processes),
+        "processes": processes,
+    }
+
+
+def get_top_consumers() -> dict[str, Any]:
+    """Gibt die Top-5 CPU- und Memory-Verbraucher zurück."""
+    rc, stdout, _ = _run(["ps", "aux", "--no-headers"])
+    if rc != 0:
+        return {"error": "ps nicht verfügbar"}
+
+    lines = [l for l in stdout.split("\n") if l.strip()]
+
+    def parse_line(line: str) -> dict:
+        parts = line.split(None, 10)
+        if len(parts) < 11:
+            return {}
+        return {
+            "user": parts[0],
+            "pid": parts[1],
+            "cpu_pct": parts[2],
+            "mem_pct": parts[3],
+            "command": parts[10][:80],
+        }
+
+    # CPU-Verbraucher
+    try:
+        cpu_sorted = sorted(lines, key=lambda l: float(l.split(None, 3)[2]), reverse=True)
+        top_cpu = [parse_line(l) for l in cpu_sorted[:5] if parse_line(l)]
+    except (IndexError, ValueError):
+        top_cpu = []
+
+    # Memory-Verbraucher
+    try:
+        mem_sorted = sorted(lines, key=lambda l: float(l.split(None, 4)[3]), reverse=True)
+        top_mem = [parse_line(l) for l in mem_sorted[:5] if parse_line(l)]
+    except (IndexError, ValueError):
+        top_mem = []
+
+    return {
+        "top_cpu": top_cpu,
+        "top_memory": top_mem,
+    }

src/tools/services.py

@@ -0,0 +1,148 @@
+"""Systemd-Service-Management-Tools: Status, Start, Stop, Restart"""
+import subprocess
+from typing import Any
+
+
+def _run(cmd: list[str], timeout: int = 15) -> tuple[int, str, str]:
+    """Führt einen Befehl aus und gibt (returncode, stdout, stderr) zurück."""
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+        )
+        return result.returncode, result.stdout.strip(), result.stderr.strip()
+    except subprocess.TimeoutExpired:
+        return 1, "", "Timeout: Befehl hat zu lange gedauert"
+    except FileNotFoundError:
+        return 1, "", f"Befehl nicht gefunden: {cmd[0]}"
+    except Exception as e:
+        return 1, "", str(e)
+
+
+def list_services(filter_state: str = "all") -> dict[str, Any]:
+    """
+    Listet systemd-Services auf.
+    filter_state: 'all', 'running', 'failed', 'inactive'
+    """
+    cmd = ["systemctl", "list-units", "--type=service", "--no-pager", "--plain"]
+    if filter_state == "running":
+        cmd.extend(["--state=running"])
+    elif filter_state == "failed":
+        cmd.extend(["--state=failed"])
+    elif filter_state == "inactive":
+        cmd.extend(["--state=inactive"])
+
+    rc, stdout, stderr = _run(cmd)
+    if rc != 0:
+        return {"error": stderr or "systemctl nicht verfügbar", "services": []}
+
+    services = []
+    for line in stdout.split("\n"):
+        parts = line.split(None, 4)
+        if len(parts) >= 4 and parts[0].endswith(".service"):
+            services.append({
+                "name": parts[0],
+                "load": parts[1],
+                "active": parts[2],
+                "sub": parts[3],
+                "description": parts[4].strip() if len(parts) > 4 else "",
+            })
+
+    return {
+        "filter": filter_state,
+        "count": len(services),
+        "services": services[:50],  # Max 50 zurückgeben
+    }
+
+
+def get_service_status(service_name: str) -> dict[str, Any]:
+    """Gibt detaillierten Status eines systemd-Services zurück."""
+    # Sicherheitscheck: Service-Name darf keine Shell-Sonderzeichen enthalten
+    safe_chars = set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.")
+    if not all(c in safe_chars for c in service_name):
+        return {"error": f"Ungültiger Service-Name: {service_name}"}
+
+    # .service anhängen falls nicht vorhanden
+    if not service_name.endswith(".service"):
+        service_name = service_name + ".service"
+
+    rc, stdout, stderr = _run(["systemctl", "status", service_name, "--no-pager", "-l"])
+
+    # Is-active und Is-enabled abfragen
+    _, active_out, _ = _run(["systemctl", "is-active", service_name])
+    _, enabled_out, _ = _run(["systemctl", "is-enabled", service_name])
+
+    return {
+        "service": service_name,
+        "active": active_out,
+        "enabled": enabled_out,
+        "status_output": stdout if stdout else stderr,
+        "exit_code": rc,
+    }
+
+
+def manage_service(service_name: str, action: str) -> dict[str, Any]:
+    """
+    Verwaltet einen systemd-Service.
+    action: 'start', 'stop', 'restart', 'reload', 'enable', 'disable'
+
+    HINWEIS: Benötigt sudo-Rechte für start/stop/restart/enable/disable.
+    """
+    # Sicherheitscheck
+    safe_chars = set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.")
+    if not all(c in safe_chars for c in service_name):
+        return {"error": f"Ungültiger Service-Name: {service_name}"}
+
+    allowed_actions = {"start", "stop", "restart", "reload", "enable", "disable"}
+    if action not in allowed_actions:
+        return {"error": f"Ungültige Aktion. Erlaubt: {', '.join(allowed_actions)}"}
+
+    if not service_name.endswith(".service"):
+        service_name = service_name + ".service"
+
+    rc, stdout, stderr = _run(["systemctl", action, service_name])
+
+    if rc == 0:
+        # Nach Statusänderung den neuen Status abrufen
+        _, active_out, _ = _run(["systemctl", "is-active", service_name])
+        return {
+            "success": True,
+            "service": service_name,
+            "action": action,
+            "new_state": active_out,
+            "message": f"Service {service_name} erfolgreich: {action}",
+        }
+    else:
+        return {
+            "success": False,
+            "service": service_name,
+            "action": action,
+            "error": stderr or stdout,
+        }
+
+
+def get_service_logs(service_name: str, lines: int = 50) -> dict[str, Any]:
+    """Gibt die letzten Log-Zeilen eines Services über journalctl zurück."""
+    safe_chars = set("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.")
+    if not all(c in safe_chars for c in service_name):
+        return {"error": f"Ungültiger Service-Name: {service_name}"}
+
+    if not service_name.endswith(".service"):
+        service_name = service_name + ".service"
+
+    lines = min(max(1, lines), 500)  # Zwischen 1 und 500
+
+    rc, stdout, stderr = _run(
+        ["journalctl", "-u", service_name, "-n", str(lines), "--no-pager", "--output=short"],
+        timeout=20,
+    )
+
+    return {
+        "service": service_name,
+        "lines_requested": lines,
+        "logs": stdout if stdout else stderr,
+        "success": rc == 0,
+    }

src/tools/system.py

@@ -0,0 +1,173 @@
+"""System-Informations-Tools: CPU, Speicher, Disk, OS-Details"""
+import subprocess
+import platform
+import os
+from typing import Any
+
+
+def _run(cmd: list[str], timeout: int = 10) -> str:
+    """Führt einen Befehl sicher aus und gibt stdout zurück."""
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+        )
+        return result.stdout.strip() if result.returncode == 0 else result.stderr.strip()
+    except subprocess.TimeoutExpired:
+        return "Timeout: Befehl hat zu lange gedauert"
+    except FileNotFoundError:
+        return f"Befehl nicht gefunden: {cmd[0]}"
+    except Exception as e:
+        return f"Fehler: {str(e)}"
+
+
+def get_system_info() -> dict[str, Any]:
+    """Gibt allgemeine System-Informationen zurück: OS, Kernel, Uptime, Hostname."""
+    hostname = _run(["hostname"])
+    kernel = _run(["uname", "-r"])
+    os_release = _run(["cat", "/etc/os-release"])
+    uptime = _run(["uptime", "-p"])
+    cpu_count = _run(["nproc"])
+    arch = _run(["uname", "-m"])
+
+    # CPU-Modell aus /proc/cpuinfo
+    cpu_model = "unbekannt"
+    try:
+        with open("/proc/cpuinfo", "r") as f:
+            for line in f:
+                if "model name" in line:
+                    cpu_model = line.split(":")[1].strip()
+                    break
+    except Exception:
+        pass
+
+    # Arbeitsspeicher aus /proc/meminfo
+    mem_total = "unbekannt"
+    mem_available = "unbekannt"
+    try:
+        with open("/proc/meminfo", "r") as f:
+            for line in f:
+                if line.startswith("MemTotal:"):
+                    kb = int(line.split()[1])
+                    mem_total = f"{kb // 1024} MB ({kb // 1048576} GB)"
+                elif line.startswith("MemAvailable:"):
+                    kb = int(line.split()[1])
+                    mem_available = f"{kb // 1024} MB ({kb // 1048576} GB)"
+    except Exception:
+        pass
+
+    return {
+        "hostname": hostname,
+        "kernel": kernel,
+        "arch": arch,
+        "uptime": uptime,
+        "cpu_count": cpu_count,
+        "cpu_model": cpu_model,
+        "mem_total": mem_total,
+        "mem_available": mem_available,
+        "os_release": os_release,
+    }
+
+
+def get_disk_usage() -> dict[str, Any]:
+    """Gibt Festplatten-Belegung aller gemounteten Laufwerke zurück."""
+    output = _run(["df", "-h", "--output=source,size,used,avail,pcent,target"])
+    lines = output.strip().split("\n")
+    if not lines:
+        return {"error": "Keine Disk-Daten verfügbar"}
+
+    header = lines[0].split()
+    disks = []
+    for line in lines[1:]:
+        parts = line.split()
+        if len(parts) >= 6:
+            disks.append({
+                "filesystem": parts[0],
+                "size": parts[1],
+                "used": parts[2],
+                "available": parts[3],
+                "use_pct": parts[4],
+                "mountpoint": parts[5],
+            })
+
+    return {"disks": disks, "raw": output}
+
+
+def get_memory_usage() -> dict[str, Any]:
+    """Gibt detaillierte Speicher-Nutzung zurück (RAM + Swap)."""
+    output = _run(["free", "-h"])
+    mem_info = {}
+    for line in output.split("\n"):
+        if line.startswith("Mem:"):
+            parts = line.split()
+            mem_info["ram_total"] = parts[1]
+            mem_info["ram_used"] = parts[2]
+            mem_info["ram_free"] = parts[3]
+            if len(parts) > 6:
+                mem_info["ram_available"] = parts[6]
+        elif line.startswith("Swap:"):
+            parts = line.split()
+            mem_info["swap_total"] = parts[1]
+            mem_info["swap_used"] = parts[2]
+            mem_info["swap_free"] = parts[3]
+    return {"memory": mem_info, "raw": output}
+
+
+def run_health_check() -> dict[str, Any]:
+    """Führt einen vollständigen System-Health-Check durch."""
+    checks = {}
+
+    # Disk-Belegung über 80%?
+    df_out = _run(["df", "-h", "--output=pcent,target"])
+    high_disk = []
+    for line in df_out.split("\n")[1:]:
+        parts = line.strip().split()
+        if len(parts) == 2:
+            pct_str = parts[0].rstrip("%")
+            try:
+                if int(pct_str) >= 80:
+                    high_disk.append({"mountpoint": parts[1], "usage": parts[0]})
+            except ValueError:
+                pass
+    checks["disk_warnings"] = high_disk
+
+    # Load Average
+    load_out = _run(["cat", "/proc/loadavg"])
+    parts = load_out.split()
+    if len(parts) >= 3:
+        checks["load_average"] = {
+            "1min": parts[0],
+            "5min": parts[1],
+            "15min": parts[2],
+        }
+
+    # Speicher verfügbar
+    mem_out = get_memory_usage()
+    checks["memory"] = mem_out.get("memory", {})
+
+    # Uptime
+    checks["uptime"] = _run(["uptime", "-p"])
+
+    # Hostname und Kernel
+    checks["hostname"] = _run(["hostname"])
+    checks["kernel"] = _run(["uname", "-r"])
+
+    # Status-Bewertung
+    issues = []
+    if high_disk:
+        issues.append(f"{len(high_disk)} Laufwerk(e) über 80% Belegung")
+    try:
+        load_1m = float(checks.get("load_average", {}).get("1min", "0"))
+        cpu_count = int(_run(["nproc"]) or "1")
+        if load_1m > cpu_count * 0.8:
+            issues.append(f"Hohe CPU-Last: {load_1m} (bei {cpu_count} Kernen)")
+    except (ValueError, TypeError):
+        pass
+
+    checks["status"] = "WARNING" if issues else "OK"
+    checks["issues"] = issues
+
+    return checks