machineconfig 5.15__py3-none-any.whl → 7.66__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,9 +1,9 @@
 
 import platform
-from machineconfig.utils.source_of_truth import LIBRARY_ROOT
+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.
 
@@ -221,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 == "essentials":
 #             print(f"""
 # {'=' * 150}
 # 📥 DOWNLOAD | Downloading {len(self.data)} apps...

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/hx.py

@@ -3,37 +3,39 @@ Installers do not add runtime files to the machine, hence this script.
 """
 
 from machineconfig.utils.path_extended import PathExtended
-from machineconfig.utils.installer_utils.installer_abc import WINDOWS_INSTALL_PATH
+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": "CMD",
     "doc": "Helix is a post-modern modal text editor.",
     "fileNamePattern": {
         "amd64": {
-            "linux": "hx-linux-amd64.tar.xz",
-            "macos": "hx-macos-amd64.tar.xz",
-            "windows": "hx-windows-amd64.zip",
+            "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": "hx-linux-arm64.tar.xz",
-            "macos": "hx-macos-arm64.tar.xz",
-            "windows": "hx-windows-arm64.zip",
+            "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))
@@ -43,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...")
@@ -57,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"
@@ -72,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(
@@ -102,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!
@@ -137,4 +194,4 @@ def main(version: Optional[str], install_lib: bool = False):
 
 
 if __name__ == "__main__":
-    main(version=None)
+    pass

machineconfig/jobs/installer/custom_dev/alacritty.py

@@ -30,8 +30,8 @@ def main(installer_data: InstallerData, version: Optional[str]) -> None:
         program = """
 
 cargo install alacritty
-mkdir -p ~/.config/alacritty/themes
-git clone https://github.com/alacritty/alacritty-theme ~/.config/alacritty/themes
+mkdir -p $HOME/.config/alacritty/themes
+git clone https://github.com/alacritty/alacritty-theme $HOME/.config/alacritty/themes
 
 """
     elif platform.system() in ["Linux", "Darwin"]:
@@ -41,8 +41,8 @@ git clone https://github.com/alacritty/alacritty-theme ~/.config/alacritty/theme
 
 
 cargo install alacritty
-mkdir -p ~/.config/alacritty/themes
-git clone https://github.com/alacritty/alacritty-theme ~/.config/alacritty/themes
+mkdir -p $HOME/.config/alacritty/themes
+git clone https://github.com/alacritty/alacritty-theme $HOME/.config/alacritty/themes
 
 """
     else:

machineconfig/jobs/installer/custom_dev/brave.py

@@ -9,12 +9,6 @@ from rich.panel import Panel
 from machineconfig.utils.schemas.installer.installer_types import InstallerData
 
 
-# config_dict: InstallerData = {
-#     "appName": "Brave",
-#     "repoURL": "CMD",
-#     "doc": "Privacy-focused web browser with built-in ad blocking",
-# }
-
 
 def main(installer_data: InstallerData, version: Optional[str]) -> None:
     console = Console()
@@ -33,7 +27,7 @@ def main(installer_data: InstallerData, version: Optional[str]) -> None:
         console.print("🪟 Installing Brave Browser on Windows using winget...", style="bold")
         program = """
 
-winget install --Name "Brave Browser" --Id Brave.Brave --source winget --accept-package-agreements --accept-source-agreements
+winget install --no-upgrade --name "Brave"                        --Id "Brave.Brave"                --source winget --scope user --accept-package-agreements --accept-source-agreements
 
 """
     elif platform.system() in ["Linux", "Darwin"]:

machineconfig/jobs/installer/custom_dev/cloudflare_warp_cli.py

@@ -0,0 +1,23 @@
+
+from typing import Optional
+import platform
+from machineconfig.utils.schemas.installer.installer_types import InstallerData
+
+
+def main(installer_data: InstallerData, version: Optional[str]):
+    _ = installer_data, version
+    system = platform.system()
+    if system == "Windows":
+        raise NotImplementedError("Installer is not yet implemented for Windows.")
+    elif system == "Linux":
+        from pathlib import Path
+        import machineconfig.jobs.installer as module
+        program = Path(module.__file__).parent.joinpath("linux_scripts/cloudflare_warp_cli.sh").read_text(encoding="utf-8")
+    elif system == "Darwin":
+        program = "brew install --cask cloudflare-warp"
+    else:
+        raise NotImplementedError(f"Unsupported platform: {system}")
+    import subprocess
+    subprocess.run(program, shell=True, check=True)
+    return f"Cloudflare WARP CLI installed successfully on {system}."
+

machineconfig/jobs/installer/custom_dev/code.py

@@ -32,7 +32,10 @@ def main(installer_data: InstallerData, version: Optional[str] = None) -> None:
         install_script = """brew install --cask visual-studio-code"""
     elif platform.system() == "Windows":
         console.print("🪟 Installing VS Code on Windows using winget...", style="bold")
-        install_script = """winget install --no-upgrade --name "Microsoft Visual Studio Code" --Id "Microsoft.VisualStudioCode" --source winget --scope user --accept-package-agreements --accept-source-agreements"""
+        install_script = """
+winget install --no-upgrade --name "Microsoft Visual Studio Code" --Id "Microsoft.VisualStudioCode" --source winget --scope user --accept-package-agreements --accept-source-agreements
+
+"""
     else:
         error_msg = f"Unsupported platform: {platform.system()}"
         console.print(

machineconfig/jobs/installer/custom_dev/dubdb_adbc.py

@@ -0,0 +1,30 @@
+
+
+
+from machineconfig.utils.schemas.installer.installer_types import InstallerData
+from typing import Optional
+
+installer_data: InstallerData = {
+      "appName": "libduckdb.so",
+      "repoURL": "https://github.com/duckdb/duckdb",
+      "doc": "🗃️ An in-process SQL OLAP database management system",
+      "fileNamePattern": {
+        "amd64": {
+          "linux": "libduckdb-linux-amd64.zip",
+          "macos": None,
+          "windows": None
+        },
+        "arm64": {
+          "linux": "libduckdb-linux-arm64.zip",
+          "macos": None,
+          "windows": None
+        }
+      }
+    }
+
+
+def main(installer_data: InstallerData, version: Optional[str]) -> None:
+    _ = version
+    from machineconfig.utils.installer_utils.installer_runner import Installer
+    installer = Installer(installer_data)
+    installer.install(version=None)

machineconfig/jobs/installer/custom_dev/nerfont_windows_helper.py

@@ -18,34 +18,25 @@ from machineconfig.utils.installer_utils.installer_class import Installer
 from machineconfig.utils.schemas.installer.installer_types import InstallerData
 
 
-# Nerd Fonts installer configuration data
 nerd_fonts: InstallerData = {
     "appName": "Cascadia Code Nerd Font",
     "repoURL": "https://github.com/ryanoasis/nerd-fonts",
     "doc": "Nerd Fonts is a project that patches developer targeted fonts with a high number of glyphs (icons)",
     "fileNamePattern": {
         "amd64": {
-            "windows": "CaskaydiaCoveNerdFontWindows.zip",
-            "linux": "CaskaydiaCoveNerdFontLinux.zip",
-            "macos": "CaskaydiaCoveNerdFontMac.zip",
+            "windows": "CascadiaCode.zip",
+            "linux": "CascadiaCode.zip",
+            "macos": "CascadiaCode.zip",
         },
         "arm64": {
-            "windows": "CaskaydiaCoveNerdFontWindows.zip",
-            "linux": "CaskaydiaCoveNerdFontLinux.zip",
-            "macos": "CaskaydiaCoveNerdFontMac.zip",
+            "windows": "CascadiaCode.zip",
+            "linux": "CascadiaCode.zip",
+            "macos": "CascadiaCode.zip",
         }
     }
 }
 
 
-# Patterns to match any installed variant (NF, Nerd Font, Mono, Propo, style weights) of Cascadia/Caskaydia
-# We'll compile them at runtime for flexibility. Keep them simple to avoid false positives.
-REQUIRED_FONT_PATTERNS: tuple[str, ...] = (
-    r"caskaydiacove.*(nf|nerd ?font)",
-    r"cascadiacode.*(nf|nerd ?font)"
-)
-
-
 console = Console()
 
 
@@ -92,7 +83,7 @@ def _missing_required_fonts(installed_fonts: Iterable[str]) -> list[str]:
 
     installed_norm = [f.lower().replace(" ", "") for f in installed_fonts]
     missing: list[str] = []
-    for pattern in REQUIRED_FONT_PATTERNS:
+    for pattern in ["cascadiacode*"]:
         regex = re.compile(pattern)
         if not any(regex.search(f) for f in installed_norm):
             missing.append(pattern)
@@ -125,7 +116,7 @@ def install_nerd_fonts() -> None:
     console.print(f"🔍 Missing fonts detected: {', '.join(missing)}. Proceeding with installation...")
     console.print("🔍 Downloading Nerd Fonts package...")
     
-    folder, _version_to_be_installed = Installer(installer_data=nerd_fonts).download(version=None)
+    folder, _version_to_be_installed = Installer(installer_data=nerd_fonts).binary_download(version=None)
 
     console.print("🧹 Cleaning up unnecessary files...")
     [p.delete(sure=True) for p in folder.search("*Windows*")]
@@ -136,7 +127,7 @@ def install_nerd_fonts() -> None:
     file = PathExtended.tmpfile(suffix=".ps1")
     file.parent.mkdir(parents=True, exist_ok=True)
     
-    raw_content = LIBRARY_ROOT.joinpath("setup_windows/wt_and_pwsh/install_fonts.ps1").read_text(encoding="utf-8").replace(r".\fonts-to-be-installed", str(folder))
+    raw_content = LIBRARY_ROOT.joinpath("jobs/installer/pwsh_scripts/install_fonts.ps1").read_text(encoding="utf-8").replace(r".\fonts-to-be-installed", str(folder))
     # PowerShell 5.1 can choke on certain unicode chars in some locales; keep ASCII only.
     content = "".join(ch for ch in raw_content if ord(ch) < 128)
     file.write_text(content, encoding="utf-8")