machineconfig 5.15__py3-none-any.whl → 7.98__py3-none-any.whl

machineconfig/utils/installer_utils/install_from_url.py

@@ -0,0 +1,183 @@
+
+
+import platform
+from typing import TYPE_CHECKING, Optional
+
+from machineconfig.utils.installer_utils.installer_helper import install_deb_package, download_and_prepare
+from machineconfig.utils.installer_utils.installer_locator_utils import find_move_delete_linux, find_move_delete_windows
+from machineconfig.utils.installer_utils.github_release_bulk import (
+    get_repo_name_from_url,
+    fetch_github_release_data,
+    extract_release_info,
+    AssetInfo,
+)
+from machineconfig.utils.path_extended import PathExtended
+from machineconfig.utils.source_of_truth import INSTALL_VERSION_ROOT
+
+if TYPE_CHECKING:
+    from rich.console import Console
+
+SUPPORTED_GITHUB_HOSTS = {"github.com", "www.github.com"}
+
+
+def _format_size(size_bytes: int) -> str:
+    if size_bytes <= 0:
+        return "0 B"
+    units = ("B", "KiB", "MiB", "GiB", "TiB")
+    value = float(size_bytes)
+    index = 0
+    while value >= 1024 and index < len(units) - 1:
+        value /= 1024
+        index += 1
+    return f"{value:.1f} {units[index]}"
+
+
+def _derive_tool_name(repo_name: str, asset_name: Optional[str]) -> Optional[str]:
+    repo_segment = repo_name.split("/", maxsplit=1)[-1]
+    repo_clean = repo_segment.replace(".git", "").lower()
+    repo_filtered = "".join(char for char in repo_clean if char.isalnum())
+    if repo_filtered:
+        return repo_filtered
+    if asset_name is None:
+        return None
+    asset_clean = asset_name.lower()
+    asset_filtered = "".join(char for char in asset_clean if char.isalnum())
+    if asset_filtered:
+        return asset_filtered
+    return None
+
+
+def _finalize_install(repo_name: str, asset_name: Optional[str], version: str, extracted_path: PathExtended, console: "Console") -> None:
+    from rich.panel import Panel
+    if extracted_path.suffix == ".deb":
+        install_deb_package(extracted_path)
+        tool_name_deb = _derive_tool_name(repo_name, asset_name)
+        if tool_name_deb is not None:
+            INSTALL_VERSION_ROOT.joinpath(tool_name_deb).parent.mkdir(parents=True, exist_ok=True)
+            INSTALL_VERSION_ROOT.joinpath(tool_name_deb).write_text(version, encoding="utf-8")
+        console.print(Panel(f"Installed Debian package for [green]{tool_name_deb}[/green]", title="✅ Complete", border_style="green"))
+        return
+    system_name = platform.system()
+    tool_name = _derive_tool_name(repo_name, asset_name)
+    rename_target = f"{tool_name}.exe" if system_name == "Windows" else tool_name
+    try:
+        if system_name == "Windows":
+            installed_path = find_move_delete_windows(downloaded_file_path=extracted_path, tool_name=tool_name, delete=True, rename_to=rename_target)
+        elif system_name in {"Linux", "Darwin"}:
+            installed_path = find_move_delete_linux(downloaded=extracted_path, tool_name=tool_name, delete=True, rename_to=rename_target)
+        else:
+            console.print(Panel(f"Unsupported operating system: {system_name}", title="❌ Error", border_style="red"))
+            return None
+    except IndexError:
+        if system_name == "Windows":
+            installed_path = find_move_delete_windows(downloaded_file_path=extracted_path, tool_name=None, delete=True, rename_to=rename_target)
+        elif system_name in {"Linux", "Darwin"}:
+            installed_path = find_move_delete_linux(downloaded=extracted_path, tool_name="", delete=True, rename_to=rename_target)
+        else:
+            raise
+    if tool_name is not None:
+        INSTALL_VERSION_ROOT.joinpath(tool_name).parent.mkdir(parents=True, exist_ok=True)
+        INSTALL_VERSION_ROOT.joinpath(tool_name).write_text(version, encoding="utf-8")
+    console.print(Panel(f"Installed [green]{tool_name}[/green] to {installed_path}\nVersion: {version}", title="✅ Complete", border_style="green"))
+
+
+def install_from_github_url(github_url: str) -> None:
+    from machineconfig.utils.options import choose_from_options
+    from rich.console import Console
+    from rich.panel import Panel
+
+    console = Console()
+    repo_info = get_repo_name_from_url(github_url)
+    if repo_info is None:
+        console.print(Panel(f"Invalid GitHub URL: {github_url}", title="❌ Error", border_style="red"))
+        return None
+    owner, repo = repo_info
+    repo_name = f"{owner}/{repo}"
+    console.print(Panel(f"Fetching latest release for [green]{repo_name}[/green]", title="🌐 GitHub", border_style="blue"))
+    release_raw = fetch_github_release_data(owner, repo)
+    if not release_raw:
+        console.print(Panel("No releases available for this repository.", title="❌ Error", border_style="red"))
+        return None
+    
+    release_info = extract_release_info(release_raw)
+    if not release_info:
+        console.print(Panel("Failed to parse release information.", title="❌ Error", border_style="red"))
+        return None
+    
+    assets = release_info["assets"]
+    if not assets:
+        console.print(Panel("No downloadable assets found in the latest release.", title="❌ Error", border_style="red"))
+        return None
+    binary_assets = assets
+    selection_pool = binary_assets if binary_assets else assets
+    if not selection_pool:
+        console.print(Panel("No assets available for installation.", title="❌ Error", border_style="red"))
+        return None
+    
+    # First pass: collect all formatted data and calculate column widths
+    asset_data = []
+    for asset in selection_pool:
+        name = asset["name"]
+        download_url = asset["browser_download_url"]
+        if name == "" or download_url == "":
+            continue
+        size = asset["size"]
+        download_count = asset.get("download_count", 0)
+        created_at = asset.get("created_at", "")
+        
+        # Format each field
+        size_str = f"[{_format_size(size)}]"
+        downloads_str = f"{download_count:,}"
+        date_str = created_at.split("T")[0] if created_at else "N/A"
+        
+        asset_data.append({
+            "name": name,
+            "size_str": size_str,
+            "downloads_str": downloads_str,
+            "date_str": date_str,
+            "asset": asset
+        })
+    
+    # Calculate maximum widths for alignment
+    max_name_len = max(len(item["name"]) for item in asset_data) if asset_data else 0
+    max_size_len = max(len(item["size_str"]) for item in asset_data) if asset_data else 0
+    max_downloads_len = max(len(item["downloads_str"]) for item in asset_data) if asset_data else 0
+    
+    # Second pass: build aligned labels
+    options_map: dict[str, AssetInfo] = {}
+    for item in asset_data:
+        name_padded = item["name"].ljust(max_name_len)
+        size_padded = item["size_str"].ljust(max_size_len)
+        downloads_padded = item["downloads_str"].rjust(max_downloads_len)
+        
+        label = f"{name_padded} {size_padded} | ⬇ {downloads_padded} | 📅 {item['date_str']}"
+        options_map[label] = item["asset"]
+    
+    if not options_map:
+        console.print(Panel("Release assets lack download URLs.", title="❌ Error", border_style="red"))
+        return None
+    selection_label = choose_from_options(options=list(options_map.keys()), msg="Select a release asset", multi=False, header="📦 GitHub Release Assets", tv=True)
+    selected_asset = options_map[selection_label]
+    download_url_value = selected_asset["browser_download_url"]
+    asset_name_value = selected_asset["name"]
+    if download_url_value == "":
+        console.print(Panel("Selected asset lacks a download URL.", title="❌ Error", border_style="red"))
+        return None
+    asset_name = asset_name_value if asset_name_value != "" else "github_binary"
+    version = release_info["tag_name"] if release_info["tag_name"] != "" else "latest"
+    console.print(Panel(f"Downloading [cyan]{asset_name}[/cyan]", title="⬇️ Download", border_style="magenta"))
+    extracted_path = download_and_prepare(download_url_value)
+    _finalize_install(repo_name=repo_name, asset_name=asset_name, version=version, extracted_path=extracted_path, console=console)
+
+
+def install_from_binary_url(binary_url: str) -> None:
+    from rich.console import Console
+    # from rich.panel import Panel
+    console = Console()
+    # parsed = urlparse(binary_url)
+    # asset_candidate = parsed.path.split("/")[-1] if parsed.path else ""
+    # asset_name = asset_candidate if asset_candidate != "" else "binary_asset"
+    # host = parsed.netloc if parsed.netloc != "" else "remote host"
+    # console.print(Panel(f"Downloading from [green]{binary_url}[/green]", title="⬇️ Download", border_style="magenta"))
+    extracted_path = download_and_prepare(binary_url)
+    _finalize_install(repo_name="", asset_name=None, version="latest", extracted_path=extracted_path, console=console)

machineconfig/utils/installer_utils/installer_class.py

@@ -1,16 +1,16 @@
+from machineconfig.utils.installer_utils.installer_helper import install_deb_package, download_and_prepare
 from machineconfig.utils.path_extended import PathExtended
-from machineconfig.utils.installer_utils.installer_abc import find_move_delete_linux, find_move_delete_windows
-from machineconfig.utils.source_of_truth import INSTALL_TMP_DIR, INSTALL_VERSION_ROOT, LIBRARY_ROOT
-from machineconfig.utils.installer_utils.installer_abc import check_tool_exists
-from machineconfig.utils.io import read_json
-from machineconfig.utils.schemas.installer.installer_types import InstallerData, InstallerDataFiles, get_os_name, get_normalized_arch
+from machineconfig.utils.source_of_truth import INSTALL_VERSION_ROOT
+from machineconfig.utils.installer_utils.installer_locator_utils import find_move_delete_linux, find_move_delete_windows, check_tool_exists
+from machineconfig.utils.schemas.installer.installer_types import InstallerData, get_os_name, get_normalized_arch
+from machineconfig.utils.installer_utils.github_release_bulk import (
+    get_repo_name_from_url,
+    get_release_info,
+)
 
 import platform
 import subprocess
-import json
-from typing import Optional, Any
-from pathlib import Path
-from urllib.parse import urlparse
+from typing import Optional
 
 
 class Installer:
@@ -32,64 +32,21 @@ class Installer:
     
     def _get_exe_name(self) -> str:
         """Derive executable name from app name by converting to lowercase and removing spaces."""
-        return self.installer_data["appName"].lower().replace(" ", "").replace("-", "")
-
-    @staticmethod
-    def choose_app_and_install():
-        print(f"\n{'=' * 80}\n🔍 SELECT APPLICATION TO INSTALL 🔍\n{'=' * 80}")
-        from machineconfig.utils.options import choose_from_options
-
-        print("📂 Searching for configuration files...")
-        jobs_dir = Path(LIBRARY_ROOT.joinpath("jobs"))
-        config_paths = [Path(p) for p in jobs_dir.rglob("config.json")]
-        path = choose_from_options(multi=False, options=config_paths, msg="Choose one option")
-        print(f"📄 Loading configuration from: {path}")
-        config_data = read_json(path)
-        installer_data_files = InstallerDataFiles(config_data)
-
-        # Extract app names from the installers
-        app_names = [installer["appName"] for installer in installer_data_files["installers"]]
-        print("🔍 Select an application to install:")
-        app_name = choose_from_options(multi=False, options=app_names, fzf=True, msg="Choose one option")
-
-        # Find the selected installer data
-        selected_installer_data = None
-        for installer_data in installer_data_files["installers"]:
-            if installer_data["appName"] == app_name:
-                selected_installer_data = installer_data
-                break
-
-        if selected_installer_data is None:
-            raise ValueError(f"Could not find installer data for {app_name}")
-
-        installer = Installer(installer_data=selected_installer_data)
-        exe_name = installer._get_exe_name()
-        print(f"📦 Selected application: {exe_name}")
-        version = input(f"📝 Enter version to install for {exe_name} [latest]: ") or None
-        print(f"\n{'=' * 80}\n🚀 INSTALLING {exe_name.upper()} 🚀\n{'=' * 80}")
-        installer.install(version=version)
+        return self.installer_data["appName"].lower().replace(" ", "")  # .replace("-", "")
 
     def install_robust(self, version: Optional[str]) -> str:
         try:
             exe_name = self._get_exe_name()
-            print(f"\n{'=' * 80}\n🚀 INSTALLING {exe_name.upper()} 🚀\n{'=' * 80}")
             result_old = subprocess.run(f"{exe_name} --version", shell=True, capture_output=True, text=True)
             old_version_cli = result_old.stdout.strip()
-            print(f"📊 Current version: {old_version_cli or 'Not installed'}")
-
+            print(f"🚀 INSTALLING {exe_name.upper()} 🚀. 📊 Current version: {old_version_cli or 'Not installed'}")
             self.install(version=version)
-
             result_new = subprocess.run(f"{exe_name} --version", shell=True, capture_output=True, text=True)
             new_version_cli = result_new.stdout.strip()
-            print(f"📊 New version: {new_version_cli}")
-
             if old_version_cli == new_version_cli:
-                print(f"ℹ️  Same version detected: {old_version_cli}")
                 return f"""📦️ 😑 {exe_name}, same version: {old_version_cli}"""
             else:
-                print(f"🚀 Update successful: {old_version_cli} ➡️ {new_version_cli}")
                 return f"""📦️ 🤩 {exe_name} updated from {old_version_cli} ➡️ TO ➡️  {new_version_cli}"""
-
         except Exception as ex:
             exe_name = self._get_exe_name()
             app_name = self.installer_data["appName"]
@@ -104,28 +61,27 @@ class Installer:
         installer_arch_os = self.installer_data["fileNamePattern"][arch][os_name]
         if installer_arch_os is None:
             raise ValueError(f"No installation pattern for {exe_name} on {os_name} {arch}")
-
-        print(f"\n{'=' * 80}\n🔧 INSTALLATION PROCESS: {exe_name} 🔧\n{'=' * 80}")
         version_to_be_installed: str = "unknown"  # Initialize to ensure it's always bound
         if repo_url == "CMD":
-            if "npm " in installer_arch_os or "pip " in installer_arch_os or "winget " in installer_arch_os:
+            if any(pm in installer_arch_os for pm in ["npm ", "pip ", "winget ", "brew ", "curl "]):
+                from rich import print as rprint
+                from rich.panel import Panel
+                from rich.console import Group
                 package_manager = installer_arch_os.split(" ", maxsplit=1)[0]
-                print(f"📦 Using package manager: {package_manager}")
+                print(f"📦 Using package manager: {installer_arch_os}")
                 desc = package_manager + " installation"
                 version_to_be_installed = package_manager + "Latest"
-                print(f"🚀 Running: {installer_arch_os}")
-                result = subprocess.run(installer_arch_os, shell=True, capture_output=True, text=True)
+                result = subprocess.run(installer_arch_os, shell=True, capture_output=False, text=True)
                 success = result.returncode == 0 and result.stderr == ""
                 if not success:
-                    print(f"❌ {desc} failed")
+                    sub_panels = []
                     if result.stdout:
-                        print(f"STDOUT: {result.stdout}")
+                        sub_panels.append(Panel(result.stdout, title="STDOUT", style="blue"))
                     if result.stderr:
-                        print(f"STDERR: {result.stderr}")
-                    print(f"Return code: {result.returncode}")
-                print(f"✅ Package manager installation completed\n{'=' * 80}")
+                        sub_panels.append(Panel(result.stderr, title="STDERR", style="red"))
+                    group_content = Group(f"❌ {desc} failed\nReturn code: {result.returncode}", *sub_panels)
+                    rprint(Panel(group_content, title=desc, style="red"))
             elif installer_arch_os.endswith((".sh", ".py", ".ps1")):
-                # search for the script, see which path ends with the script name
                 import machineconfig.jobs.installer as module
                 from pathlib import Path
                 search_root = Path(module.__file__).parent
@@ -139,34 +95,22 @@ class Installer:
                 if installer_arch_os.endswith(".sh"):
                     if platform.system() not in ["Linux", "Darwin"]:
                         raise NotImplementedError(f"Shell script installation not supported on {platform.system()}")
-                    print(f"🚀 Running shell script: {installer_path}")
                     subprocess.run(f"bash {installer_path}", shell=True, check=True)
                     version_to_be_installed = "scripted_installation"
-                    print(f"✅ Shell script installation completed\n{'=' * 80}")
                 elif installer_arch_os.endswith(".ps1"):
                     if platform.system() != "Windows":
                         raise NotImplementedError(f"PowerShell script installation not supported on {platform.system()}")
-                    print(f"🚀 Running PowerShell script: {installer_path}")
                     subprocess.run(f"powershell -ExecutionPolicy Bypass -File {installer_path}", shell=True, check=True)
                     version_to_be_installed = "scripted_installation"
-                    print(f"✅ PowerShell script installation completed\n{'=' * 80}")
                 elif installer_arch_os.endswith(".py"):
                     import runpy
                     runpy.run_path(str(installer_path), run_name=None)["main"](self.installer_data, version=version)
                     version_to_be_installed = str(version)
-                    print(f"✅ Custom installation completed\n{'=' * 80}")
-            elif installer_arch_os.startswith("https://"):  # its a url to be downloaded
-                print(f"📥 Downloading object from URL: {installer_arch_os}")
-                downloaded_object = PathExtended(installer_arch_os).download(folder=INSTALL_TMP_DIR)
-                # object is either a zip containing a binary or a straight out binary.
-                if downloaded_object.suffix in [".zip", ".tar.gz"]:
-                    print(f"📦 Decompressing downloaded archive: {downloaded_object}")
-                    downloaded_object = downloaded_object.decompress()
-                    print(f"✅ Decompression completed to: {downloaded_object}")
+            elif installer_arch_os.startswith("https://") or installer_arch_os.startswith("http://"):
+                downloaded_object = download_and_prepare(installer_arch_os)
                 if downloaded_object.suffix in [".exe", ""]:  # likely an executable
                     if platform.system() == "Windows":
-                        print("🪟 Installing on Windows...")
-                        exe = find_move_delete_windows(downloaded_file_path=downloaded_object, exe_name=exe_name, delete=True, rename_to=exe_name.replace(".exe", "") + ".exe")
+                        exe = find_move_delete_windows(downloaded_file_path=downloaded_object, tool_name=exe_name, delete=True, rename_to=exe_name.replace(".exe", "") + ".exe")
                     elif platform.system() in ["Linux", "Darwin"]:
                         system_name = "Linux" if platform.system() == "Linux" else "macOS"
                         print(f"🐧 Installing on {system_name}...")
@@ -175,7 +119,6 @@ class Installer:
                         error_msg = f"❌ ERROR: System {platform.system()} not supported"
                         print(error_msg)
                         raise NotImplementedError(error_msg)
-
                     _ = exe
                     if exe.name.replace(".exe", "") != exe_name.replace(".exe", ""):
                         from rich import print as pprint
@@ -186,33 +129,20 @@ class Installer:
                         print(f"🔄 Renaming to correct name: {new_exe_name}")
                         exe.with_name(name=new_exe_name, inplace=True, overwrite=True)
                     version_to_be_installed = "downloaded_binary"
-                    print(f"✅ Downloaded binary installation completed\n{'=' * 80}")
+                elif downloaded_object.suffix in [".deb"]:
+                    install_deb_package(downloaded_object)
+                    version_to_be_installed = "downloaded_deb"
+                else:
+                    raise ValueError(f"Downloaded file is not an executable: {downloaded_object}")
             else:
                 raise NotImplementedError(f"CMD installation method not implemented for: {installer_arch_os}")
         else:
             assert repo_url.startswith("https://github.com/"), f"repoURL must be a GitHub URL, got {repo_url}"
-            print("📥 Downloading from repository...")
-            downloaded, version_to_be_installed = self.download(version=version)
-            if str(downloaded).endswith(".deb"):
-                print(f"📦 Installing .deb package: {downloaded}")
-                assert platform.system() == "Linux"
-                result = subprocess.run(f"sudo nala install -y {downloaded}", shell=True, capture_output=True, text=True)
-                success = result.returncode == 0 and result.stderr == ""
-                if not success:
-                    desc = "Installing .deb"
-                    print(f"❌ {desc} failed")
-                    if result.stdout:
-                        print(f"STDOUT: {result.stdout}")
-                    if result.stderr:
-                        print(f"STDERR: {result.stderr}")
-                    print(f"Return code: {result.returncode}")
-                print("🗑️  Cleaning up .deb package...")
-                downloaded.delete(sure=True)
-                print(f"✅ DEB package installation completed\n{'=' * 80}")
+            downloaded, version_to_be_installed = self.binary_download(version=version)
+            if str(downloaded).endswith(".deb"): install_deb_package(downloaded)
             else:
                 if platform.system() == "Windows":
-                    print("🪟 Installing on Windows...")
-                    exe = find_move_delete_windows(downloaded_file_path=downloaded, exe_name=exe_name, delete=True, rename_to=exe_name.replace(".exe", "") + ".exe")
+                    exe = find_move_delete_windows(downloaded_file_path=downloaded, tool_name=exe_name, delete=True, rename_to=exe_name.replace(".exe", "") + ".exe")
                 elif platform.system() in ["Linux", "Darwin"]:
                     system_name = "Linux" if platform.system() == "Linux" else "macOS"
                     print(f"🐧 Installing on {system_name}...")
@@ -221,33 +151,24 @@ class Installer:
                     error_msg = f"❌ ERROR: System {platform.system()} not supported"
                     print(error_msg)
                     raise NotImplementedError(error_msg)
-
                 _ = exe
                 if exe.name.replace(".exe", "") != exe_name.replace(".exe", ""):
                     from rich import print as pprint
                     from rich.panel import Panel
-
                     print("⚠️  Warning: Executable name mismatch")
                     pprint(Panel(f"Expected exe name: [red]{exe_name}[/red] \nAttained name: [red]{exe.name.replace('.exe', '')}[/red]", title="exe name mismatch", subtitle=repo_url))
                     new_exe_name = exe_name + ".exe" if platform.system() == "Windows" else exe_name
                     print(f"🔄 Renaming to correct name: {new_exe_name}")
                     exe.with_name(name=new_exe_name, inplace=True, overwrite=True)
-
-        print(f"💾 Saving version information to: {INSTALL_VERSION_ROOT.joinpath(exe_name)}")
         INSTALL_VERSION_ROOT.joinpath(exe_name).parent.mkdir(parents=True, exist_ok=True)
         INSTALL_VERSION_ROOT.joinpath(exe_name).write_text(version_to_be_installed or "unknown", encoding="utf-8")
-        print(f"✅ Installation completed successfully!\n{'=' * 80}")
-
-    def download(self, version: Optional[str]) -> tuple[PathExtended, str]:
+    def binary_download(self, version: Optional[str]) -> tuple[PathExtended, str]:
         exe_name = self._get_exe_name()
         repo_url = self.installer_data["repoURL"]
-        app_name = self.installer_data["appName"]
-        print(f"\n{'=' * 80}\n📥 DOWNLOADING: {exe_name} 📥\n{'=' * 80}")
-        
+        # app_name = self.installer_data["appName"]
         download_link: Optional[str] = None
         version_to_be_installed: Optional[str] = None
-        
-        if "github" not in repo_url or ".zip" in repo_url or ".tar.gz" in repo_url:
+        if "github" not in repo_url:
             # Direct download URL
             download_link = repo_url
             version_to_be_installed = "predefined_url"
@@ -259,71 +180,19 @@ class Installer:
             arch = get_normalized_arch()
             os_name = get_os_name()
             print(f"🧭 Detected system={os_name} arch={arch}")
-            
             # Use existing get_github_release method to get download link and version
             download_link, version_to_be_installed = self.get_github_release(repo_url, version)
-            
+            # print(f"🌟 Retrieved download link from GitHub: {download_link}")
+            # print(f"📦 Version to be installed: {version_to_be_installed}")
             if download_link is None:
                 raise ValueError(f"Could not retrieve download link for {exe_name} version {version or 'latest'}")
-            
             print(f"📦 Version to be installed: {version_to_be_installed}")
             print(f"🔗 Download URL: {download_link}")
-
         assert download_link is not None, "download_link must be set"
         assert version_to_be_installed is not None, "version_to_be_installed must be set"
-        print(f"📥 Downloading {app_name} from: {download_link}")
-        downloaded = PathExtended(download_link).download(folder=INSTALL_TMP_DIR).decompress()
-        print(f"✅ Download and extraction completed to: {downloaded}\n{'=' * 80}")
+        downloaded = download_and_prepare(download_link)
         return downloaded, version_to_be_installed
 
-    # --------------------------- Arch / template helpers ---------------------------
-
-    @staticmethod
-    def _get_repo_name_from_url(repo_url: str) -> str:
-        """Extract owner/repo from GitHub URL."""
-        try:
-            parsed = urlparse(repo_url)
-            path_parts = parsed.path.strip("/").split("/")
-            return f"{path_parts[0]}/{path_parts[1]}"
-        except (IndexError, AttributeError):
-            return ""
-
-    @staticmethod
-    def _fetch_github_release_data(repo_name: str, version: Optional[str] = None) -> Optional[dict[str, Any]]:
-        """Fetch release data from GitHub API using requests."""
-        import requests
-        
-        try:
-            if version and version.lower() != "latest":
-                # Fetch specific version
-                url = f"https://api.github.com/repos/{repo_name}/releases/tags/{version}"
-            else:
-                # Fetch latest release
-                url = f"https://api.github.com/repos/{repo_name}/releases/latest"
-            
-            response = requests.get(url, timeout=30)
-            
-            if response.status_code != 200:
-                print(f"❌ Failed to fetch data for {repo_name}: HTTP {response.status_code}")
-                return None
-                
-            response_data = response.json()
-            
-            # Check if API returned an error
-            if "message" in response_data:
-                if "API rate limit exceeded" in response_data.get("message", ""):
-                    print(f"🚫 Rate limit exceeded for {repo_name}")
-                    return None
-                elif "Not Found" in response_data.get("message", ""):
-                    print(f"🔍 No releases found for {repo_name}")
-                    return None
-                    
-            return response_data
-            
-        except (requests.RequestException, requests.Timeout, json.JSONDecodeError) as e:
-            print(f"❌ Error fetching {repo_name}: {e}")
-            return None
-
     def get_github_release(self, repo_url: str, version: Optional[str]) -> tuple[Optional[str], Optional[str]]:
         """
         Get download link and version from GitHub release based on fileNamePattern.
@@ -334,25 +203,39 @@ class Installer:
         filename_pattern = self.installer_data["fileNamePattern"][arch][os_name]
         if filename_pattern is None:
             raise ValueError(f"No fileNamePattern for {self._get_exe_name()} on {os_name} {arch}")
-        repo_name = self._get_repo_name_from_url(repo_url)
-        if not repo_name:
+        repo_info = get_repo_name_from_url(repo_url)
+        if not repo_info:
             print(f"❌ Invalid repository URL: {repo_url}")
             return None, None
-        release_data = self._fetch_github_release_data(repo_name, version)
-        if not release_data:
+        username, repository = repo_info
+        release_info = get_release_info(username, repository, version)
+        if not release_info:
             return None, None        
-        # print(release_data)
-        actual_version = release_data.get("tag_name", "unknown")
+        actual_version = release_info.get("tag_name", "unknown") or "unknown"
         filename = filename_pattern.format(version=actual_version)
 
         available_filenames: list[str] = []
-        for asset in release_data.get("assets", []):
-            an_dl = asset.get("browser_download_url", "NA")
+        for asset in release_info["assets"]:
+            an_dl = asset["browser_download_url"]
             available_filenames.append(an_dl.split("/")[-1])
         if filename not in available_filenames:
-            filename = filename_pattern.format(version=actual_version.replace("v", ""))
-            if filename not in available_filenames:
-                print(f"❌ Filename {filename} not found in assets: {available_filenames}")
+            candidates = [
+                filename,
+                filename_pattern.format(version=actual_version),
+                filename_pattern.format(version=actual_version.replace("v", "")),
+            ]
+
+            # Include hyphen/underscore variants
+            variants = []
+            for f in candidates:
+                variants += [f, f.replace("-", "_"), f.replace("_", "-")]
+
+            for f in variants:
+                if f in available_filenames:
+                    filename = f
+                    break
+            else:
+                print(f"❌ Filename not found in assets. Tried: {variants}\nAvailable: {available_filenames}")
                 return None, None
         browser_download_url = f"{repo_url}/releases/download/{actual_version}/{filename}"
         return browser_download_url, actual_version