machineconfig 5.21__py3-none-any.whl → 5.23__py3-none-any.whl

machineconfig/cluster/sessions_managers/helpers/zellij_local_manager_helper.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+import json
+import logging
+import shutil
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+from machineconfig.cluster.sessions_managers.zellij_utils.monitoring_types import ActiveSessionInfo, StartResult
+from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
+
+if TYPE_CHECKING:
+    from machineconfig.cluster.sessions_managers.zellij_local import ZellijLayoutGenerator
+
+
+logger = logging.getLogger(__name__)
+TMP_SERIALIZATION_DIR = Path.home() / "tmp_results" / "zellij_sessions" / "serialized"
+
+
+def list_saved_sessions() -> list[str]:
+    """List all saved session IDs."""
+    if not TMP_SERIALIZATION_DIR.exists():
+        return []
+    sessions = []
+    for item in TMP_SERIALIZATION_DIR.iterdir():
+        if item.is_dir() and (item / "metadata.json").exists():
+            sessions.append(item.name)
+    return sorted(sessions)
+
+
+def delete_session(session_id: str) -> bool:
+    """Delete a saved session."""
+    session_dir = TMP_SERIALIZATION_DIR / session_id
+    if not session_dir.exists():
+        logger.warning(f"Session directory not found: {session_dir}")
+        return False
+    try:
+        shutil.rmtree(session_dir)
+        logger.info(f"✅ Deleted session: {session_id}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to delete session {session_id}: {e}")
+        return False
+
+
+def get_all_session_names(managers: list["ZellijLayoutGenerator"]) -> list[str]:
+    """Get all managed session names."""
+    return [manager.session_name for manager in managers]
+
+
+def attach_to_session(managers: list["ZellijLayoutGenerator"], session_name: Optional[str]) -> str:
+    """
+    Generate command to attach to a specific session or list attachment commands for all.
+
+    Args:
+        managers: List of ZellijLayoutGenerator instances
+        session_name: Specific session to attach to, or None for all sessions
+
+    Returns:
+        Command string to attach to session(s)
+    """
+    if session_name:
+        for manager in managers:
+            if manager.session_name == session_name:
+                return f"zellij attach {session_name}"
+        raise ValueError(f"Session '{session_name}' not found")
+    else:
+        commands: list[str] = []
+        for manager in managers:
+            commands.append(f"# Attach to session '{manager.session_name}':")
+            commands.append(f"zellij attach {manager.session_name}")
+            commands.append("")
+        return "\n".join(commands)
+
+
+def list_active_sessions(managers: list["ZellijLayoutGenerator"]) -> list[ActiveSessionInfo]:
+    """List currently active zellij sessions managed by this instance."""
+    active_sessions: list[ActiveSessionInfo] = []
+    try:
+        result = subprocess.run(["zellij", "list-sessions"], capture_output=True, text=True, timeout=10)
+        if result.returncode == 0:
+            all_sessions = result.stdout.strip().split("\n") if result.stdout.strip() else []
+            for manager in managers:
+                session_name = manager.session_name
+                is_active = any(session_name in session for session in all_sessions)
+                tab_info = []
+                tab_count = 0
+                if manager.layout_config:
+                    tab_count = len(manager.layout_config["layoutTabs"])
+                    tab_info = [tab["tabName"] for tab in manager.layout_config["layoutTabs"]]
+                active_sessions.append({"session_name": session_name, "is_active": is_active, "tab_count": tab_count, "tabs": tab_info})
+    except Exception as e:
+        logger.error(f"Error listing active sessions: {e}")
+    return active_sessions
+
+
+def save_manager(session_layouts: list[LayoutConfig], managers: list["ZellijLayoutGenerator"], session_name_prefix: str, session_id: Optional[str]) -> str:
+    """Save the manager state to disk."""
+    if session_id is None:
+        import uuid
+        session_id = str(uuid.uuid4())[:8]
+    session_dir = TMP_SERIALIZATION_DIR / session_id
+    session_dir.mkdir(parents=True, exist_ok=True)
+    config_file = session_dir / "session_layouts.json"
+    text = json.dumps(session_layouts, indent=2, ensure_ascii=False)
+    config_file.write_text(text, encoding="utf-8")
+    metadata = {"session_name_prefix": session_name_prefix, "created_at": str(datetime.now()), "num_managers": len(managers), "sessions": [item["layoutName"] for item in session_layouts], "manager_type": "ZellijLocalManager"}
+    metadata_file = session_dir / "metadata.json"
+    text = json.dumps(metadata, indent=2, ensure_ascii=False)
+    metadata_file.write_text(text, encoding="utf-8")
+    managers_dir = session_dir / "managers"
+    managers_dir.mkdir(exist_ok=True)
+    for i, manager in enumerate(managers):
+        manager_data = {"session_name": manager.session_name, "layout_config": manager.layout_config, "layout_path": manager.layout_path}
+        manager_file = managers_dir / f"manager_{i}_{manager.session_name}.json"
+        text = json.dumps(manager_data, indent=2, ensure_ascii=False)
+        manager_file.write_text(text, encoding="utf-8")
+    logger.info(f"✅ Saved ZellijLocalManager session to: {session_dir}")
+    return session_id
+
+
+def load_manager(session_id: str):
+    """Load a saved manager state from disk and return the data needed to reconstruct ZellijLocalManager."""
+    from machineconfig.cluster.sessions_managers.zellij_local import ZellijLayoutGenerator
+    
+    session_dir = TMP_SERIALIZATION_DIR / session_id
+    if not session_dir.exists():
+        raise FileNotFoundError(f"Session directory not found: {session_dir}")
+    config_file = session_dir / "session_layouts.json"
+    if not config_file.exists():
+        raise FileNotFoundError(f"Configuration file not found: {config_file}")
+    text = config_file.read_text(encoding="utf-8")
+    session_layouts = json.loads(text)
+    managers = []
+    managers_dir = session_dir / "managers"
+    if managers_dir.exists():
+        manager_files = sorted(managers_dir.glob("manager_*.json"))
+        for manager_file in manager_files:
+            try:
+                text = manager_file.read_text(encoding="utf-8")
+                manager_data = json.loads(text)
+                manager = ZellijLayoutGenerator(layout_config=manager_data["layout_config"], session_name=manager_data["session_name"])
+                manager.layout_path = manager_data["layout_path"]
+                managers.append(manager)
+            except Exception as e:
+                logger.warning(f"Failed to load manager from {manager_file}: {e}")
+    logger.info(f"✅ Loaded ZellijLocalManager session from: {session_dir}")
+    return session_layouts, managers
+
+
+def kill_all_sessions(managers: list["ZellijLayoutGenerator"]) -> dict[str, StartResult]:
+    """Kill all managed zellij sessions."""
+    results: dict[str, StartResult] = {}
+    for manager in managers:
+        try:
+            session_name = manager.session_name
+            cmd = f"zellij delete-session --force {session_name}"
+            logger.info(f"Killing session '{session_name}'")
+            result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=10)
+            results[session_name] = {"success": result.returncode == 0, "message": "Session killed" if result.returncode == 0 else result.stderr}
+        except Exception as e:
+            key = getattr(manager, "session_name", None) or f"manager_{managers.index(manager)}"
+            results[key] = {"success": False, "error": str(e)}
+    return results

machineconfig/cluster/sessions_managers/wt_local.py

@@ -13,27 +13,30 @@ import random
 import string
 import json
 import platform
-from typing import Dict, List, Optional, Any
+from typing import Optional, Any
 from pathlib import Path
 import logging
+
 from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
 
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 console = Console()
-TMP_LAYOUT_DIR = Path.home().joinpath("tmp_results", "session_manager", "wt", "layout_manager")
 
 # Check if we're on Windows
 IS_WINDOWS = platform.system().lower() == "windows"
 POWERSHELL_CMD = "powershell" if IS_WINDOWS else "pwsh"  # Use pwsh on non-Windows systems
+TMP_LAYOUT_DIR = Path.home() / "tmp_results" / "wt_layouts"
 
 
 class WTLayoutGenerator:
-    def __init__(self):
-        self.session_name: Optional[str] = None
-        self.layout_config: Optional[LayoutConfig] = None  # Store the complete layout config
+    def __init__(self, layout_config: LayoutConfig, session_name: str):
+        self.session_name: str = session_name
+        self.layout_config: LayoutConfig = layout_config.copy()
         self.script_path: Optional[str] = None  # Store the full path to the PowerShell script
 
     @staticmethod
@@ -42,7 +45,7 @@ class WTLayoutGenerator:
         return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
 
     @staticmethod
-    def _parse_command(command: str) -> tuple[str, List[str]]:
+    def _parse_command(command: str) -> tuple[str, list[str]]:
         try:
             parts = shlex.split(command)
             if not parts:
@@ -77,41 +80,35 @@ class WTLayoutGenerator:
             if not tab["startDir"].strip():
                 raise ValueError(f"Invalid startDir for tab '{tab['tabName']}': {tab['startDir']}")
 
-    def create_wt_layout(self, layout_config: LayoutConfig, output_dir: Optional[str]) -> str:
-        WTLayoutGenerator._validate_layout_config(layout_config)
-        logger.info(f"Creating Windows Terminal layout '{layout_config['layoutName']}' with {len(layout_config['layoutTabs'])} tabs")
-
-        # Store session name and layout config for status checking
-        self.session_name = layout_config["layoutName"]
-        self.layout_config = layout_config.copy()
+    def create_layout_file(self) -> bool:
+        """Create Windows Terminal layout file and return success status."""
+        WTLayoutGenerator._validate_layout_config(self.layout_config)
+        tab_count = len(self.layout_config['layoutTabs'])
+        layout_name = self.layout_config['layoutName']
+        console.print(f"[bold cyan]📋 Creating Windows Terminal layout[/bold cyan] [bright_green]'{layout_name}' with {tab_count} tabs[/bright_green]")
+        
+        for tab in self.layout_config['layoutTabs']:
+            console.print(f"  [yellow]→[/yellow] [bold]{tab['tabName']}[/bold] [dim]in[/dim] [blue]{tab['startDir']}[/blue]")
 
         # Generate Windows Terminal command
-        wt_command = self._generate_wt_command_string(layout_config, self.session_name)
-
-        try:
-            random_suffix = WTLayoutGenerator._generate_random_suffix(8)
-            if output_dir:
-                output_path = Path(output_dir)
-                output_path.mkdir(parents=True, exist_ok=True)
-                script_file = output_path / f"wt_layout_{random_suffix}.ps1"
-            else:
-                # 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}.ps1"
+        wt_command = self._generate_wt_command_string(self.layout_config, self.session_name)
 
-            # Create PowerShell script
-            text = f"""# Windows Terminal layout for {self.session_name}
+        random_suffix = WTLayoutGenerator._generate_random_suffix(8)
+        # Create PowerShell script content
+        script_content = f"""# Windows Terminal layout for {self.session_name}
 # Generated with random suffix: {random_suffix}
 {wt_command}
 """
-            script_file.write_text(text, encoding="utf-8")
+        # Write to file
+        random_suffix = WTLayoutGenerator._generate_random_suffix(8)
+        tmp_dir = Path(TMP_LAYOUT_DIR)
+        tmp_dir.mkdir(parents=True, exist_ok=True)
+        script_file = tmp_dir / f"wt_layout_{self.session_name}_{random_suffix}.ps1"
+        script_file.write_text(script_content, encoding="utf-8")
+        self.script_path = str(script_file.absolute())
 
-            self.script_path = str(script_file.absolute())
-            logger.info(f"Windows Terminal PowerShell script created: {self.script_path}")
-            return self.script_path
-        except OSError as e:
-            logger.error(f"Failed to create PowerShell script: {e}")
-            raise
+        console.print(f"[bold green]✅ Layout created successfully:[/bold green] [cyan]{self.script_path}[/cyan]")
+        return True
 
     def _generate_wt_command_string(self, layout_config: LayoutConfig, window_name: str) -> str:
         """Generate complete Windows Terminal command string."""
@@ -154,7 +151,7 @@ class WTLayoutGenerator:
         WTLayoutGenerator._validate_layout_config(layout_config)
         return self._generate_wt_command_string(layout_config, "preview")
 
-    def check_all_commands_status(self) -> Dict[str, Dict[str, Any]]:
+    def check_all_commands_status(self) -> dict[str, dict[str, Any]]:
         if not self.layout_config:
             logger.warning("No layout config tracked. Make sure to create a layout first.")
             return {}
@@ -167,7 +164,7 @@ class WTLayoutGenerator:
         return status_report
 
     @staticmethod
-    def check_wt_session_status(session_name: str) -> Dict[str, Any]:
+    def check_wt_session_status(session_name: str) -> dict[str, Any]:
         try:
             # Simplified Windows Terminal process check
             ps_script = """
@@ -223,7 +220,7 @@ try {
             return {"wt_running": False, "error": str(e), "session_name": session_name}
 
     @staticmethod
-    def check_command_status(tab_name: str, layout_config: LayoutConfig) -> Dict[str, Any]:
+    def check_command_status(tab_name: str, layout_config: LayoutConfig) -> dict[str, Any]:
         """Check if a command is running by looking for processes."""
         # Find the tab with the given name
         tab_config = None
@@ -290,7 +287,7 @@ try {{
             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}
 
-    def get_status_report(self) -> Dict[str, Any]:
+    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()
@@ -311,64 +308,90 @@ try {{
         commands = status["commands"]
         summary = status["summary"]
 
-        print("=" * 80)
-        print("🖥️  WINDOWS TERMINAL LAYOUT STATUS REPORT")
-        print("=" * 80)
+        console.print()
+        console.print(Panel.fit("� WINDOWS TERMINAL LAYOUT STATUS REPORT", style="bold cyan"))
 
         # Windows Terminal session status
-        print(f"🪟 Session: {self.session_name}")
         if wt_session.get("wt_running", False):
             if wt_session.get("session_exists", False):
                 session_windows = wt_session.get("session_windows", [])
                 all_windows = wt_session.get("all_windows", [])
-                print("✅ Windows Terminal is running")
-                print(f"   Session windows: {len(session_windows)}")
-                print(f"   Total WT windows: {len(all_windows)}")
+                console.print(f"[bold green]✅ Windows Terminal session[/bold green] [yellow]'{self.session_name}'[/yellow] [green]is running[/green]")
+                console.print(f"   Session windows: {len(session_windows)}")
+                console.print(f"   Total WT windows: {len(all_windows)}")
             else:
-                print("⚠️  Windows Terminal is running but no session windows found")
+                console.print(f"[bold yellow]⚠️  Windows Terminal is running but session[/bold yellow] [yellow]'{self.session_name}'[/yellow] [yellow]not found[/yellow]")
         else:
             error_msg = wt_session.get("error", "Unknown error")
-            print(f"❌ Windows Terminal session issue: {error_msg}")
+            console.print(f"[bold red]❌ Windows Terminal session issue:[/bold red] [red]{error_msg}[/red]")
 
-        print()
+        console.print()
+
+        # Commands status table
+        table = Table(title="📋 COMMAND STATUS", show_header=True, header_style="bold magenta")
+        table.add_column("Tab", style="cyan", no_wrap=True)
+        table.add_column("Status", justify="center")
+        table.add_column("PID", justify="center", style="dim")
+        table.add_column("Command", style="green", max_width=40)
 
-        # Commands in this layout
-        print(f"📋 COMMANDS ({summary['running_commands']}/{summary['total_commands']} running):")
         for tab_name, cmd_status in commands.items():
-            status_icon = "✅" if cmd_status.get("running", False) else "❌"
-            cmd_text = cmd_status.get("command", "Unknown")[:50]
-            if len(cmd_status.get("command", "")) > 50:
-                cmd_text += "..."
+            if cmd_status.get("running", False):
+                status_text = "[bold green]✅ Running[/bold green]"
+                processes = cmd_status.get("processes", [])
+                if processes:
+                    proc = processes[0]
+                    pid = str(proc.get("pid", "N/A"))
+                else:
+                    pid = "N/A"
+            else:
+                status_text = "[bold red]❌ Stopped[/bold red]"
+                pid = "N/A"
 
-            print(f"   {status_icon} {tab_name}: {cmd_text}")
+            command = cmd_status.get("command", "Unknown")
+            if len(command) > 35:
+                command = command[:32] + "..."
 
-            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")
-                    console.print(f"      [dim]└─[/dim] PID {pid}: {name}")
-        print()
+            table.add_row(tab_name, status_text, pid, command)
 
-        print("=" * 80)
+        console.print(table)
+        console.print()
 
+        # Summary panel
+        summary_text = f"""[bold]Total commands:[/bold] {summary['total_commands']}
+[green]Running:[/green] {summary['running_commands']}
+[red]Stopped:[/red] {summary['stopped_commands']}
+[yellow]Session healthy:[/yellow] {"✅" if summary['session_healthy'] else "❌"}"""
 
-def create_wt_layout(layout_config: LayoutConfig, output_dir: Optional[str]) -> str:
-    generator = WTLayoutGenerator()
-    return generator.create_wt_layout(layout_config, output_dir)
+        console.print(Panel(summary_text, title="📊 Summary", style="blue"))
 
 
-def run_wt_layout(layout_config: LayoutConfig) -> str:
+def create_wt_layout(layout_config: LayoutConfig, output_path: str) -> str:
+    session_name = layout_config["layoutName"]
+    generator = WTLayoutGenerator(layout_config=layout_config, session_name=session_name)
+    generator.create_layout_file()
+    
+    if generator.script_path is None:
+        raise RuntimeError("Script path was not set after creating layout file")
+    
+    logger.info(f"Windows Terminal PowerShell script created: {generator.script_path}")
+    return generator.script_path
+
+
+def run_wt_layout(layout_config: LayoutConfig) -> None:
     """Create and run a Windows Terminal layout."""
-    generator = WTLayoutGenerator()
-    script_path = generator.create_wt_layout(layout_config, None)
+    session_name = layout_config["layoutName"]
+    generator = WTLayoutGenerator(layout_config=layout_config, session_name=session_name)
+    generator.create_layout_file()
+    
+    if generator.script_path is None:
+        raise RuntimeError("Script path was not set after creating layout file")
 
     # Execute the script
-    cmd = f'powershell -ExecutionPolicy Bypass -File "{script_path}"'
+    cmd = f'powershell -ExecutionPolicy Bypass -File "{generator.script_path}"'
     result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
 
     if result.returncode == 0:
         print(f"Windows Terminal layout is running @ {layout_config['layoutName']}")
-        return script_path
     else:
         logger.error(f"Failed to run Windows Terminal layout: {result.stderr}")
         raise RuntimeError(f"Failed to run layout: {result.stderr}")
@@ -391,15 +414,17 @@ if __name__ == "__main__":
             {"tabName": "Monitor", "startDir": "~", "command": "lf"}
             ]}
     try:
-        generator = WTLayoutGenerator()
-        script_path = generator.create_wt_layout(layout_config=sample_layout, output_dir=None)
-        print(f"✅ Windows Terminal layout created: {script_path}")
-        preview = generator.get_wt_layout_preview(layout_config=sample_layout)
+        session_name = sample_layout["layoutName"]
+        generator = WTLayoutGenerator(layout_config=sample_layout, session_name=session_name)
+        generator.create_layout_file()
+        
+        print(f"✅ Windows Terminal layout created: {generator.script_path}")
+        preview = generator.get_wt_layout_preview(generator.layout_config)
         print(f"📋 Command Preview:\n{preview}")
         print("🔍 Current status:")
         generator.print_status_report()
         print("▶️  To run this layout, execute:")
-        print(f'   powershell -ExecutionPolicy Bypass -File "{script_path}"')
+        print(f'   powershell -ExecutionPolicy Bypass -File "{generator.script_path}"')
     except Exception as e:
         print(f"❌ Error: {e}")
         import traceback

machineconfig/cluster/sessions_managers/wt_local_manager.py

@@ -5,26 +5,23 @@ import uuid
 import logging
 import subprocess
 from pathlib import Path
-from typing import TypedDict, Optional, Dict, List, Any
+from typing import Optional, Any
 from rich.console import Console
 from machineconfig.utils.scheduler import Scheduler
 from machineconfig.cluster.sessions_managers.wt_local import WTLayoutGenerator
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
 from machineconfig.cluster.sessions_managers.zellij_utils.monitoring_types import (
-    StartResult, GlobalSummary, ActiveSessionInfo, CommandStatus, CommandSummary
+    StartResult, GlobalSummary, ActiveSessionInfo
 )
 
 
-class WTSessionReport(TypedDict):
-    session_status: Dict[str, Any]  # WT-specific session status
-    commands_status: Dict[str, CommandStatus]
-    summary: CommandSummary
+
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 console = Console()
+TMP_SERIALIZATION_DIR = Path.home() / "tmp_results" / "wt_sessions" / "serialized"
 
-TMP_SERIALIZATION_DIR = Path.home().joinpath("tmp_results", "session_manager", "wt", "local_manager")
 
 
 class WTLocalManager:
@@ -41,21 +38,22 @@ class WTLocalManager:
         """
         self.session_name_prefix = session_name_prefix
         self.session_layouts = session_layouts  # Store the original config
-        self.managers: List[WTLayoutGenerator] = []
+        self.managers: list[WTLayoutGenerator] = []
 
         # Create a WTLayoutGenerator for each session
         for layout_config in session_layouts:
-            manager = WTLayoutGenerator()
-            manager.create_wt_layout(layout_config=layout_config, output_dir=None)
+            session_name = layout_config["layoutName"]
+            manager = WTLayoutGenerator(layout_config=layout_config, session_name=session_name)
+            manager.create_layout_file()
             self.managers.append(manager)
 
         logger.info(f"Initialized WTLocalManager with {len(self.managers)} sessions")
 
-    def get_all_session_names(self) -> List[str]:
+    def get_all_session_names(self) -> list[str]:
         """Get all managed session names."""
-        return [manager.session_name for manager in self.managers if manager.session_name is not None]
+        return [manager.session_name for manager in self.managers]
 
-    def start_all_sessions(self) -> Dict[str, StartResult]:
+    def start_all_sessions(self) -> dict[str, StartResult]:
         """Start all Windows Terminal sessions with their layouts."""
         results = {}
         for manager in self.managers:
@@ -86,7 +84,7 @@ class WTLocalManager:
 
         return results
 
-    def kill_all_sessions(self) -> Dict[str, StartResult]:
+    def kill_all_sessions(self) -> dict[str, StartResult]:
         """Kill all managed Windows Terminal sessions."""
         results = {}
         for manager in self.managers:
@@ -130,7 +128,7 @@ class WTLocalManager:
                 commands.append("")
             return "\n".join(commands)
 
-    def check_all_sessions_status(self) -> Dict[str, WTSessionReport]:
+    def check_all_sessions_status(self) -> dict[str, dict[str, Any]]:
         """Check the status of all sessions and their commands."""
         status_report = {}
 
@@ -361,9 +359,7 @@ class WTLocalManager:
                     manager_data = json.loads(text)
 
                     # Recreate the manager
-                    manager = WTLayoutGenerator()
-                    manager.session_name = manager_data["session_name"]
-                    manager.layout_config = manager_data["layout_config"]
+                    manager = WTLayoutGenerator(layout_config=manager_data["layout_config"], session_name=manager_data["session_name"])
                     manager.script_path = manager_data["script_path"]
 
                     instance.managers.append(manager)
@@ -375,7 +371,7 @@ class WTLocalManager:
         return instance
 
     @staticmethod
-    def list_saved_sessions() -> List[str]:
+    def list_saved_sessions() -> list[str]:
         """List all saved session IDs."""
         if not TMP_SERIALIZATION_DIR.exists():
             return []
@@ -406,7 +402,7 @@ class WTLocalManager:
             logger.error(f"Failed to delete session {session_id}: {e}")
             return False
 
-    def list_active_sessions(self) -> List[ActiveSessionInfo]:
+    def list_active_sessions(self) -> list[ActiveSessionInfo]:
         """List currently active Windows Terminal sessions managed by this instance."""
         active_sessions = []
 
@@ -448,7 +444,7 @@ class WTLocalManager:
 
         return active_sessions
 
-    def get_wt_overview(self) -> Dict[str, Any]:
+    def get_wt_overview(self) -> dict[str, Any]:
         """Get overview of all Windows Terminal windows and processes."""
         try:
             result = subprocess.run(