machineconfig 1.96__py3-none-any.whl → 2.0__py3-none-any.whl

machineconfig/cluster/sessions_managers/wt_utils/remote_executor.py

@@ -12,10 +12,10 @@ 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
@@ -23,7 +23,7 @@ class WTRemoteExecutor:
             # 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(
@@ -39,7 +39,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 +54,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 +64,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 +75,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,16 +83,16 @@ 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,
@@ -106,7 +106,7 @@ class WTRemoteExecutor:
                 "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,19 +116,19 @@ 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,
@@ -148,7 +148,7 @@ class WTRemoteExecutor:
                 "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,9 +158,9 @@ 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,
@@ -172,4 +172,4 @@ class WTRemoteExecutor:
                 "success": False,
                 "error": str(e),
                 "remote": self.remote_name
-            } 
+            }

machineconfig/cluster/sessions_managers/wt_utils/session_manager.py

@@ -13,19 +13,19 @@ logger = logging.getLogger(__name__)
 
 class WTSessionManager:
     """Handles Windows Terminal session operations on local and remote machines."""
-    
-    def __init__(self, remote_executor: Optional[WTRemoteExecutor] = None, 
+
+    def __init__(self, remote_executor: Optional[WTRemoteExecutor] = None,
                  session_name: str = "default", tmp_layout_dir: Path | None = None):
         self.remote_executor = remote_executor
         self.session_name = session_name
         self.tmp_layout_dir = tmp_layout_dir or Path.home() / "tmp_results" / "wt_layouts" / "layout_manager"
         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:
@@ -39,31 +39,31 @@ class WTSessionManager:
             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 copy_script_to_remote(self, local_script_file: Path, random_suffix: str) -> str:
         """Copy the script file to the remote machine and return the remote path."""
         if self.is_local:
             # For local operations, just return the local path
             return str(local_script_file)
-        
+
         if self.remote_executor is None:
             raise ValueError("Remote executor is None but operation requires remote access")
-        
+
         remote_layout_dir = f"~/{self.tmp_layout_dir.relative_to(Path.home())}"
         remote_script_file = f"{remote_layout_dir}/wt_script_{self.session_name}_{random_suffix}.ps1"
-        
+
         # Create remote directory
         if not self.remote_executor.create_remote_directory(remote_layout_dir):
             raise RuntimeError(f"Failed to create remote directory: {remote_layout_dir}")
-        
+
         # Copy script file to remote machine
         copy_result = self.remote_executor.copy_file_to_remote(str(local_script_file), remote_script_file)
         if not copy_result["success"]:
             raise RuntimeError(f"Failed to copy script file to remote: {copy_result['error']}")
-        
+
         logger.info(f"Windows Terminal script file copied to remote: {self.remote_executor.remote_name}:{remote_script_file}")
         return remote_script_file
-    
+
     def check_wt_session_status(self) -> Dict[str, Any]:
         """Check if Windows Terminal windows exist and are running."""
         try:
@@ -74,7 +74,7 @@ Select-Object Id, ProcessName, StartTime, MainWindowTitle |
 ConvertTo-Json -Depth 2
 """
             result = self._run_command(wt_check_cmd, timeout=10)
-            
+
             if result.returncode == 0:
                 output = result.stdout.strip()
                 if output and output != "":
@@ -83,14 +83,14 @@ ConvertTo-Json -Depth 2
                         processes = json.loads(output)
                         if not isinstance(processes, list):
                             processes = [processes]
-                        
+
                         # Look for windows that might belong to our session
                         session_windows = []
                         for proc in processes:
                             window_title = proc.get("MainWindowTitle", "")
                             if self.session_name in window_title or not window_title:
                                 session_windows.append(proc)
-                        
+
                         return {
                             "wt_running": True,
                             "session_exists": len(session_windows) > 0,
@@ -123,7 +123,7 @@ ConvertTo-Json -Depth 2
                     "session_name": self.session_name,
                     "location": self.location_name
                 }
-                
+
         except Exception as e:
             return {
                 "wt_running": False,
@@ -131,8 +131,8 @@ ConvertTo-Json -Depth 2
                 "session_name": self.session_name,
                 "location": self.location_name
             }
-    
-    def start_wt_session(self, script_file_path: Optional[str] = None, 
+
+    def start_wt_session(self, script_file_path: Optional[str] = None,
                         wt_command: Optional[str] = None) -> Dict[str, Any]:
         """Start a Windows Terminal session with the generated layout."""
         try:
@@ -143,25 +143,25 @@ ConvertTo-Json -Depth 2
                 else:
                     script_filename = Path(script_file_path).name
                     script_path = f"~/{self.tmp_layout_dir.relative_to(Path.home())}/{script_filename}"
-                
+
                 logger.info(f"Starting Windows Terminal session '{self.session_name}' with script: {script_path}")
-                
+
                 # Execute the PowerShell script
                 if self.is_local:
                     start_cmd = f"& '{script_path}'"
                 else:
                     start_cmd = f"powershell -ExecutionPolicy Bypass -File '{script_path}'"
-                    
+
             elif wt_command:
                 # Execute the wt command directly
                 logger.info(f"Starting Windows Terminal session '{self.session_name}' with command: {wt_command}")
                 start_cmd = wt_command
             else:
                 raise ValueError("Either script_file_path or wt_command must be provided.")
-            
+
             logger.info(f"Executing command: {start_cmd}")
             result = self._run_command(start_cmd, timeout=30)
-            
+
             if result.returncode == 0:
                 logger.info(f"Windows Terminal session '{self.session_name}' started successfully")
                 return {
@@ -177,7 +177,7 @@ ConvertTo-Json -Depth 2
                     "session_name": self.session_name,
                     "location": self.location_name
                 }
-                
+
         except Exception as e:
             error_location = "locally" if self.is_local else f"on {self.remote_executor.remote_name if self.remote_executor else 'unknown'}"
             logger.error(f"Failed to start Windows Terminal session {error_location}: {e}")
@@ -187,7 +187,7 @@ ConvertTo-Json -Depth 2
                 "session_name": self.session_name,
                 "location": self.location_name
             }
-    
+
     def attach_to_session(self, window_name: Optional[str] = None) -> None:
         """Attach to a Windows Terminal session/window."""
         try:
@@ -197,24 +197,24 @@ ConvertTo-Json -Depth 2
                     attach_cmd = f"wt -w {window_name}"
                 else:
                     attach_cmd = f"wt -w {self.session_name}"
-                
+
                 logger.info(f"Attaching to local Windows Terminal window '{window_name or self.session_name}'")
                 subprocess.run(attach_cmd, shell=True)
             else:
                 # For remote sessions, use SSH with interactive terminal
                 if self.remote_executor is None:
                     raise ValueError("Remote executor is None but operation requires remote access")
-                    
+
                 if window_name:
                     attach_cmd = f"wt -w {window_name}"
                 else:
                     attach_cmd = f"wt -w {self.session_name}"
-                
+
                 self.remote_executor.start_wt_session_interactive(attach_cmd)
         except Exception as e:
             logger.error(f"Failed to attach to Windows Terminal session: {e}")
             raise
-    
+
     def kill_wt_session(self, force: bool = True) -> Dict[str, Any]:
         """Kill Windows Terminal processes related to this session."""
         try:
@@ -224,17 +224,17 @@ ConvertTo-Json -Depth 2
             else:
                 # Try to gracefully close windows (this is harder to target specific windows)
                 kill_cmd = "Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue | ForEach-Object { $_.CloseMainWindow() }"
-            
+
             logger.info(f"Killing Windows Terminal session '{self.session_name}'")
             result = self._run_command(kill_cmd, timeout=10)
-            
+
             return {
                 "success": result.returncode == 0,
                 "message": "Session killed" if result.returncode == 0 else result.stderr,
                 "session_name": self.session_name,
                 "location": self.location_name
             }
-            
+
         except Exception as e:
             logger.error(f"Failed to kill Windows Terminal session: {e}")
             return {
@@ -243,27 +243,27 @@ ConvertTo-Json -Depth 2
                 "session_name": self.session_name,
                 "location": self.location_name
             }
-    
-    def create_new_tab(self, tab_name: str, cwd: str, command: str, 
+
+    def create_new_tab(self, tab_name: str, cwd: str, command: str,
                       window_name: Optional[str] = None) -> Dict[str, Any]:
         """Create a new tab in the Windows Terminal session."""
         try:
             # Build the new-tab command
             tab_cmd_parts = ["wt"]
-            
+
             if window_name:
                 tab_cmd_parts.extend(["-w", f'"{window_name}"'])
-            
+
             tab_cmd_parts.append("new-tab")
             tab_cmd_parts.extend(["-d", f'"{cwd}"'])
             tab_cmd_parts.extend(["--title", f'"{tab_name}"'])
             tab_cmd_parts.append(f'"{command}"')
-            
+
             new_tab_cmd = " ".join(tab_cmd_parts)
-            
+
             logger.info(f"Creating new tab '{tab_name}' in Windows Terminal")
             result = self._run_command(new_tab_cmd, timeout=15)
-            
+
             return {
                 "success": result.returncode == 0,
                 "message": f"Tab '{tab_name}' created" if result.returncode == 0 else result.stderr,
@@ -271,7 +271,7 @@ ConvertTo-Json -Depth 2
                 "command": command,
                 "location": self.location_name
             }
-            
+
         except Exception as e:
             logger.error(f"Failed to create new tab '{tab_name}': {e}")
             return {
@@ -280,13 +280,13 @@ ConvertTo-Json -Depth 2
                 "tab_name": tab_name,
                 "location": self.location_name
             }
-    
+
     def get_wt_version(self) -> Dict[str, Any]:
         """Get Windows Terminal version information."""
         try:
             version_cmd = "wt --version"
             result = self._run_command(version_cmd, timeout=10)
-            
+
             return {
                 "success": result.returncode == 0,
                 "version": result.stdout.strip() if result.returncode == 0 else "Unknown",
@@ -297,4 +297,4 @@ ConvertTo-Json -Depth 2
                 "success": False,
                 "error": str(e),
                 "location": self.location_name
-            } 
+            }

machineconfig/cluster/sessions_managers/wt_utils/status_reporter.py

@@ -12,19 +12,19 @@ logger = logging.getLogger(__name__)
 
 class WTStatusReporter:
     """Handles comprehensive status reporting for Windows Terminal sessions."""
-    
+
     def __init__(self, process_monitor: WTProcessMonitor, session_manager: WTSessionManager):
         self.process_monitor = process_monitor
         self.session_manager = session_manager
-    
+
     def get_comprehensive_status(self, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
         """Get comprehensive status including Windows Terminal session and all commands."""
         wt_status = self.session_manager.check_wt_session_status()
         commands_status = self.process_monitor.check_all_commands_status(tab_config)
-        
+
         running_count = sum(1 for status in commands_status.values() if status.get("running", False))
         total_count = len(commands_status)
-        
+
         return {
             "wt_session": wt_status,
             "commands": commands_status,
@@ -36,23 +36,23 @@ class WTStatusReporter:
                 "location": wt_status.get("location", "unknown")
             }
         }
-    
+
     def print_status_report(self, tab_config: Dict[str, Tuple[str, str]]) -> None:
         """Print a comprehensive status report for the Windows Terminal session."""
         status = self.get_comprehensive_status(tab_config)
         wt_session = status["wt_session"]
         commands = status["commands"]
         summary = status["summary"]
-        
+
         print("=" * 80)
         print("🖥️  WINDOWS TERMINAL STATUS REPORT")
         print("=" * 80)
-        
+
         # Session status
         location = wt_session.get("location", "unknown")
         print(f"📍 Location: {location}")
         print(f"🪟 Session: {self.session_manager.session_name}")
-        
+
         if wt_session.get("wt_running", False):
             if wt_session.get("session_exists", False):
                 session_windows = wt_session.get("session_windows", [])
@@ -65,53 +65,53 @@ class WTStatusReporter:
         else:
             error_msg = wt_session.get("error", "Unknown error")
             print(f"❌ Windows Terminal session issue: {error_msg}")
-        
+
         print()
-        
+
         # Commands status
         print(f"📋 COMMANDS STATUS ({summary['running_commands']}/{summary['total_commands']} running):")
         print("-" * 60)
-        
+
         for tab_name, cmd_status in commands.items():
             status_icon = "✅" if cmd_status.get("running", False) else "❌"
             cmd_text = cmd_status.get("command", "Unknown")[:50]
             if len(cmd_status.get("command", "")) > 50:
                 cmd_text += "..."
-            
+
             print(f"  {status_icon} {tab_name}")
             print(f"     Command: {cmd_text}")
-            
+
             if cmd_status.get("processes"):
                 processes = cmd_status["processes"][:3]  # Show first 3 processes
                 for proc in processes:
                     pid = proc.get("pid", "Unknown")
                     name = proc.get("name", "Unknown")
                     print(f"       └─ PID {pid}: {name}")
-                
+
                 if len(cmd_status["processes"]) > 3:
                     remaining = len(cmd_status["processes"]) - 3
                     print(f"       └─ ... and {remaining} more processes")
-            
+
             if cmd_status.get("error"):
                 print(f"     Error: {cmd_status['error']}")
-            
+
             print()
-        
+
         # Summary
         print("📊 SUMMARY:")
         print(f"   Total commands: {summary['total_commands']}")
         print(f"   Running: {summary['running_commands']}")
         print(f"   Stopped: {summary['stopped_commands']}")
         print(f"   Session healthy: {'✅' if summary['session_healthy'] else '❌'}")
-        
+
         print("=" * 80)
-    
+
     def get_windows_terminal_overview(self) -> Dict[str, Any]:
         """Get an overview of all Windows Terminal windows and processes."""
         try:
             wt_windows = self.process_monitor.get_windows_terminal_windows()
             wt_version = self.session_manager.get_wt_version()
-            
+
             return {
                 "success": True,
                 "windows_info": wt_windows,
@@ -125,32 +125,32 @@ class WTStatusReporter:
                 "error": str(e),
                 "location": self.process_monitor.location_name
             }
-    
+
     def print_windows_terminal_overview(self) -> None:
         """Print an overview of Windows Terminal status."""
         overview = self.get_windows_terminal_overview()
-        
+
         print("=" * 80)
         print("🖥️  WINDOWS TERMINAL OVERVIEW")
         print("=" * 80)
-        
+
         if overview["success"]:
             location = overview.get("location", "unknown")
             print(f"📍 Location: {location}")
-            
+
             # Version info
             version_info = overview.get("version_info", {})
             if version_info.get("success"):
                 print(f"📦 Version: {version_info.get('version', 'Unknown')}")
             else:
                 print(f"📦 Version: Error getting version - {version_info.get('error', 'Unknown')}")
-            
+
             # Windows info
             windows_info = overview.get("windows_info", {})
             if windows_info.get("success"):
                 windows = windows_info.get("windows", [])
                 print(f"🪟 Active Windows: {len(windows)}")
-                
+
                 if windows:
                     print("\nActive Windows:")
                     for i, window in enumerate(windows[:5], 1):  # Show first 5 windows
@@ -158,7 +158,7 @@ class WTStatusReporter:
                         title = window.get("WindowTitle", "No Title")
                         start_time = window.get("StartTime", "Unknown")
                         print(f"  {i}. PID {pid}: {title} (Started: {start_time})")
-                    
+
                     if len(windows) > 5:
                         print(f"  ... and {len(windows) - 5} more windows")
                 else:
@@ -167,18 +167,18 @@ class WTStatusReporter:
                 print(f"🪟 Windows Info: Error - {windows_info.get('error', 'Unknown')}")
         else:
             print(f"❌ Failed to get overview: {overview.get('error', 'Unknown')}")
-        
+
         print("=" * 80)
-    
+
     def generate_status_summary(self, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
         """Generate a concise status summary suitable for monitoring."""
         try:
             comprehensive_status = self.get_comprehensive_status(tab_config)
             wt_overview = self.get_windows_terminal_overview()
-            
+
             summary = comprehensive_status["summary"]
             wt_status = comprehensive_status["wt_session"]
-            
+
             return {
                 "timestamp": None,  # Will be filled by caller if needed
                 "session_name": self.session_manager.session_name,
@@ -199,7 +199,7 @@ class WTStatusReporter:
                 "session_name": self.session_manager.session_name,
                 "location": self.process_monitor.location_name
             }
-    
+
     def check_tab_specific_status(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
         """Get detailed status for a specific tab."""
         if tab_name not in tab_config:
@@ -207,17 +207,17 @@ class WTStatusReporter:
                 "error": f"Tab '{tab_name}' not found in configuration",
                 "tab_name": tab_name
             }
-        
+
         try:
             cmd_status = self.process_monitor.check_command_status(tab_name, tab_config)
-            
+
             # Add additional context
             cwd, command = tab_config[tab_name]
             cmd_status["tab_config"] = {
                 "working_directory": cwd,
                 "command": command
             }
-            
+
             return cmd_status
         except Exception as e:
             logger.error(f"Failed to check status for tab '{tab_name}': {e}")
@@ -225,4 +225,4 @@ class WTStatusReporter:
                 "error": str(e),
                 "tab_name": tab_name,
                 "location": self.process_monitor.location_name
-            } 
+            }