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

machineconfig/cluster/sessions_managers/zellij_local_manager.py

@@ -1,12 +1,9 @@
 #!/usr/bin/env python3
 from datetime import datetime
-import json
-import uuid
 import logging
 import subprocess
 import time
-from pathlib import Path
-from typing import Optional, List
+from typing import Optional
 
 from rich.console import Console
 
@@ -14,13 +11,13 @@ from machineconfig.cluster.sessions_managers.zellij_utils.monitoring_types impor
 from machineconfig.utils.scheduler import Scheduler
 from machineconfig.cluster.sessions_managers.zellij_local import ZellijLayoutGenerator
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
+from machineconfig.cluster.sessions_managers.zellij_utils import zellij_local_manager_helper as helper
 
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 console = Console()
 
-TMP_SERIALIZATION_DIR = Path.home().joinpath("tmp_results", "session_manager", "zellij", "local_manager")
 
 
 class ZellijLocalManager:
@@ -29,22 +26,23 @@ class ZellijLocalManager:
     def __init__(self, session_layouts: list[LayoutConfig]):
         self.session_name_prefix = "LocalJobMgr"
         self.session_layouts = session_layouts  # Store the original config
-        self.managers: List[ZellijLayoutGenerator] = []
+        self.managers: list[ZellijLayoutGenerator] = []
 
         # Create a ZellijLayoutGenerator for each session
         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(layout_config=layout_config, output_dir=None, session_name=full_session_name)
+            manager = ZellijLayoutGenerator(layout_config=layout_config, session_name=full_session_name)
+            manager.create_layout_file()
+            
             self.managers.append(manager)
 
         # Enhanced Rich logging for initialization
         console.print(f"[bold green]🔧 Initialized ZellijLocalManager[/bold green] [dim]with[/dim] [bright_green]{len(self.managers)} sessions[/bright_green]")
 
-    def get_all_session_names(self) -> List[str]:
+    def get_all_session_names(self) -> list[str]:
         """Get all managed session names."""
-        return [manager.session_name for manager in self.managers if manager.session_name is not None]
+        return helper.get_all_session_names(self.managers)
 
     def start_all_sessions(self, poll_seconds: float, poll_interval: float) -> dict[str, StartResult]:
         """Start all zellij sessions with their layouts without blocking on the interactive TUI.
@@ -66,8 +64,6 @@ class ZellijLocalManager:
         for manager in self.managers:
             session_name = manager.session_name
             try:
-                if session_name is None:
-                    continue
                 layout_path = manager.layout_path
                 if not layout_path:
                     results[session_name] = {"success": False, "error": "No layout file path available"}
@@ -88,6 +84,7 @@ class ZellijLocalManager:
                 # ZELLIJ_AUTO_ATTACH=0 prevents auto-attach if compiled with that feature; harmless otherwise.
                 start_cmd = ["bash", "-lc", f"ZELLIJ_AUTO_ATTACH=0 zellij --layout {layout_path} attach {session_name} --create >/dev/null 2>&1 &"]
                 console.print(f"[bold cyan]🚀 Starting session[/bold cyan] [yellow]'{session_name}'[/yellow] with layout [blue]{layout_path}[/blue] (non-blocking)...")
+                console.print(f"[dim]   Command: {' '.join(start_cmd)}[/dim]")
                 subprocess.Popen(start_cmd)
 
                 # 3. Poll for presence
@@ -114,26 +111,7 @@ class ZellijLocalManager:
 
     def kill_all_sessions(self) -> dict[str, StartResult]:
         """Kill all managed zellij sessions."""
-        results: dict[str, StartResult] = {}
-        for manager in self.managers:
-            try:
-                session_name = manager.session_name
-                if session_name is None:
-                    continue  # Skip managers without a session name
-
-                cmd = f"zellij delete-session --force {session_name}"
-
-                logger.info(f"Killing session '{session_name}'")
-                result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=10)
-
-                results[session_name] = {"success": result.returncode == 0, "message": "Session killed" if result.returncode == 0 else result.stderr}
-
-            except Exception as e:
-                # Use a fallback key since session_name might not be defined here
-                key = getattr(manager, "session_name", None) or f"manager_{self.managers.index(manager)}"
-                results[key] = {"success": False, "error": str(e)}
-
-        return results
+        return helper.kill_all_sessions(self.managers)
 
     def attach_to_session(self, session_name: Optional[str]) -> str:
         """
@@ -145,20 +123,7 @@ class ZellijLocalManager:
         Returns:
             Command string to attach to session(s)
         """
-        if session_name:
-            # Find the specific session
-            for manager in self.managers:
-                if manager.session_name == session_name:
-                    return f"zellij attach {session_name}"
-            raise ValueError(f"Session '{session_name}' not found")
-        else:
-            # Return commands for all sessions
-            commands: list[str] = []
-            for manager in self.managers:
-                commands.append(f"# Attach to session '{manager.session_name}':")
-                commands.append(f"zellij attach {manager.session_name}")
-                commands.append("")
-            return "\n".join(commands)
+        return helper.attach_to_session(self.managers, session_name)
 
     def check_all_sessions_status(self) -> dict[str, SessionReport]:
         """Check the status of all sessions and their commands."""
@@ -166,11 +131,10 @@ class ZellijLocalManager:
 
         for manager in self.managers:
             session_name = manager.session_name
-            if session_name is None:
-                continue  # Skip managers without a session name
 
-            # Get session status
-            session_status = ZellijLayoutGenerator.check_zellij_session_status(session_name)
+            # Get session status using the helper function
+            from machineconfig.cluster.sessions_managers.zellij_utils.zellij_local_helper import check_zellij_session_status
+            session_status = check_zellij_session_status(session_name)
 
             # Get commands status for this session
             commands_status = manager.check_all_commands_status()
@@ -248,7 +212,7 @@ class ZellijLocalManager:
 
                 if cmd_status.get("processes"):
                     for proc in cmd_status["processes"][:2]:  # Show first 2 processes
-                        print(f"        └─ PID {proc['pid']}: {proc['name']} ({proc['status']})")
+                        console.print(f"        [dim]└─[/dim] PID {proc['pid']}: {proc['name']} ({proc['status']})")
             print()
 
         print("=" * 80)
@@ -317,143 +281,29 @@ class ZellijLocalManager:
 
     def save(self, session_id: Optional[str]) -> str:
         """Save the manager state to disk."""
-        if session_id is None:
-            session_id = str(uuid.uuid4())[:8]
-
-        # Create session directory
-        session_dir = TMP_SERIALIZATION_DIR / session_id
-        session_dir.mkdir(parents=True, exist_ok=True)
-
-        # 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": [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")
-
-        # Save each manager's state
-        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, "layout_path": manager.layout_path}
-            manager_file = managers_dir / f"manager_{i}_{manager.session_name}.json"
-            text = json.dumps(manager_data, indent=2, ensure_ascii=False)
-            manager_file.write_text(text, encoding="utf-8")
-
-        logger.info(f"✅ Saved ZellijLocalManager session to: {session_dir}")
-        return session_id
+        return helper.save_manager(self.session_layouts, self.managers, self.session_name_prefix, session_id)
 
     @classmethod
     def load(cls, session_id: str) -> "ZellijLocalManager":
         """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)
-
-        # Create new instance
+        session_layouts, managers = helper.load_manager(session_id)
         instance = cls(session_layouts=session_layouts)
-
-        # 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:
-                try:
-                    text = manager_file.read_text(encoding="utf-8")
-                    manager_data = json.loads(text)
-
-                    # Recreate the manager
-                    manager = ZellijLayoutGenerator()
-                    manager.session_name = manager_data["session_name"]
-                    manager.layout_config = manager_data["layout_config"]
-                    manager.layout_path = manager_data["layout_path"]
-
-                    instance.managers.append(manager)
-
-                except Exception as e:
-                    logger.warning(f"Failed to load manager from {manager_file}: {e}")
-
-        logger.info(f"✅ Loaded ZellijLocalManager session from: {session_dir}")
+        instance.managers = managers
         return instance
 
     @staticmethod
-    def list_saved_sessions() -> List[str]:
+    def list_saved_sessions() -> list[str]:
         """List all saved session IDs."""
-        if not TMP_SERIALIZATION_DIR.exists():
-            return []
-
-        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 helper.list_saved_sessions()
 
     @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 helper.delete_session(session_id)
 
     def list_active_sessions(self) -> list[ActiveSessionInfo]:
         """List currently active zellij sessions managed by this instance."""
-        active_sessions: list[ActiveSessionInfo] = []
-
-        try:
-            # Get all running zellij sessions
-            result = subprocess.run(["zellij", "list-sessions"], capture_output=True, text=True, timeout=10)
-
-            if result.returncode == 0:
-                all_sessions = result.stdout.strip().split("\n") if result.stdout.strip() else []
-
-                # Filter to only our managed sessions
-                for manager in self.managers:
-                    session_name = manager.session_name
-                    if session_name is None:
-                        continue  # Skip managers without a session name
-                    is_active = any(session_name in session for session in all_sessions)
-
-                    tab_info = []
-                    tab_count = 0
-                    if manager.layout_config:
-                        tab_count = len(manager.layout_config["layoutTabs"])
-                        tab_info = [tab["tabName"] for tab in manager.layout_config["layoutTabs"]]
-
-                    active_sessions.append({"session_name": session_name, "is_active": is_active, "tab_count": tab_count, "tabs": tab_info})
-
-        except Exception as e:
-            logger.error(f"Error listing active sessions: {e}")
-
-        return active_sessions
+        return helper.list_active_sessions(self.managers)
 
 
 if __name__ == "__main__":

machineconfig/cluster/sessions_managers/zellij_remote.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-from typing import Dict, Optional, List, Union, Any
+from typing import Optional, Any
 from pathlib import Path
 import logging
 import json
@@ -22,10 +22,10 @@ TMP_LAYOUT_DIR = Path.home().joinpath("tmp_results", "zellij_layouts", "layout_m
 
 
 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(8)
-        self.layout_config: Optional[LayoutConfig] = None
+    def __init__(self, layout_config: LayoutConfig, remote_name: str, session_name: str):
+        self.remote_name: str = remote_name
+        self.session_name: str = session_name
+        self.layout_config: LayoutConfig = layout_config.copy()
         self.layout_path: Optional[str] = None
 
         # Initialize modular components
@@ -35,23 +35,27 @@ class ZellijRemoteLayoutGenerator:
         self.session_manager = SessionManager(self.remote_executor, self.session_name, TMP_LAYOUT_DIR)
         self.status_reporter = StatusReporter(self.process_monitor, self.session_manager)
 
-    def create_zellij_layout(self, layout_config: LayoutConfig, output_dir: Optional[str]) -> str:
+    def create_layout_file(self) -> bool:
+        """Create Zellij layout file and return success status."""
         # Enhanced Rich logging for remote layout creation
-        tab_count = len(layout_config["layoutTabs"])
-        layout_name = layout_config["layoutName"]
+        tab_count = len(self.layout_config["layoutTabs"])
+        layout_name = self.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 in layout_config["layoutTabs"]:
+        for tab in self.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.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(layout_config, output_path, self.session_name)
-        return self.layout_path
+        layout_content = self.layout_generator.create_layout_file(self.layout_config, session_name=self.session_name)
+        
+        # Write to file
+        TMP_LAYOUT_DIR.mkdir(parents=True, exist_ok=True)
+        layout_file = TMP_LAYOUT_DIR / f"zellij_layout_{self.session_name}.kdl"
+        layout_file.write_text(layout_content, encoding="utf-8")
+        self.layout_path = str(layout_file.absolute())
+        
+        console.print(f"[bold green]✅ Remote layout created:[/bold green] [cyan]{self.layout_path}[/cyan]")
+        return True
 
     # Static methods for backward compatibility
     @staticmethod
@@ -59,10 +63,10 @@ class ZellijRemoteLayoutGenerator:
         executor = RemoteExecutor(remote_name)
         return executor.run_command(command, timeout)
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         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]]) -> str:
+    def to_json(self, file_path: Optional[str | Path]) -> str:
         # Generate file path if not provided
         if file_path is None:
             random_id = str(uuid.uuid4())[:8]
@@ -89,7 +93,7 @@ class ZellijRemoteLayoutGenerator:
         return str(file_path_obj)
 
     @classmethod
-    def from_json(cls, file_path: Union[str, Path]) -> "ZellijRemoteLayoutGenerator":
+    def from_json(cls, file_path: str | Path) -> "ZellijRemoteLayoutGenerator":
         file_path = Path(file_path)
 
         # Ensure .json extension
@@ -108,25 +112,18 @@ class ZellijRemoteLayoutGenerator:
             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.layout_config = data["layout_config"]
+        instance = cls(
+            layout_config=data["layout_config"],
+            remote_name=data["remote_name"],
+            session_name=data["session_name"]
+        )
         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]]) -> List[str]:
+    def list_saved_sessions(directory_path: Optional[str | Path]) -> list[str]:
         if directory_path is None:
             directory_path = Path.home() / "tmp_results" / "zellij_sessions" / "serialized"
         else:
@@ -144,8 +141,8 @@ if __name__ == "__main__":
     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": "🤖Bot1", "startDir": "~/code/bytesense/bithence", "command": "fire -mO go1.py bot1 -- --create_new_bot=True"},
+            {"tabName": "🤖Bot2", "startDir": "~/code/bytesense/bithence", "command": "fire -mO go2.py bot2 -- --create_new_bot=True"},
             {"tabName": "📊Monitor", "startDir": "~", "command": "htop"},
             {"tabName": "📝Logs", "startDir": "/var/log", "command": "tail -f /var/log/app.log"},
         ],
@@ -157,9 +154,14 @@ 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_layout, None)
-        print(f"✅ Remote layout created successfully: {layout_path}")
+        generator = ZellijRemoteLayoutGenerator(
+            layout_config=sample_layout,
+            remote_name=remote_name,
+            session_name=session_name
+        )
+        generator.create_layout_file()
+        
+        print(f"✅ Remote layout created successfully: {generator.layout_path}")
 
         # Demonstrate serialization
         print("\n💾 Demonstrating serialization...")
@@ -179,10 +181,7 @@ if __name__ == "__main__":
 
         # Demonstrate status checking
         print(f"\n🔍 Checking command status on remote '{remote_name}':")
-        if not generator.layout_config:
-            console.print("[bold red]❌ No layout config available[/bold red]")
-        else:
-            generator.status_reporter.print_status_report(generator.layout_config)
+        generator.status_reporter.print_status_report(generator.layout_config)
 
         # Start the session (uncomment to actually start)
         # start_result = generator.start_zellij_session()

machineconfig/cluster/sessions_managers/zellij_remote_manager.py

@@ -2,7 +2,7 @@ from datetime import datetime
 import json
 import uuid
 from pathlib import Path
-from typing import Optional, Dict
+from typing import Optional
 from machineconfig.utils.scheduler import Scheduler
 from machineconfig.cluster.sessions_managers.zellij_local import run_command_in_zellij_tab
 from machineconfig.cluster.sessions_managers.zellij_remote import ZellijRemoteLayoutGenerator
@@ -10,18 +10,24 @@ from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
 from machineconfig.logger import get_logger
 
 
-TMP_SERIALIAZATION_DIR = Path.home().joinpath("tmp_results", "session_manager", "zellij", "remote_manager")
 logger = get_logger("cluster.sessions_managers.zellij_remote_manager")
+TMP_SERIALIAZATION_DIR = Path.home() / "tmp_results" / "zellij_sessions" / "serialized"
 
 
 class ZellijSessionManager:
-    def __init__(self, machine_layouts: Dict[str, LayoutConfig], session_name_prefix: str):
+    def __init__(self, machine_layouts: dict[str, LayoutConfig], session_name_prefix: str):
         self.session_name_prefix = session_name_prefix
         self.machine_layouts = machine_layouts  # Store the original config
         self.managers: list[ZellijRemoteLayoutGenerator] = []
         for machine, layout_config in machine_layouts.items():
-            an_m = ZellijRemoteLayoutGenerator(remote_name=machine, session_name_prefix=self.session_name_prefix)
-            an_m.create_zellij_layout(layout_config=layout_config, output_dir=None)
+            from machineconfig.cluster.sessions_managers.zellij_utils.layout_generator import LayoutGenerator
+            session_name = f"{self.session_name_prefix}_{LayoutGenerator.generate_random_suffix(8)}"
+            an_m = ZellijRemoteLayoutGenerator(
+                layout_config=layout_config,
+                remote_name=machine,
+                session_name=session_name
+            )
+            an_m.create_layout_file()
             self.managers.append(an_m)
 
     def ssh_to_all_machines(self) -> str:
@@ -51,10 +57,7 @@ class ZellijSessionManager:
             if scheduler.cycle % 2 == 0:
                 statuses = []
                 for _idx, an_m in enumerate(self.managers):
-                    if not an_m.layout_config:
-                        a_status = {}
-                    else:
-                        a_status = an_m.process_monitor.check_all_commands_status(an_m.layout_config)
+                    a_status = an_m.process_monitor.check_all_commands_status(an_m.layout_config)
                     statuses.append(a_status)
                 keys = []
                 for item in statuses:
@@ -71,7 +74,7 @@ class ZellijSessionManager:
                 # 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
+                    scheduler.max_cycles = scheduler.cycle  # stop the scheduler from calling this routine again
 
                 # Print status
                 for item in status_data:

machineconfig/cluster/sessions_managers/zellij_utils/example_usage.py

@@ -17,8 +17,8 @@ def example_usage():
     sample_layout: LayoutConfig = {
         "layoutName": "ExampleRemoteSession",
         "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": "🤖Bot1", "startDir": "~/code/bytesense/bithence", "command": "fire -mO go1.py bot1 -- --create_new_bot=True"},
+            {"tabName": "🤖Bot2", "startDir": "~/code/bytesense/bithence", "command": "fire -mO go2.py bot2 -- --create_new_bot=True"},
             {"tabName": "📊Monitor", "startDir": "~", "command": "htop"},
             {"tabName": "📝Logs", "startDir": "/var/log", "command": "tail -f /var/log/app.log"},
         ],
@@ -30,12 +30,8 @@ def example_usage():
 
     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_layout, None)
-        print(f"✅ Remote layout created successfully: {layout_path}")
-
+        generator = ZellijRemoteLayoutGenerator(remote_name=remote_name, session_name=session_name, layout_config=sample_layout)
+        generator.create_layout_file()
         # Preview the layout content
         preview = generator.layout_generator.generate_layout_content(sample_layout)
         print(f"📄 Layout preview:\n{preview}")

machineconfig/cluster/sessions_managers/zellij_utils/layout_generator.py

@@ -7,7 +7,6 @@ import shlex
 import random
 import string
 from typing import List, Tuple
-from pathlib import Path
 import logging
 
 from rich.console import Console
@@ -116,26 +115,12 @@ class LayoutGenerator:
 
         return layout_content
 
-    def create_layout_file(self, layout_config: LayoutConfig, output_dir: Path, session_name: str) -> str:
-        """Create a layout file and return its absolute path."""
+    def create_layout_file(self, layout_config: LayoutConfig, session_name: str) -> str:
+        """Create layout content and return it as string."""
         self.validate_tab_config(layout_config)
 
-        # Generate unique suffix for this layout
-        random_suffix = self.generate_random_suffix(8)
         layout_content = self.generate_layout_content(layout_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
-            layout_file.write_text(layout_content, encoding="utf-8")
-
-            # 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
+        # Enhanced Rich logging
+        console.print("[bold green]✅ Zellij layout content generated[/bold green]")
+        return layout_content

machineconfig/cluster/sessions_managers/zellij_utils/process_monitor.py

@@ -51,12 +51,10 @@ class ProcessMonitor:
             return {"status": "unknown", "error": f"Tab '{tab_name}' not found in layout config", "running": False, "command": "", "tab_name": tab_name, "processes": [], "remote": self.remote_executor.remote_name}
 
         command = tab_config["command"]
-
         try:
             check_script = self._create_process_check_script(command)
-            remote_cmd = f"$HOME/code/machineconfig/.venv/bin/python -c {shlex.quote(check_script)}"
+            remote_cmd = f"$HOME/.local/bin devops self run-python -c {shlex.quote(check_script)}"
             result = self.remote_executor.run_command(remote_cmd, timeout=15)
-
             if result.returncode == 0:
                 try:
                     matching_processes = json.loads(result.stdout.strip())
@@ -127,16 +125,12 @@ if __name__ == "__main__":
 
     def force_fresh_process_check(self, tab_name: str, layout_config: LayoutConfig) -> CommandStatus:
         """Force a fresh process check with additional validation."""
-        # 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:
+        else:
             return {"status": "unknown", "error": f"Tab '{tab_name}' not found in layout config", "running": False, "command": "", "tab_name": tab_name, "processes": [], "remote": self.remote_executor.remote_name}
-
         command = tab_config["command"]
 
         try:
@@ -145,7 +139,7 @@ if __name__ == "__main__":
             check_timestamp = timestamp_result.stdout.strip() if timestamp_result.returncode == 0 else "unknown"
 
             check_script = self._create_fresh_check_script(command)
-            remote_cmd = f"$HOME/code/machineconfig/.venv/bin/python -c {shlex.quote(check_script)}"
+            remote_cmd = f"$HOME/.local/bin/devops self run-python -c {shlex.quote(check_script)}"
             result = self.remote_executor.run_command(remote_cmd, timeout=15)
 
             if result.returncode == 0:

machineconfig/cluster/sessions_managers/zellij_utils/status_reporter.py

@@ -5,11 +5,13 @@ Status reporting utilities for Zellij remote layouts.
 
 import logging
 from typing import Dict, Any
+from rich.console import Console
 from machineconfig.cluster.sessions_managers.zellij_utils.process_monitor import ProcessMonitor
 from machineconfig.cluster.sessions_managers.zellij_utils.session_manager import SessionManager
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
 
 logger = logging.getLogger(__name__)
+console = Console()
 
 
 class StatusReporter:
@@ -70,7 +72,7 @@ class StatusReporter:
                 print(f"✅ {tab_name}: Running on {remote_name}")
                 if cmd_status.get("processes"):
                     for proc in cmd_status["processes"][:2]:  # Show first 2 processes
-                        print(f"   └─ PID {proc['pid']}: {proc['name']} ({proc['status']})")
+                        console.print(f"   [dim]└─[/dim] PID {proc['pid']}: {proc['name']} ({proc['status']})")
             else:
                 print(f"❌ {tab_name}: Not running on {remote_name}")
             print(f"   Command: {cmd_status.get('command', 'Unknown')}")