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

machineconfig/cluster/sessions_managers/wt_remote.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-from typing import Dict, Tuple, Optional, List, Any
+from typing import Dict, Optional, List, Any
 from pathlib import Path
 import logging
 import json
@@ -11,6 +11,7 @@ from machineconfig.cluster.sessions_managers.wt_utils.layout_generator import WT
 from machineconfig.cluster.sessions_managers.wt_utils.process_monitor import WTProcessMonitor
 from machineconfig.cluster.sessions_managers.wt_utils.session_manager import WTSessionManager
 from machineconfig.cluster.sessions_managers.wt_utils.status_reporter import WTStatusReporter
+from machineconfig.cluster.sessions_managers.layout_types import TabConfig
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -21,7 +22,7 @@ class WTRemoteLayoutGenerator:
     def __init__(self, remote_name: str, session_name_prefix: str):
         self.remote_name = remote_name
         self.session_name = session_name_prefix + "_" + WTLayoutGenerator.generate_random_suffix()
-        self.tab_config: Dict[str, Tuple[str, str]] = {}
+        self.tabs: List[TabConfig] = []
         self.script_path: Optional[str] = None
 
         # Initialize modular components
@@ -31,77 +32,22 @@ class WTRemoteLayoutGenerator:
         self.session_manager = WTSessionManager(self.remote_executor, self.session_name, TMP_LAYOUT_DIR)
         self.status_reporter = WTStatusReporter(self.process_monitor, self.session_manager)
 
-    def copy_script_to_remote(self, local_script_file: Path, random_suffix: str) -> str:
-        return self.session_manager.copy_script_to_remote(local_script_file, random_suffix)
+    # Tabs are stored and used as List[TabConfig]; no legacy dict compatibility
 
-    def create_wt_layout(self, tab_config: Dict[str, Tuple[str, str]], output_dir: Optional[str] = None) -> str:
-        logger.info(f"Creating Windows Terminal layout with {len(tab_config)} tabs for remote '{self.remote_name}'")
-        self.tab_config = tab_config.copy()
+    def create_wt_layout(self, tabs: List[TabConfig], output_dir: Optional[str] = None) -> str:
+        logger.info(f"Creating Windows Terminal layout with {len(tabs)} tabs for remote '{self.remote_name}'")
+        self.tabs = tabs
         if output_dir:
             output_path = Path(output_dir)
         else:
             output_path = TMP_LAYOUT_DIR
-        self.script_path = self.layout_generator.create_wt_script(tab_config, output_path, self.session_name)
+        self.script_path = self.layout_generator.create_wt_script(self.tabs, output_path, self.session_name)
         return self.script_path
 
-    def get_layout_preview(self, tab_config: Dict[str, Tuple[str, str]]) -> str:
-        return self.layout_generator.generate_wt_command(tab_config)
-
-    def check_command_status(self, tab_name: str, use_verification: bool = True) -> Dict[str, Any]:
-        return self.process_monitor.check_command_status(tab_name, self.tab_config, use_verification)
-
-    def check_all_commands_status(self) -> Dict[str, Dict[str, Any]]:
-        return self.process_monitor.check_all_commands_status(self.tab_config)
-
-    def check_wt_session_status(self) -> Dict[str, Any]:
-        return self.session_manager.check_wt_session_status()
-
-    def get_comprehensive_status(self) -> Dict[str, Any]:
-        return self.status_reporter.get_comprehensive_status(self.tab_config)
-
-    def print_status_report(self) -> None:
-        self.status_reporter.print_status_report(self.tab_config)
-
-    def start_wt_session(self, script_file_path: Optional[str] = None) -> Dict[str, Any]:
-        return self.session_manager.start_wt_session(script_file_path or self.script_path)
-
-    def attach_to_session(self) -> None:
-        self.session_manager.attach_to_session()
-
     # Legacy methods for backward compatibility
-    def force_fresh_process_check(self, tab_name: str) -> Dict[str, Any]:
-        return self.process_monitor.force_fresh_process_check(tab_name, self.tab_config)
-
-    def verify_process_alive(self, pid: int) -> bool:
-        return self.process_monitor.verify_process_alive(pid)
-
-    def get_verified_process_status(self, tab_name: str) -> Dict[str, Any]:
-        return self.process_monitor.get_verified_process_status(tab_name, self.tab_config)
-
-    # Static methods for backward compatibility
-    @staticmethod
-    def run_remote_command(remote_name: str, command: str, timeout: int = 30):
-        executor = WTRemoteExecutor(remote_name)
-        return executor.run_command(command, timeout)
-
-    def kill_wt_session(self, force: bool = True) -> Dict[str, Any]:
-        """Kill Windows Terminal processes on the remote machine."""
-        return self.session_manager.kill_wt_session(force)
-
-    def create_new_tab(self, tab_name: str, cwd: str, command: str) -> Dict[str, Any]:
-        """Create a new tab in the Windows Terminal session."""
-        return self.session_manager.create_new_tab(tab_name, cwd, command, self.session_name)
-
-    def get_wt_version(self) -> Dict[str, Any]:
-        """Get Windows Terminal version information on the remote machine."""
-        return self.session_manager.get_wt_version()
-
-    def get_remote_windows_info(self) -> Dict[str, Any]:
-        """Get information about the remote Windows system."""
-        return self.remote_executor.get_remote_windows_info()
 
     def to_dict(self) -> Dict[str, Any]:
-        return {"remote_name": self.remote_name, "session_name": self.session_name, "tab_config": self.tab_config, "script_path": self.script_path, "created_at": datetime.now().isoformat(), "class_name": self.__class__.__name__}
+        return {"remote_name": self.remote_name, "session_name": self.session_name, "tabs": self.tabs, "script_path": self.script_path, "created_at": datetime.now().isoformat(), "class_name": self.__class__.__name__}
 
     def to_json(self, file_path: Optional[str] = None) -> str:
         # Generate file path if not provided
@@ -160,7 +106,11 @@ class WTRemoteLayoutGenerator:
 
         # Restore state
         instance.session_name = data["session_name"]
-        instance.tab_config = data["tab_config"]
+        # New schema only
+        if "tabs" in data:
+            instance.tabs = data["tabs"]
+        else:
+            instance.tabs = []
         instance.script_path = data["script_path"]
 
         logger.info(f"✅ Loaded WTRemoteLayoutGenerator from: {file_path}")
@@ -179,43 +129,15 @@ class WTRemoteLayoutGenerator:
         json_files = [f.name for f in dir_path.glob("*.json")]
         return sorted(json_files)
 
-    def check_wt_available(self) -> bool:
-        """Check if Windows Terminal is available on the remote machine."""
-        return self.remote_executor.check_wt_available()
-
-    def list_wt_processes(self) -> Dict[str, Any]:
-        """List Windows Terminal processes on the remote machine."""
-        return self.remote_executor.list_wt_processes()
-
-    def kill_wt_processes(self, process_ids: Optional[List[Any]] = None) -> Dict[str, Any]:
-        """Kill Windows Terminal processes on the remote machine."""
-        return self.remote_executor.kill_wt_processes(process_ids)
-
-    def get_windows_terminal_overview(self) -> Dict[str, Any]:
-        """Get overview of Windows Terminal on the remote machine."""
-        return self.status_reporter.get_windows_terminal_overview()
-
-    def print_windows_terminal_overview(self) -> None:
-        """Print overview of Windows Terminal on the remote machine."""
-        self.status_reporter.print_windows_terminal_overview()
-
-    def generate_status_summary(self) -> Dict[str, Any]:
-        """Generate a concise status summary for monitoring."""
-        return self.status_reporter.generate_status_summary(self.tab_config)
-
-    def check_tab_specific_status(self, tab_name: str) -> Dict[str, Any]:
-        """Get detailed status for a specific tab."""
-        return self.status_reporter.check_tab_specific_status(tab_name, self.tab_config)
-
 
 if __name__ == "__main__":
     # Example usage
-    sample_tabs = {
-        "🤖Bot1": ("~/code/bytesense/bithence", "python bot1.py --create_new_bot True"),
-        "🤖Bot2": ("~/code/bytesense/bithence", "python bot2.py --create_new_bot True"),
-        "📊Monitor": ("~", "Get-Process | Sort-Object CPU -Descending | Select-Object -First 10"),
-        "📝Logs": ("C:/logs", "Get-Content app.log -Wait"),
-    }
+    sample_tabs: List[TabConfig] = [
+        {"tabName": "🤖Bot1", "startDir": "~/code/bytesense/bithence", "command": "python bot1.py --create_new_bot True"},
+        {"tabName": "🤖Bot2", "startDir": "~/code/bytesense/bithence", "command": "python bot2.py --create_new_bot True"},
+        {"tabName": "📊Monitor", "startDir": "~", "command": "Get-Process | Sort-Object CPU -Descending | Select-Object -First 10"},
+        {"tabName": "📝Logs", "startDir": "C:/logs", "command": "Get-Content app.log -Wait"},
+    ]
 
     # Replace 'myserver' with an actual SSH config alias for a Windows machine
     remote_name = "myserver"  # This should be in ~/.ssh/config
@@ -228,11 +150,11 @@ if __name__ == "__main__":
         print(f"✅ Remote layout created successfully: {script_path}")
 
         # Check if Windows Terminal is available on remote
-        wt_available = generator.check_wt_available()
+        wt_available = generator.remote_executor.check_wt_available()
         print(f"🖥️  Windows Terminal available on {remote_name}: {'✅' if wt_available else '❌'}")
 
         # Get remote Windows info
-        windows_info = generator.get_remote_windows_info()
+        windows_info = generator.remote_executor.get_remote_windows_info()
         if windows_info.get("wt_available"):
             print(f"📦 Remote system info: {windows_info.get('windows_info', 'Unknown')}")
 
@@ -248,31 +170,31 @@ if __name__ == "__main__":
         # Demonstrate loading (using the full path)
         loaded_generator = WTRemoteLayoutGenerator.from_json(saved_path)
         print(f"✅ Session loaded successfully: {loaded_generator.session_name}")
-        print(f"📊 Loaded tabs: {list(loaded_generator.tab_config.keys())}")
+        print(f"📊 Loaded tabs: {[tab['tabName'] for tab in loaded_generator.tabs]}")
 
         # Show command preview
-        preview = generator.get_layout_preview(sample_tabs)
+        preview = generator.layout_generator.generate_wt_command(sample_tabs)
         print(f"\n📋 Command Preview:\n{preview}")
 
         # Demonstrate status checking
         print(f"\n🔍 Checking command status on remote '{remote_name}':")
-        generator.print_status_report()
+        generator.status_reporter.print_status_report(generator.tabs)
 
         # Show Windows Terminal overview
         print("\n🖥️  Windows Terminal Overview:")
-        generator.print_windows_terminal_overview()
+        generator.status_reporter.print_windows_terminal_overview()
 
         # Start the session (uncomment to actually start)
-        # start_result = generator.start_wt_session()
+        # start_result = generator.session_manager.start_wt_session(generator.script_path)
         # print(f"Session start result: {start_result}")
 
         # Attach to session (uncomment to attach)
-        # generator.attach_to_session()
+        # generator.session_manager.attach_to_session()
 
         print("\n▶️  To start this session, run:")
-        print("   generator.start_wt_session()")
+        print("   generator.session_manager.start_wt_session(generator.script_path)")
         print("\n📎 To attach to this session, run:")
-        print("   generator.attach_to_session()")
+        print("   generator.session_manager.attach_to_session()")
 
     except Exception as e:
         print(f"❌ Error: {e}")

machineconfig/cluster/sessions_managers/wt_remote_manager.py

@@ -7,6 +7,7 @@ from typing import Optional, Any
 from machineconfig.utils.utils5 import Scheduler
 from machineconfig.cluster.sessions_managers.wt_local import run_command_in_wt_tab
 from machineconfig.cluster.sessions_managers.wt_remote import WTRemoteLayoutGenerator
+from machineconfig.cluster.sessions_managers.layout_types import TabConfig
 
 TMP_SERIALIZATION_DIR = Path.home().joinpath("tmp_results", "session_manager", "wt", "remote_manager")
 
@@ -21,7 +22,9 @@ class WTSessionManager:
         self.managers: list[WTRemoteLayoutGenerator] = []
         for machine, tab_config in machine2wt_tabs.items():
             an_m = WTRemoteLayoutGenerator(remote_name=machine, session_name_prefix=self.session_name_prefix)
-            an_m.create_wt_layout(tab_config=tab_config)
+            # Convert legacy dict[str, tuple[str,str]] to List[TabConfig]
+            tabs: list[TabConfig] = [{"tabName": name, "startDir": cwd, "command": cmd} for name, (cwd, cmd) in tab_config.items()]
+            an_m.create_wt_layout(tabs=tabs)
             self.managers.append(an_m)
 
     def ssh_to_all_machines(self) -> str:
@@ -40,14 +43,14 @@ class WTSessionManager:
 
     def kill_all_sessions(self) -> None:
         for an_m in self.managers:
-            WTRemoteLayoutGenerator.run_remote_command(remote_name=an_m.remote_name, command="powershell -Command \"Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue | Stop-Process -Force\"")
+            an_m.remote_executor.run_command("powershell -Command \"Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue | Stop-Process -Force\"")
 
     def run_monitoring_routine(self, wait_ms: int = 60000) -> None:
         def routine(scheduler: Scheduler):
             if scheduler.cycle % 2 == 0:
                 statuses = []
                 for _idx, an_m in enumerate(self.managers):
-                    a_status = an_m.check_all_commands_status()
+                    a_status = an_m.process_monitor.check_all_commands_status(an_m.tabs)
                     statuses.append(a_status)
                 keys = []
                 for item in statuses:
@@ -72,7 +75,7 @@ class WTSessionManager:
             else:
                 statuses = []
                 for _idx, an_m in enumerate(self.managers):
-                    a_status = an_m.check_wt_session_status()
+                    a_status = an_m.session_manager.check_wt_session_status()
                     statuses.append(a_status)
 
                 # Print statuses
@@ -188,7 +191,7 @@ class WTSessionManager:
                 remote_name = manager.remote_name
 
                 # Start the Windows Terminal session on the remote machine
-                start_result = manager.start_wt_session()
+                start_result = manager.session_manager.start_wt_session(manager.script_path)
 
                 results[f"{remote_name}:{session_name}"] = start_result
 
@@ -212,10 +215,10 @@ class WTSessionManager:
 
             try:
                 # Get Windows Terminal session status
-                wt_status = manager.check_wt_session_status()
+                wt_status = manager.session_manager.check_wt_session_status()
 
                 # Get commands status for this session
-                commands_status = manager.check_all_commands_status()
+                commands_status = manager.process_monitor.check_all_commands_status(manager.tabs)
 
                 # Calculate summary for this session
                 running_count = sum(1 for status in commands_status.values() if status.get("running", False))
@@ -330,15 +333,15 @@ class WTSessionManager:
                 remote_name = manager.remote_name
 
                 # Get remote Windows info
-                windows_info = manager.get_remote_windows_info()
+                windows_info = manager.remote_executor.get_remote_windows_info()
 
                 # Get Windows Terminal processes
-                wt_processes = manager.list_wt_processes()
+                wt_processes = manager.remote_executor.list_wt_processes()
 
                 # Get Windows Terminal version
-                wt_version = manager.get_wt_version()
+                wt_version = manager.session_manager.get_wt_version()
 
-                overview[remote_name] = {"windows_info": windows_info, "wt_processes": wt_processes, "wt_version": wt_version, "session_name": manager.session_name, "tab_count": len(manager.tab_config)}
+                overview[remote_name] = {"windows_info": windows_info, "wt_processes": wt_processes, "wt_version": wt_version, "session_name": manager.session_name, "tab_count": len(manager.tabs)}
 
             except Exception as e:
                 overview[manager.remote_name] = {"error": str(e), "session_name": manager.session_name}

machineconfig/cluster/sessions_managers/wt_utils/layout_generator.py

@@ -7,10 +7,13 @@ Based on Windows Terminal documentation: https://learn.microsoft.com/en-us/windo
 import shlex
 import random
 import string
-from typing import Dict, List, Tuple
+from typing import List, Tuple
 from pathlib import Path
 import logging
 
+from machineconfig.cluster.sessions_managers.layout_types import TabConfig
+
+
 logger = logging.getLogger(__name__)
 
 
@@ -78,21 +81,21 @@ class WTLayoutGenerator:
         return " ".join(tab_parts)
 
     @staticmethod
-    def validate_tab_config(tab_config: Dict[str, Tuple[str, str]]) -> None:
+    def validate_tab_config(tabs: List[TabConfig]) -> None:
         """Validate tab configuration format and content."""
-        if not tab_config:
+        if not tabs:
             raise ValueError("Tab configuration cannot be empty")
-        for tab_name, (cwd, command) in tab_config.items():
-            if not tab_name.strip():
-                raise ValueError(f"Invalid tab name: {tab_name}")
-            if not command.strip():
-                raise ValueError(f"Invalid command for tab '{tab_name}': {command}")
-            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:
+        for tab in tabs:
+            if not tab["tabName"].strip():
+                raise ValueError(f"Invalid tab name: {tab['tabName']}")
+            if not tab["command"].strip():
+                raise ValueError(f"Invalid command for tab '{tab['tabName']}': {tab['command']}")
+            if not tab["startDir"].strip():
+                raise ValueError(f"Invalid startDir for tab '{tab['tabName']}': {tab['startDir']}")
+
+    def generate_wt_command(self, tabs: List[TabConfig], window_name: str | None = None, maximized: bool = False, focus: bool = True) -> str:
         """Generate complete Windows Terminal command string."""
-        self.validate_tab_config(tab_config)
+        self.validate_tab_config(tabs)
 
         # Start building the wt command
         wt_parts = ["wt"]
@@ -109,9 +112,9 @@ class WTLayoutGenerator:
 
         # Add tabs
         tab_commands = []
-        for i, (tab_name, (cwd, command)) in enumerate(tab_config.items()):
+        for i, tab in enumerate(tabs):
             is_first = i == 0
-            tab_cmd = self.create_tab_command(tab_name, cwd, command, is_first)
+            tab_cmd = self.create_tab_command(tab["tabName"], tab["startDir"], tab["command"], is_first)
             tab_commands.append(tab_cmd)
 
         # Join all parts with semicolons (Windows Terminal command separator)
@@ -127,46 +130,38 @@ 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:
-        """Create a Windows Terminal script file and return its absolute path."""
-        self.validate_tab_config(tab_config)
+    def create_wt_script(self, tabs: List[TabConfig], output_dir: Path, session_name: str, window_name: str | None = None) -> str:
+        """Create a Windows Terminal PowerShell script and return its absolute path."""
+        self.validate_tab_config(tabs)
 
         # 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)
+        wt_command = self.generate_wt_command(tabs, 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"
+            # Create PowerShell script
             ps1_file = output_dir / f"wt_layout_{session_name}_{random_suffix}.ps1"
 
-            # Create batch file
-            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)
+            # Create PowerShell script content
             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())
+            logger.info(f"Windows Terminal PowerShell script created: {ps1_file.absolute()}")
+            return str(ps1_file.absolute())
 
         except OSError as e:
-            logger.error(f"Failed to create script file: {e}")
+            logger.error(f"Failed to create PowerShell script: {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, tabs: List[TabConfig], window_name: str | None = None) -> str:
         """Generate Windows Terminal command with split panes instead of separate tabs."""
-        self.validate_tab_config(tab_config)
+        self.validate_tab_config(tabs)
 
         wt_parts = ["wt"]
 
@@ -174,8 +169,8 @@ REM Windows Terminal layout for {session_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
+        first_tab = tabs[0]
+        tab_name, cwd, command = first_tab["tabName"], first_tab["startDir"], first_tab["command"]
 
         # Start with first tab
         wt_parts.extend(["-d", WTLayoutGenerator.escape_for_wt(cwd)])
@@ -183,7 +178,8 @@ REM Windows Terminal layout for {session_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:]:
+        for tab in tabs[1:]:
+            tab_name, cwd, command = tab["tabName"], tab["startDir"], tab["command"]
             wt_parts.append(";")
             wt_parts.append("split-pane")
             wt_parts.extend(["-d", WTLayoutGenerator.escape_for_wt(cwd)])

machineconfig/cluster/sessions_managers/wt_utils/process_monitor.py

@@ -7,8 +7,9 @@ Adapted from zellij process monitor but focused on Windows processes.
 import json
 import logging
 import subprocess
-from typing import Dict, Tuple, Any, Optional
-from .remote_executor import WTRemoteExecutor
+from typing import Dict, Any, Optional, List
+from machineconfig.cluster.sessions_managers.layout_types import TabConfig
+from machineconfig.cluster.sessions_managers.wt_utils.remote_executor import WTRemoteExecutor
 
 logger = logging.getLogger(__name__)
 
@@ -34,20 +35,22 @@ class WTProcessMonitor:
                 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, tabs: List[TabConfig], use_verification: bool = True) -> Dict[str, Any]:
         """Check command status with optional process verification."""
-        if tab_name not in tab_config:
+        the_tab = next((t for t in tabs if t["tabName"] == tab_name), None)
+        if the_tab is None:
             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:
-            return self.get_verified_process_status(tab_name, tab_config)
+            return self.get_verified_process_status(tab_name, tabs)
 
-        return self._basic_process_check(tab_name, tab_config)
+        return self._basic_process_check(tab_name, tabs)
 
-    def _basic_process_check(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def _basic_process_check(self, tab_name: str, tabs: List[TabConfig]) -> Dict[str, Any]:
         """Basic process checking without verification."""
-        _, command = tab_config[tab_name]
+        the_tab = next((t for t in tabs if t["tabName"] == tab_name), None)
+        command = the_tab["command"] if the_tab is not None else ""
 
         try:
             check_script = self._create_process_check_script(command)
@@ -132,12 +135,13 @@ Get-Process | ForEach-Object {{
 }}
 """
 
-    def force_fresh_process_check(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def force_fresh_process_check(self, tab_name: str, tabs: List[TabConfig]) -> Dict[str, Any]:
         """Force a fresh process check with additional validation."""
-        if tab_name not in tab_config:
+        the_tab = next((t for t in tabs if t["tabName"] == tab_name), None)
+        if the_tab is None:
             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]
+        command = the_tab["command"]
 
         try:
             # Get timestamp for freshness validation
@@ -262,9 +266,9 @@ Write-Output $result
         except Exception:
             return False
 
-    def get_verified_process_status(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def get_verified_process_status(self, tab_name: str, tabs: List[TabConfig]) -> Dict[str, Any]:
         """Get process status with additional verification that processes are actually alive."""
-        status = self.force_fresh_process_check(tab_name, tab_config)
+        status = self.force_fresh_process_check(tab_name, tabs)
 
         if status.get("running") and status.get("processes"):
             verified_processes = []
@@ -284,15 +288,16 @@ Write-Output $result
 
         return status
 
-    def check_all_commands_status(self, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Dict[str, Any]]:
+    def check_all_commands_status(self, tabs: List[TabConfig]) -> Dict[str, Dict[str, Any]]:
         """Check status of all commands in the tab configuration."""
-        if not tab_config:
+        if not tabs:
             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)
+        for the_tab in tabs:
+            tab_name = the_tab["tabName"]
+            status_report[tab_name] = self.check_command_status(tab_name, tabs)
         return status_report
 
     def get_windows_terminal_windows(self) -> Dict[str, Any]:

machineconfig/cluster/sessions_managers/wt_utils/session_manager.py

@@ -5,13 +5,62 @@ Windows Terminal session management utilities for local and remote operations.
 
 import logging
 import subprocess
-from typing import Dict, Any, Optional
+from typing import Optional, TypedDict, NotRequired
 from pathlib import Path
-from .remote_executor import WTRemoteExecutor
+from machineconfig.cluster.sessions_managers.wt_utils.remote_executor import WTRemoteExecutor
 
 logger = logging.getLogger(__name__)
 
 
+class WTProcessInfo(TypedDict, total=False):
+    Id: int
+    ProcessName: str
+    StartTime: str
+    MainWindowTitle: str
+
+
+class CheckWTSessionStatusResult(TypedDict):
+    wt_running: bool
+    session_exists: bool
+    session_name: str
+    location: str
+    all_windows: NotRequired[list[WTProcessInfo]]
+    session_windows: NotRequired[list[WTProcessInfo]]
+    error: NotRequired[str]
+
+
+class StartWTSessionResult(TypedDict):
+    success: bool
+    session_name: str
+    location: str
+    message: NotRequired[str]
+    error: NotRequired[str]
+
+
+class KillWTSessionResult(TypedDict):
+    success: bool
+    session_name: str
+    location: str
+    message: NotRequired[str]
+    error: NotRequired[str]
+
+
+class CreateNewTabResult(TypedDict):
+    success: bool
+    tab_name: str
+    command: str
+    location: str
+    message: NotRequired[str]
+    error: NotRequired[str]
+
+
+class GetWTVersionResult(TypedDict):
+    success: bool
+    location: str
+    version: NotRequired[str]
+    error: NotRequired[str]
+
+
 class WTSessionManager:
     """Handles Windows Terminal session operations on local and remote machines."""
 
@@ -59,7 +108,7 @@ class WTSessionManager:
         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]:
+    def check_wt_session_status(self) -> CheckWTSessionStatusResult:
         """Check if Windows Terminal windows exist and are running."""
         try:
             # Check for Windows Terminal processes
@@ -94,12 +143,12 @@ ConvertTo-Json -Depth 2
                 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}
+                return {"wt_running": False, "session_exists": 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}
+            return {"wt_running": False, "session_exists": 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]:
+    def start_wt_session(self, script_file_path: Optional[str] = None, wt_command: Optional[str] = None) -> StartWTSessionResult:
         """Start a Windows Terminal session with the generated layout."""
         try:
             if script_file_path:
@@ -166,7 +215,7 @@ ConvertTo-Json -Depth 2
             logger.error(f"Failed to attach to Windows Terminal session: {e}")
             raise
 
-    def kill_wt_session(self, force: bool = True) -> Dict[str, Any]:
+    def kill_wt_session(self, force: bool = True) -> KillWTSessionResult:
         """Kill Windows Terminal processes related to this session."""
         try:
             if force:
@@ -185,7 +234,7 @@ ConvertTo-Json -Depth 2
             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]:
+    def create_new_tab(self, tab_name: str, cwd: str, command: str, window_name: Optional[str] = None) -> CreateNewTabResult:
         """Create a new tab in the Windows Terminal session."""
         try:
             # Build the new-tab command
@@ -208,9 +257,9 @@ ConvertTo-Json -Depth 2
 
         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, "command": command, "location": self.location_name}
 
-    def get_wt_version(self) -> Dict[str, Any]:
+    def get_wt_version(self) -> GetWTVersionResult:
         """Get Windows Terminal version information."""
         try:
             version_cmd = "wt --version"