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

machineconfig/cluster/sessions_managers/wt_utils/session_manager.py

@@ -2,6 +2,7 @@
 """
 Windows Terminal session management utilities for local and remote operations.
 """
+
 import logging
 import subprocess
 from typing import Dict, Any, Optional
@@ -13,57 +14,51 @@ logger = logging.getLogger(__name__)
 
 class WTSessionManager:
     """Handles Windows Terminal session operations on local and remote machines."""
-    
-    def __init__(self, remote_executor: Optional[WTRemoteExecutor] = None, 
-                 session_name: str = "default", tmp_layout_dir: Path | None = 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:
-            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 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,66 +69,37 @@ 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 != "":
                     try:
                         import json
+
                         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,
-                            "session_name": self.session_name,
-                            "all_windows": processes,
-                            "session_windows": session_windows,
-                            "location": self.location_name
-                        }
+
+                        return {"wt_running": True, "session_exists": len(session_windows) > 0, "session_name": self.session_name, "all_windows": processes, "session_windows": session_windows, "location": self.location_name}
                     except Exception as e:
                         logger.error(f"Failed to parse Windows Terminal process info: {e}")
-                        return {
-                            "wt_running": True,
-                            "session_exists": False,
-                            "error": f"Failed to parse process info: {e}",
-                            "session_name": self.session_name,
-                            "location": self.location_name
-                        }
+                        return {"wt_running": True, "session_exists": False, "error": f"Failed to parse process info: {e}", "session_name": self.session_name, "location": self.location_name}
                 else:
-                    return {
-                        "wt_running": False,
-                        "session_exists": False,
-                        "session_name": self.session_name,
-                        "all_windows": [],
-                        "location": self.location_name
-                    }
+                    return {"wt_running": False, "session_exists": False, "session_name": self.session_name, "all_windows": [], "location": self.location_name}
             else:
-                return {
-                    "wt_running": False,
-                    "error": result.stderr,
-                    "session_name": self.session_name,
-                    "location": self.location_name
-                }
-                
+                return {"wt_running": False, "error": result.stderr, "session_name": self.session_name, "location": self.location_name}
+
         except Exception as e:
-            return {
-                "wt_running": False,
-                "error": str(e),
-                "session_name": self.session_name,
-                "location": self.location_name
-            }
-    
-    def start_wt_session(self, script_file_path: Optional[str] = None, 
-                        wt_command: Optional[str] = None) -> Dict[str, Any]:
+            return {"wt_running": False, "error": str(e), "session_name": self.session_name, "location": self.location_name}
+
+    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:
             if script_file_path:
@@ -143,51 +109,36 @@ 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 {
-                    "success": True,
-                    "session_name": self.session_name,
-                    "location": self.location_name,
-                    "message": "Session started successfully"
-                }
+                return {"success": True, "session_name": self.session_name, "location": self.location_name, "message": "Session started successfully"}
             else:
-                return {
-                    "success": False,
-                    "error": result.stderr or result.stdout,
-                    "session_name": self.session_name,
-                    "location": self.location_name
-                }
-                
+                return {"success": False, "error": result.stderr or result.stdout, "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}")
-            return {
-                "success": False,
-                "error": str(e),
-                "session_name": self.session_name,
-                "location": self.location_name
-            }
-    
+            return {"success": False, "error": str(e), "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 +148,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,77 +175,47 @@ 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
-            }
-            
+
+            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 {
-                "success": False,
-                "error": str(e),
-                "session_name": self.session_name,
-                "location": self.location_name
-            }
-    
-    def create_new_tab(self, tab_name: str, cwd: str, command: str, 
-                      window_name: Optional[str] = None) -> Dict[str, Any]:
+            return {"success": False, "error": str(e), "session_name": self.session_name, "location": self.location_name}
+
+    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,
-                "tab_name": tab_name,
-                "command": command,
-                "location": self.location_name
-            }
-            
+
+            return {"success": result.returncode == 0, "message": f"Tab '{tab_name}' created" if result.returncode == 0 else result.stderr, "tab_name": tab_name, "command": command, "location": self.location_name}
+
         except Exception as e:
             logger.error(f"Failed to create new tab '{tab_name}': {e}")
-            return {
-                "success": False,
-                "error": str(e),
-                "tab_name": tab_name,
-                "location": self.location_name
-            }
-    
+            return {"success": False, "error": str(e), "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",
-                "location": self.location_name
-            }
+
+            return {"success": result.returncode == 0, "version": result.stdout.strip() if result.returncode == 0 else "Unknown", "location": self.location_name}
         except Exception as 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/status_reporter.py

@@ -2,6 +2,7 @@
 """
 Status reporting utilities for Windows Terminal layouts and sessions.
 """
+
 import logging
 from typing import Dict, Any, Tuple
 from .process_monitor import WTProcessMonitor
@@ -12,145 +13,130 @@ 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,
-            "summary": {
-                "total_commands": total_count,
-                "running_commands": running_count,
-                "stopped_commands": total_count - running_count,
-                "session_healthy": wt_status.get("session_exists", False),
-                "location": wt_status.get("location", "unknown")
-            }
+            "summary": {"total_commands": total_count, "running_commands": running_count, "stopped_commands": total_count - running_count, "session_healthy": wt_status.get("session_exists", False), "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", [])
                 all_windows = wt_session.get("all_windows", [])
-                print(f"✅ Windows Terminal is running")
+                print("✅ Windows Terminal is running")
                 print(f"   Session windows: {len(session_windows)}")
                 print(f"   Total WT windows: {len(all_windows)}")
             else:
-                print(f"⚠️  Windows Terminal is running but no session windows found")
+                print("⚠️  Windows Terminal is running but no session windows found")
         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,
-                "version_info": wt_version,
-                "location": self.process_monitor.location_name
-            }
+
+            return {"success": True, "windows_info": wt_windows, "version_info": wt_version, "location": self.process_monitor.location_name}
         except Exception as e:
             logger.error(f"Failed to get Windows Terminal overview: {e}")
-            return {
-                "success": False,
-                "error": str(e),
-                "location": self.process_monitor.location_name
-            }
-    
+            return {"success": False, "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 +144,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 +153,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,
@@ -190,39 +176,25 @@ class WTStatusReporter:
                 "stopped_commands": summary["stopped_commands"],
                 "all_commands_running": summary["running_commands"] == summary["total_commands"],
                 "wt_windows_count": len(wt_overview.get("windows_info", {}).get("windows", [])) if wt_overview["success"] else 0,
-                "wt_version": wt_overview.get("version_info", {}).get("version", "Unknown") if wt_overview["success"] else "Unknown"
+                "wt_version": wt_overview.get("version_info", {}).get("version", "Unknown") if wt_overview["success"] else "Unknown",
             }
         except Exception as e:
             logger.error(f"Failed to generate status summary: {e}")
-            return {
-                "error": str(e),
-                "session_name": self.session_manager.session_name,
-                "location": self.process_monitor.location_name
-            }
-    
+            return {"error": str(e), "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:
-            return {
-                "error": f"Tab '{tab_name}' not found in configuration",
-                "tab_name": tab_name
-            }
-        
+            return {"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
-            }
-            
+            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}")
-            return {
-                "error": str(e),
-                "tab_name": tab_name,
-                "location": self.process_monitor.location_name
-            } 
+            return {"error": str(e), "tab_name": tab_name, "location": self.process_monitor.location_name}