# Update system
apt update && apt upgrade -y

# Install Python and pip
apt install -y python3 python3-pip python3-venv

# Install Docker (if your VPS supports it)
curl -fsSL https://get.docker.com | sh

mkdir -p ~/ai-vps-ops && cd ~/ai-vps-ops
python3 -m venv venv
source venv/bin/activate

# Install core dependencies
pip install crewai crewai-tools langchain-openai
pip install psutil requests pyyaml

# Use local Ollama model
export OPENAI_API_BASE=http://localhost:11434/v1
export OPENAI_MODEL_NAME=deepseek-v4:latest

export OPENAI_API_KEY=sk-your-api-key
export OPENAI_MODEL_NAME=gpt-4o

#!/usr/bin/env python3
"""
AI VPS Operations System
CrewAI + MCP based intelligent monitoring and self-healing
"""

import os
import json
import subprocess
from datetime import datetime

import psutil

from crewai import Agent, Task, Crew, Process
from crewai_tools import tool

# ── Tool: Get System Metrics ──────────────────────────────────
@tool("Get System Metrics")
def get_system_metrics():
    """Get critical server performance metrics: CPU, memory, disk, network"""
    cpu_percent = psutil.cpu_percent(interval=1)
    memory = psutil.virtual_memory()
    disk = psutil.disk_usage('/')
    net = psutil.net_io_counters()

    metrics = {
        "timestamp": datetime.now().isoformat(),
        "cpu": {
            "percent": cpu_percent,
            "cores": psutil.cpu_count(),
            "load_avg": psutil.getloadavg()
        },
        "memory": {
            "total_gb": round(memory.total / (1024**3), 2),
            "used_gb": round(memory.used / (1024**3), 2),
            "percent": memory.percent
        },
        "disk": {
            "total_gb": round(disk.total / (1024**3), 2),
            "used_gb": round(disk.used / (1024**3), 2),
            "percent": disk.percent
        },
        "network": {
            "bytes_sent_mb": round(net.bytes_sent / (1024**2), 2),
            "bytes_recv_mb": round(net.bytes_recv / (1024**2), 2)
        }
    }
    return json.dumps(metrics, indent=2)


# ── Tool: Get Process List ───────────────────────────────────
@tool("Get Top Processes")
def get_top_processes(n: int = 10):
    """Get top N processes by CPU/memory usage"""
    processes = []
    for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent']):
        try:
            processes.append(proc.info)
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            pass

    by_cpu = sorted(processes, key=lambda p: p.get('cpu_percent', 0) or 0, reverse=True)[:n]
    by_mem = sorted(processes, key=lambda p: p.get('memory_percent', 0) or 0, reverse=True)[:n]

    return json.dumps({
        "top_by_cpu": by_cpu,
        "top_by_memory": by_mem
    }, indent=2)


# ── Tool: Execute Shell Command ──────────────────────────────
@tool("Execute Shell Command")
def run_shell_command(command: str):
    """
    Execute a shell command and return output.
    Used for remediation operations: restart services, clean disk, free memory, etc.
    """
    try:
        result = subprocess.run(
            command, shell=True,
            capture_output=True, text=True,
            timeout=30
        )
        return {
            "stdout": result.stdout,
            "stderr": result.stderr,
            "return_code": result.returncode
        }
    except subprocess.TimeoutExpired:
        return {"error": "Command timed out after 30 seconds"}
    except Exception as e:
        return {"error": str(e)}


# ── Tool: Check Docker Status ───────────────────────────────
@tool("Check Docker Status")
def check_docker_status():
    """Check Docker container running status"""
    try:
        result = subprocess.run(
            "docker ps -a --format '{{.Names}}|{{.Status}}|{{.Image}}'",
            shell=True, capture_output=True, text=True, timeout=10
        )
        if result.returncode != 0:
            return {"error": "Docker not available", "detail": result.stderr}

        containers = []
        for line in result.stdout.strip().split('\n'):
            if not line:
                continue
            parts = line.split('|')
            containers.append({
                "name": parts[0],
                "status": parts[1],
                "image": parts[2]
            })

        running = [c for c in containers if 'Up' in c['status']]
        unhealthy = [c for c in containers if 'unhealthy' in c['status'] or 'restarting' in c['status']]

        return json.dumps({
            "total": len(containers),
            "running": len(running),
            "unhealthy": len(unhealthy),
            "containers": containers
        }, indent=2)
    except Exception as e:
        return {"error": str(e)}


# ── Tool: Clean System ──────────────────────────────────────
@tool("Clean System")
def clean_system(target: str = "all"):
    """
    Clean system resources.
    target options:
    - "docker": clean unused Docker resources
    - "apt": clean APT cache
    - "logs": clean old log files
    - "all": clean everything
    """
    results = {}

    if target in ("docker", "all"):
        r = subprocess.run(
            "docker system prune -af --volumes 2>&1 | tail -5",
            shell=True, capture_output=True, text=True, timeout=60
        )
        results["docker"] = r.stdout.strip()

    if target in ("apt", "all"):
        r = subprocess.run(
            "apt clean && apt autoremove -y 2>&1 | tail -3",
            shell=True, capture_output=True, text=True, timeout=120
        )
        results["apt"] = r.stdout.strip()

    if target in ("logs", "all"):
        r = subprocess.run(
            "find /var/log -name '*.log.*' -mtime +7 -delete 2>&1; "
            "journalctl --vacuum-time=3d 2>&1 | tail -3",
            shell=True, capture_output=True, text=True, timeout=60
        )
        results["logs"] = r.stdout.strip()

    return json.dumps(results, indent=2)


# ── Create Agents ────────────────────────────────────────────

monitor_agent = Agent(
    role="System Monitor",
    goal="Continuously monitor VPS system metrics and identify anomalies",
    backstory=(
        "You are the VPS's 24/7 monitoring expert. You collect CPU, memory, disk, "
        "network, and Docker container metrics, flagging anything outside normal ranges. "
        "Your reports feed into the diagnosis expert for root cause analysis."
    ),
    tools=[get_system_metrics, get_top_processes, check_docker_status],
    verbose=True,
    allow_delegation=False,
)

diagnosis_agent = Agent(
    role="Fault Diagnosis Expert",
    goal="Analyze monitoring data, identify root causes, and create remediation plans",
    backstory=(
        "You are a senior system diagnosis expert. You excel at finding the true cause "
        "of issues from system metrics and logs. Your reports must include: what the "
        "problem is, its severity, root cause analysis, and recommended fix steps."
    ),
    tools=[get_system_metrics, get_top_processes],
    verbose=True,
    allow_delegation=False,
)

remediation_agent = Agent(
    role="Automation Engineer",
    goal="Execute remediation operations, restore system health, and verify fixes",
    backstory=(
        "You are an efficient automation engineer. You execute the fix plans from the "
        "diagnosis expert — restarting services, cleaning disk, freeing memory, "
        "restarting containers. After each operation, you verify the result and try "
        "alternatives if something fails."
    ),
    tools=[run_shell_command, clean_system],
    verbose=True,
    allow_delegation=False,
)


# ── Create Tasks ──────────────────────────────────────────────

monitor_task = Task(
    description="""Perform a complete system health check:
1. CPU usage, load average
2. Memory usage
3. Disk usage
4. Network I/O
5. Docker container status
6. Top 10 processes by CPU and memory

Return a detailed metrics report with all anomalies flagged (CPU > 80%, memory > 85%, etc.).""",
    expected_output="A JSON-formatted system metrics report with all values and anomaly flags",
    agent=monitor_agent,
)

diagnosis_task = Task(
    description="""Analyze anomalous metrics from the monitoring report:
1. Perform root cause analysis for each anomaly
2. Assess severity (critical/warning/info)
3. Create step-by-step remediation plan
4. If Docker containers are unhealthy, analyze why

Output a diagnosis report with the remediation plan.""",
    expected_output="Diagnosis report with root cause analysis, severity assessment, and step-by-step fix plan",
    agent=diagnosis_agent,
)

remediation_task = Task(
    description="""Execute the remediation plan from the diagnosis report:
1. Execute fix commands step by step
2. Verify results after each step
3. If successful, log the operation
4. If failed, try alternative approaches
5. After all fixes, re-run health check to verify

Output a complete remediation report.""",
    expected_output="Remediation execution report with all operations performed, results, and final system state",
    agent=remediation_agent,
)


# ── Create Crew ───────────────────────────────────────────────

ops_crew = Crew(
    agents=[monitor_agent, diagnosis_agent, remediation_agent],
    tasks=[monitor_task, diagnosis_task, remediation_task],
    process=Process.sequential,
    verbose=True,
)


# ── Main ──────────────────────────────────────────────────────

if __name__ == "__main__":
    print("=" * 60)
    print("🤖 AI VPS Operations System Starting")
    print(f"📅 {datetime.now().isoformat()}")
    print("=" * 60)

    result = ops_crew.kickoff()

    print("\n" + "=" * 60)
    print("✅ Operations Task Complete")
    print("=" * 60)
    print(result)

cd ~/ai-vps-ops
source venv/bin/activate
python ai_vps_ops.py

# Edit crontab
crontab -e

@tool("Send Notification")
def send_notification(message: str):
    """Send alert notification via Telegram Bot"""
    bot_token = os.environ.get("TELEGRAM_BOT_TOKEN")
    chat_id = os.environ.get("TELEGRAM_CHAT_ID")
    if not bot_token or not chat_id:
        return "Notification not configured"
    
    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
    data = {"chat_id": chat_id, "text": message, "parse_mode": "Markdown"}
    requests.post(url, json=data)
    return "Notification sent"

# Install msmtp
apt install -y msmtp msmtp-mta

# Configure ~/.msmtprc
cat > ~/.msmtprc << 'EOF'
defaults
auth           on
tls            on
tls_trust_file /etc/ssl/certs/ca-certificates.crt

account        default
host           smtp.gmail.com
port           587
from           your-email@gmail.com
user           your-email@gmail.com
password       your-app-password
EOF
chmod 600 ~/.msmtprc

@tool("Send Webhook")
def send_webhook(payload: dict):
    """Send webhook to external system"""
    webhook_url = os.environ.get("WEBHOOK_URL")
    if not webhook_url:
        return "Webhook not configured"
    requests.post(webhook_url, json=payload)
    return "Webhook sent"

@tool("Check SSL Certificate")
def check_ssl_certificate(domain: str):
    """Check SSL certificate expiry"""
    import ssl, socket
    ctx = ssl.create_default_context()
    with ctx.wrap_socket(socket.socket(), server_hostname=domain) as s:
        s.connect((domain, 443))
        cert = s.getpeercert()
        expiry = cert['notAfter']
        days_left = (datetime.strptime(expiry, '%b %d %H:%M:%S %Y %Z') - datetime.now()).days
        return f"{domain} certificate expires in {days_left} days"

@tool("Analyze Auth Logs")
def analyze_auth_logs():
    """Analyze authentication logs for unusual login attempts"""
    import re
    result = subprocess.run(
        "grep 'Failed password' /var/log/auth.log | tail -100",
        shell=True, capture_output=True, text=True, timeout=10
    )
    failed_attempts = len(result.stdout.strip().split('\n'))
    
    if failed_attempts > 50:
        return f"⚠️ Detected {failed_attempts} failed login attempts — possible brute force attack"
    return f"{failed_attempts} failed login attempts, within normal range"

@tool("Resource Trend Analysis")
def resource_trend_analysis():
    """Analyze resource usage trends and suggest optimizations"""
    # Collect average CPU usage over the past 24 hours
    # If consistently below 20%, suggest downgrading to save cost
    # If consistently above 80%, suggest upgrading to avoid performance issues
    ...

@tool("Check Backup Status")
def check_backup_status():
    """Check recent backup status and integrity"""
    # Verify backup file existence and size
    # Confirm backup timing is within expected range
    # Trigger backup if anomalies found
    ...

SAFE_COMMANDS = [
    "systemctl", "docker", "journalctl", "df", "free",
    "ps", "top", "kill", "rm", "apt", "find", "du"
]

def validate_command(command: str) -> bool:
    cmd_base = command.strip().split()[0]
    return cmd_base in SAFE_COMMANDS