# copilot/intent_parser.py
from pydantic import BaseModel, Field
from typing import Literal, Optional

class CommandIntent(BaseModel):
    """Command intent definition"""
    action: Literal[
        "diagnose", "monitor", "manage", "debug", "optimize", "security"
    ] = Field(..., description="Operation type")
    target: str = Field(..., description="Target, e.g. 'nginx', 'docker', 'system'")
    command: str = Field(..., description="Generated specific command")
    explanation: str = Field(..., description="Command explanation")
    risk_level: Literal["low", "medium", "high"] = Field(
        ..., description="Risk level"
    )
    requires_approval: bool = Field(
        False, description="Requires human approval"
    )

    def validate_safety(self) -> bool:
        """Safety validation: reject high-risk dangerous operations"""
        dangerous_patterns = [
            r"rm\s+/-rf\s*/", r">\s*/dev/sda", r"dd\s+if=.*of=/dev/"
        ]
        import re
        for pattern in dangerous_patterns:
            if re.search(pattern, self.command):
                return False
        return True

# Dockerfile.sandbox
FROM ubuntu:22.04

# Install common operations tools
RUN apt-get update && apt-get install -y \
    procps net-tools iproute2 curl wget \
    htop iotop nload lm-sensors \
    docker.io nginx mysql-client postgresql-client \
    && rm -rf /var/lib/apt/lists/*

# Resource limits applied at runtime
CMD ["/bin/bash"]

# copilot/sandbox.py
import docker
import json
from datetime import timedelta

class CommandSandbox:
    def __init__(self):
        self.client = docker.from_env()
        self.container = None

    def execute(self, command: str, timeout: int = 30) -> dict:
        """Execute command in sandbox, return structured result"""
        self.container = self.client.containers.run(
            "vps-copilot-sandbox:latest",
            command,
            detach=True,
            network_mode="none",      # Disable network, prevent outbound commands
            mem_limit="512m",
            cpu_period=100000,
            cpu_quota=200000,        # Limit to 0.2 CPU
            read_only=True,
            tmpfs={"/tmp": "rw,nosuid,noexec,size=64m"},
            security_opt=["no-new-privileges:true"],
            user="nobody",
        )

        try:
            result = self.container.wait(timeout=timeout)
            logs = self.container.logs().decode("utf-8", errors="replace")
            exit_code = result.get("StatusCode", -1)

            return {
                "exit_code": exit_code,
                "stdout": logs,
                "success": exit_code == 0,
                "sandbox_id": self.container.id[:12],
            }
        finally:
            self.container.remove(force=True)

# copilot/context_manager.py
from langchain_community.vectorstores import Chroma
from langchain_community.embeddings import OllamaEmbeddings
import json

class VPSContextManager:
    def __init__(self, llm_model: str = "deepseek-r1:8b"):
        self.embeddings = OllamaEmbeddings(model=llm_model)
        self.vectorstore = Chroma(
            persist_directory="./data/vps_knowledge",
            embedding_function=self.embeddings,
        )
        self.session_history = []
        self.system_state = self._collect_system_state()

    def _collect_system_state(self) -> dict:
        """Collect current VPS system state as context"""
        state = {
            "os": self._run_simple("cat /etc/os-release | grep PRETTY_NAME"),
            "cpu": self._run_simple("nproc"),
            "memory_total_gb": self._run_simple(
                "free -g | awk '/^Mem:/{print $2}'"
            ),
            "disk_total_gb": self._run_simple(
                "df -BG / | awk 'NR==2{print $2}' | tr -d 'G'"
            ),
            "running_services": self._run_simple(
                "systemctl list-units --type=service --state=running "
                "| awk 'NR>2{print $1}' | sed 's/.service//'"
            ),
            "uptime": self._run_simple("uptime -p"),
        }
        return state

    def add_to_context(self, message: str, role: str = "user"):
        """Add conversation history to context"""
        self.session_history.append({
            "role": role,
            "content": message,
            "timestamp": __import__("datetime").datetime.now().isoformat(),
        })
        # Keep last 20 turns of conversation
        if len(self.session_history) > 20:
            self.session_history = self.session_history[-20:]

    def get_system_prompt(self) -> str:
        """Build complete prompt with system state"""
        state_desc = json.dumps(self.system_state, ensure_ascii=False, indent=2)
        history_desc = json.dumps(
            self.session_history[-10:], ensure_ascii=False, indent=2
        )

        return f"""You are a professional VPS operations AI assistant.

【Current System State】
{state_desc}

【Recent Conversation History】
{history_desc}

Please provide accurate, safe operations recommendations based on system state and history.
For operations that may affect production, always mark the risk level and request confirmation."""

# copilot/diagnostician.py
class VPSDiagnostician:
    """Intelligent diagnostic engine"""

    DIAGNOSTIC_CHECKS = {
        "cpu": {
            "command": "top -bn1 | head -20",
            "alert_threshold": {"load_avg_1min": 8.0, "cpu_usage": 90},
        },
        "memory": {
            "command": "free -h && vmstat -s",
            "alert_threshold": {"memory_usage": 85, "swap_usage": 70},
        },
        "disk": {
            "command": "df -h && du -sh /var/log/* 2>/dev/null | sort -hr | head -10",
            "alert_threshold": {"disk_usage": 90},
        },
        "network": {
            "command": "ss -tuln | head -30 && curl -s --max-time 5 https://www.baidu.com > /dev/null && echo 'Network OK'",
            "alert_threshold": {"connection_count": 1000},
        },
        "process": {
            "command": "ps aux --sort=-%mem | head -15",
            "alert_threshold": {"max_procs": 500},
        },
    }

    def diagnose(self, scope: str = "all") -> dict:
        """Run diagnostics and return structured results"""
        results = {}
        if scope == "all":
            checks = self.DIAGNOSTIC_CHECKS
        else:
            checks = {scope: self.DIAGNOSTIC_CHECKS[scope]}

        for check_name, config in checks.items():
            output = self._execute_command(config["command"])
            alerts = self._analyze_output(check_name, output, config["alert_threshold"])
            results[check_name] = {
                "output": output[:2000],  # Truncate long output
                "alerts": alerts,
                "status": "healthy" if not alerts else "warning",
            }

        return results

# docker-compose.yml
version: "3.8"

services:
  copilot-api:
    build: .
    container_name: vps-copilot-api
    ports:
      - "8080:8080"
    environment:
      - LLM_PROVIDER=ollama
      - OLLAMA_HOST=http://ollama:11434
      - LLM_MODEL=deepseek-r1:8b
      - AUTH_SECRET=${AUTH_SECRET}
      - ENABLE_DANGER_APPROVAL=true
    volumes:
      - ./data:/app/data
      - /var/run/docker.sock:/var/run/docker.sock:ro  # Read-only access
    networks:
      - copilot-net
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true

  ollama:
    image: ollama/ollama:latest
    container_name: vps-copilot-ollama
    ports:
      - "11434:11434"
    volumes:
      - ./ollama-data:/root/.ollama
    networks:
      - copilot-net
    restart: unless-stopped

  chroma:
    image: chromadb/chroma:latest
    container_name: vps-copilot-chroma
    volumes:
      - ./chroma-data:/chroma/chroma
    networks:
      - copilot-net
    restart: unless-stopped

networks:
  copilot-net:
    driver: bridge

# api/routes.py
from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel

app = FastAPI(title="VPS Copilot API", version="1.0.0")

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_methods=["*"],
    allow_headers=["*"],
)

class ChatRequest(BaseModel):
    message: str
    session_id: str = ""
    stream: bool = True

class ChatResponse(BaseModel):
    response: str
    commands_executed: list[dict] = []
    diagnostics: dict = {}

@app.post("/api/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
    """Process natural language instructions"""
    copilot = get_copilot_instance(request.session_id)
    response = await copilot.process_message(request.message)

    # Security audit
    audit_log = await security_auditor.log(
        session_id=request.session_id,
        message=request.message,
        commands=response.commands_executed,
    )

    return ChatResponse(
        response=response.text,
        commands_executed=response.commands_executed,
        diagnostics=response.diagnostics,
    )

@app.websocket("/ws/terminal")
async def terminal_websocket(websocket: WebSocket):
    """Real-time terminal WebSocket"""
    await websocket.accept()
    try:
        while True:
            data = await websocket.receive_text()
            response = await process_terminal_input(data, websocket)
            await websocket.send_text(response)
    except WebSocketDisconnect:
        print("Client disconnected")

// config/rbac.json
{
  "roles": {
    "admin": {
      "permissions": ["read", "write", "execute", "approve", "manage"],
      "dangerous_commands": false,
      "max_concurrent_sessions": 10
    },
    "operator": {
      "permissions": ["read", "execute"],
      "dangerous_commands": true,
      "requires_approval_for": ["systemctl restart", "iptables"],
      "max_concurrent_sessions": 3
    },
    "viewer": {
      "permissions": ["read"],
      "dangerous_commands": false,
      "max_concurrent_sessions": 1
    }
  }
}

# copilot/security.py
import json
import logging
from datetime import datetime
from pathlib import Path

AUDIT_LOG = Path("/var/log/vps-copilot/audit.log")

class SecurityAuditor:
    def __init__(self):
        AUDIT_LOG.parent.mkdir(parents=True, exist_ok=True)
        self.logger = logging.getLogger("copilot.audit")

    async def log(self, session_id: str, message: str,
                  commands: list[dict], user: str = "anonymous") -> dict:
        """Log operation audit trail"""
        entry = {
            "timestamp": datetime.now().isoformat(),
            "session_id": session_id,
            "user": user,
            "natural_language": message,
            "commands_executed": commands,
            "risk_assessment": self._assess_risk(commands),
            "audit_id": self._generate_audit_id(),
        }

        with open(AUDIT_LOG, "a") as f:
            f.write(json.dumps(entry, ensure_ascii=False) + "\n")

        return entry

    def _assess_risk(self, commands: list[dict]) -> str:
        """Assess operation risk level"""
        risk_score = 0
        for cmd in commands:
            if "rm -rf" in cmd.get("command", ""):
                risk_score += 10
            if "iptables" in cmd.get("command", ""):
                risk_score += 5
            if "systemctl" in cmd.get("command", ""):
                risk_score += 3

        if risk_score >= 10:
            return "critical"
        elif risk_score >= 5:
            return "high"
        return "low"