get-sys-info 0.1.0__py3-none-any.whl

get_sys_info/__init__.py

@@ -0,0 +1,207 @@
+"""
+MCP Server — Get OS Info
+One tool: get_os_info — returns comprehensive macOS system information.
+"""
+
+import json
+import platform
+import subprocess
+from datetime import datetime
+
+import psutil
+from mcp.server.fastmcp import FastMCP
+
+server = FastMCP("get-sys-info")
+
+
+def _run_cmd(cmd: list[str]) -> str | None:
+    """Run a shell command and return stdout, or None on failure."""
+    try:
+        return subprocess.check_output(cmd, text=True).strip()
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+
+def _sw_vers() -> dict[str, str | None]:
+    """macOS version details via sw_vers."""
+    raw = _run_cmd(["sw_vers"])
+    if not raw:
+        return {}
+    result = {}
+    for line in raw.splitlines():
+        if ":" in line:
+            k, v = line.split(":", 1)
+            result[k.strip()] = v.strip()
+    return result
+
+
+def _uptime_seconds() -> float | None:
+    """System uptime in seconds from sysctl (macOS)."""
+    raw = _run_cmd(["sysctl", "-n", "kern.boottime"])
+    if not raw:
+        return None
+    try:
+        sec = int(raw.split("sec = ")[1].split(",")[0])
+        return datetime.now().timestamp() - sec
+    except (ValueError, IndexError):
+        return None
+
+
+def _human_time(seconds: float) -> str:
+    """Format seconds into a human-readable string."""
+    days, rem = divmod(int(seconds), 86400)
+    hours, rem = divmod(rem, 3600)
+    minutes, secs = divmod(rem, 60)
+    parts = []
+    if days:
+        parts.append(f"{days}d")
+    if hours:
+        parts.append(f"{hours}h")
+    if minutes:
+        parts.append(f"{minutes}m")
+    parts.append(f"{secs}s")
+    return " ".join(parts)
+
+
+@server.tool()
+def get_os_info(output_path: str) -> str:
+    """Return comprehensive macOS system information and save to a JSON file.
+
+    Collects macOS system details (OS version, CPU, memory, disk,
+    network, processes, uptime), returns them as a JSON string,
+    and saves the result to the specified file.
+
+    Args:
+        output_path: Absolute path to save the JSON output file.
+                     Pass your project root directory (e.g. the consumer
+                     project's root) with a filename like "system_info.json".
+    """
+    sv = _sw_vers()
+    up_secs = _uptime_seconds()
+
+    mem = psutil.virtual_memory()
+    swap = psutil.swap_memory()
+    disks = psutil.disk_partitions()
+    disk_io = psutil.disk_io_counters()
+    addrs = psutil.net_if_addrs()
+    net_io = psutil.net_io_counters()
+    load1, load5, load15 = psutil.getloadavg()
+
+    # Primary IP (first non-loopback IPv4)
+    primary_ip = None
+    for _iface, addr_list in addrs.items():
+        for addr in addr_list:
+            if addr.family == 2 and not addr.address.startswith("127."):
+                primary_ip = addr.address
+                break
+        if primary_ip:
+            break
+
+    # Top processes by CPU
+    proc_count = len(psutil.pids())
+    top_procs = []
+    for p in sorted(
+        psutil.process_iter(["pid", "name", "cpu_percent", "memory_percent"]),
+        key=lambda p: (p.info.get("cpu_percent") or 0),
+        reverse=True,
+    )[:10]:
+        info = p.info
+        top_procs.append({
+            "pid": info["pid"],
+            "name": info.get("name", "?"),
+            "cpu%": round(info.get("cpu_percent", 0) or 0, 1),
+            "mem%": round(info.get("memory_percent", 0) or 0, 1),
+        })
+
+    info: dict = {
+        "hostname": platform.node(),
+        "os": {
+            "system": platform.system(),
+            "release": platform.release(),
+            "version": platform.version(),
+            "machine": platform.machine(),
+            "macOS": sv.get("ProductName", "?"),
+            "macOS_version": sv.get("ProductVersion", "?"),
+            "macOS_build": sv.get("BuildVersion", "?"),
+        },
+        "uptime": _human_time(up_secs) if up_secs else "unknown",
+        "uptime_seconds": up_secs,
+        "boot_time": (
+            datetime.fromtimestamp(psutil.boot_time()).isoformat()
+            if psutil.boot_time() else None
+        ),
+        "cpu": {
+            "model": _run_cmd(["sysctl", "-n", "machdep.cpu.brand_string"]),
+            "architecture": platform.machine(),
+            "physical_cores": psutil.cpu_count(logical=False),
+            "logical_cores": psutil.cpu_count(logical=True),
+            "usage_per_core": psutil.cpu_percent(percpu=True),
+            "usage_total": psutil.cpu_percent(interval=0.1),
+            "load_average": {
+                "1min": round(load1, 2),
+                "5min": round(load5, 2),
+                "15min": round(load15, 2),
+            },
+        },
+        "memory": {
+            "total": mem.total,
+            "available": mem.available,
+            "used": mem.used,
+            "percent": mem.percent,
+            "swap_total": swap.total,
+            "swap_used": swap.used,
+            "swap_percent": swap.percent if swap.total else 0,
+        },
+        "disks": [],
+        "network": {
+            "hostname": platform.node(),
+            "primary_ip": primary_ip,
+            "bytes_sent": net_io.bytes_sent,
+            "bytes_recv": net_io.bytes_recv,
+            "packets_sent": net_io.packets_sent,
+            "packets_recv": net_io.packets_recv,
+        },
+        "processes": {
+            "total": proc_count,
+            "top_by_cpu": top_procs,
+        },
+    }
+
+    for d in disks:
+        try:
+            usage = psutil.disk_usage(d.mountpoint)
+            info["disks"].append({
+                "device": d.device,
+                "mount": d.mountpoint,
+                "fstype": d.fstype,
+                "total": usage.total,
+                "used": usage.used,
+                "free": usage.free,
+                "percent": usage.percent,
+            })
+        except PermissionError:
+            continue
+
+    if disk_io:
+        info["disk_io"] = {
+            "read_count": disk_io.read_count,
+            "write_count": disk_io.write_count,
+            "read_bytes": disk_io.read_bytes,
+            "write_bytes": disk_io.write_bytes,
+        }
+
+    result = json.dumps(info, ensure_ascii=False, indent=2)
+
+    with open(output_path, "w") as f:
+        f.write(result)
+
+    return result
+
+
+def main():
+    """Entry point — run the MCP server over stdio."""
+    server.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

get_sys_info/__main__.py

@@ -0,0 +1,4 @@
+"""Allow `python -m get_sys_info` to run the MCP server."""
+from get_sys_info import main
+
+main()

get_sys_info-0.1.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: get-sys-info
+Version: 0.1.0
+Summary: MCP server for macOS system information
+Requires-Python: >=3.12
+Requires-Dist: mcp[cli]>=1.0.0
+Requires-Dist: psutil>=6.0.0

get_sys_info-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+get_sys_info/__init__.py,sha256=HKb-bRp7l2M-lr_Ub7eYjC2ARYLIXqCHAa9gR2PRatM,6333
+get_sys_info/__main__.py,sha256=B22-QaRxducwURnwn-P_a68pFYBF_MW2kUoie1Pl8DI,98
+get_sys_info-0.1.0.dist-info/METADATA,sha256=SpCV4yq6gGvBKUwmgJNkTxKEeHrytipz0t9Dnd_0EJY,189
+get_sys_info-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+get_sys_info-0.1.0.dist-info/entry_points.txt,sha256=BWxcscUIAd9a51uj3GpP9oy2xH9WxaIpkaH5CN90who,51
+get_sys_info-0.1.0.dist-info/RECORD,,

get_sys_info-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

get_sys_info-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+get-sys-info = get_sys_info:main