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

machineconfig/cluster/sessions_managers/wt_utils/layout_generator.py

@@ -15,25 +15,25 @@ logger = logging.getLogger(__name__)
 
 class WTLayoutGenerator:
     """Handles generation of Windows Terminal command strings for multi-tab layouts."""
-    
+
     @staticmethod
     def generate_random_suffix(length: int = 8) -> str:
         """Generate a random string suffix for unique window names."""
         return ''.join(random.choices(string.ascii_lowercase + string.digits, k=length))
-    
+
     @staticmethod
     def parse_command(command: str) -> Tuple[str, List[str]]:
         """Parse a command string into command and arguments."""
         try:
             parts = shlex.split(command)
-            if not parts: 
+            if not parts:
                 raise ValueError("Empty command provided")
             return parts[0], parts[1:] if len(parts) > 1 else []
         except ValueError as e:
             logger.error(f"Error parsing command '{command}': {e}")
             parts = command.split()
             return parts[0] if parts else "", parts[1:] if len(parts) > 1 else []
-    
+
     @staticmethod
     def escape_for_wt(text: str) -> str:
         """Escape text for use in Windows Terminal commands."""
@@ -43,79 +43,79 @@ class WTLayoutGenerator:
         if ' ' in text or ';' in text or '&' in text or '|' in text:
             return f'"{text}"'
         return text
-    
+
     @staticmethod
     def create_tab_command(tab_name: str, cwd: str, command: str, is_first_tab: bool = False) -> str:
         """Create a Windows Terminal tab command string."""
         cmd, args = WTLayoutGenerator.parse_command(command)
-        
+
         # Convert paths to Windows format if needed
         if cwd.startswith('~/'):
             cwd = cwd.replace('~/', f"{Path.home()}/")
         elif cwd == '~':
             cwd = str(Path.home())
-        
+
         # Build the wt command parts
         tab_parts = []
-        
+
         if not is_first_tab:
             tab_parts.append("new-tab")
-        
+
         # Add profile if specified (could be extended to support different shells)
         # tab_parts.extend(["-p", "\"Command Prompt\""])  # or "PowerShell", "WSL", etc.
-        
+
         # Add starting directory
         tab_parts.extend(["-d", WTLayoutGenerator.escape_for_wt(cwd)])
-        
+
         # Add tab title
         tab_parts.extend(["--title", WTLayoutGenerator.escape_for_wt(tab_name)])
-        
+
         # Add the command to execute
         full_command = command if not args else f"{cmd} {' '.join(args)}"
         tab_parts.append(WTLayoutGenerator.escape_for_wt(full_command))
-        
+
         return " ".join(tab_parts)
-    
+
     @staticmethod
     def validate_tab_config(tab_config: Dict[str, Tuple[str, str]]) -> None:
         """Validate tab configuration format and content."""
-        if not tab_config: 
+        if not tab_config:
             raise ValueError("Tab configuration cannot be empty")
         for tab_name, (cwd, command) in tab_config.items():
-            if not tab_name.strip(): 
+            if not tab_name.strip():
                 raise ValueError(f"Invalid tab name: {tab_name}")
-            if not command.strip(): 
+            if not command.strip():
                 raise ValueError(f"Invalid command for tab '{tab_name}': {command}")
-            if not cwd.strip(): 
+            if not cwd.strip():
                 raise ValueError(f"Invalid cwd for tab '{tab_name}': {cwd}")
-    
-    def generate_wt_command(self, tab_config: Dict[str, Tuple[str, str]], 
-                           window_name: str | None = None, 
+
+    def generate_wt_command(self, tab_config: Dict[str, Tuple[str, str]],
+                           window_name: str | None = None,
                            maximized: bool = False,
                            focus: bool = True) -> str:
         """Generate complete Windows Terminal command string."""
         self.validate_tab_config(tab_config)
-        
+
         # Start building the wt command
         wt_parts = ["wt"]
-        
+
         # Add window options
         if maximized:
             wt_parts.append("--maximized")
-        
+
         if focus:
             wt_parts.append("--focus")
-        
+
         if window_name:
             wt_parts.extend(["-w", WTLayoutGenerator.escape_for_wt(window_name)])
-        
+
         # Add tabs
         tab_commands = []
         for i, (tab_name, (cwd, command)) in enumerate(tab_config.items()):
             is_first = i == 0
             tab_cmd = self.create_tab_command(tab_name, cwd, command, is_first)
             tab_commands.append(tab_cmd)
-        
+
         # Join all parts with semicolons (Windows Terminal command separator)
         if tab_commands:
             if len(tab_commands) == 1:
@@ -126,65 +126,67 @@ class WTLayoutGenerator:
                 wt_parts.append(tab_commands[0])  # First tab
                 for tab_cmd in tab_commands[1:]:
                     wt_parts.extend([";", tab_cmd])
-        
+
         return " ".join(wt_parts)
-    
-    def create_wt_script(self, tab_config: Dict[str, Tuple[str, str]], 
+
+    def create_wt_script(self, tab_config: Dict[str, Tuple[str, str]],
                         output_dir: Path, session_name: str,
                         window_name: str | None = None) -> str:
         """Create a Windows Terminal script file and return its absolute path."""
         self.validate_tab_config(tab_config)
-        
+
         # Generate unique suffix for this script
         random_suffix = self.generate_random_suffix()
         wt_command = self.generate_wt_command(tab_config, window_name or session_name)
-        
+
         try:
             # Create output directory if it doesn't exist
             output_dir.mkdir(parents=True, exist_ok=True)
-            
+
             # Create both .bat and .ps1 versions for flexibility
             bat_file = output_dir / f"wt_layout_{session_name}_{random_suffix}.bat"
             ps1_file = output_dir / f"wt_layout_{session_name}_{random_suffix}.ps1"
-            
+
             # Create batch file
-            with open(bat_file, 'w', encoding='utf-8') as f:
-                f.write(f"@echo off\n")
-                f.write(f"REM Windows Terminal layout for {session_name}\n")
-                f.write(f"{wt_command}\n")
-            
+            text = f"""@echo off
+REM Windows Terminal layout for {session_name}
+{wt_command}
+"""
+            bat_file.write_text(text, encoding="utf-8")
+
             # Create PowerShell file (better for complex commands)
-            with open(ps1_file, 'w', encoding='utf-8') as f:
-                f.write(f"# Windows Terminal layout for {session_name}\n")
-                f.write(f"# Generated on {random_suffix}\n")
-                f.write(f"{wt_command}\n")
-            
+            text = f"""# Windows Terminal layout for {session_name}
+# Generated on {random_suffix}
+{wt_command}
+"""
+            ps1_file.write_text(text, encoding="utf-8")
+
             logger.info(f"Windows Terminal script files created: {bat_file.absolute()}")
             return str(bat_file.absolute())
-            
+
         except OSError as e:
             logger.error(f"Failed to create script file: {e}")
             raise
-    
-    def generate_split_pane_command(self, tab_config: Dict[str, Tuple[str, str]], 
+
+    def generate_split_pane_command(self, tab_config: Dict[str, Tuple[str, str]],
                                    window_name: str | None = None) -> str:
         """Generate Windows Terminal command with split panes instead of separate tabs."""
         self.validate_tab_config(tab_config)
-        
+
         wt_parts = ["wt"]
-        
+
         if window_name:
             wt_parts.extend(["-w", WTLayoutGenerator.escape_for_wt(window_name)])
-        
+
         # First pane (main tab)
         first_tab = list(tab_config.items())[0]
         tab_name, (cwd, command) = first_tab
-        
+
         # Start with first tab
         wt_parts.extend(["-d", WTLayoutGenerator.escape_for_wt(cwd)])
         wt_parts.extend(["--title", WTLayoutGenerator.escape_for_wt(tab_name)])
         wt_parts.append(WTLayoutGenerator.escape_for_wt(command))
-        
+
         # Add split panes for remaining tabs
         for tab_name, (cwd, command) in list(tab_config.items())[1:]:
             wt_parts.append(";")
@@ -192,5 +194,5 @@ class WTLayoutGenerator:
             wt_parts.extend(["-d", WTLayoutGenerator.escape_for_wt(cwd)])
             wt_parts.extend(["--title", WTLayoutGenerator.escape_for_wt(tab_name)])
             wt_parts.append(WTLayoutGenerator.escape_for_wt(command))
-        
-        return " ".join(wt_parts) 
+
+        return " ".join(wt_parts)

machineconfig/cluster/sessions_managers/wt_utils/process_monitor.py

@@ -14,16 +14,16 @@ 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:
@@ -37,8 +37,8 @@ class WTProcessMonitor:
             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]], 
+
+    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:
@@ -50,27 +50,27 @@ class WTProcessMonitor:
                 "command": None,
                 "location": self.location_name
             }
-        
+
         # Use the verified method by default for more accurate results
         if use_verification:
             return self.get_verified_process_status(tab_name, tab_config)
-        
+
         return self._basic_process_check(tab_name, tab_config)
-    
+
     def _basic_process_check(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
         """Basic process checking without verification."""
         _, command = tab_config[tab_name]
-        
+
         try:
             check_script = self._create_process_check_script(command)
             result = self._run_command(check_script, timeout=15)
-            
+
             if result.returncode == 0:
                 try:
                     # Parse PowerShell output (JSON format)
                     output_lines = [line.strip() for line in result.stdout.strip().split('\n') if line.strip()]
                     matching_processes = []
-                    
+
                     for line in output_lines:
                         if line.startswith('{') and line.endswith('}'):
                             try:
@@ -78,7 +78,7 @@ class WTProcessMonitor:
                                 matching_processes.append(proc_info)
                             except json.JSONDecodeError:
                                 continue
-                    
+
                     if matching_processes:
                         return {
                             "status": "running",
@@ -109,14 +109,14 @@ class WTProcessMonitor:
                     }
             else:
                 return {
-                    "status": "error", 
+                    "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 {
@@ -127,14 +127,14 @@ class WTProcessMonitor:
                 "tab_name": tab_name,
                 "location": self.location_name
             }
-    
+
     def _create_process_check_script(self, command: str) -> str:
         """Create PowerShell script for checking processes."""
         # Escape command for PowerShell
         escaped_command = command.replace("'", "''").replace('"', '""')
         cmd_parts = [part for part in command.split() if len(part) > 2]
         primary_cmd = cmd_parts[0] if cmd_parts else ''
-        
+
         return f"""
 $targetCommand = '{escaped_command}'
 $cmdParts = @({', '.join([f"'{part}'" for part in cmd_parts])})
@@ -144,23 +144,23 @@ $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,7 +178,7 @@ 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:
@@ -189,18 +189,18 @@ Get-Process | ForEach-Object {{
                 "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
@@ -209,7 +209,7 @@ Get-Process | ForEach-Object {{
                         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),
@@ -220,7 +220,7 @@ Get-Process | ForEach-Object {{
                                 "check_timestamp": check_timestamp,
                                 "method": "force_fresh_check"
                             }
-                    
+
                     # Fallback if no JSON found
                     return {
                         "status": "not_running",
@@ -244,14 +244,14 @@ Get-Process | ForEach-Object {{
                     }
             else:
                 return {
-                    "status": "error", 
+                    "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 {
@@ -262,13 +262,13 @@ Get-Process | ForEach-Object {{
                 "tab_name": tab_name,
                 "location": self.location_name
             }
-    
+
     def _create_fresh_check_script(self, command: str) -> str:
         """Create enhanced PowerShell process checking script with freshness validation."""
         escaped_command = command.replace("'", "''").replace('"', '""')
         cmd_parts = [part for part in command.split() if len(part) > 2]
         primary_cmd = cmd_parts[0] if cmd_parts else ''
-        
+
         return f"""
 Start-Sleep -Milliseconds 100
 
@@ -282,30 +282,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 +334,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,35 +359,35 @@ 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)
@@ -415,4 +415,4 @@ ConvertTo-Json -Depth 2
                 "success": False,
                 "error": str(e),
                 "location": self.location_name
-            } 
+            }