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

machineconfig/cluster/sessions_managers/wt_utils/session_manager.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python3
+"""
+Windows Terminal session management utilities for local and remote operations.
+"""
+import logging
+import subprocess
+from typing import Dict, Any, Optional
+from pathlib import Path
+from .remote_executor import WTRemoteExecutor
+
+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):
+        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
+            )
+        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:
+            # Check for Windows Terminal processes
+            wt_check_cmd = """
+Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue |
+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
+                        }
+                    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
+                        }
+                else:
+                    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
+                }
+                
+        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]:
+        """Start a Windows Terminal session with the generated layout."""
+        try:
+            if script_file_path:
+                # Execute the script file
+                if self.is_local:
+                    script_path = script_file_path
+                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"
+                }
+            else:
+                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
+            }
+    
+    def attach_to_session(self, window_name: Optional[str] = None) -> None:
+        """Attach to a Windows Terminal session/window."""
+        try:
+            if self.is_local:
+                # For local sessions, try to focus existing window or create new one
+                if window_name:
+                    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:
+            if force:
+                # Kill all Windows Terminal processes
+                kill_cmd = "Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue | Stop-Process -Force"
+            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 {
+                "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
+            }
+            
+        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
+            }
+    
+    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
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "location": self.location_name
+            } 

machineconfig/cluster/sessions_managers/wt_utils/status_reporter.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""
+Status reporting utilities for Windows Terminal layouts and sessions.
+"""
+import logging
+from typing import Dict, Any, Tuple
+from .process_monitor import WTProcessMonitor
+from .session_manager import WTSessionManager
+
+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")
+            }
+        }
+    
+    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(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")
+        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
+            }
+        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
+            }
+    
+    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
+                        pid = window.get("Id", "Unknown")
+                        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:
+                    print("  No Windows Terminal windows currently running")
+            else:
+                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,
+                "location": summary.get("location", "unknown"),
+                "wt_running": wt_status.get("wt_running", False),
+                "session_healthy": summary["session_healthy"],
+                "total_commands": summary["total_commands"],
+                "running_commands": summary["running_commands"],
+                "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"
+            }
+        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
+            }
+    
+    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
+            }
+        
+        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}")
+            return {
+                "error": str(e),
+                "tab_name": tab_name,
+                "location": self.process_monitor.location_name
+            }