machineconfig 1.95__py3-none-any.whl → 1.97__py3-none-any.whl

machineconfig/cluster/sessions_managers/wt_utils/process_monitor.py

@@ -0,0 +1,418 @@
+#!/usr/bin/env python3
+"""
+Process monitoring and status checking utilities for Windows Terminal commands.
+Adapted from zellij process monitor but focused on Windows processes.
+"""
+import json
+import logging
+import subprocess
+from typing import Dict, Tuple, Any, Optional
+from .remote_executor import WTRemoteExecutor
+
+logger = logging.getLogger(__name__)
+
+
+class WTProcessMonitor:
+    """Handles process status checking and verification on local and remote Windows machines."""
+    
+    def __init__(self, remote_executor: Optional[WTRemoteExecutor] = None):
+        self.remote_executor = remote_executor
+        self.is_local = remote_executor is None
+    
+    @property
+    def location_name(self) -> str:
+        """Get the location name for status reporting."""
+        return "local" if self.is_local else (self.remote_executor.remote_name if self.remote_executor else "unknown")
+    
+    def _run_command(self, command: str, timeout: int = 30) -> subprocess.CompletedProcess[str]:
+        """Run command either locally or remotely."""
+        if self.is_local:
+            return subprocess.run(
+                ["powershell", "-Command", command],
+                capture_output=True,
+                text=True,
+                timeout=timeout
+            )
+        else:
+            if self.remote_executor is None:
+                raise ValueError("Remote executor is None but is_local is False")
+            return self.remote_executor.run_command(command, timeout)
+    
+    def check_command_status(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]], 
+                           use_verification: bool = True) -> Dict[str, Any]:
+        """Check command status with optional process verification."""
+        if tab_name not in tab_config:
+            return {
+                "status": "unknown",
+                "error": f"Tab '{tab_name}' not found in tracked configuration",
+                "running": False,
+                "pid": None,
+                "command": None,
+                "location": self.location_name
+            }
+        
+        # Use the verified method by default for more accurate results
+        if use_verification:
+            return self.get_verified_process_status(tab_name, tab_config)
+        
+        return self._basic_process_check(tab_name, tab_config)
+    
+    def _basic_process_check(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+        """Basic process checking without verification."""
+        _, command = tab_config[tab_name]
+        
+        try:
+            check_script = self._create_process_check_script(command)
+            result = self._run_command(check_script, timeout=15)
+            
+            if result.returncode == 0:
+                try:
+                    # Parse PowerShell output (JSON format)
+                    output_lines = [line.strip() for line in result.stdout.strip().split('\n') if line.strip()]
+                    matching_processes = []
+                    
+                    for line in output_lines:
+                        if line.startswith('{') and line.endswith('}'):
+                            try:
+                                proc_info = json.loads(line)
+                                matching_processes.append(proc_info)
+                            except json.JSONDecodeError:
+                                continue
+                    
+                    if matching_processes:
+                        return {
+                            "status": "running",
+                            "running": True,
+                            "processes": matching_processes,
+                            "command": command,
+                            "tab_name": tab_name,
+                            "location": self.location_name
+                        }
+                    else:
+                        return {
+                            "status": "not_running",
+                            "running": False,
+                            "processes": [],
+                            "command": command,
+                            "tab_name": tab_name,
+                            "location": self.location_name
+                        }
+                except Exception as e:
+                    logger.error(f"Failed to parse process check output: {e}")
+                    return {
+                        "status": "error",
+                        "error": f"Failed to parse output: {e}",
+                        "running": False,
+                        "command": command,
+                        "tab_name": tab_name,
+                        "location": self.location_name
+                    }
+            else:
+                return {
+                    "status": "error", 
+                    "error": f"Command failed: {result.stderr}",
+                    "running": False,
+                    "command": command,
+                    "tab_name": tab_name,
+                    "location": self.location_name
+                }
+                
+        except Exception as e:
+            logger.error(f"Error checking command status for tab '{tab_name}': {e}")
+            return {
+                "status": "error",
+                "error": str(e),
+                "running": False,
+                "command": command,
+                "tab_name": tab_name,
+                "location": self.location_name
+            }
+    
+    def _create_process_check_script(self, command: str) -> str:
+        """Create PowerShell script for checking processes."""
+        # Escape command for PowerShell
+        escaped_command = command.replace("'", "''").replace('"', '""')
+        cmd_parts = [part for part in command.split() if len(part) > 2]
+        primary_cmd = cmd_parts[0] if cmd_parts else ''
+        
+        return f"""
+$targetCommand = '{escaped_command}'
+$cmdParts = @({', '.join([f"'{part}'" for part in cmd_parts])})
+$primaryCmd = '{primary_cmd}'
+$currentPid = $PID
+
+Get-Process | ForEach-Object {{
+    try {{
+        if ($_.Id -eq $currentPid) {{ return }}
+        
+        $cmdline = ""
+        try {{
+            $cmdline = (Get-WmiObject Win32_Process -Filter "ProcessId = $($_.Id)").CommandLine
+        }} catch {{
+            $cmdline = $_.ProcessName
+        }}
+        
+        if ($cmdline -and $cmdline -ne "") {{
+            if ($cmdline -like "*PowerShell*" -and $cmdline -like "*Get-Process*") {{ return }}
+            
+            $matchesPrimary = $cmdline -like "*$primaryCmd*" -and $primaryCmd -ne "powershell"
+            $matchCount = 0
+            foreach ($part in $cmdParts[1..($cmdParts.Length-1)]) {{
+                if ($cmdline -like "*$part*") {{ $matchCount++ }}
+            }}
+            
+            if ($matchesPrimary -and $matchCount -ge 2) {{
+                $procInfo = @{{
+                    "pid" = $_.Id
+                    "name" = $_.ProcessName
+                    "cmdline" = $cmdline
+                    "status" = $_.Status
+                    "start_time" = $_.StartTime
+                    "cpu_time" = $_.CPU
+                }} | ConvertTo-Json -Compress
+                Write-Output $procInfo
+            }}
+        }}
+    }} catch {{
+        # Ignore processes we can't access
+    }}
+}}
+"""
+    
+    def force_fresh_process_check(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+        """Force a fresh process check with additional validation."""
+        if tab_name not in tab_config:
+            return {
+                "status": "unknown",
+                "error": f"Tab '{tab_name}' not found in tracked configuration",
+                "running": False,
+                "command": None,
+                "location": self.location_name
+            }
+        
+        _, command = tab_config[tab_name]
+        
+        try:
+            # Get timestamp for freshness validation
+            timestamp_cmd = "Get-Date -UFormat %s"
+            timestamp_result = self._run_command(timestamp_cmd, timeout=5)
+            check_timestamp = timestamp_result.stdout.strip() if timestamp_result.returncode == 0 else "unknown"
+            
+            check_script = self._create_fresh_check_script(command)
+            result = self._run_command(check_script, timeout=15)
+            
+            if result.returncode == 0:
+                try:
+                    # Parse the output to extract JSON
+                    output_lines = [line.strip() for line in result.stdout.strip().split('\n') if line.strip()]
+                    for line in output_lines:
+                        if line.startswith('{') and '"processes"' in line:
+                            check_result = json.loads(line)
+                            matching_processes = check_result.get("processes", [])
+                            
+                            return {
+                                "status": "running" if matching_processes else "not_running",
+                                "running": bool(matching_processes),
+                                "processes": matching_processes,
+                                "command": command,
+                                "tab_name": tab_name,
+                                "location": self.location_name,
+                                "check_timestamp": check_timestamp,
+                                "method": "force_fresh_check"
+                            }
+                    
+                    # Fallback if no JSON found
+                    return {
+                        "status": "not_running",
+                        "running": False,
+                        "processes": [],
+                        "command": command,
+                        "tab_name": tab_name,
+                        "location": self.location_name,
+                        "raw_output": result.stdout
+                    }
+                except json.JSONDecodeError as e:
+                    logger.error(f"Failed to parse fresh check output: {e}")
+                    return {
+                        "status": "error",
+                        "error": f"Failed to parse output: {e}",
+                        "running": False,
+                        "command": command,
+                        "tab_name": tab_name,
+                        "location": self.location_name,
+                        "raw_output": result.stdout
+                    }
+            else:
+                return {
+                    "status": "error", 
+                    "error": f"Command failed: {result.stderr}",
+                    "running": False,
+                    "command": command,
+                    "tab_name": tab_name,
+                    "location": self.location_name
+                }
+                
+        except Exception as e:
+            logger.error(f"Error in fresh process check for tab '{tab_name}': {e}")
+            return {
+                "status": "error",
+                "error": str(e),
+                "running": False,
+                "command": command,
+                "tab_name": tab_name,
+                "location": self.location_name
+            }
+    
+    def _create_fresh_check_script(self, command: str) -> str:
+        """Create enhanced PowerShell process checking script with freshness validation."""
+        escaped_command = command.replace("'", "''").replace('"', '""')
+        cmd_parts = [part for part in command.split() if len(part) > 2]
+        primary_cmd = cmd_parts[0] if cmd_parts else ''
+        
+        return f"""
+Start-Sleep -Milliseconds 100
+
+$targetCommand = '{escaped_command}'
+$cmdParts = @({', '.join([f"'{part}'" for part in cmd_parts])})
+$primaryCmd = '{primary_cmd}'
+$currentPid = $PID
+$checkTime = Get-Date
+$matchingProcesses = @()
+
+Get-Process | ForEach-Object {{
+    try {{
+        if ($_.Id -eq $currentPid) {{ return }}
+        
+        $cmdline = ""
+        try {{
+            $cmdline = (Get-WmiObject Win32_Process -Filter "ProcessId = $($_.Id)").CommandLine
+        }} catch {{
+            $cmdline = $_.ProcessName
+        }}
+        
+        if ($cmdline -and $cmdline -ne "") {{
+            # Skip our own checking processes
+            if ($cmdline -like "*Get-Process*" -or $cmdline -like "*force_fresh_check*") {{ return }}
+            
+            # Skip processes that started very recently (likely our own scripts)
+            if ($_.StartTime -and ($checkTime - $_.StartTime).TotalSeconds -lt 5) {{ return }}
+            
+            $matchesPrimary = $cmdline -like "*$primaryCmd*" -and $primaryCmd -ne "powershell"
+            $matchCount = 0
+            foreach ($part in $cmdParts[1..($cmdParts.Length-1)]) {{
+                if ($cmdline -like "*$part*") {{ $matchCount++ }}
+            }}
+            
+            if ($matchesPrimary -and $matchCount -ge 2) {{
+                $isDirectCommand = -not ($cmdline -like "*-Command*" -or $cmdline -like "*Get-Process*")
+                
+                if ($isDirectCommand -or ($targetCommand -in $cmdline -and $cmdline -notlike "*powershell -Command*")) {{
+                    $procInfo = @{{
+                        "pid" = $_.Id
+                        "name" = $_.ProcessName
+                        "cmdline" = $cmdline
+                        "status" = $_.Status
+                        "start_time" = $_.StartTime
+                        "cpu_time" = $_.CPU
+                        "is_direct_command" = $isDirectCommand
+                    }}
+                    $matchingProcesses += $procInfo
+                }}
+            }}
+        }}
+    }} catch {{
+        # Ignore processes we can't access
+    }}
+}}
+
+$result = @{{
+    "processes" = $matchingProcesses
+    "check_timestamp" = $checkTime
+    "search_command" = $targetCommand
+    "search_parts" = $cmdParts
+}} | ConvertTo-Json -Depth 3 -Compress
+
+Write-Output $result
+"""
+    
+    def verify_process_alive(self, pid: int) -> bool:
+        """Verify if a process with given PID is actually alive."""
+        try:
+            verify_cmd = f"Get-Process -Id {pid} -ErrorAction SilentlyContinue | Select-Object -First 1"
+            result = self._run_command(verify_cmd, timeout=5)
+            
+            return result.returncode == 0 and result.stdout.strip() != ""
+        except Exception:
+            return False
+    
+    def get_verified_process_status(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+        """Get process status with additional verification that processes are actually alive."""
+        status = self.force_fresh_process_check(tab_name, tab_config)
+        
+        if status.get("running") and status.get("processes"):
+            verified_processes = []
+            for proc in status["processes"]:
+                pid = proc.get("pid")
+                if pid and self.verify_process_alive(pid):
+                    proc["verified_alive"] = True
+                    verified_processes.append(proc)
+                else:
+                    proc["verified_alive"] = False
+                    logger.warning(f"Process PID {pid} found in process list but not actually alive")
+            
+            status["processes"] = verified_processes
+            status["running"] = bool(verified_processes)
+            status["status"] = "running" if verified_processes else "not_running"
+            status["verification_method"] = "get_process_check"
+        
+        return status
+    
+    def check_all_commands_status(self, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Dict[str, Any]]:
+        """Check status of all commands in the tab configuration."""
+        if not tab_config:
+            logger.warning("No tab configuration provided.")
+            return {}
+        
+        status_report = {}
+        for tab_name in tab_config:
+            status_report[tab_name] = self.check_command_status(tab_name, tab_config)
+        return status_report
+    
+    def get_windows_terminal_windows(self) -> Dict[str, Any]:
+        """Get information about currently running Windows Terminal windows."""
+        try:
+            wt_info_cmd = """
+Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue | 
+Select-Object Id, ProcessName, StartTime, @{Name="WindowTitle";Expression={(Get-Process -Id $_.Id).MainWindowTitle}} |
+ConvertTo-Json -Depth 2
+"""
+            result = self._run_command(wt_info_cmd, timeout=15)
+            
+            if result.returncode == 0 and result.stdout.strip():
+                try:
+                    wt_processes = json.loads(result.stdout)
+                    return {
+                        "success": True,
+                        "windows": wt_processes if isinstance(wt_processes, list) else [wt_processes],
+                        "location": self.location_name
+                    }
+                except json.JSONDecodeError:
+                    return {
+                        "success": False,
+                        "error": "Failed to parse Windows Terminal process info",
+                        "location": self.location_name
+                    }
+            else:
+                return {
+                    "success": True,
+                    "windows": [],
+                    "message": "No Windows Terminal processes found",
+                    "location": self.location_name
+                }
+        except Exception as e:
+            logger.error(f"Failed to get Windows Terminal windows: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "location": self.location_name
+            } 

machineconfig/cluster/sessions_managers/wt_utils/remote_executor.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+"""
+Remote command execution utilities for SSH operations with Windows Terminal.
+Adapted from zellij remote executor but focused on Windows Terminal commands.
+"""
+import subprocess
+import logging
+from typing import Dict, Any, Optional, List
+
+logger = logging.getLogger(__name__)
+
+
+class WTRemoteExecutor:
+    """Handles SSH command execution on remote Windows machines with Windows Terminal."""
+    
+    def __init__(self, remote_name: str):
+        self.remote_name = remote_name
+    
+    def run_command(self, command: str, timeout: int = 30, shell: str = "powershell") -> subprocess.CompletedProcess[str]:
+        """Execute a command on the remote machine via SSH."""
+        # For Windows Terminal on remote machines, we need to use PowerShell or CMD
+        if shell == "powershell":
+            # Wrap command in PowerShell invocation if needed
+            if not command.startswith("powershell"):
+                command = f"powershell -Command \"{command}\""
+        
+        ssh_cmd = ["ssh", self.remote_name, command]
+        try:
+            result = subprocess.run(
+                ssh_cmd,
+                capture_output=True,
+                text=True,
+                timeout=timeout
+            )
+            return result
+        except subprocess.TimeoutExpired:
+            logger.error(f"SSH command timed out after {timeout}s: {command}")
+            raise
+        except Exception as e:
+            logger.error(f"SSH command failed: {e}")
+            raise
+    
+    def copy_file_to_remote(self, local_file: str, remote_path: str) -> Dict[str, Any]:
+        """Copy a file to the remote machine using SCP."""
+        scp_cmd = ["scp", local_file, f"{self.remote_name}:{remote_path}"]
+        try:
+            result = subprocess.run(scp_cmd, capture_output=True, text=True)
+            if result.returncode == 0:
+                logger.info(f"File copied successfully to {self.remote_name}:{remote_path}")
+                return {"success": True, "remote_path": remote_path}
+            else:
+                logger.error(f"SCP failed: {result.stderr}")
+                return {"success": False, "error": result.stderr}
+        except Exception as e:
+            logger.error(f"SCP operation failed: {e}")
+            return {"success": False, "error": str(e)}
+    
+    def create_remote_directory(self, remote_dir: str) -> bool:
+        """Create a directory on the remote machine."""
+        try:
+            # Use PowerShell mkdir which creates parent directories automatically
+            result = self.run_command(f"New-Item -ItemType Directory -Path '{remote_dir}' -Force")
+            return result.returncode == 0
+        except Exception as e:
+            logger.error(f"Failed to create remote directory {remote_dir}: {e}")
+            return False
+    
+    def start_wt_session_interactive(self, wt_command: str) -> None:
+        """Start a Windows Terminal session interactively via SSH."""
+        try:
+            # For interactive Windows Terminal, we need to use SSH with a TTY
+            ssh_cmd = ["ssh", "-t", self.remote_name, wt_command]
+            logger.info(f"Starting Windows Terminal session on {self.remote_name}")
+            subprocess.run(ssh_cmd)
+        except Exception as e:
+            logger.error(f"Failed to start Windows Terminal session: {e}")
+            raise
+    
+    def check_wt_available(self) -> bool:
+        """Check if Windows Terminal is available on the remote machine."""
+        try:
+            result = self.run_command("where wt", timeout=10)
+            return result.returncode == 0
+        except Exception:
+            return False
+    
+    def get_remote_windows_info(self) -> Dict[str, Any]:
+        """Get information about the remote Windows system."""
+        try:
+            # Get Windows version and terminal info
+            version_cmd = "Get-ComputerInfo | Select-Object WindowsProductName, WindowsVersion"
+            result = self.run_command(version_cmd, timeout=15)
+            
+            wt_available = self.check_wt_available()
+            
+            return {
+                "windows_info": result.stdout if result.returncode == 0 else "Unknown",
+                "wt_available": wt_available,
+                "remote_name": self.remote_name
+            }
+        except Exception as e:
+            logger.error(f"Failed to get remote Windows info: {e}")
+            return {
+                "windows_info": "Error getting info",
+                "wt_available": False,
+                "remote_name": self.remote_name,
+                "error": str(e)
+            }
+    
+    def run_wt_command(self, wt_command: str, detached: bool = True) -> subprocess.CompletedProcess[str]:
+        """Run a Windows Terminal command on the remote machine."""
+        try:
+            if detached:
+                # Run in detached mode (background)
+                full_command = f"Start-Process -FilePath 'wt' -ArgumentList '{wt_command}' -WindowStyle Hidden"
+            else:
+                # Run in foreground
+                full_command = f"wt {wt_command}"
+            
+            return self.run_command(full_command, timeout=30)
+        except Exception as e:
+            logger.error(f"Failed to run Windows Terminal command: {e}")
+            raise
+    
+    def list_wt_processes(self) -> Dict[str, Any]:
+        """List Windows Terminal processes on the remote machine."""
+        try:
+            # Get all WindowsTerminal.exe processes
+            ps_command = "Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, StartTime, CPU"
+            result = self.run_command(ps_command, timeout=15)
+            
+            if result.returncode == 0:
+                return {
+                    "success": True,
+                    "processes": result.stdout,
+                    "remote": self.remote_name
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": result.stderr,
+                    "remote": self.remote_name
+                }
+        except Exception as e:
+            logger.error(f"Failed to list Windows Terminal processes: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "remote": self.remote_name
+            }
+    
+    def kill_wt_processes(self, process_ids: Optional[List[Any]] = None) -> Dict[str, Any]:
+        """Kill Windows Terminal processes on the remote machine."""
+        try:
+            if process_ids:
+                # Kill specific processes
+                kill_cmd = f"Stop-Process -Id {','.join(map(str, process_ids))} -Force"
+            else:
+                # Kill all Windows Terminal processes
+                kill_cmd = "Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue | Stop-Process -Force"
+            
+            result = self.run_command(kill_cmd, timeout=10)
+            
+            return {
+                "success": result.returncode == 0,
+                "message": "Processes killed" if result.returncode == 0 else result.stderr,
+                "remote": self.remote_name
+            }
+        except Exception as e:
+            logger.error(f"Failed to kill Windows Terminal processes: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "remote": self.remote_name
+            }