machineconfig 2.0__py3-none-any.whl → 2.1__py3-none-any.whl

machineconfig/cluster/sessions_managers/wt_utils/status_reporter.py

@@ -2,6 +2,7 @@
 """
 Status reporting utilities for Windows Terminal layouts and sessions.
 """
+
 import logging
 from typing import Dict, Any, Tuple
 from .process_monitor import WTProcessMonitor
@@ -28,13 +29,7 @@ class WTStatusReporter:
         return {
             "wt_session": wt_status,
             "commands": commands_status,
-            "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")
-            }
+            "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:
@@ -57,11 +52,11 @@ class WTStatusReporter:
             if wt_session.get("session_exists", False):
                 session_windows = wt_session.get("session_windows", [])
                 all_windows = wt_session.get("all_windows", [])
-                print(f"✅ Windows Terminal is running")
+                print("✅ Windows Terminal is running")
                 print(f"   Session windows: {len(session_windows)}")
                 print(f"   Total WT windows: {len(all_windows)}")
             else:
-                print(f"⚠️  Windows Terminal is running but no session windows found")
+                print("⚠️  Windows Terminal is running but no session windows found")
         else:
             error_msg = wt_session.get("error", "Unknown error")
             print(f"❌ Windows Terminal session issue: {error_msg}")
@@ -112,19 +107,10 @@ class WTStatusReporter:
             wt_windows = self.process_monitor.get_windows_terminal_windows()
             wt_version = self.session_manager.get_wt_version()
 
-            return {
-                "success": True,
-                "windows_info": wt_windows,
-                "version_info": wt_version,
-                "location": self.process_monitor.location_name
-            }
+            return {"success": True, "windows_info": wt_windows, "version_info": wt_version, "location": self.process_monitor.location_name}
         except Exception as e:
             logger.error(f"Failed to get Windows Terminal overview: {e}")
-            return {
-                "success": False,
-                "error": str(e),
-                "location": self.process_monitor.location_name
-            }
+            return {"success": False, "error": str(e), "location": self.process_monitor.location_name}
 
     def print_windows_terminal_overview(self) -> None:
         """Print an overview of Windows Terminal status."""
@@ -190,39 +176,25 @@ class WTStatusReporter:
                 "stopped_commands": summary["stopped_commands"],
                 "all_commands_running": summary["running_commands"] == summary["total_commands"],
                 "wt_windows_count": len(wt_overview.get("windows_info", {}).get("windows", [])) if wt_overview["success"] else 0,
-                "wt_version": wt_overview.get("version_info", {}).get("version", "Unknown") if wt_overview["success"] else "Unknown"
+                "wt_version": wt_overview.get("version_info", {}).get("version", "Unknown") if wt_overview["success"] else "Unknown",
             }
         except Exception as e:
             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
-            }
+            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]:
         """Get detailed status for a specific tab."""
         if tab_name not in tab_config:
-            return {
-                "error": f"Tab '{tab_name}' not found in configuration",
-                "tab_name": tab_name
-            }
+            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)
 
             # Add additional context
             cwd, command = tab_config[tab_name]
-            cmd_status["tab_config"] = {
-                "working_directory": cwd,
-                "command": command
-            }
+            cmd_status["tab_config"] = {"working_directory": cwd, "command": command}
 
             return cmd_status
         except Exception as e:
             logger.error(f"Failed to check status for tab '{tab_name}': {e}")
-            return {
-                "error": str(e),
-                "tab_name": tab_name,
-                "location": self.process_monitor.location_name
-            }
+            return {"error": str(e), "tab_name": tab_name, "location": self.process_monitor.location_name}

machineconfig/cluster/sessions_managers/zellij_local.py

@@ -34,13 +34,14 @@ class ZellijLayoutGenerator:
     @staticmethod
     def _generate_random_suffix(length: int = 8) -> str:
         """Generate a random string suffix for unique layout file names."""
-        return ''.join(random.choices(string.ascii_lowercase + string.digits, k=length))
+        return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
 
     @staticmethod
     def _parse_command(command: str) -> tuple[str, List[str]]:
         try:
             parts = shlex.split(command)
-            if not parts: raise ValueError("Empty command provided")
+            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}")
@@ -49,10 +50,11 @@ class ZellijLayoutGenerator:
 
     @staticmethod
     def _format_args_for_kdl(args: List[str]) -> str:
-        if not args: return ""
+        if not args:
+            return ""
         formatted_args = []
         for arg in args:
-            if ' ' in arg or '"' in arg or "'" in arg:
+            if " " in arg or '"' in arg or "'" in arg:
                 escaped_arg = arg.replace('"', '\\"')
                 formatted_args.append(f'"{escaped_arg}"')
             else:
@@ -67,17 +69,22 @@ class ZellijLayoutGenerator:
         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'
+        if args_str:
+            tab_section += f"      args {args_str}\n"
+        tab_section += "    }\n  }\n"
         return tab_section
 
     @staticmethod
     def _validate_tab_config(tab_config: Dict[str, tuple[str, str]]) -> None:
-        if not tab_config: raise ValueError("Tab configuration cannot be empty")
+        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}")
+            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)
@@ -141,14 +148,7 @@ class ZellijLayoutGenerator:
     @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
-            }
+            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]
         cmd, _ = ZellijLayoutGenerator._parse_command(command)
@@ -156,51 +156,23 @@ class ZellijLayoutGenerator:
         try:
             # Look for processes matching the command
             matching_processes = []
-            for proc in psutil.process_iter(['pid', 'name', 'cmdline', 'status']):
+            for proc in psutil.process_iter(["pid", "name", "cmdline", "status"]):
                 try:
-                    if proc.info['cmdline'] and len(proc.info['cmdline']) > 0:
+                    if proc.info["cmdline"] and len(proc.info["cmdline"]) > 0:
                         # Check if the command matches
-                        if (proc.info['name'] == cmd or
-                            cmd in proc.info['cmdline'][0] or
-                            any(cmd in arg for arg in proc.info['cmdline'])):
-                            matching_processes.append({
-                                "pid": proc.info['pid'],
-                                "name": proc.info['name'],
-                                "cmdline": proc.info['cmdline'],
-                                "status": proc.info['status']
-                            })
+                        if proc.info["name"] == cmd or cmd in proc.info["cmdline"][0] or any(cmd in arg for arg in proc.info["cmdline"]):
+                            matching_processes.append({"pid": proc.info["pid"], "name": proc.info["name"], "cmdline": proc.info["cmdline"], "status": proc.info["status"]})
                 except (psutil.NoSuchProcess, psutil.AccessDenied):
                     continue
 
             if matching_processes:
-                return {
-                    "status": "running",
-                    "running": True,
-                    "processes": matching_processes,
-                    "command": command,
-                    "cwd": cwd,
-                    "tab_name": tab_name
-                }
+                return {"status": "running", "running": True, "processes": matching_processes, "command": command, "cwd": cwd, "tab_name": tab_name}
             else:
-                return {
-                    "status": "not_running",
-                    "running": False,
-                    "processes": [],
-                    "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
-            }
+            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:
@@ -217,48 +189,22 @@ class ZellijLayoutGenerator:
     def check_zellij_session_status(session_name: str) -> Dict[str, Any]:
         try:
             # Run zellij list-sessions command
-            result = subprocess.run(
-                ['zellij', 'list-sessions'],
-                capture_output=True,
-                text=True,
-                timeout=10
-            )
+            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 []
+                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
-                }
+                return {"zellij_running": True, "session_exists": session_running, "session_name": session_name, "all_sessions": sessions}
             else:
-                return {
-                    "zellij_running": False,
-                    "error": result.stderr,
-                    "session_name": session_name
-                }
+                return {"zellij_running": False, "error": result.stderr, "session_name": session_name}
 
         except subprocess.TimeoutExpired:
-            return {
-                "zellij_running": False,
-                "error": "Timeout while checking Zellij sessions",
-                "session_name": session_name
-            }
+            return {"zellij_running": False, "error": "Timeout while checking Zellij sessions", "session_name": session_name}
         except FileNotFoundError:
-            return {
-                "zellij_running": False,
-                "error": "Zellij not found in PATH",
-                "session_name": session_name
-            }
+            return {"zellij_running": False, "error": "Zellij not found in PATH", "session_name": session_name}
         except Exception as e:
-            return {
-                "zellij_running": False,
-                "error": str(e),
-                "session_name": session_name
-            }
+            return {"zellij_running": False, "error": str(e), "session_name": session_name}
 
     def get_comprehensive_status(self) -> Dict[str, Any]:
         zellij_status = ZellijLayoutGenerator.check_zellij_session_status(self.session_name or "default")
@@ -270,12 +216,7 @@ class ZellijLayoutGenerator:
         return {
             "zellij_session": zellij_status,
             "commands": commands_status,
-            "summary": {
-                "total_commands": total_count,
-                "running_commands": running_count,
-                "stopped_commands": total_count - running_count,
-                "session_healthy": zellij_status.get("session_exists", False)
-            }
+            "summary": {"total_commands": total_count, "running_commands": running_count, "stopped_commands": total_count - running_count, "session_healthy": zellij_status.get("session_exists", False)},
         }
 
     def print_status_report(self) -> None:
@@ -296,7 +237,7 @@ class ZellijLayoutGenerator:
             else:
                 console.print(f"[bold yellow]⚠️  Zellij is running but session[/bold yellow] [yellow]'{self.session_name}'[/yellow] [yellow]not found[/yellow]")
         else:
-            error_msg = zellij.get('error', 'Unknown error')
+            error_msg = zellij.get("error", "Unknown error")
             console.print(f"[bold red]❌ Zellij session issue:[/bold red] [red]{error_msg}[/red]")
 
         console.print()
@@ -316,8 +257,8 @@ class ZellijLayoutGenerator:
                 processes = cmd_status.get("processes", [])
                 if processes:
                     proc = processes[0]  # Show first process
-                    pid = str(proc.get('pid', 'N/A'))
-                    memory = f"{proc.get('memory_mb', 0):.1f}MB" if proc.get('memory_mb') else "N/A"
+                    pid = str(proc.get("pid", "N/A"))
+                    memory = f"{proc.get('memory_mb', 0):.1f}MB" if proc.get("memory_mb") else "N/A"
                 else:
                     pid = "N/A"
                     memory = "N/A"
@@ -326,7 +267,7 @@ class ZellijLayoutGenerator:
                 pid = "N/A"
                 memory = "N/A"
 
-            command = cmd_status.get('command', 'Unknown')
+            command = cmd_status.get("command", "Unknown")
             # Truncate long commands
             if len(command) > 35:
                 command = command[:32] + "..."
@@ -339,29 +280,35 @@ class ZellijLayoutGenerator:
         # Enhanced summary
         summary = status["summary"]
         from rich.panel import Panel
-        summary_text = f"""[bold]Total commands:[/bold] {summary['total_commands']}
-[green]Running:[/green] {summary['running_commands']}
-[red]Stopped:[/red] {summary['stopped_commands']}
-[yellow]Session healthy:[/yellow] {'✅' if summary['session_healthy'] else '❌'}"""
+
+        summary_text = f"""[bold]Total commands:[/bold] {summary["total_commands"]}
+[green]Running:[/green] {summary["running_commands"]}
+[red]Stopped:[/red] {summary["stopped_commands"]}
+[yellow]Session healthy:[/yellow] {"✅" if summary["session_healthy"] else "❌"}"""
 
         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:
     generator = ZellijLayoutGenerator()
     return generator.create_zellij_layout(tab_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))
+        session_name = "".join(random.choices(string.ascii_lowercase + string.digits, k=8))
     layout_path = created_zellij_layout(tab_config)
 
     # Use enhanced command execution
     try:
         from .enhanced_command_runner import enhanced_zellij_session_start
+
         enhanced_zellij_session_start(session_name, layout_path)
     except ImportError:
         # Fallback to original implementation
         cmd = f"zellij delete-session --force {session_name}; zellij --layout {layout_path} a -b {session_name}"
         import subprocess
+
         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
@@ -393,7 +340,7 @@ if __name__ == "__main__":
         "🤖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")
+        "📝Logs": ("/var/log", "tail -f /var/log/app.log"),
     }
     try:
         # Create layout using the generator directly to access status methods

machineconfig/cluster/sessions_managers/zellij_local_manager.py

@@ -90,10 +90,7 @@ class ZellijLocalManager:
                 # 2. Launch new session. We intentionally do NOT wait for completion.
                 # Using the same pattern as before (attach --create) but detached via env var.
                 # 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 &"
-                ]
+                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)...")
                 subprocess.Popen(start_cmd)
 
@@ -133,18 +130,12 @@ class ZellijLocalManager:
                 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
-                }
+                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)
-                }
+                key = getattr(manager, "session_name", None) or f"manager_{self.managers.index(manager)}"
+                results[key] = {"success": False, "error": str(e)}
 
         return results
 
@@ -195,12 +186,7 @@ class ZellijLocalManager:
             status_report[session_name] = {
                 "session_status": session_status,
                 "commands_status": commands_status,
-                "summary": {
-                    "total_commands": total_count,
-                    "running_commands": running_count,
-                    "stopped_commands": total_count - running_count,
-                    "session_healthy": session_status.get("session_exists", False)
-                }
+                "summary": {"total_commands": total_count, "running_commands": running_count, "stopped_commands": total_count - running_count, "session_healthy": session_status.get("session_exists", False)},
             }
 
         return status_report
@@ -210,12 +196,9 @@ class ZellijLocalManager:
         all_status = self.check_all_sessions_status()
 
         total_sessions = len(all_status)
-        healthy_sessions = sum(1 for status in all_status.values()
-                             if status["summary"]["session_healthy"])
-        total_commands = sum(status["summary"]["total_commands"]
-                           for status in all_status.values())
-        total_running = sum(status["summary"]["running_commands"]
-                          for status in all_status.values())
+        healthy_sessions = sum(1 for status in all_status.values() if status["summary"]["session_healthy"])
+        total_commands = sum(status["summary"]["total_commands"] for status in all_status.values())
+        total_running = sum(status["summary"]["running_commands"] for status in all_status.values())
 
         return {
             "total_sessions": total_sessions,
@@ -225,7 +208,7 @@ class ZellijLocalManager:
             "running_commands": total_running,
             "stopped_commands": total_commands - total_running,
             "all_sessions_healthy": healthy_sessions == total_sessions,
-            "all_commands_running": total_running == total_commands
+            "all_commands_running": total_running == total_commands,
         }
 
     def print_status_report(self) -> None:
@@ -281,6 +264,7 @@ class ZellijLocalManager:
         Args:
             wait_ms: How long to wait between checks in milliseconds (default: 30000ms = 30s)
         """
+
         def routine(scheduler: Scheduler):
             print(f"\n⏰ Monitoring cycle {scheduler.cycle} at {datetime.now()}")
             print("-" * 50)
@@ -293,13 +277,15 @@ class ZellijLocalManager:
                 status_data = []
                 for session_name, status in all_status.items():
                     for tab_name, cmd_status in status["commands_status"].items():
-                        status_data.append({
-                            "session": session_name,
-                            "tab": tab_name,
-                            "running": cmd_status.get("running", False),
-                            "command": cmd_status.get("command", "Unknown")[:50] + "..." if len(cmd_status.get("command", "")) > 50 else cmd_status.get("command", ""),
-                            "processes": len(cmd_status.get("processes", []))
-                        })
+                        status_data.append(
+                            {
+                                "session": session_name,
+                                "tab": tab_name,
+                                "running": cmd_status.get("running", False),
+                                "command": cmd_status.get("command", "Unknown")[:50] + "..." if len(cmd_status.get("command", "")) > 50 else cmd_status.get("command", ""),
+                                "processes": len(cmd_status.get("processes", [])),
+                            }
+                        )
 
                 if status_data:
                     # Format data as table
@@ -346,13 +332,7 @@ class ZellijLocalManager:
         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": list(self.session2zellij_tabs.keys()), "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")
@@ -362,11 +342,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, "tab_config": manager.tab_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")
@@ -375,7 +351,7 @@ class ZellijLocalManager:
         return session_id
 
     @classmethod
-    def load(cls, session_id: str) -> 'ZellijLocalManager':
+    def load(cls, session_id: str) -> "ZellijLocalManager":
         """Load a saved manager state from disk."""
         session_dir = TMP_SERIALIZATION_DIR / session_id
 
@@ -387,14 +363,14 @@ class ZellijLocalManager:
         if not config_file.exists():
             raise FileNotFoundError(f"Configuration file not found: {config_file}")
 
-        with open(config_file, 'r', encoding='utf-8') as f:
+        with open(config_file, "r", encoding="utf-8") as f:
             session2zellij_tabs = json.load(f)
 
         # Load metadata
         metadata_file = session_dir / "metadata.json"
         session_name_prefix = "LocalJobMgr"  # default fallback
         if metadata_file.exists():
-            with open(metadata_file, 'r', encoding='utf-8') as f:
+            with open(metadata_file, "r", encoding="utf-8") as f:
                 metadata = json.load(f)
                 session_name_prefix = metadata.get("session_name_prefix", "LocalJobMgr")
 
@@ -409,7 +385,7 @@ class ZellijLocalManager:
 
             for manager_file in manager_files:
                 try:
-                    with open(manager_file, 'r', encoding='utf-8') as f:
+                    with open(manager_file, "r", encoding="utf-8") as f:
                         manager_data = json.load(f)
 
                     # Recreate the manager
@@ -450,6 +426,7 @@ class ZellijLocalManager:
 
         try:
             import shutil
+
             shutil.rmtree(session_dir)
             logger.info(f"✅ Deleted session: {session_id}")
             return True
@@ -463,15 +440,10 @@ class ZellijLocalManager:
 
         try:
             # Get all running zellij sessions
-            result = subprocess.run(
-                ['zellij', 'list-sessions'],
-                capture_output=True,
-                text=True,
-                timeout=10
-            )
+            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 []
+                all_sessions = result.stdout.strip().split("\n") if result.stdout.strip() else []
 
                 # Filter to only our managed sessions
                 for manager in self.managers:
@@ -480,12 +452,7 @@ 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())
-                    })
+                    active_sessions.append({"session_name": session_name, "is_active": is_active, "tab_count": len(manager.tab_config), "tabs": list(manager.tab_config.keys())})
 
         except Exception as e:
             logger.error(f"Error listing active sessions: {e}")
@@ -496,21 +463,9 @@ 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")
-        }
+        "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")},
     }
 
     try:
@@ -549,4 +504,5 @@ if __name__ == "__main__":
     except Exception as e:
         print(f"❌ Error: {e}")
         import traceback
-        traceback.print_exc()
+
+        traceback.print_exc()