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

machineconfig/cluster/sessions_managers/wt_local.py

@@ -3,6 +3,7 @@
 Windows Terminal local layout generator and session manager.
 Equivalent to zellij_local.py but for Windows Terminal.
 """
+
 import shlex
 import subprocess
 import random
@@ -22,82 +23,83 @@ class WTLayoutGenerator:
         self.session_name: Optional[str] = None
         self.tab_config: Dict[str, tuple[str, str]] = {}  # Store entire tab config (cwd, command) for status checking
         self.script_path: Optional[str] = None  # Store the full path to the script file
-    
+
     @staticmethod
     def _generate_random_suffix(length: int = 8) -> str:
         """Generate a random string suffix for unique script file names."""
-        return ''.join(random.choices(string.ascii_lowercase + string.digits, k=length))
-    
+        return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
+
     @staticmethod
     def _parse_command(command: str) -> tuple[str, List[str]]:
         try:
             parts = shlex.split(command)
-            if not parts: raise ValueError("Empty command provided")
+            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."""
         # Windows Terminal uses PowerShell-style escaping
         text = text.replace('"', '""')  # Escape quotes for PowerShell
-        if ' ' in text or ';' in text or '&' in text or '|' in text:
+        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."""
         # Convert paths to Windows format if needed
-        if cwd.startswith('~/'):
-            cwd = cwd.replace('~/', f"{Path.home()}/")
-        elif cwd == '~':
+        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 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
         tab_parts.append(WTLayoutGenerator._escape_for_wt(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 create_wt_layout(self, tab_config: Dict[str, tuple[str, str]], output_dir: Optional[str] = None, session_name: Optional[str] = None) -> str:
         WTLayoutGenerator._validate_tab_config(tab_config)
         logger.info(f"Creating Windows Terminal layout with {len(tab_config)} tabs")
-        
+
         # Store session name and entire tab config for status checking
         self.session_name = session_name or "default"
         self.tab_config = tab_config.copy()
-        
+
         # Generate Windows Terminal command
         wt_command = self._generate_wt_command_string(tab_config, self.session_name)
-        
+
         try:
             random_suffix = WTLayoutGenerator._generate_random_suffix()
             if output_dir:
@@ -108,42 +110,44 @@ class WTLayoutGenerator:
                 # Use the predefined TMP_LAYOUT_DIR for temporary files
                 TMP_LAYOUT_DIR.mkdir(parents=True, exist_ok=True)
                 script_file = TMP_LAYOUT_DIR / f"wt_layout_{self.session_name}_{random_suffix}.bat"
-            
+
             # Create batch script
-            with open(script_file, 'w', encoding='utf-8') as f:
-                f.write("@echo off\n")
-                f.write(f"REM Windows Terminal layout for {self.session_name}\n")
-                f.write(f"{wt_command}\n")
-            
+            text = f"""@echo off
+REM Windows Terminal layout for {self.session_name}
+{wt_command}
+"""
+            script_file.write_text(text, encoding="utf-8")
+
             # Also create PowerShell script for better command handling
-            ps1_file = script_file.with_suffix('.ps1')
-            with open(ps1_file, 'w', encoding='utf-8') as f:
-                f.write(f"# Windows Terminal layout for {self.session_name}\n")
-                f.write(f"# Generated with random suffix: {random_suffix}\n")
-                f.write(f"{wt_command}\n")
-            
+            ps1_file = script_file.with_suffix(".ps1")
+            text = f"""# Windows Terminal layout for {self.session_name}
+# Generated with random suffix: {random_suffix}
+{wt_command}
+"""
+            ps1_file.write_text(text, encoding="utf-8")
+
             self.script_path = str(script_file.absolute())
             logger.info(f"Windows Terminal script file created: {self.script_path}")
             return self.script_path
         except OSError as e:
             logger.error(f"Failed to create script file: {e}")
             raise
-    
+
     def _generate_wt_command_string(self, tab_config: Dict[str, tuple[str, str]], window_name: str) -> str:
         """Generate complete Windows Terminal command string."""
         # Start building the wt command
         wt_parts = ["wt"]
-        
+
         # Add 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:
@@ -154,123 +158,81 @@ 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 get_wt_layout_preview(self, tab_config: Dict[str, tuple[str, str]]) -> str:
         """Generate preview of the Windows Terminal command that would be created."""
         WTLayoutGenerator._validate_tab_config(tab_config)
         return self._generate_wt_command_string(tab_config, "preview")
-    
+
     def check_all_commands_status(self) -> Dict[str, Dict[str, Any]]:
         if not self.tab_config:
             logger.warning("No tab config tracked. Make sure to create a layout first.")
             return {}
-        
+
         status_report = {}
         for tab_name in self.tab_config:
             status_report[tab_name] = WTLayoutGenerator.check_command_status(tab_name, self.tab_config)
-        
+
         return status_report
 
     @staticmethod
     def check_wt_session_status(session_name: str) -> Dict[str, Any]:
         try:
             # Check for Windows Terminal processes
-            wt_check_cmd = [
-                "powershell", "-Command",
-                "Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue | "
-                "Select-Object Id, ProcessName, StartTime, MainWindowTitle | "
-                "ConvertTo-Json -Depth 2"
-            ]
-            
+            wt_check_cmd = ["powershell", "-Command", "Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, StartTime, MainWindowTitle | ConvertTo-Json -Depth 2"]
+
             result = subprocess.run(wt_check_cmd, capture_output=True, text=True, 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 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": session_name,
-                            "all_windows": processes,
-                            "session_windows": session_windows
-                        }
+
+                        return {"wt_running": True, "session_exists": len(session_windows) > 0, "session_name": session_name, "all_windows": processes, "session_windows": session_windows}
                     except Exception as e:
-                        return {
-                            "wt_running": True,
-                            "session_exists": False,
-                            "error": f"Failed to parse process info: {e}",
-                            "session_name": session_name
-                        }
+                        return {"wt_running": True, "session_exists": False, "error": f"Failed to parse process info: {e}", "session_name": session_name}
                 else:
-                    return {
-                        "wt_running": False,
-                        "session_exists": False,
-                        "session_name": session_name,
-                        "all_windows": []
-                    }
+                    return {"wt_running": False, "session_exists": False, "session_name": session_name, "all_windows": []}
             else:
-                return {
-                    "wt_running": False,
-                    "error": result.stderr,
-                    "session_name": session_name
-                }
-                
+                return {"wt_running": False, "error": result.stderr, "session_name": session_name}
+
         except subprocess.TimeoutExpired:
-            return {
-                "wt_running": False,
-                "error": "Timeout while checking Windows Terminal processes",
-                "session_name": session_name
-            }
+            return {"wt_running": False, "error": "Timeout while checking Windows Terminal processes", "session_name": session_name}
         except FileNotFoundError:
-            return {
-                "wt_running": False,
-                "error": "PowerShell not found in PATH",
-                "session_name": session_name
-            }
+            return {"wt_running": False, "error": "PowerShell not found in PATH", "session_name": session_name}
         except Exception as e:
-            return {
-                "wt_running": False,
-                "error": str(e),
-                "session_name": session_name
-            }
+            return {"wt_running": False, "error": str(e), "session_name": session_name}
 
     @staticmethod
     def check_command_status(tab_name: str, tab_config: Dict[str, tuple[str, str]]) -> Dict[str, Any]:
         """Check if a command is running by looking for processes."""
         if tab_name not in tab_config:
-            return {
-                "status": "unknown",
-                "error": f"Tab '{tab_name}' not found in tracked configuration",
-                "running": False,
-                "pid": None,
-                "command": None
-            }
-        
+            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in tracked configuration", "running": False, "pid": None, "command": None}
+
         _, command = tab_config[tab_name]
-        
+
         try:
             # Create PowerShell script to check for processes
             cmd_parts = [part for part in command.split() if len(part) > 2]
-            primary_cmd = cmd_parts[0] if cmd_parts else ''
-            
+            primary_cmd = cmd_parts[0] if cmd_parts else ""
+
             ps_script = f"""
-$targetCommand = '{command.replace("'", "''")}' 
-$cmdParts = @({', '.join([f"'{part}'" for part in cmd_parts])})
+$targetCommand = '{command.replace("'", "''")}'
+$cmdParts = @({", ".join([f"'{part}'" for part in cmd_parts])})
 $primaryCmd = '{primary_cmd}'
 $currentPid = $PID
 $matchingProcesses = @()
@@ -278,23 +240,23 @@ $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 "") {{
             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 1) {{
                 $procInfo = @{{
                     "pid" = $_.Id
@@ -311,78 +273,44 @@ Get-Process | ForEach-Object {{
     }}
 }}
 """
-            
-            result = subprocess.run(
-                ["powershell", "-Command", ps_script],
-                capture_output=True,
-                text=True,
-                timeout=15
-            )
-            
+
+            result = subprocess.run(["powershell", "-Command", ps_script], capture_output=True, text=True, timeout=15)
+
             if result.returncode == 0:
-                output_lines = [line.strip() for line in result.stdout.strip().split('\n') if line.strip()]
+                output_lines = [line.strip() for line in result.stdout.strip().split("\n") if line.strip()]
                 matching_processes = []
-                
+
                 for line in output_lines:
-                    if line.startswith('{') and line.endswith('}'):
+                    if line.startswith("{") and line.endswith("}"):
                         try:
                             proc_info = json.loads(line)
                             matching_processes.append(proc_info)
                         except json.JSONDecodeError:
                             continue
-                
+
                 if matching_processes:
-                    return {
-                        "status": "running",
-                        "running": True,
-                        "processes": matching_processes,
-                        "command": command,
-                        "tab_name": tab_name
-                    }
+                    return {"status": "running", "running": True, "processes": matching_processes, "command": command, "tab_name": tab_name}
                 else:
-                    return {
-                        "status": "not_running",
-                        "running": False,
-                        "processes": [],
-                        "command": command,
-                        "tab_name": tab_name
-                    }
+                    return {"status": "not_running", "running": False, "processes": [], "command": command, "tab_name": tab_name}
             else:
-                return {
-                    "status": "error", 
-                    "error": f"Command failed: {result.stderr}",
-                    "running": False,
-                    "command": command,
-                    "tab_name": tab_name
-                }
-                
+                return {"status": "error", "error": f"Command failed: {result.stderr}", "running": False, "command": command, "tab_name": tab_name}
+
         except Exception as e:
             logger.error(f"Error checking command status for tab '{tab_name}': {e}")
-            return {
-                "status": "error",
-                "error": str(e),
-                "running": False,
-                "command": command,
-                "tab_name": tab_name
-            }
+            return {"status": "error", "error": str(e), "running": False, "command": command, "tab_name": tab_name}
 
     def get_status_report(self) -> Dict[str, Any]:
         """Get status report for this layout including Windows Terminal and commands."""
         wt_status = WTLayoutGenerator.check_wt_session_status(self.session_name or "default")
         commands_status = self.check_all_commands_status()
-        
+
         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)
-            }
+            "summary": {"total_commands": total_count, "running_commands": running_count, "stopped_commands": total_count - running_count, "session_healthy": wt_status.get("session_exists", False)},
         }
 
     def print_status_report(self) -> None:
@@ -391,11 +319,11 @@ Get-Process | ForEach-Object {{
         wt_session = status["wt_session"]
         commands = status["commands"]
         summary = status["summary"]
-        
+
         print("=" * 80)
         print("🖥️  WINDOWS TERMINAL LAYOUT STATUS REPORT")
         print("=" * 80)
-        
+
         # Windows Terminal session status
         print(f"🪟 Session: {self.session_name}")
         if wt_session.get("wt_running", False):
@@ -410,9 +338,9 @@ Get-Process | ForEach-Object {{
         else:
             error_msg = wt_session.get("error", "Unknown error")
             print(f"❌ Windows Terminal session issue: {error_msg}")
-        
+
         print()
-        
+
         # Commands in this layout
         print(f"📋 COMMANDS ({summary['running_commands']}/{summary['total_commands']} running):")
         for tab_name, cmd_status in commands.items():
@@ -420,16 +348,16 @@ Get-Process | ForEach-Object {{
             cmd_text = cmd_status.get("command", "Unknown")[:50]
             if len(cmd_status.get("command", "")) > 50:
                 cmd_text += "..."
-            
+
             print(f"   {status_icon} {tab_name}: {cmd_text}")
-            
+
             if cmd_status.get("processes"):
                 for proc in cmd_status["processes"][:2]:  # Show first 2 processes
                     pid = proc.get("pid", "Unknown")
                     name = proc.get("name", "Unknown")
                     print(f"      └─ PID {pid}: {name}")
         print()
-        
+
         print("=" * 80)
 
 
@@ -437,15 +365,16 @@ def create_wt_layout(tab_config: Dict[str, tuple[str, str]], output_dir: Optiona
     generator = WTLayoutGenerator()
     return generator.create_wt_layout(tab_config, output_dir)
 
+
 def run_wt_layout(tab_config: Dict[str, tuple[str, str]], session_name: Optional[str] = None) -> str:
     """Create and run a Windows Terminal layout."""
     generator = WTLayoutGenerator()
     script_path = generator.create_wt_layout(tab_config, session_name=session_name)
-    
+
     # Execute the script
-    cmd = f"powershell -ExecutionPolicy Bypass -File \"{script_path}\""
+    cmd = f'powershell -ExecutionPolicy Bypass -File "{script_path}"'
     result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
-    
+
     if result.returncode == 0:
         print(f"Windows Terminal layout is running @ {session_name}")
         return script_path
@@ -453,10 +382,11 @@ def run_wt_layout(tab_config: Dict[str, tuple[str, str]], session_name: Optional
         logger.error(f"Failed to run Windows Terminal layout: {result.stderr}")
         raise RuntimeError(f"Failed to run layout: {result.stderr}")
 
+
 def run_command_in_wt_tab(command: str, tab_name: str, cwd: Optional[str]) -> str:
     """Create a command to run in a new Windows Terminal tab."""
-    cwd_part = f"-d \"{cwd}\"" if cwd else ""
-    
+    cwd_part = f'-d "{cwd}"' if cwd else ""
+
     return f"""
 echo "Creating new Windows Terminal tab: {tab_name}"
 wt new-tab --title "{tab_name}" {cwd_part} "{command}"
@@ -465,30 +395,28 @@ wt new-tab --title "{tab_name}" {cwd_part} "{command}"
 
 if __name__ == "__main__":
     # Example usage
-    sample_tabs = {
-        "Frontend": ("~/code", "btm"),
-        "Monitor": ("~", "lf"),
-    }
-    
+    sample_tabs = {"Frontend": ("~/code", "btm"), "Monitor": ("~", "lf")}
+
     try:
         # Create layout using the generator
         generator = WTLayoutGenerator()
         script_path = generator.create_wt_layout(sample_tabs, session_name="test_session")
         print(f"✅ Windows Terminal layout created: {script_path}")
-        
+
         # Show preview
         preview = generator.get_wt_layout_preview(sample_tabs)
         print(f"\n📋 Command Preview:\n{preview}")
-        
+
         # Check status (won't find anything since we haven't run it)
         print("\n🔍 Current status:")
         generator.print_status_report()
-        
+
         # Show how to run the layout
         print("\n▶️  To run this layout, execute:")
-        print(f"   powershell -ExecutionPolicy Bypass -File \"{script_path}\"")
-        
+        print(f'   powershell -ExecutionPolicy Bypass -File "{script_path}"')
+
     except Exception as e:
         print(f"❌ Error: {e}")
         import traceback
-        traceback.print_exc() 
+
+        traceback.print_exc()