machineconfig 3.92__py3-none-any.whl → 3.94__py3-none-any.whl

machineconfig/utils/installer_utils/installer_class.py

@@ -3,12 +3,14 @@ from machineconfig.utils.installer_utils.installer_abc import find_move_delete_l
 from machineconfig.utils.source_of_truth import INSTALL_TMP_DIR, INSTALL_VERSION_ROOT, LIBRARY_ROOT
 from machineconfig.utils.options import check_tool_exists
 from machineconfig.utils.io import read_json
-from machineconfig.utils.schemas.installer.installer_types import InstallerData, InstallerDataFiles
+from machineconfig.utils.schemas.installer.installer_types import InstallerData, InstallerDataFiles, get_os_name, get_normalized_arch
 
 import platform
 import subprocess
-from typing import Optional
+import json
+from typing import Optional, Any
 from pathlib import Path
+from urllib.parse import urlparse
 
 
 class Installer:
@@ -16,23 +18,21 @@ class Installer:
         self.installer_data: InstallerData = installer_data
 
     def __repr__(self) -> str:
-        exe_name = self.installer_data.get("exeName", "unknown")
-        app_name = self.installer_data.get("appName", "unknown")
-        repo_url = self.installer_data.get("repoURL", "unknown")
-        return f"Installer of {exe_name} {app_name} @ {repo_url}"
-
-    def get_description(self):
-        # old_version_cli = Terminal().run(f"{self.exe_name} --version").op.replace("\n", "")
-        # old_version_cli = os.system(f"{self.exe_name} --version").replace("\n", "")
-        exe_name = self.installer_data.get("exeName", "")
-        if not exe_name:
-            return "Invalid installer: missing exeName"
+        app_name = self.installer_data["appName"]
+        repo_url = self.installer_data["repoURL"]
+        return f"Installer of {app_name} @ {repo_url}"
 
+    def get_description(self) -> str:
+        exe_name = self._get_exe_name()
+        
         old_version_cli: bool = check_tool_exists(tool_name=exe_name)
         old_version_cli_str = "✅" if old_version_cli else "❌"
-        # name_version = f"{self.exe_name} {old_version_cli_str}"
-        doc = self.installer_data.get("doc", "No description")
+        doc = self.installer_data["doc"]
         return f"{exe_name:<12} {old_version_cli_str} {doc}"
+    
+    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():
@@ -63,14 +63,15 @@ class Installer:
             raise ValueError(f"Could not find installer data for {app_name}")
 
         installer = Installer(installer_data=selected_installer_data)
-        print(f"📦 Selected application: {selected_installer_data.get('exeName', 'unknown')}")
-        version = input(f"📝 Enter version to install for {selected_installer_data.get('exeName', 'unknown')} [latest]: ") or None
-        print(f"\n{'=' * 80}\n🚀 INSTALLING {selected_installer_data.get('exeName', 'UNKNOWN').upper()} 🚀\n{'=' * 80}")
+        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)
 
-    def install_robust(self, version: Optional[str]):
+    def install_robust(self, version: Optional[str]) -> str:
         try:
-            exe_name = self.installer_data.get("exeName", "unknown")
+            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()
@@ -90,67 +91,106 @@ class Installer:
                 return f"""📦️ 🤩 {exe_name} updated from {old_version_cli} ➡️ TO ➡️  {new_version_cli}"""
 
         except Exception as ex:
-            exe_name = self.installer_data.get("exeName", "unknown")
-            app_name = self.installer_data.get("appName", "unknown")
+            exe_name = self._get_exe_name()
+            app_name = self.installer_data["appName"]
             print(f"❌ ERROR: Installation failed for {exe_name}: {ex}")
             return f"""📦️ ❌ Failed to install `{app_name}` with error: {ex}"""
 
-    def install(self, version: Optional[str]):
-        exe_name = self.installer_data.get("exeName", "unknown")
-        repo_url = self.installer_data.get("repoURL", "")
+    def install(self, version: Optional[str]) -> None:
+        exe_name = self._get_exe_name()
+        repo_url = self.installer_data["repoURL"]
+        os_name = get_os_name()
+        arch = get_normalized_arch()
+        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}")
-        if repo_url == "CUSTOM":
-            print(f"🧩 Using custom installer for {exe_name}")
-            import machineconfig.jobs.python_custom_installers as python_custom_installers
-
-            installer_path = Path(python_custom_installers.__file__).parent.joinpath(exe_name + ".py")
-            if not installer_path.exists():
-                installer_path = Path(python_custom_installers.__file__).parent.joinpath("dev", exe_name + ".py")
-                print(f"🔍 Looking for installer in dev folder: {installer_path}")
-            else:
-                print(f"🔍 Found installer at: {installer_path}")
-
-            import runpy
-
-            print(f"⚙️  Executing function 'main' from '{installer_path}'...")
-            program: str = runpy.run_path(str(installer_path), run_name=None)["main"](version=version)
-            # print(program)
-            print("🚀 Running installation script...")
-            if platform.system() == "Linux":
-                script = "#!/bin/bash" + "\n" + program
-            else:
-                script = program
-            script_file = PathExtended.tmpfile(name="tmp_shell_script", suffix=".ps1" if platform.system() == "Windows" else ".sh", folder="tmp_scripts")
-            script_file.write_text(script, newline=None if platform.system() == "Windows" else "\n")
-            if platform.system() == "Windows":
-                start_cmd = "powershell"
-                full_command = f"{start_cmd} {script_file}"
+        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:
+                package_manager = installer_arch_os.split(" ", maxsplit=1)[0]
+                print(f"📦 Using package manager: {package_manager}")
+                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)
+                success = result.returncode == 0 and result.stderr == ""
+                if not success:
+                    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(f"✅ Package manager installation completed\n{'=' * 80}")
+            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
+                search_results = list(search_root.rglob(installer_arch_os))
+                if len(search_results) == 0:
+                    raise FileNotFoundError(f"Could not find installation script: {installer_arch_os}")
+                elif len(search_results) > 1:
+                    raise ValueError(f"Multiple installation scripts found for {installer_arch_os}: {search_results}")
+                installer_path = search_results[0]
+                print(f"📄 Found installation script: {installer_path}")
+                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}")
+                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")
+                    elif platform.system() in ["Linux", "Darwin"]:
+                        system_name = "Linux" if platform.system() == "Linux" else "macOS"
+                        print(f"🐧 Installing on {system_name}...")
+                        exe = find_move_delete_linux(downloaded=downloaded_object, tool_name=exe_name, delete=True, rename_to=exe_name)
+                    else:
+                        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)
+                    version_to_be_installed = "downloaded_binary"
+                    print(f"✅ Downloaded binary installation completed\n{'=' * 80}")
             else:
-                start_cmd = "bash"
-                full_command = f"{start_cmd} {script_file}"
-            subprocess.run(full_command, stdin=None, stdout=None, stderr=None, shell=True, text=True)
-            version_to_be_installed = str(version)
-            print(f"✅ Custom installation completed\n{'=' * 80}")
-
-        elif "npm " in repo_url or "pip " in repo_url or "winget " in repo_url:
-            package_manager = repo_url.split(" ", maxsplit=1)[0]
-            print(f"📦 Using package manager: {package_manager}")
-            desc = package_manager + " installation"
-            version_to_be_installed = package_manager + "Latest"
-            print(f"🚀 Running: {repo_url}")
-            result = subprocess.run(repo_url, shell=True, capture_output=True, text=True)
-            success = result.returncode == 0 and result.stderr == ""
-            if not success:
-                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(f"✅ Package manager installation completed\n{'=' * 80}")
-
+                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"):
@@ -195,55 +235,39 @@ class Installer:
 
         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, encoding="utf-8")
+        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]):
-        exe_name = self.installer_data.get("exeName", "unknown")
-        repo_url = self.installer_data.get("repoURL", "")
-        app_name = self.installer_data.get("appName", "unknown")
-        strip_v = self.installer_data.get("stripVersion", False)
-
+    def 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}")
-        download_link: Optional[Path] = None
+        
+        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:
-            download_link = Path(repo_url)
+            # Direct download URL
+            download_link = repo_url
             version_to_be_installed = "predefined_url"
             print(f"🔗 Using direct download URL: {download_link}")
             print(f"📦 Version to be installed: {version_to_be_installed}")
-        elif self._any_direct_http_template():
-            template, arch = self._select_template()
-            if not template.startswith("http"):
-                # Fall back to github-style handling below
-                pass
-            else:
-                download_link = Path(template)
-                version_to_be_installed = "predefined_url"
-                system_name = self._system_name()
-                print(f"🧭 Detected system={system_name} arch={arch}")
-                print(f"🔗 Using architecture-specific direct URL: {download_link}")
-                print(f"📦 Version to be installed: {version_to_be_installed}")
-                # continue to unified download logic below
-
         else:
+            # GitHub repository
             print("🌐 Retrieving release information from GitHub...")
-            release_url, version_to_be_installed = Installer.get_github_release(repo_url=repo_url, version=version)
+            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)
+            
+            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"📦 Release URL: {release_url}")
-
-            version_to_be_installed_stripped = version_to_be_installed.replace("v", "") if strip_v else version_to_be_installed
-            version_to_be_installed_stripped = version_to_be_installed_stripped.replace("ipinfo-", "")
-
-            template, arch = self._select_template()
-            system_name = self._system_name()
-            file_name = template.format(version_to_be_installed_stripped)
-            print(f"🧭 Detected system={system_name} arch={arch}")
-            print(f"📄 Using template: {template}")
-            print(f"🗂️  Resolved file name: {file_name}")
-
-            print(f"📄 File name: {file_name}")
-            download_link = release_url.joinpath(file_name)
+            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"
@@ -253,100 +277,89 @@ class Installer:
         return downloaded, version_to_be_installed
 
     # --------------------------- Arch / template helpers ---------------------------
-    def _normalized_arch(self) -> str:
-        arch_raw = platform.machine().lower()
-        if arch_raw in ("x86_64", "amd64"):
-            return "amd64"
-        if arch_raw in ("aarch64", "arm64", "armv8", "armv8l"):
-            return "arm64"
-        return arch_raw
-
-    def _system_name(self) -> str:
-        sys_ = platform.system()
-        if sys_ == "Darwin":
-            return "macOS"
-        return sys_
-
-    def _any_direct_http_template(self) -> bool:
-        filename_templates = self.installer_data.get("filenameTemplate", {})
-        templates: list[str] = []
-
-        for arch_templates in filename_templates.values():
-            templates.extend([t for t in arch_templates.values() if t])
-
-        return any(t for t in templates if t.startswith("http"))
-
-    def _select_template(self) -> tuple[str, str]:
-        sys_name = platform.system()
-        arch = self._normalized_arch()
-
-        filename_templates = self.installer_data.get("filenameTemplate", {})
-
-        # Get templates for each architecture
-        amd64_templates = filename_templates.get("amd64", {})
-        arm64_templates = filename_templates.get("arm64", {})
-
-        # mapping logic
-        candidates: list[str] = []
-        template: Optional[str] = None
-
-        if sys_name == "Windows":
-            if arch == "arm64" and arm64_templates.get("windows"):
-                template = arm64_templates["windows"]
-            else:
-                template = amd64_templates.get("windows", "")
-            candidates = ["arm64.windows", "amd64.windows"]
-        elif sys_name == "Linux":
-            if arch == "arm64" and arm64_templates.get("linux"):
-                template = arm64_templates["linux"]
-            else:
-                template = amd64_templates.get("linux", "")
-            candidates = ["arm64.linux", "amd64.linux"]
-        elif sys_name == "Darwin":
-            if arch == "arm64" and arm64_templates.get("macos"):
-                template = arm64_templates["macos"]
-            elif arch == "amd64" and amd64_templates.get("macos"):
-                template = amd64_templates["macos"]
-            else:
-                # fallback between available mac templates
-                template = arm64_templates.get("macos") or amd64_templates.get("macos") or ""
-            candidates = ["arm64.macos", "amd64.macos"]
-        else:
-            raise NotImplementedError(f"System {sys_name} not supported")
-
-        if not template:
-            raise ValueError(f"No filename template available for system={sys_name} arch={arch}. Checked {candidates}")
-
-        return template, arch
 
     @staticmethod
-    def get_github_release(repo_url: str, version: Optional[str] = None):
-        print(f"\n{'=' * 80}\n🔍 GITHUB RELEASE DETECTION 🔍\n{'=' * 80}")
-        print(f"🌐 Inspecting releases at: {repo_url}")
-        # with console.status("Installing..."):  # makes troubles on linux when prompt asks for password to move file to /usr/bin
-        if version is None:
-            # see this: https://api.github.com/repos/cointop-sh/cointop/releases/latest
-            print("🔍 Finding latest version...")
-            import requests  # https://docs.github.com/en/repositories/releasing-projects-on-github/linking-to-releases
-
-            _latest_version = requests.get(str(repo_url) + "/releases/latest", timeout=10).url.split("/")[
-                -1
-            ]  # this is to resolve the redirection that occures: https://stackoverflow.com/questions/36070821/how-to-get-redirect-url-using-python-requests
-            version_to_be_installed = _latest_version
-            print(f"✅ Latest version detected: {version_to_be_installed}")
-            # print(version_to_be_installed)
-        else:
-            version_to_be_installed = version
-            print(f"📝 Using specified version: {version_to_be_installed}")
+    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 ""
 
-        release_url = Path(repo_url + "/releases/download/" + version_to_be_installed)
-        print(f"🔗 Release download URL: {release_url}\n{'=' * 80}")
-        return release_url, version_to_be_installed
+    @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.
+        Returns (download_url, actual_version)
+        """
+        arch = get_normalized_arch()
+        os_name = get_os_name()
+        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:
+            print(f"❌ Invalid repository URL: {repo_url}")
+            return None, None
+        release_data = self._fetch_github_release_data(repo_name, version)
+        if not release_data:
+            return None, None        
+        # print(release_data)
+        actual_version = release_data.get("tag_name", "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")
+            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}")
+                return None, None
+        browser_download_url = f"{repo_url}/releases/download/{actual_version}/{filename}"
+        return browser_download_url, actual_version
 
     @staticmethod
-    def check_if_installed_already(exe_name: str, version: str, use_cache: bool):
+    def check_if_installed_already(exe_name: str, version: Optional[str], use_cache: bool) -> tuple[str, str, str]:
         print(f"\n{'=' * 80}\n🔍 CHECKING INSTALLATION STATUS: {exe_name} 🔍\n{'=' * 80}")
-        version_to_be_installed = version
         INSTALL_VERSION_ROOT.joinpath(exe_name).parent.mkdir(parents=True, exist_ok=True)
         tmp_path = INSTALL_VERSION_ROOT.joinpath(exe_name)
 
@@ -368,18 +381,18 @@ class Installer:
                 existing_version = result.stdout.strip()
                 print(f"📄 Detected installed version: {existing_version}")
 
-        if existing_version is not None:
-            if existing_version == version_to_be_installed:
-                print(f"✅ {exe_name} is up to date (version {version_to_be_installed})")
+        if existing_version is not None and version is not None:
+            if existing_version == version:
+                print(f"✅ {exe_name} is up to date (version {version})")
                 print(f"📂 Version information stored at: {INSTALL_VERSION_ROOT}")
-                return ("✅ Up to date", version.strip(), version_to_be_installed.strip())
+                return ("✅ Up to date", version.strip(), version.strip())
             else:
-                print(f"🔄 {exe_name} needs update: {existing_version.rstrip()} → {version_to_be_installed}")
-                tmp_path.write_text(version_to_be_installed, encoding="utf-8")
-                return ("❌ Outdated", existing_version.strip(), version_to_be_installed.strip())
+                print(f"🔄 {exe_name} needs update: {existing_version.rstrip()} → {version}")
+                tmp_path.write_text(version, encoding="utf-8")
+                return ("❌ Outdated", existing_version.strip(), version.strip())
         else:
-            print(f"📦 {exe_name} is not installed. Will install version: {version_to_be_installed}")
-            tmp_path.write_text(version_to_be_installed, encoding="utf-8")
+            print(f"📦 {exe_name} is not installed. Will install version: {version}")
+            # tmp_path.write_text(version, encoding="utf-8")
 
         print(f"{'=' * 80}")
-        return ("⚠️ NotInstalled", "None", version_to_be_installed.strip())
+        return ("⚠️ NotInstalled", "None", version or "unknown")

machineconfig/utils/schemas/installer/installer_types.py

@@ -1,20 +1,43 @@
-from typing import TypedDict, Literal, TypeAlias
+from typing import TypedDict, Literal, TypeAlias, Optional
+import platform
 
 
-APP_INSTALLER_CATEGORY: TypeAlias = Literal["OS_SPECIFIC", "OS_GENERIC", "CUSTOM", "OS_SPECIFIC_DEV", "OS_GENERIC_DEV", "CUSTOM_DEV"]
+APP_INSTALLER_CATEGORY: TypeAlias = Literal["GITHUB_ESSENTIAL", "CUSTOM_ESSENTIAL", "GITHUB_DEV", "CUSTOM_DEV"]
 CPU_ARCHITECTURES: TypeAlias = Literal["amd64", "arm64"]
 OPERATING_SYSTEMS: TypeAlias = Literal["windows", "linux", "macos"]
 
 
 class InstallerData(TypedDict):
     appName: str
-    repoURL: str
     doc: str
-    filenameTemplate: dict[CPU_ARCHITECTURES, dict[OPERATING_SYSTEMS, str]]
-    stripVersion: bool
-    exeName: str
+    repoURL: str
+    fileNamePattern: dict[CPU_ARCHITECTURES, dict[OPERATING_SYSTEMS, Optional[str]]]
 
 
 class InstallerDataFiles(TypedDict):
     version: str
     installers: list[InstallerData]
+
+
+def get_os_name() -> OPERATING_SYSTEMS:
+    """Get the operating system name in the format expected by the github parser."""
+    sys_name = platform.system()
+    if sys_name == "Windows":
+        return "windows"
+    elif sys_name == "Linux":
+        return "linux"
+    elif sys_name == "Darwin":
+        return "macos"
+    else:
+        raise NotImplementedError(f"System {sys_name} not supported")
+
+
+def get_normalized_arch() -> CPU_ARCHITECTURES:
+    """Get the normalized CPU architecture."""
+    arch_raw = platform.machine().lower()
+    if arch_raw in ("x86_64", "amd64"):
+        return "amd64" 
+    if arch_raw in ("aarch64", "arm64", "armv8", "armv8l"):
+        return "arm64"
+    # Default to amd64 if unknown architecture
+    return "amd64"

{machineconfig-3.92.dist-info → machineconfig-3.94.dist-info}/METADATA

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