eos-mcp 0.2.0__tar.gz

eos_mcp-0.2.0/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: eos-mcp
+Version: 0.2.0
+Summary: MCP server for Arista EOS device operations via eAPI
+Author: AIKAWA Shigechika
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/shigechika/eos-mcp
+Project-URL: Repository, https://github.com/shigechika/eos-mcp
+Project-URL: Issues, https://github.com/shigechika/eos-mcp/issues
+Keywords: arista,eos,eapi,mcp,model-context-protocol,network,automation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.0
+Requires-Dist: pyeapi
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+
+# eos-mcp
+
+MCP server for Arista EOS device operations via eAPI.
+
+Exposes EOS show commands, running-config retrieval, configuration push
+(via configure session with commit timer), and tech-support collection
+to MCP-compatible AI assistants.
+
+## Installation
+
+```bash
+pip install eos-mcp
+```
+
+## Configuration
+
+Copy `config.ini.example` to `~/.config/eos-mcp/config.ini` and fill in credentials:
+
+```ini
+[DEFAULT]
+username = admin
+password = yourpassword
+transport = https
+verify = false
+
+[switch1.example.com]
+tags = main,dc1
+
+[switch2.example.com]
+tags = main,dc1
+```
+
+Config file discovery order:
+1. `--config_path` argument
+2. `EOS_MCP_CONFIG` environment variable
+3. `./config.ini` (current directory)
+4. `~/.config/eos-mcp/config.ini`
+
+## Usage
+
+```bash
+# Verify config and list devices
+eos-mcp --check
+
+# Test connectivity to a specific host
+eos-mcp --check --check-host switch1.example.com
+
+# Start MCP server (stdio transport, default)
+eos-mcp
+```
+
+## Tools
+
+| Tool | Description |
+|---|---|
+| `get_router_list` | List registered devices (optional tag filter) |
+| `get_device_facts` | Return structured facts for one device (model, serial, EOS version, uptime, memory) |
+| `get_device_facts_batch` | Return device facts for multiple devices in parallel |
+| `get_version` | Return EOS version string (quick connectivity check) |
+| `run_command` | Run a single enable-mode command on one device |
+| `run_commands` | Run multiple enable-mode commands on one device |
+| `run_command_batch` | Run an enable-mode command on multiple devices in parallel |
+| `get_config` | Retrieve running-config |
+| `get_config_diff` | Show config diff vs rollback checkpoint |
+| `list_config_sessions` | List configure sessions and their state |
+| `push_config` | Push config via configure session (dry_run=True by default) |
+| `confirm_config_session` | Confirm a pending commit timer session |
+| `abort_config_session` | Abort a pending session |
+| `collect_tech_support` | Collect show tech-support output |
+| `daily_brief` | Health check (environment, errdisabled, uptime) across multiple devices |
+
+## Requirements
+
+- Python >= 3.10
+- Arista EOS with eAPI enabled (`management api http-commands`)
+- Network access to port 443 (HTTPS) on target devices
+
+## License
+
+Apache-2.0

eos_mcp-0.2.0/README.md

@@ -0,0 +1,80 @@
+# eos-mcp
+
+MCP server for Arista EOS device operations via eAPI.
+
+Exposes EOS show commands, running-config retrieval, configuration push
+(via configure session with commit timer), and tech-support collection
+to MCP-compatible AI assistants.
+
+## Installation
+
+```bash
+pip install eos-mcp
+```
+
+## Configuration
+
+Copy `config.ini.example` to `~/.config/eos-mcp/config.ini` and fill in credentials:
+
+```ini
+[DEFAULT]
+username = admin
+password = yourpassword
+transport = https
+verify = false
+
+[switch1.example.com]
+tags = main,dc1
+
+[switch2.example.com]
+tags = main,dc1
+```
+
+Config file discovery order:
+1. `--config_path` argument
+2. `EOS_MCP_CONFIG` environment variable
+3. `./config.ini` (current directory)
+4. `~/.config/eos-mcp/config.ini`
+
+## Usage
+
+```bash
+# Verify config and list devices
+eos-mcp --check
+
+# Test connectivity to a specific host
+eos-mcp --check --check-host switch1.example.com
+
+# Start MCP server (stdio transport, default)
+eos-mcp
+```
+
+## Tools
+
+| Tool | Description |
+|---|---|
+| `get_router_list` | List registered devices (optional tag filter) |
+| `get_device_facts` | Return structured facts for one device (model, serial, EOS version, uptime, memory) |
+| `get_device_facts_batch` | Return device facts for multiple devices in parallel |
+| `get_version` | Return EOS version string (quick connectivity check) |
+| `run_command` | Run a single enable-mode command on one device |
+| `run_commands` | Run multiple enable-mode commands on one device |
+| `run_command_batch` | Run an enable-mode command on multiple devices in parallel |
+| `get_config` | Retrieve running-config |
+| `get_config_diff` | Show config diff vs rollback checkpoint |
+| `list_config_sessions` | List configure sessions and their state |
+| `push_config` | Push config via configure session (dry_run=True by default) |
+| `confirm_config_session` | Confirm a pending commit timer session |
+| `abort_config_session` | Abort a pending session |
+| `collect_tech_support` | Collect show tech-support output |
+| `daily_brief` | Health check (environment, errdisabled, uptime) across multiple devices |
+
+## Requirements
+
+- Python >= 3.10
+- Arista EOS with eAPI enabled (`management api http-commands`)
+- Network access to port 443 (HTTPS) on target devices
+
+## License
+
+Apache-2.0

eos_mcp-0.2.0/eos_mcp/__init__.py

@@ -0,0 +1,8 @@
+"""eos-mcp: MCP server for Arista EOS device operations via eAPI."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("eos-mcp")
+except PackageNotFoundError:
+    __version__ = "0.2.0"

eos_mcp-0.2.0/eos_mcp/__main__.py

@@ -0,0 +1,92 @@
+"""Allow running as: python -m eos_mcp"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+from eos_mcp import __version__
+from eos_mcp import config as cfg_mod
+from eos_mcp import eapi
+from eos_mcp.server import _ensure_config, mcp
+
+
+def _check_config(check_host: str | None = None) -> int:
+    """Verify config.ini is loadable and optionally test eAPI connectivity."""
+    err = _ensure_config("")
+    if err:
+        print(f"Configuration error: {err}", file=sys.stderr)
+        return 1
+
+    cfg, path = cfg_mod.load("")
+    hosts = cfg_mod.get_hosts(cfg)
+    print(f"OK: config loaded from {path}")
+    print(f"Devices ({len(hosts)}): {', '.join(hosts) if hosts else '(none)'}")
+
+    if check_host is None:
+        return 0
+
+    if not cfg.has_section(check_host):
+        print(f"Error: host '{check_host}' not found in config", file=sys.stderr)
+        return 2
+
+    try:
+        creds = cfg_mod.get_creds(cfg, check_host)
+        node = eapi.get_node(host=check_host, **creds)
+        result = node.execute(["show version"])
+        model = result["result"][0].get("modelName", "?")
+        version = result["result"][0].get("version", "?")
+        print(f"OK: connected to {check_host} (model={model}, EOS={version})")
+    except Exception as e:
+        print(f"Connection error ({check_host}): {e}", file=sys.stderr)
+        return 2
+
+    return 0
+
+
+def main() -> None:
+    """Entry point for console_scripts."""
+    parser = argparse.ArgumentParser(
+        prog="eos-mcp",
+        description=(
+            "MCP server for Arista EOS. Exposes EOS device operations "
+            "(show commands, config management, tech-support collection) "
+            "to AI assistants via eAPI."
+        ),
+        epilog=(
+            "Config file discovery order: --config_path argument > "
+            f"{cfg_mod.CONFIG_ENV_VAR} env var > ./config.ini > "
+            "~/.config/eos-mcp/config.ini."
+        ),
+    )
+    parser.add_argument("-V", "--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument(
+        "--check",
+        action="store_true",
+        help="Verify config.ini is loadable and list devices, then exit.",
+    )
+    parser.add_argument(
+        "--check-host",
+        metavar="HOSTNAME",
+        help="With --check, also open an eAPI connection to HOSTNAME.",
+    )
+    parser.add_argument(
+        "--transport",
+        choices=["stdio", "streamable-http"],
+        default="stdio",
+        help="Transport protocol (default: stdio)",
+    )
+    args = parser.parse_args()
+
+    if args.check or args.check_host:
+        sys.exit(_check_config(args.check_host))
+
+    try:
+        mcp.run(transport=args.transport)
+    except KeyboardInterrupt:
+        os._exit(0)
+
+
+if __name__ == "__main__":
+    main()

eos_mcp-0.2.0/eos_mcp/config.py

@@ -0,0 +1,70 @@
+"""Configuration file loader (XDG-compliant).
+
+Config file discovery order:
+  1. explicit override argument
+  2. EOS_MCP_CONFIG environment variable
+  3. ./config.ini (current directory)
+  4. ~/.config/eos-mcp/config.ini
+"""
+
+from __future__ import annotations
+
+import configparser
+import os
+from pathlib import Path
+
+CONFIG_ENV_VAR = "EOS_MCP_CONFIG"
+_XDG_PATH = Path.home() / ".config" / "eos-mcp" / "config.ini"
+
+
+def find_config_path(override: str = "") -> Path:
+    """Resolve config file path using discovery order."""
+    if override:
+        return Path(override)
+    env = os.environ.get(CONFIG_ENV_VAR, "")
+    if env:
+        return Path(env)
+    local = Path("config.ini")
+    if local.exists():
+        return local
+    return _XDG_PATH
+
+
+def load(config_path: str = "") -> tuple[configparser.ConfigParser, Path]:
+    """Load config and return (ConfigParser, resolved_path).
+
+    Raises FileNotFoundError if the resolved path does not exist.
+    """
+    path = find_config_path(config_path)
+    cfg = configparser.ConfigParser()
+    read = cfg.read(path)
+    if not read:
+        raise FileNotFoundError(f"Config file not found: {path}")
+    return cfg, path
+
+
+def get_hosts(cfg: configparser.ConfigParser, tags: list[str] | None = None) -> list[str]:
+    """Return section names (hostnames), optionally filtered by tags.
+
+    A host matches if it has *any* of the requested tags.
+    """
+    result = []
+    for section in cfg.sections():
+        if tags:
+            raw = cfg.get(section, "tags", fallback="")
+            host_tags = {t.strip() for t in raw.split(",") if t.strip()}
+            if not host_tags.intersection(tags):
+                continue
+        result.append(section)
+    return result
+
+
+def get_creds(cfg: configparser.ConfigParser, host: str) -> dict[str, str | bool]:
+    """Return connection credentials for a host (falls back to DEFAULT)."""
+    defaults = cfg.defaults()
+    return {
+        "username": cfg.get(host, "username", fallback=defaults.get("username", "")),
+        "password": cfg.get(host, "password", fallback=defaults.get("password", "")),
+        "transport": cfg.get(host, "transport", fallback=defaults.get("transport", "https")),
+        "verify": cfg.getboolean(host, "verify", fallback=False),
+    }

eos_mcp-0.2.0/eos_mcp/eapi.py

@@ -0,0 +1,307 @@
+"""pyeapi client wrapper with TLS compatibility and connection cache."""
+
+from __future__ import annotations
+
+import ssl
+import threading
+from typing import Any
+
+import pyeapi
+
+# EOS 4.28.x supports TLS 1.0–1.2 with legacy cipher suites.
+# Python 3.14 raised the default security level, causing
+# SSLV3_ALERT_HANDSHAKE_FAILURE.  Patch _create_unverified_context globally
+# so pyeapi's HTTPS transport works with older EOS versions.
+_orig_create_unverified_context = ssl._create_unverified_context
+
+
+def _tls_compat_context(protocol=ssl.PROTOCOL_TLS_CLIENT, **kwargs):
+    ctx = _orig_create_unverified_context(protocol, **kwargs)
+    ctx.set_ciphers("DEFAULT:@SECLEVEL=0")
+    ctx.minimum_version = ssl.TLSVersion.TLSv1
+    return ctx
+
+
+ssl._create_unverified_context = _tls_compat_context
+
+# hostname -> pyeapi.client.Node
+_cache: dict[str, pyeapi.client.Node] = {}
+_lock = threading.Lock()
+
+
+def get_node(
+    host: str,
+    username: str,
+    password: str,
+    transport: str = "https",
+    verify: bool = False,
+) -> pyeapi.client.Node:
+    """Return a cached Node, creating a new connection if needed."""
+    with _lock:
+        if host not in _cache:
+            _cache[host] = pyeapi.connect(
+                host=host,
+                username=username,
+                password=password,
+                transport=transport,
+                verify=verify,
+            )
+        return _cache[host]
+
+
+def clear_cache(host: str | None = None) -> None:
+    """Remove cached node(s) so the next call creates a fresh connection."""
+    with _lock:
+        if host is not None:
+            _cache.pop(host, None)
+        else:
+            _cache.clear()
+
+
+def run_show(node: pyeapi.client.Node, command: str) -> str:
+    """Run a single show command and return text output."""
+    result = node.execute([command], encoding="text")
+    return result["result"][0].get("output", "")
+
+
+def run_shows(node: pyeapi.client.Node, commands: list[str]) -> str:
+    """Run multiple show commands and return labelled concatenated text."""
+    result = node.execute(commands, encoding="text")
+    parts = [
+        f"--- {cmd} ---\n{result['result'][i].get('output', '')}"
+        for i, cmd in enumerate(commands)
+    ]
+    return "\n".join(parts)
+
+
+def get_running_config(node: pyeapi.client.Node) -> str:
+    """Return running-config as text."""
+    return run_show(node, "show running-config")
+
+
+def _timer_str(seconds: int) -> str:
+    h, rem = divmod(seconds, 3600)
+    m, s = divmod(rem, 60)
+    return f"{h:02d}:{m:02d}:{s:02d}"
+
+
+def push_config(
+    node: pyeapi.client.Node,
+    session_name: str,
+    config_lines: list[str],
+    dry_run: bool = True,
+    commit_timer: int = 300,
+) -> dict[str, Any]:
+    """Apply config lines via a named configure session.
+
+    All commands are sent in a single eAPI call to maintain session context.
+    When dry_run=True the session is aborted after showing diffs.
+    When dry_run=False the session is committed with a rollback timer.
+
+    Returns dict: {session_name, diffs, committed, timer_seconds}.
+    """
+    terminate = "abort" if dry_run else f"commit timer {_timer_str(commit_timer)}"
+    cmds = (
+        [f"configure session {session_name}"]
+        + list(config_lines)
+        + ["show session-config diffs", terminate]
+    )
+    result = node.execute(cmds, encoding="text")
+    diffs_idx = 1 + len(config_lines)
+    diffs = result["result"][diffs_idx].get("output", "(no diffs)")
+    return {
+        "session_name": session_name,
+        "diffs": diffs,
+        "committed": not dry_run,
+        "timer_seconds": 0 if dry_run else commit_timer,
+    }
+
+
+def confirm_session(node: pyeapi.client.Node, session_name: str) -> str:
+    """Confirm (finalize) a pending configure session commit timer."""
+    node.execute([f"configure session {session_name} commit"])
+    return f"Session '{session_name}' confirmed and committed."
+
+
+def abort_session(node: pyeapi.client.Node, session_name: str) -> str:
+    """Abort a pending configure session."""
+    node.execute([f"configure session {session_name} abort"])
+    return f"Session '{session_name}' aborted."
+
+
+def collect_tech_support(node: pyeapi.client.Node) -> str:
+    """Return show tech-support output (large — may take 30+ seconds)."""
+    return run_show(node, "show tech-support")
+
+
+def get_device_facts(node: pyeapi.client.Node) -> dict[str, Any]:
+    """Return structured device facts from show version + show hostname.
+
+    Keys: hostname, fqdn, model, serial, version, hardware_revision,
+    uptime_seconds, memory_total_kb, memory_free_kb, mac, architecture.
+    """
+    result = node.execute(["show version", "show hostname"])
+    v = result["result"][0]
+    h = result["result"][1]
+    return {
+        "hostname": h.get("hostname", ""),
+        "fqdn": h.get("fqdn", ""),
+        "model": v.get("modelName", ""),
+        "serial": v.get("serialNumber", ""),
+        "version": v.get("version", ""),
+        "hardware_revision": v.get("hardwareRevision", ""),
+        "uptime_seconds": v.get("uptime", 0),
+        "memory_total_kb": v.get("memTotal", 0),
+        "memory_free_kb": v.get("memFree", 0),
+        "mac": v.get("systemMacAddress", ""),
+        "architecture": v.get("architecture", ""),
+    }
+
+
+def get_config_diff(node: pyeapi.client.Node, rollback_id: int = 1) -> str:
+    """Return config diff between running-config and a rollback checkpoint.
+
+    rollback_id=1  → diff vs most recent rollback checkpoint (default)
+    rollback_id=N  → diff vs Nth rollback checkpoint
+
+    Note: 'show running-config diffs' (vs startup) requires EOS 4.30+.
+    This function uses 'show rollback config <N>' which is available on
+    EOS 4.28+, falling back gracefully when no rollbacks exist.
+    """
+    candidates = [
+        f"show rollback config {rollback_id}",
+        f"show running-config diffs",
+    ]
+    last_err = ""
+    for cmd in candidates:
+        try:
+            return run_show(node, cmd)
+        except Exception as e:
+            last_err = str(e)
+    return f"Config diff not available on this EOS version: {last_err}"
+
+
+def list_config_sessions(node: pyeapi.client.Node) -> str:
+    """Return configure session list with state (show configuration sessions detail)."""
+    return run_show(node, "show configuration sessions detail")
+
+
+def _get_environment_text(node: pyeapi.client.Node) -> str:
+    """Return environment status text, trying EOS 4.28+ and older syntax."""
+    for cmd in ("show system environment all", "show environment all"):
+        try:
+            return run_show(node, cmd)
+        except Exception:
+            continue
+    return ""
+
+
+def check_health(node: pyeapi.client.Node) -> dict[str, Any]:
+    """Run health checks for daily_brief.
+
+    Checks: device facts (uptime, memory), environment (temperature/cooling/fans/PSUs),
+    errdisabled interfaces, and MLAG status (when active).
+
+    Returns dict: {anomalies: list[str], info: dict}.
+    anomalies entries are prefixed with 'CRITICAL:' or 'WARNING:'.
+    """
+    anomalies: list[str] = []
+    info: dict[str, Any] = {}
+
+    # Device facts (uptime + memory — no extra API call)
+    try:
+        facts = get_device_facts(node)
+        info["hostname"] = facts["hostname"]
+        info["model"] = facts["model"]
+        info["version"] = facts["version"]
+        uptime_s = int(facts["uptime_seconds"])
+        uptime_d, rem = divmod(uptime_s, 86400)
+        uptime_h, rem2 = divmod(rem, 3600)
+        uptime_m = rem2 // 60
+        if uptime_d == 0 and uptime_h == 0:
+            info["uptime"] = f"{uptime_m}m"
+        elif uptime_d == 0:
+            info["uptime"] = f"{uptime_h}h"
+        else:
+            info["uptime"] = f"{uptime_d}d {uptime_h}h"
+        if uptime_d == 0:
+            display = f"{uptime_m}m" if uptime_h == 0 else f"{uptime_h}h"
+            anomalies.append(f"WARNING: uptime {display} — recent reboot?")
+        total_kb = facts.get("memory_total_kb", 0)
+        free_kb = facts.get("memory_free_kb", 0)
+        if total_kb > 0:
+            used_pct = (total_kb - free_kb) / total_kb * 100
+            info["memory_pct"] = round(used_pct, 1)
+            if used_pct >= 90:
+                anomalies.append(
+                    f"CRITICAL: memory {used_pct:.0f}% used ({free_kb // 1024} MB free)"
+                )
+            elif used_pct >= 80:
+                anomalies.append(
+                    f"WARNING: memory {used_pct:.0f}% used ({free_kb // 1024} MB free)"
+                )
+    except Exception as exc:
+        anomalies.append(f"CRITICAL: cannot fetch facts: {exc}")
+
+    # Environment (temperature / cooling / fans / PSUs)
+    try:
+        env = _get_environment_text(node)
+        if env:
+            for _prefix in ("System temperature status", "System cooling status"):
+                _sline = next((l.strip() for l in env.splitlines() if l.startswith(_prefix)), None)
+                if _sline is not None and "Ok" not in _sline:
+                    anomalies.append(f"CRITICAL: {_sline}")
+            for line in env.splitlines():
+                stripped = line.strip()
+                # Fan/PSU failure: lines starting with a digit, PowerSupply, or Fan (FanTray, Fan1/1…)
+                if stripped and " Fail" in stripped:
+                    if stripped[0].isdigit() or stripped.startswith(("PowerSupply", "Fan")):
+                        anomalies.append(f"CRITICAL: hardware Fail: {stripped}")
+        else:
+            anomalies.append("WARNING: environment status unavailable")
+    except Exception as exc:
+        anomalies.append(f"WARNING: environment check failed: {exc}")
+
+    # Errdisabled interfaces
+    try:
+        intf_text = run_show(node, "show interfaces status")
+        errdisabled = [
+            line.split()[0]
+            for line in intf_text.splitlines()
+            if "errdisabled" in line and line.strip()
+        ]
+        info["errdisabled"] = errdisabled
+        if errdisabled:
+            anomalies.append(f"WARNING: errdisabled: {', '.join(errdisabled)}")
+    except Exception as exc:
+        anomalies.append(f"WARNING: interface check failed: {exc}")
+
+    # MLAG status (ignore when disabled or not configured)
+    try:
+        mlag_text = run_show(node, "show mlag")
+        mlag_state = ""
+        mlag_neg = ""
+        mlag_peer = ""
+        for line in mlag_text.splitlines():
+            stripped = line.strip()
+            if stripped.startswith("state") and ":" in stripped:
+                mlag_state = stripped.split(":", 1)[1].strip().lower()
+            elif stripped.startswith("negotiation status") and ":" in stripped:
+                mlag_neg = stripped.split(":", 1)[1].strip().lower()
+            elif stripped.startswith("peer-link status") and ":" in stripped:
+                mlag_peer = stripped.split(":", 1)[1].strip().lower()
+        if mlag_state and mlag_state != "disabled":
+            info["mlag_state"] = mlag_state
+            info["mlag_neg"] = mlag_neg
+            info["mlag_peer"] = mlag_peer
+            if mlag_state != "active":
+                anomalies.append(f"CRITICAL: MLAG state={mlag_state}")
+            else:
+                if mlag_neg and mlag_neg != "connected":
+                    anomalies.append(f"CRITICAL: MLAG negotiation={mlag_neg}")
+                if mlag_peer and mlag_peer != "up":
+                    anomalies.append(f"CRITICAL: MLAG peer-link={mlag_peer}")
+    except Exception:
+        pass  # MLAG not configured on this device
+
+    return {"anomalies": anomalies, "info": info}