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

machineconfig/cluster/sessions_managers/wt_local_manager.py

@@ -53,36 +53,24 @@ class WTLocalManager:
                 script_path = manager.script_path
 
                 if not script_path:
-                    results[session_name] = {
-                        "success": False,
-                        "error": "No script file path available"
-                    }
+                    results[session_name] = {"success": False, "error": "No script file path available"}
                     continue
 
                 # Execute the PowerShell script to start Windows Terminal
-                cmd = f"powershell -ExecutionPolicy Bypass -File \"{script_path}\""
+                cmd = f'powershell -ExecutionPolicy Bypass -File "{script_path}"'
 
                 logger.info(f"Starting session '{session_name}' with script: {script_path}")
                 result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=30)
 
                 if result.returncode == 0:
-                    results[session_name] = {
-                        "success": True,
-                        "message": f"Session '{session_name}' started successfully"
-                    }
+                    results[session_name] = {"success": True, "message": f"Session '{session_name}' started successfully"}
                     logger.info(f"✅ Session '{session_name}' started successfully")
                 else:
-                    results[session_name] = {
-                        "success": False,
-                        "error": result.stderr or result.stdout
-                    }
+                    results[session_name] = {"success": False, "error": result.stderr or result.stdout}
                     logger.error(f"❌ Failed to start session '{session_name}': {result.stderr}")
 
             except Exception as e:
-                results[session_name] = {
-                    "success": False,
-                    "error": str(e)
-                }
+                results[session_name] = {"success": False, "error": str(e)}
                 logger.error(f"❌ Exception starting session '{session_name}': {e}")
 
         return results
@@ -99,16 +87,10 @@ class WTLocalManager:
                 logger.info(f"Killing Windows Terminal processes for session '{session_name}'")
                 result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=10)
 
-                results[session_name] = {
-                    "success": result.returncode == 0,
-                    "message": "Windows Terminal processes killed" if result.returncode == 0 else result.stderr
-                }
+                results[session_name] = {"success": result.returncode == 0, "message": "Windows Terminal processes killed" if result.returncode == 0 else result.stderr}
 
             except Exception as e:
-                results[session_name] = {
-                    "success": False,
-                    "error": str(e)
-                }
+                results[session_name] = {"success": False, "error": str(e)}
 
         return results
 
@@ -157,12 +139,7 @@ class WTLocalManager:
             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
@@ -172,12 +149,9 @@ class WTLocalManager:
         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,
@@ -187,7 +161,7 @@ class WTLocalManager:
             "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:
@@ -253,6 +227,7 @@ class WTLocalManager:
         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)
@@ -265,13 +240,15 @@ class WTLocalManager:
                 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
@@ -316,13 +293,7 @@ class WTLocalManager:
         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.session2wt_tabs.keys()),
-            "manager_type": "WTLocalManager"
-        }
+        metadata = {"session_name_prefix": self.session_name_prefix, "created_at": str(datetime.now()), "num_managers": len(self.managers), "sessions": list(self.session2wt_tabs.keys()), "manager_type": "WTLocalManager"}
         metadata_file = session_dir / "metadata.json"
         text = json.dumps(metadata, indent=2, ensure_ascii=False)
         metadata_file.write_text(text, encoding="utf-8")
@@ -332,11 +303,7 @@ class WTLocalManager:
         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,
-                "script_path": manager.script_path
-            }
+            manager_data = {"session_name": manager.session_name, "tab_config": manager.tab_config, "script_path": manager.script_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")
@@ -345,7 +312,7 @@ class WTLocalManager:
         return session_id
 
     @classmethod
-    def load(cls, session_id: str) -> 'WTLocalManager':
+    def load(cls, session_id: str) -> "WTLocalManager":
         """Load a saved manager state from disk."""
         session_dir = TMP_SERIALIZATION_DIR / session_id
 
@@ -357,14 +324,14 @@ class WTLocalManager:
         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:
             session2wt_tabs = json.load(f)
 
         # Load metadata
         metadata_file = session_dir / "metadata.json"
         session_name_prefix = "LocalWTMgr"  # 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", "LocalWTMgr")
 
@@ -379,7 +346,7 @@ class WTLocalManager:
 
             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
@@ -420,6 +387,7 @@ class WTLocalManager:
 
         try:
             import shutil
+
             shutil.rmtree(session_dir)
             logger.info(f"✅ Deleted session: {session_id}")
             return True
@@ -434,15 +402,12 @@ class WTLocalManager:
         try:
             # Get all running Windows Terminal processes
             result = subprocess.run(
-                ['powershell', '-Command',
-                 'Get-Process -Name "WindowsTerminal" -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, StartTime, MainWindowTitle | ConvertTo-Json -Depth 2'],
-                capture_output=True,
-                text=True,
-                timeout=10
+                ["powershell", "-Command", 'Get-Process -Name "WindowsTerminal" -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, StartTime, MainWindowTitle | ConvertTo-Json -Depth 2'], capture_output=True, text=True, timeout=10
             )
 
             if result.returncode == 0 and result.stdout.strip():
                 import json
+
                 all_processes = json.loads(result.stdout.strip())
                 if not isinstance(all_processes, list):
                     all_processes = [all_processes]
@@ -457,13 +422,7 @@ class WTLocalManager:
                         if session_name in window_title or not window_title:
                             session_windows.append(proc)
 
-                    active_sessions.append({
-                        "session_name": session_name,
-                        "is_active": len(session_windows) > 0,
-                        "tab_count": len(manager.tab_config),
-                        "tabs": list(manager.tab_config.keys()),
-                        "windows": session_windows
-                    })
+                    active_sessions.append({"session_name": session_name, "is_active": len(session_windows) > 0, "tab_count": len(manager.tab_config), "tabs": list(manager.tab_config.keys()), "windows": session_windows})
 
         except Exception as e:
             logger.error(f"Error listing active sessions: {e}")
@@ -474,59 +433,29 @@ class WTLocalManager:
         """Get overview of all Windows Terminal windows and processes."""
         try:
             result = subprocess.run(
-                ['powershell', '-Command',
-                 'Get-Process -Name "WindowsTerminal" -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, StartTime, MainWindowTitle, CPU | ConvertTo-Json -Depth 2'],
-                capture_output=True,
-                text=True,
-                timeout=10
+                ["powershell", "-Command", 'Get-Process -Name "WindowsTerminal" -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, StartTime, MainWindowTitle, CPU | ConvertTo-Json -Depth 2'], capture_output=True, text=True, timeout=10
             )
 
             if result.returncode == 0 and result.stdout.strip():
                 import json
+
                 processes = json.loads(result.stdout.strip())
                 if not isinstance(processes, list):
                     processes = [processes]
 
-                return {
-                    "success": True,
-                    "total_windows": len(processes),
-                    "windows": processes,
-                    "managed_sessions": len(self.managers)
-                }
+                return {"success": True, "total_windows": len(processes), "windows": processes, "managed_sessions": len(self.managers)}
             else:
-                return {
-                    "success": True,
-                    "total_windows": 0,
-                    "windows": [],
-                    "managed_sessions": len(self.managers),
-                    "message": "No Windows Terminal processes found"
-                }
+                return {"success": True, "total_windows": 0, "windows": [], "managed_sessions": len(self.managers), "message": "No Windows Terminal processes found"}
         except Exception as e:
-            return {
-                "success": False,
-                "error": str(e),
-                "managed_sessions": len(self.managers)
-            }
+            return {"success": False, "error": str(e), "managed_sessions": len(self.managers)}
 
 
 if __name__ == "__main__":
     # Example usage
     sample_sessions = {
-        "development": {
-            "🚀Frontend": ("~/code/myapp/frontend", "npm run dev"),
-            "⚙️Backend": ("~/code/myapp/backend", "python manage.py runserver"),
-            "📊Monitor": ("~", "Get-Process | Sort-Object CPU -Descending | Select-Object -First 10")
-        },
-        "testing": {
-            "🧪Tests": ("~/code/myapp", "pytest --watch"),
-            "🔍Coverage": ("~/code/myapp", "python -m coverage run --source=. -m pytest"),
-            "📝Logs": ("~/logs", "Get-Content app.log -Wait")
-        },
-        "deployment": {
-            "🐳Docker": ("~/code/myapp", "docker-compose up"),
-            "☸️K8s": ("~/k8s", "kubectl get pods --watch"),
-            "📈Metrics": ("~", "Get-Counter \"\\Processor(_Total)\\% Processor Time\" -SampleInterval 2 -MaxSamples 30")
-        }
+        "development": {"🚀Frontend": ("~/code/myapp/frontend", "npm run dev"), "⚙️Backend": ("~/code/myapp/backend", "python manage.py runserver"), "📊Monitor": ("~", "Get-Process | Sort-Object CPU -Descending | Select-Object -First 10")},
+        "testing": {"🧪Tests": ("~/code/myapp", "pytest --watch"), "🔍Coverage": ("~/code/myapp", "python -m coverage run --source=. -m pytest"), "📝Logs": ("~/logs", "Get-Content app.log -Wait")},
+        "deployment": {"🐳Docker": ("~/code/myapp", "docker-compose up"), "☸️K8s": ("~/k8s", "kubectl get pods --watch"), "📈Metrics": ("~", 'Get-Counter "\\Processor(_Total)\\% Processor Time" -SampleInterval 2 -MaxSamples 30')},
     }
 
     try:
@@ -574,4 +503,5 @@ if __name__ == "__main__":
     except Exception as e:
         print(f"❌ Error: {e}")
         import traceback
-        traceback.print_exc()
+
+        traceback.print_exc()

machineconfig/cluster/sessions_managers/wt_remote.py

@@ -18,7 +18,6 @@ TMP_LAYOUT_DIR = Path.home().joinpath("tmp_results", "wt_layouts", "layout_manag
 
 
 class WTRemoteLayoutGenerator:
-
     def __init__(self, remote_name: str, session_name_prefix: str):
         self.remote_name = remote_name
         self.session_name = session_name_prefix + "_" + WTLayoutGenerator.generate_random_suffix()
@@ -102,14 +101,7 @@ class WTRemoteLayoutGenerator:
         return self.remote_executor.get_remote_windows_info()
 
     def to_dict(self) -> Dict[str, Any]:
-        return {
-            "remote_name": self.remote_name,
-            "session_name": self.session_name,
-            "tab_config": self.tab_config,
-            "script_path": self.script_path,
-            "created_at": datetime.now().isoformat(),
-            "class_name": self.__class__.__name__
-        }
+        return {"remote_name": self.remote_name, "session_name": self.session_name, "tab_config": self.tab_config, "script_path": self.script_path, "created_at": datetime.now().isoformat(), "class_name": self.__class__.__name__}
 
     def to_json(self, file_path: Optional[str] = None) -> str:
         # Generate file path if not provided
@@ -122,8 +114,8 @@ class WTRemoteLayoutGenerator:
             path_obj = Path(file_path)
 
         # Ensure .json extension
-        if not str(path_obj).endswith('.json'):
-            path_obj = path_obj.with_suffix('.json')
+        if not str(path_obj).endswith(".json"):
+            path_obj = path_obj.with_suffix(".json")
 
         # Ensure parent directory exists
         path_obj.parent.mkdir(parents=True, exist_ok=True)
@@ -138,38 +130,38 @@ class WTRemoteLayoutGenerator:
         return str(path_obj)
 
     @classmethod
-    def from_json(cls, file_path: str) -> 'WTRemoteLayoutGenerator':
+    def from_json(cls, file_path: str) -> "WTRemoteLayoutGenerator":
         path_obj = Path(file_path)
 
         # Ensure .json extension
-        if not str(path_obj).endswith('.json'):
-            path_obj = path_obj.with_suffix('.json')
+        if not str(path_obj).endswith(".json"):
+            path_obj = path_obj.with_suffix(".json")
 
         if not path_obj.exists():
             raise FileNotFoundError(f"JSON file not found: {path_obj}")
 
         # Load JSON data
-        with open(path_obj, 'r', encoding='utf-8') as f:
+        with open(path_obj, "r", encoding="utf-8") as f:
             data = json.load(f)
 
         # Validate that it's the correct class
-        if data.get('class_name') != cls.__name__:
+        if data.get("class_name") != cls.__name__:
             logger.warning(f"Class name mismatch: expected {cls.__name__}, got {data.get('class_name')}")
 
         # Create new instance
         # Extract session name prefix by removing the suffix
-        session_name = data['session_name']
-        if '_' in session_name:
-            session_name_prefix = '_'.join(session_name.split('_')[:-1])
+        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)
+        instance = cls(remote_name=data["remote_name"], session_name_prefix=session_name_prefix)
 
         # Restore state
-        instance.session_name = data['session_name']
-        instance.tab_config = data['tab_config']
-        instance.script_path = data['script_path']
+        instance.session_name = data["session_name"]
+        instance.tab_config = data["tab_config"]
+        instance.script_path = data["script_path"]
 
         logger.info(f"✅ Loaded WTRemoteLayoutGenerator from: {file_path}")
         return instance
@@ -222,7 +214,7 @@ if __name__ == "__main__":
         "🤖Bot1": ("~/code/bytesense/bithence", "python bot1.py --create_new_bot True"),
         "🤖Bot2": ("~/code/bytesense/bithence", "python bot2.py --create_new_bot True"),
         "📊Monitor": ("~", "Get-Process | Sort-Object CPU -Descending | Select-Object -First 10"),
-        "📝Logs": ("C:/logs", "Get-Content app.log -Wait")
+        "📝Logs": ("C:/logs", "Get-Content app.log -Wait"),
     }
 
     # Replace 'myserver' with an actual SSH config alias for a Windows machine
@@ -267,7 +259,7 @@ if __name__ == "__main__":
         generator.print_status_report()
 
         # Show Windows Terminal overview
-        print(f"\n🖥️  Windows Terminal Overview:")
+        print("\n🖥️  Windows Terminal Overview:")
         generator.print_windows_terminal_overview()
 
         # Start the session (uncomment to actually start)
@@ -277,12 +269,13 @@ if __name__ == "__main__":
         # Attach to session (uncomment to attach)
         # generator.attach_to_session()
 
-        print(f"\n▶️  To start this session, run:")
-        print(f"   generator.start_wt_session()")
-        print(f"\n📎 To attach to this session, run:")
-        print(f"   generator.attach_to_session()")
+        print("\n▶️  To start this session, run:")
+        print("   generator.start_wt_session()")
+        print("\n📎 To attach to this session, run:")
+        print("   generator.attach_to_session()")
 
     except Exception as e:
         print(f"❌ Error: {e}")
         import traceback
-        traceback.print_exc()
+
+        traceback.print_exc()

machineconfig/cluster/sessions_managers/wt_remote_manager.py

@@ -40,10 +40,7 @@ class WTSessionManager:
 
     def kill_all_sessions(self) -> None:
         for an_m in self.managers:
-            WTRemoteLayoutGenerator.run_remote_command(
-                remote_name=an_m.remote_name,
-                command="powershell -Command \"Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue | Stop-Process -Force\""
-            )
+            WTRemoteLayoutGenerator.run_remote_command(remote_name=an_m.remote_name, command="powershell -Command \"Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue | Stop-Process -Force\"")
 
     def run_monitoring_routine(self, wait_ms: int = 60000) -> None:
         def routine(scheduler: Scheduler):
@@ -81,6 +78,7 @@ class WTSessionManager:
                 # Print statuses
                 for i, status in enumerate(statuses):
                     print(f"Manager {i}: {status}")
+
         sched = Scheduler(routine=routine, wait_ms=wait_ms, logger=logger)
         sched.run()
 
@@ -98,13 +96,7 @@ class WTSessionManager:
         config_file.write_text(text, encoding="utf-8")
 
         # Save session metadata
-        metadata = {
-            "session_name_prefix": self.session_name_prefix,
-            "created_at": str(datetime.now()),
-            "num_managers": len(self.managers),
-            "machines": list(self.machine2wt_tabs.keys()),
-            "manager_type": "WTSessionManager"
-        }
+        metadata = {"session_name_prefix": self.session_name_prefix, "created_at": str(datetime.now()), "num_managers": len(self.managers), "machines": list(self.machine2wt_tabs.keys()), "manager_type": "WTSessionManager"}
         metadata_file = session_dir / "metadata.json"
         text = json.dumps(metadata, indent=2, ensure_ascii=False)
         metadata_file.write_text(text, encoding="utf-8")
@@ -121,7 +113,7 @@ class WTSessionManager:
         return session_id
 
     @classmethod
-    def load(cls, session_id: str) -> 'WTSessionManager':
+    def load(cls, session_id: str) -> "WTSessionManager":
         session_dir = TMP_SERIALIZATION_DIR / session_id
 
         if not session_dir.exists():
@@ -129,14 +121,14 @@ class WTSessionManager:
         config_file = session_dir / "machine2wt_tabs.json"
         if not config_file.exists():
             raise FileNotFoundError(f"Configuration file not found: {config_file}")
-        with open(config_file, 'r', encoding='utf-8') as f:
+        with open(config_file, "r", encoding="utf-8") as f:
             machine2wt_tabs = json.load(f)
 
         # Load metadata
         metadata_file = session_dir / "metadata.json"
         session_name_prefix = "WTJobMgr"  # 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", "WTJobMgr")
         # Create new instance (this will create new managers)
@@ -179,6 +171,7 @@ class WTSessionManager:
 
         try:
             import shutil
+
             shutil.rmtree(session_dir)
             logger.info(f"✅ Deleted session: {session_id}")
             return True
@@ -205,10 +198,7 @@ class WTSessionManager:
                     logger.error(f"❌ Failed to start session '{session_name}' on {remote_name}: {start_result.get('error')}")
 
             except Exception as e:
-                results[f"{manager.remote_name}:{manager.session_name}"] = {
-                    "success": False,
-                    "error": str(e)
-                }
+                results[f"{manager.remote_name}:{manager.session_name}"] = {"success": False, "error": str(e)}
                 logger.error(f"❌ Exception starting session on {manager.remote_name}: {e}")
 
         return results
@@ -236,26 +226,11 @@ class WTSessionManager:
                     "session_name": manager.session_name,
                     "wt_status": wt_status,
                     "commands_status": commands_status,
-                    "summary": {
-                        "total_commands": total_count,
-                        "running_commands": running_count,
-                        "stopped_commands": total_count - running_count,
-                        "session_healthy": wt_status.get("wt_running", False)
-                    }
+                    "summary": {"total_commands": total_count, "running_commands": running_count, "stopped_commands": total_count - running_count, "session_healthy": wt_status.get("wt_running", False)},
                 }
 
             except Exception as e:
-                status_report[session_key] = {
-                    "remote_name": manager.remote_name,
-                    "session_name": manager.session_name,
-                    "error": str(e),
-                    "summary": {
-                        "total_commands": 0,
-                        "running_commands": 0,
-                        "stopped_commands": 0,
-                        "session_healthy": False
-                    }
-                }
+                status_report[session_key] = {"remote_name": manager.remote_name, "session_name": manager.session_name, "error": str(e), "summary": {"total_commands": 0, "running_commands": 0, "stopped_commands": 0, "session_healthy": False}}
                 logger.error(f"Error checking status for {session_key}: {e}")
 
         return status_report
@@ -265,12 +240,9 @@ class WTSessionManager:
         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,
@@ -281,7 +253,7 @@ class WTSessionManager:
             "stopped_commands": total_commands - total_running,
             "all_sessions_healthy": healthy_sessions == total_sessions,
             "all_commands_running": total_running == total_commands,
-            "remote_machines": list(set(status["remote_name"] for status in all_status.values()))
+            "remote_machines": list(set(status["remote_name"] for status in all_status.values())),
         }
 
     def print_status_report(self) -> None:
@@ -366,19 +338,10 @@ class WTSessionManager:
                 # Get Windows Terminal version
                 wt_version = manager.get_wt_version()
 
-                overview[remote_name] = {
-                    "windows_info": windows_info,
-                    "wt_processes": wt_processes,
-                    "wt_version": wt_version,
-                    "session_name": manager.session_name,
-                    "tab_count": len(manager.tab_config)
-                }
+                overview[remote_name] = {"windows_info": windows_info, "wt_processes": wt_processes, "wt_version": wt_version, "session_name": manager.session_name, "tab_count": len(manager.tab_config)}
 
             except Exception as e:
-                overview[manager.remote_name] = {
-                    "error": str(e),
-                    "session_name": manager.session_name
-                }
+                overview[manager.remote_name] = {"error": str(e), "session_name": manager.session_name}
 
         return overview
 
@@ -431,14 +394,8 @@ class WTSessionManager:
 if __name__ == "__main__":
     # Example usage
     sample_machines = {
-        "server1": {
-            "🤖Bot1": ("~/code/project", "python bot1.py"),
-            "📊Monitor": ("~", "Get-Process | Sort-Object CPU -Descending | Select-Object -First 10"),
-        },
-        "server2": {
-            "🤖Bot2": ("~/code/project", "python bot2.py"),
-            "📝Logs": ("C:/logs", "Get-Content app.log -Wait"),
-        }
+        "server1": {"🤖Bot1": ("~/code/project", "python bot1.py"), "📊Monitor": ("~", "Get-Process | Sort-Object CPU -Descending | Select-Object -First 10")},
+        "server2": {"🤖Bot2": ("~/code/project", "python bot2.py"), "📝Logs": ("C:/logs", "Get-Content app.log -Wait")},
     }
 
     try:
@@ -483,4 +440,5 @@ if __name__ == "__main__":
     except Exception as e:
         print(f"❌ Error: {e}")
         import traceback
-        traceback.print_exc()
+
+        traceback.print_exc()