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

machineconfig/setup_windows/uv.ps1

@@ -7,4 +7,11 @@ if (-not (Test-Path -Path "$HOME\.local\bin\uv.exe")) {
     Write-Output "uv binary found, updating..."
     & "$HOME\.local\bin\uv.exe" self update
 }
-& "$HOME\.local\bin\uv.exe" python install 3.14
+
+# `C:\Users\aalsaf01\.local\bin` is not on your PATH. To use installed Python executables, run `$env:PATH = "C:\Users\aalsaf01\.local\bin;$env:PATH"` or `uv python update-shell`.
+& "$env:USERPROFILE\.local\bin\uv.exe" python update-shell
+$env:Path = [System.Environment]::GetEnvironmentVariable('Path', 'Machine') + ';' + [System.Environment]::GetEnvironmentVariable('Path', 'User')
+
+# & "$HOME\.local\bin\uv.exe" python install 3.14
+uv python install 3.14
+

machineconfig/setup_windows/web_shortcuts/interactive.ps1

@@ -3,16 +3,16 @@
 iex (iwr "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_windows/uv.ps1").Content
 iex (iwr "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/scripts/windows/wrap_mcfg.ps1").Content
 
-function devops   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.53" devops $args }
-function cloud    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.53" cloud $args }
-function agents   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.53" agents $args }
-function sessions { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.53" sessions $args }
-function ftpx     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.53" ftpx $args }
-function fire     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.53" fire $args }
-function croshell { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.53" croshell $args }
-function utils    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.53" utils $args }
-function terminal { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.53" terminal $args }
-function msearch  { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.53" msearch $args }
+function devops   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.69" devops $args }
+function cloud    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.69" cloud $args }
+function agents   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.69" agents $args }
+function sessions { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.69" sessions $args }
+function ftpx     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.69" ftpx $args }
+function fire     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.69" fire $args }
+function croshell { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.69" croshell $args }
+function utils    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.69" utils $args }
+function terminal { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.69" terminal $args }
+function msearch  { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.69" msearch $args }
 
 function d { wrap_in_shell_script devops @args }
 function c { wrap_in_shell_script cloud @args }
@@ -25,5 +25,6 @@ function u { wrap_in_shell_script utils @args }
 function t { wrap_in_shell_script terminal @args }
 function ms { wrap_in_shell_script msearch @args }
 
-devops self
 Write-Host "mcfg command aliases are now defined in this PowerShell session."
+
+devops self interactive

machineconfig/setup_windows/web_shortcuts/quick_init.ps1

@@ -1,7 +1,8 @@
 
 iex (iwr "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_windows/uv.ps1").Content
 # iex (iwr "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/scripts/windows/wrap_mcfg.ps1").Content
-uv tool install --upgrade  --python 3.14 machineconfig both
+
+uv tool install --upgrade  --python 3.14 machineconfig
 
 devops install --group sysabc
 
@@ -12,4 +13,5 @@ devops config shell
 devops config shell --which nushell
 
 wt  # start Windows Terminal to pick up config changes
-devops install --group termabc
+devops install --group termabc 
+devops install --group gui

machineconfig/utils/accessories.py

@@ -1,4 +1,3 @@
-from pathlib import Path
 from typing import Optional, Any
 
 from datetime import datetime, timezone, timedelta
@@ -96,14 +95,18 @@ def human_friendly_dict(d: dict[str, Any]) -> dict[str, Any]:
     return result
 
 
-def get_repo_root(path: Path) -> Optional[Path]:
+def get_repo_root(path: "Path") -> Optional["Path"]:
     from git import Repo, InvalidGitRepositoryError
-
     try:
-        repo = Repo(str(path), search_parent_directories=True)
+        repo = Repo(path, search_parent_directories=True)
         root = repo.working_tree_dir
         if root is not None:
+            from pathlib import Path
             return Path(root)
     except InvalidGitRepositoryError:
         pass
     return None
+
+
+if __name__ == "__main__":
+    from pathlib import Path

machineconfig/utils/code.py

@@ -38,14 +38,16 @@ def get_uv_command_executing_python_script(python_script: str, uv_with: Optional
         uv_project_dir_arg = "--project" + f' "{uv_project_dir}"'
     else:
         uv_project_dir_arg = ""
-    print_code_string = lambda_to_python_script(lambda: print_code(code=python_script, lexer="python", desc="Temporary Python Script", subtitle="Executing via shell script"), in_global=True, import_module=False)
+    print_code_string = lambda_to_python_script(lambda: print_code(code=python_script, lexer="python", desc="Temporary Python Script", subtitle="Executing via shell script"),
+                                                in_global=True, import_module=False)
     python_file.write_text(print_code_string + "\n" + python_script, encoding="utf-8")
     shell_script = f"""uv run {uv_with_arg} {uv_project_dir_arg}  {str(python_file)} """
     return shell_script, python_file
 
 
 def run_lambda_function(lmb: Callable[[], Any], uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> None:
-    code = lambda_to_python_script(lmb, in_global=True, import_module=False)
+    code = lambda_to_python_script(lmb,
+in_global=True, import_module=False)
     uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=uv_with, uv_project_dir=uv_project_dir)
     run_shell_script(uv_command)
 def run_python_script_in_marimo(py_script: str, uv_project_with: Optional[str]):
@@ -132,7 +134,7 @@ def exit_then_run_shell_script(script: str, strict: bool = False):
             op_program_path = Path.home().joinpath("tmp_results", "tmp_scripts", "manual_run", f"manual_script_{randstr()}{suffix}")
             op_program_path.parent.mkdir(parents=True, exist_ok=True)
             op_program_path.write_text(script, encoding="utf-8")
-            print_code(script, lexer=lexer, desc="script to run manually")
+            print_code(code=script, lexer=lexer, desc="script to run manually")
             console.print("[bold yellow]⚠️  STRICT MODE:[/bold yellow] [cyan]Please run the script manually via your shell by executing:[/cyan]")
             console.print(f"[green]{str(op_program_path)}[/green]")
             console.print("[red]❌ OP_PROGRAM_PATH environment variable is not set in strict mode.[/red]")
@@ -145,7 +147,7 @@ def exit_then_run_shell_script(script: str, strict: bool = False):
         op_program_path.write_text(script, encoding="utf-8")
         console.print("[cyan]🚀 Handing over to shell script runner via OP_PROGRAM_PATH:[/cyan]")
         console.print(f"[bold green]{str(op_program_path)}[/bold green]")
-        print_code(script, lexer="shell", desc="script to run via OP_PROGRAM_PATH")
+        print_code(code=script, lexer="shell", desc="script to run via OP_PROGRAM_PATH")
     else:
         if op_program_path is not None and exists:
             console.print(f"[yellow]⚠️  OP_PROGRAM_PATH @ {str(op_program_path)} already exists.[/yellow] [cyan]Falling back to direct execution.[/cyan]")

machineconfig/utils/files/headers.py

@@ -25,7 +25,7 @@ def print_header():
     table.add_row("Virtual Environment", os.getenv('VIRTUAL_ENV', 'None'))
     table.add_row("Running @", str(Path.cwd()))
 
-    from machineconfig.utils.installer import get_machineconfig_version
+    from machineconfig.utils.installer_utils.installer_runner import get_machineconfig_version
 
     console.print(Panel(table, title=f"[bold blue]✨ 🐊 Machineconfig Shell {get_machineconfig_version()} ✨ Made with 🐍 | Built with ❤️[/bold blue]", border_style="blue"))
 def print_logo(logo: str):
@@ -44,7 +44,7 @@ def print_logo(logo: str):
             _default_art = Path(random.choice(glob.glob(str(Path(__file__).parent.joinpath("art", "*")))))
             print(_default_art.read_text())
     elif platform.system() in ["Linux", "Darwin"]:  # Explicitly handle both Linux and macOS
-        from machineconfig.utils.installer_utils.installer_abc import is_executable_in_path
+        from machineconfig.utils.installer_utils.installer_locator_utils import is_executable_in_path
         avail_cowsay = is_executable_in_path("cowsay")
         avail_lolcat = is_executable_in_path("lolcat")
         avail_boxes = is_executable_in_path("boxes")

machineconfig/utils/installer_utils/install_from_url.py

@@ -0,0 +1,180 @@
+
+
+import platform
+from urllib.parse import urlparse
+
+import typer
+from typing import Optional, TypeAlias, cast
+
+from machineconfig.utils.installer_utils.installer_class import install_deb_package
+from machineconfig.utils.installer_utils.installer_locator_utils import find_move_delete_linux, find_move_delete_windows
+from machineconfig.utils.path_extended import DECOMPRESS_SUPPORTED_FORMATS, PathExtended
+from machineconfig.utils.source_of_truth import INSTALL_TMP_DIR, INSTALL_VERSION_ROOT
+
+SUPPORTED_GITHUB_HOSTS = {"github.com", "www.github.com"}
+
+GitHubAsset: TypeAlias = dict[str, object]
+GitHubRelease: TypeAlias = dict[str, object]
+
+
+def _extract_repo_name(github_url: str) -> str:
+    parsed = urlparse(github_url)
+    parts = [part for part in parsed.path.strip("/").split("/") if part]
+    if len(parts) < 2:
+        return ""
+    owner, repo = parts[0], parts[1]
+    if repo == "":
+        return ""
+    return f"{owner}/{repo}"
+
+
+def _fetch_latest_release(repo_name: str) -> Optional[GitHubRelease]:
+    import json
+    import requests
+    try:
+        response = requests.get(f"https://api.github.com/repos/{repo_name}/releases/latest", timeout=30)
+    except requests.RequestException:
+        return None
+    if response.status_code != 200:
+        return None
+    try:
+        data = response.json()
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(data, dict):
+        return None
+    return cast(GitHubRelease, data)
+
+
+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: str) -> 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
+    asset_clean = asset_name.lower()
+    asset_filtered = "".join(char for char in asset_clean if char.isalnum())
+    if asset_filtered:
+        return asset_filtered
+    return "githubapp"
+
+
+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_name = _extract_repo_name(github_url)
+    if repo_name == "":
+        console.print(Panel(f"Invalid GitHub URL: {github_url}", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    console.print(Panel(f"Fetching latest release for [green]{repo_name}[/green]", title="🌐 GitHub", border_style="blue"))
+    release_raw = _fetch_latest_release(repo_name)
+    if not release_raw:
+        console.print(Panel("No releases available for this repository.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    release = release_raw
+    assets_value = release.get("assets", [])
+    assets: list[GitHubAsset] = []
+    if isinstance(assets_value, list):
+        for asset in assets_value:
+            if isinstance(asset, dict):
+                typed_asset: GitHubAsset = {}
+                name_value = asset.get("name")
+                url_value = asset.get("browser_download_url")
+                size_value = asset.get("size")
+                content_value = asset.get("content_type")
+                if isinstance(name_value, str):
+                    typed_asset["name"] = name_value
+                if isinstance(url_value, str):
+                    typed_asset["browser_download_url"] = url_value
+                if isinstance(size_value, int):
+                    typed_asset["size"] = size_value
+                if isinstance(content_value, str):
+                    typed_asset["content_type"] = content_value
+                assets.append(typed_asset)
+    if not assets:
+        console.print(Panel("No downloadable assets found in the latest release.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    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"))
+        raise typer.Exit(1)
+    options_map: dict[str, GitHubAsset] = {}
+    for asset in selection_pool:
+        name = asset.get("name")
+        download_url = asset.get("browser_download_url")
+        if not isinstance(name, str) or not isinstance(download_url, str) or name == "" or download_url == "":
+            continue
+        size_value = asset.get("size")
+        size = size_value if isinstance(size_value, int) else 0
+        label = f"{name} [{_format_size(size)}]"
+        options_map[label] = asset
+    if not options_map:
+        console.print(Panel("Release assets lack download URLs.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    selection_label = choose_from_options(options=list(options_map.keys()), msg="Select a release asset", multi=False, header="📦 GitHub Release Assets", fzf=True)
+    selected_asset = options_map[selection_label]
+    download_url_value = selected_asset.get("browser_download_url")
+    asset_name_value = selected_asset.get("name")
+    if not isinstance(download_url_value, str) or download_url_value == "":
+        console.print(Panel("Selected asset lacks a download URL.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    asset_name = asset_name_value if isinstance(asset_name_value, str) else "github_binary"
+    version_value = release.get("tag_name")
+    version = version_value if isinstance(version_value, str) and version_value != "" else "latest"
+    console.print(Panel(f"Downloading [cyan]{asset_name}[/cyan]", title="⬇️ Download", border_style="magenta"))
+    archive_path = PathExtended(download_url_value).download(folder=INSTALL_TMP_DIR)
+    extracted_path = archive_path
+    if extracted_path.suffix in DECOMPRESS_SUPPORTED_FORMATS:
+        extracted_path = archive_path.decompress()
+        archive_path.delete(sure=True)
+        if extracted_path.is_dir():
+            nested_items = list(extracted_path.glob("*"))
+            if len(nested_items) == 1:
+                nested_path = PathExtended(nested_items[0])
+                if nested_path.suffix in DECOMPRESS_SUPPORTED_FORMATS:
+                    extracted_path = nested_path.decompress()
+                    nested_path.delete(sure=True)
+    if extracted_path.suffix == ".deb":
+        install_deb_package(extracted_path)
+        tool_name_deb = _derive_tool_name(repo_name, asset_name)
+        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, exe_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"))
+            raise typer.Exit(1)
+    except IndexError:
+        if system_name == "Windows":
+            installed_path = find_move_delete_windows(downloaded_file_path=extracted_path, exe_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
+    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"))

machineconfig/utils/installer_utils/installer_class.py

@@ -1,7 +1,6 @@
-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.path_extended import PathExtended, DECOMPRESS_SUPPORTED_FORMATS
 from machineconfig.utils.source_of_truth import INSTALL_TMP_DIR, INSTALL_VERSION_ROOT
-from machineconfig.utils.installer_utils.installer_abc import check_tool_exists
+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
 
 import platform
@@ -11,6 +10,28 @@ from typing import Optional, Any
 from urllib.parse import urlparse
 
 
+
+def install_deb_package(downloaded: PathExtended) -> None:
+    from rich import print as rprint
+    from rich.panel import Panel
+    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:
+        from rich.console import Group
+        desc = "Installing .deb"
+        sub_panels = []
+        if result.stdout:
+            sub_panels.append(Panel(result.stdout, title="STDOUT", style="blue"))
+        if result.stderr:
+            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"))
+    print("🗑️  Cleaning up .deb package...")
+    downloaded.delete(sure=True)
+
+
 class Installer:
     def __init__(self, installer_data: InstallerData):
         self.installer_data: InstallerData = installer_data
@@ -42,10 +63,8 @@ class Installer:
             result_new = subprocess.run(f"{exe_name} --version", shell=True, capture_output=True, text=True)
             new_version_cli = result_new.stdout.strip()
             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()
@@ -64,23 +83,24 @@ class Installer:
         version_to_be_installed: str = "unknown"  # Initialize to ensure it's always bound
         if repo_url == "CMD":
             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: {installer_arch_os}")
                 desc = package_manager + " installation"
                 version_to_be_installed = package_manager + "Latest"
-                result = subprocess.run(installer_arch_os, shell=True, capture_output=True, text=False)
-                # from machineconfig.utils.code import run_shell_script
-                # result = run_shell_script(installer_arch_os)
-                success = result.returncode == 0 and result.stderr == "".encode()
+                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}")
+                        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
@@ -106,9 +126,14 @@ class Installer:
                     runpy.run_path(str(installer_path), run_name=None)["main"](self.installer_data, version=version)
                     version_to_be_installed = str(version)
             elif installer_arch_os.startswith("https://"):  # its a url to be downloaded
-                downloaded_object = PathExtended(installer_arch_os).download(folder=INSTALL_TMP_DIR)
+                # downloaded_object = PathExtended(installer_arch_os).download(folder=INSTALL_TMP_DIR)
+                from machineconfig.scripts.python.helpers_utils.download import download
+                downloaded_object = download(installer_arch_os, output_dir=str(INSTALL_TMP_DIR))
+                if downloaded_object is None:
+                    raise ValueError(f"Failed to download from URL: {installer_arch_os}")
                 # object is either a zip containing a binary or a straight out binary.
-                if downloaded_object.suffix in [".zip", ".tar.gz"]:
+                downloaded_object = PathExtended(downloaded_object)
+                if downloaded_object.suffix in DECOMPRESS_SUPPORTED_FORMATS:
                     downloaded_object = downloaded_object.decompress()
                 if downloaded_object.suffix in [".exe", ""]:  # likely an executable
                     if platform.system() == "Windows":
@@ -131,26 +156,17 @@ 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"
+                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}"
-            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)
+            downloaded, version_to_be_installed = self.binary_download(version=version)
+            if str(downloaded).endswith(".deb"): install_deb_package(downloaded)
             else:
                 if platform.system() == "Windows":
                     exe = find_move_delete_windows(downloaded_file_path=downloaded, exe_name=exe_name, delete=True, rename_to=exe_name.replace(".exe", "") + ".exe")
@@ -173,13 +189,13 @@ class Installer:
                     exe.with_name(name=new_exe_name, inplace=True, overwrite=True)
         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")
-    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"]
         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 or (any(ext in repo_url for ext in DECOMPRESS_SUPPORTED_FORMATS)):
             # Direct download URL
             download_link = repo_url
             version_to_be_installed = "predefined_url"
@@ -200,10 +216,11 @@ class Installer:
         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"
         downloaded = PathExtended(download_link).download(folder=INSTALL_TMP_DIR).decompress()
+        if downloaded.is_dir() and len(downloaded.search("*", r=True)) == 1:
+            only_file_in = next(downloaded.glob("*"))
+            if only_file_in.is_file() and only_file_in.suffix in DECOMPRESS_SUPPORTED_FORMATS:  # further decompress
+                downloaded = only_file_in.decompress()
         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."""
@@ -218,23 +235,16 @@ class Installer:
     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
+            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
+            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", ""):