machineconfig 6.83__py3-none-any.whl → 6.85__py3-none-any.whl

machineconfig/cluster/sessions_managers/wt_local.py

@@ -7,11 +7,7 @@ https://github.com/ruby9455/app_management/tree/main/app_management
 
 """
 
-import shlex
 import subprocess
-import random
-import string
-import json
 import platform
 from typing import Optional, Any
 from pathlib import Path
@@ -22,6 +18,14 @@ from rich.panel import Panel
 from rich.table import Table
 
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
+from machineconfig.cluster.sessions_managers.wt_utils.wt_helpers import (
+    generate_random_suffix,
+    # escape_for_wt,
+    validate_layout_config,
+    generate_wt_command_string,
+    check_wt_session_status,
+    check_command_status,
+)
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -37,52 +41,11 @@ class WTLayoutGenerator:
     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
-    def _generate_random_suffix(length: int) -> str:
-        """Generate a random string suffix for unique PowerShell script names."""
-        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")
-            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:
-            return f'"{text}"'
-        return text
-
-
-
-    @staticmethod
-    def _validate_layout_config(layout_config: LayoutConfig) -> None:
-        """Validate layout configuration format and content."""
-        if not layout_config["layoutTabs"]:
-            raise ValueError("Layout must contain at least one tab")
-        for tab in layout_config["layoutTabs"]:
-            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']}")
+        self.script_path: Optional[str] = None
 
     def create_layout_file(self) -> bool:
         """Create Windows Terminal layout file and return success status."""
-        WTLayoutGenerator._validate_layout_config(self.layout_config)
+        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]")
@@ -90,17 +53,13 @@ class WTLayoutGenerator:
         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(self.layout_config, self.session_name)
+        wt_command = generate_wt_command_string(self.layout_config, self.session_name)
 
-        random_suffix = WTLayoutGenerator._generate_random_suffix(8)
-        # Create PowerShell script content
+        random_suffix = generate_random_suffix(8)
         script_content = f"""# Windows Terminal layout for {self.session_name}
 # Generated with random suffix: {random_suffix}
 {wt_command}
 """
-        # 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"
@@ -110,46 +69,10 @@ class WTLayoutGenerator:
         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."""
-        # Build the complete Windows Terminal command
-        command_parts = []
-        
-        for i, tab in enumerate(layout_config["layoutTabs"]):
-            is_first = i == 0
-            
-            if is_first:
-                # First tab: start with wt command and window name
-                tab_parts = ["wt", "-w", WTLayoutGenerator._escape_for_wt(window_name)]
-            else:
-                # Subsequent tabs: use new-tab
-                tab_parts = ["new-tab"]
-            
-            # Add common tab arguments
-            tab_name = tab["tabName"]
-            cwd = tab["startDir"]
-            command = tab["command"]
-            
-            # Convert paths to Windows format if needed
-            if cwd.startswith("~/"):
-                cwd = cwd.replace("~/", f"{Path.home()}/")
-            elif cwd == "~":
-                cwd = str(Path.home())
-            
-            # Add arguments in the correct order
-            tab_parts.extend(["-d", WTLayoutGenerator._escape_for_wt(cwd)])
-            tab_parts.extend(["--title", WTLayoutGenerator._escape_for_wt(tab_name)])
-            tab_parts.append(WTLayoutGenerator._escape_for_wt(command))
-            
-            command_parts.append(" ".join(tab_parts))
-        
-        # Join all tab commands with escaped semicolons for PowerShell
-        return " `; ".join(command_parts)
-
     def get_wt_layout_preview(self, layout_config: LayoutConfig) -> str:
         """Generate preview of the Windows Terminal command that would be created."""
-        WTLayoutGenerator._validate_layout_config(layout_config)
-        return self._generate_wt_command_string(layout_config, "preview")
+        validate_layout_config(layout_config)
+        return generate_wt_command_string(layout_config, "preview")
 
     def check_all_commands_status(self) -> dict[str, dict[str, Any]]:
         if not self.layout_config:
@@ -159,137 +82,13 @@ class WTLayoutGenerator:
         status_report = {}
         for tab in self.layout_config["layoutTabs"]:
             tab_name = tab["tabName"]
-            status_report[tab_name] = WTLayoutGenerator.check_command_status(tab_name, self.layout_config)
+            status_report[tab_name] = check_command_status(tab_name, self.layout_config)
 
         return status_report
 
-    @staticmethod
-    def check_wt_session_status(session_name: str) -> dict[str, Any]:
-        try:
-            # Simplified Windows Terminal process check
-            ps_script = """
-try {
-    $wtProcesses = Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue
-    if ($wtProcesses) {
-        $processInfo = @()
-        $wtProcesses | ForEach-Object {
-            $info = @{
-                "Id" = $_.Id
-                "ProcessName" = $_.ProcessName
-                "StartTime" = $_.StartTime.ToString()
-            }
-            $processInfo += $info
-        }
-        $processInfo | ConvertTo-Json -Depth 2
-    }
-} catch {
-    # No Windows Terminal processes found
-}
-"""
-
-            result = subprocess.run([POWERSHELL_CMD, "-Command", ps_script], capture_output=True, text=True, timeout=5)
-
-            if result.returncode == 0:
-                output = result.stdout.strip()
-                if output and output != "":
-                    try:
-                        processes = json.loads(output)
-                        if not isinstance(processes, list):
-                            processes = [processes]
-
-                        # For simplicity, assume session exists if WT is running
-                        return {
-                            "wt_running": True, 
-                            "session_exists": len(processes) > 0, 
-                            "session_name": session_name, 
-                            "all_windows": processes, 
-                            "session_windows": processes  # Simplified - assume all windows could be 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}
-                else:
-                    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}
-
-        except subprocess.TimeoutExpired:
-            return {"wt_running": False, "error": "Timeout while checking Windows Terminal processes", "session_name": session_name}
-        except FileNotFoundError:
-            return {"wt_running": False, "error": f"PowerShell ({POWERSHELL_CMD}) not found in PATH", "session_name": session_name}
-        except Exception as e:
-            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]:
-        """Check if a command is running by looking for processes."""
-        # Find the tab with the given name
-        tab_config = None
-        for tab in layout_config["layoutTabs"]:
-            if tab["tabName"] == tab_name:
-                tab_config = tab
-                break
-
-        if tab_config is None:
-            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in layout config", "running": False, "pid": None, "command": None}
-
-        command = tab_config["command"]
-
-        try:
-            # Extract the primary executable name from command
-            primary_cmd = command.split()[0] if command.strip() else ""
-            if not primary_cmd:
-                return {"status": "error", "error": "Empty command", "running": False, "command": command, "tab_name": tab_name}
-
-            # Use a much simpler PowerShell script that just checks for process names
-            ps_script = f"""
-try {{
-    $processes = Get-Process -Name '{primary_cmd}' -ErrorAction SilentlyContinue
-    if ($processes) {{
-        $processes | ForEach-Object {{
-            $procInfo = @{{
-                "pid" = $_.Id
-                "name" = $_.ProcessName
-                "start_time" = $_.StartTime.ToString()
-            }}
-            Write-Output ($procInfo | ConvertTo-Json -Compress)
-        }}
-    }}
-}} catch {{
-    # No processes found or other error
-}}
-"""
-
-            result = subprocess.run([POWERSHELL_CMD, "-Command", ps_script], capture_output=True, text=True, timeout=5)
-
-            if result.returncode == 0:
-                output_lines = [line.strip() for line in result.stdout.strip().split("\n") if line.strip()]
-                matching_processes = []
-
-                for line in output_lines:
-                    if line.startswith("{") and line.endswith("}"):
-                        try:
-                            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}
-                else:
-                    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}
-
-        except subprocess.TimeoutExpired:
-            logger.error(f"Timeout checking command status for tab '{tab_name}'")
-            return {"status": "timeout", "error": "Timeout checking process status", "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}
-
     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")
+        wt_status = 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))
@@ -382,14 +181,11 @@ def run_wt_layout(layout_config: LayoutConfig) -> 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 "{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']}")
     else:
@@ -400,7 +196,6 @@ def run_wt_layout(layout_config: LayoutConfig) -> None:
 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 ""
-
     return f"""
 echo "Creating new Windows Terminal tab: {tab_name}"
 wt new-tab --title "{tab_name}" {cwd_part} "{command}"

machineconfig/cluster/sessions_managers/wt_local_manager.py

@@ -1,7 +1,5 @@
 #!/usr/bin/env python3
 from datetime import datetime
-import json
-import uuid
 import logging
 import subprocess
 from pathlib import Path
@@ -9,9 +7,14 @@ 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.cluster.sessions_managers.wt_utils.wt_helpers import check_wt_session_status
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
-from machineconfig.cluster.sessions_managers.zellij_utils.monitoring_types import (
-    StartResult, GlobalSummary, ActiveSessionInfo
+from machineconfig.cluster.sessions_managers.zellij_utils.monitoring_types import StartResult, ActiveSessionInfo
+from machineconfig.cluster.sessions_managers.wt_utils.manager_persistence import (
+    generate_session_id, save_json_file, load_json_file, list_saved_sessions_in_dir, delete_session_dir, ensure_session_dir_exists
+)
+from machineconfig.cluster.sessions_managers.wt_utils.status_reporting import (
+    print_global_summary, print_session_health_status, print_commands_status, calculate_session_summary, calculate_global_summary_from_status
 )
 
 
@@ -129,104 +132,29 @@ class WTLocalManager:
             return "\n".join(commands)
 
     def check_all_sessions_status(self) -> dict[str, dict[str, Any]]:
-        """Check the status of all sessions and their commands."""
         status_report = {}
-
         for manager in self.managers:
             session_name = manager.session_name or "default"
-
-            # Get session status
-            session_status = WTLayoutGenerator.check_wt_session_status(session_name)
-
-            # Get commands status for this session
+            session_status = check_wt_session_status(session_name)
             commands_status = manager.check_all_commands_status()
-
-            # Calculate summary for this session
-            running_count = sum(1 for status in commands_status.values() if status.get("running", False))
-            total_count = len(commands_status)
-
-            status_report[session_name] = {
-                "session_status": session_status,
-                "commands_status": commands_status,
-                "summary": {"total_commands": total_count, "running_commands": running_count, "stopped_commands": total_count - running_count, "session_healthy": session_status.get("session_exists", False)},
-            }
-
+            summary = calculate_session_summary(commands_status, session_status.get("session_exists", False))
+            status_report[session_name] = {"session_status": session_status, "commands_status": commands_status, "summary": summary}
         return status_report
 
-    def get_global_summary(self) -> GlobalSummary:
-        """Get a global summary across all sessions."""
+    def get_global_summary(self) -> dict[str, Any]:
         all_status = self.check_all_sessions_status()
-
-        total_sessions = len(all_status)
-        healthy_sessions = sum(1 for status in all_status.values() if status["summary"]["session_healthy"])
-        total_commands = sum(status["summary"]["total_commands"] for status in all_status.values())
-        total_running = sum(status["summary"]["running_commands"] for status in all_status.values())
-
-        return {
-            "total_sessions": total_sessions,
-            "healthy_sessions": healthy_sessions,
-            "unhealthy_sessions": total_sessions - healthy_sessions,
-            "total_commands": total_commands,
-            "running_commands": total_running,
-            "stopped_commands": total_commands - total_running,
-            "all_sessions_healthy": healthy_sessions == total_sessions,
-            "all_commands_running": total_running == total_commands,
-        }
+        return calculate_global_summary_from_status(all_status, include_remote_machines=False)
 
     def print_status_report(self) -> None:
-        """Print a comprehensive status report for all sessions."""
         all_status = self.check_all_sessions_status()
         global_summary = self.get_global_summary()
-
-        print("=" * 80)
-        print("🖥️  WINDOWS TERMINAL LOCAL MANAGER STATUS REPORT")
-        print("=" * 80)
-
-        # Global summary
-        print("🌐 GLOBAL SUMMARY:")
-        print(f"   Total sessions: {global_summary['total_sessions']}")
-        print(f"   Healthy sessions: {global_summary['healthy_sessions']}")
-        print(f"   Total commands: {global_summary['total_commands']}")
-        print(f"   Running commands: {global_summary['running_commands']}")
-        print(f"   All healthy: {'✅' if global_summary['all_sessions_healthy'] else '❌'}")
-        print()
-
-        # Per-session details
+        print_global_summary(global_summary, "WINDOWS TERMINAL LOCAL MANAGER STATUS REPORT")
         for session_name, status in all_status.items():
-            session_status = status["session_status"]
-            commands_status = status["commands_status"]
-            summary = status["summary"]
-
             print(f"🪟 SESSION: {session_name}")
             print("-" * 60)
-
-            # Session health
-            if session_status.get("wt_running", False):
-                if session_status.get("session_exists", False):
-                    session_windows = session_status.get("session_windows", [])
-                    all_windows = session_status.get("all_windows", [])
-                    print("✅ Windows Terminal is running")
-                    print(f"   Session windows: {len(session_windows)}")
-                    print(f"   Total WT windows: {len(all_windows)}")
-                else:
-                    print("⚠️  Windows Terminal is running but no session windows found")
-            else:
-                print(f"❌ Windows Terminal session issue: {session_status.get('error', 'Unknown error')}")
-
-            # Commands in this session
-            print(f"   Commands ({summary['running_commands']}/{summary['total_commands']} running):")
-            for tab_name, cmd_status in commands_status.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 += "..."
-                console.print(f"     {status_icon} {tab_name}: {cmd_text}")
-
-                if cmd_status.get("processes"):
-                    for proc in cmd_status["processes"][:2]:  # Show first 2 processes
-                        console.print(f"        [dim]└─[/dim] PID {proc['pid']}: {proc['name']}")
+            print_session_health_status(status["session_status"], remote_name=None)
+            print_commands_status(status["commands_status"], status["summary"])
             print()
-
         print("=" * 80)
 
     def run_monitoring_routine(self, wait_ms: int = 30000) -> None:
@@ -288,126 +216,59 @@ class WTLocalManager:
         sched.run(max_cycles=None)
 
     def save(self, session_id: Optional[str] = None) -> str:
-        """Save the manager state to disk."""
         if session_id is None:
-            session_id = str(uuid.uuid4())[:8]
-
-        # Create session directory
+            session_id = generate_session_id()
         session_dir = TMP_SERIALIZATION_DIR / session_id
-        session_dir.mkdir(parents=True, exist_ok=True)
-
-        # Save the session2wt_tabs configuration
-        config_file = session_dir / "session_layouts.json"
-        text = json.dumps(self.session_layouts, indent=2, ensure_ascii=False)
-        config_file.write_text(text, encoding="utf-8")
-
-        # Save metadata
+        ensure_session_dir_exists(session_dir)
+        save_json_file(session_dir / "session_layouts.json", self.session_layouts, "session layouts")
         metadata = {"session_name_prefix": self.session_name_prefix, "created_at": str(datetime.now()), "num_managers": len(self.managers), "sessions": [item["layoutName"] for item in self.session_layouts], "manager_type": "WTLocalManager"}
-        metadata_file = session_dir / "metadata.json"
-        text = json.dumps(metadata, indent=2, ensure_ascii=False)
-        metadata_file.write_text(text, encoding="utf-8")
-
-        # Save each manager's state
+        save_json_file(session_dir / "metadata.json", metadata, "metadata")
         managers_dir = session_dir / "managers"
         managers_dir.mkdir(exist_ok=True)
-
         for i, manager in enumerate(self.managers):
             manager_data = {"session_name": manager.session_name, "layout_config": manager.layout_config, "script_path": manager.script_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")
-
+            save_json_file(managers_dir / f"manager_{i}_{manager.session_name}.json", manager_data, f"manager {i}")
         logger.info(f"✅ Saved WTLocalManager session to: {session_dir}")
         return session_id
 
     @classmethod
     def load(cls, session_id: str) -> "WTLocalManager":
-        """Load a saved manager state from disk."""
         session_dir = TMP_SERIALIZATION_DIR / session_id
-
         if not session_dir.exists():
             raise FileNotFoundError(f"Session directory not found: {session_dir}")
-
-        # Load configuration
-        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)
-
-        # Load metadata
-        metadata_file = session_dir / "metadata.json"
-        session_name_prefix = "LocalWTMgr"  # default fallback
-        if metadata_file.exists():
-            text = metadata_file.read_text(encoding="utf-8")
-            metadata = json.loads(text)
-            session_name_prefix = metadata.get("session_name_prefix", "LocalWTMgr")
-
-        # Create new instance
+        loaded_data = load_json_file(session_dir / "session_layouts.json", "Configuration file")
+        session_layouts = loaded_data if isinstance(loaded_data, list) else []  # type: ignore[arg-type]
+        metadata_data = load_json_file(session_dir / "metadata.json", "Metadata file") if (session_dir / "metadata.json").exists() else {}
+        metadata = metadata_data if isinstance(metadata_data, dict) else {}  # type: ignore[arg-type]
+        session_name_prefix = metadata.get("session_name_prefix", "LocalWTMgr")  # type: ignore[union-attr]
         instance = cls(session_layouts=session_layouts, session_name_prefix=session_name_prefix)
-
-        # Load saved manager states
         managers_dir = session_dir / "managers"
         if managers_dir.exists():
             instance.managers = []
-            manager_files = sorted(managers_dir.glob("manager_*.json"))
-
-            for manager_file in manager_files:
+            for manager_file in sorted(managers_dir.glob("manager_*.json")):
                 try:
-                    text = manager_file.read_text(encoding="utf-8")
-                    manager_data = json.loads(text)
-
-                    # Recreate the manager
-                    manager = WTLayoutGenerator(layout_config=manager_data["layout_config"], session_name=manager_data["session_name"])
-                    manager.script_path = manager_data["script_path"]
-
+                    loaded_manager_data = load_json_file(manager_file, "Manager data")
+                    manager_data = loaded_manager_data if isinstance(loaded_manager_data, dict) else {}  # type: ignore[arg-type]
+                    manager = WTLayoutGenerator(layout_config=manager_data["layout_config"], session_name=manager_data["session_name"])  # type: ignore[typeddict-item]
+                    manager.script_path = manager_data["script_path"]  # type: ignore[typeddict-item]
                     instance.managers.append(manager)
-
                 except Exception as e:
                     logger.warning(f"Failed to load manager from {manager_file}: {e}")
-
         logger.info(f"✅ Loaded WTLocalManager session from: {session_dir}")
         return instance
 
     @staticmethod
     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)
+        return list_saved_sessions_in_dir(TMP_SERIALIZATION_DIR)
 
     @staticmethod
     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:
-            import shutil
-
-            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
+        return delete_session_dir(TMP_SERIALIZATION_DIR / session_id, session_id)
 
     def list_active_sessions(self) -> list[ActiveSessionInfo]:
-        """List currently active Windows Terminal sessions managed by this instance."""
-        active_sessions = []
+        active_sessions: list[ActiveSessionInfo] = []
 
         try:
-            # Get all running Windows Terminal processes
             result = subprocess.run(
                 ["powershell", "-Command", 'Get-Process -Name "WindowsTerminal" -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, StartTime, MainWindowTitle | ConvertTo-Json -Depth 2'], capture_output=True, text=True, timeout=10
             )
@@ -419,7 +280,6 @@ class WTLocalManager:
                 if not isinstance(all_processes, list):
                     all_processes = [all_processes]
 
-                # Filter to only our managed sessions
                 for manager in self.managers:
                     session_name = manager.session_name
                     session_windows = []
@@ -435,7 +295,6 @@ class WTLocalManager:
                             "is_active": len(session_windows) > 0,
                             "tab_count": len(manager.layout_config["layoutTabs"]) if manager.layout_config else 0,
                             "tabs": [tab["tabName"] for tab in manager.layout_config["layoutTabs"]] if manager.layout_config else [],
-                            "windows": session_windows,
                         }
                     )