machineconfig 2.95__py3-none-any.whl → 2.98__py3-none-any.whl

machineconfig/cluster/sessions_managers/zellij_local.py

@@ -1,10 +1,11 @@
 #!/usr/bin/env python3
 import shlex
 import subprocess
+from machineconfig.cluster.sessions_managers.zellij_utils.monitoring_types import CommandStatusResult,  ZellijSessionStatus, ComprehensiveStatus, ProcessInfo
 import psutil
 import random
 import string
-from typing import Dict, List, Optional, Any
+from typing import List, Optional
 from pathlib import Path
 import logging
 
@@ -12,6 +13,8 @@ from rich.console import Console
 
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig, TabConfig
 
+
+
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 console = Console()
@@ -154,7 +157,7 @@ class ZellijLayoutGenerator:
         return layout_content + "\n}\n"
 
     @staticmethod
-    def check_command_status(tab_name: str, layout_config: LayoutConfig) -> Dict[str, Any]:
+    def check_command_status(tab_name: str, layout_config: LayoutConfig) -> CommandStatusResult:
         # Find the tab with the given name
         tab_config = None
         for tab in layout_config["layoutTabs"]:
@@ -163,39 +166,99 @@ class ZellijLayoutGenerator:
                 break
 
         if tab_config is None:
-            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in layout config", "running": False, "pid": None, "command": None, "cwd": None}
+            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in layout config", "running": False, "command": "", "cwd": "", "tab_name": tab_name, "processes": []}
 
         command = tab_config["command"]
         cwd = tab_config["startDir"]
-        cmd, _ = ZellijLayoutGenerator._parse_command(command)
+        cmd, args = ZellijLayoutGenerator._parse_command(command)
 
         try:
-            # Look for processes matching the command
-            matching_processes = []
-            for proc in psutil.process_iter(["pid", "name", "cmdline", "status"]):
+            # Look for processes matching the command more accurately
+            matching_processes: list[ProcessInfo] = []
+            for proc in psutil.process_iter(["pid", "name", "cmdline", "status", "ppid"]):
+                try:
+                    if not proc.info["cmdline"] or len(proc.info["cmdline"]) == 0:
+                        continue
+                    
+                    # Skip processes that are already dead/zombie/stopped
+                    if proc.info["status"] in ["zombie", "dead", "stopped"]:
+                        continue
+                    
+                    # Get the actual command from cmdline
+                    proc_cmdline = proc.info["cmdline"]
+                    proc_name = proc.info["name"]
+                    
+                    # More precise matching logic
+                    is_match = False
+                    
+                    # Check if this is the exact command we're looking for
+                    if proc_name == cmd:
+                        # For exact name matches, also check if arguments match or if it's a reasonable match
+                        if len(args) == 0 or any(arg in " ".join(proc_cmdline) for arg in args):
+                            is_match = True
+                    
+                    # Check if the command appears in the command line
+                    elif cmd in proc_cmdline[0]:
+                        is_match = True
+                    
+                    # For script-based commands, check if the script name appears
+                    elif any(cmd in arg for arg in proc_cmdline):
+                        is_match = True
+                    
+                    # Skip shell processes that are just wrappers unless they're running our specific command
+                    if is_match and proc_name in ["bash", "sh", "zsh", "fish"]:
+                        # Only count shell processes if they contain our specific command
+                        full_cmdline = " ".join(proc_cmdline)
+                        if cmd not in full_cmdline and not any(arg in full_cmdline for arg in args):
+                            is_match = False
+                    
+                    if is_match:
+                        # Additional check: make sure the process is actually running something meaningful
+                        try:
+                            # Check if process has been running for a reasonable time and is active
+                            proc_obj = psutil.Process(proc.info["pid"])
+                            if proc_obj.status() not in ["running", "sleeping"]:
+                                continue  # Skip inactive processes
+                                
+                            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
+                            
+                except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                    continue
+
+            # Filter out clearly finished processes or parent shells
+            active_processes = []
+            for proc_info in matching_processes:
                 try:
-                    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"]})
-                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    proc = psutil.Process(proc_info["pid"])
+                    # Double-check the process is still active
+                    if proc.status() in ["running", "sleeping"] and proc.is_running():
+                        active_processes.append(proc_info)
+                except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                    # Process is gone, don't count it
                     continue
 
-            if matching_processes:
-                return {"status": "running", "running": True, "processes": matching_processes, "command": command, "cwd": cwd, "tab_name": tab_name}
+            if active_processes:
+                return {"status": "running", "running": True, "processes": active_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}
 
         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, "processes": []}
 
-    def check_all_commands_status(self) -> Dict[str, Dict[str, Any]]:
+    def check_all_commands_status(self) -> dict[str, CommandStatusResult]:
         if not self.layout_config:
             logger.warning("No layout config tracked. Make sure to create a layout first.")
             return {}
 
-        status_report = {}
+        status_report: dict[str, CommandStatusResult] = {}
         for tab in self.layout_config["layoutTabs"]:
             tab_name = tab["tabName"]
             status_report[tab_name] = ZellijLayoutGenerator.check_command_status(tab_name, self.layout_config)
@@ -203,7 +266,7 @@ class ZellijLayoutGenerator:
         return status_report
 
     @staticmethod
-    def check_zellij_session_status(session_name: str) -> Dict[str, Any]:
+    def check_zellij_session_status(session_name: str) -> ZellijSessionStatus:
         try:
             # Run zellij list-sessions command
             result = subprocess.run(["zellij", "list-sessions"], capture_output=True, text=True, timeout=10)
@@ -214,16 +277,16 @@ class ZellijLayoutGenerator:
 
                 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, "session_name": session_name, "all_sessions": [], "error": result.stderr}
 
         except subprocess.TimeoutExpired:
-            return {"zellij_running": False, "error": "Timeout while checking Zellij sessions", "session_name": session_name}
+            return {"zellij_running": False, "session_name": session_name, "all_sessions": [], "error": "Timeout while checking Zellij sessions"}
         except FileNotFoundError:
-            return {"zellij_running": False, "error": "Zellij not found in PATH", "session_name": session_name}
+            return {"zellij_running": False, "session_name": session_name, "all_sessions": [], "error": "Zellij not found in PATH"}
         except Exception as e:
-            return {"zellij_running": False, "error": str(e), "session_name": session_name}
+            return {"zellij_running": False, "session_name": session_name, "all_sessions": [], "error": str(e)}
 
-    def get_comprehensive_status(self) -> Dict[str, Any]:
+    def get_comprehensive_status(self) -> ComprehensiveStatus:
         zellij_status = ZellijLayoutGenerator.check_zellij_session_status(self.session_name or "default")
         commands_status = self.check_all_commands_status()
 

machineconfig/cluster/sessions_managers/zellij_local_manager.py

@@ -6,14 +6,16 @@ import logging
 import subprocess
 import time
 from pathlib import Path
-from typing import Optional, Dict, List, Any
+from typing import Optional, List
 
 from rich.console import Console
 
+from machineconfig.cluster.sessions_managers.zellij_utils.monitoring_types import SessionReport, GlobalSummary, StartResult, ActiveSessionInfo
 from machineconfig.utils.utils5 import Scheduler
 from machineconfig.cluster.sessions_managers.zellij_local import ZellijLayoutGenerator
 from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
 
+
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 console = Console()
@@ -24,7 +26,7 @@ TMP_SERIALIZATION_DIR = Path.home().joinpath("tmp_results", "session_manager", "
 class ZellijLocalManager:
     """Manages multiple local zellij sessions and monitors their tabs and processes."""
 
-    def __init__(self, session_layouts: list[LayoutConfig], ):
+    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] = []
@@ -44,7 +46,7 @@ class ZellijLocalManager:
         """Get all managed session names."""
         return [manager.session_name for manager in self.managers if manager.session_name is not None]
 
-    def start_all_sessions(self, poll_seconds: float = 5.0, poll_interval: float = 0.25) -> Dict[str, Any]:
+    def start_all_sessions(self, poll_seconds: float = 5.0, poll_interval: float = 0.25) -> dict[str, StartResult]:
         """Start all zellij sessions with their layouts without blocking on the interactive TUI.
 
         Rationale:
@@ -60,7 +62,7 @@ class ZellijLocalManager:
         Returns:
             Dict mapping session name to success metadata.
         """
-        results: Dict[str, Any] = {}
+        results: dict[str, StartResult] = {}
         for manager in self.managers:
             session_name = manager.session_name
             try:
@@ -110,9 +112,9 @@ class ZellijLocalManager:
                 logger.error(f"❌ Exception starting session '{key}': {e}")
         return results
 
-    def kill_all_sessions(self) -> Dict[str, Any]:
+    def kill_all_sessions(self) -> dict[str, StartResult]:
         """Kill all managed zellij sessions."""
-        results = {}
+        results: dict[str, StartResult] = {}
         for manager in self.managers:
             try:
                 session_name = manager.session_name
@@ -158,9 +160,9 @@ class ZellijLocalManager:
                 commands.append("")
             return "\n".join(commands)
 
-    def check_all_sessions_status(self) -> Dict[str, Dict[str, Any]]:
+    def check_all_sessions_status(self) -> dict[str, SessionReport]:
         """Check the status of all sessions and their commands."""
-        status_report = {}
+        status_report: dict[str, SessionReport] = {}
 
         for manager in self.managers:
             session_name = manager.session_name
@@ -185,7 +187,7 @@ class ZellijLocalManager:
 
         return status_report
 
-    def get_global_summary(self) -> Dict[str, Any]:
+    def get_global_summary(self) -> GlobalSummary:
         """Get a global summary across all sessions."""
         all_status = self.check_all_sessions_status()
 
@@ -298,7 +300,8 @@ class ZellijLocalManager:
                     running_count = sum(1 for row in status_data if row.get("running", False))
                     if running_count == 0:
                         print("\n⚠️  All commands have stopped. Stopping monitoring.")
-                        scheduler.max_cycles = scheduler.cycle
+                        # Set max_cycles to current cycle + 1 to exit after this cycle
+                        scheduler.max_cycles = scheduler.cycle + 1
                         return
                 else:
                     print("No status data available")
@@ -420,9 +423,9 @@ class ZellijLocalManager:
             logger.error(f"Failed to delete session {session_id}: {e}")
             return False
 
-    def list_active_sessions(self) -> List[Dict[str, Any]]:
+    def list_active_sessions(self) -> list[ActiveSessionInfo]:
         """List currently active zellij sessions managed by this instance."""
-        active_sessions = []
+        active_sessions: list[ActiveSessionInfo] = []
 
         try:
             # Get all running zellij sessions
@@ -482,7 +485,7 @@ if __name__ == "__main__":
     ]
     try:
         # Create the local manager
-        manager = ZellijLocalManager(sample_sessions,)
+        manager = ZellijLocalManager(sample_sessions)
         print(f"✅ Local manager created with {len(manager.managers)} sessions")
 
         # Show session names

machineconfig/cluster/sessions_managers/zellij_utils/monitoring_types.py

@@ -0,0 +1,121 @@
+# TypedDict definitions for better type safety
+from typing import NotRequired, TypedDict, Optional
+
+# Import concrete types to replace Any usage
+from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
+
+
+class ProcessInfo(TypedDict):
+    pid: int
+    name: str
+    cmdline: list[str]
+    status: str
+
+class CommandStatus(TypedDict):
+    status: str
+    running: bool
+    processes: list[ProcessInfo]
+    command: str
+    cwd: str
+    tab_name: str
+    error: NotRequired[str]
+    pid: NotRequired[int]
+
+
+class SessionStatus(TypedDict):
+    session_exists: bool
+    zellij_running: bool
+    session_name: str
+    all_sessions: list[str]
+    error: NotRequired[str]
+
+
+class CommandSummary(TypedDict):
+    total_commands: int
+    running_commands: int
+    stopped_commands: int
+    session_healthy: bool
+
+
+class CommandStatusResult(TypedDict):
+    status: str
+    running: bool
+    processes: list[ProcessInfo]
+    command: str
+    cwd: str
+    tab_name: str
+    error: NotRequired[str]
+    pid: NotRequired[int]
+
+
+class ZellijSessionStatus(TypedDict):
+    zellij_running: bool
+    session_exists: NotRequired[bool]
+    session_name: str
+    all_sessions: list[str]
+    error: NotRequired[str]
+
+
+class SessionReport(TypedDict):
+    session_status: ZellijSessionStatus  # ZellijSessionStatus from zellij_local
+    commands_status: dict[str, CommandStatusResult]  # dict[str, CommandStatusResult from zellij_local]  
+    summary: CommandSummary
+
+
+class GlobalSummary(TypedDict):
+    total_sessions: int
+    healthy_sessions: int
+    unhealthy_sessions: int
+    total_commands: int
+    running_commands: int
+    stopped_commands: int
+    all_sessions_healthy: bool
+    all_commands_running: bool
+
+
+class StartResult(TypedDict):
+    success: bool
+    message: NotRequired[str]
+    error: NotRequired[str]
+
+
+class StatusRow(TypedDict):
+    session: str
+    tab: str
+    running: bool
+    command: str
+    processes: int
+
+
+class SessionMetadata(TypedDict):
+    session_name_prefix: str
+    created_at: str
+    num_managers: int
+    sessions: list[str]
+    manager_type: str
+
+
+class ManagerData(TypedDict):
+    session_name: Optional[str]
+    layout_config: Optional[LayoutConfig]  # Will be LayoutConfig from layout_types
+    layout_path: Optional[str]
+
+
+class ActiveSessionInfo(TypedDict):
+    session_name: str
+    is_active: bool
+    tab_count: int
+    tabs: list[str]
+
+
+class StatusSummary(TypedDict):
+    total_commands: int
+    running_commands: int
+    stopped_commands: int
+    session_healthy: bool
+
+
+class ComprehensiveStatus(TypedDict):
+    zellij_session: ZellijSessionStatus
+    commands: dict[str, CommandStatusResult]
+    summary: StatusSummary

machineconfig/scripts/python/fire_agents.py

@@ -15,8 +15,8 @@ import sys
 from machineconfig.scripts.python.fire_agents_help_launch import prep_agent_launch, get_agents_launch_layout, AGENTS
 from machineconfig.scripts.python.fire_agents_help_search import search_files_by_pattern, search_python_files
 from machineconfig.scripts.python.fire_agents_load_balancer import chunk_prompts, SPLITTING_STRATEGY, DEFAULT_AGENT_CAP
-from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
 from machineconfig.utils.options import choose_one_option
+from machineconfig.utils.schemas.layouts.layout_types import LayoutsFile
 from machineconfig.utils.ve import get_repo_root
 
 SEARCH_STRATEGIES: TypeAlias = Literal["file_path", "keyword_search", "filename_pattern"]
@@ -141,10 +141,22 @@ manager.run_monitoring_routine()
     if len(layoutfile["layouts"][0]["layoutTabs"]) > 25:
         print("Too many agents (>25) to launch. Skipping launch.")
         sys.exit(0)
+    from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
     manager = ZellijLocalManager(session_layouts=layoutfile["layouts"])
     manager.start_all_sessions()
     manager.run_monitoring_routine()
 
 
+def launch_sequentially(layoutfile: "LayoutsFile"):
+    from machineconfig.utils.utils2 import split
+    from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
+    for layout_chunk in split(layoutfile["layouts"], every=3):
+        manager = ZellijLocalManager(session_layouts=layout_chunk)
+        manager.start_all_sessions()
+        manager.run_monitoring_routine()
+
+
+
+
 if __name__ == "__main__":  # pragma: no cover
     main()

machineconfig/scripts/python/fire_agents_help_launch.py

@@ -74,10 +74,10 @@ sleep 0.1
                 model = "gemini-2.5-pro"
                 # model = "gemini-2.5-flash-lite"
                 # model = None  # auto-select
-                if model is None:
-                    model_arg = ""
-                else:
-                    model_arg = f"--model {shlex.quote(model)}"
+                # if model is None:
+                #     model_arg = ""
+                # else:
+                model_arg = f"--model {shlex.quote(model)}"
                 # Need a real shell for the pipeline; otherwise '| gemini ...' is passed as args to 'cat'
                 safe_path = shlex.quote(str(prompt_path))
                 api_keys = get_gemini_api_keys()

machineconfig/utils/options.py

@@ -4,13 +4,10 @@ from rich.panel import Panel
 from rich.console import Console
 import platform
 import subprocess
-from typing import Optional, Union, TypeVar, Iterable
+from typing import Optional, Union, Iterable
 from machineconfig.utils.source_of_truth import WINDOWS_INSTALL_PATH, LINUX_INSTALL_PATH
 
 
-T = TypeVar("T")
-
-
 def check_tool_exists(tool_name: str) -> bool:
     if platform.system() == "Windows":
         tool_name = tool_name.replace(".exe", "") + ".exe"
@@ -35,20 +32,20 @@ def check_tool_exists(tool_name: str) -> bool:
     # return root_path.joinpath(tool_name).is_file()
 
 
-def choose_one_option(options: Iterable[T], header: str = "", tail: str = "", prompt: str = "", msg: str = "", default: Optional[T] = None, fzf: bool = False, custom_input: bool = False) -> T:
+def choose_one_option[T](options: Iterable[T], header: str = "", tail: str = "", prompt: str = "", msg: str = "", default: Optional[T] = None, fzf: bool = False, custom_input: bool = False) -> T:
     choice_key = display_options(msg=msg, options=options, header=header, tail=tail, prompt=prompt, default=default, fzf=fzf, multi=False, custom_input=custom_input)
     assert not isinstance(choice_key, list)
     return choice_key
 
 
-def choose_multiple_options(options: Iterable[T], header: str = "", tail: str = "", prompt: str = "", msg: str = "", default: Optional[T] = None, custom_input: bool = False) -> list[T]:
+def choose_multiple_options[T](options: Iterable[T], header: str = "", tail: str = "", prompt: str = "", msg: str = "", default: Optional[T] = None, custom_input: bool = False) -> list[T]:
     choice_key = display_options(msg=msg, options=options, header=header, tail=tail, prompt=prompt, default=default, fzf=True, multi=True, custom_input=custom_input)
     if isinstance(choice_key, list):
         return choice_key
     return [choice_key]
 
 
-def display_options(msg: str, options: Iterable[T], header: str = "", tail: str = "", prompt: str = "", default: Optional[T] = None, fzf: bool = False, multi: bool = False, custom_input: bool = False) -> Union[T, list[T]]:
+def display_options[T](msg: str, options: Iterable[T], header: str = "", tail: str = "", prompt: str = "", default: Optional[T] = None, fzf: bool = False, multi: bool = False, custom_input: bool = False) -> Union[T, list[T]]:
     # TODO: replace with https://github.com/tmbo/questionary
     # # also see https://github.com/charmbracelet/gum
     tool_name = "fzf"

machineconfig/utils/path.py

@@ -5,11 +5,9 @@ from rich.console import Console
 from rich.panel import Panel
 import platform
 import subprocess
-from typing import TypeVar
 from pathlib import Path
 
 
-T = TypeVar("T")
 console = Console()
 
 

machineconfig/utils/utils2.py

@@ -18,6 +18,19 @@ def randstr(length: int = 10, lower: bool = True, upper: bool = True, digits: bo
     return "".join(random.choices(population, k=length))
 
 
+def split[T](iterable: list[T], every: int = 1, to: Optional[int] = None) -> list[list[T]]:
+    import math
+    every = every if to is None else math.ceil(len(iterable) / to)
+    res: list[list[T]] = []
+    for ix in range(0, len(iterable), every):
+        if ix + every < len(iterable):
+            tmp = iterable[ix : ix + every]
+        else:
+            tmp = iterable[ix : len(iterable)]
+        res.append(list(tmp))
+    return list(res)
+
+
 def read_ini(path: "Path", encoding: Optional[str] = None):
     if not Path(path).exists() or Path(path).is_dir():
         raise FileNotFoundError(f"File not found or is a directory: {path}")

{machineconfig-2.95.dist-info → machineconfig-2.98.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 2.95
+Version: 2.98
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0

{machineconfig-2.95.dist-info → machineconfig-2.98.dist-info}/RECORD

@@ -16,8 +16,8 @@ machineconfig/cluster/sessions_managers/wt_local.py,sha256=5tBgiWf-gsAvg1PrSEF7Z
 machineconfig/cluster/sessions_managers/wt_local_manager.py,sha256=EqSdzHx5VLkaxKXLfHXigpaGB3dXS5RS-04d-BiTgzI,24192
 machineconfig/cluster/sessions_managers/wt_remote.py,sha256=7KT5D0FM9wwY8N3Mp9uO9rv3z29n6HIDJfPSLWXOIIs,8755
 machineconfig/cluster/sessions_managers/wt_remote_manager.py,sha256=V7Z_1sLGfCjyGh2rxbtnDCzrzlMYrdY_6uG3Gljp20o,19758
-machineconfig/cluster/sessions_managers/zellij_local.py,sha256=I2iQAS7G13lxQa0KCfHHXYMo9_54dDUwOYNKW_AWlek,17081
-machineconfig/cluster/sessions_managers/zellij_local_manager.py,sha256=eemuygUYs6jjAns_xjX-W25T8pVw4Ds7aXK8WQQ2Ot0,23464
+machineconfig/cluster/sessions_managers/zellij_local.py,sha256=dPrnSvRlzhs8tWY1pI3qOqKYexUKsRp5S3nPqAx5LfE,20557
+machineconfig/cluster/sessions_managers/zellij_local_manager.py,sha256=AoUnXIL-K31HcO-Xto-eTcuvy3u5G0Y0VG4aRvlUzj8,23785
 machineconfig/cluster/sessions_managers/zellij_remote.py,sha256=G1SdycIHuCBMOnO5kfxDNN-boNxZ6PSh0xsZsDK8H1s,11039
 machineconfig/cluster/sessions_managers/zellij_remote_manager.py,sha256=2ZoSPrlsYJbugH8f8doNIDhmbv2M61DN9KIQNVUqE1k,8116
 machineconfig/cluster/sessions_managers/wt_utils/layout_generator.py,sha256=CFGcZPFTZQJtFf0OvMUHhadZ0qbImCP3wxvbWYVcVYo,7445
@@ -27,6 +27,7 @@ machineconfig/cluster/sessions_managers/wt_utils/session_manager.py,sha256=-PNcY
 machineconfig/cluster/sessions_managers/wt_utils/status_reporter.py,sha256=EEscow4hsvLJ1roXEXxXg0QUEwetJmTq0VRm_1Vg6L0,9499
 machineconfig/cluster/sessions_managers/zellij_utils/example_usage.py,sha256=lxeZVYIelUEf7pFSmg1F5jPbWfzuxQmZ2IBZsHMwFVk,2852
 machineconfig/cluster/sessions_managers/zellij_utils/layout_generator.py,sha256=OfMhdqDR43r8vEnTNSrV9hvMHG3cNl7EmJKB_ChJBJ8,5263
+machineconfig/cluster/sessions_managers/zellij_utils/monitoring_types.py,sha256=v0bHlnxYVVvsDX-s_2W7UYAGZFNuIRD7VAPL5VejZ9o,2667
 machineconfig/cluster/sessions_managers/zellij_utils/process_monitor.py,sha256=8ilY7ntXWTsFy6-G-j2GZvakK4C43s5y5RFw_feOnDk,13298
 machineconfig/cluster/sessions_managers/zellij_utils/remote_executor.py,sha256=Nkd5QFw5yG2qD2-WLioqi-e3WKuOqGA8C35epGmB49g,2602
 machineconfig/cluster/sessions_managers/zellij_utils/session_manager.py,sha256=U_Gvhf-uPwY8jFoxg4aOWsIQbYjd8ueRsfPim1Wv0Pc,4936
@@ -172,8 +173,8 @@ machineconfig/scripts/python/devops_backup_retrieve.py,sha256=I7lghN_HJT1mPaZ7zc
 machineconfig/scripts/python/devops_devapps_install.py,sha256=xQaOHlr6ziHxrx7e5Ri7WQ-FjIW0hjzDhlPJC-3qwks,8596
 machineconfig/scripts/python/devops_update_repos.py,sha256=sqtkpQ2InUz-TFLhejN8EZqjZC1aBanAhohL6aHxPf0,8213
 machineconfig/scripts/python/dotfile.py,sha256=miL8mQH2AqPdnHSz0Cxa7qQavaOmzTD9DAF66H2PRzA,2259
-machineconfig/scripts/python/fire_agents.py,sha256=XIxOhI5q7DWpZJMs3rrhvdl0k8t-UICEpSp5W8Oc7bk,7716
-machineconfig/scripts/python/fire_agents_help_launch.py,sha256=70iFF0wmFYKvaPsUy35_bIw5ivn5EdonahjSw1GTMIs,6125
+machineconfig/scripts/python/fire_agents.py,sha256=HoT2NjNDB3lmmGjcsvFVf8dTtCAQKBh_DtdhLClL_Bw,8202
+machineconfig/scripts/python/fire_agents_help_launch.py,sha256=B3Pl2uLIk3EMttT1eRaJeBMoH1u_05PsMqEBYKyYogU,6127
 machineconfig/scripts/python/fire_agents_help_search.py,sha256=jEgPFMHL4s1VHQ1AJO1YdV2pyGdxdaCY5XxDUvC55nU,2991
 machineconfig/scripts/python/fire_agents_load_balancer.py,sha256=FeTfbp7n6jHHwMp4L6KVYO5HgenP57XpCyaab_vCwc0,2135
 machineconfig/scripts/python/fire_jobs.py,sha256=IRs0_KY8WvYdF4Zr9fF-wWyqZYTx-zfhAx5ExYbwpOg,16642
@@ -397,8 +398,8 @@ machineconfig/utils/installer.py,sha256=725N-0gmMbrWWh6_9sn-2w9aXrfjIPrnuu9o13T4
 machineconfig/utils/io_save.py,sha256=iC1YTH0MOlBS8bWUB8Xhdl4CG_bEKQ3OVwMohdCOazI,3145
 machineconfig/utils/links.py,sha256=5rDQ6Id-vTtJRFwOWX8xZDXIOR5lY0DgLy0HpxIKLhk,10247
 machineconfig/utils/notifications.py,sha256=q1kZM1y4ZmNhAHlEWZlzLE2HS3nnevrSUpunxd8rAT4,9307
-machineconfig/utils/options.py,sha256=F8w5AEvm8yxgipYpLgeHlXJtvoXigZvDJjSqA5TU9J0,8554
-machineconfig/utils/path.py,sha256=k0iyDaYsO-4yWCzjZ88-SxXDZLZPTGYX2WeSU8Pn-6w,8056
+machineconfig/utils/options.py,sha256=wCP1oN-UFl8CbcCfJ7Orw_Ghy2ZKqNLiolzCGeRVfuk,8535
+machineconfig/utils/path.py,sha256=csRyffpWYY5-sqeQCZyWi_z4b295EAztEmZWyvFYRW8,8012
 machineconfig/utils/path_reduced.py,sha256=hccGUTSMtggU-LpLNS7W_c1s-CqhjHMbTQ59-1EqgmY,52473
 machineconfig/utils/procs.py,sha256=aw2UyFvoJw69zDzfcxG46z-4O8MA5WsXvRpvFTqht-4,11484
 machineconfig/utils/scheduling.py,sha256=8xjeoR_D5QHT0d7299Mgsj6JUbvkE_PX_pWq3myi658,11184
@@ -406,7 +407,7 @@ machineconfig/utils/source_of_truth.py,sha256=GnjcVkKm11RyZFHGnPbne5YDEBYoZ5yryB
 machineconfig/utils/ssh.py,sha256=YBL2avhPUC43L1wxi2Doh2-cK-I7j81eUWEmfzAj9Jc,21196
 machineconfig/utils/terminal.py,sha256=k3xoMwJPGvmaeL9CxEIwrcQjRNN6EnJItoIIxXrUY8c,12258
 machineconfig/utils/upgrade_packages.py,sha256=H96zVJEWXJW07nh5vhjuSCrPtXGqoUb7xeJsFYYdmCI,3330
-machineconfig/utils/utils2.py,sha256=Y9bX4gaaPih7gbOeTcfPhQ3CcMFKGXgVCEQhVhljH4Q,2526
+machineconfig/utils/utils2.py,sha256=wcvI9Vcz3A1syRL1qs75jVTmGsLyFh1ZIZlfGmG9cfE,2972
 machineconfig/utils/utils5.py,sha256=s2NFUBcm4Jeuet8sUC7WKGSrYT4BnqTog39bsynXLik,15166
 machineconfig/utils/ve.py,sha256=bi2bCiBbCdNICvXA8stXvMOmvtipd1dMePDTX_IYZcc,2765
 machineconfig/utils/ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -419,8 +420,8 @@ machineconfig/utils/installer_utils/installer_class.py,sha256=3jknokPmaN4LuBR5n6
 machineconfig/utils/schemas/fire_agents/fire_agents_input.py,sha256=Pkp5nzmzuFOKhVHhaAcue7gmCOKrm7m0ft_FSdDn6X8,2350
 machineconfig/utils/schemas/layouts/layout_types.py,sha256=9l8c02MVX_e-OOvGTlfM_Ef6wWw6_Wqru1g7HxWnhgU,615
 machineconfig/utils/schemas/repos/repos_types.py,sha256=beWlwPRNDBABmlzxHBYkAsMXS1MgFFdDZf4G2ge8J-I,408
-machineconfig-2.95.dist-info/METADATA,sha256=yL5o8Om_xVx_w4EfyWB6GlvVoLSIH0QySr-K1kwSxMs,7049
-machineconfig-2.95.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-machineconfig-2.95.dist-info/entry_points.txt,sha256=71EzS7_2LTIigVxC1YXNxHXhC9mu5Me2Feyq2KocXBI,977
-machineconfig-2.95.dist-info/top_level.txt,sha256=porRtB8qms8fOIUJgK-tO83_FeH6Bpe12oUVC670teA,14
-machineconfig-2.95.dist-info/RECORD,,
+machineconfig-2.98.dist-info/METADATA,sha256=4Vf7Rgil9VfPA1EYFpD30HClPoxIsQNerPqI3tP6Jpw,7049
+machineconfig-2.98.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+machineconfig-2.98.dist-info/entry_points.txt,sha256=71EzS7_2LTIigVxC1YXNxHXhC9mu5Me2Feyq2KocXBI,977
+machineconfig-2.98.dist-info/top_level.txt,sha256=porRtB8qms8fOIUJgK-tO83_FeH6Bpe12oUVC670teA,14
+machineconfig-2.98.dist-info/RECORD,,