machineconfig 3.7__py3-none-any.whl → 7.69__py3-none-any.whl

machineconfig/cluster/sessions_managers/zellij_utils/zellij_local_helper.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+import shlex
+import subprocess
+import random
+import string
+import psutil
+import logging
+from typing import List
+from pathlib import Path
+
+from machineconfig.cluster.sessions_managers.zellij_utils.monitoring_types import CommandStatus, ZellijSessionStatus
+from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig, TabConfig
+
+
+logger = logging.getLogger(__name__)
+
+
+def generate_random_suffix(length: int) -> str:
+    """Generate a random string suffix for unique layout file names."""
+    return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
+
+
+def parse_command(command: str) -> tuple[str, List[str]]:
+    """Parse a command string into executable 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 []
+
+
+def format_args_for_kdl(args: List[str]) -> str:
+    """Format command arguments for KDL layout format."""
+    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)
+
+
+def create_tab_section(tab_config: TabConfig) -> str:
+    """Create a KDL tab section from tab configuration."""
+    tab_name = tab_config["tabName"]
+    cwd = tab_config["startDir"]
+    command = tab_config["command"]
+    cmd, args = parse_command(command)
+    args_str = 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
+
+
+def validate_layout_config(layout_config: LayoutConfig) -> None:
+    """Validate layout configuration."""
+    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 check_command_status(tab_name: str, layout_config: LayoutConfig) -> CommandStatus:
+    """Check the running status of a command for a specific tab."""
+    # 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, "command": "", "cwd": "", "tab_name": tab_name, "processes": []}
+
+    command = tab_config["command"]
+    cwd = tab_config["startDir"]
+    cmd, args = parse_command(command)
+    try:
+        shells = {"bash", "sh", "zsh", "fish"}
+        matching_processes = []
+        for proc in psutil.process_iter(["pid", "name", "cmdline", "status", "ppid", "create_time", "memory_info"]):
+            try:
+                info = proc.info
+                proc_cmdline: list[str] | None = info.get("cmdline")  # type: ignore[assignment]
+                if not proc_cmdline:
+                    continue
+                if info.get("status") in ["zombie", "dead", "stopped"]:
+                    continue
+                proc_name = info.get("name", "")
+                is_match = False
+                joined_cmdline = " ".join(proc_cmdline)
+                # Primary matching heuristics - more precise matching
+                if proc_name == cmd and cmd not in shells:
+                    # For non-shell commands, match if args appear in cmdline
+                    if not args or any(arg in joined_cmdline for arg in args):
+                        is_match = True
+                elif proc_name == cmd and cmd in shells:
+                    # For shell commands, require more precise matching to avoid false positives
+                    if args:
+                        # Check if all args appear as separate cmdline arguments (not just substrings)
+                        args_found = 0
+                        for arg in args:
+                            for cmdline_arg in proc_cmdline[1:]:  # Skip shell name
+                                if arg == cmdline_arg or (len(arg) > 3 and arg in cmdline_arg):
+                                    args_found += 1
+                                    break
+                        # Require at least as many args found as we're looking for
+                        if args_found >= len(args):
+                            is_match = True
+                elif cmd in proc_cmdline[0] and cmd not in shells:
+                    # Non-shell command in first argument
+                    is_match = True
+
+                # Additional shell wrapper filter - be more restrictive for shells
+                if is_match and proc_name in shells and args:
+                    # For shell processes, ensure the match is actually meaningful
+                    # Don't match generic shell sessions just because they contain common paths
+                    meaningful_match = False
+                    for arg in args:
+                        # Only consider it meaningful if the arg is substantial (not just a common path)
+                        if len(arg) > 10 and any(arg == cmdline_arg for cmdline_arg in proc_cmdline[1:]):
+                            meaningful_match = True
+                            break
+                        # Or if it's an exact script name match
+                        elif arg.endswith(".py") or arg.endswith(".sh") or arg.endswith(".rb"):
+                            if any(arg in cmdline_arg for cmdline_arg in proc_cmdline[1:]):
+                                meaningful_match = True
+                                break
+                    if not meaningful_match:
+                        is_match = False
+                if not is_match:
+                    continue
+                try:
+                    proc_obj = psutil.Process(info["pid"])  # type: ignore[index]
+                    if proc_obj.status() not in ["running", "sleeping"]:
+                        continue
+                    mem_info = None
+                    try:
+                        mem = proc_obj.memory_info()
+                        mem_info = mem.rss / (1024 * 1024)
+                    except (psutil.NoSuchProcess, psutil.AccessDenied):
+                        pass
+                    matching_processes.append(
+                        {
+                            "pid": info["pid"],  # type: ignore[index]
+                            "name": proc_name,
+                            "cmdline": proc_cmdline,
+                            "status": info.get("status", "unknown"),
+                            "cmdline_str": joined_cmdline,
+                            "create_time": info.get("create_time", 0.0),
+                            **({"memory_mb": float(mem_info)} if mem_info is not None else {}),
+                        }
+                    )
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    continue
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                continue
+
+        # Second-pass filtering: remove idle wrapper shells that have no meaningful (non-shell) descendants
+        filtered_active = []
+        for proc_info in matching_processes:
+            try:
+                proc_obj = psutil.Process(proc_info["pid"])  # type: ignore[index]
+                if not proc_obj.is_running():
+                    continue
+                status_val = proc_obj.status()
+                if status_val not in ["running", "sleeping"]:
+                    continue
+                proc_name = proc_info.get("name", "")
+                if proc_name in shells:
+                    descendants = proc_obj.children(recursive=True)
+                    # Keep shell only if there exists a non-shell alive descendant OR descendant cmdline still includes our command token
+                    meaningful = False
+                    for child in descendants:
+                        try:
+                            if not child.is_running():
+                                continue
+                            child_name = child.name()
+                            child_cmdline = " ".join(child.cmdline())
+                            if child_name not in shells:
+                                meaningful = True
+                                break
+                            if cmd in child_cmdline or any(arg in child_cmdline for arg in args):
+                                meaningful = True
+                                break
+                        except (psutil.NoSuchProcess, psutil.AccessDenied):
+                            continue
+                    if not meaningful:
+                        continue  # discard idle wrapper shell
+                filtered_active.append(proc_info)
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                continue
+
+        if filtered_active:
+            # Heuristic: if the only remaining processes are wrapper shells invoking a script that already completed, mark as not running.
+            # Case: layout launches 'bash <script.sh>' where script finishes and leaves an idle shell whose cmdline still shows the script path.
+            try:
+                if all(p.get("name") in shells for p in filtered_active):
+                    script_paths = [arg for arg in args if arg.endswith(".sh")]
+                    shell_only = True
+                    stale_script_overall = False
+                    for p in filtered_active:
+                        proc_shell = psutil.Process(p["pid"])  # type: ignore[index]
+                        create_time = getattr(proc_shell, "create_time", lambda: None)()
+                        cmdline_joined = " ".join(p.get("cmdline", []))
+                        stale_script = False
+                        for spath in script_paths:
+                            script_file = Path(spath)
+                            if script_file.exists():
+                                try:
+                                    # If script mtime older than process start AND no non-shell descendants -> likely finished
+                                    if create_time and script_file.stat().st_mtime < create_time:
+                                        stale_script = True
+                                except OSError:
+                                    pass
+                            if spath not in cmdline_joined:
+                                stale_script = False
+                        # If shell has any alive non-shell descendants, treat as running
+                        descendants = proc_shell.children(recursive=True)
+                        for d in descendants:
+                            try:
+                                if d.is_running() and d.name() not in shells:
+                                    shell_only = False
+                                    break
+                            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                                continue
+                        if not shell_only:
+                            break
+                        if stale_script:
+                            stale_script_overall = True
+                    if shell_only and stale_script_overall:
+                        return {"status": "not_running", "running": False, "processes": [], "command": command, "cwd": cwd, "tab_name": tab_name}
+            except Exception:
+                pass
+            return {"status": "running", "running": True, "processes": filtered_active, "command": command, "cwd": cwd, "tab_name": tab_name}
+        return {"status": "not_running", "running": False, "processes": [], "command": command, "cwd": cwd, "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, "cwd": cwd, "tab_name": tab_name, "processes": []}
+
+
+def check_zellij_session_status(session_name: str) -> ZellijSessionStatus:
+    """Check if a Zellij session is running."""
+    try:
+        # Run zellij list-sessions command
+        result = subprocess.run(["zellij", "list-sessions"], capture_output=True, text=True, timeout=10)
+
+        if result.returncode == 0:
+            sessions = result.stdout.strip().split("\n") if result.stdout.strip() else []
+            session_running = any(session_name in session for session in sessions)
+
+            return {"zellij_running": True, "session_exists": session_running, "session_name": session_name, "all_sessions": sessions}
+        else:
+            return {"zellij_running": False, "session_exists": False, "session_name": session_name, "all_sessions": [], "error": result.stderr}
+
+    except subprocess.TimeoutExpired:
+        return {"zellij_running": False, "session_exists": False, "session_name": session_name, "all_sessions": [], "error": "Timeout while checking Zellij sessions"}
+    except FileNotFoundError:
+        return {"zellij_running": False, "session_exists": False, "session_name": session_name, "all_sessions": [], "error": "Zellij not found in PATH"}
+    except Exception as e:
+        return {"zellij_running": False, "session_exists": False, "session_name": session_name, "all_sessions": [], "error": str(e)}
+
+
+def get_layout_preview(layout_config: LayoutConfig, layout_template: str | None) -> str:
+    """Generate a preview of the layout configuration."""
+    if layout_template is None:
+        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
+    }
+"""
+    validate_layout_config(layout_config)
+    layout_content = layout_template
+    for tab in layout_config["layoutTabs"]:
+        layout_content += "\n" + create_tab_section(tab)
+    return layout_content + "\n}\n"

machineconfig/cluster/sessions_managers/zellij_utils/zellij_local_helper_restart.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+import subprocess
+import time
+import logging
+from rich.console import Console
+
+from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
+
+
+logger = logging.getLogger(__name__)
+console = Console()
+
+
+def restart_tab_process(tab_name: str, layout_config: LayoutConfig, session_name: str) -> bool:
+    """Restart the process running in a specific Zellij tab without changing the layout.
+    
+    This function will:
+    1. Navigate to the specified tab
+    2. Send Ctrl+C to stop the running process
+    3. Clear the screen
+    4. Re-execute the original command
+    
+    The tab layout and configuration remain unchanged - only the process is restarted.
+    """
+    if not layout_config:
+        logger.error("No layout config available. Cannot restart tab.")
+        return False
+    
+    tab_config = None
+    for tab in layout_config["layoutTabs"]:
+        if tab["tabName"] == tab_name:
+            tab_config = tab
+            break
+    
+    if tab_config is None:
+        logger.error(f"Tab '{tab_name}' not found in layout config.")
+        console.print(f"[bold red]❌ Tab '{tab_name}' not found in layout[/bold red]")
+        return False
+    
+    command = tab_config.get("command", "")
+    if not command:
+        logger.warning(f"No command configured for tab '{tab_name}'")
+        console.print(f"[bold yellow]⚠️  No command to restart for tab '{tab_name}'[/bold yellow]")
+        return False
+    
+    console.print(f"[bold cyan]🔄 Restarting tab[/bold cyan] [yellow]'{tab_name}'[/yellow]")
+    console.print(f"[dim]Command: {command}[/dim]")
+    
+    try:
+        session_arg = f"--session {session_name}" if session_name else ""
+        
+        subprocess.run(f"zellij {session_arg} action go-to-tab-name '{tab_name}'", shell=True, check=True, capture_output=True, text=True)
+        time.sleep(0.5)
+        
+        subprocess.run(f"zellij {session_arg} action write-chars '\\u0003'", shell=True, check=True, capture_output=True, text=True)
+        time.sleep(0.3)
+        
+        subprocess.run(f"zellij {session_arg} action write-chars 'clear'", shell=True, check=True, capture_output=True, text=True)
+        subprocess.run(f"zellij {session_arg} action write-chars '\\n'", shell=True, check=True, capture_output=True, text=True)
+        time.sleep(0.2)
+        
+        escaped_command = command.replace("'", "'\\''")
+        subprocess.run(f"zellij {session_arg} action write-chars '{escaped_command}'", shell=True, check=True, capture_output=True, text=True)
+        subprocess.run(f"zellij {session_arg} action write-chars '\\n'", shell=True, check=True, capture_output=True, text=True)
+        
+        console.print(f"[bold green]✅ Tab '{tab_name}' restarted successfully[/bold green]")
+        return True
+        
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Failed to restart tab '{tab_name}': {e}")
+        console.print(f"[bold red]❌ Failed to restart tab '{tab_name}'[/bold red]")
+        console.print(f"[red]Error: {e}[/red]")
+        return False
+    except Exception as e:
+        logger.error(f"Unexpected error while restarting tab '{tab_name}': {e}")
+        console.print(f"[bold red]❌ Unexpected error: {e}[/bold red]")
+        return False

machineconfig/cluster/sessions_managers/zellij_utils/zellij_local_helper_with_panes.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""
+Helper functions for generating Zellij KDL layouts with support for multiple panes per tab.
+This module extends the basic layout functionality to organize multiple commands into panes within a single tab.
+"""
+import shlex
+import random
+import string
+import logging
+from pathlib import Path
+from typing import Literal
+
+from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig, TabConfig
+
+
+logger = logging.getLogger(__name__)
+
+
+def generate_random_suffix(length: int) -> str:
+    """Generate a random string suffix for unique layout file names."""
+    return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
+
+
+def parse_command(command: str) -> tuple[str, list[str]]:
+    """Parse a command string into executable 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 []
+
+
+def format_args_for_kdl(args: list[str]) -> str:
+    """Format command arguments for KDL layout format."""
+    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)
+
+
+def create_pane_kdl(tab_config: TabConfig, indent_level: int) -> str:
+    """Create a KDL pane definition from a tab configuration."""
+    indent = "  " * indent_level
+    cmd, args = parse_command(tab_config["command"])
+    args_str = format_args_for_kdl(args)
+    pane_content = f'{indent}pane command="{cmd}" {{\n'
+    if args_str:
+        pane_content += f'{indent}  args {args_str}\n'
+    pane_content += f'{indent}}}\n'
+    return pane_content
+
+
+def create_tab_with_panes(
+    tab_configs: list[TabConfig],
+    tab_name: str,
+    common_cwd: str,
+    split_direction: Literal["vertical", "horizontal"] = "vertical",
+) -> str:
+    """
+    Create a KDL tab section with multiple panes from multiple tab configurations.
+    
+    Args:
+        tab_configs: List of TabConfig objects to be organized as panes within one tab
+        tab_name: Name for the tab (derived from configs)
+        common_cwd: Common working directory for the tab
+        split_direction: Direction to split panes ('vertical' or 'horizontal')
+    
+    Returns:
+        KDL formatted string for the tab with multiple panes
+    """
+    escaped_tab_name = tab_name.replace('"', '\\"')
+    tab_section = f'  tab name="{escaped_tab_name}" cwd="{common_cwd}" {{\n'
+    if len(tab_configs) == 1:
+        cmd, args = parse_command(tab_configs[0]["command"])
+        args_str = format_args_for_kdl(args)
+        tab_section += f'    pane command="{cmd}" {{\n'
+        if args_str:
+            tab_section += f"      args {args_str}\n"
+        tab_section += "    }\n"
+    else:
+        tab_section += f'    pane split_direction="{split_direction}" {{\n'
+        for config in tab_configs:
+            tab_section += create_pane_kdl(config, indent_level=3)
+        tab_section += "    }\n"
+    tab_section += "  }\n"
+    return tab_section
+
+
+def generate_tab_name(tab_configs: list[TabConfig], tab_index: int) -> str:
+    """
+    Generate a meaningful tab name from a list of tab configurations.
+    
+    Args:
+        tab_configs: List of TabConfig objects in this tab
+        tab_index: Index of the tab (1-based)
+    
+    Returns:
+        A descriptive tab name
+    """
+    if len(tab_configs) == 1:
+        return tab_configs[0]["tabName"]
+    first_name = tab_configs[0]["tabName"].strip()
+    if first_name.startswith("🤖") or first_name.startswith("📊") or first_name.startswith("📝"):
+        base_name = first_name[:2]
+        return f"{base_name}Group{tab_index}"
+    words = first_name.split()
+    if words:
+        first_word = words[0].strip(":")
+        return f"{first_word}×{len(tab_configs)}"
+    return f"Tab{tab_index}[{len(tab_configs)}]"
+
+
+def determine_common_cwd(tab_configs: list[TabConfig]) -> str:
+    """
+    Determine the common working directory for a group of tab configs.
+    
+    Args:
+        tab_configs: List of TabConfig objects
+    
+    Returns:
+        The most common directory or the first one if no commonality
+    """
+    if not tab_configs:
+        return "~"
+    dirs = [config["startDir"] for config in tab_configs]
+    if len(set(dirs)) == 1:
+        return dirs[0]
+    return dirs[0]
+
+
+def create_zellij_layout_with_panes(
+    layout_config: LayoutConfig,
+    output_path: str,
+    panes_per_tab: int = 1,
+    split_direction: Literal["vertical", "horizontal"] = "vertical",
+) -> str:
+    """
+    Create a Zellij KDL layout file with support for multiple panes per tab.
+    
+    Args:
+        layout_config: The LayoutConfig object containing all tabs/commands
+        panes_per_tab: Number of panes to group into each tab (default: 1 = same as original behavior)
+        split_direction: Direction to split panes within a tab ('vertical' or 'horizontal')
+        output_path: Path to save the layout file (directory or full file path)
+    
+    Returns:
+        Absolute path to the created layout file
+    
+    Example:
+        >>> layout = {"layoutName": "MyLayout", "layoutTabs": [...]}
+        >>> path = create_zellij_layout_with_panes(layout, panes_per_tab=2, split_direction="vertical", output_path="/tmp/layout.kdl")
+    """
+    if panes_per_tab < 1:
+        raise ValueError("panes_per_tab must be at least 1")
+    layout_tabs = layout_config["layoutTabs"]
+    if not layout_tabs:
+        raise ValueError("Layout must contain at least one tab")
+    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
+    }
+"""
+    layout_content = layout_template
+    grouped_tabs: list[list[TabConfig]] = []
+    for i in range(0, len(layout_tabs), panes_per_tab):
+        group = layout_tabs[i : i + panes_per_tab]
+        grouped_tabs.append(group)
+    for tab_index, group in enumerate(grouped_tabs, start=1):
+        tab_name = generate_tab_name(group, tab_index)
+        common_cwd = determine_common_cwd(group)
+        layout_content += "\n" + create_tab_with_panes(group, tab_name, common_cwd, split_direction)
+    layout_content += "\n}\n"
+    try:
+        path_obj = Path(output_path)
+        if path_obj.is_dir():
+            raise ValueError("Output path must be a file path ending with .kdl, not a directory")
+        if path_obj.suffix == ".kdl":
+            layout_file = path_obj
+            layout_file.parent.mkdir(parents=True, exist_ok=True)
+        else:
+            raise ValueError("Output path must end with .kdl")
+        layout_file.write_text(layout_content, encoding="utf-8")
+        logger.info(f"Created Zellij layout file: {layout_file.absolute()}")
+        return str(layout_file.absolute())
+    except OSError as e:
+        logger.error(f"Failed to create layout file: {e}")
+        raise
+
+
+if __name__ == "__main__":
+    sample_layout: LayoutConfig = {
+        "layoutName": "TestMultiPane",
+        "layoutTabs": [
+            {"tabName": "🤖Bot1", "startDir": "~/code/project1", "command": "python bot1.py"},
+            {"tabName": "🤖Bot2", "startDir": "~/code/project1", "command": "python bot2.py"},
+            {"tabName": "🤖Bot3", "startDir": "~/code/project1", "command": "python bot3.py"},
+            {"tabName": "🤖Bot4", "startDir": "~/code/project2", "command": "python bot4.py"},
+            {"tabName": "📊Monitor", "startDir": "~", "command": "htop"},
+            {"tabName": "📝Logs", "startDir": "/var/log", "command": "tail -f /var/log/app.log"},
+        ],
+    }
+    print("=" * 80)
+    print("DEMO 1: panes_per_tab=1 (same as original behavior)")
+    print("=" * 80)
+    layout_path_1 = create_zellij_layout_with_panes(sample_layout, "/tmp/zellij_test_123.kdl", panes_per_tab=1)
+    print(f"✅ Layout created: {layout_path_1}")
+    layout_path_2 = create_zellij_layout_with_panes(layout_config=sample_layout, output_path="/tmp/zellij_test_1234.kdl", panes_per_tab=2, split_direction="vertical")
+    print(f"✅ Layout created: {layout_path_2}")
+    print("DEMO 3: panes_per_tab=3 (three panes per tab, horizontal split)")
+    layout_path_3 = create_zellij_layout_with_panes(layout_config=sample_layout, output_path="/tmp/zellij_test_12345.kdl", panes_per_tab=3, split_direction="horizontal")
+    print(f"✅ Layout created: {layout_path_3}")
+
+    from machineconfig.cluster.sessions_managers.helpers.enhanced_command_runner import enhanced_zellij_session_start
+    enhanced_zellij_session_start(session_name="tmp", layout_path=layout_path_3)