mcp-deploy-server 0.3.0__tar.gz

mcp_deploy_server-0.3.0/.gitignore

@@ -0,0 +1,8 @@
+node_modules/
+dist/
+*.tsbuildinfo
+.omx/
+__pycache__/
+*.pyc
+*.egg-info/
+.python-version

mcp_deploy_server-0.3.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.5
+Name: mcp-deploy-server
+Version: 0.3.0
+Summary: MCP deployment server for AI agents to execute commands on remote servers
+License: MIT
+Keywords: ai-agents,deployment,mcp,ssh
+Requires-Python: >=3.11
+Requires-Dist: asyncssh>=2.14.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Description-Content-Type: text/markdown
+
+# serverASmcp

mcp_deploy_server-0.3.0/README.md

@@ -0,0 +1 @@
+# serverASmcp

mcp_deploy_server-0.3.0/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "mcp-deploy-server"
+version = "0.3.0"
+description = "MCP deployment server for AI agents to execute commands on remote servers"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.11"
+keywords = ["mcp", "deployment", "ssh", "ai-agents"]
+dependencies = [
+    "mcp>=1.0.0",
+    "asyncssh>=2.14.0",
+    "pydantic>=2.0.0",
+]
+
+[project.scripts]
+mcp-deploy-server = "mcp_deploy_server.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mcp_deploy_server"]

mcp_deploy_server-0.3.0/src/mcp_deploy_server/__init__.py

@@ -0,0 +1,2 @@
+"""MCP Deploy Server - AI agent deployment via SSH."""
+__version__ = "0.3.0"

mcp_deploy_server-0.3.0/src/mcp_deploy_server/main.py

@@ -0,0 +1,320 @@
+"""MCP Deploy Server - main entry point."""
+
+import json
+import time
+import uuid
+from typing import Any
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import Tool, TextContent
+
+from .models import (
+    ServerEntry,
+    load_servers,
+    find_server,
+    find_server_by_name,
+    add_server,
+    remove_server,
+    append_audit,
+    get_config_dir,
+)
+from .ssh import (
+    get_connection,
+    close_connection,
+    close_all_connections,
+    exec_command,
+    upload_content,
+    upload_file,
+)
+
+app = Server("mcp-deploy-server")
+
+
+def _resolve_server(id_or_name: str) -> ServerEntry | None:
+    return find_server(id_or_name) or find_server_by_name(id_or_name)
+
+
+def _sanitize_args(args: dict[str, Any]) -> str:
+    sanitized = dict(args)
+    if "password" in sanitized:
+        sanitized["password"] = "***"
+    if "content" in sanitized and isinstance(sanitized["content"], str) and len(sanitized["content"]) > 200:
+        sanitized["content"] = f"[{len(sanitized['content'])} chars]"
+    return json.dumps(sanitized)
+
+
+TOOLS = [
+    Tool(
+        name="add_server",
+        description="Add a target server. Call multiple times to add many servers.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "name": {"type": "string", "description": "Unique label (e.g. web-1)"},
+                "host": {"type": "string", "description": "IP or hostname"},
+                "port": {"type": "integer", "default": 22, "description": "SSH port"},
+                "username": {"type": "string", "default": "root", "description": "SSH user"},
+                "authMethod": {"type": "string", "enum": ["password", "private_key"]},
+                "password": {"type": "string", "description": "SSH password"},
+                "privateKeyPath": {"type": "string", "description": "Path to SSH key"},
+                "privateKey": {"type": "string", "description": "SSH key content"},
+            },
+            "required": ["name", "host", "authMethod"],
+        },
+    ),
+    Tool(
+        name="list_servers",
+        description="List all registered servers",
+        inputSchema={"type": "object", "properties": {}},
+    ),
+    Tool(
+        name="remove_server",
+        description="Remove a server by name",
+        inputSchema={
+            "type": "object",
+            "properties": {"server": {"type": "string", "description": "Server name"}},
+            "required": ["server"],
+        },
+    ),
+    Tool(
+        name="run_command",
+        description="Execute any shell command as root on a specific server. No restrictions.",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "server": {"type": "string", "description": "Server name or ID"},
+                "command": {"type": "string", "description": "Shell command"},
+                "timeoutSec": {"type": "integer", "default": 30},
+            },
+            "required": ["server", "command"],
+        },
+    ),
+    Tool(
+        name="run_all",
+        description="Execute the same command on ALL servers",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "command": {"type": "string"},
+                "timeoutSec": {"type": "integer", "default": 30},
+            },
+            "required": ["command"],
+        },
+    ),
+    Tool(
+        name="deploy_file",
+        description="Upload files and run commands on a specific server",
+        inputSchema={
+            "type": "object",
+            "properties": {
+                "server": {"type": "string", "description": "Server name or ID"},
+                "files": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "localPath": {"type": "string"},
+                            "content": {"type": "string"},
+                            "remotePath": {"type": "string"},
+                        },
+                        "required": ["remotePath"],
+                    },
+                    "minItems": 1,
+                },
+                "remoteDir": {"type": "string", "default": "/tmp"},
+                "commands": {"type": "array", "items": {"type": "string"}, "default": []},
+            },
+            "required": ["server", "files"],
+        },
+    ),
+    Tool(
+        name="check_status",
+        description="Test SSH connectivity to a server",
+        inputSchema={
+            "type": "object",
+            "properties": {"server": {"type": "string"}},
+            "required": ["server"],
+        },
+    ),
+]
+
+
+@app.list_tools()
+async def list_tools() -> list[Tool]:
+    return TOOLS
+
+
+@app.call_tool()
+async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
+    start = time.monotonic()
+
+    if name == "add_server":
+        result = await _add_server(arguments)
+    elif name == "list_servers":
+        result = await _list_servers()
+    elif name == "remove_server":
+        result = await _remove_server(arguments)
+    elif name == "run_command":
+        result = await _run_command(arguments)
+    elif name == "run_all":
+        result = await _run_all(arguments)
+    elif name == "deploy_file":
+        result = await _deploy_file(arguments)
+    elif name == "check_status":
+        result = await _check_status(arguments)
+    else:
+        result = f"Unknown tool: {name}"
+
+    duration_ms = int((time.monotonic() - start) * 1000)
+    server_name = arguments.get("server", arguments.get("name", "*"))
+    append_audit(name, str(server_name), _sanitize_args(arguments), result[:200], duration_ms)
+    return [TextContent(type="text", text=result)]
+
+
+async def _add_server(args: dict[str, Any]) -> str:
+    name = args.get("name", "")
+    if find_server_by_name(name):
+        return f"Server name '{name}' already exists. Use a different name."
+
+    auth = args.get("authMethod", "password")
+    if auth == "password" and not args.get("password"):
+        return "Password is required when authMethod is 'password'."
+    if auth == "private_key" and not args.get("privateKeyPath") and not args.get("privateKey"):
+        return "privateKeyPath or privateKey is required when authMethod is 'private_key'."
+
+    entry = ServerEntry(
+        id=str(uuid.uuid4()),
+        name=name,
+        host=args.get("host", ""),
+        port=args.get("port", 22),
+        username=args.get("username", "root"),
+        auth_method=auth,
+        password=args.get("password"),
+        private_key_path=args.get("privateKeyPath"),
+        private_key=args.get("privateKey"),
+    )
+    add_server(entry)
+    return f"Server '{name}' added ({entry.username}@{entry.host}:{entry.port}). ID: {entry.id}"
+
+
+async def _list_servers() -> str:
+    servers = load_servers()
+    if not servers:
+        return "No servers registered. Use add_server to add one."
+    lines = []
+    for s in servers:
+        auth = "password" if s.auth_method == "password" else f"key: {s.private_key_path or 'inline'}"
+        lines.append(f"- {s.name} → {s.username}@{s.host}:{s.port} [{auth}] (id: {s.id})")
+    return "\n".join(lines)
+
+
+async def _remove_server(args: dict[str, Any]) -> str:
+    entry = _resolve_server(args.get("server", ""))
+    if not entry:
+        return f"Server '{args.get('server')}' not found."
+    close_connection(entry.id)
+    removed = remove_server(entry.id)
+    return f"Server '{args.get('server')}' removed." if removed else "Failed to remove."
+
+
+async def _run_command(args: dict[str, Any]) -> str:
+    entry = _resolve_server(args.get("server", ""))
+    if not entry:
+        return f"Server '{args.get('server')}' not found. Use list_servers."
+
+    try:
+        conn = await get_connection(entry)
+        result = await exec_command(conn, args["command"], args.get("timeoutSec", 30))
+        output = [
+            f"Server: {entry.name} ({entry.host})",
+            f"Command: {args['command']}",
+            f"Exit code: {result['exit_code']}",
+        ]
+        if result["stdout"]:
+            output.append(f"\nSTDOUT:\n{result['stdout'].strip()}")
+        if result["stderr"]:
+            output.append(f"\nSTDERR:\n{result['stderr'].strip()}")
+        return "\n".join(output)
+    except Exception as e:
+        return f"Error: {e}"
+
+
+async def _run_all(args: dict[str, Any]) -> str:
+    servers = load_servers()
+    if not servers:
+        return "No servers registered."
+
+    results = [f"Command on all {len(servers)} server(s): {args['command']}"]
+    for entry in servers:
+        try:
+            conn = await get_connection(entry)
+            result = await exec_command(conn, args["command"], args.get("timeoutSec", 30))
+            status = "OK" if result["exit_code"] == 0 else f"FAILED ({result['exit_code']})"
+            results.append(f"{entry.name}: {status}")
+            if result["stdout"]:
+                results.append(f"  stdout: {result['stdout'].strip()[:200]}")
+        except Exception as e:
+            results.append(f"{entry.name}: ERROR — {e}")
+    return "\n".join(results)
+
+
+async def _deploy_file(args: dict[str, Any]) -> str:
+    entry = _resolve_server(args.get("server", ""))
+    if not entry:
+        return f"Server '{args.get('server')}' not found."
+
+    results = [f"Server: {entry.name}"]
+    try:
+        conn = await get_connection(entry)
+        for f in args.get("files", []):
+            if "localPath" in f:
+                await upload_file(conn, f["localPath"], f["remotePath"])
+                results.append(f"Uploaded {f['localPath']} → {f['remotePath']}")
+            elif "content" in f:
+                await upload_content(conn, f["content"], f["remotePath"])
+                results.append(f"Wrote {f['remotePath']} ({len(f['content'])} chars)")
+
+        remote_dir = args.get("remoteDir", "/tmp")
+        for cmd in args.get("commands", []):
+            try:
+                result = await exec_command(conn, f"cd {remote_dir} && {cmd}", 60)
+                status = "OK" if result["exit_code"] == 0 else f"FAILED ({result['exit_code']})"
+                results.append(f"$ {cmd} → {status}")
+                if result["stderr"]:
+                    results.append(f"  stderr: {result['stderr'].strip()[:500]}")
+            except Exception as e:
+                results.append(f"$ {cmd} → ERROR: {e}")
+    except Exception as e:
+        results.append(f"Error: {e}")
+
+    return "\n".join(results)
+
+
+async def _check_status(args: dict[str, Any]) -> str:
+    entry = _resolve_server(args.get("server", ""))
+    if not entry:
+        return f"Server '{args.get('server')}' not found."
+
+    try:
+        conn = await get_connection(entry)
+        result = await exec_command(conn, "echo ok && uname -a && whoami", 5)
+        return f"{entry.name}: connected\n{result['stdout'].strip()}"
+    except Exception as e:
+        return f"{args.get('server')}: connection failed — {e}"
+
+
+async def main() -> None:
+    async with stdio_server() as (read_stream, write_stream):
+        servers = load_servers()
+        import sys
+        print(
+            f"MCP Deploy Server v0.3.0 (stdio) | {len(servers)} server(s) registered | config: {get_config_dir()}",
+            file=sys.stderr,
+        )
+        await app.run(read_stream, write_stream, app.create_initialization_options())
+
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

mcp_deploy_server-0.3.0/src/mcp_deploy_server/models.py

@@ -0,0 +1,106 @@
+"""Data models for server configuration and audit entries."""
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class ServerEntry(BaseModel):
+    id: str
+    name: str
+    host: str
+    port: int = 22
+    username: str = "root"
+    auth_method: str = Field(..., alias="authMethod", pattern="^(password|private_key)$")
+    password: Optional[str] = None
+    private_key_path: Optional[str] = Field(None, alias="privateKeyPath")
+    private_key: Optional[str] = Field(None, alias="privateKey")
+
+    model_config = {"populate_by_name": True}
+
+
+class AuditEntry(BaseModel):
+    timestamp: str
+    tool_name: str
+    server_name: str
+    args_summary: str
+    result_summary: str
+    duration_ms: Optional[int] = None
+
+
+CONFIG_DIR = Path.home() / ".mcp-deploy"
+SERVERS_FILE = CONFIG_DIR / "servers.json"
+AUDIT_FILE = CONFIG_DIR / "audit.log"
+
+
+def ensure_config_dir() -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_servers() -> list[ServerEntry]:
+    ensure_config_dir()
+    if not SERVERS_FILE.exists():
+        return []
+    try:
+        data = json.loads(SERVERS_FILE.read_text("utf-8"))
+        return [ServerEntry(**s) for s in data.get("servers", [])]
+    except Exception:
+        return []
+
+
+def save_servers(servers: list[ServerEntry]) -> None:
+    ensure_config_dir()
+    SERVERS_FILE.write_text(
+        json.dumps({"servers": [s.model_dump(by_alias=True, exclude_none=True) for s in servers]}, indent=2),
+        "utf-8",
+    )
+
+
+def find_server(server_id: str) -> Optional[ServerEntry]:
+    return next((s for s in load_servers() if s.id == server_id), None)
+
+
+def find_server_by_name(name: str) -> Optional[ServerEntry]:
+    return next((s for s in load_servers() if s.name == name), None)
+
+
+def add_server(entry: ServerEntry) -> None:
+    servers = load_servers()
+    servers.append(entry)
+    save_servers(servers)
+
+
+def remove_server(server_id: str) -> bool:
+    servers = load_servers()
+    filtered = [s for s in servers if s.id != server_id]
+    if len(filtered) == len(servers):
+        return False
+    save_servers(filtered)
+    return True
+
+
+def get_config_dir() -> str:
+    return str(CONFIG_DIR)
+
+
+def append_audit(
+    tool_name: str,
+    server_name: str,
+    args_summary: str,
+    result_summary: str,
+    duration_ms: int | None = None,
+) -> None:
+    ensure_config_dir()
+    entry = AuditEntry(
+        timestamp=datetime.now(timezone.utc).isoformat(),
+        tool_name=tool_name,
+        server_name=server_name,
+        args_summary=args_summary,
+        result_summary=result_summary,
+        duration_ms=duration_ms,
+    )
+    with open(AUDIT_FILE, "a") as f:
+        f.write(entry.model_dump_json(exclude_none=True) + "\n")

mcp_deploy_server-0.3.0/src/mcp_deploy_server/ssh.py

@@ -0,0 +1,108 @@
+"""Async SSH connection manager with connection pooling per server."""
+
+import asyncio
+from pathlib import Path
+from typing import Any
+
+import asyncssh
+
+from .models import ServerEntry
+
+_connections: dict[str, asyncssh.SSHClientConnection] = {}
+
+
+def _build_connect_kwargs(server: ServerEntry) -> dict[str, Any]:
+    kwargs: dict[str, Any] = {
+        "host": server.host,
+        "port": server.port,
+        "username": server.username,
+        "known_hosts": None,
+        "connect_timeout": 10,
+    }
+    if server.auth_method == "password" and server.password:
+        kwargs["password"] = server.password
+    elif server.auth_method == "private_key":
+        if server.private_key_path:
+            kwargs["client_keys"] = [server.private_key_path]
+        elif server.private_key:
+            kwargs["client_keys"] = [(asyncssh.import_private_key(server.private_key))]
+    return kwargs
+
+
+async def get_connection(server: ServerEntry) -> asyncssh.SSHClientConnection:
+    """Get or create a pooled SSH connection for a server."""
+    conn = _connections.get(server.id)
+    if conn is not None:
+        try:
+            # Liveness check
+            result = await conn.run("true", check=False)
+            if result.exit_code == 0:
+                return conn
+        except Exception:
+            pass
+        # Stale connection, remove
+        _connections.pop(server.id, None)
+        try:
+            conn.close()
+        except Exception:
+            pass
+
+    kwargs = _build_connect_kwargs(server)
+    conn = await asyncssh.connect(**kwargs)
+    _connections[server.id] = conn
+    return conn
+
+
+def close_connection(server_id: str) -> None:
+    """Close a specific server connection."""
+    conn = _connections.pop(server_id, None)
+    if conn:
+        conn.close()
+
+
+def close_all_connections() -> None:
+    """Close all pooled connections."""
+    for conn in _connections.values():
+        conn.close()
+    _connections.clear()
+
+
+async def exec_command(
+    conn: asyncssh.SSHClientConnection,
+    command: str,
+    timeout_sec: int = 30,
+) -> dict[str, Any]:
+    """Execute a command and return exit_code, stdout, stderr."""
+    try:
+        result = await asyncio.wait_for(
+            conn.run(command, check=False),
+            timeout=timeout_sec,
+        )
+        return {
+            "exit_code": result.exit_code or 0,
+            "stdout": result.stdout or "",
+            "stderr": result.stderr or "",
+        }
+    except asyncio.TimeoutError:
+        raise TimeoutError(f"Command timed out after {timeout_sec}s")
+
+
+async def upload_content(
+    conn: asyncssh.SSHClientConnection,
+    content: str,
+    remote_path: str,
+) -> None:
+    """Write content to a remote file via SFTP."""
+    async with conn.start_sftp_client() as sftp:
+        async with sftp.open(remote_path, "w") as f:
+            await f.write(content)
+
+
+async def upload_file(
+    conn: asyncssh.SSHClientConnection,
+    local_path: str,
+    remote_path: str,
+) -> None:
+    """Upload a local file to a remote path via SFTP."""
+    async with conn.start_sftp_client() as sftp:
+        await sftp.put(local_path, remote_path)