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

machineconfig/cluster/sessions_managers/wt_utils/process_monitor.py

@@ -3,6 +3,7 @@
 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
@@ -14,153 +15,105 @@ 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
-            )
+            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]:
+
+    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
-            }
-        
+            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()]
+                    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('}'):
+                        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
-                        }
+                        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
-                        }
+                        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
-                    }
+                    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
-                }
-                
+                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
-            }
-    
+            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 ''
-        
+        primary_cmd = cmd_parts[0] if cmd_parts else ""
+
         return f"""
 $targetCommand = '{escaped_command}'
-$cmdParts = @({', '.join([f"'{part}'" for part in cmd_parts])})
+$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
@@ -178,38 +131,32 @@ Get-Process | ForEach-Object {{
     }}
 }}
 """
-    
+
     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
-            }
-        
+            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()]
+                    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:
+                        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),
@@ -218,62 +165,32 @@ Get-Process | ForEach-Object {{
                                 "tab_name": tab_name,
                                 "location": self.location_name,
                                 "check_timestamp": check_timestamp,
-                                "method": "force_fresh_check"
+                                "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
-                    }
+                    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
-                    }
+                    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
-                }
-                
+                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
-            }
-    
+            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 ''
-        
+        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])})
+$cmdParts = @({", ".join([f"'{part}'" for part in cmd_parts])})
 $primaryCmd = '{primary_cmd}'
 $currentPid = $PID
 $checkTime = Get-Date
@@ -282,30 +199,30 @@ $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
@@ -334,21 +251,21 @@ $result = @{{
 
 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"]:
@@ -359,60 +276,43 @@ Write-Output $result
                 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 | 
+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
-                    }
+                    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
-                    }
+                    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
-                }
+                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
-            } 
+            return {"success": False, "error": str(e), "location": self.location_name}

machineconfig/cluster/sessions_managers/wt_utils/remote_executor.py

@@ -3,6 +3,7 @@
 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
@@ -12,26 +13,21 @@ 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}\""
-        
+                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
-            )
+            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}")
@@ -39,7 +35,7 @@ class WTRemoteExecutor:
         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}"]
@@ -54,7 +50,7 @@ class WTRemoteExecutor:
         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:
@@ -64,7 +60,7 @@ class WTRemoteExecutor:
         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:
@@ -75,7 +71,7 @@ class WTRemoteExecutor:
         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:
@@ -83,30 +79,21 @@ class WTRemoteExecutor:
             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
-            }
+
+            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)
-            }
-    
+            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:
@@ -116,39 +103,27 @@ class WTRemoteExecutor:
             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
-                }
+                return {"success": True, "processes": result.stdout, "remote": self.remote_name}
             else:
-                return {
-                    "success": False,
-                    "error": result.stderr,
-                    "remote": self.remote_name
-                }
+                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
-            }
-    
+            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:
@@ -158,18 +133,10 @@ class WTRemoteExecutor:
             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
-            }
+
+            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
-            } 
+            return {"success": False, "error": str(e), "remote": self.remote_name}