core/terminal.py

"""
Terminal – Cross-OS shell execution with retries and timeouts.

This module is a low-level primitive. It:
- Connects to remote targets via SSH (Linux) or WinRM (Windows), or
  falls back to local subprocess execution if no remote target is used.
- Executes commands with retries and timeouts.
- Returns a normalized result dict: {stdout, stderr, exit_code, status}.

IMPORTANT:
- Do NOT pass raw LLM text directly into `execute` unless you explicitly
  intend to (e.g., via an unsafe "terminal_raw" path in the orchestrator).
- For local execution, `allow_shell` controls whether `shell=True` is used.
"""

import logging
import subprocess
import time
from typing import Any, Dict, Optional

import paramiko
import winrm

logger = logging.getLogger(__name__)


class TerminalAdapter:
    def __init__(
        self,
        target: Dict[str, Any],
        retries: int = 3,
        connect_timeout: int = 10,
        allow_shell: bool = True,
    ) -> None:
        """
        :param target: dict with keys like:
                       - "ip": str
                       - "os": "linux" | "windows" | "local" | ...
                       - "creds": {"user": "...", "pass": "..."}
                       - "port": int (for SSH)
        :param retries: how many times to retry connecting.
        :param connect_timeout: timeout (seconds) for connection attempts.
        :param allow_shell: if False, local subprocess will *not* use shell=True.
                            (Remote SSH/WinRM still receive the command string.)
        """
        self.target = target or {}
        self.retries = retries
        self.connect_timeout = connect_timeout
        self.allow_shell = allow_shell

        # Connection object: SSHClient, winrm.Session, or None for local
        self.conn: Optional[Any] = self._connect_with_retry()

    # -------------------------------------------------------------------------
    # Connection handling
    # -------------------------------------------------------------------------

    def _connect_with_retry(self) -> Optional[Any]:
        """
        Attempt to establish a connection (SSH/WinRM). Falls back to None for local.
        """
        for attempt in range(self.retries):
            try:
                conn = self._connect()
                if conn is not None:
                    return conn
                # If _connect() returns None, we treat it as local mode
                return None
            except Exception as e:
                logger.warning(
                    f"TerminalAdapter: connection attempt {attempt + 1} failed: {e}"
                )
                time.sleep(2 * (attempt + 1))

        # If all attempts fail, raise; orchestrator should handle.
        raise ConnectionError(f"Failed to connect after {self.retries} attempts")

    def _connect(self) -> Optional[Any]:
        """
        Set up SSH (Linux) or WinRM (Windows) based on target; return connection object.

        If the target is explicitly local (os == 'local') or has no IP, return None.
        """
        os_type = self.target.get("os", "linux").lower()
        ip = self.target.get("ip")
        creds = self.target.get("creds", {})
        port = int(self.target.get("port", 22))

        # Local mode if no IP or explicit "local"
        if not ip or os_type == "local":
            logger.debug("TerminalAdapter: running in local mode (no remote IP)")
            return None

        if os_type.startswith("linux"):
            logger.debug(f"TerminalAdapter: setting up SSH client to {ip}:{port}")
            client = paramiko.SSHClient()
            client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
            client.connect(
                ip,
                port=port,
                username=creds.get("user"),
                password=creds.get("pass"),
                timeout=self.connect_timeout,
            )
            return client

        if os_type.startswith("win"):
            logger.debug(f"TerminalAdapter: setting up WinRM session to {ip}")
            # HTTPS 5986 with NTLM; adjust as needed for your environment
            session = winrm.Session(
                f"https://{ip}:5986",
                auth=(creds.get("user"), creds.get("pass")),
                transport="ntlm",
            )
            # Simple test command
            session.run_cmd("echo test")
            return session

        # Unknown OS -> treat as local
        logger.debug(f"TerminalAdapter: unknown OS '{os_type}', using local mode")
        return None

    # -------------------------------------------------------------------------
    # Command execution
    # -------------------------------------------------------------------------

    def execute(self, command: str, timeout: int = 60) -> Dict[str, Any]:
        """
        Execute a command on the target (SSH/WinRM/local).

        :param command: command string to execute remotely or locally.
        :param timeout: per-command timeout in seconds.
        :return: dict with keys:
                 - "stdout": str
                 - "stderr": str
                 - "exit_code": int
                 - "status": "success" | "error"
        """
        # SSH
        if isinstance(self.conn, paramiko.SSHClient):
            return self._execute_ssh(command, timeout)

        # WinRM
        if isinstance(self.conn, winrm.Session):
            return self._execute_winrm(command, timeout)

        # Local subprocess
        return self._execute_local(command, timeout)

    def _execute_ssh(self, command: str, timeout: int) -> Dict[str, Any]:
        logger.debug(f"TerminalAdapter[SSH] executing: {command}")
        try:
            stdin, stdout, stderr = self.conn.exec_command(
                command,
                timeout=timeout,
            )
            exit_code = stdout.channel.recv_exit_status()
            out = stdout.read().decode(errors="ignore")
            err = stderr.read().decode(errors="ignore")
            status = "success" if exit_code == 0 else "error"
            return {
                "stdout": out,
                "stderr": err,
                "exit_code": exit_code,
                "status": status,
            }
        except Exception as e:
            logger.error(f"TerminalAdapter[SSH] execution error: {e}")
            return {
                "stdout": "",
                "stderr": str(e),
                "exit_code": -1,
                "status": "error",
            }

    def _execute_winrm(self, command: str, timeout: int) -> Dict[str, Any]:
        logger.debug(f"TerminalAdapter[WinRM] executing: {command}")
        try:
            result = self.conn.run_cmd(
                command,
                timeout_sec=timeout,
            )
            out = result.std_out.decode("utf-8", errors="ignore")
            err = result.std_err.decode("utf-8", errors="ignore")
            exit_code = result.status_code
            status = "success" if exit_code == 0 else "error"
            return {
                "stdout": out,
                "stderr": err,
                "exit_code": exit_code,
                "status": status,
            }
        except Exception as e:
            logger.error(f"TerminalAdapter[WinRM] execution error: {e}")
            return {
                "stdout": "",
                "stderr": str(e),
                "exit_code": -1,
                "status": "error",
            }

    def _execute_local(self, command: str, timeout: int) -> Dict[str, Any]:
        """
        Execute a command locally. By default uses shell=True for backward
        compatibility and flexibility, but this is controlled by allow_shell.

        Note: This method does NOT know anything about the LLM. The orchestrator
        should decide whether it is acceptable to pass LLM-originated strings
        into this function.
        """
        logger.debug(
            f"TerminalAdapter[local] executing: {command} (shell={self.allow_shell})"
        )
        try:
            if self.allow_shell:
                proc = subprocess.run(
                    command,
                    shell=True,
                    capture_output=True,
                    text=True,
                    timeout=timeout,
                )
            else:
                # If allow_shell is False, we try to split into args minimally.
                # For complex commands, you should supply a pre-tokenized list
                # and extend this method to accept List[str].
                proc = subprocess.run(
                    command.split(),
                    shell=False,
                    capture_output=True,
                    text=True,
                    timeout=timeout,
                )

            out = proc.stdout
            err = proc.stderr
            exit_code = proc.returncode
            status = "success" if exit_code == 0 else "error"
            return {
                "stdout": out,
                "stderr": err,
                "exit_code": exit_code,
                "status": status,
            }
        except subprocess.TimeoutExpired:
            logger.warning("TerminalAdapter[local] command timed out")
            return {
                "stdout": "",
                "stderr": "Timeout",
                "exit_code": -1,
                "status": "error",
            }
        except Exception as e:
            logger.error(f"TerminalAdapter[local] execution error: {e}")
            return {
                "stdout": "",
                "stderr": str(e),
                "exit_code": -1,
                "status": "error",
            }