machineconfig 1.94__py3-none-any.whl → 1.96__py3-none-any.whl

machineconfig/cluster/sessions_managers/zellij_remote.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+from typing import Dict, Tuple, Optional, List, Union, Any
+from pathlib import Path
+import logging
+import json
+import uuid
+from datetime import datetime
+
+from rich.console import Console
+
+from machineconfig.cluster.sessions_managers.zellij_utils.remote_executor import RemoteExecutor
+from machineconfig.cluster.sessions_managers.zellij_utils.layout_generator import LayoutGenerator
+from machineconfig.cluster.sessions_managers.zellij_utils.process_monitor import ProcessMonitor
+from machineconfig.cluster.sessions_managers.zellij_utils.session_manager import SessionManager
+from machineconfig.cluster.sessions_managers.zellij_utils.status_reporter import StatusReporter
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+console = Console()
+TMP_LAYOUT_DIR = Path.home().joinpath("tmp_results", "zellij_layouts", "layout_manager")
+
+
+class ZellijRemoteLayoutGenerator:
+    
+    def __init__(self, remote_name: str, session_name_prefix: str):
+        self.remote_name = remote_name
+        self.session_name = session_name_prefix + "_" + LayoutGenerator.generate_random_suffix()
+        self.tab_config: Dict[str, Tuple[str, str]] = {}
+        self.layout_path: Optional[str] = None
+        
+        # Initialize modular components
+        self.remote_executor = RemoteExecutor(remote_name)
+        self.layout_generator = LayoutGenerator()
+        self.process_monitor = ProcessMonitor(self.remote_executor)
+        self.session_manager = SessionManager(self.remote_executor, self.session_name, TMP_LAYOUT_DIR)
+        self.status_reporter = StatusReporter(self.process_monitor, self.session_manager)
+    
+    def copy_layout_to_remote(self, local_layout_file: Path, random_suffix: str) -> str:
+        return self.session_manager.copy_layout_to_remote(local_layout_file, random_suffix)
+
+    def create_zellij_layout(self, tab_config: Dict[str, Tuple[str, str]], output_dir: Optional[str] = None) -> str:
+        # Enhanced Rich logging for remote layout creation
+        tab_count = len(tab_config)
+        console.print(f"[bold cyan]📋 Creating Zellij layout[/bold cyan] [bright_green]with {tab_count} tabs[/bright_green] [magenta]for remote[/magenta] [bold yellow]'{self.remote_name}'[/bold yellow]")
+        
+        # Display tab summary for remote
+        for tab_name, (cwd, _) in tab_config.items():
+            console.print(f"  [yellow]→[/yellow] [bold]{tab_name}[/bold] [dim]in[/dim] [blue]{cwd}[/blue] [dim]on[/dim] [yellow]{self.remote_name}[/yellow]")
+        
+        self.tab_config = tab_config.copy()
+        if output_dir:
+            output_path = Path(output_dir)
+        else:
+            output_path = TMP_LAYOUT_DIR
+        self.layout_path = self.layout_generator.create_layout_file(tab_config, output_path, self.session_name)        
+        return self.layout_path
+    
+    def get_layout_preview(self, tab_config: Dict[str, Tuple[str, str]]) -> str:
+        return self.layout_generator.generate_layout_content(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_zellij_session_status(self) -> Dict[str, Any]:
+        return self.session_manager.check_zellij_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_zellij_session(self, layout_file_path: Optional[str] = None) -> Dict[str, Any]:
+        return self.session_manager.start_zellij_session(layout_file_path or self.layout_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 = RemoteExecutor(remote_name)
+        return executor.run_command(command, timeout)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "remote_name": self.remote_name,
+            "session_name": self.session_name,
+            "tab_config": self.tab_config,
+            "layout_path": self.layout_path,
+            "created_at": datetime.now().isoformat(),
+            "class_name": self.__class__.__name__
+        }
+
+    def to_json(self, file_path: Optional[Union[str, Path]] = None) -> str:
+        # Generate file path if not provided
+        if file_path is None:
+            random_id = str(uuid.uuid4())[:8]
+            default_dir = Path.home() / "tmp_results" / "zellij_sessions" / "serialized"
+            default_dir.mkdir(parents=True, exist_ok=True)
+            file_path_obj = default_dir / f"zellij_session_{random_id}.json"
+        else:
+            file_path_obj = Path(file_path)
+        
+        # Ensure .json extension
+        if not str(file_path_obj).endswith('.json'):
+            file_path_obj = file_path_obj.with_suffix('.json')
+            
+        # Ensure parent directory exists
+        file_path_obj.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Serialize to JSON
+        data = self.to_dict()
+        
+        with open(file_path_obj, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+        
+        logger.info(f"✅ Serialized ZellijRemoteLayoutGenerator to: {file_path_obj}")
+        return str(file_path_obj)
+
+    @classmethod
+    def from_json(cls, file_path: Union[str, Path]) -> 'ZellijRemoteLayoutGenerator':
+        file_path = Path(file_path)
+        
+        # Ensure .json extension
+        if not str(file_path).endswith('.json'):
+            file_path = file_path.with_suffix('.json')
+            
+        if not file_path.exists():
+            raise FileNotFoundError(f"JSON file not found: {file_path}")
+        
+        # Load JSON data
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        # Validate that it's the correct class
+        if data.get('class_name') != cls.__name__:
+            logger.warning(f"Class name mismatch: expected {cls.__name__}, got {data.get('class_name')}")
+        
+        # Create new instance
+        # Extract session name prefix by removing the suffix
+        session_name = data['session_name']
+        if '_' in session_name:
+            session_name_prefix = '_'.join(session_name.split('_')[:-1])
+        else:
+            session_name_prefix = session_name
+            
+        instance = cls(remote_name=data['remote_name'], session_name_prefix=session_name_prefix)
+        
+        # Restore state
+        instance.session_name = data['session_name']
+        instance.tab_config = data['tab_config']
+        instance.layout_path = data['layout_path']
+        
+        logger.info(f"✅ Loaded ZellijRemoteLayoutGenerator from: {file_path}")
+        return instance
+
+    @staticmethod
+    def list_saved_sessions(directory_path: Optional[Union[str, Path]] = None) -> List[str]:
+        if directory_path is None:
+            directory_path = Path.home() / "tmp_results" / "zellij_sessions" / "serialized"
+        else:
+            directory_path = Path(directory_path)
+            
+        if not directory_path.exists():
+            return []
+        
+        json_files = [f.name for f in directory_path.glob("*.json")]
+        return sorted(json_files)
+
+if __name__ == "__main__":
+    # Example usage
+    sample_tabs = {
+        "🤖Bot1": ("~/code/bytesense/bithence", "~/scripts/fire -mO go1.py bot1 --kw create_new_bot True"),
+        "🤖Bot2": ("~/code/bytesense/bithence", "~/scripts/fire -mO go2.py bot2 --kw create_new_bot True"), 
+        "📊Monitor": ("~", "htop"),
+        "📝Logs": ("/var/log", "tail -f /var/log/app.log")
+    }
+    
+    # Replace 'myserver' with an actual SSH config alias
+    remote_name = "myserver"  # This should be in ~/.ssh/config
+    session_name = "test_remote_session"
+    
+    try:
+        # Create layout using the remote generator
+        generator = ZellijRemoteLayoutGenerator(remote_name=remote_name, session_name_prefix=session_name)
+        layout_path = generator.create_zellij_layout(sample_tabs)
+        print(f"✅ Remote layout created successfully: {layout_path}")
+        
+        # Demonstrate serialization
+        print("\n💾 Demonstrating serialization...")
+        saved_path = generator.to_json()
+        print(f"✅ Session saved to: {saved_path}")
+        
+        # List all saved sessions
+        saved_sessions = ZellijRemoteLayoutGenerator.list_saved_sessions()
+        print(f"📋 Available saved sessions: {saved_sessions}")
+        
+        # Demonstrate loading (using the full path)
+        loaded_generator = ZellijRemoteLayoutGenerator.from_json(saved_path)
+        print(f"✅ Session loaded successfully: {loaded_generator.session_name}")
+        print(f"📊 Loaded tabs: {list(loaded_generator.tab_config.keys())}")
+        
+        # Demonstrate status checking
+        print(f"\n🔍 Checking command status on remote '{remote_name}':")
+        generator.print_status_report()
+        
+        # Start the session (uncomment to actually start)
+        # start_result = generator.start_zellij_session()
+        # print(f"Session start result: {start_result}")
+        
+        # Attach to session (uncomment to attach)
+        # generator.attach_to_session()
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")

machineconfig/cluster/sessions_managers/zellij_remote_manager.py

@@ -0,0 +1,188 @@
+from datetime import datetime
+import json
+import uuid
+import logging
+from pathlib import Path
+from typing import Optional
+from machineconfig.utils.utils5 import Scheduler
+from machineconfig.cluster.sessions_managers.zellij_local import run_command_in_zellij_tab
+from machineconfig.cluster.sessions_managers.zellij_remote import ZellijRemoteLayoutGenerator
+
+
+TMP_SERIALIAZATION_DIR = Path.home().joinpath("tmp_results", "session_manager", "zellij", "remote_manager")
+
+
+class ZellijSessionManager:
+    def __init__(self, machine2zellij_tabs: dict[str, dict[str, tuple[str, str]]], session_name_prefix: str = "JobMgr"):
+        self.session_name_prefix = session_name_prefix
+        self.machine2zellij_tabs = machine2zellij_tabs  # Store the original config
+        self.managers: list[ZellijRemoteLayoutGenerator] = []
+        for machine, tab_config in machine2zellij_tabs.items():
+            an_m = ZellijRemoteLayoutGenerator(remote_name=machine, session_name_prefix=self.session_name_prefix)
+            an_m.create_zellij_layout(tab_config=tab_config)
+            self.managers.append(an_m)
+
+    def ssh_to_all_machines(self) -> str:
+        hostname2zellij_session = {}
+        for an_m in self.managers:
+            hostname = an_m.remote_name
+            session_name = an_m.session_name
+            hostname2zellij_session[hostname] = session_name
+        cmds = ""
+        for hostname, session_name in hostname2zellij_session.items():
+            # ssh hpc-node024 -t "zellij attach JobMgrd074muex"
+            ssh_cmd = f"ssh {hostname} -t 'zellij attach {session_name}'"
+            a_cmd = run_command_in_zellij_tab(command=ssh_cmd, tab_name=hostname, cwd=None)
+            cmds += a_cmd + "\n"
+        return cmds
+    
+    def kill_all_sessions(self) -> None:
+        for an_m in self.managers:
+            ZellijRemoteLayoutGenerator.run_remote_command(
+                remote_name=an_m.remote_name,
+                command="zellij kill-all-sessions --yes"
+            )
+    
+    def start_zellij_sessions(self) -> None:
+        for an_m in self.managers:
+            an_m.start_zellij_session()
+
+    def run_monitoring_routine(self) -> 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()
+                    statuses.append(a_status)
+                keys = []
+                for item in statuses:
+                    keys.extend(item.keys())
+                values = []
+                for item in statuses:
+                    values.extend(item.values())
+                # Create list of dictionaries instead of DataFrame
+                status_data = []
+                for i, key in enumerate(keys):
+                    if i < len(values):
+                        status_data.append({"tabName": key, "status": values[i]})
+                
+                # Check if all stopped
+                running_count = sum(1 for item in status_data if item.get("status", {}).get("running", False))
+                if running_count == 0:  # they all stopped
+                    sched.max_cycles = sched.cycle  # stop the scheduler from calling this routine again
+                
+                # Print status
+                for item in status_data:
+                    print(f"Tab: {item['tabName']}, Status: {item['status']}")
+            else:
+                statuses = []
+                for _idx, an_m in enumerate(self.managers):
+                    a_status = an_m.check_zellij_session_status()
+                    statuses.append(a_status)
+                
+                # Print statuses
+                for i, status in enumerate(statuses):
+                    print(f"Manager {i}: {status}")
+        sched = Scheduler(routine=routine, wait_ms=60000)  # 60 seconds
+        sched.run()
+
+    def save(self, session_id: Optional[str] = None) -> str:
+        if session_id is None:
+            session_id = str(uuid.uuid4())[:8]
+        
+        # Create session directory
+        session_dir = TMP_SERIALIAZATION_DIR / session_id
+        session_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Save the machine2zellij_tabs configuration
+        config_file = session_dir / "machine2zellij_tabs.json"
+        with open(config_file, 'w', encoding='utf-8') as f:
+            json.dump(self.machine2zellij_tabs, f, indent=2, ensure_ascii=False)
+        
+        # Save session metadata
+        metadata = {
+            "session_name_prefix": self.session_name_prefix,
+            "created_at": str(datetime.now()),
+            "num_managers": len(self.managers),
+            "machines": list(self.machine2zellij_tabs.keys())
+        }
+        metadata_file = session_dir / "metadata.json"
+        with open(metadata_file, 'w', encoding='utf-8') as f:
+            json.dump(metadata, f, indent=2, ensure_ascii=False)
+        
+        # Save each ZellijRemoteLayoutGenerator
+        managers_dir = session_dir / "managers"
+        managers_dir.mkdir(exist_ok=True)
+        
+        for i, manager in enumerate(self.managers):
+            manager_file = managers_dir / f"manager_{i}_{manager.remote_name}.json"
+            manager.to_json(str(manager_file))
+        
+        logging.info(f"✅ Saved ZellijSessionManager session to: {session_dir}")
+        return session_id
+
+    @classmethod
+    def load(cls, session_id: str) -> 'ZellijSessionManager':
+        session_dir = TMP_SERIALIAZATION_DIR / session_id
+        
+        if not session_dir.exists():
+            raise FileNotFoundError(f"Session directory not found: {session_dir}")        
+        config_file = session_dir / "machine2zellij_tabs.json"
+        if not config_file.exists():
+            raise FileNotFoundError(f"Configuration file not found: {config_file}")        
+        with open(config_file, 'r', encoding='utf-8') as f:
+            machine2zellij_tabs = json.load(f)
+        
+        # Load metadata
+        metadata_file = session_dir / "metadata.json"
+        session_name_prefix = "JobMgr"  # default fallback
+        if metadata_file.exists():
+            with open(metadata_file, 'r', encoding='utf-8') as f:
+                metadata = json.load(f)
+                session_name_prefix = metadata.get("session_name_prefix", "JobMgr")        
+        # Create new instance (this will create new managers)
+        instance = cls(machine2zellij_tabs=machine2zellij_tabs, session_name_prefix=session_name_prefix)
+        # Load saved managers to restore their states
+        managers_dir = session_dir / "managers"
+        if managers_dir.exists():
+            # Clear the auto-created managers and load the saved ones
+            instance.managers = []
+            # Get all manager files and sort them
+            manager_files = sorted(managers_dir.glob("manager_*.json"))            
+            for manager_file in manager_files:
+                try:
+                    loaded_manager = ZellijRemoteLayoutGenerator.from_json(str(manager_file))
+                    instance.managers.append(loaded_manager)
+                except Exception as e:
+                    logging.warning(f"Failed to load manager from {manager_file}: {e}")
+        logging.info(f"✅ Loaded ZellijSessionManager session from: {session_dir}")
+        return instance
+
+    @staticmethod
+    def list_saved_sessions() -> list[str]:
+        if not TMP_SERIALIAZATION_DIR.exists():
+            return []
+        
+        sessions = []
+        for item in TMP_SERIALIAZATION_DIR.iterdir():
+            if item.is_dir() and (item / "metadata.json").exists():
+                sessions.append(item.name)
+        
+        return sorted(sessions)
+
+    @staticmethod
+    def delete_session(session_id: str) -> bool:
+        session_dir = TMP_SERIALIAZATION_DIR / session_id
+        
+        if not session_dir.exists():
+            logging.warning(f"Session directory not found: {session_dir}")
+            return False
+        
+        try:
+            import shutil
+            shutil.rmtree(session_dir)
+            logging.info(f"✅ Deleted session: {session_id}")
+            return True
+        except Exception as e:
+            logging.error(f"Failed to delete session {session_id}: {e}")
+            return False

machineconfig/cluster/sessions_managers/zellij_utils/example_usage.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""
+Example usage of the modularized Zellij remote layout generator.
+"""
+
+from machineconfig.cluster.sessions_managers.zellij_remote import ZellijRemoteLayoutGenerator
+
+def example_usage():
+    """Demonstrate the refactored modular usage."""
+    
+    # Sample tab configuration
+    sample_tabs = {
+        "🤖Bot1": ("~/code/bytesense/bithence", "~/scripts/fire -mO go1.py bot1 --kw create_new_bot True"),
+        "🤖Bot2": ("~/code/bytesense/bithence", "~/scripts/fire -mO go2.py bot2 --kw create_new_bot True"), 
+        "📊Monitor": ("~", "htop"),
+        "📝Logs": ("/var/log", "tail -f /var/log/app.log")
+    }
+    
+    # Replace 'myserver' with an actual SSH config alias
+    remote_name = "myserver"  # This should be in ~/.ssh/config
+    session_name = "test_remote_session"
+    
+    try:
+        # Create layout using the remote generator
+        generator = ZellijRemoteLayoutGenerator(remote_name=remote_name, session_name_prefix=session_name)
+        
+        # Create layout file
+        layout_path = generator.create_zellij_layout(sample_tabs)
+        print(f"✅ Remote layout created successfully: {layout_path}")
+        
+        # Preview the layout content
+        preview = generator.get_layout_preview(sample_tabs)
+        print(f"📄 Layout preview:\n{preview}")
+        
+        # Check status using the modular components
+        print(f"\n🔍 Checking command status on remote '{remote_name}':")
+        generator.print_status_report()
+        
+        # The individual components can also be used directly:
+        print(f"\n🔧 Direct component usage examples:")
+        
+        # Use remote executor directly
+        print(f"Remote executor: {generator.remote_executor.remote_name}")
+        
+        # Use layout generator directly  
+        layout_content = generator.layout_generator.generate_layout_content(sample_tabs)
+        print(f"Layout content length: {len(layout_content)} characters")
+        
+        # Use process monitor directly
+        status = generator.process_monitor.check_all_commands_status(sample_tabs)
+        print(f"Command status check completed for {len(status)} commands")
+        
+        print("\n✅ All modular components working correctly!")
+        
+        # Uncomment these to actually start and attach to the session:
+        # start_result = generator.start_zellij_session()
+        # print(f"Session start result: {start_result}")
+        # generator.attach_to_session()
+        
+    except Exception as e:
+        print(f"❌ Error: {e}")
+
+if __name__ == "__main__":
+    example_usage()

machineconfig/cluster/sessions_managers/zellij_utils/layout_generator.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""
+Zellij layout generation utilities for creating KDL layout files.
+"""
+import shlex
+import random
+import string
+from typing import Dict, List, Tuple
+from pathlib import Path
+import logging
+
+from rich.console import Console
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+class LayoutGenerator:
+    """Handles generation of Zellij KDL layout files."""
+    
+    LAYOUT_TEMPLATE = """layout {
+    default_tab_template {
+        // the default zellij tab-bar and status bar plugins
+        pane size=1 borderless=true {
+            plugin location="zellij:compact-bar"
+        }
+        children
+    }
+"""
+    
+    @staticmethod
+    def generate_random_suffix(length: int = 8) -> str:
+        """Generate a random string suffix for unique layout file names."""
+        return ''.join(random.choices(string.ascii_lowercase + string.digits, k=length))
+    
+    @staticmethod
+    def parse_command(command: str) -> Tuple[str, List[str]]:
+        """Parse a command string into command and arguments."""
+        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 format_args_for_kdl(args: List[str]) -> str:
+        """Format command arguments for KDL syntax."""
+        if not args: 
+            return ""
+        formatted_args = []
+        for arg in args:
+            if ' ' in arg or '"' in arg or "'" in arg:
+                escaped_arg = arg.replace('"', '\\"')
+                formatted_args.append(f'"{escaped_arg}"')
+            else:
+                formatted_args.append(f'"{arg}"')
+        return " ".join(formatted_args)
+    
+    @staticmethod
+    def create_tab_section(tab_name: str, cwd: str, command: str) -> str:
+        """Create a KDL tab section for the layout."""
+        cmd, args = LayoutGenerator.parse_command(command)
+        args_str = LayoutGenerator.format_args_for_kdl(args)
+        tab_cwd = cwd or "~"
+        escaped_tab_name = tab_name.replace('"', '\\"')
+        
+        tab_section = f'  tab name="{escaped_tab_name}" cwd="{tab_cwd}" {{\n'
+        tab_section += f'    pane command="{cmd}" {{\n'
+        if args_str: 
+            tab_section += f'      args {args_str}\n'
+        tab_section += '    }\n  }\n'
+        return tab_section
+    
+    @staticmethod
+    def validate_tab_config(tab_config: Dict[str, Tuple[str, str]]) -> None:
+        """Validate tab configuration format and content."""
+        if not tab_config: 
+            raise ValueError("Tab configuration cannot be empty")
+        for tab_name, (cwd, command) in tab_config.items():
+            if not tab_name.strip(): 
+                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_layout_content(self, tab_config: Dict[str, Tuple[str, str]]) -> str:
+        """Generate complete KDL layout content."""
+        self.validate_tab_config(tab_config)
+        
+        layout_content = self.LAYOUT_TEMPLATE
+        for tab_name, (cwd, command) in tab_config.items():
+            layout_content += "\n" + self.create_tab_section(tab_name, cwd, command)
+        layout_content += "\n}\n"
+        
+        return layout_content
+    
+    def create_layout_file(self, tab_config: Dict[str, Tuple[str, str]], 
+                          output_dir: Path, session_name: str) -> str:
+        """Create a layout file and return its absolute path."""
+        self.validate_tab_config(tab_config)
+        
+        # Generate unique suffix for this layout
+        random_suffix = self.generate_random_suffix()
+        layout_content = self.generate_layout_content(tab_config)
+        
+        try:
+            # Create output directory if it doesn't exist
+            output_dir.mkdir(parents=True, exist_ok=True)
+            layout_file = output_dir / f"zellij_layout_{session_name}_{random_suffix}.kdl"
+            
+            # Write layout file
+            with open(layout_file, 'w', encoding='utf-8') as f:
+                f.write(layout_content)
+            
+            # Enhanced Rich logging
+            console.print(f"[bold green]✅ Zellij layout file created:[/bold green] [cyan]{layout_file.absolute()}[/cyan]")
+            return str(layout_file.absolute())
+            
+        except OSError as e:
+            logger.error(f"Failed to create layout file: {e}")
+            raise