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

machineconfig/cluster/sessions_managers/wt_utils/layout_generator.py

@@ -3,6 +3,7 @@
 Windows Terminal layout generation utilities for creating wt command strings.
 Based on Windows Terminal documentation: https://learn.microsoft.com/en-us/windows/terminal/command-line-arguments
 """
+
 import shlex
 import random
 import string
@@ -19,7 +20,7 @@ class WTLayoutGenerator:
     @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))
+        return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
 
     @staticmethod
     def parse_command(command: str) -> Tuple[str, List[str]]:
@@ -40,7 +41,7 @@ class WTLayoutGenerator:
         # Windows Terminal uses PowerShell-style escaping
         # Escape special characters that might cause issues
         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
 
@@ -50,9 +51,9 @@ class WTLayoutGenerator:
         cmd, args = WTLayoutGenerator.parse_command(command)
 
         # 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
@@ -89,10 +90,7 @@ class WTLayoutGenerator:
             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,
-                           maximized: bool = False,
-                           focus: bool = True) -> str:
+    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)
 
@@ -129,9 +127,7 @@ class WTLayoutGenerator:
 
         return " ".join(wt_parts)
 
-    def create_wt_script(self, tab_config: Dict[str, Tuple[str, str]],
-                        output_dir: Path, session_name: str,
-                        window_name: str | None = None) -> 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)
 
@@ -168,8 +164,7 @@ REM Windows Terminal layout for {session_name}
             logger.error(f"Failed to create script file: {e}")
             raise
 
-    def generate_split_pane_command(self, tab_config: Dict[str, Tuple[str, str]],
-                                   window_name: str | None = None) -> 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)
 
@@ -195,4 +190,4 @@ REM Windows Terminal layout for {session_name}
             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

@@ -3,6 +3,7 @@
 Process monitoring and status checking utilities for Windows Terminal commands.
 Adapted from zellij process monitor but focused on Windows processes.
 """
+
 import json
 import logging
 import subprocess
@@ -27,29 +28,16 @@ class WTProcessMonitor:
     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 check_command_status(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]],
-                           use_verification: bool = True) -> Dict[str, Any]:
+    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:
-            return {
-                "status": "unknown",
-                "error": f"Tab '{tab_name}' not found in tracked configuration",
-                "running": False,
-                "pid": None,
-                "command": None,
-                "location": self.location_name
-            }
+            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in tracked configuration", "running": False, "pid": None, "command": None, "location": self.location_name}
 
         # Use the verified method by default for more accurate results
         if use_verification:
@@ -68,11 +56,11 @@ class WTProcessMonitor:
             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()]
+                    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)
@@ -80,64 +68,29 @@ class WTProcessMonitor:
                                 continue
 
                     if matching_processes:
-                        return {
-                            "status": "running",
-                            "running": True,
-                            "processes": matching_processes,
-                            "command": command,
-                            "tab_name": tab_name,
-                            "location": self.location_name
-                        }
+                        return {"status": "running", "running": True, "processes": matching_processes, "command": command, "tab_name": tab_name, "location": self.location_name}
                     else:
-                        return {
-                            "status": "not_running",
-                            "running": False,
-                            "processes": [],
-                            "command": command,
-                            "tab_name": tab_name,
-                            "location": self.location_name
-                        }
+                        return {"status": "not_running", "running": False, "processes": [], "command": command, "tab_name": tab_name, "location": self.location_name}
                 except Exception as e:
                     logger.error(f"Failed to parse process check output: {e}")
-                    return {
-                        "status": "error",
-                        "error": f"Failed to parse output: {e}",
-                        "running": False,
-                        "command": command,
-                        "tab_name": tab_name,
-                        "location": self.location_name
-                    }
+                    return {"status": "error", "error": f"Failed to parse output: {e}", "running": False, "command": command, "tab_name": tab_name, "location": self.location_name}
             else:
-                return {
-                    "status": "error",
-                    "error": f"Command failed: {result.stderr}",
-                    "running": False,
-                    "command": command,
-                    "tab_name": tab_name,
-                    "location": self.location_name
-                }
+                return {"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 {
-                "status": "error",
-                "error": str(e),
-                "running": False,
-                "command": command,
-                "tab_name": tab_name,
-                "location": self.location_name
-            }
+            return {"status": "error", "error": str(e), "running": False, "command": command, "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 ''
+        primary_cmd = cmd_parts[0] if cmd_parts else ""
 
         return f"""
 $targetCommand = '{escaped_command}'
-$cmdParts = @({', '.join([f"'{part}'" for part in cmd_parts])})
+$cmdParts = @({", ".join([f"'{part}'" for part in cmd_parts])})
 $primaryCmd = '{primary_cmd}'
 $currentPid = $PID
 
@@ -182,13 +135,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:
-            return {
-                "status": "unknown",
-                "error": f"Tab '{tab_name}' not found in tracked configuration",
-                "running": False,
-                "command": None,
-                "location": self.location_name
-            }
+            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in tracked configuration", "running": False, "command": None, "location": self.location_name}
 
         _, command = tab_config[tab_name]
 
@@ -204,9 +151,9 @@ Get-Process | ForEach-Object {{
             if result.returncode == 0:
                 try:
                     # Parse the output to extract JSON
-                    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()]
                     for line in output_lines:
-                        if line.startswith('{') and '"processes"' in line:
+                        if line.startswith("{") and '"processes"' in line:
                             check_result = json.loads(line)
                             matching_processes = check_result.get("processes", [])
 
@@ -218,62 +165,32 @@ Get-Process | ForEach-Object {{
                                 "tab_name": tab_name,
                                 "location": self.location_name,
                                 "check_timestamp": check_timestamp,
-                                "method": "force_fresh_check"
+                                "method": "force_fresh_check",
                             }
 
                     # Fallback if no JSON found
-                    return {
-                        "status": "not_running",
-                        "running": False,
-                        "processes": [],
-                        "command": command,
-                        "tab_name": tab_name,
-                        "location": self.location_name,
-                        "raw_output": result.stdout
-                    }
+                    return {"status": "not_running", "running": False, "processes": [], "command": command, "tab_name": tab_name, "location": self.location_name, "raw_output": result.stdout}
                 except json.JSONDecodeError as e:
                     logger.error(f"Failed to parse fresh check output: {e}")
-                    return {
-                        "status": "error",
-                        "error": f"Failed to parse output: {e}",
-                        "running": False,
-                        "command": command,
-                        "tab_name": tab_name,
-                        "location": self.location_name,
-                        "raw_output": result.stdout
-                    }
+                    return {"status": "error", "error": f"Failed to parse output: {e}", "running": False, "command": command, "tab_name": tab_name, "location": self.location_name, "raw_output": result.stdout}
             else:
-                return {
-                    "status": "error",
-                    "error": f"Command failed: {result.stderr}",
-                    "running": False,
-                    "command": command,
-                    "tab_name": tab_name,
-                    "location": self.location_name
-                }
+                return {"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 {
-                "status": "error",
-                "error": str(e),
-                "running": False,
-                "command": command,
-                "tab_name": tab_name,
-                "location": self.location_name
-            }
+            return {"status": "error", "error": str(e), "running": False, "command": command, "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 ''
+        primary_cmd = cmd_parts[0] if cmd_parts else ""
 
         return f"""
 Start-Sleep -Milliseconds 100
 
 $targetCommand = '{escaped_command}'
-$cmdParts = @({', '.join([f"'{part}'" for part in cmd_parts])})
+$cmdParts = @({", ".join([f"'{part}'" for part in cmd_parts])})
 $primaryCmd = '{primary_cmd}'
 $currentPid = $PID
 $checkTime = Get-Date
@@ -391,28 +308,11 @@ ConvertTo-Json -Depth 2
             if result.returncode == 0 and result.stdout.strip():
                 try:
                     wt_processes = json.loads(result.stdout)
-                    return {
-                        "success": True,
-                        "windows": wt_processes if isinstance(wt_processes, list) else [wt_processes],
-                        "location": self.location_name
-                    }
+                    return {"success": True, "windows": wt_processes if isinstance(wt_processes, list) else [wt_processes], "location": self.location_name}
                 except json.JSONDecodeError:
-                    return {
-                        "success": False,
-                        "error": "Failed to parse Windows Terminal process info",
-                        "location": self.location_name
-                    }
+                    return {"success": False, "error": "Failed to parse Windows Terminal process info", "location": self.location_name}
             else:
-                return {
-                    "success": True,
-                    "windows": [],
-                    "message": "No Windows Terminal processes found",
-                    "location": self.location_name
-                }
+                return {"success": True, "windows": [], "message": "No Windows Terminal processes found", "location": self.location_name}
         except Exception as e:
             logger.error(f"Failed to get Windows Terminal windows: {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/remote_executor.py

@@ -3,6 +3,7 @@
 Remote command execution utilities for SSH operations with Windows Terminal.
 Adapted from zellij remote executor but focused on Windows Terminal commands.
 """
+
 import subprocess
 import logging
 from typing import Dict, Any, Optional, List
@@ -22,16 +23,11 @@ class WTRemoteExecutor:
         if shell == "powershell":
             # Wrap command in PowerShell invocation if needed
             if not command.startswith("powershell"):
-                command = f"powershell -Command \"{command}\""
+                command = f'powershell -Command "{command}"'
 
         ssh_cmd = ["ssh", self.remote_name, command]
         try:
-            result = subprocess.run(
-                ssh_cmd,
-                capture_output=True,
-                text=True,
-                timeout=timeout
-            )
+            result = subprocess.run(ssh_cmd, capture_output=True, text=True, timeout=timeout)
             return result
         except subprocess.TimeoutExpired:
             logger.error(f"SSH command timed out after {timeout}s: {command}")
@@ -93,19 +89,10 @@ class WTRemoteExecutor:
 
             wt_available = self.check_wt_available()
 
-            return {
-                "windows_info": result.stdout if result.returncode == 0 else "Unknown",
-                "wt_available": wt_available,
-                "remote_name": self.remote_name
-            }
+            return {"windows_info": result.stdout if result.returncode == 0 else "Unknown", "wt_available": wt_available, "remote_name": self.remote_name}
         except Exception as e:
             logger.error(f"Failed to get remote Windows info: {e}")
-            return {
-                "windows_info": "Error getting info",
-                "wt_available": False,
-                "remote_name": self.remote_name,
-                "error": str(e)
-            }
+            return {"windows_info": "Error getting info", "wt_available": False, "remote_name": self.remote_name, "error": str(e)}
 
     def run_wt_command(self, wt_command: str, detached: bool = True) -> subprocess.CompletedProcess[str]:
         """Run a Windows Terminal command on the remote machine."""
@@ -130,24 +117,12 @@ class WTRemoteExecutor:
             result = self.run_command(ps_command, timeout=15)
 
             if result.returncode == 0:
-                return {
-                    "success": True,
-                    "processes": result.stdout,
-                    "remote": self.remote_name
-                }
+                return {"success": True, "processes": result.stdout, "remote": self.remote_name}
             else:
-                return {
-                    "success": False,
-                    "error": result.stderr,
-                    "remote": self.remote_name
-                }
+                return {"success": False, "error": result.stderr, "remote": self.remote_name}
         except Exception as e:
             logger.error(f"Failed to list Windows Terminal processes: {e}")
-            return {
-                "success": False,
-                "error": str(e),
-                "remote": self.remote_name
-            }
+            return {"success": False, "error": str(e), "remote": self.remote_name}
 
     def kill_wt_processes(self, process_ids: Optional[List[Any]] = None) -> Dict[str, Any]:
         """Kill Windows Terminal processes on the remote machine."""
@@ -161,15 +136,7 @@ class WTRemoteExecutor:
 
             result = self.run_command(kill_cmd, timeout=10)
 
-            return {
-                "success": result.returncode == 0,
-                "message": "Processes killed" if result.returncode == 0 else result.stderr,
-                "remote": self.remote_name
-            }
+            return {"success": result.returncode == 0, "message": "Processes killed" if result.returncode == 0 else result.stderr, "remote": self.remote_name}
         except Exception as e:
             logger.error(f"Failed to kill Windows Terminal processes: {e}")
-            return {
-                "success": False,
-                "error": str(e),
-                "remote": self.remote_name
-            }
+            return {"success": False, "error": str(e), "remote": self.remote_name}

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
@@ -14,8 +15,7 @@ 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"
@@ -29,12 +29,7 @@ class WTSessionManager:
     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")
@@ -80,6 +75,7 @@ ConvertTo-Json -Depth 2
                 if output and output != "":
                     try:
                         import json
+
                         processes = json.loads(output)
                         if not isinstance(processes, list):
                             processes = [processes]
@@ -91,49 +87,19 @@ ConvertTo-Json -Depth 2
                             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:
@@ -164,29 +130,14 @@ ConvertTo-Json -Depth 2
 
             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."""
@@ -228,24 +179,13 @@ ConvertTo-Json -Depth 2
             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
@@ -264,22 +204,11 @@ ConvertTo-Json -Depth 2
             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."""
@@ -287,14 +216,6 @@ ConvertTo-Json -Depth 2
             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}