machineconfig 2.97__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()
@@ -23,7 +25,8 @@ 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] = []
@@ -43,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:
@@ -59,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:
@@ -109,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
@@ -157,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
@@ -184,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()
 
@@ -297,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")
@@ -419,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
@@ -481,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_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-2.97.dist-info → machineconfig-2.98.dist-info}/METADATA

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

{machineconfig-2.97.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=U9UW6ybeMwPOqYRJafShAKqpXyQyUy1ybwDcNvhpGLg,23463
+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
@@ -173,7 +174,7 @@ machineconfig/scripts/python/devops_devapps_install.py,sha256=xQaOHlr6ziHxrx7e5R
 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=HoT2NjNDB3lmmGjcsvFVf8dTtCAQKBh_DtdhLClL_Bw,8202
-machineconfig/scripts/python/fire_agents_help_launch.py,sha256=70iFF0wmFYKvaPsUy35_bIw5ivn5EdonahjSw1GTMIs,6125
+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
@@ -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.97.dist-info/METADATA,sha256=l_UGz0o_tZJSeBW9AoTg8Ib3dwBvVVmRNTDZzWXJ4Us,7049
-machineconfig-2.97.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-machineconfig-2.97.dist-info/entry_points.txt,sha256=71EzS7_2LTIigVxC1YXNxHXhC9mu5Me2Feyq2KocXBI,977
-machineconfig-2.97.dist-info/top_level.txt,sha256=porRtB8qms8fOIUJgK-tO83_FeH6Bpe12oUVC670teA,14
-machineconfig-2.97.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,,