machineconfig 3.7__py3-none-any.whl → 7.69__py3-none-any.whl

machineconfig/cluster/sessions_managers/zellij_utils/zellij_local_manager_helper.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+import json
+import logging
+import shutil
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+from machineconfig.cluster.sessions_managers.zellij_utils.monitoring_types import ActiveSessionInfo, StartResult
+from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
+
+if TYPE_CHECKING:
+    from machineconfig.cluster.sessions_managers.zellij_local import ZellijLayoutGenerator
+
+
+logger = logging.getLogger(__name__)
+TMP_SERIALIZATION_DIR = Path.home() / "tmp_results" / "zellij_sessions" / "serialized"
+
+
+def list_saved_sessions() -> list[str]:
+    """List all saved session IDs."""
+    if not TMP_SERIALIZATION_DIR.exists():
+        return []
+    sessions = []
+    for item in TMP_SERIALIZATION_DIR.iterdir():
+        if item.is_dir() and (item / "metadata.json").exists():
+            sessions.append(item.name)
+    return sorted(sessions)
+
+
+def delete_session(session_id: str) -> bool:
+    """Delete a saved session."""
+    session_dir = TMP_SERIALIZATION_DIR / session_id
+    if not session_dir.exists():
+        logger.warning(f"Session directory not found: {session_dir}")
+        return False
+    try:
+        shutil.rmtree(session_dir)
+        logger.info(f"✅ Deleted session: {session_id}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to delete session {session_id}: {e}")
+        return False
+
+
+def get_all_session_names(managers: list["ZellijLayoutGenerator"]) -> list[str]:
+    """Get all managed session names."""
+    return [manager.session_name for manager in managers]
+
+
+def attach_to_session(managers: list["ZellijLayoutGenerator"], session_name: Optional[str]) -> str:
+    """
+    Generate command to attach to a specific session or list attachment commands for all.
+
+    Args:
+        managers: List of ZellijLayoutGenerator instances
+        session_name: Specific session to attach to, or None for all sessions
+
+    Returns:
+        Command string to attach to session(s)
+    """
+    if session_name:
+        for manager in managers:
+            if manager.session_name == session_name:
+                return f"zellij attach {session_name}"
+        raise ValueError(f"Session '{session_name}' not found")
+    else:
+        commands: list[str] = []
+        for manager in managers:
+            commands.append(f"# Attach to session '{manager.session_name}':")
+            commands.append(f"zellij attach {manager.session_name}")
+            commands.append("")
+        return "\n".join(commands)
+
+
+def list_active_sessions(managers: list["ZellijLayoutGenerator"]) -> list[ActiveSessionInfo]:
+    """List currently active zellij sessions managed by this instance."""
+    active_sessions: list[ActiveSessionInfo] = []
+    try:
+        result = subprocess.run(["zellij", "list-sessions"], capture_output=True, text=True, timeout=10)
+        if result.returncode == 0:
+            all_sessions = result.stdout.strip().split("\n") if result.stdout.strip() else []
+            for manager in managers:
+                session_name = manager.session_name
+                is_active = any(session_name in session for session in all_sessions)
+                tab_info = []
+                tab_count = 0
+                if manager.layout_config:
+                    tab_count = len(manager.layout_config["layoutTabs"])
+                    tab_info = [tab["tabName"] for tab in manager.layout_config["layoutTabs"]]
+                active_sessions.append({"session_name": session_name, "is_active": is_active, "tab_count": tab_count, "tabs": tab_info})
+    except Exception as e:
+        logger.error(f"Error listing active sessions: {e}")
+    return active_sessions
+
+
+def save_manager(session_layouts: list[LayoutConfig], managers: list["ZellijLayoutGenerator"], session_name_prefix: str, session_id: Optional[str]) -> str:
+    """Save the manager state to disk."""
+    if session_id is None:
+        import uuid
+        session_id = str(uuid.uuid4())[:8]
+    session_dir = TMP_SERIALIZATION_DIR / session_id
+    session_dir.mkdir(parents=True, exist_ok=True)
+    config_file = session_dir / "session_layouts.json"
+    text = json.dumps(session_layouts, indent=2, ensure_ascii=False)
+    config_file.write_text(text, encoding="utf-8")
+    metadata = {"session_name_prefix": session_name_prefix, "created_at": str(datetime.now()), "num_managers": len(managers), "sessions": [item["layoutName"] for item in session_layouts], "manager_type": "ZellijLocalManager"}
+    metadata_file = session_dir / "metadata.json"
+    text = json.dumps(metadata, indent=2, ensure_ascii=False)
+    metadata_file.write_text(text, encoding="utf-8")
+    managers_dir = session_dir / "managers"
+    managers_dir.mkdir(exist_ok=True)
+    for i, manager in enumerate(managers):
+        manager_data = {"session_name": manager.session_name, "layout_config": manager.layout_config, "layout_path": manager.layout_path}
+        manager_file = managers_dir / f"manager_{i}_{manager.session_name}.json"
+        text = json.dumps(manager_data, indent=2, ensure_ascii=False)
+        manager_file.write_text(text, encoding="utf-8")
+    logger.info(f"✅ Saved ZellijLocalManager session to: {session_dir}")
+    return session_id
+
+
+def load_manager(session_id: str):
+    """Load a saved manager state from disk and return the data needed to reconstruct ZellijLocalManager."""
+    from machineconfig.cluster.sessions_managers.zellij_local import ZellijLayoutGenerator
+    
+    session_dir = TMP_SERIALIZATION_DIR / session_id
+    if not session_dir.exists():
+        raise FileNotFoundError(f"Session directory not found: {session_dir}")
+    config_file = session_dir / "session_layouts.json"
+    if not config_file.exists():
+        raise FileNotFoundError(f"Configuration file not found: {config_file}")
+    text = config_file.read_text(encoding="utf-8")
+    session_layouts = json.loads(text)
+    managers = []
+    managers_dir = session_dir / "managers"
+    if managers_dir.exists():
+        manager_files = sorted(managers_dir.glob("manager_*.json"))
+        for manager_file in manager_files:
+            try:
+                text = manager_file.read_text(encoding="utf-8")
+                manager_data = json.loads(text)
+                manager = ZellijLayoutGenerator(layout_config=manager_data["layout_config"], session_name=manager_data["session_name"])
+                manager.layout_path = manager_data["layout_path"]
+                managers.append(manager)
+            except Exception as e:
+                logger.warning(f"Failed to load manager from {manager_file}: {e}")
+    logger.info(f"✅ Loaded ZellijLocalManager session from: {session_dir}")
+    return session_layouts, managers
+
+
+def kill_all_sessions(managers: list["ZellijLayoutGenerator"]) -> dict[str, StartResult]:
+    """Kill all managed zellij sessions."""
+    results: dict[str, StartResult] = {}
+    for manager in managers:
+        try:
+            session_name = manager.session_name
+            cmd = f"zellij delete-session --force {session_name}"
+            logger.info(f"Killing session '{session_name}'")
+            result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=10)
+            results[session_name] = {"success": result.returncode == 0, "message": "Session killed" if result.returncode == 0 else result.stderr}
+        except Exception as e:
+            key = getattr(manager, "session_name", None) or f"manager_{managers.index(manager)}"
+            results[key] = {"success": False, "error": str(e)}
+    return results

machineconfig/jobs/{python → installer}/check_installations.py

@@ -1,22 +1,9 @@
-# """CI
-# """
 
-
-# import time
 import platform
-
-# from typing import Any
-# from rich.console import Console
-# from machineconfig.utils.utils2 import pprint
-# # from rich.progress import track
-from machineconfig.utils.source_of_truth import LIBRARY_ROOT
-# from machineconfig.utils.installer import get_installed_cli_apps
-# from typing import Optional
-# from datetime import datetime
-# import csv
+from machineconfig.utils.source_of_truth import CONFIG_ROOT
 
 
-APP_SUMMARY_PATH = LIBRARY_ROOT.joinpath(f"profile/records/{platform.system().lower()}/apps_summary_report.csv")
+APP_SUMMARY_PATH = CONFIG_ROOT.joinpath(f"profile/records/{platform.system().lower()}/apps_summary_report.csv")
 # CLOUD: str = "gdw"  # Read.ini(DEFAULTS_PATH)['general']['rclone_config_name']
 # # my onedrive doesn't allow sharing.
 
@@ -193,7 +180,7 @@ APP_SUMMARY_PATH = LIBRARY_ROOT.joinpath(f"profile/records/{platform.system().lo
 #     else: return None
 
 
-# class PrecheckedCloudInstaller:
+# class precheckedPackages:
 #     def __init__(self):
 #         # Read CSV using standard library
 #         self.data = []
@@ -214,7 +201,7 @@ APP_SUMMARY_PATH = LIBRARY_ROOT.joinpath(f"profile/records/{platform.system().lo
 #     @staticmethod
 #     def install_cli_apps(app_url: str):
 #         try:
-#             exe = PrecheckedCloudInstaller.download_google_links(app_url)
+#             exe = precheckedPackages.download_google_links(app_url)
 #         except Exception as ex:  # type: ignore
 #             print(f"❌ ERROR | Failed downloading {app_url}: {ex}")
 #             return None
@@ -225,7 +212,7 @@ APP_SUMMARY_PATH = LIBRARY_ROOT.joinpath(f"profile/records/{platform.system().lo
 #             exe.move(folder=PathExtended.home().joinpath("AppData/Local/Microsoft/WindowsApps"), overwrite=True)
 #         return True
 
-#     def download_safe_apps(self, name: str="AllEssentials"):
+#     def download_safe_apps(self, name: str="essentials"):
 #         # if platform.system().lower() == "windows":
 #         #     from machineconfig.jobs.python.python_windows_installers_all import get_cli_py_installers
 #         #     cli_installers = get_cli_py_installers()
@@ -234,7 +221,6 @@ APP_SUMMARY_PATH = LIBRARY_ROOT.joinpath(f"profile/records/{platform.system().lo
 #         #     cli_installers = get_cli_py_installers()
 #         # else: raise NotImplementedError(f"Platform {platform.system().lower()} is not supported yet.")
 
-#         if name == "AllEssentials":
 #             print(f"""
 # {'=' * 150}
 # 📥 DOWNLOAD | Downloading {len(self.data)} apps...
@@ -244,13 +230,13 @@ APP_SUMMARY_PATH = LIBRARY_ROOT.joinpath(f"profile/records/{platform.system().lo
 #             app_urls = [item['app_url'] for item in self.data]
 #             from concurrent.futures import ThreadPoolExecutor
 #             with ThreadPoolExecutor(max_workers=20) as executor:
-#                 _res = list(executor.map(PrecheckedCloudInstaller.install_cli_apps, app_urls))
+#                 _res = list(executor.map(precheckedPackages.install_cli_apps, app_urls))
 #         else:
 #             app_items = [item for item in self.data if item['app_name'] == name]
 #             if not app_items:
 #                 raise ValueError(f"App '{name}' not found in data")
 #             app_url = app_items[0]['app_url']
-#             _res = PrecheckedCloudInstaller.install_cli_apps(app_url=app_url)
+#             _res = precheckedPackages.install_cli_apps(app_url=app_url)
 
 #         # print("\n" * 3)
 #         # for item_flag, item_name in zip(res, self.df["app_name"]):

machineconfig/jobs/installer/custom/boxes.py

@@ -0,0 +1,61 @@
+
+
+import platform
+from typing import Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from machineconfig.utils.installer_utils.installer_locator_utils import WINDOWS_INSTALL_PATH
+
+from machineconfig.utils.installer_utils.installer_class import Installer
+from machineconfig.utils.schemas.installer.installer_types import InstallerData
+
+installer_data_modified: InstallerData = {
+      "appName": "boxes",
+      "repoURL": "https://github.com/ascii-boxes/boxes",
+      "doc": "📦 ASCI draws boxes around text.",
+      "fileNamePattern": {
+        "amd64": {
+          "windows": "boxes-{version}-intel-win32.zip",
+          "linux": None,
+          "macos": None
+        },
+        "arm64": {
+          "linux": None,
+          "macos": None,
+          "windows": None
+        }
+      }
+    }
+
+def main(installer_data: InstallerData, version: Optional[str] = None) -> None:
+    console = Console()
+    _ = installer_data
+    console.print(
+        Panel.fit(
+            "\n".join([f"🖥️  Platform: {platform.system()}", f"🔄 Version: {'latest' if version is None else version}"]),
+            title="📦 Boxes Installer",
+            border_style="blue",
+        )
+    )
+
+    installer = Installer(installer_data=installer_data_modified)
+    downloaded, _version_to_be_installed = installer.binary_download(version=version)
+    decomp_path = downloaded.decompress()
+    from pathlib import Path
+    for item in decomp_path.rglob("*"):
+        if "boxes.exe" in item.name:
+            dest_exe = Path(WINDOWS_INSTALL_PATH) / "boxes.exe"
+            if dest_exe.exists():
+                dest_exe.unlink()
+            item.rename(dest_exe)
+        if "boxes.cfg" in item.name:
+            dest_cfg = Path(WINDOWS_INSTALL_PATH) / "boxes.cfg"
+            if dest_cfg.exists():
+                dest_cfg.unlink()
+            item.rename(dest_cfg)
+    console.print("📦 Boxes downloaded and decompressed.", style="bold green")
+
+
+if __name__ == "__main__":
+    pass

machineconfig/jobs/installer/custom/gh.py

@@ -0,0 +1,128 @@
+"""gh-cli installer"""
+
+import platform
+import subprocess
+from typing import Optional
+
+from rich.console import Console
+from rich.panel import Panel
+
+from machineconfig.utils.installer_utils.installer_class import Installer
+from machineconfig.utils.schemas.installer.installer_types import InstallerData
+
+r"""
+https://github.com/cli/cli
+
+
+# as per https://docs.github.com/en/copilot/github-copilot-in-the-cli/using-github-copilot-in-the-cli
+# gh auth login
+# gh extension install github/gh-copilot
+
+# & 'C:\Program Files\GitHub CLI\gh.exe' extension install github/gh-copilot
+# & 'C:\Program Files\GitHub CLI\gh.exe' extension install auth login
+
+"""
+
+config_dict: InstallerData = {
+    "appName": "gh",
+    "repoURL": "https://github.com/cli/cli",
+    "doc": "GitHub CLI",
+    "fileNamePattern": {"amd64": {"windows": "gh_{version}_windows_amd64.msi", "linux": "gh_{version}_linux_amd64.deb", "macos": "gh_{version}_macOS_amd64.pkg"}, "arm64": {"windows": "gh_{version}_windows_arm64.msi", "linux": "gh_{version}_linux_arm64.deb", "macos": "gh_{version}_macOS_arm64.pkg"}},
+}
+
+
+console = Console()
+
+
+def main(version: Optional[str]):
+    console.print(
+        Panel.fit(
+            "\n".join(
+                [
+                    "[bold magenta]GitHub CLI Installer[/bold magenta]",
+                    f"💻 Platform: {platform.system()}",
+                    f"🔄 Version: {version or 'latest'}",
+                ]
+            ),
+            title="🔱 GitHub CLI",
+            border_style="magenta",
+            padding=(1, 2),
+        )
+    )
+
+    _ = version
+    inst = Installer(installer_data=config_dict)
+    console.print("[bold cyan]📦 INSTALLATION | Installing GitHub CLI base package...[/bold cyan]")
+    inst.install(version=version)
+
+    console.print(
+        Panel.fit(
+            "🤖 GITHUB COPILOT | Setting up GitHub Copilot CLI extension",
+            title="Extension Setup",
+            border_style="cyan",
+        )
+    )
+
+    if platform.system() == "Windows":
+        console.print(
+            Panel.fit(
+                "🪟 WINDOWS SETUP | Configuring GitHub CLI for Windows...",
+                border_style="blue",
+                title="Platform Setup",
+            )
+        )
+        program = "gh extension install github/gh-copilot"
+    elif platform.system() in ["Linux", "Darwin"]:
+        system_name = "LINUX" if platform.system() == "Linux" else "MACOS"
+        console.print(
+            Panel.fit(
+                f"🐧 {system_name} SETUP | Configuring GitHub CLI for {platform.system()}...",
+                border_style="blue",
+                title="Platform Setup",
+            )
+        )
+        program = """
+gh extension install github/gh-copilot
+"""
+    else:
+        error_msg = f"Unsupported platform: {platform.system()}"
+        console.print(
+            Panel.fit(
+                f"❌ ERROR | {error_msg}",
+                title="Unsupported Platform",
+                border_style="red",
+            )
+        )
+        raise NotImplementedError(error_msg)
+
+    program += """
+gh auth login --with-token $HOME/dotfiles/creds/git/gh_token.txt
+"""
+    console.print("[bold]🔐 AUTHENTICATION | Setting up GitHub authentication with token...[/bold]")
+
+    console.print("[bold]🔄 EXECUTING | Running GitHub Copilot extension installation and authentication...[/bold]")
+    try:
+        subprocess.run(program, shell=True, text=True, check=True)
+        console.print("[green]✅ Command executed successfully[/green]")
+    except subprocess.CalledProcessError as e:
+        console.print(f"❌ [red]Command failed with exit code {e.returncode}[/red]")
+        raise
+
+    console.print(
+        Panel.fit(
+            "\n".join(
+                [
+                    "✅ SUCCESS | GitHub CLI installation completed",
+                    "🚀 GitHub Copilot CLI extension installed",
+                    "🔑 Authentication configured with token",
+                ]
+            ),
+            title="Installation Complete",
+            border_style="green",
+            padding=(1, 2),
+        )
+    )
+
+
+if __name__ == "__main__":
+    pass

machineconfig/jobs/{python_custom_installers → installer/custom}/hx.py

@@ -2,29 +2,40 @@
 Installers do not add runtime files to the machine, hence this script.
 """
 
-from machineconfig.utils.path_extended import PathExtended as PathExtended
-from machineconfig.utils.installer_utils.installer_abc import WINDOWS_INSTALL_PATH
+from machineconfig.utils.path_extended import PathExtended
+from machineconfig.utils.installer_utils.installer_locator_utils import WINDOWS_INSTALL_PATH
 from typing import Optional
 import platform
 
-from machineconfig.utils.installer_utils.installer_abc import LINUX_INSTALL_PATH
+from machineconfig.utils.installer_utils.installer_locator_utils import LINUX_INSTALL_PATH
 from machineconfig.utils.installer_utils.installer_class import Installer
 from rich.console import Console
 from rich.panel import Panel
 from machineconfig.utils.schemas.installer.installer_types import InstallerData
 
 
+LANGUAGES_SUPPORTED_GRAMMER = ["python.so", "nu.so", "bash.so", "lua.so", "powershell.so"]
 config_dict: InstallerData = {
     "appName": "hx",
-    "repoURL": "CUSTOM",
+    "repoURL": "CMD",
     "doc": "Helix is a post-modern modal text editor.",
-    "filenameTemplate": {"amd64": {"windows": "helix-{}-x86_64-windows.zip", "linux": "helix-{}-x86_64-linux.tar.xz", "macos": ""}, "arm64": {"windows": "", "linux": "", "macos": ""}},
-    "stripVersion": False,
-    "exeName": "hx",
+    "fileNamePattern": {
+        "amd64": {
+            "linux": "helix-{version}-x86_64-linux.tar.xz",
+            "macos": "helix-{version}-x86_64-macos.tar.xz",
+            "windows": "helix-{version}-x86_64-windows.zip",
+        },
+        "arm64": {
+            "linux": "helix-{version}-arm64-linux.tar.xz",
+            "macos": "helix-{version}-arm64-macos.tar.xz",
+            "windows": "helix-{version}-arm64-windows.zip",
+        },
+    },
 }
 
 
-def main(version: Optional[str], install_lib: bool = False):
+def main(installer_data: InstallerData, version: Optional[str], install_lib: bool = True):
+    _ = installer_data
     console = Console()
 
     console.print(Panel(f"HELIX EDITOR INSTALLER 🧬\nPlatform: {platform.system()}\nVersion:  {'latest' if version is None else version}", title="Installer", expand=False))
@@ -34,7 +45,7 @@ def main(version: Optional[str], install_lib: bool = False):
     inst = Installer(installer_data=config_dict_copy)
 
     print("\n📥 [Step 1/5] Downloading Helix editor...")
-    downloaded, _version_to_be_installed = inst.download(version=version)
+    downloaded, _version_to_be_installed = inst.binary_download(version=version)
     print("   ✨ Download complete.")
 
     print("\n🔍 [Step 2/5] Locating executable and components...")
@@ -48,6 +59,7 @@ def main(version: Optional[str], install_lib: bool = False):
         raise FileNotFoundError(f"Could not find 'hx' executable in {downloaded.name}")
 
     assert len(hx_file_search) == 1, f"Expected 1 'hx' executable, found {len(hx_file_search)}"
+
     hx_file = hx_file_search[0]
     contrib = hx_file.parent / "contrib"
     runtime = contrib.parent / "runtime"
@@ -63,21 +75,50 @@ def main(version: Optional[str], install_lib: bool = False):
     print("\n🗑️  [Step 3/5] Cleaning up previous installation (if any)...")
     runtime_path = PathExtended.home().joinpath(".config/helix/runtime")
     contrib_path = PathExtended.home().joinpath(".config/helix/contrib")
-    runtime_path.delete(sure=True, verbose=False)
-    contrib_path.delete(sure=True, verbose=False)
-    print(f"   ✨ Cleaned '{runtime_path}' and '{contrib_path}'.")
 
     print("\n📦 [Step 4/5] Installing Helix components...")
-    target_config_dir = PathExtended("~/.config/helix").expanduser()
+    target_config_dir = PathExtended.home().joinpath(".config/helix").expanduser()
     target_config_dir.mkdir(parents=True, exist_ok=True)
 
     if platform.system() in ["Linux", "Darwin"]:
         target_bin_path = PathExtended(LINUX_INSTALL_PATH) if platform.system() == "Linux" else PathExtended("/usr/local/bin")
         exe_name = "hx"
         hx_file.move(folder=target_bin_path, overwrite=True)
+
+        # Always install contrib (regardless of install_lib flag) — treat it like the executable.
+        contrib_path.delete(sure=True, verbose=False)
+        contrib.move(folder=target_config_dir, overwrite=True)
+
+        # Install runtime only if install_lib is True. When copying runtime, copy all subfolders
+        # except 'grammars' (for which we only copy the specific python.so file if present).
         if install_lib:
-            contrib.move(folder=target_config_dir, overwrite=True)
-            runtime.move(folder=target_config_dir, overwrite=True)
+            runtime_path.delete(sure=True, verbose=False)
+            print(f"   ✨ Cleaned '{runtime_path}' and '{contrib_path}'.")
+            target_runtime = target_config_dir.joinpath("runtime")
+            target_runtime.mkdir(parents=True, exist_ok=True)
+
+            # iterate runtime children and copy selectively
+            for child in runtime.iterdir():
+                # skip non-existent or weird entries
+                if not child.exists():
+                    continue
+                if child.name == "grammars":
+                    # copy only the specific language files from runtime/grammars if they exist
+                    for a_language in LANGUAGES_SUPPORTED_GRAMMER:
+                        lang_file = child.joinpath(a_language)
+                        if lang_file.exists() and lang_file.is_file():
+                            dest = target_runtime.joinpath("grammars")
+                            lang_file.copy(folder=dest, overwrite=True)
+                else:
+                    # copy the whole child (file or directory) into target_runtime
+                    # for directories, copy will create target_runtime/<child.name>
+                    try:
+                        child.copy(folder=target_runtime, overwrite=True)
+                    except Exception:
+                        # fallback: try copying contents if it's a directory
+                        if child.is_dir():
+                            for sub in child.iterdir():
+                                sub.copy(folder=target_runtime.joinpath(child.name), overwrite=True)
         system_name = "Linux" if platform.system() == "Linux" else "macOS"
         console.print(
             Panel(
@@ -93,9 +134,34 @@ def main(version: Optional[str], install_lib: bool = False):
         target_bin_path = PathExtended(WINDOWS_INSTALL_PATH)
         exe_name = "hx.exe"
         hx_file.move(folder=target_bin_path, overwrite=True)
+
+        # Always install contrib (regardless of install_lib flag)
+        contrib_path.delete(sure=True, verbose=False)
+        contrib.move(folder=target_config_dir, overwrite=True)
+
+        # Install runtime only if install_lib is True. Copy selectively as on POSIX.
         if install_lib:
-            contrib.move(folder=target_config_dir, overwrite=True)
-            runtime.move(folder=target_config_dir, overwrite=True)
+            runtime_path.delete(sure=True, verbose=False)
+            print(f"   ✨ Cleaned '{runtime_path}' and '{contrib_path}'.")
+            target_runtime = target_config_dir.joinpath("runtime")
+            target_runtime.mkdir(parents=True, exist_ok=True)
+
+            for child in runtime.iterdir():
+                if not child.exists():
+                    continue
+                if child.name == "grammars":
+                    for a_language in LANGUAGES_SUPPORTED_GRAMMER:
+                        lang_file = child.joinpath(a_language)
+                        if lang_file.exists() and lang_file.is_file():
+                            dest = target_runtime.joinpath("grammars")
+                            lang_file.copy(folder=dest, overwrite=True)
+                else:
+                    try:
+                        child.copy(folder=target_runtime, overwrite=True)
+                    except Exception:
+                        if child.is_dir():
+                            for sub in child.iterdir():
+                                sub.copy(folder=target_runtime.joinpath(child.name), overwrite=True)
         console.print(
             Panel(
                 f"""✅ SUCCESS | Helix editor installed successfully on Windows!
@@ -128,4 +194,4 @@ def main(version: Optional[str], install_lib: bool = False):
 
 
 if __name__ == "__main__":
-    main(version=None)
+    pass