macos-sysinfo-mcp 0.1.0__tar.gz

macos_sysinfo_mcp-0.1.0/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(python3 -c \"import sys; print\\(sys.version\\)\")",
+      "Bash(pip3 list *)",
+      "Bash(uv sync *)"
+    ]
+  }
+}

macos_sysinfo_mcp-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+# Generated system info dumps
+system_info.json
+
+# Environment
+.venv/
+__pycache__/
+*.pyc
+
+# IDE
+.idea/
+*.swp
+*.swo
+
+# Logs
+*.log

macos_sysinfo_mcp-0.1.0/CLAUDE.md

@@ -0,0 +1,80 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+An MCP (Model Context Protocol) server that collects macOS system information — OS version, CPU, memory, disk, network, processes, and uptime — exposed via a single `get_os_info` tool.
+
+## Environment
+
+- Python 3.12.10 (managed by pyenv + uv 0.11.17)
+- Virtual env: `.venv/` (uv-created)
+- Dependencies managed via `pyproject.toml`
+
+## Package Structure
+
+```
+get_sys_info/
+├── get_sys_info/          # Python package
+│   ├── __init__.py        # MCP server — single tool: get_os_info
+│   └── __main__.py        # python -m entry point
+├── pyproject.toml          # project config / build / entry point
+├── CLAUDE.md
+├── .gitignore
+└── .venv/
+```
+
+## Commands
+
+```bash
+source .venv/bin/activate        # activate venv
+uv sync                          # install / update deps
+uv run python -m get_sys_info    # run MCP server (stdio mode)
+uv build                         # build wheel + sdist
+```
+
+## Key Dependencies
+
+- `mcp` — MCP Python SDK (FastMCP server)
+- `psutil` — cross-platform system metrics
+
+## Packaging for Other Projects
+
+```bash
+# Build the package
+uv build
+
+# Install in another project
+uv pip install dist/get_sys_info-0.1.0-py3-none-any.whl
+# or from local source
+uv pip install -e /path/to/get_sys_info
+```
+
+## MCP Config for Consumer Projects
+
+In the consumer project's `.claude/mcp.json` or `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "get-sys-info": {
+      "command": "python",
+      "args": ["-m", "get_sys_info"]
+    }
+  }
+}
+```
+
+For uv-managed projects without a pre-installed package:
+
+```json
+{
+  "mcpServers": {
+    "get-sys-info": {
+      "command": "uv",
+      "args": ["run", "--with", "get-sys-info", "python", "-m", "get_sys_info"]
+    }
+  }
+}
+```

macos_sysinfo_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: macos-sysinfo-mcp
+Version: 0.1.0
+Summary: MCP server for macOS system information
+Project-URL: Homepage, https://github.com/QIMING/macos-sysinfo-mcp
+Project-URL: Repository, https://github.com/QIMING/macos-sysinfo-mcp
+Project-URL: Issues, https://github.com/QIMING/macos-sysinfo-mcp/issues
+Author-email: QIMING <13728724090@163.com>
+License: MIT
+Keywords: macos,mcp,model-context-protocol,system-info
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.12
+Requires-Dist: mcp[cli]>=1.0.0
+Requires-Dist: psutil>=6.0.0
+Description-Content-Type: text/markdown
+
+# macOS System Info MCP
+
+An MCP (Model Context Protocol) server that collects macOS system information — OS version, CPU, memory, disk, network, processes, and uptime — exposed via a single `get_os_info` tool.
+
+## Usage
+
+### In MCP Client Configuration
+
+```json
+{
+  "mcpServers": {
+    "macos-sysinfo-mcp": {
+      "command": "python",
+      "args": ["-m", "get_sys_info"]
+    }
+  }
+}
+```
+
+Or with `uv` (no pre-install needed):
+
+```json
+{
+  "mcpServers": {
+    "macos-sysinfo-mcp": {
+      "command": "uv",
+      "args": [
+        "run",
+        "--with", "macos-sysinfo-mcp",
+        "python", "-m", "get_sys_info"
+      ]
+    }
+  }
+}
+```
+
+### Tool: `get_os_info`
+
+- **Required parameter**: `output_path` — absolute path to save the JSON result
+
+## Development
+
+```bash
+uv sync
+source .venv/bin/activate
+uv run python -m get_sys_info
+```

macos_sysinfo_mcp-0.1.0/README.md

@@ -0,0 +1,47 @@
+# macOS System Info MCP
+
+An MCP (Model Context Protocol) server that collects macOS system information — OS version, CPU, memory, disk, network, processes, and uptime — exposed via a single `get_os_info` tool.
+
+## Usage
+
+### In MCP Client Configuration
+
+```json
+{
+  "mcpServers": {
+    "macos-sysinfo-mcp": {
+      "command": "python",
+      "args": ["-m", "get_sys_info"]
+    }
+  }
+}
+```
+
+Or with `uv` (no pre-install needed):
+
+```json
+{
+  "mcpServers": {
+    "macos-sysinfo-mcp": {
+      "command": "uv",
+      "args": [
+        "run",
+        "--with", "macos-sysinfo-mcp",
+        "python", "-m", "get_sys_info"
+      ]
+    }
+  }
+}
+```
+
+### Tool: `get_os_info`
+
+- **Required parameter**: `output_path` — absolute path to save the JSON result
+
+## Development
+
+```bash
+uv sync
+source .venv/bin/activate
+uv run python -m get_sys_info
+```

macos_sysinfo_mcp-0.1.0/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()

macos_sysinfo_mcp-0.1.0/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()

macos_sysinfo_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "macos-sysinfo-mcp"
+version = "0.1.0"
+description = "MCP server for macOS system information"
+readme = "README.md"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+authors = [
+    { name = "QIMING", email = "13728724090@163.com" },
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: MacOS",
+    "Environment :: Console",
+    "Topic :: System :: Monitoring",
+]
+keywords = ["mcp", "system-info", "macos", "model-context-protocol"]
+dependencies = [
+    "mcp[cli]>=1.0.0",
+    "psutil>=6.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/QIMING/macos-sysinfo-mcp"
+Repository = "https://github.com/QIMING/macos-sysinfo-mcp"
+Issues = "https://github.com/QIMING/macos-sysinfo-mcp/issues"
+
+[project.scripts]
+get-sys-info = "get_sys_info:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["get_sys_info"]