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

machineconfig/cluster/sessions_managers/wt_utils/status_reporter.py

@@ -4,9 +4,10 @@ Status reporting utilities for Windows Terminal layouts and sessions.
 """
 
 import logging
-from typing import Dict, Any, Tuple
-from .process_monitor import WTProcessMonitor
-from .session_manager import WTSessionManager
+from typing import Dict, Any, List
+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.layout_types import TabConfig
 
 logger = logging.getLogger(__name__)
 
@@ -18,10 +19,10 @@ class WTStatusReporter:
         self.process_monitor = process_monitor
         self.session_manager = session_manager
 
-    def get_comprehensive_status(self, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def get_comprehensive_status(self, tabs: List[TabConfig]) -> Dict[str, Any]:
         """Get comprehensive status including Windows Terminal session and all commands."""
         wt_status = self.session_manager.check_wt_session_status()
-        commands_status = self.process_monitor.check_all_commands_status(tab_config)
+        commands_status = self.process_monitor.check_all_commands_status(tabs)
 
         running_count = sum(1 for status in commands_status.values() if status.get("running", False))
         total_count = len(commands_status)
@@ -32,9 +33,9 @@ class WTStatusReporter:
             "summary": {"total_commands": total_count, "running_commands": running_count, "stopped_commands": total_count - running_count, "session_healthy": wt_status.get("session_exists", False), "location": wt_status.get("location", "unknown")},
         }
 
-    def print_status_report(self, tab_config: Dict[str, Tuple[str, str]]) -> None:
+    def print_status_report(self, tabs: List[TabConfig]) -> None:
         """Print a comprehensive status report for the Windows Terminal session."""
-        status = self.get_comprehensive_status(tab_config)
+        status = self.get_comprehensive_status(tabs)
         wt_session = status["wt_session"]
         commands = status["commands"]
         summary = status["summary"]
@@ -156,10 +157,10 @@ class WTStatusReporter:
 
         print("=" * 80)
 
-    def generate_status_summary(self, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def generate_status_summary(self, tabs: List[TabConfig]) -> Dict[str, Any]:
         """Generate a concise status summary suitable for monitoring."""
         try:
-            comprehensive_status = self.get_comprehensive_status(tab_config)
+            comprehensive_status = self.get_comprehensive_status(tabs)
             wt_overview = self.get_windows_terminal_overview()
 
             summary = comprehensive_status["summary"]
@@ -182,17 +183,18 @@ class WTStatusReporter:
             logger.error(f"Failed to generate status summary: {e}")
             return {"error": str(e), "session_name": self.session_manager.session_name, "location": self.process_monitor.location_name}
 
-    def check_tab_specific_status(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def check_tab_specific_status(self, tab_name: str, tabs: List[TabConfig]) -> Dict[str, Any]:
         """Get detailed status for a specific tab."""
-        if tab_name not in tab_config:
+        if next((t for t in tabs if t["tabName"] == tab_name), None) is None:
             return {"error": f"Tab '{tab_name}' not found in configuration", "tab_name": tab_name}
 
         try:
-            cmd_status = self.process_monitor.check_command_status(tab_name, tab_config)
+            cmd_status = self.process_monitor.check_command_status(tab_name, tabs)
 
             # Add additional context
-            cwd, command = tab_config[tab_name]
-            cmd_status["tab_config"] = {"working_directory": cwd, "command": command}
+            the_tab = next((t for t in tabs if t["tabName"] == tab_name), None)
+            if the_tab is not None:
+                cmd_status["tab_config"] = {"working_directory": the_tab["startDir"], "command": the_tab["command"]}
 
             return cmd_status
         except Exception as e:

machineconfig/cluster/sessions_managers/zellij_local.py

@@ -10,6 +10,8 @@ import logging
 
 from rich.console import Console
 
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig, TabConfig
+
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 console = Console()
@@ -19,7 +21,7 @@ TMP_LAYOUT_DIR = Path.home().joinpath("tmp_results", "session_manager", "zellij"
 class ZellijLayoutGenerator:
     def __init__(self):
         self.session_name: Optional[str] = None
-        self.tab_config: Dict[str, tuple[str, str]] = {}  # Store entire tab config (cwd, command) for status checking
+        self.layout_config: Optional[LayoutConfig] = None  # Store the complete layout config
         self.layout_path: Optional[str] = None  # Store the full path to the layout file
         self.layout_template = """layout {
     default_tab_template {
@@ -62,7 +64,11 @@ class ZellijLayoutGenerator:
         return " ".join(formatted_args)
 
     @staticmethod
-    def _create_tab_section(tab_name: str, cwd: str, command: str) -> str:
+    def _create_tab_section(tab_config: TabConfig) -> str:
+        tab_name = tab_config["tabName"]
+        cwd = tab_config["startDir"]
+        command = tab_config["command"]
+
         cmd, args = ZellijLayoutGenerator._parse_command(command)
         args_str = ZellijLayoutGenerator._format_args_for_kdl(args)
         tab_cwd = cwd or "~"
@@ -75,36 +81,38 @@ class ZellijLayoutGenerator:
         return tab_section
 
     @staticmethod
-    def _validate_tab_config(tab_config: Dict[str, tuple[str, str]]) -> None:
-        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 create_zellij_layout(self, tab_config: Dict[str, tuple[str, str]], output_dir: Optional[str] = None, session_name: Optional[str] = None) -> str:
-        ZellijLayoutGenerator._validate_tab_config(tab_config)
+    def _validate_layout_config(layout_config: LayoutConfig) -> None:
+        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']}")
+
+    def create_zellij_layout(self, layout_config: LayoutConfig, output_dir: Optional[str] = None, session_name: Optional[str] = None) -> str:
+        ZellijLayoutGenerator._validate_layout_config(layout_config)
 
         # Enhanced Rich logging
-        tab_count = len(tab_config)
-        console.print(f"[bold cyan]📋 Creating Zellij layout[/bold cyan] [bright_green]with {tab_count} tabs[/bright_green]")
+        tab_count = len(layout_config["layoutTabs"])
+        layout_name = layout_config["layoutName"]
+        console.print(f"[bold cyan]📋 Creating Zellij layout[/bold cyan] [bright_green]'{layout_name}' with {tab_count} tabs[/bright_green]")
 
         # Display tab summary with emojis and colors
-        for tab_name, (cwd, command) in tab_config.items():
-            console.print(f"  [yellow]→[/yellow] [bold]{tab_name}[/bold] [dim]in[/dim] [blue]{cwd}[/blue]")
+        for tab in layout_config["layoutTabs"]:
+            console.print(f"  [yellow]→[/yellow] [bold]{tab['tabName']}[/bold] [dim]in[/dim] [blue]{tab['startDir']}[/blue]")
 
-        # Store session name and entire tab config for status checking
-        self.session_name = session_name or "default"
-        self.tab_config = tab_config.copy()
+        # Store session name and layout config for status checking
+        self.session_name = session_name or layout_name
+        self.layout_config = layout_config.copy()
 
         layout_content = self.layout_template
-        for tab_name, (cwd, command) in tab_config.items():
-            layout_content += "\n" + ZellijLayoutGenerator._create_tab_section(tab_name, cwd, command)
+        for tab in layout_config["layoutTabs"]:
+            layout_content += "\n" + ZellijLayoutGenerator._create_tab_section(tab)
         layout_content += "\n}\n"
+
         try:
             random_suffix = ZellijLayoutGenerator._generate_random_suffix()
             if output_dir:
@@ -128,7 +136,7 @@ class ZellijLayoutGenerator:
             raise
 
     @staticmethod
-    def get_layout_preview(tab_config: Dict[str, tuple[str, str]], layout_template: str | None = None) -> str:
+    def get_layout_preview(layout_config: LayoutConfig, layout_template: str | None = None) -> str:
         if layout_template is None:
             layout_template = """layout {
     default_tab_template {
@@ -139,18 +147,26 @@ class ZellijLayoutGenerator:
         children
     }
 """
-        ZellijLayoutGenerator._validate_tab_config(tab_config)
+        ZellijLayoutGenerator._validate_layout_config(layout_config)
         layout_content = layout_template
-        for tab_name, (cwd, command) in tab_config.items():
-            layout_content += "\n" + ZellijLayoutGenerator._create_tab_section(tab_name, cwd, command)
+        for tab in layout_config["layoutTabs"]:
+            layout_content += "\n" + ZellijLayoutGenerator._create_tab_section(tab)
         return layout_content + "\n}\n"
 
     @staticmethod
-    def check_command_status(tab_name: str, tab_config: Dict[str, tuple[str, str]]) -> Dict[str, Any]:
-        if tab_name not in tab_config:
-            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in tracked tab config", "running": False, "pid": None, "command": None, "cwd": None}
-
-        cwd, command = tab_config[tab_name]
+    def check_command_status(tab_name: str, layout_config: LayoutConfig) -> Dict[str, Any]:
+        # 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, "cwd": None}
+
+        command = tab_config["command"]
+        cwd = tab_config["startDir"]
         cmd, _ = ZellijLayoutGenerator._parse_command(command)
 
         try:
@@ -175,13 +191,14 @@ class ZellijLayoutGenerator:
             return {"status": "error", "error": str(e), "running": False, "command": command, "cwd": cwd, "tab_name": tab_name}
 
     def check_all_commands_status(self) -> Dict[str, Dict[str, Any]]:
-        if not self.tab_config:
-            logger.warning("No tab config tracked. Make sure to create a layout first.")
+        if not self.layout_config:
+            logger.warning("No layout config tracked. Make sure to create a layout first.")
             return {}
 
         status_report = {}
-        for tab_name in self.tab_config:
-            status_report[tab_name] = ZellijLayoutGenerator.check_command_status(tab_name, self.tab_config)
+        for tab in self.layout_config["layoutTabs"]:
+            tab_name = tab["tabName"]
+            status_report[tab_name] = ZellijLayoutGenerator.check_command_status(tab_name, self.layout_config)
 
         return status_report
 
@@ -289,20 +306,16 @@ class ZellijLayoutGenerator:
         console.print(Panel(summary_text, title="📊 Summary", style="blue"))
 
 
-def created_zellij_layout(tab_config: Dict[str, tuple[str, str]], output_dir: Optional[str] = None) -> str:
+def created_zellij_layout(layout_config: LayoutConfig, output_dir: Optional[str] = None) -> str:
     generator = ZellijLayoutGenerator()
-    return generator.create_zellij_layout(tab_config, output_dir)
+    return generator.create_zellij_layout(layout_config, output_dir)
 
 
-def run_zellij_layout(tab_config: Dict[str, tuple[str, str]], session_name: Optional[str] = None) -> str:
-    if not session_name:
-        session_name = "".join(random.choices(string.ascii_lowercase + string.digits, k=8))
-    layout_path = created_zellij_layout(tab_config)
-
-    # Use enhanced command execution
+def run_zellij_layout(layout_config: LayoutConfig):
+    layout_path = created_zellij_layout(layout_config)
+    session_name = layout_config["layoutName"]
     try:
-        from .enhanced_command_runner import enhanced_zellij_session_start
-
+        from machineconfig.cluster.sessions_managers.enhanced_command_runner import enhanced_zellij_session_start
         enhanced_zellij_session_start(session_name, layout_path)
     except ImportError:
         # Fallback to original implementation
@@ -311,7 +324,6 @@ def run_zellij_layout(tab_config: Dict[str, tuple[str, str]], session_name: Opti
 
         subprocess.run(cmd, shell=True, check=True)
         console.print(f"[bold green]🚀 Zellij layout is running[/bold green] [yellow]@[/yellow] [bold cyan]{session_name}[/bold cyan]")
-    return session_name
 
 
 def run_command_in_zellij_tab(command: str, tab_name: str, cwd: Optional[str]) -> str:
@@ -336,16 +348,21 @@ zellij action close-pane; sleep 2
 
 
 if __name__ == "__main__":
-    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"),
+    # Example usage with new schema
+    sample_layout: LayoutConfig = {
+        "layoutName": "SampleBots",
+        "layoutTabs": [
+            {"tabName": "🤖Bot1", "startDir": "~/code/bytesense/bithence", "command": "~/scripts/fire -mO go1.py bot1 --kw create_new_bot True"},
+            {"tabName": "🤖Bot2", "startDir": "~/code/bytesense/bithence", "command": "~/scripts/fire -mO go2.py bot2 --kw create_new_bot True"},
+            {"tabName": "📊Monitor", "startDir": "~", "command": "htop"},
+            {"tabName": "📝Logs", "startDir": "/var/log", "command": "tail -f /var/log/app.log"},
+        ],
     }
+
     try:
         # Create layout using the generator directly to access status methods
         generator = ZellijLayoutGenerator()
-        layout_path = generator.create_zellij_layout(sample_tabs, session_name="test_session")
+        layout_path = generator.create_zellij_layout(sample_layout, session_name="test_session")
         print(f"✅ Layout created successfully: {layout_path}")
 
         # Demonstrate status checking
@@ -354,9 +371,10 @@ if __name__ == "__main__":
 
         # Individual command status check
         print("\n🔎 Individual command status for Bot1:")
-        bot1_status = ZellijLayoutGenerator.check_command_status("🤖Bot1", generator.tab_config)
-        print(f"Status: {bot1_status['status']}")
-        print(f"Running: {bot1_status['running']}")
+        if generator.layout_config:
+            bot1_status = ZellijLayoutGenerator.check_command_status("🤖Bot1", generator.layout_config)
+            print(f"Status: {bot1_status['status']}")
+            print(f"Running: {bot1_status['running']}")
 
     except Exception as e:
         print(f"❌ Error: {e}")

machineconfig/cluster/sessions_managers/zellij_local_manager.py

@@ -12,6 +12,7 @@ from rich.console import Console
 
 from machineconfig.utils.utils5 import Scheduler
 from machineconfig.cluster.sessions_managers.zellij_local import ZellijLayoutGenerator
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -23,24 +24,25 @@ TMP_SERIALIZATION_DIR = Path.home().joinpath("tmp_results", "session_manager", "
 class ZellijLocalManager:
     """Manages multiple local zellij sessions and monitors their tabs and processes."""
 
-    def __init__(self, session2zellij_tabs: Dict[str, Dict[str, tuple[str, str]]], session_name_prefix: str = "LocalJobMgr"):
+    def __init__(self, session_layouts: list[LayoutConfig], session_name_prefix: str = "LocalJobMgr"):
         """
         Initialize the local zellij manager.
 
         Args:
-            session2zellij_tabs: Dict mapping session names to their tab configs
-                Format: {session_name: {tab_name: (cwd, command), ...}, ...}
+            session_layouts: Dict mapping session names to their layout configs
+                Format: {session_name: LayoutConfig, ...}
             session_name_prefix: Prefix for session names
         """
         self.session_name_prefix = session_name_prefix
-        self.session2zellij_tabs = session2zellij_tabs  # Store the original config
+        self.session_layouts = session_layouts  # Store the original config
         self.managers: List[ZellijLayoutGenerator] = []
 
         # Create a ZellijLayoutGenerator for each session
-        for session_name, tab_config in session2zellij_tabs.items():
+        for layout_config in session_layouts:
+            session_name = layout_config["layoutName"].replace(" ", "_")
             manager = ZellijLayoutGenerator()
             full_session_name = f"{self.session_name_prefix}_{session_name}"
-            manager.create_zellij_layout(tab_config=tab_config, session_name=full_session_name)
+            manager.create_zellij_layout(layout_config=layout_config, session_name=full_session_name)
             self.managers.append(manager)
 
         # Enhanced Rich logging for initialization
@@ -326,13 +328,13 @@ class ZellijLocalManager:
         session_dir = TMP_SERIALIZATION_DIR / session_id
         session_dir.mkdir(parents=True, exist_ok=True)
 
-        # Save the session2zellij_tabs configuration
-        config_file = session_dir / "session2zellij_tabs.json"
-        text = json.dumps(self.session2zellij_tabs, indent=2, ensure_ascii=False)
+        # Save the session_layouts 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
-        metadata = {"session_name_prefix": self.session_name_prefix, "created_at": str(datetime.now()), "num_managers": len(self.managers), "sessions": list(self.session2zellij_tabs.keys()), "manager_type": "ZellijLocalManager"}
+        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": "ZellijLocalManager"}
         metadata_file = session_dir / "metadata.json"
         text = json.dumps(metadata, indent=2, ensure_ascii=False)
         metadata_file.write_text(text, encoding="utf-8")
@@ -342,7 +344,7 @@ class ZellijLocalManager:
         managers_dir.mkdir(exist_ok=True)
 
         for i, manager in enumerate(self.managers):
-            manager_data = {"session_name": manager.session_name, "tab_config": manager.tab_config, "layout_path": manager.layout_path}
+            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")
@@ -359,12 +361,12 @@ class ZellijLocalManager:
             raise FileNotFoundError(f"Session directory not found: {session_dir}")
 
         # Load configuration
-        config_file = session_dir / "session2zellij_tabs.json"
+        config_file = session_dir / "session_layouts.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:
-            session2zellij_tabs = json.load(f)
+            session_layouts = json.load(f)
 
         # Load metadata
         metadata_file = session_dir / "metadata.json"
@@ -375,7 +377,7 @@ class ZellijLocalManager:
                 session_name_prefix = metadata.get("session_name_prefix", "LocalJobMgr")
 
         # Create new instance
-        instance = cls(session2zellij_tabs=session2zellij_tabs, session_name_prefix=session_name_prefix)
+        instance = cls(session_layouts=session_layouts, session_name_prefix=session_name_prefix)
 
         # Load saved manager states
         managers_dir = session_dir / "managers"
@@ -391,7 +393,7 @@ class ZellijLocalManager:
                     # Recreate the manager
                     manager = ZellijLayoutGenerator()
                     manager.session_name = manager_data["session_name"]
-                    manager.tab_config = manager_data["tab_config"]
+                    manager.layout_config = manager_data["layout_config"]
                     manager.layout_path = manager_data["layout_path"]
 
                     instance.managers.append(manager)
@@ -452,7 +454,13 @@ class ZellijLocalManager:
                         continue  # Skip managers without a session name
                     is_active = any(session_name in session for session in all_sessions)
 
-                    active_sessions.append({"session_name": session_name, "is_active": is_active, "tab_count": len(manager.tab_config), "tabs": list(manager.tab_config.keys())})
+                    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}")
@@ -461,13 +469,33 @@ class ZellijLocalManager:
 
 
 if __name__ == "__main__":
-    # Example usage
-    sample_sessions = {
-        "development": {"🚀Frontend": ("~/code/myapp/frontend", "npm run dev"), "⚙️Backend": ("~/code/myapp/backend", "python manage.py runserver"), "📊Monitor": ("~", "htop")},
-        "testing": {"🧪Tests": ("~/code/myapp", "pytest --watch"), "🔍Coverage": ("~/code/myapp", "coverage run --source=. -m pytest"), "📝Logs": ("~/logs", "tail -f app.log")},
-        "deployment": {"🐳Docker": ("~/code/myapp", "docker-compose up"), "☸️K8s": ("~/k8s", "kubectl get pods --watch"), "📈Metrics": ("~", "k9s")},
-    }
-
+    # Example usage with new schema
+    sample_sessions: list[LayoutConfig] = [
+        {
+            "layoutName": "Development",
+            "layoutTabs": [
+                {"tabName": "🚀Frontend", "startDir": "~/code/myapp/frontend", "command": "npm run dev"},
+                {"tabName": "⚙️Backend", "startDir": "~/code/myapp/backend", "command": "python manage.py runserver"},
+                {"tabName": "📊Monitor", "startDir": "~", "command": "htop"},
+            ],
+        },
+        {
+            "layoutName": "Testing",
+            "layoutTabs": [
+                {"tabName": "🧪Tests", "startDir": "~/code/myapp", "command": "pytest --watch"},
+                {"tabName": "🔍Coverage", "startDir": "~/code/myapp", "command": "coverage run --source=. -m pytest"},
+                {"tabName": "📝Logs", "startDir": "~/logs", "command": "tail -f app.log"},
+            ],
+        },
+        {
+            "layoutName": "Deployment",
+            "layoutTabs": [
+                {"tabName": "🐳Docker", "startDir": "~/code/myapp", "command": "docker-compose up"},
+                {"tabName": "☸️K8s", "startDir": "~/k8s", "command": "kubectl get pods --watch"},
+                {"tabName": "📈Metrics", "startDir": "~", "command": "k9s"},
+            ],
+        },
+    ]
     try:
         # Create the local manager
         manager = ZellijLocalManager(sample_sessions, session_name_prefix="DevEnv")

machineconfig/cluster/sessions_managers/zellij_remote.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-from typing import Dict, Tuple, Optional, List, Union, Any
+from typing import Dict, Optional, List, Union, Any
 from pathlib import Path
 import logging
 import json
@@ -13,6 +13,7 @@ from machineconfig.cluster.sessions_managers.zellij_utils.layout_generator impor
 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
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -24,7 +25,7 @@ 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_config: Optional[LayoutConfig] = None
         self.layout_path: Optional[str] = None
 
         # Initialize modular components
@@ -37,40 +38,50 @@ class ZellijRemoteLayoutGenerator:
     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:
+    def create_zellij_layout(self, layout_config: LayoutConfig, 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]")
+        tab_count = len(layout_config["layoutTabs"])
+        layout_name = layout_config["layoutName"]
+        console.print(f"[bold cyan]📋 Creating Zellij layout[/bold cyan] [bright_green]'{layout_name}' 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]")
+        for tab in layout_config["layoutTabs"]:
+            console.print(f"  [yellow]→[/yellow] [bold]{tab['tabName']}[/bold] [dim]in[/dim] [blue]{tab['startDir']}[/blue] [dim]on[/dim] [yellow]{self.remote_name}[/yellow]")
 
-        self.tab_config = tab_config.copy()
+        self.layout_config = layout_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)
+        self.layout_path = self.layout_generator.create_layout_file(layout_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 get_layout_preview(self, layout_config: LayoutConfig) -> str:
+        return self.layout_generator.generate_layout_content(layout_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)
+        if not self.layout_config:
+            return {"status": "error", "error": "No layout config available", "running": False}
+        return self.process_monitor.check_command_status(tab_name, self.layout_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)
+        if not self.layout_config:
+            return {}
+        return self.process_monitor.check_all_commands_status(self.layout_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)
+        if not self.layout_config:
+            return {"error": "No layout config available"}
+        return self.status_reporter.get_comprehensive_status(self.layout_config)
 
     def print_status_report(self) -> None:
-        self.status_reporter.print_status_report(self.tab_config)
+        if not self.layout_config:
+            console.print("[bold red]❌ No layout config available[/bold red]")
+            return
+        self.status_reporter.print_status_report(self.layout_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)
@@ -80,13 +91,17 @@ class ZellijRemoteLayoutGenerator:
 
     # 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)
+        if not self.layout_config:
+            return {"error": "No layout config available"}
+        return self.process_monitor.force_fresh_process_check(tab_name, self.layout_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)
+        if not self.layout_config:
+            return {"error": "No layout config available"}
+        return self.process_monitor.get_verified_process_status(tab_name, self.layout_config)
 
     # Static methods for backward compatibility
     @staticmethod
@@ -95,7 +110,7 @@ class ZellijRemoteLayoutGenerator:
         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__}
+        return {"remote_name": self.remote_name, "session_name": self.session_name, "layout_config": self.layout_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
@@ -154,7 +169,7 @@ class ZellijRemoteLayoutGenerator:
 
         # Restore state
         instance.session_name = data["session_name"]
-        instance.tab_config = data["tab_config"]
+        instance.layout_config = data["layout_config"]
         instance.layout_path = data["layout_path"]
 
         logger.info(f"✅ Loaded ZellijRemoteLayoutGenerator from: {file_path}")
@@ -175,12 +190,15 @@ class ZellijRemoteLayoutGenerator:
 
 
 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"),
+    # Example usage with new schema
+    sample_layout: LayoutConfig = {
+        "layoutName": "RemoteBots",
+        "layoutTabs": [
+            {"tabName": "🤖Bot1", "startDir": "~/code/bytesense/bithence", "command": "~/scripts/fire -mO go1.py bot1 --kw create_new_bot True"},
+            {"tabName": "🤖Bot2", "startDir": "~/code/bytesense/bithence", "command": "~/scripts/fire -mO go2.py bot2 --kw create_new_bot True"},
+            {"tabName": "📊Monitor", "startDir": "~", "command": "htop"},
+            {"tabName": "📝Logs", "startDir": "/var/log", "command": "tail -f /var/log/app.log"},
+        ],
     }
 
     # Replace 'myserver' with an actual SSH config alias
@@ -190,7 +208,7 @@ if __name__ == "__main__":
     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)
+        layout_path = generator.create_zellij_layout(sample_layout)
         print(f"✅ Remote layout created successfully: {layout_path}")
 
         # Demonstrate serialization
@@ -205,7 +223,9 @@ if __name__ == "__main__":
         # 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())}")
+        if loaded_generator.layout_config:
+            tab_names = [tab["tabName"] for tab in loaded_generator.layout_config["layoutTabs"]]
+            print(f"📊 Loaded tabs: {tab_names}")
 
         # Demonstrate status checking
         print(f"\n🔍 Checking command status on remote '{remote_name}':")