machineconfig 2.2__py3-none-any.whl → 2.3__py3-none-any.whl

machineconfig/cluster/sessions_managers/zellij_remote_manager.py

@@ -2,10 +2,11 @@ from datetime import datetime
 import json
 import uuid
 from pathlib import Path
-from typing import Optional
+from typing import Optional, Dict
 from machineconfig.utils.utils5 import Scheduler
 from machineconfig.cluster.sessions_managers.zellij_local import run_command_in_zellij_tab
 from machineconfig.cluster.sessions_managers.zellij_remote import ZellijRemoteLayoutGenerator
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 from machineconfig.logger import get_logger
 
 
@@ -14,13 +15,13 @@ logger = get_logger("cluster.sessions_managers.zellij_remote_manager")
 
 
 class ZellijSessionManager:
-    def __init__(self, machine2zellij_tabs: dict[str, dict[str, tuple[str, str]]], session_name_prefix: str = "JobMgr"):
+    def __init__(self, machine_layouts: Dict[str, LayoutConfig], session_name_prefix: str = "JobMgr"):
         self.session_name_prefix = session_name_prefix
-        self.machine2zellij_tabs = machine2zellij_tabs  # Store the original config
+        self.machine_layouts = machine_layouts  # Store the original config
         self.managers: list[ZellijRemoteLayoutGenerator] = []
-        for machine, tab_config in machine2zellij_tabs.items():
+        for machine, layout_config in machine_layouts.items():
             an_m = ZellijRemoteLayoutGenerator(remote_name=machine, session_name_prefix=self.session_name_prefix)
-            an_m.create_zellij_layout(tab_config=tab_config)
+            an_m.create_zellij_layout(layout_config=layout_config)
             self.managers.append(an_m)
 
     def ssh_to_all_machines(self) -> str:
@@ -93,13 +94,13 @@ class ZellijSessionManager:
         session_dir = TMP_SERIALIAZATION_DIR / session_id
         session_dir.mkdir(parents=True, exist_ok=True)
 
-        # Save the machine2zellij_tabs configuration
-        config_file = session_dir / "machine2zellij_tabs.json"
-        text = json.dumps(self.machine2zellij_tabs, indent=2, ensure_ascii=False)
+        # Save the machine_layouts configuration
+        config_file = session_dir / "machine_layouts.json"
+        text = json.dumps(self.machine_layouts, indent=2, ensure_ascii=False)
         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.machine2zellij_tabs.keys())}
+        metadata = {"session_name_prefix": self.session_name_prefix, "created_at": str(datetime.now()), "num_managers": len(self.managers), "machines": list(self.machine_layouts.keys())}
         metadata_file = session_dir / "metadata.json"
         text = json.dumps(metadata, indent=2, ensure_ascii=False)
         metadata_file.write_text(text, encoding="utf-8")
@@ -120,11 +121,11 @@ class ZellijSessionManager:
 
         if not session_dir.exists():
             raise FileNotFoundError(f"Session directory not found: {session_dir}")
-        config_file = session_dir / "machine2zellij_tabs.json"
+        config_file = session_dir / "machine_layouts.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:
-            machine2zellij_tabs = json.load(f)
+            machine_layouts = json.load(f)
 
         # Load metadata
         metadata_file = session_dir / "metadata.json"
@@ -134,7 +135,7 @@ class ZellijSessionManager:
                 metadata = json.load(f)
                 session_name_prefix = metadata.get("session_name_prefix", "JobMgr")
         # Create new instance (this will create new managers)
-        instance = cls(machine2zellij_tabs=machine2zellij_tabs, session_name_prefix=session_name_prefix)
+        instance = cls(machine_layouts=machine_layouts, session_name_prefix=session_name_prefix)
         # Load saved managers to restore their states
         managers_dir = session_dir / "managers"
         if managers_dir.exists():

machineconfig/cluster/sessions_managers/zellij_utils/example_usage.py

@@ -4,17 +4,21 @@ Example usage of the modularized Zellij remote layout generator.
 """
 
 from machineconfig.cluster.sessions_managers.zellij_remote import ZellijRemoteLayoutGenerator
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
 
 def example_usage():
     """Demonstrate the refactored modular usage."""
 
-    # Sample tab configuration
-    sample_tabs = {
-        "🤖Bot1": ("~/code/bytesense/bithence", "~/scripts/fire -mO go1.py bot1 --kw create_new_bot True"),
-        "🤖Bot2": ("~/code/bytesense/bithence", "~/scripts/fire -mO go2.py bot2 --kw create_new_bot True"),
-        "📊Monitor": ("~", "htop"),
-        "📝Logs": ("/var/log", "tail -f /var/log/app.log"),
+    # Sample layout configuration using new schema
+    sample_layout: LayoutConfig = {
+        "layoutName": "ExampleRemoteSession",
+        "layoutTabs": [
+            {"tabName": "🤖Bot1", "startDir": "~/code/bytesense/bithence", "command": "~/scripts/fire -mO go1.py bot1 --kw create_new_bot True"},
+            {"tabName": "🤖Bot2", "startDir": "~/code/bytesense/bithence", "command": "~/scripts/fire -mO go2.py bot2 --kw create_new_bot True"},
+            {"tabName": "📊Monitor", "startDir": "~", "command": "htop"},
+            {"tabName": "📝Logs", "startDir": "/var/log", "command": "tail -f /var/log/app.log"},
+        ],
     }
 
     # Replace 'myserver' with an actual SSH config alias
@@ -26,11 +30,11 @@ def example_usage():
         generator = ZellijRemoteLayoutGenerator(remote_name=remote_name, session_name_prefix=session_name)
 
         # Create layout file
-        layout_path = generator.create_zellij_layout(sample_tabs)
+        layout_path = generator.create_zellij_layout(sample_layout)
         print(f"✅ Remote layout created successfully: {layout_path}")
 
         # Preview the layout content
-        preview = generator.get_layout_preview(sample_tabs)
+        preview = generator.get_layout_preview(sample_layout)
         print(f"📄 Layout preview:\n{preview}")
 
         # Check status using the modular components
@@ -44,11 +48,11 @@ def example_usage():
         print(f"Remote executor: {generator.remote_executor.remote_name}")
 
         # Use layout generator directly
-        layout_content = generator.layout_generator.generate_layout_content(sample_tabs)
+        layout_content = generator.layout_generator.generate_layout_content(sample_layout)
         print(f"Layout content length: {len(layout_content)} characters")
 
         # Use process monitor directly
-        status = generator.process_monitor.check_all_commands_status(sample_tabs)
+        status = generator.process_monitor.check_all_commands_status(sample_layout)
         print(f"Command status check completed for {len(status)} commands")
 
         print("\n✅ All modular components working correctly!")

machineconfig/cluster/sessions_managers/zellij_utils/layout_generator.py

@@ -6,11 +6,12 @@ Zellij layout generation utilities for creating KDL layout files.
 import shlex
 import random
 import string
-from typing import Dict, List, Tuple
+from typing import List, Tuple
 from pathlib import Path
 import logging
 
 from rich.console import Console
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
 logger = logging.getLogger(__name__)
 console = Console()
@@ -77,36 +78,51 @@ class LayoutGenerator:
         return tab_section
 
     @staticmethod
-    def validate_tab_config(tab_config: Dict[str, Tuple[str, str]]) -> None:
-        """Validate tab configuration format and content."""
-        if not tab_config:
-            raise ValueError("Tab configuration cannot be empty")
-        for tab_name, (cwd, command) in tab_config.items():
+    def validate_tab_config(layout_config: LayoutConfig) -> None:
+        """Validate layout configuration format and content."""
+        if not layout_config:
+            raise ValueError("Layout configuration cannot be empty")
+
+        if not layout_config.get("layoutName", "").strip():
+            raise ValueError("Layout name cannot be empty")
+
+        layout_tabs = layout_config.get("layoutTabs", [])
+        if not layout_tabs:
+            raise ValueError("Layout must have at least one tab")
+
+        for tab in layout_tabs:
+            tab_name = tab.get("tabName", "")
+            command = tab.get("command", "")
+            start_dir = tab.get("startDir", "")
+
             if not tab_name.strip():
                 raise ValueError(f"Invalid tab name: {tab_name}")
             if not command.strip():
                 raise ValueError(f"Invalid command for tab '{tab_name}': {command}")
-            if not cwd.strip():
-                raise ValueError(f"Invalid cwd for tab '{tab_name}': {cwd}")
+            if not start_dir.strip():
+                raise ValueError(f"Invalid startDir for tab '{tab_name}': {start_dir}")
 
-    def generate_layout_content(self, tab_config: Dict[str, Tuple[str, str]]) -> str:
+    def generate_layout_content(self, layout_config: LayoutConfig) -> str:
         """Generate complete KDL layout content."""
-        self.validate_tab_config(tab_config)
+        self.validate_tab_config(layout_config)
 
         layout_content = self.LAYOUT_TEMPLATE
-        for tab_name, (cwd, command) in tab_config.items():
-            layout_content += "\n" + self.create_tab_section(tab_name, cwd, command)
+        for tab in layout_config["layoutTabs"]:
+            tab_name = tab["tabName"]
+            start_dir = tab["startDir"]
+            command = tab["command"]
+            layout_content += "\n" + self.create_tab_section(tab_name, start_dir, command)
         layout_content += "\n}\n"
 
         return layout_content
 
-    def create_layout_file(self, tab_config: Dict[str, Tuple[str, str]], output_dir: Path, session_name: str) -> str:
+    def create_layout_file(self, layout_config: LayoutConfig, output_dir: Path, session_name: str) -> str:
         """Create a layout file and return its absolute path."""
-        self.validate_tab_config(tab_config)
+        self.validate_tab_config(layout_config)
 
         # Generate unique suffix for this layout
         random_suffix = self.generate_random_suffix()
-        layout_content = self.generate_layout_content(tab_config)
+        layout_content = self.generate_layout_content(layout_config)
 
         try:
             # Create output directory if it doesn't exist

machineconfig/cluster/sessions_managers/zellij_utils/process_monitor.py

@@ -6,8 +6,9 @@ Process monitoring and status checking utilities for remote commands.
 import json
 import shlex
 import logging
-from typing import Dict, Tuple, Any
-from .remote_executor import RemoteExecutor
+from typing import Dict, Any
+from machineconfig.cluster.sessions_managers.zellij_utils.remote_executor import RemoteExecutor
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
 logger = logging.getLogger(__name__)
 
@@ -18,20 +19,37 @@ class ProcessMonitor:
     def __init__(self, remote_executor: RemoteExecutor):
         self.remote_executor = remote_executor
 
-    def check_command_status(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]], use_verification: bool = True) -> Dict[str, Any]:
+    def check_command_status(self, tab_name: str, layout_config: LayoutConfig, use_verification: bool = True) -> Dict[str, Any]:
         """Check command status with optional process verification."""
-        if tab_name not in tab_config:
-            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in tracked configuration", "running": False, "pid": None, "command": None, "remote": self.remote_executor.remote_name}
+        # Find the tab with the given name
+        tab_config = None
+        for tab in layout_config["layoutTabs"]:
+            if tab["tabName"] == tab_name:
+                tab_config = tab
+                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, "remote": self.remote_executor.remote_name}
 
         # Use the verified method by default for more accurate results
         if use_verification:
-            return self.get_verified_process_status(tab_name, tab_config)
+            return self.get_verified_process_status(tab_name, layout_config)
 
-        return self._basic_process_check(tab_name, tab_config)
+        return self._basic_process_check(tab_name, layout_config)
 
-    def _basic_process_check(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def _basic_process_check(self, tab_name: str, layout_config: LayoutConfig) -> Dict[str, Any]:
         """Basic process checking without verification."""
-        _, command = tab_config[tab_name]
+        # Find the tab with the given name
+        tab_config = None
+        for tab in layout_config["layoutTabs"]:
+            if tab["tabName"] == tab_name:
+                tab_config = tab
+                break
+
+        if tab_config is None:
+            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in layout config", "running": False, "command": None, "remote": self.remote_executor.remote_name}
+
+        command = tab_config["command"]
 
         try:
             check_script = self._create_process_check_script(command)
@@ -106,12 +124,19 @@ if __name__ == "__main__":
     print(json.dumps(processes))
 """
 
-    def force_fresh_process_check(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def force_fresh_process_check(self, tab_name: str, layout_config: LayoutConfig) -> Dict[str, Any]:
         """Force a fresh process check with additional validation."""
-        if tab_name not in tab_config:
-            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in tracked configuration", "running": False, "command": None, "remote": self.remote_executor.remote_name}
+        # Find the tab with the given name
+        tab_config = None
+        for tab in layout_config["layoutTabs"]:
+            if tab["tabName"] == tab_name:
+                tab_config = tab
+                break
+
+        if tab_config is None:
+            return {"status": "unknown", "error": f"Tab '{tab_name}' not found in layout config", "running": False, "command": None, "remote": self.remote_executor.remote_name}
 
-        _, command = tab_config[tab_name]
+        command = tab_config["command"]
 
         try:
             # Get timestamp for freshness validation
@@ -230,9 +255,9 @@ if __name__ == "__main__":
         except Exception:
             return False
 
-    def get_verified_process_status(self, tab_name: str, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def get_verified_process_status(self, tab_name: str, layout_config: LayoutConfig) -> Dict[str, Any]:
         """Get process status with additional verification that processes are actually alive."""
-        status = self.force_fresh_process_check(tab_name, tab_config)
+        status = self.force_fresh_process_check(tab_name, layout_config)
 
         if status.get("running") and status.get("processes"):
             verified_processes = []
@@ -252,13 +277,14 @@ if __name__ == "__main__":
 
         return status
 
-    def check_all_commands_status(self, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Dict[str, Any]]:
-        """Check status of all commands in the tab configuration."""
-        if not tab_config:
-            logger.warning("No tab configuration provided.")
+    def check_all_commands_status(self, layout_config: LayoutConfig) -> Dict[str, Dict[str, Any]]:
+        """Check status of all commands in the layout configuration."""
+        if not layout_config or not layout_config.get("layoutTabs"):
+            logger.warning("No layout configuration provided.")
             return {}
 
         status_report = {}
-        for tab_name in tab_config:
-            status_report[tab_name] = self.check_command_status(tab_name, tab_config)
+        for tab in layout_config["layoutTabs"]:
+            tab_name = tab["tabName"]
+            status_report[tab_name] = self.check_command_status(tab_name, layout_config)
         return status_report

machineconfig/cluster/sessions_managers/zellij_utils/session_manager.py

@@ -9,7 +9,7 @@ from pathlib import Path
 
 from rich.console import Console
 
-from .remote_executor import RemoteExecutor
+from machineconfig.cluster.sessions_managers.zellij_utils.remote_executor import RemoteExecutor
 
 logger = logging.getLogger(__name__)
 console = Console()

machineconfig/cluster/sessions_managers/zellij_utils/status_reporter.py

@@ -4,9 +4,10 @@ Status reporting utilities for Zellij remote layouts.
 """
 
 import logging
-from typing import Dict, Any, Tuple
-from .process_monitor import ProcessMonitor
-from .session_manager import SessionManager
+from typing import Dict, Any
+from machineconfig.cluster.sessions_managers.zellij_utils.process_monitor import ProcessMonitor
+from machineconfig.cluster.sessions_managers.zellij_utils.session_manager import SessionManager
+from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
 logger = logging.getLogger(__name__)
 
@@ -18,10 +19,10 @@ class StatusReporter:
         self.process_monitor = process_monitor
         self.session_manager = session_manager
 
-    def get_comprehensive_status(self, tab_config: Dict[str, Tuple[str, str]]) -> Dict[str, Any]:
+    def get_comprehensive_status(self, layout_config: LayoutConfig) -> Dict[str, Any]:
         """Get comprehensive status including Zellij session and all commands."""
         zellij_status = self.session_manager.check_zellij_session_status()
-        commands_status = self.process_monitor.check_all_commands_status(tab_config)
+        commands_status = self.process_monitor.check_all_commands_status(layout_config)
 
         running_count = sum(1 for status in commands_status.values() if status.get("running", False))
         total_count = len(commands_status)
@@ -38,9 +39,9 @@ class StatusReporter:
             },
         }
 
-    def print_status_report(self, tab_config: Dict[str, Tuple[str, str]]) -> None:
+    def print_status_report(self, layout_config: LayoutConfig) -> None:
         """Print a formatted status report to console."""
-        status = self.get_comprehensive_status(tab_config)
+        status = self.get_comprehensive_status(layout_config)
         remote_name = self.session_manager.remote_executor.remote_name
         session_name = self.session_manager.session_name
 

machineconfig/cluster/templates/utils.py

@@ -1,7 +1,7 @@
-
 from typing import Optional
 from machineconfig.utils.path_reduced import PathExtended, PLike
 
+
 def to_cloud(
     localpath: PLike,
     cloud: str,

machineconfig/profile/create.py

@@ -24,9 +24,12 @@ ERROR_LIST: list[Any] = []  # append to this after every exception captured.
 
 SYSTEM = system.lower()
 
+
 def get_other_systems(current_system: str) -> list[str]:
     all_systems = ["linux", "windows", "darwin"]
     return [s for s in all_systems if s != current_system.lower()]
+
+
 OTHER_SYSTEMS = get_other_systems(SYSTEM)
 
 
@@ -59,6 +62,7 @@ def main_symlinks(choice: Optional[str] = None):
             choice_selected = "all"  # i.e. program_keys = program_keys
         # overwrite = display_options(msg="Overwrite existing source file?", options=["yes", "no"], default="yes") == "yes"
         from rich.prompt import Confirm
+
         overwrite = Confirm.ask("Overwrite existing source file?", default=True)
     else:
         choice_selected = choice

machineconfig/scripts/python/devops.py

@@ -74,6 +74,7 @@ def display_task_success(success: str) -> None:
 
 def main(which: Optional[str] = None):
     from machineconfig.utils.path_reduced import PathExtended
+
     PathExtended(PROGRAM_PATH).delete(sure=True, verbose=False)
     console.print(Panel("🚀 Initializing DevOps operation...", width=BOX_WIDTH, border_style="blue"))
 

machineconfig/scripts/python/devops_devapps_install.py

@@ -39,6 +39,7 @@ def main(which: Optional[WHICH_CAT | str] = None):
     # interactive installation
     installers = [Installer.from_dict(d=vd, name=name) for __kat, vds in get_all_dicts(system=system()).items() for name, vd in vds.items()]
     options = [x.get_description() for x in tqdm(installers, desc="✅ Checking installed programs")] + list(get_args(WHICH_CAT))
+    # print("s"*1000)
     program_names = choose_multiple_options(msg="", options=options, header="🚀 CHOOSE DEV APP", default="AllEssentials")
 
     total_program = ""

machineconfig/scripts/python/fire_agents.py

@@ -15,6 +15,7 @@ from math import ceil
 from typing import Literal, TypeAlias, get_args, Iterable
 
 from machineconfig.cluster.sessions_managers.zellij_local_manager import ZellijLocalManager
+from machineconfig.cluster.sessions_managers.layout_types import TabConfig, LayoutConfig
 from machineconfig.utils.utils2 import randstr
 import random
 # import time
@@ -23,7 +24,6 @@ AGENTS: TypeAlias = Literal[
     "cursor-agent", "gemini", "crush", "q", "onlyPrepPromptFiles"
     # warp terminal
 ]
-TabConfig = dict[str, tuple[str, str]]  # tab name -> (cwd, command)
 DEFAULT_AGENT_CAP = 6
 
 
@@ -93,7 +93,7 @@ def _confirm(message: str, default_no: bool = True) -> bool:
     return False
 
 
-def launch_agents(repo_root: Path, prompts: list[str], agent: AGENTS, *, max_agents: int = DEFAULT_AGENT_CAP) -> TabConfig:
+def launch_agents(repo_root: Path, prompts: list[str], agent: AGENTS, *, max_agents: int = DEFAULT_AGENT_CAP) -> list[TabConfig]:
     """Create tab configuration for a set of agent prompts.
 
     If number of prompts exceeds max_agents, ask user for confirmation.
@@ -106,9 +106,9 @@ def launch_agents(repo_root: Path, prompts: list[str], agent: AGENTS, *, max_age
         proceed = _confirm(message=(f"You are about to launch {len(prompts)} agents which exceeds the cap ({max_agents}). Proceed?"))
         if not proceed:
             print("Aborting per user choice.")
-            return {}
+            return []
 
-    tab_config: TabConfig = {}
+    tab_config: list[TabConfig] = []
     tmp_dir = repo_root / ".ai" / f"tmp_prompts/{randstr()}"
     tmp_dir.mkdir(parents=True, exist_ok=True)
 
@@ -173,7 +173,7 @@ echo "---------END OF AGENT OUTPUT---------"
 """
         cmd_path.write_text(cmd_prefix + cmd + cmd_postfix, encoding="utf-8")
         fire_cmd = f"bash {shlex.quote(str(cmd_path))}"
-        tab_config[f"Agent{idx}"] = (str(repo_root), fire_cmd)
+        tab_config.append(TabConfig(tabName=f"Agent{idx}", startDir=str(repo_root), command=fire_cmd))
 
     print(f"Launching a template with #{len(tab_config)} agents")
     return tab_config
@@ -228,7 +228,7 @@ def main():  # noqa: C901 - (complexity acceptable for CLI glue)
     from machineconfig.utils.utils2 import randstr
 
     random_name = randstr(length=3)
-    manager = ZellijLocalManager(session2zellij_tabs={"Agents": tab_config}, session_name_prefix=random_name)
+    manager = ZellijLocalManager(session_layouts=[LayoutConfig(layoutName="Agents", layoutTabs=tab_config)], session_name_prefix=random_name)
     manager.start_all_sessions()
     manager.run_monitoring_routine()
 

machineconfig/scripts/python/fire_jobs.py

@@ -18,52 +18,23 @@ from machineconfig.utils.source_of_truth import PROGRAM_PATH
 from machineconfig.utils.path_reduced import PathExtended as PathExtended
 from machineconfig.utils.io_save import save_toml
 from machineconfig.utils.utils2 import randstr, read_toml
+from machineconfig.scripts.python.fire_jobs_args_helper import get_args, FireJobArgs, extract_kwargs
 import platform
 from typing import Optional
-import argparse
 import os
 
 
-str2obj = {"True": True, "False": False, "None": None}
+def main(args: FireJobArgs) -> None:
+    if args.layout:
+        from machineconfig.scripts.python.fire_jobs_layout_helper import handle_layout_args
 
+        return handle_layout_args(args)
 
-def main() -> None:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("path", nargs="?", type=str, help="The directory containing the jobs", default=".")
-    parser.add_argument("function", nargs="?", type=str, help="Fuction to run", default=None)
-    parser.add_argument("--ve", "-v", type=str, help="virtual enviroment name", default="")
-    parser.add_argument("--cmd", "-B", action="store_true", help="Create a cmd fire command to launch the the job asynchronously.")
-    parser.add_argument("--interactive", "-i", action="store_true", help="Whether to run the job interactively using IPython")
-    parser.add_argument("--debug", "-d", action="store_true", help="debug")
-    parser.add_argument("--choose_function", "-c", action="store_true", help="debug")
-    parser.add_argument("--loop", "-l", action="store_true", help="infinite recusion (runs again after completion/interruption)")
-    parser.add_argument("--jupyter", "-j", action="store_true", help="open in a jupyter notebook")
-    parser.add_argument("--submit_to_cloud", "-C", action="store_true", help="submit to cloud compute")
-    parser.add_argument("--remote", "-r", action="store_true", help="launch on a remote machine")
-    parser.add_argument("--module", "-m", action="store_true", help="launch the main file")
-    parser.add_argument("--streamlit", "-S", action="store_true", help="run as streamlit app")
-    parser.add_argument("--environment", "-E", type=str, help="Choose ip, localhost, hostname or arbitrary url", default="")
-    parser.add_argument("--holdDirectory", "-D", action="store_true", help="hold current directory and avoid cd'ing to the script directory")
-    parser.add_argument("--PathExport", "-P", action="store_true", help="augment the PYTHONPATH with repo root.")
-    parser.add_argument("--git_pull", "-g", action="store_true", help="Start by pulling the git repo")
-    parser.add_argument("--optimized", "-O", action="store_true", help="Run the optimized version of the function")
-    parser.add_argument("--Nprocess", "-p", type=int, help="Number of processes to use", default=1)
-    parser.add_argument("--zellij_tab", "-z", type=str, dest="zellij_tab", help="open in a new zellij tab")
-    parser.add_argument("--watch", "-w", action="store_true", help="watch the file for changes")
-    parser.add_argument("--kw", nargs="*", default=None, help="keyword arguments to pass to the function in the form of k1 v1 k2 v2 ... (meaning k1=v1, k2=v2, etc)")
-    try:
-        args = parser.parse_args()
-    except Exception as ex:
-        print(f"❌ Failed to parse arguments: {ex}")
-        parser.print_help()
-        raise ex
     path_obj = sanitize_path(args.path)
-    # print(f"Passed path sanitied to {path_obj}")
     if not path_obj.exists():
-        path_obj = match_file_name(sub_string=args.path, search_root=PathExtended.cwd())
-    else:
-        pass
-    if path_obj.is_dir():
+        suffixes = {".py", ".sh", ".ps1"}
+        choice_file = match_file_name(sub_string=args.path, search_root=PathExtended.cwd(), suffixes=suffixes)
+    elif path_obj.is_dir():
         print(f"🔍 Searching recursively for Python, PowerShell and Shell scripts in directory `{path_obj}`")
         files = search_for_files_of_interest(path_obj)
         print(f"🔍 Got #{len(files)} results.")
@@ -73,24 +44,13 @@ def main() -> None:
         choice_file = path_obj
     repo_root = get_repo_root(str(choice_file))
     print(f"💾 Selected file: {choice_file}.\nRepo root: {repo_root}")
-
     ve_root_from_file, ipy_profile = get_ve_path_and_ipython_profile(choice_file)
     if ipy_profile is None:
         ipy_profile = "default"
     activate_ve_line = get_ve_activate_line(ve_root=args.ve or ve_root_from_file or "$HOME/code/machineconfig/.venv")
 
-    # Convert args.kw to dictionary
     if choice_file.suffix == ".py":
-        if args.kw is not None:
-            assert len(args.kw) % 2 == 0, f"args.kw must be a list of even length. Got {len(args.kw)}"
-            kwargs = dict(zip(args.kw[::2], args.kw[1::2]))
-            for key, value in kwargs.items():
-                if value in str2obj:
-                    kwargs[key] = str2obj[value]
-            if args.function is None:  # if user passed arguments and forgot to pass function, then assume they want to run the main function.
-                args.choose_function = True
-        else:
-            kwargs = {}
+        kwargs = extract_kwargs(args)
     else:
         kwargs = {}
 
@@ -296,22 +256,13 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
             command += f"--function {choice_function} "
 
     if args.Nprocess > 1:
-        # lines = [f""" zellij action new-tab --name nProcess{randstr(2)}"""]
-        # command = command.replace(". activate_ve", ". $HOME/scripts/activate_ve")
-        # for an_arg in range(args.Nprocess):
-        #     sub_command = f"{command} --idx={an_arg} --idx_max={args.Nprocess}"
-        #     if args.optimized:
-        #         sub_command = sub_command.replace("python ", "python -OO ")
-        #     sub_command_path = PathExtended.tmpfile(suffix=".sh").write_text(sub_command, encoding="utf-8")
-        #     lines.append(f"""zellij action new-pane -- bash {sub_command_path}  """)
-        #     lines.append("sleep 5")  # python tends to freeze if you launch instances within 1 microsecond of each other
-        # command = "\n".join(lines)
-        tab_config = {}
-        for an_arg in range(args.Nprocess):
-            tab_config[f"tab{an_arg}"] = (str(PathExtended.cwd()), f"uv run -m fire {choice_file} {choice_function} --idx={an_arg} --idx_max={args.Nprocess}")
         from machineconfig.cluster.sessions_managers.zellij_local import run_zellij_layout
+        from machineconfig.cluster.sessions_managers.layout_types import LayoutConfig
 
-        run_zellij_layout(tab_config=tab_config, session_name=None)
+        layout: LayoutConfig = {"layoutName": "fireNprocess", "layoutTabs": []}
+        for an_arg in range(args.Nprocess):
+            layout["layoutTabs"].append({"tabName": f"tab{an_arg}", "startDir": str(PathExtended.cwd()), "command": f"uv run -m fire {choice_file} {choice_function} --idx={an_arg} --idx_max={args.Nprocess}"})
+        run_zellij_layout(layout_config=layout)
         return None
 
     if args.optimized:
@@ -375,4 +326,5 @@ python -m machineconfig.cluster.templates.cli_click --file {choice_file} """
 
 if __name__ == "__main__":
     # options, func_args = parse_pyfile(file_path="C:/Users/aalsaf01/code/machineconfig/myresources/crocodile/core.py")
-    main()
+    args = get_args()
+    main(args)