machineconfig 6.82__py3-none-any.whl → 8.51__py3-none-any.whl

machineconfig/jobs/installer/python_scripts/hx.py

@@ -0,0 +1,214 @@
+"""
+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_locator_utils import WINDOWS_INSTALL_PATH
+from typing import Optional
+import platform
+
+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 = ["python", "nu", "bash", "lua", "powershell", "json", "json5", "toml", "ini", "yaml", "markdown", "markdoc", "markdown_inline"]
+config_dict: InstallerData = {
+    "appName": "hx",
+    "repoURL": "CMD",
+    "doc": "Helix is a post-modern modal text editor.",
+    "fileNamePattern": {
+        "amd64": {
+            "linux": "helix-{version}-x86_64-linux.tar.xz",
+            "macos": "helix-{version}-x86_64-macos.tar.xz",
+            "windows": "helix-{version}-x86_64-windows.zip",
+        },
+        "arm64": {
+            "linux": "helix-{version}-arm64-linux.tar.xz",
+            "macos": "helix-{version}-arm64-macos.tar.xz",
+            "windows": "helix-{version}-arm64-windows.zip",
+        },
+    },
+}
+
+
+def main(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))
+
+    config_dict_copy = config_dict.copy()
+    config_dict_copy["repoURL"] = "https://github.com/helix-editor/helix"
+    inst = Installer(installer_data=config_dict_copy)
+
+    print("\n📥 [Step 1/5] Downloading Helix editor...")
+    downloaded, _version_to_be_installed = inst.binary_download(version=version)
+    print("   ✨ Download complete.")
+
+    print("\n🔍 [Step 2/5] Locating executable and components...")
+    if platform.system() == "Windows":
+        hx_file_search = [p for p in downloaded.rglob("hx.exe") if p.is_file()]
+    else:
+        hx_file_search = [p for p in downloaded.rglob("hx") if p.is_file()]
+
+    if not hx_file_search:
+        console.print(Panel("❌ ERROR: Could not find 'hx' executable in downloaded files.", title="Error", expand=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"
+
+    if not runtime.exists():
+        console.print(Panel(f"❌ ERROR: 'runtime' directory not found at expected location: {runtime}", title="Error", expand=False))
+        raise FileNotFoundError(f"'runtime' directory not found at expected location: {runtime}")
+    if not contrib.exists():
+        console.print(Panel(f"❌ ERROR: 'contrib' directory not found at expected location: {contrib}", title="Error", expand=False))
+        raise FileNotFoundError(f"'contrib' directory not found at expected location: {contrib}")
+    print("   ✨ Executable and components located.")
+
+    print("\n🗑️  [Step 3/5] Cleaning up previous installation (if any)...")
+    if platform.system() in ["Linux", "Darwin"]:
+        runtime_path = PathExtended.home().joinpath(".config/helix/runtime")
+        contrib_path = PathExtended.home().joinpath(".config/helix/contrib")
+        target_config_dir = PathExtended.home().joinpath(".config/helix").expanduser()
+        target_config_dir.mkdir(parents=True, exist_ok=True)
+    elif platform.system() == "Windows":
+        runtime_path = PathExtended.home().joinpath("AppData/Roaming/helix/runtime")
+        contrib_path = PathExtended.home().joinpath("AppData/Roaming/helix/contrib")
+        target_config_dir = PathExtended.home().joinpath("AppData/Roaming/helix").expanduser()
+        target_config_dir.mkdir(parents=True, exist_ok=True)
+    else:
+        console.print(
+            Panel(
+                f"""⚠️ WARNING | Unsupported operating system: {platform.system()}
+          | Installation aborted.""",
+                title="Warning",
+                expand=False,
+            )
+        )
+        print("\n🧹 [Step 5/5] Cleaning up temporary download files...")
+        downloaded.delete(sure=True)
+        print("   ✨ Cleanup complete.")
+        return f"Error: Unsupported OS: {platform.system()}"
+
+    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:
+            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:
+                        lang_file = child.joinpath(f"{a_language}.so")
+                        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(
+                f"""✅ SUCCESS | Helix editor installed successfully on {system_name}!
+
+📂 Executable: {target_bin_path / exe_name}
+🔧 Config:     {target_config_dir}""",
+                title="Success",
+                expand=False,
+            )
+        )
+    elif platform.system() == "Windows":
+        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:
+            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:
+                        lang_file = child.joinpath(f"{a_language}.dll")
+                        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!
+📂 Executable: {target_bin_path / exe_name}
+🔧 Config:     {target_config_dir}""",
+                title="Success",
+                expand=False,
+            )
+        )
+    else:
+        console.print(
+            Panel(
+                f"""⚠️ WARNING | Unsupported operating system: {platform.system()}
+          | Installation aborted.""",
+                title="Warning",
+                expand=False,
+            )
+        )
+        print("\n🧹 [Step 5/5] Cleaning up temporary download files...")
+        downloaded.delete(sure=True)
+        print("   ✨ Cleanup complete.")
+        return f"Error: Unsupported OS: {platform.system()}"
+
+    print("\n🧹 [Step 5/5] Cleaning up temporary download files...")
+    downloaded.delete(sure=True)
+    print("   ✨ Cleanup complete.")
+
+    console.print(Panel("🎉 Installation Finished Successfully! 🎉", title="Finished", expand=False))
+    return ""
+
+
+if __name__ == "__main__":
+    pass

machineconfig/jobs/installer/{custom_dev → python_scripts}/nerdfont.py

@@ -32,7 +32,7 @@ def main(installer_data: InstallerData, version: Optional[str]) -> None:
 
     if current_platform == "Windows":
         console.print("🪟 Installing Nerd Fonts on Windows...", style="bold")
-        from machineconfig.jobs.installer.custom_dev.nerfont_windows_helper import install_nerd_fonts
+        from machineconfig.jobs.installer.python_scripts.nerfont_windows_helper import install_nerd_fonts
 
         try:
             install_nerd_fonts()
@@ -108,4 +108,4 @@ def main(installer_data: InstallerData, version: Optional[str]) -> None:
 
 
 if __name__ == "__main__":
-    pass
+    main(1, None)  # type: ignore

machineconfig/jobs/installer/{custom_dev → python_scripts}/nerfont_windows_helper.py

@@ -13,12 +13,12 @@ from rich.console import Console
 from rich.panel import Panel
 
 from machineconfig.utils.path_extended import PathExtended
+from machineconfig.utils.accessories import randstr
 from machineconfig.utils.source_of_truth import LIBRARY_ROOT
 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",
@@ -38,14 +38,6 @@ nerd_fonts: InstallerData = {
 }
 
 
-# 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()
 
 
@@ -80,22 +72,28 @@ def _list_installed_fonts() -> list[str]:
 
 
 def _missing_required_fonts(installed_fonts: Iterable[str]) -> list[str]:
-    """Check which required font patterns are missing from installed fonts.
-    
+    """Check which feature fonts are missing from installed fonts.
+
     Args:
         installed_fonts: List of installed font names
-        
+
     Returns:
-        List of missing font patterns
+        List of descriptions for missing font groups
     """
-    import re
 
-    installed_norm = [f.lower().replace(" ", "") for f in installed_fonts]
+    def _normalize(name: str) -> str:
+        return name.lower().replace(" ", "").replace("_", "")
+
+    installed_norm = [_normalize(font) for font in installed_fonts]
+    requirements: list[tuple[str, str]] = [
+        ("cascadiacode", "Cascadia Code family"),
+        ("caskaydiacove", "Caskaydia Cove Nerd Font family"),
+    ]
+
     missing: list[str] = []
-    for pattern in ["cascadiacode*"]:
-        regex = re.compile(pattern)
-        if not any(regex.search(f) for f in installed_norm):
-            missing.append(pattern)
+    for needle, label in requirements:
+        if not any(needle in font for font in installed_norm):
+            missing.append(label)
     return missing
 
 
@@ -125,18 +123,22 @@ 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*")]
-    [p.delete(sure=True) for p in folder.search("*readme*")]
-    [p.delete(sure=True) for p in folder.search("*LICENSE*")]
+    [PathExtended(p).delete(sure=True) for p in folder.glob("*Windows*")]
+    [PathExtended(p).delete(sure=True) for p in folder.glob("*readme*")]
+    [PathExtended(p).delete(sure=True) for p in folder.glob("*LICENSE*")]
+
+    print("Fonts to be installed:")
+    for font in (list(folder.glob("*.ttf")) + list(folder.glob("*.otf"))):
+        print(f" - {font}")
 
     console.print("⚙️  Installing fonts via PowerShell...")
-    file = PathExtended.tmpfile(suffix=".ps1")
+    file = PathExtended("~/tmp_results/tmp_files").expanduser().joinpath(f"{randstr()}.ps1")
     file.parent.mkdir(parents=True, exist_ok=True)
-    
-    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))
+
+    raw_content = LIBRARY_ROOT.joinpath("jobs/installer/powershell_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")
@@ -156,3 +158,7 @@ def install_nerd_fonts() -> None:
     console.print()
     render_banner("✅ Nerd Fonts installation complete! ✅", "Nerd Fonts Installer", "green", box.DOUBLE)
     console.print()
+
+
+if __name__ == "__main__":
+    install_nerd_fonts()

machineconfig/jobs/installer/python_scripts/sysabc.py

@@ -0,0 +1,145 @@
+
+
+import platform
+from typing import Optional
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from machineconfig.utils.schemas.installer.installer_types import InstallerData
+
+ps1 = r"""
+$winget = Get-Command winget -ErrorAction SilentlyContinue
+if (-not $winget) {
+    Write-Host "winget not found. Installing..."
+    $finalUrl = (Invoke-WebRequest 'https://github.com/microsoft/winget-cli/releases/latest' -UseBasicParsing).BaseResponse.ResponseUri.AbsoluteUri
+    $releaseTag = $finalUrl.Split('/')[-1]
+    $DownloadUrl = "https://github.com/microsoft/winget-cli/releases/download/$releaseTag/Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle"
+    $DestDir     = Join-Path $HOME "Downloads"
+    $DestFile    = Join-Path $DestDir "Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle"
+    # Create folder if it doesn't exist
+    if (-not (Test-Path $DestDir)) {
+        New-Item -ItemType Directory -Path $DestDir | Out-Null
+    }
+    Write-Host "Downloading winget installer..."
+    # Invoke-WebRequest -Uri $DownloadUrl -OutFile $DestFile
+    # Start-BitsTransfer -Source $DownloadUrl -Destination $DestFile  # 
+    #Invoke-WebRequest -Uri $DownloadUrl -OutFile $DestFile -UseBasicParsing
+    curl.exe -L -o $DestFile $DownloadUrl
+    Write-Host "Saved to: $DestFile"
+    # We MUST run Add-AppxPackage in Windows PowerShell
+    Write-Host "Installing package via Windows PowerShell..."
+    powershell.exe -NoLogo -NoProfile -Command "Add-AppxPackage -Path `"$DestFile`" "
+    Write-Host "Installation complete."
+    }
+else {
+    Write-Host "winget already available. Skipping installation."
+}
+
+winget install --no-upgrade --name "Powershell"                   --Id "Microsoft.PowerShell"       --source winget --scope user --accept-package-agreements --accept-source-agreements  # powershell require admin
+winget install --no-upgrade --name "Windows Terminal"             --Id "Microsoft.WindowsTerminal"  --source winget --scope user --accept-package-agreements --accept-source-agreements  # Terminal is is installed by default on W 11
+winget install --no-upgrade --name "Git"                          --Id "Git.Git"                    --source winget --scope user --accept-package-agreements --accept-source-agreements
+powershell -c "irm bun.sh/install.ps1|iex"
+
+# --GROUP:gui:Brave+VSCode+Git+WezTerm
+# --GROUP:dev2:VSRedistrib+VSBuildTools+Codeblocks+GnuWin32: Make+GnuPG+graphviz+WinFsp+SSHFS-win+xming+Node.js+Rustup+Cloudflare+Cloudflare WARP+Microsoft Garage Mouse without Borders
+# --GROUP:user:nu+Chrome+ChromeRemoteDesktop+Zoom+7zip+Firefox+Thunderbird+StreamlabsOBS+OBSStudio+MiKTeX+TexMaker+notepad+++Lapce+TesseractOCR+perl+DB Browser for SQLite+sql server management studio+Adobe Acrobat Reader DC+julia+Chafa+bottom+onefetch+Just+hyperfine+AWS CLI
+# Install-Module -Name Terminal-Icons -Repository PSGallery -Force -AcceptLicense -PassThru -Confirm  # -RequiredVersion 2.5.10
+# [System.Environment]::SetEnvironmentVariable('PYTHONUTF8', '1', 'User')
+# [System.Environment]::SetEnvironmentVariable('PYTHONIOENCODING', 'utf-8', 'User')
+
+
+"""
+
+zsh = r"""
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+echo "🔄 Updating Homebrew..."
+brew update || true
+
+curl -fsSL https://bun.com/install | bash
+
+# Note: git and nano are pre-installed on macOS, but we install via Homebrew to ensure latest versions
+# brew install git || true
+# brew install nano || true
+# brew install curl || true
+# nvm install node || true
+# brew install make
+# brew install ffmpeg
+# brew install openssl
+
+
+echo "✅ Essential tools installation complete."
+"""
+
+bash = r"""
+sudo apt update -y || true
+sudo apt install nala -y || true
+sudo nala install curl wget gpg lsb-release apt-transport-https -y || true
+sudo nala install git net-tools htop nano -y || true
+sudo nala install build-essential python3-dev -y || true  # C build toolchain: Where build-essential brings gcc, make, etc., and python3-dev ensures headers for your Python version.
+# sudo nala install libssl-dev -y
+# sudo nala install libaa-bin -y
+
+# curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash
+# source ~/.bashrc || true
+# nvm install node || true
+
+sudo nala install unzip -y  # required by bun installer
+curl -fsSL https://bun.com/install | bash
+. ~/.bashrc || true
+# sudo ln -s $(which bun) /usr/local/bin/node  # trick programs that expect node to use bun runtime.
+sudo ln -s ~/.bun/bin/bun /usr/local/bin/node
+
+
+sudo nala install samba -y || true
+sudo nala install fuse3 -y || true
+sudo nala install nfs-common -y || true
+
+# echo 'keyboard-configuration keyboard-configuration/layout select US English' | sudo debconf-set-selections
+# echo 'keyboard-configuration keyboard-configuration/layoutcode string us' | sudo debconf-set-selections
+# sudo DEBIAN_FRONTEND=noninteractive nala install -y cmatrix
+# sudo nala install hollywood -y || true
+
+# sudo nala install ffmpeg -y || true  # Required by some dev tools
+# sudo nala install make -y || true  # Required by LunarVim and SpaceVim
+# (curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh) || true
+
+"""
+
+
+def main(installer_data: InstallerData, version: Optional[str]) -> 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="🔧 ABC Installer",
+            border_style="blue",
+            box=box.ROUNDED,
+        )
+    )
+
+    _ = version
+    if platform.system() == "Windows":
+        console.print("🪟 Installing ABC on Windows using winget...", style="bold")
+        program = ps1
+    elif platform.system() == "Linux":
+        console.print("🐧 Installing ABC on Linux...", style="bold")
+        program = bash
+    elif platform.system() == "Darwin":
+        console.print("🍎 Installing ABC on macOS...", style="bold")
+        program = zsh
+    else:
+        error_msg = f"Unsupported platform: {platform.system()}"
+        console.print(
+            Panel.fit(
+                "\n".join([error_msg]),
+                title="❌ Error",
+                subtitle="⚠️ Unsupported platform",
+                border_style="red",
+                box=box.ROUNDED,
+            )
+        )
+        raise NotImplementedError(error_msg)
+    from machineconfig.utils.code import print_code, run_shell_script
+    print_code(code=program, lexer="shell", desc="Installation Script Preview")
+    run_shell_script(program, display_script=True, clean_env=False)

machineconfig/jobs/installer/{custom_dev → python_scripts}/wezterm.py

@@ -9,10 +9,6 @@ from rich.panel import Panel
 
 from machineconfig.utils.schemas.installer.installer_types import InstallerData
 
-
-# config_dict: InstallerData = {"appName": "Wezterm", "repoURL": "CMD", "doc": "Modern, GPU-accelerated terminal emulator"}
-
-
 console = Console()
 
 
@@ -35,21 +31,8 @@ def main(installer_data: InstallerData, version: Optional[str]):
 
     _ = version
     if platform.system() == "Windows":
-        error_msg = "WezTerm installation not supported on Windows through this installer"
-        console.print(
-            Panel.fit(
-                "\n".join(
-                    [
-                        f"❌ ERROR | {error_msg}",
-                        "💡 TIP: Please download and install manually from the WezTerm website",
-                    ]
-                ),
-                title="Unsupported Platform",
-                border_style="red",
-                padding=(1, 2),
-            )
-        )
-        raise NotImplementedError(error_msg)
+        program = """winget install --no-upgrade --name "WezTerm" --Id "wez.wezterm" --source winget --accept-package-agreements --accept-source-agreements
+"""
     elif platform.system() in ["Linux", "Darwin"]:
         system_name = "LINUX" if platform.system() == "Linux" else "MACOS"
         console.print(

machineconfig/jobs/installer/{custom_dev → python_scripts}/winget.py

@@ -3,11 +3,16 @@ import requests
 import tempfile
 from pathlib import Path
 from typing import Optional
+from machineconfig.utils.schemas.installer.installer_types import InstallerData
 
 
-# config_dict: InstallerData = {"appName": "winget", "repoURL": "CMD", "doc": "winget installer"}
-# on older windows, use this to get winget for first time: Add-AppxPackage -RegisterByFamilyName -MainPackage Microsoft.DesktopAppInstaller_8wekyb3d8bbwe as per https://learn.microsoft.com/en-us/windows/package-manager/winget/
-
+r"""
+# download latest from
+cd $HOME/Downloads
+d u "https://github.com/microsoft/winget-cli/releases/download/v1.12.170-preview/Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle"
+# this must be run in windows powershell, not in pwsh
+Add-AppxPackage .\Microsoft.DesktopAppInstaller_8wekyb3d8bbwe.msixbundle
+"""
 
 def is_winget_available() -> bool:
     """
@@ -110,7 +115,7 @@ def install_msix_package(package_path: Path) -> bool:
         return False
 
 
-def ensure_winget_available() -> bool:
+def main(installer_data: InstallerData, version: Optional[str]) -> bool:
     """
     Ensure winget is available on the system. If not available, download and install it.
 
@@ -118,6 +123,7 @@ def ensure_winget_available() -> bool:
         bool: True if winget is available (either was already installed or successfully installed),
               False if installation failed
     """
+    _ = installer_data
     # First check if winget is already available
     if is_winget_available():
         print("Winget is already available on the system.")
@@ -164,13 +170,3 @@ def ensure_winget_available() -> bool:
     else:
         print("Installation completed but winget is still not available. You may need to restart your terminal or add it to PATH.")
         return False
-
-
-if __name__ == "__main__":
-    # Example usage
-    print("=== Winget Installation ===\n")
-
-    if ensure_winget_available():
-        print("Winget is ready to use!")
-    else:
-        print("Failed to ensure winget availability.")