machineconfig 7.64__py3-none-any.whl → 7.83__py3-none-any.whl

machineconfig/settings/yazi/yazi_windows.toml

@@ -0,0 +1,58 @@
+
+[mgr]
+show_hidden = true
+ratio = [1, 3, 5]
+
+[opener]
+system_default = [
+  { run = "cmd /C start \"\" \"%1\"", desc = "System Default (Windows)", for = "windows", block = false, orphan = false }
+]
+# Edit files in your editor (replace "code" with your editor if you like)
+edit = [
+  { run = "code \"%*\"", desc = "VS Code (Editor)", block = true, orphan = false, for = "windows" }
+]
+helix = [
+  { run = "hx \"%*\"", desc = "Helix (Editor)", block = true, orphan = false, for = "windows" }
+]
+
+# Play media files
+play = [
+  { run = "start \"\" \"%*\"", desc = "System Default (Media)", block = false, orphan = false, for = "windows" }
+]
+
+# Open files/folders with system default program/explorer
+open = [
+  { run = "start \"\" \"%1\"", desc = "System Default (Open)", block = false, orphan = false, for = "windows" }
+]
+
+
+[open]
+prepend_rules = [
+  # Text/Code files - open with VSCode by default, Helix as alternative
+  { name = "*.py", use = ["edit", "helix"] },
+  { name = "*.{rs,toml,yaml,yml,json,js,ts,tsx,jsx,html,css,md,txt,sh,ps1,bat,cmd}", use = ["edit", "helix"] },
+  { mime = "text/*", use = ["edit", "helix"] },
+]
+rules = [
+  { mime = "video/*", use = "play" },
+  { mime = "application/pdf", use = ["system_default"] },
+  { mime = "image/*", use = ["system_default"] },
+  { name = "*", use = ["system_default"] }
+]
+
+
+
+[plugin]
+# dir = "~/AppData/Roaming/yazi/config/plugins"
+
+[[plugin.load]]
+name = "toggle-pane"
+path = "toggle-pane.yazi"
+
+
+[preview]
+# Change them to your desired values
+max_width  = 1000
+max_height = 1000
+
+

machineconfig/setup_linux/web_shortcuts/interactive.sh

@@ -2,16 +2,16 @@
 . <( curl -sSL "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_linux/uv.sh")
 . <( curl -sSL "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/scripts/linux/wrap_mcfg")
 
-alias devops='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.64" devops'
-alias cloud='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.64" cloud'
-alias agents='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.64" agents'
-alias sessions='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.64" sessions'
-alias ftpx='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.64" ftpx'
-alias fire='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.64" fire'
-alias croshell='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.64" croshell'
-alias utils='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.64" utils'
-alias terminal='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.64" terminal'
-alias msearch='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.64" msearch'
+alias devops='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.83" devops'
+alias cloud='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.83" cloud'
+alias agents='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.83" agents'
+alias sessions='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.83" sessions'
+alias ftpx='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.83" ftpx'
+alias fire='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.83" fire'
+alias croshell='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.83" croshell'
+alias utils='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.83" utils'
+alias terminal='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.83" terminal'
+alias msearch='$HOME/.local/bin/uvx --python 3.14 --from "machineconfig>=7.83" msearch'
 
 alias d='wrap_in_shell_script devops'
 alias c='wrap_in_shell_script cloud'

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.64" devops $args }
-function cloud    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" cloud $args }
-function agents   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" agents $args }
-function sessions { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" sessions $args }
-function ftpx     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" ftpx $args }
-function fire     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" fire $args }
-function croshell { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" croshell $args }
-function utils    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" utils $args }
-function terminal { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" terminal $args }
-function msearch  { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.64" msearch $args }
+function devops   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.83" devops $args }
+function cloud    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.83" cloud $args }
+function agents   { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.83" agents $args }
+function sessions { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.83" sessions $args }
+function ftpx     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.83" ftpx $args }
+function fire     { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.83" fire $args }
+function croshell { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.83" croshell $args }
+function utils    { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.83" utils $args }
+function terminal { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.83" terminal $args }
+function msearch  { & "$HOME\.local\bin\uvx.exe" --python 3.14 --from "machineconfig>=7.83" msearch $args }
 
 function d { wrap_in_shell_script devops @args }
 function c { wrap_in_shell_script cloud @args }

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,5 +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]):

machineconfig/utils/installer_utils/github_release_bulk.py

@@ -6,12 +6,40 @@ Extracts GitHub repository URLs and fetches latest release data with rate limiti
 
 import json
 import time
-import subprocess
+import requests
 from pathlib import Path
-from typing import Any, Dict, Optional, Set
+from typing import Any, Dict, Optional, Set, TypedDict
 from urllib.parse import urlparse
 
 
+class AssetInfo(TypedDict):
+    """Type definition for GitHub release asset information."""
+    name: str
+    size: int
+    download_count: int
+    content_type: str
+    created_at: str
+    updated_at: str
+    browser_download_url: str
+
+
+class ReleaseInfo(TypedDict):
+    """Type definition for GitHub release information."""
+    tag_name: str
+    name: str
+    published_at: str
+    assets: list[AssetInfo]
+    assets_count: int
+
+
+class OutputData(TypedDict):
+    """Type definition for the output JSON data structure."""
+    generated_at: str
+    total_repositories: int
+    successful_fetches: int
+    releases: Dict[str, Optional[ReleaseInfo]]
+
+
 def is_github_repo(url: str) -> bool:
     """Check if URL is a GitHub repository URL."""
     try:
@@ -19,87 +47,99 @@ def is_github_repo(url: str) -> bool:
         return parsed.netloc == "github.com" and len(parsed.path.split("/")) >= 3
     except Exception:
         return False
-
-
 def extract_github_repos_from_json(json_file_path: Path) -> Set[str]:
     """Extract GitHub repository URLs from installer JSON file."""
     github_repos: Set[str] = set()
-    
     try:
         with open(json_file_path, 'r', encoding='utf-8') as file:
             data = json.load(file)
-            
         for installer in data.get("installers", []):
             repo_url = installer.get("repoURL", "")
             if is_github_repo(repo_url):
                 github_repos.add(repo_url)
-                
     except (json.JSONDecodeError, FileNotFoundError) as e:
         print(f"Error reading {json_file_path}: {e}")
-        
     return github_repos
-
-
-def get_repo_name_from_url(repo_url: str) -> str:
-    """Extract owner/repo from GitHub URL."""
+def get_repo_name_from_url(repo_url: str) -> Optional[tuple[str, str]]:
+    """Extract owner/repo from GitHub URL as a tuple (username, repo_name)."""
     try:
         parsed = urlparse(repo_url)
         path_parts = parsed.path.strip("/").split("/")
-        return f"{path_parts[0]}/{path_parts[1]}"
+        return (path_parts[0], path_parts[1])
     except (IndexError, AttributeError):
-        return ""
+        return None
 
 
-def fetch_github_release_data(repo_name: str) -> Optional[Dict[str, Any]]:
-    """Fetch latest release data from GitHub API using curl."""
+def fetch_github_release_data(
+    username: str,
+    repo_name: str,
+    version: Optional[str] = None,
+) -> Optional[Dict[str, Any]]:
+    """Fetch GitHub release data for the latest or a specific tag."""
+
     try:
-        cmd = [
-            "curl", "-s",
-            f"https://api.github.com/repos/{repo_name}/releases/latest"
-        ]
-        
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=30
-        )
-        
-        if result.returncode != 0:
-            print(f"❌ Failed to fetch data for {repo_name}: {result.stderr}")
+        requested_version = (version or "").strip()
+        if requested_version and requested_version.lower() != "latest":
+            url = f"https://api.github.com/repos/{username}/{repo_name}/releases/tags/{requested_version}"
+        else:
+            url = f"https://api.github.com/repos/{username}/{repo_name}/releases/latest"
+
+        response = requests.get(url, timeout=30)
+        if response.status_code != 200:
+            print(f"❌ Failed to fetch data for {username}/{repo_name}: HTTP {response.status_code}")
             return None
-            
-        response_data = json.loads(result.stdout)
-        
-        # 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}")
+
+        response_data = response.json()
+        message = response_data.get("message")
+        if isinstance(message, str):
+            if "API rate limit exceeded" in message:
+                print(f"🚫 Rate limit exceeded for {username}/{repo_name}")
                 return None
-            elif "Not Found" in response_data.get("message", ""):
-                print(f"🔍 No releases found for {repo_name}")
+            if "Not Found" in message:
+                print(f"🔍 No releases found for {username}/{repo_name}")
                 return None
-                
+
         return response_data
-        
-    except (subprocess.TimeoutExpired, json.JSONDecodeError, subprocess.SubprocessError) as e:
-        print(f"❌ Error fetching {repo_name}: {e}")
+
+    except (requests.RequestException, requests.Timeout, json.JSONDecodeError) as error:
+        print(f"❌ Error fetching {username}/{repo_name}: {error}")
         return None
 
 
-def extract_release_info(release_data: Dict[str, Any]) -> Dict[str, Any]:
+def get_release_info(
+    username: str,
+    repo_name: str,
+    version: Optional[str] = None,
+) -> Optional[ReleaseInfo]:
+    """Return sanitized release information for the requested repository."""
+    release_data = fetch_github_release_data(username, repo_name, version)
+    if not release_data:
+        return None
+    return extract_release_info(release_data)
+
+
+def extract_release_info(release_data: Dict[str, Any]) -> Optional[ReleaseInfo]:
     """Extract relevant information from GitHub release data."""
     if not release_data:
-        return {}
-        
-    asset_names = [asset["name"] for asset in release_data.get("assets", [])]
-    
+        return None
+    assets: list[AssetInfo] = []
+    for asset in release_data.get("assets", []):
+        asset_info: AssetInfo = {
+            "name": asset.get("name", ""),
+            "size": asset.get("size", 0),
+            "download_count": asset.get("download_count", 0),
+            "content_type": asset.get("content_type", ""),
+            "created_at": asset.get("created_at", ""),
+            "updated_at": asset.get("updated_at", ""),
+            "browser_download_url": asset.get("browser_download_url", "")
+        }
+        assets.append(asset_info)
     return {
         "tag_name": release_data.get("tag_name", ""),
         "name": release_data.get("name", ""),
         "published_at": release_data.get("published_at", ""),
-        "assets": asset_names,
-        "assets_count": len(asset_names)
+        "assets": assets,
+        "assets_count": len(assets)
     }
 
 
@@ -132,7 +172,7 @@ def main() -> None:
         return
     
     # Fetch release data with rate limiting
-    release_mapping: Dict[str, Any] = {}
+    release_mapping: Dict[str, Optional[ReleaseInfo]] = {}
     total_repos = len(all_github_repos)
     
     print(f"\n🚀 Fetching release data for {total_repos} repositories...")
@@ -140,24 +180,26 @@ def main() -> None:
     print("-" * 60)
     
     for i, repo_url in enumerate(sorted(all_github_repos), 1):
-        repo_name = get_repo_name_from_url(repo_url)
+        repo_info = get_repo_name_from_url(repo_url)
         
-        if not repo_name:
+        if not repo_info:
             print(f"⚠️  [{i:3d}/{total_repos}] Invalid repo URL: {repo_url}")
             continue
-            
-        print(f"📡 [{i:3d}/{total_repos}] Fetching: {repo_name}", end=" ... ")
         
-        release_data = fetch_github_release_data(repo_name)
+        username, repo_name = repo_info
+        repo_full_name = f"{username}/{repo_name}"
+            
+        print(f"📡 [{i:3d}/{total_repos}] Fetching: {repo_full_name}", end=" ... ")
         
-        if release_data:
-            release_info = extract_release_info(release_data)
+        release_info = get_release_info(username, repo_name)
+
+        if release_info:
             release_mapping[repo_url] = release_info
-            assets_count = release_info.get("assets_count", 0)
-            tag = release_info.get("tag_name", "unknown")
+            assets_count = release_info["assets_count"]
+            tag = release_info["tag_name"]
             print(f"✅ {tag} ({assets_count} assets)")
         else:
-            release_mapping[repo_url] = {}
+            release_mapping[repo_url] = None
             print("❌ No data")
         
         # Rate limiting - wait 5 seconds between requests (except for the last one)
@@ -165,7 +207,7 @@ def main() -> None:
             time.sleep(5)
     
     # Save results
-    output_data = {
+    output_data: OutputData = {
         "generated_at": time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime()),
         "total_repositories": len(all_github_repos),
         "successful_fetches": len([v for v in release_mapping.values() if v]),

machineconfig/utils/installer_utils/install_from_url.py

@@ -0,0 +1,200 @@
+
+
+import platform
+from urllib.parse import urlparse
+
+import typer
+from typing import TYPE_CHECKING
+
+from machineconfig.utils.installer_utils.installer_helper import install_deb_package
+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 DECOMPRESS_SUPPORTED_FORMATS, PathExtended
+from machineconfig.utils.source_of_truth import INSTALL_TMP_DIR, 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: 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 _download_and_prepare(download_url: str) -> PathExtended:
+    archive_path = PathExtended(download_url).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)
+    return extracted_path
+
+
+def _finalize_install(repo_name: str, asset_name: 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)
+        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"))
+
+
+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"))
+        raise typer.Exit(1)
+    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"))
+        raise typer.Exit(1)
+    
+    release_info = extract_release_info(release_raw)
+    if not release_info:
+        console.print(Panel("Failed to parse release information.", title="❌ Error", border_style="red"))
+        raise typer.Exit(1)
+    
+    assets = release_info["assets"]
+    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)
+    
+    # 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"))
+        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["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"))
+        raise typer.Exit(1)
+    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 [cyan]{asset_name}[/cyan] from [green]{host}[/green]", title="⬇️ Download", border_style="magenta"))
+    extracted_path = _download_and_prepare(binary_url)
+    _finalize_install(repo_name="", asset_name=asset_name, version="latest", extracted_path=extracted_path, console=console)