machineconfig 4.92__tar.gz → 4.94__tar.gz

{machineconfig-4.92/src/machineconfig.egg-info → machineconfig-4.94}/PKG-INFO

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

{machineconfig-4.92 → machineconfig-4.94}/pyproject.toml

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

{machineconfig-4.92 → machineconfig-4.94}/src/machineconfig/cluster/sessions_managers/wt_local.py

@@ -9,16 +9,21 @@ import subprocess
 import random
 import string
 import json
+import platform
 from typing import Dict, List, Optional, Any
 from pathlib import Path
 import logging
 
-from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig, TabConfig
+from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 TMP_LAYOUT_DIR = Path.home().joinpath("tmp_results", "session_manager", "wt", "layout_manager")
 
+# Check if we're on Windows
+IS_WINDOWS = platform.system().lower() == "windows"
+POWERSHELL_CMD = "powershell" if IS_WINDOWS else "pwsh"  # Use pwsh on non-Windows systems
+
 
 class WTLayoutGenerator:
     def __init__(self):
@@ -52,35 +57,7 @@ class WTLayoutGenerator:
             return f'"{text}"'
         return text
 
-    @staticmethod
-    def _create_tab_command(tab_config: TabConfig, is_first_tab: bool) -> str:
-        """Create a Windows Terminal tab command string from tab config."""
-        tab_name = tab_config["tabName"]
-        cwd = tab_config["startDir"]
-        command = tab_config["command"]
-
-        # Convert paths to Windows format if needed
-        if cwd.startswith("~/"):
-            cwd = cwd.replace("~/", f"{Path.home()}/")
-        elif cwd == "~":
-            cwd = str(Path.home())
-
-        # Build the wt command parts
-        tab_parts = []
-
-        if not is_first_tab:
-            tab_parts.append("new-tab")
-
-        # Add starting directory
-        tab_parts.extend(["-d", WTLayoutGenerator._escape_for_wt(cwd)])
-
-        # Add tab title
-        tab_parts.extend(["--title", WTLayoutGenerator._escape_for_wt(tab_name)])
 
-        # Add the command to execute
-        tab_parts.append(WTLayoutGenerator._escape_for_wt(command))
-
-        return " ".join(tab_parts)
 
     @staticmethod
     def _validate_layout_config(layout_config: LayoutConfig) -> None:
@@ -133,31 +110,39 @@ class WTLayoutGenerator:
 
     def _generate_wt_command_string(self, layout_config: LayoutConfig, window_name: str) -> str:
         """Generate complete Windows Terminal command string."""
-        # Start building the wt command
-        wt_parts = ["wt"]
-
-        # Add window name
-        wt_parts.extend(["-w", WTLayoutGenerator._escape_for_wt(window_name)])
-
-        # Add tabs
-        tab_commands = []
+        # Build the complete Windows Terminal command
+        command_parts = []
+        
         for i, tab in enumerate(layout_config["layoutTabs"]):
             is_first = i == 0
-            tab_cmd = self._create_tab_command(tab, is_first)
-            tab_commands.append(tab_cmd)
-
-        # Join all parts with semicolons (Windows Terminal command separator)
-        if tab_commands:
-            if len(tab_commands) == 1:
-                # Single tab - just add to the main command
-                wt_parts.extend(tab_commands[0].split())
+            
+            if is_first:
+                # First tab: start with wt command and window name
+                tab_parts = ["wt", "-w", WTLayoutGenerator._escape_for_wt(window_name)]
             else:
-                # Multiple tabs - join with semicolons
-                wt_parts.append(tab_commands[0])  # First tab
-                for tab_cmd in tab_commands[1:]:
-                    wt_parts.extend([";", tab_cmd])
-
-        return " ".join(wt_parts)
+                # Subsequent tabs: use new-tab
+                tab_parts = ["new-tab"]
+            
+            # Add common tab arguments
+            tab_name = tab["tabName"]
+            cwd = tab["startDir"]
+            command = tab["command"]
+            
+            # Convert paths to Windows format if needed
+            if cwd.startswith("~/"):
+                cwd = cwd.replace("~/", f"{Path.home()}/")
+            elif cwd == "~":
+                cwd = str(Path.home())
+            
+            # Add arguments in the correct order
+            tab_parts.extend(["-d", WTLayoutGenerator._escape_for_wt(cwd)])
+            tab_parts.extend(["--title", WTLayoutGenerator._escape_for_wt(tab_name)])
+            tab_parts.append(WTLayoutGenerator._escape_for_wt(command))
+            
+            command_parts.append(" ".join(tab_parts))
+        
+        # Join all tab commands with escaped semicolons for PowerShell
+        return " `; ".join(command_parts)
 
     def get_wt_layout_preview(self, layout_config: LayoutConfig) -> str:
         """Generate preview of the Windows Terminal command that would be created."""
@@ -179,29 +164,45 @@ class WTLayoutGenerator:
     @staticmethod
     def check_wt_session_status(session_name: str) -> Dict[str, Any]:
         try:
-            # Check for Windows Terminal processes
-            wt_check_cmd = ["powershell", "-Command", "Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue | Select-Object Id, ProcessName, StartTime, MainWindowTitle | ConvertTo-Json -Depth 2"]
+            # Simplified Windows Terminal process check
+            ps_script = """
+try {
+    $wtProcesses = Get-Process -Name 'WindowsTerminal' -ErrorAction SilentlyContinue
+    if ($wtProcesses) {
+        $processInfo = @()
+        $wtProcesses | ForEach-Object {
+            $info = @{
+                "Id" = $_.Id
+                "ProcessName" = $_.ProcessName
+                "StartTime" = $_.StartTime.ToString()
+            }
+            $processInfo += $info
+        }
+        $processInfo | ConvertTo-Json -Depth 2
+    }
+} catch {
+    # No Windows Terminal processes found
+}
+"""
 
-            result = subprocess.run(wt_check_cmd, capture_output=True, text=True, timeout=10)
+            result = subprocess.run([POWERSHELL_CMD, "-Command", ps_script], capture_output=True, text=True, timeout=5)
 
             if result.returncode == 0:
                 output = result.stdout.strip()
                 if output and output != "":
                     try:
-                        import json
-
                         processes = json.loads(output)
                         if not isinstance(processes, list):
                             processes = [processes]
 
-                        # Look for windows that might belong to our session
-                        session_windows = []
-                        for proc in processes:
-                            window_title = proc.get("MainWindowTitle", "")
-                            if session_name in window_title or not window_title:
-                                session_windows.append(proc)
-
-                        return {"wt_running": True, "session_exists": len(session_windows) > 0, "session_name": session_name, "all_windows": processes, "session_windows": session_windows}
+                        # For simplicity, assume session exists if WT is running
+                        return {
+                            "wt_running": True, 
+                            "session_exists": len(processes) > 0, 
+                            "session_name": session_name, 
+                            "all_windows": processes, 
+                            "session_windows": processes  # Simplified - assume all windows could be session windows
+                        }
                     except Exception as e:
                         return {"wt_running": True, "session_exists": False, "error": f"Failed to parse process info: {e}", "session_name": session_name}
                 else:
@@ -212,7 +213,7 @@ class WTLayoutGenerator:
         except subprocess.TimeoutExpired:
             return {"wt_running": False, "error": "Timeout while checking Windows Terminal processes", "session_name": session_name}
         except FileNotFoundError:
-            return {"wt_running": False, "error": "PowerShell not found in PATH", "session_name": session_name}
+            return {"wt_running": False, "error": f"PowerShell ({POWERSHELL_CMD}) not found in PATH", "session_name": session_name}
         except Exception as e:
             return {"wt_running": False, "error": str(e), "session_name": session_name}
 
@@ -232,55 +233,31 @@ class WTLayoutGenerator:
         command = tab_config["command"]
 
         try:
-            # Create PowerShell script to check for processes
-            cmd_parts = [part for part in command.split() if len(part) > 2]
-            primary_cmd = cmd_parts[0] if cmd_parts else ""
+            # Extract the primary executable name from command
+            primary_cmd = command.split()[0] if command.strip() else ""
+            if not primary_cmd:
+                return {"status": "error", "error": "Empty command", "running": False, "command": command, "tab_name": tab_name}
 
+            # Use a much simpler PowerShell script that just checks for process names
             ps_script = f"""
-$targetCommand = '{command.replace("'", "''")}'
-$cmdParts = @({", ".join([f"'{part}'" for part in cmd_parts])})
-$primaryCmd = '{primary_cmd}'
-$currentPid = $PID
-$matchingProcesses = @()
-
-Get-Process | ForEach-Object {{
-    try {{
-        if ($_.Id -eq $currentPid) {{ return }}
-
-        $cmdline = ""
-        try {{
-            $cmdline = (Get-WmiObject Win32_Process -Filter "ProcessId = $($_.Id)").CommandLine
-        }} catch {{
-            $cmdline = $_.ProcessName
-        }}
-
-        if ($cmdline -and $cmdline -ne "") {{
-            if ($cmdline -like "*PowerShell*" -and $cmdline -like "*Get-Process*") {{ return }}
-
-            $matchesPrimary = $cmdline -like "*$primaryCmd*" -and $primaryCmd -ne "powershell"
-            $matchCount = 0
-            foreach ($part in $cmdParts[1..($cmdParts.Length-1)]) {{
-                if ($cmdline -like "*$part*") {{ $matchCount++ }}
-            }}
-
-            if ($matchesPrimary -and $matchCount -ge 1) {{
-                $procInfo = @{{
-                    "pid" = $_.Id
-                    "name" = $_.ProcessName
-                    "cmdline" = $cmdline
-                    "status" = $_.Status
-                    "start_time" = $_.StartTime
-                }} | ConvertTo-Json -Compress
-                Write-Output $procInfo
+try {{
+    $processes = Get-Process -Name '{primary_cmd}' -ErrorAction SilentlyContinue
+    if ($processes) {{
+        $processes | ForEach-Object {{
+            $procInfo = @{{
+                "pid" = $_.Id
+                "name" = $_.ProcessName
+                "start_time" = $_.StartTime.ToString()
             }}
+            Write-Output ($procInfo | ConvertTo-Json -Compress)
         }}
-    }} catch {{
-        # Ignore processes we can't access
     }}
+}} catch {{
+    # No processes found or other error
 }}
 """
 
-            result = subprocess.run(["powershell", "-Command", ps_script], capture_output=True, text=True, timeout=15)
+            result = subprocess.run([POWERSHELL_CMD, "-Command", ps_script], capture_output=True, text=True, timeout=5)
 
             if result.returncode == 0:
                 output_lines = [line.strip() for line in result.stdout.strip().split("\n") if line.strip()]
@@ -301,6 +278,9 @@ Get-Process | ForEach-Object {{
             else:
                 return {"status": "error", "error": f"Command failed: {result.stderr}", "running": False, "command": command, "tab_name": tab_name}
 
+        except subprocess.TimeoutExpired:
+            logger.error(f"Timeout checking command status for tab '{tab_name}'")
+            return {"status": "timeout", "error": "Timeout checking process status", "running": False, "command": command, "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, "tab_name": tab_name}
@@ -400,29 +380,22 @@ wt new-tab --title "{tab_name}" {cwd_part} "{command}"
 
 
 if __name__ == "__main__":
-    # Example usage with new schema
-    sample_layout: LayoutConfig = {"layoutName": "TestLayout", "layoutTabs": [{"tabName": "Frontend", "startDir": "~/code", "command": "btm"}, {"tabName": "Monitor", "startDir": "~", "command": "lf"}]}
-
+    sample_layout: LayoutConfig = {"layoutName": "TestLayout",
+                                   "layoutTabs": [
+            {"tabName": "Frontend", "startDir": "~/code", "command": "btm"},
+            {"tabName": "Monitor", "startDir": "~", "command": "lf"}
+            ]}
     try:
-        # Create layout using the generator
         generator = WTLayoutGenerator()
-        script_path = generator.create_wt_layout(sample_layout, None)
+        script_path = generator.create_wt_layout(layout_config=sample_layout, output_dir=None)
         print(f"✅ Windows Terminal layout created: {script_path}")
-
-        # Show preview
-        preview = generator.get_wt_layout_preview(sample_layout)
-        print(f"\n📋 Command Preview:\n{preview}")
-
-        # Check status (won't find anything since we haven't run it)
-        print("\n🔍 Current status:")
+        preview = generator.get_wt_layout_preview(layout_config=sample_layout)
+        print(f"📋 Command Preview:\n{preview}")
+        print("🔍 Current status:")
         generator.print_status_report()
-
-        # Show how to run the layout
-        print("\n▶️  To run this layout, execute:")
+        print("▶️  To run this layout, execute:")
         print(f'   powershell -ExecutionPolicy Bypass -File "{script_path}"')
-
     except Exception as e:
         print(f"❌ Error: {e}")
         import traceback
-
         traceback.print_exc()

{machineconfig-4.92 → machineconfig-4.94}/src/machineconfig/scripts/python/devops_devapps_install.py

@@ -5,7 +5,6 @@ import typer
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
-from platform import system
 from typing import Optional, cast, get_args
 from machineconfig.jobs.installer.package_groups import PACKAGE_GROUPS
 
@@ -45,15 +44,12 @@ def _handle_installer_not_found(search_term: str, all_installers: list["Installe
         if len(all_installers) > 10:
             console.print(f"   [dim]... and {len(all_installers) - 10} more[/dim]")
 
-    panel = Panel(
-        f"[bold blue]💡 Use 'ia' to interactively browse all available installers.[/bold blue]\n[bold blue]💡 Use one of the categories: {list(get_args(PACKAGE_GROUPS))}[/bold blue]", title="[yellow]Helpful Tips[/yellow]", border_style="yellow"
-    )
+    panel = Panel(f"[bold blue]💡 Use 'ia' to interactively browse all available installers.[/bold blue]\n[bold blue]💡 Use one of the categories: {list(get_args(PACKAGE_GROUPS))}[/bold blue]", title="[yellow]Helpful Tips[/yellow]", border_style="yellow")
     console.print(panel)
 
 
 def main_with_parser():
     import typer
-
     app = typer.Typer()
     app.command()(main)
     app()
@@ -122,11 +118,12 @@ def get_programs_by_category(package_group: PACKAGE_GROUPS):
         case "DEV_SYSTEM" | "ESSENTIAL_SYSTEM":
             options_system = get_installers_system_groups()
             from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
+            from machineconfig.utils.code import run_script
             for an_item in options_system:
                 if an_item["appName"] == package_group:
                     program = an_item["fileNamePattern"][get_normalized_arch()][get_os_name()]
                     if program is not None:
-                        install_terminal_packages(program)
+                        run_script(program)
 
 
 def choose_from_system_package_groups(options_system: dict[str, tuple[str, str]]) -> str:
@@ -150,33 +147,6 @@ def choose_from_system_package_groups(options_system: dict[str, tuple[str, str]]
     return program
 
 
-def install_terminal_packages(program: str):
-    from pathlib import Path
-
-    if system() == "Windows":
-        temp_script_path = Path("C:/Windows/Temp/temp_install_script.ps1")
-        lexer = "powershell"
-    else:
-        temp_script_path = Path("/tmp/temp_install_script.sh")
-        lexer = "bash"
-    temp_script_path.write_text(program, encoding="utf-8")
-    console.print(f"📝 [blue]Temporary script written to:[/blue] [green]{temp_script_path}[/green]")
-    from rich.syntax import Syntax
-
-    console.print(Panel(Syntax(code=program, lexer=lexer), title="📄 Installation Program", subtitle="shell code"), style="bold red")
-    console.print("🚀 [bold yellow]Starting installation...[/bold yellow]")
-    if system() == "Windows":
-        import subprocess
-
-        subprocess.run(["powershell", "-ExecutionPolicy", "Bypass", "-File", str(temp_script_path)], check=True)
-    elif system() == "Linux":
-        import subprocess
-
-        subprocess.run(["bash", str(temp_script_path)], check=True)
-    console.print("✅ [bold green]Installation completed.[/bold green]")
-    temp_script_path.unlink(missing_ok=True)
-
-
 def install_clis(clis_names: list[str]):
     from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
     from machineconfig.utils.installer import get_installers