eos-mcp 0.2.0__py3-none-any.whl

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/__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/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/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}

eos_mcp/server.py

@@ -0,0 +1,430 @@
+"""MCP server exposing Arista EOS device operations via eAPI.
+
+Provides tools for show commands, device facts, config retrieval,
+config push via configure session (with commit timer + confirm/abort),
+config diff, session management, and tech-support collection.
+"""
+
+from __future__ import annotations
+
+import concurrent.futures
+import datetime
+import os
+
+from mcp.server.fastmcp import FastMCP
+
+from eos_mcp import config as cfg_mod
+from eos_mcp import eapi
+
+mcp = FastMCP("eos-mcp")
+
+
+def _config_path(override: str) -> str:
+    return override or os.environ.get(cfg_mod.CONFIG_ENV_VAR, "")
+
+
+def _connect(host: str, config_path: str) -> eapi.pyeapi.client.Node:
+    """Load config and return a connected Node for host."""
+    cfg, _ = cfg_mod.load(config_path)
+    creds = cfg_mod.get_creds(cfg, host)
+    return eapi.get_node(host=host, **creds)
+
+
+def _resolve_hosts(
+    cfg,
+    hostnames: list[str] | None,
+    tags: list[str] | None,
+) -> list[str]:
+    result = set(hostnames or [])
+    if tags:
+        result.update(cfg_mod.get_hosts(cfg, tags))
+    return sorted(result)
+
+
+def _ensure_config(config_path: str) -> str | None:
+    """Return error string if config is unloadable, else None."""
+    try:
+        cfg_mod.load(config_path)
+        return None
+    except FileNotFoundError as e:
+        return str(e)
+
+
+@mcp.tool()
+def get_router_list(tags: list[str] | None = None, config_path: str = "") -> str:
+    """List EOS devices registered in config, optionally filtered by tags."""
+    try:
+        cfg, path = cfg_mod.load(_config_path(config_path))
+    except FileNotFoundError as e:
+        return f"Error: {e}"
+    hosts = cfg_mod.get_hosts(cfg, tags)
+    if not hosts:
+        return f"No hosts found (config: {path}, tags: {tags})"
+    lines = [f"Hosts ({len(hosts)}) from {path}:"]
+    for h in hosts:
+        host_tags = cfg.get(h, "tags", fallback="")
+        lines.append(f"  {h}  tags={host_tags or '(none)'}")
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def get_device_facts(hostname: str, config_path: str = "") -> str:
+    """Return structured device facts: hostname, model, serial, EOS version, uptime, memory."""
+    try:
+        node = _connect(hostname, _config_path(config_path))
+        f = eapi.get_device_facts(node)
+        uptime_h = int(f["uptime_seconds"]) // 3600
+        uptime_d, uptime_h = divmod(uptime_h, 24)
+        fqdn_line = f"\nfqdn:              {f['fqdn']}" if f["fqdn"] != f["hostname"] else ""
+        return (
+            f"hostname:          {f['hostname']}{fqdn_line}\n"
+            f"model:             {f['model']}\n"
+            f"serial:            {f['serial']}\n"
+            f"EOS version:       {f['version']}\n"
+            f"hardware revision: {f['hardware_revision']}\n"
+            f"uptime:            {uptime_d}d {uptime_h}h\n"
+            f"memory total:      {f['memory_total_kb'] // 1024} MB\n"
+            f"memory free:       {f['memory_free_kb'] // 1024} MB\n"
+            f"MAC:               {f['mac']}\n"
+            f"architecture:      {f['architecture']}"
+        )
+    except Exception as e:
+        eapi.clear_cache(hostname)
+        return f"Error ({hostname}): {e}"
+
+
+@mcp.tool()
+def get_device_facts_batch(
+    hostnames: list[str] | None = None,
+    tags: list[str] | None = None,
+    max_workers: int = 5,
+    config_path: str = "",
+) -> str:
+    """Return device facts (model, serial, EOS version, uptime) for multiple devices in parallel."""
+    try:
+        cfg, _ = cfg_mod.load(_config_path(config_path))
+    except FileNotFoundError as e:
+        return f"Error: {e}"
+
+    targets = _resolve_hosts(cfg, hostnames, tags)
+    if not targets:
+        return "No hosts resolved."
+
+    cp = _config_path(config_path)
+
+    def _run_one(host: str) -> tuple[str, str]:
+        try:
+            node = _connect(host, cp)
+            f = eapi.get_device_facts(node)
+            uptime_h = int(f["uptime_seconds"]) // 3600
+            uptime_d, uptime_h = divmod(uptime_h, 24)
+            return host, f"{f['model']}  EOS {f['version']}  serial={f['serial']}  up={uptime_d}d{uptime_h}h"
+        except Exception as exc:
+            eapi.clear_cache(host)
+            return host, f"Error: {exc}"
+
+    results: dict[str, str] = {}
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as pool:
+        for host, output in pool.map(_run_one, targets):
+            results[host] = output
+
+    lines = [f"Device facts ({len(targets)} hosts):"]
+    for host in targets:
+        lines.append(f"  {host:<35} {results.get(host, '')}")
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def get_version(hostname: str, config_path: str = "") -> str:
+    """Return EOS version string for a device (quick connectivity check)."""
+    try:
+        node = _connect(hostname, _config_path(config_path))
+        result = node.execute(["show version"])
+        v = result["result"][0]
+        return f"{v.get('modelName', '?')}  EOS {v.get('version', '?')}"
+    except Exception as e:
+        eapi.clear_cache(hostname)
+        return f"Error ({hostname}): {e}"
+
+
+@mcp.tool()
+def get_config_diff(hostname: str, rollback_id: int = 1, config_path: str = "") -> str:
+    """Show config diff on an EOS device.
+
+    rollback_id=1 (default) → diff vs most recent rollback checkpoint.
+    rollback_id=N           → diff vs Nth rollback checkpoint.
+    Note: diff vs startup-config requires EOS 4.30+; older versions fall back gracefully.
+    """
+    try:
+        node = _connect(hostname, _config_path(config_path))
+        diff = eapi.get_config_diff(node, rollback_id)
+        return diff if diff.strip() else "(no diff — running-config matches checkpoint)"
+    except Exception as e:
+        eapi.clear_cache(hostname)
+        return f"Error ({hostname}): {e}"
+
+
+@mcp.tool()
+def list_config_sessions(hostname: str, config_path: str = "") -> str:
+    """List configure sessions and their state on an EOS device.
+
+    Shows pending, pendingCommitTimer, and completed sessions.
+    Useful for tracking in-flight push_config operations.
+    """
+    try:
+        node = _connect(hostname, _config_path(config_path))
+        return eapi.list_config_sessions(node)
+    except Exception as e:
+        eapi.clear_cache(hostname)
+        return f"Error ({hostname}): {e}"
+
+
+@mcp.tool()
+def run_command(hostname: str, command: str, config_path: str = "") -> str:
+    """Run a single enable-mode command on an EOS device and return text output."""
+    try:
+        node = _connect(hostname, _config_path(config_path))
+        return eapi.run_show(node, command)
+    except Exception as e:
+        eapi.clear_cache(hostname)
+        return f"Error ({hostname}): {e}"
+
+
+@mcp.tool()
+def run_commands(hostname: str, commands: list[str], config_path: str = "") -> str:
+    """Run multiple enable-mode commands on one EOS device and return labelled output."""
+    try:
+        node = _connect(hostname, _config_path(config_path))
+        return eapi.run_shows(node, commands)
+    except Exception as e:
+        eapi.clear_cache(hostname)
+        return f"Error ({hostname}): {e}"
+
+
+@mcp.tool()
+def run_command_batch(
+    command: str,
+    hostnames: list[str] | None = None,
+    tags: list[str] | None = None,
+    max_workers: int = 5,
+    config_path: str = "",
+) -> str:
+    """Run an enable-mode command on multiple EOS devices in parallel.
+
+    Specify targets via 'hostnames', 'tags', or both.
+    """
+    try:
+        cfg, _ = cfg_mod.load(_config_path(config_path))
+    except FileNotFoundError as e:
+        return f"Error: {e}"
+
+    targets = _resolve_hosts(cfg, hostnames, tags)
+    if not targets:
+        return "No hosts resolved (check hostnames/tags)."
+
+    cp = _config_path(config_path)
+
+    def _run_one(host: str) -> tuple[str, str]:
+        try:
+            node = _connect(host, cp)
+            return host, eapi.run_show(node, command)
+        except Exception as exc:
+            eapi.clear_cache(host)
+            return host, f"Error: {exc}"
+
+    results: dict[str, str] = {}
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as pool:
+        for host, output in pool.map(_run_one, targets):
+            results[host] = output
+
+    lines = []
+    for host in targets:
+        lines.append(f"# {host}")
+        lines.append(results.get(host, ""))
+        lines.append("")
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def get_config(hostname: str, config_path: str = "") -> str:
+    """Retrieve the running-config from an EOS device."""
+    try:
+        node = _connect(hostname, _config_path(config_path))
+        return eapi.get_running_config(node)
+    except Exception as e:
+        eapi.clear_cache(hostname)
+        return f"Error ({hostname}): {e}"
+
+
+@mcp.tool()
+def push_config(
+    hostname: str,
+    config_lines: list[str],
+    session_name: str = "mcp-push",
+    dry_run: bool = True,
+    commit_timer: int = 300,
+    config_path: str = "",
+) -> str:
+    """Push configuration to an EOS device via a named configure session.
+
+    When dry_run=True (default) shows diffs and aborts — no changes applied.
+    When dry_run=False commits with a rollback timer (default 300 seconds).
+    Call confirm_config_session before the timer expires to finalize.
+    """
+    try:
+        node = _connect(hostname, _config_path(config_path))
+        result = eapi.push_config(
+            node=node,
+            session_name=session_name,
+            config_lines=config_lines,
+            dry_run=dry_run,
+            commit_timer=commit_timer,
+        )
+    except Exception as e:
+        eapi.clear_cache(hostname)
+        return f"Error ({hostname}): {e}"
+
+    if result["committed"]:
+        status = f"COMMITTED — timer={result['timer_seconds']}s, confirm with confirm_config_session"
+    else:
+        status = "DRY RUN — session aborted, no changes applied"
+    return f"Session '{result['session_name']}' [{status}]\n\nDiffs:\n{result['diffs']}"
+
+
+@mcp.tool()
+def confirm_config_session(
+    hostname: str,
+    session_name: str = "mcp-push",
+    config_path: str = "",
+) -> str:
+    """Confirm (finalize) a pending configure session commit timer on an EOS device."""
+    try:
+        node = _connect(hostname, _config_path(config_path))
+        return eapi.confirm_session(node, session_name)
+    except Exception as e:
+        eapi.clear_cache(hostname)
+        return f"Error ({hostname}): {e}"
+
+
+@mcp.tool()
+def abort_config_session(
+    hostname: str,
+    session_name: str = "mcp-push",
+    config_path: str = "",
+) -> str:
+    """Abort a pending configure session on an EOS device."""
+    try:
+        node = _connect(hostname, _config_path(config_path))
+        return eapi.abort_session(node, session_name)
+    except Exception as e:
+        eapi.clear_cache(hostname)
+        return f"Error ({hostname}): {e}"
+
+
+@mcp.tool()
+def collect_tech_support(hostname: str, config_path: str = "") -> str:
+    """Collect show tech-support from an EOS device (large output, 30+ seconds)."""
+    try:
+        node = _connect(hostname, _config_path(config_path))
+        return eapi.collect_tech_support(node)
+    except Exception as e:
+        eapi.clear_cache(hostname)
+        return f"Error ({hostname}): {e}"
+
+
+@mcp.tool()
+def daily_brief(
+    hostnames: list[str] | None = None,
+    tags: list[str] | None = None,
+    max_workers: int = 5,
+    config_path: str = "",
+) -> str:
+    """Run health checks on EOS devices and return a Markdown daily brief.
+
+    Checks environment (temperature, cooling, fans, PSUs), errdisabled interfaces,
+    and device uptime. Returns CRITICAL/WARNING/OK per device with a summary.
+    Specify targets via 'hostnames', 'tags', or both (default: all configured devices).
+    """
+    try:
+        cfg, _ = cfg_mod.load(_config_path(config_path))
+    except FileNotFoundError as e:
+        return f"Error: {e}"
+
+    targets = _resolve_hosts(cfg, hostnames, tags)
+    if not targets and hostnames is None and tags is None:
+        targets = cfg_mod.get_hosts(cfg, None)
+    if not targets:
+        return "No hosts resolved."
+
+    cp = _config_path(config_path)
+
+    def _run_one(host: str) -> tuple[str, dict]:
+        try:
+            node = _connect(host, cp)
+            return host, eapi.check_health(node)
+        except Exception as exc:
+            eapi.clear_cache(host)
+            return host, {
+                "anomalies": [f"CRITICAL: connection failed: {exc}"],
+                "info": {},
+            }
+
+    results: dict[str, dict] = {}
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as pool:
+        for host, result in pool.map(_run_one, targets):
+            results[host] = result
+
+    now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
+    lines = [f"## EOS デイリーブリーフ（{now}）", ""]
+
+    critical_count = warning_count = ok_count = 0
+
+    for host in targets:
+        r = results.get(host, {})
+        anomalies = r.get("anomalies", [])
+        info = r.get("info", {})
+
+        criticals = [a for a in anomalies if a.startswith("CRITICAL")]
+        warnings = [a for a in anomalies if a.startswith("WARNING")]
+
+        if criticals:
+            status = "CRITICAL"
+            critical_count += 1
+        elif warnings:
+            status = "WARNING"
+            warning_count += 1
+        else:
+            status = "OK"
+            ok_count += 1
+
+        model = info.get("model", "?")
+        version = info.get("version", "?")
+        uptime = info.get("uptime", "?")
+
+        lines.append(f"### {host} [{status}]")
+        lines.append(f"- model: {model}  EOS {version}  uptime: {uptime}")
+
+        for a in criticals + warnings:
+            lines.append(f"- {a}")
+
+        if not anomalies:
+            mem_pct = info.get("memory_pct")
+            mem_str = f"  メモリ: {mem_pct}%" if mem_pct is not None else ""
+            mlag_state = info.get("mlag_state", "")
+            if mlag_state == "active":
+                mlag_str = f"  MLAG: Active/{info.get('mlag_neg', '?').capitalize()}"
+            elif mlag_state and mlag_state != "disabled":
+                mlag_str = f"  MLAG: {mlag_state}"
+            else:
+                mlag_str = ""
+            lines.append(f"- 環境: OK{mem_str}{mlag_str}  errdisabled: なし")
+
+        lines.append("")
+
+    lines += [
+        "### サマリー",
+        f"- CRITICAL: {critical_count} 台",
+        f"- WARNING:  {warning_count} 台",
+        f"- OK:       {ok_count} 台",
+    ]
+    return "\n".join(lines)

eos_mcp-0.2.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,10 @@
+eos_mcp/__init__.py,sha256=LXOBJslQMjVwvpxgy2XT0QRd_3iBLEvHZLfaTXAgROs,229
+eos_mcp/__main__.py,sha256=lrxPS_dnrIN08cWVZL8gKO-BONMPuyJ6bEjo2acOzJY,2788
+eos_mcp/config.py,sha256=x9yOcohwAf511vt6QoEHaIvpT-h3tm5mnJqn2jIO8r0,2264
+eos_mcp/eapi.py,sha256=F7ih9QTepnZijZILeokY6vOxCKzEEibvb0vHRuF_Kao,11465
+eos_mcp/server.py,sha256=IoraW6_0y6xGcp6CfmVwOY2yPUNUi6oG_paYxb0SUjk,14385
+eos_mcp-0.2.0.dist-info/METADATA,sha256=wVicM_RDsBGnxt0oExRJPU3qb24GUkLJsc6ATvqqguU,3442
+eos_mcp-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+eos_mcp-0.2.0.dist-info/entry_points.txt,sha256=NAO3rz3e9unTrl6zK__ldhGckF6d3cM0jsbrCv6DElQ,50
+eos_mcp-0.2.0.dist-info/top_level.txt,sha256=HVys6NPD4runPUc492KHiP3Yehg8shc2QhYb2yQeRmo,8
+eos_mcp-0.2.0.dist-info/RECORD,,

eos_mcp-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

eos_mcp-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+eos-mcp = eos_mcp.__main__:main

eos_mcp-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+eos_mcp