mcp-ssh-vps 0.4.1__py3-none-any.whl

sshmcp/prompts/deploy.py

@@ -0,0 +1,115 @@
+"""MCP Prompt for application deployment."""
+
+
+def deploy_app(
+    host: str,
+    branch: str = "main",
+    app_path: str = "/var/www/app",
+    package_manager: str = "npm",
+    process_manager: str = "pm2",
+    app_name: str = "app",
+) -> str:
+    """
+    Generate deployment prompt for application.
+
+    Creates a step-by-step deployment plan for a web application.
+
+    Args:
+        host: Target host name.
+        branch: Git branch to deploy (default: main).
+        app_path: Application directory path.
+        package_manager: Package manager (npm, yarn, pip).
+        process_manager: Process manager (pm2, systemd, supervisor).
+        app_name: Application name for process manager.
+
+    Returns:
+        Deployment instructions as multi-line string.
+    """
+    # Build install command based on package manager
+    install_commands = {
+        "npm": "npm ci --production",
+        "yarn": "yarn install --frozen-lockfile --production",
+        "pip": "pip install -r requirements.txt",
+        "poetry": "poetry install --no-dev",
+    }
+    install_cmd = install_commands.get(package_manager, "npm install")
+
+    # Build restart command based on process manager
+    restart_commands = {
+        "pm2": f"pm2 restart {app_name}",
+        "systemd": f"systemctl restart {app_name}",
+        "supervisor": f"supervisorctl restart {app_name}",
+    }
+    restart_cmd = restart_commands.get(process_manager, f"pm2 restart {app_name}")
+
+    # Build status command
+    status_commands = {
+        "pm2": f"pm2 status {app_name}",
+        "systemd": f"systemctl status {app_name}",
+        "supervisor": f"supervisorctl status {app_name}",
+    }
+    status_cmd = status_commands.get(process_manager, f"pm2 status {app_name}")
+
+    return f"""Deploy application to {host}:
+
+## Pre-deployment Checks
+1. Check server status:
+   - Use get_status resource for {host} to verify server is online
+   - Use get_metrics resource for {host} to check available resources
+
+2. Check current application state:
+   ```
+   execute_command(host="{host}", command="cd {app_path} && git status")
+   ```
+
+## Deployment Steps
+
+3. Pull latest code from branch {branch}:
+   ```
+   execute_command(host="{host}", command="cd {app_path} && git fetch origin && git checkout {branch} && git pull origin {branch}")
+   ```
+
+4. Install dependencies:
+   ```
+   execute_command(host="{host}", command="cd {app_path} && {install_cmd}")
+   ```
+
+5. Build application (if needed):
+   ```
+   execute_command(host="{host}", command="cd {app_path} && npm run build")
+   ```
+
+6. Restart application:
+   ```
+   execute_command(host="{host}", command="{restart_cmd}")
+   ```
+
+## Post-deployment Verification
+
+7. Check application status:
+   ```
+   execute_command(host="{host}", command="{status_cmd}")
+   ```
+
+8. Check application logs:
+   - Use get_logs resource for {host} with path "var/log/{app_name}.log" or appropriate log path
+
+9. Verify health endpoint (if available):
+   ```
+   execute_command(host="{host}", command="curl -s http://localhost:3000/health")
+   ```
+
+## Rollback Plan
+If deployment fails:
+1. Checkout previous commit:
+   ```
+   execute_command(host="{host}", command="cd {app_path} && git checkout HEAD~1")
+   ```
+2. Reinstall dependencies and restart application
+
+## Notes
+- Branch: {branch}
+- Application path: {app_path}
+- Package manager: {package_manager}
+- Process manager: {process_manager}
+"""

sshmcp/prompts/monitor.py

@@ -0,0 +1,146 @@
+"""MCP Prompt for system monitoring."""
+
+
+def monitor_health(
+    host: str,
+    check_logs: bool = True,
+    check_services: bool = True,
+    log_paths: list[str] | None = None,
+    services: list[str] | None = None,
+) -> str:
+    """
+    Generate health monitoring prompt.
+
+    Creates a comprehensive health check plan for a server.
+
+    Args:
+        host: Target host name.
+        check_logs: Whether to check log files for errors.
+        check_services: Whether to check service statuses.
+        log_paths: List of log file paths to check.
+        services: List of services to check.
+
+    Returns:
+        Monitoring instructions as multi-line string.
+    """
+    default_logs = [
+        "/var/log/syslog",
+        "/var/log/nginx/error.log",
+        "/var/log/app/error.log",
+    ]
+    default_services = ["nginx", "postgresql", "redis"]
+
+    log_paths = log_paths or default_logs
+    services = services or default_services
+
+    logs_section = ""
+    if check_logs:
+        logs_section = """
+## Log Analysis
+
+Check for errors in application logs:
+"""
+        for log_path in log_paths:
+            logs_section += f"""
+### {log_path}
+- Use get_logs resource for {host} with path "{log_path.lstrip("/")}" and filter_level="error"
+- Or execute directly:
+```
+execute_command(host="{host}", command="tail -n 100 {log_path} | grep -iE 'error|fatal|critical' | tail -20")
+```
+"""
+
+    services_section = ""
+    if check_services:
+        services_section = """
+## Service Health
+
+Check status of critical services:
+"""
+        for service in services:
+            services_section += f"""
+### {service}
+```
+manage_process(host="{host}", action="status", process_name="{service}")
+```
+"""
+
+    return f"""Monitor health of {host}:
+
+## System Metrics
+
+1. Get current system metrics:
+   - Use get_metrics resource for {host}
+   - This provides CPU, memory, disk usage, and load average
+
+2. Check for high resource usage:
+   ```
+   execute_command(host="{host}", command="top -bn1 | head -20")
+   ```
+
+3. Check disk space on all mounts:
+   ```
+   execute_command(host="{host}", command="df -h")
+   ```
+
+4. Check memory details:
+   ```
+   execute_command(host="{host}", command="free -m")
+   ```
+
+5. Check system load:
+   ```
+   execute_command(host="{host}", command="uptime")
+   ```
+{logs_section}{services_section}
+## Network Health
+
+Check network connectivity:
+```
+execute_command(host="{host}", command="netstat -tuln | head -20")
+```
+
+Check established connections:
+```
+execute_command(host="{host}", command="netstat -an | grep ESTABLISHED | wc -l")
+```
+
+## Recent System Events
+
+Check dmesg for hardware/kernel issues:
+```
+execute_command(host="{host}", command="dmesg | tail -20")
+```
+
+Check authentication logs:
+```
+execute_command(host="{host}", command="tail -20 /var/log/auth.log")
+```
+
+## Health Report Summary
+
+After running the above checks, summarize:
+
+1. **System Resources**:
+   - CPU usage: [X]%
+   - Memory usage: [X]%
+   - Disk usage: [X]%
+   - Load average: [X]
+
+2. **Services Status**:
+   - List all checked services and their status
+
+3. **Issues Found**:
+   - List any errors from logs
+   - List any services that are not running
+   - List any resource usage concerns
+
+4. **Recommendations**:
+   - Based on findings, provide action items
+
+## Thresholds to Watch
+- CPU > 80%: High usage warning
+- Memory > 85%: Memory pressure warning
+- Disk > 90%: Disk space critical
+- Load average > number of cores: System overloaded
+"""

sshmcp/resources/__init__.py

@@ -0,0 +1,7 @@
+"""MCP Resources for VPS data access."""
+
+from sshmcp.resources.logs import get_logs
+from sshmcp.resources.metrics import get_metrics
+from sshmcp.resources.status import get_status
+
+__all__ = ["get_logs", "get_metrics", "get_status"]

sshmcp/resources/logs.py

@@ -0,0 +1,99 @@
+"""MCP Resource for reading logs."""
+
+import structlog
+
+from sshmcp.config import get_machine
+from sshmcp.security.audit import get_audit_logger
+from sshmcp.security.validator import validate_path
+from sshmcp.ssh.pool import get_pool
+
+logger = structlog.get_logger()
+
+
+def get_logs(
+    host: str,
+    log_path: str,
+    lines: int = 100,
+    filter_level: str | None = None,
+) -> str:
+    """
+    Get logs from VPS server.
+
+    Reads the last N lines from a log file, optionally filtering by log level.
+
+    Args:
+        host: Name of the host from machines.json configuration.
+        log_path: Path to log file (e.g., "var/log/app.log").
+        lines: Number of lines to retrieve (default: 100).
+        filter_level: Optional log level filter (error, warn, info).
+
+    Returns:
+        Log content as string.
+
+    Raises:
+        ValueError: If host not found or path not allowed.
+        RuntimeError: If logs cannot be read.
+
+    Example:
+        Resource URI: vps://production-server/logs/var/log/app.log
+    """
+    audit = get_audit_logger()
+
+    # Normalize path (add leading slash if needed)
+    if not log_path.startswith("/"):
+        log_path = "/" + log_path
+
+    # Get machine configuration
+    try:
+        machine = get_machine(host)
+    except Exception as e:
+        raise ValueError(f"Host not found: {host}") from e
+
+    # Validate path
+    is_valid, error_msg = validate_path(log_path, machine.security, "read")
+    if not is_valid:
+        audit.log_path_rejected(host, log_path, error_msg or "Path not allowed")
+        raise ValueError(f"Path not allowed: {error_msg}")
+
+    # Build command
+    if filter_level:
+        level_patterns = {
+            "error": "ERROR|FATAL|CRITICAL",
+            "warn": "WARN|WARNING|ERROR|FATAL|CRITICAL",
+            "info": "INFO|WARN|WARNING|ERROR|FATAL|CRITICAL",
+        }
+        pattern = level_patterns.get(filter_level.lower(), "")
+        if pattern:
+            command = f"tail -n {lines * 2} {log_path} | grep -iE '{pattern}' | tail -n {lines}"
+        else:
+            command = f"tail -n {lines} {log_path}"
+    else:
+        command = f"tail -n {lines} {log_path}"
+
+    # Execute command
+    pool = get_pool()
+    pool.register_machine(machine)
+
+    try:
+        client = pool.get_client(host)
+        try:
+            result = client.execute(command)
+
+            if result.exit_code != 0:
+                if "No such file" in result.stderr:
+                    raise RuntimeError(f"Log file not found: {log_path}")
+                raise RuntimeError(f"Failed to read logs: {result.stderr}")
+
+            audit.log(
+                event="logs_read",
+                host=host,
+                result={"path": log_path, "lines": lines},
+            )
+
+            return result.stdout
+
+        finally:
+            pool.release_client(client)
+
+    except Exception as e:
+        raise RuntimeError(f"Failed to read logs: {e}") from e

sshmcp/resources/metrics.py

@@ -0,0 +1,204 @@
+"""MCP Resource for system metrics."""
+
+import re
+
+import structlog
+
+from sshmcp.config import get_machine
+from sshmcp.security.audit import get_audit_logger
+from sshmcp.ssh.pool import get_pool
+
+logger = structlog.get_logger()
+
+
+def get_metrics(host: str) -> dict:
+    """
+    Get system metrics from VPS server.
+
+    Returns CPU, memory, disk usage, and uptime information.
+
+    Args:
+        host: Name of the host from machines.json configuration.
+
+    Returns:
+        Dictionary with metrics:
+        - cpu: CPU usage information
+        - memory: Memory usage information
+        - disk: Disk usage information
+        - uptime_seconds: System uptime
+
+    Raises:
+        ValueError: If host not found.
+        RuntimeError: If metrics cannot be retrieved.
+
+    Example:
+        Resource URI: vps://production-server/metrics
+    """
+    audit = get_audit_logger()
+
+    # Get machine configuration
+    try:
+        machine = get_machine(host)
+    except Exception as e:
+        raise ValueError(f"Host not found: {host}") from e
+
+    pool = get_pool()
+    pool.register_machine(machine)
+
+    metrics = {
+        "cpu": {},
+        "memory": {},
+        "disk": {},
+        "uptime_seconds": 0,
+        "host": host,
+    }
+
+    try:
+        client = pool.get_client(host)
+        try:
+            # Get CPU usage
+            cpu_result = client.execute(
+                "top -bn1 | head -5 | grep 'Cpu' || cat /proc/stat | head -1"
+            )
+            metrics["cpu"] = _parse_cpu(cpu_result.stdout)
+
+            # Get memory usage
+            mem_result = client.execute("free -m")
+            metrics["memory"] = _parse_memory(mem_result.stdout)
+
+            # Get disk usage
+            disk_result = client.execute("df -h / | tail -1")
+            metrics["disk"] = _parse_disk(disk_result.stdout)
+
+            # Get uptime
+            uptime_result = client.execute("cat /proc/uptime")
+            metrics["uptime_seconds"] = _parse_uptime(uptime_result.stdout)
+
+            # Get load average
+            load_result = client.execute("cat /proc/loadavg")
+            metrics["load_average"] = _parse_load(load_result.stdout)
+
+            audit.log(
+                event="metrics_read",
+                host=host,
+            )
+
+            return metrics
+
+        finally:
+            pool.release_client(client)
+
+    except Exception as e:
+        raise RuntimeError(f"Failed to get metrics: {e}") from e
+
+
+def _parse_cpu(output: str) -> dict:
+    """Parse CPU usage from top or /proc/stat output."""
+    cpu_info = {"usage_percent": 0.0, "cores": 1}
+
+    try:
+        # Try parsing top output
+        if "Cpu" in output:
+            # Format: %Cpu(s):  1.2 us,  0.3 sy,  0.0 ni, 98.5 id, ...
+            match = re.search(r"(\d+\.?\d*)\s*id", output)
+            if match:
+                idle = float(match.group(1))
+                cpu_info["usage_percent"] = round(100.0 - idle, 1)
+
+        # Get CPU cores
+        import os
+
+        cpu_info["cores"] = os.cpu_count() or 1
+
+    except Exception:
+        pass
+
+    return cpu_info
+
+
+def _parse_memory(output: str) -> dict:
+    """Parse memory usage from free -m output."""
+    mem_info = {"used_mb": 0, "total_mb": 0, "usage_percent": 0.0, "available_mb": 0}
+
+    try:
+        lines = output.strip().split("\n")
+        for line in lines:
+            if line.startswith("Mem:"):
+                parts = line.split()
+                if len(parts) >= 4:
+                    mem_info["total_mb"] = int(parts[1])
+                    mem_info["used_mb"] = int(parts[2])
+                    if len(parts) >= 7:
+                        mem_info["available_mb"] = int(parts[6])
+                    else:
+                        mem_info["available_mb"] = (
+                            mem_info["total_mb"] - mem_info["used_mb"]
+                        )
+
+                    if mem_info["total_mb"] > 0:
+                        mem_info["usage_percent"] = round(
+                            mem_info["used_mb"] / mem_info["total_mb"] * 100, 1
+                        )
+    except Exception:
+        pass
+
+    return mem_info
+
+
+def _parse_disk(output: str) -> dict:
+    """Parse disk usage from df -h output."""
+    disk_info = {
+        "used_gb": 0.0,
+        "total_gb": 0.0,
+        "usage_percent": 0.0,
+        "available_gb": 0.0,
+    }
+
+    try:
+        parts = output.split()
+        if len(parts) >= 5:
+            # Parse size with units (e.g., "50G", "1.2T")
+            def parse_size(s: str) -> float:
+                s = s.upper()
+                multipliers = {"K": 1 / 1024 / 1024, "M": 1 / 1024, "G": 1, "T": 1024}
+                for unit, mult in multipliers.items():
+                    if unit in s:
+                        return float(s.replace(unit, "")) * mult
+                return float(s)
+
+            disk_info["total_gb"] = round(parse_size(parts[1]), 1)
+            disk_info["used_gb"] = round(parse_size(parts[2]), 1)
+            disk_info["available_gb"] = round(parse_size(parts[3]), 1)
+            disk_info["usage_percent"] = float(parts[4].replace("%", ""))
+
+    except Exception:
+        pass
+
+    return disk_info
+
+
+def _parse_uptime(output: str) -> int:
+    """Parse uptime from /proc/uptime."""
+    try:
+        parts = output.strip().split()
+        if parts:
+            return int(float(parts[0]))
+    except Exception:
+        pass
+    return 0
+
+
+def _parse_load(output: str) -> dict:
+    """Parse load average from /proc/loadavg."""
+    load = {"1min": 0.0, "5min": 0.0, "15min": 0.0}
+
+    try:
+        parts = output.strip().split()
+        if len(parts) >= 3:
+            load["1min"] = float(parts[0])
+            load["5min"] = float(parts[1])
+            load["15min"] = float(parts[2])
+    except Exception:
+        pass
+
+    return load