machineconfig 2.95__tar.gz → 2.98__tar.gz

{machineconfig-2.95/src/machineconfig.egg-info → machineconfig-2.98}/PKG-INFO

@@ -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 → machineconfig-2.98}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "machineconfig"
-version = "2.95"
+version = "2.98"
 description = "Dotfiles management package"
 readme = "README.md"
 license = {text = "Apache 2.0"}

{machineconfig-2.95 → machineconfig-2.98}/src/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-2.95 → machineconfig-2.98}/src/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-2.98/src/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-2.95 → machineconfig-2.98}/src/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-2.95 → machineconfig-2.98}/src/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.95 → machineconfig-2.98}/src/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-2.95 → machineconfig-2.98}/src/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-2.95 → machineconfig-2.98}/src/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 → machineconfig-2.98/src/machineconfig.egg-info}/PKG-INFO

@@ -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 → machineconfig-2.98}/src/machineconfig.egg-info/SOURCES.txt

@@ -36,6 +36,7 @@ src/machineconfig/cluster/sessions_managers/wt_utils/session_manager.py
 src/machineconfig/cluster/sessions_managers/wt_utils/status_reporter.py
 src/machineconfig/cluster/sessions_managers/zellij_utils/example_usage.py
 src/machineconfig/cluster/sessions_managers/zellij_utils/layout_generator.py
+src/machineconfig/cluster/sessions_managers/zellij_utils/monitoring_types.py
 src/machineconfig/cluster/sessions_managers/zellij_utils/process_monitor.py
 src/machineconfig/cluster/sessions_managers/zellij_utils/remote_executor.py
 src/machineconfig/cluster/sessions_managers/zellij_utils/session_manager.py