evo-cli 0.11.0__tar.gz → 0.11.1__tar.gz

{evo_cli-0.11.0 → evo_cli-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.11.0
+Version: 0.11.1
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli

evo_cli-0.11.1/evo_cli/VERSION

@@ -0,0 +1 @@
+0.11.1

evo_cli-0.11.1/evo_cli/commands/gh.py

@@ -0,0 +1,420 @@
+"""Install the GitHub CLI (gh) and report whether it is authenticated."""
+
+import os
+import platform
+import re
+import shutil
+import subprocess
+import tarfile
+import tempfile
+import urllib.request
+import zipfile
+from pathlib import Path
+
+import rich_click as click
+from rich.panel import Panel
+from rich.text import Text
+
+from evo_cli.console import (
+    CommandError,
+    console,
+    download_file,
+    error,
+    info,
+    resolve_executable,
+    run_command,
+    step,
+    success,
+    warning,
+)
+
+EPILOG = Text.from_markup(
+    "[bold]Examples[/bold]\n\n"
+    "  [cyan]evo setup gh[/cyan]                    install gh, then check its auth status\n"
+    "  [cyan]evo setup gh --reinstall[/cyan]        install again even if gh is present\n"
+    "  [cyan]evo setup gh --user[/cyan]             install into ~/.local/bin; never touch the system\n"
+    "  [cyan]evo setup gh --skip-auth-check[/cyan]  install only; do not run `gh auth status`"
+)
+
+RELEASES_URL = "https://github.com/cli/cli/releases/latest"
+DOWNLOAD_URL = "https://github.com/cli/cli/releases/download"
+
+# Where a userspace install puts the binary. Not on PATH in every shell, so
+# callers have to check.
+USER_BIN = Path.home() / ".local" / "bin"
+
+# uname machine -> the arch slug used in gh's release asset names.
+ARCH_SLUGS = {
+    "x86_64": "amd64",
+    "amd64": "amd64",
+    "aarch64": "arm64",
+    "arm64": "arm64",
+    "armv6l": "armv6",
+    "armv7l": "armv6",
+    "i386": "386",
+    "i686": "386",
+}
+
+# gh is not in the default Debian/Ubuntu repositories, so the official
+# instructions add GitHub's keyring and apt source first. Kept close to upstream:
+# https://github.com/cli/cli/blob/trunk/docs/install_linux.md
+APT_SCRIPT = """set -e
+(type -p wget >/dev/null || ($SUDO apt update && $SUDO apt install wget -y))
+$SUDO mkdir -p -m 755 /etc/apt/keyrings
+out=$(mktemp)
+wget -nv -O$out https://cli.github.com/packages/githubcli-archive-keyring.gpg
+cat $out | $SUDO tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null
+$SUDO chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg
+$SUDO mkdir -p -m 755 /etc/apt/sources.list.d
+echo "deb [arch=$(dpkg --print-architecture) \
+signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] \
+https://cli.github.com/packages stable main" | $SUDO tee /etc/apt/sources.list.d/github-cli.list > /dev/null
+$SUDO apt update
+$SUDO apt install gh -y
+"""
+
+# Fedora ships gh in its own repositories; only fall back to GitHub's rpm repo
+# when the distro does not carry the package.
+DNF_SCRIPT = """$SUDO dnf install -y gh || {
+  $SUDO dnf install -y dnf5-plugins
+  $SUDO dnf config-manager addrepo --from-repofile=https://cli.github.com/packages/rpm/gh-cli.repo
+  $SUDO dnf install -y gh
+}
+"""
+
+ZYPPER_SCRIPT = """set -e
+$SUDO zypper addrepo https://cli.github.com/packages/rpm/gh-cli.repo
+$SUDO zypper ref
+$SUDO zypper install -y gh
+"""
+
+
+def is_root():
+    geteuid = getattr(os, "geteuid", None)
+    return geteuid is not None and geteuid() == 0
+
+
+def can_elevate():
+    """Whether privileged package-manager commands are possible at all.
+
+    Containers commonly run as an unprivileged user with no sudo installed (the
+    Jupyter `jovyan` image, for one), so every system-wide install path is out
+    and only a userspace install can work.
+    """
+    return is_root() or bool(shutil.which("sudo"))
+
+
+def shell_script(script):
+    """Wrap a package-manager script, defining $SUDO to '' when already root."""
+    sudo = "" if is_root() else "sudo"
+    return ["bash", "-c", f"SUDO={sudo}\n{script}"]
+
+
+def elevated(argv):
+    """Prefix a command with sudo unless we are already root."""
+    return list(argv) if is_root() else ["sudo", *argv]
+
+
+def gh_version():
+    """Return the installed gh version string, or None if gh is not on PATH."""
+    if not shutil.which("gh"):
+        return None
+    try:
+        result = subprocess.run(
+            resolve_executable(["gh", "--version"]),
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=30,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return "unknown"
+    match = re.search(r"\d+\.\d+\.\d+", result.stdout or "")
+    return match.group(0) if match else "unknown"
+
+
+def linux_install_command():
+    if shutil.which("apt-get"):
+        return shell_script(APT_SCRIPT)
+    if shutil.which("dnf"):
+        return shell_script(DNF_SCRIPT)
+    if shutil.which("pacman"):
+        return elevated(["pacman", "-S", "--noconfirm", "github-cli"])
+    if shutil.which("apk"):
+        return elevated(["apk", "add", "github-cli"])
+    if shutil.which("zypper"):
+        return shell_script(ZYPPER_SCRIPT)
+    return None
+
+
+def windows_install_command():
+    if shutil.which("winget"):
+        # The accept flags keep winget from stopping on an interactive agreement prompt.
+        return [
+            "winget",
+            "install",
+            "--id",
+            "GitHub.cli",
+            "--source",
+            "winget",
+            "--accept-package-agreements",
+            "--accept-source-agreements",
+        ]
+    if shutil.which("scoop"):
+        return ["scoop", "install", "gh"]
+    if shutil.which("choco"):
+        return ["choco", "install", "gh", "-y"]
+    return None
+
+
+def install_command():
+    """The system-wide gh install command for this platform, or None if unusable."""
+    system = platform.system()
+    if system == "Darwin":
+        return ["brew", "install", "gh"] if shutil.which("brew") else None
+    if system == "Linux":
+        return linux_install_command() if can_elevate() else None
+    if system == "Windows":
+        return windows_install_command()
+    return None
+
+
+def latest_gh_version():
+    """Resolve the latest gh version from the releases redirect.
+
+    /releases/latest redirects to /releases/tag/vX.Y.Z, so the version can be
+    read without spending an unauthenticated GitHub API call (60/hour per IP).
+    """
+    request = urllib.request.Request(RELEASES_URL, headers={"User-Agent": "evo-cli"})
+    try:
+        with urllib.request.urlopen(request, timeout=30) as response:
+            final_url = response.geturl()
+    except OSError as exc:
+        warning(f"Could not reach {RELEASES_URL}: {exc}")
+        return None
+    match = re.search(r"/tag/v?(\d+\.\d+\.\d+)", final_url or "")
+    return match.group(1) if match else None
+
+
+def release_arch():
+    return ARCH_SLUGS.get(platform.machine().lower())
+
+
+def asset_url(version, arch, system):
+    """URL of the official release archive for this platform."""
+    if system == "Darwin":
+        return f"{DOWNLOAD_URL}/v{version}/gh_{version}_macOS_{arch}.zip"
+    return f"{DOWNLOAD_URL}/v{version}/gh_{version}_linux_{arch}.tar.gz"
+
+
+def extract_gh_binary(archive, destination):
+    """Pull just bin/gh out of the release archive and write it to destination.
+
+    Only the one member is read, so a hostile archive cannot write outside the
+    destination the way a blanket extractall() could.
+    """
+    if str(archive).endswith(".zip"):
+        with zipfile.ZipFile(archive) as bundle:
+            names = [n for n in bundle.namelist() if n.endswith("bin/gh")]
+            if not names:
+                return False
+            with bundle.open(names[0]) as source, open(destination, "wb") as target:
+                shutil.copyfileobj(source, target)
+    else:
+        with tarfile.open(archive) as bundle:
+            members = [m for m in bundle.getmembers() if m.name.endswith("bin/gh") and m.isfile()]
+            if not members:
+                return False
+            source = bundle.extractfile(members[0])
+            if source is None:
+                return False
+            with source, open(destination, "wb") as target:
+                shutil.copyfileobj(source, target)
+
+    destination.chmod(0o755)
+    return True
+
+
+def ensure_user_bin_on_path():
+    """Make a just-installed ~/.local/bin/gh visible to this process.
+
+    The user's shell has not re-read PATH yet, so without this the auth check
+    below would not find the binary we just wrote.
+    """
+    entries = os.environ.get("PATH", "").split(os.pathsep)
+    if str(USER_BIN) in entries:
+        return True
+    os.environ["PATH"] = f"{USER_BIN}{os.pathsep}{os.environ.get('PATH', '')}"
+    return False
+
+
+def install_from_release():
+    """Install gh into ~/.local/bin straight from the official release archive.
+
+    This is the path for machines where a system-wide install is impossible: no
+    root, no sudo, no usable package manager. It needs no privileges because it
+    only writes under the user's home.
+    """
+    step("Installing gh from the official release")
+    system = platform.system()
+    if system not in ("Linux", "Darwin"):
+        error(f"No userspace install available for {system}.")
+        return False
+
+    arch = release_arch()
+    if not arch:
+        error(f"Unsupported architecture: {platform.machine()}")
+        return False
+
+    version = latest_gh_version()
+    if not version:
+        error("Could not work out the latest gh version.")
+        return False
+
+    url = asset_url(version, arch, system)
+    info(f"Downloading gh {version} ({system.lower()}/{arch})")
+    USER_BIN.mkdir(parents=True, exist_ok=True)
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        archive = Path(tmpdir) / url.rsplit("/", 1)[-1]
+        try:
+            download_file(url, archive, description=f"gh {version}")
+        except OSError as exc:
+            error(f"Download failed: {exc}")
+            return False
+
+        if not extract_gh_binary(archive, USER_BIN / "gh"):
+            error(f"No gh binary inside {archive.name}")
+            return False
+
+    already_on_path = ensure_user_bin_on_path()
+    success(f"gh {version} installed to [accent]{USER_BIN / 'gh'}[/accent]")
+    if not already_on_path:
+        warning(f"{USER_BIN} is not on your PATH")
+        info('Add this to your shell rc: [accent]export PATH="$HOME/.local/bin:$PATH"[/accent]')
+    return True
+
+
+def install_gh(reinstall=False, user=False):
+    """Install the GitHub CLI. Returns True when `gh` ends up runnable."""
+    step("Installing GitHub CLI")
+
+    version = gh_version()
+    if version and not reinstall:
+        info(f"gh already installed ({version}); skipping install")
+        return True
+
+    if user:
+        info("Installing into ~/.local/bin as requested")
+        return install_from_release()
+
+    command = install_command()
+    if command is None:
+        if platform.system() == "Linux" and not can_elevate():
+            warning("No root and no sudo, so a system-wide install is not possible")
+        else:
+            warning("No usable package manager found")
+        info("Falling back to a userspace install in ~/.local/bin")
+        return install_from_release()
+
+    try:
+        run_command(command, status="Installing gh", stdin=subprocess.DEVNULL, timeout=900)
+    except CommandError:
+        warning("The package-manager install failed; falling back to ~/.local/bin")
+        return install_from_release()
+
+    if not gh_version():
+        warning("gh installed but it is not on PATH yet")
+        info("Open a new terminal, then run `gh --version` to confirm.")
+        return False
+
+    success(f"gh installed ({gh_version()})")
+    return True
+
+
+def check_gh_auth():
+    """Report whether gh holds GitHub credentials.
+
+    `gh auth status` is read-only and exits non-zero when logged out, so it is
+    safe here. `gh auth login` is not: it needs a TTY and a browser, so leave it
+    to the user rather than blocking the run on it.
+    """
+    step("Checking GitHub authentication")
+    result = run_command(
+        ["gh", "auth", "status"],
+        status="Running gh auth status",
+        stdin=subprocess.DEVNULL,
+        timeout=60,
+        check=False,
+    )
+    if getattr(result, "returncode", None) == 0:
+        success("gh is authenticated")
+        return True
+
+    warning("gh is not authenticated")
+    info("Run [accent]gh auth login[/accent] in your terminal; it opens a browser to sign in.")
+    return False
+
+
+def print_summary(installed, authenticated, auth_checked):
+    console.print()
+    if not installed:
+        console.print(
+            Panel(
+                f"gh was not installed. Install it manually from [accent]{RELEASES_URL}[/accent], then re-run.",
+                title="setup gh incomplete",
+                border_style="warning",
+                expand=False,
+            )
+        )
+        return
+
+    lines = [f"GitHub CLI [accent]{gh_version()}[/accent] is ready."]
+    if not auth_checked:
+        lines.append("Auth check skipped; run [accent]gh auth status[/accent] to see if you are signed in.")
+    elif authenticated:
+        lines.append("You are signed in; `gh pr`, `gh issue` and Claude Code's GitHub workflows will work.")
+    else:
+        lines.append("Sign in with [accent]gh auth login[/accent] to finish setting it up.")
+
+    console.print(
+        Panel(
+            Text.from_markup("\n".join(lines)),
+            title="setup gh complete",
+            border_style="success",
+            expand=False,
+        )
+    )
+
+
+@click.command("gh", epilog=EPILOG)
+@click.option("--reinstall", is_flag=True, help="Install even if gh is already present.")
+@click.option(
+    "--user",
+    is_flag=True,
+    help="Install into ~/.local/bin from the official release; never touch system packages.",
+)
+@click.option("--skip-auth-check", is_flag=True, help="Skip the `gh auth status` check afterwards.")
+def setup_gh(reinstall, user, skip_auth_check):
+    """Install the GitHub CLI (gh) and check whether it is signed in.
+
+    Uses the package manager for your platform - Homebrew on macOS, apt/dnf/
+    pacman/apk/zypper on Linux, winget/scoop/choco on Windows - following
+    GitHub's official instructions (on Debian/Ubuntu that means adding GitHub's
+    keyring and apt source, since gh is not in the default repos).
+
+    Where a system-wide install is impossible - a container with no root and no
+    sudo - it falls back to downloading the official release into ~/.local/bin,
+    which needs no privileges. Force that path with --user.
+
+    An existing install is left alone unless --reinstall is passed. Signing in is
+    left to you: `gh auth login` needs an interactive terminal and a browser, so
+    this command only reports whether credentials are already present.
+    """
+    step("evo setup gh")
+    installed = install_gh(reinstall, user)
+    authenticated = False
+    if installed and not skip_auth_check:
+        authenticated = check_gh_auth()
+    print_summary(installed, authenticated, auth_checked=not skip_auth_check)

{evo_cli-0.11.0 → evo_cli-0.11.1}/evo_cli/console.py

@@ -4,6 +4,7 @@ import sys
 import urllib.request
 
 from rich.console import Console
+from rich.markup import escape
 from rich.progress import (
     BarColumn,
     DownloadColumn,
@@ -73,7 +74,10 @@ def resolve_executable(cmd):
 
 def run_command(cmd, capture=False, check=True, input_text=None, status=None, timeout=None, stdin=None):
     cmd = [str(part) for part in cmd]
-    console.print(f"[cmd]$ {' '.join(cmd)}[/cmd]")
+    # Escape the echo: a command containing brackets (an apt sources line, a
+    # regex) would otherwise be parsed as rich markup and printed with those
+    # parts silently missing, i.e. showing a command we did not run.
+    console.print(f"[cmd]$ {escape(' '.join(cmd))}[/cmd]")
     exec_cmd = resolve_executable(cmd)
 
     run_kwargs = {

{evo_cli-0.11.0 → evo_cli-0.11.1}/evo_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.11.0
+Version: 0.11.1
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli

{evo_cli-0.11.0 → evo_cli-0.11.1}/tests/test_console.py

@@ -3,7 +3,7 @@ import sys
 
 import pytest
 
-from evo_cli.console import CommandError, run_command
+from evo_cli.console import CommandError, console, run_command
 
 
 def test_run_command_raises_on_timeout():
@@ -21,6 +21,18 @@ def test_run_command_timeout_without_check_returns_exception():
     assert isinstance(result, subprocess.TimeoutExpired)
 
 
+def test_run_command_echo_keeps_brackets(capsys):
+    # Rich reads [..] as markup, so an unescaped echo would silently drop the
+    # bracketed part and show a command that is not the one we ran.
+    with console.capture() as capture:
+        run_command([sys.executable, "-c", "pass"], timeout=10)
+    assert "[arch=amd64]" not in capture.get()  # sanity: no brackets in this command
+
+    with console.capture() as capture:
+        run_command(["echo", "deb [arch=amd64 signed-by=/etc/apt/keyrings/gh.gpg] https://x"], timeout=10)
+    assert "deb [arch=amd64 signed-by=/etc/apt/keyrings/gh.gpg] https://x" in capture.get()
+
+
 def test_run_command_detaches_stdin_when_requested():
     # With stdin=DEVNULL a child that reads stdin sees EOF immediately instead
     # of blocking on an inherited terminal.

evo_cli-0.11.1/tests/test_gh.py

@@ -0,0 +1,285 @@
+import tarfile
+import zipfile
+
+import pytest
+from click.testing import CliRunner
+
+from evo_cli.cli import cli
+from evo_cli.commands import gh as gh_mod
+from evo_cli.commands.gh import (
+    asset_url,
+    check_gh_auth,
+    extract_gh_binary,
+    gh_version,
+    install_command,
+    install_gh,
+    latest_gh_version,
+    release_arch,
+)
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+
+def only_which(*available):
+    """A shutil.which stub that finds only the named binaries."""
+    return lambda name: f"/usr/bin/{name}" if name in available else None
+
+
+@pytest.fixture
+def unprivileged(monkeypatch):
+    """A plain user: not root, no sudo."""
+    monkeypatch.setattr(gh_mod, "is_root", lambda: False)
+
+
+@pytest.fixture
+def as_root(monkeypatch):
+    monkeypatch.setattr(gh_mod, "is_root", lambda: True)
+
+
+def test_gh_command_is_registered():
+    assert "gh" in cli.commands["setup"].commands
+
+
+def test_gh_help_runs(runner):
+    result = runner.invoke(cli, ["setup", "gh", "--help"])
+    assert result.exit_code == 0
+    assert "GitHub CLI" in result.output
+
+
+def test_install_command_macos_uses_brew(monkeypatch):
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Darwin")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which("brew"))
+    assert install_command() == ["brew", "install", "gh"]
+
+
+def test_install_command_macos_without_brew(monkeypatch):
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Darwin")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which())
+    assert install_command() is None
+
+
+def test_apt_script_keeps_the_signed_by_source_line(monkeypatch, unprivileged):
+    """The apt source needs the arch/signed-by block; it must survive intact."""
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which("apt-get", "sudo"))
+    script = install_command()[2]
+    assert "deb [arch=$(dpkg --print-architecture) signed-by=" in script
+    assert script.startswith("SUDO=sudo\n")
+    assert "$SUDO apt install gh -y" in script
+
+
+def test_apt_script_drops_sudo_when_running_as_root(monkeypatch, as_root):
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which("apt-get"))
+    script = install_command()[2]
+    assert script.startswith("SUDO=\n")
+    assert "sudo" not in script.replace("$SUDO", "")
+
+
+def test_pacman_is_elevated_only_when_not_root(monkeypatch, unprivileged):
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which("pacman", "sudo"))
+    assert install_command() == ["sudo", "pacman", "-S", "--noconfirm", "github-cli"]
+
+
+def test_pacman_as_root_needs_no_sudo(monkeypatch, as_root):
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which("pacman"))
+    assert install_command() == ["pacman", "-S", "--noconfirm", "github-cli"]
+
+
+def test_no_system_install_without_root_or_sudo(monkeypatch, unprivileged):
+    """The container case: apt exists, but nothing can elevate to use it."""
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which("apt-get"))
+    assert install_command() is None
+
+
+def test_install_command_windows_winget_is_non_interactive(monkeypatch):
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Windows")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which("winget"))
+    command = install_command()
+    assert command[:4] == ["winget", "install", "--id", "GitHub.cli"]
+    assert "--accept-package-agreements" in command
+
+
+def test_install_command_windows_falls_back_to_scoop(monkeypatch):
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Windows")
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which("scoop"))
+    assert install_command() == ["scoop", "install", "gh"]
+
+
+def test_gh_version_none_when_missing(monkeypatch):
+    monkeypatch.setattr(gh_mod.shutil, "which", only_which())
+    assert gh_version() is None
+
+
+def test_release_arch_maps_uname_machines(monkeypatch):
+    monkeypatch.setattr(gh_mod.platform, "machine", lambda: "x86_64")
+    assert release_arch() == "amd64"
+    monkeypatch.setattr(gh_mod.platform, "machine", lambda: "aarch64")
+    assert release_arch() == "arm64"
+    monkeypatch.setattr(gh_mod.platform, "machine", lambda: "sparc")
+    assert release_arch() is None
+
+
+def test_asset_url_per_platform():
+    assert asset_url("2.62.0", "amd64", "Linux").endswith("/v2.62.0/gh_2.62.0_linux_amd64.tar.gz")
+    assert asset_url("2.62.0", "arm64", "Darwin").endswith("/v2.62.0/gh_2.62.0_macOS_arm64.zip")
+
+
+def test_latest_gh_version_reads_the_redirect(monkeypatch):
+    class FakeResponse:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *exc):
+            return False
+
+        def geturl(self):
+            return "https://github.com/cli/cli/releases/tag/v2.63.1"
+
+    monkeypatch.setattr(gh_mod.urllib.request, "urlopen", lambda *a, **kw: FakeResponse())
+    assert latest_gh_version() == "2.63.1"
+
+
+def test_latest_gh_version_survives_a_network_error(monkeypatch):
+    def boom(*args, **kwargs):
+        raise OSError("no network")
+
+    monkeypatch.setattr(gh_mod.urllib.request, "urlopen", boom)
+    assert latest_gh_version() is None
+
+
+def test_extract_gh_binary_from_tarball(tmp_path):
+    payload = tmp_path / "gh"
+    payload.write_bytes(b"#!/bin/sh\necho gh\n")
+    archive = tmp_path / "gh_2.62.0_linux_amd64.tar.gz"
+    with tarfile.open(archive, "w:gz") as bundle:
+        bundle.add(payload, arcname="gh_2.62.0_linux_amd64/bin/gh")
+
+    destination = tmp_path / "out" / "gh"
+    destination.parent.mkdir()
+    assert extract_gh_binary(archive, destination) is True
+    assert destination.read_bytes() == b"#!/bin/sh\necho gh\n"
+    assert destination.stat().st_mode & 0o111  # executable
+
+
+def test_extract_gh_binary_from_zip(tmp_path):
+    archive = tmp_path / "gh_2.62.0_macOS_arm64.zip"
+    with zipfile.ZipFile(archive, "w") as bundle:
+        bundle.writestr("gh_2.62.0_macOS_arm64/bin/gh", "binary")
+
+    destination = tmp_path / "gh"
+    assert extract_gh_binary(archive, destination) is True
+    assert destination.read_text() == "binary"
+
+
+def test_extract_gh_binary_without_the_binary(tmp_path):
+    archive = tmp_path / "empty.tar.gz"
+    with tarfile.open(archive, "w:gz"):
+        pass
+    assert extract_gh_binary(archive, tmp_path / "gh") is False
+
+
+def test_install_gh_skips_when_present(monkeypatch):
+    monkeypatch.setattr(gh_mod, "gh_version", lambda: "2.62.0")
+    monkeypatch.setattr(gh_mod, "run_command", lambda *a, **kw: pytest.fail("must not install"))
+    assert install_gh() is True
+
+
+def test_install_gh_reinstall_runs_the_installer(monkeypatch):
+    calls = []
+    monkeypatch.setattr(gh_mod, "gh_version", lambda: "2.62.0")
+    monkeypatch.setattr(gh_mod, "install_command", lambda: ["brew", "install", "gh"])
+    monkeypatch.setattr(gh_mod, "run_command", lambda cmd, **kw: calls.append(cmd))
+    assert install_gh(reinstall=True) is True
+    assert calls == [["brew", "install", "gh"]]
+
+
+def test_install_gh_falls_back_to_release_without_a_package_manager(monkeypatch):
+    """No root, no sudo: the userspace install is the only way through."""
+    monkeypatch.setattr(gh_mod, "gh_version", lambda: None)
+    monkeypatch.setattr(gh_mod, "install_command", lambda: None)
+    monkeypatch.setattr(gh_mod, "can_elevate", lambda: False)
+    monkeypatch.setattr(gh_mod, "install_from_release", lambda: True)
+    monkeypatch.setattr(gh_mod, "run_command", lambda *a, **kw: pytest.fail("must not install"))
+    assert install_gh() is True
+
+
+def test_install_gh_falls_back_to_release_after_a_failed_install(monkeypatch):
+    monkeypatch.setattr(gh_mod, "gh_version", lambda: None)
+    monkeypatch.setattr(gh_mod, "install_command", lambda: ["brew", "install", "gh"])
+    monkeypatch.setattr(gh_mod, "install_from_release", lambda: True)
+
+    def boom(cmd, **kwargs):
+        raise gh_mod.CommandError("brew exploded")
+
+    monkeypatch.setattr(gh_mod, "run_command", boom)
+    assert install_gh() is True
+
+
+def test_user_flag_never_touches_system_packages(monkeypatch):
+    monkeypatch.setattr(gh_mod, "gh_version", lambda: None)
+    monkeypatch.setattr(gh_mod, "install_command", lambda: pytest.fail("must not use a package manager"))
+    monkeypatch.setattr(gh_mod, "install_from_release", lambda: True)
+    assert install_gh(user=True) is True
+
+
+def test_install_from_release_writes_the_binary(monkeypatch, tmp_path):
+    user_bin = tmp_path / ".local" / "bin"
+    monkeypatch.setattr(gh_mod, "USER_BIN", user_bin)
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(gh_mod, "release_arch", lambda: "amd64")
+    monkeypatch.setattr(gh_mod, "latest_gh_version", lambda: "2.62.0")
+
+    downloaded = []
+
+    def fake_download(url, destination, description=""):
+        downloaded.append(url)
+        with tarfile.open(destination, "w:gz") as bundle:
+            payload = tmp_path / "gh"
+            payload.write_bytes(b"gh-binary")
+            bundle.add(payload, arcname="gh_2.62.0_linux_amd64/bin/gh")
+
+    monkeypatch.setattr(gh_mod, "download_file", fake_download)
+
+    assert gh_mod.install_from_release() is True
+    assert downloaded == ["https://github.com/cli/cli/releases/download/v2.62.0/gh_2.62.0_linux_amd64.tar.gz"]
+    assert (user_bin / "gh").read_bytes() == b"gh-binary"
+
+
+def test_install_from_release_reports_an_unknown_arch(monkeypatch):
+    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(gh_mod, "release_arch", lambda: None)
+    monkeypatch.setattr(gh_mod, "download_file", lambda *a, **kw: pytest.fail("must not download"))
+    assert gh_mod.install_from_release() is False
+
+
+class FakeResult:
+    def __init__(self, returncode):
+        self.returncode = returncode
+
+
+def test_check_gh_auth_signed_in(monkeypatch):
+    monkeypatch.setattr(gh_mod, "run_command", lambda cmd, **kw: FakeResult(0))
+    assert check_gh_auth() is True
+
+
+def test_check_gh_auth_signed_out(monkeypatch):
+    """`gh auth status` exits non-zero when logged out; that must not be fatal."""
+    monkeypatch.setattr(gh_mod, "run_command", lambda cmd, **kw: FakeResult(1))
+    assert check_gh_auth() is False
+
+
+def test_setup_gh_skip_auth_check(runner, monkeypatch):
+    monkeypatch.setattr(gh_mod, "install_gh", lambda reinstall, user: True)
+    monkeypatch.setattr(gh_mod, "gh_version", lambda: "2.62.0")
+    monkeypatch.setattr(gh_mod, "check_gh_auth", lambda: pytest.fail("must not check auth"))
+
+    result = runner.invoke(cli, ["setup", "gh", "--skip-auth-check"])
+    assert result.exit_code == 0
+    assert "Auth check skipped" in result.output

evo_cli-0.11.0/evo_cli/VERSION

@@ -1 +0,0 @@
-0.11.0

evo_cli-0.11.0/evo_cli/commands/gh.py

@@ -1,246 +0,0 @@
-"""Install the GitHub CLI (gh) and report whether it is authenticated."""
-
-import platform
-import re
-import shutil
-import subprocess
-
-import rich_click as click
-from rich.panel import Panel
-from rich.text import Text
-
-from evo_cli.console import CommandError, console, error, info, resolve_executable, run_command, step, success, warning
-
-EPILOG = Text.from_markup(
-    "[bold]Examples[/bold]\n\n"
-    "  [cyan]evo setup gh[/cyan]                    install gh, then check its auth status\n"
-    "  [cyan]evo setup gh --reinstall[/cyan]        install again even if gh is present\n"
-    "  [cyan]evo setup gh --skip-auth-check[/cyan]  install only; do not run `gh auth status`"
-)
-
-RELEASES_URL = "https://github.com/cli/cli/releases/latest"
-
-# gh is not in the default Debian/Ubuntu repositories, so the official
-# instructions add GitHub's keyring and apt source first. Kept close to upstream:
-# https://github.com/cli/cli/blob/trunk/docs/install_linux.md
-APT_SCRIPT = (
-    "set -e\n"
-    "(type -p wget >/dev/null || (sudo apt update && sudo apt install wget -y))\n"
-    "sudo mkdir -p -m 755 /etc/apt/keyrings\n"
-    "out=$(mktemp)\n"
-    "wget -nv -O$out https://cli.github.com/packages/githubcli-archive-keyring.gpg\n"
-    "cat $out | sudo tee /etc/apt/keyrings/githubcli-archive-keyring.gpg > /dev/null\n"
-    "sudo chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg\n"
-    "sudo mkdir -p -m 755 /etc/apt/sources.list.d\n"
-    'echo "deb [arch=$(dpkg --print-architecture) '
-    "signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] "
-    'https://cli.github.com/packages stable main" '
-    "| sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null\n"
-    "sudo apt update\n"
-    "sudo apt install gh -y\n"
-)
-
-# Fedora ships gh in its own repositories; only fall back to GitHub's rpm repo
-# when the distro does not carry the package.
-DNF_SCRIPT = (
-    "sudo dnf install -y gh || {\n"
-    "  sudo dnf install -y dnf5-plugins\n"
-    "  sudo dnf config-manager addrepo --from-repofile=https://cli.github.com/packages/rpm/gh-cli.repo\n"
-    "  sudo dnf install -y gh\n"
-    "}\n"
-)
-
-ZYPPER_SCRIPT = (
-    "set -e\n"
-    "sudo zypper addrepo https://cli.github.com/packages/rpm/gh-cli.repo\n"
-    "sudo zypper ref\n"
-    "sudo zypper install -y gh\n"
-)
-
-
-def gh_version():
-    """Return the installed gh version string, or None if gh is not on PATH."""
-    if not shutil.which("gh"):
-        return None
-    try:
-        result = subprocess.run(
-            resolve_executable(["gh", "--version"]),
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            timeout=30,
-        )
-    except (OSError, subprocess.SubprocessError):
-        return "unknown"
-    match = re.search(r"\d+\.\d+\.\d+", result.stdout or "")
-    return match.group(0) if match else "unknown"
-
-
-def linux_install_command():
-    if shutil.which("apt-get"):
-        return ["bash", "-c", APT_SCRIPT]
-    if shutil.which("dnf"):
-        return ["bash", "-c", DNF_SCRIPT]
-    if shutil.which("pacman"):
-        return ["sudo", "pacman", "-S", "--noconfirm", "github-cli"]
-    if shutil.which("apk"):
-        return ["sudo", "apk", "add", "github-cli"]
-    if shutil.which("zypper"):
-        return ["bash", "-c", ZYPPER_SCRIPT]
-    return None
-
-
-def windows_install_command():
-    if shutil.which("winget"):
-        # The accept flags keep winget from stopping on an interactive agreement prompt.
-        return [
-            "winget",
-            "install",
-            "--id",
-            "GitHub.cli",
-            "--source",
-            "winget",
-            "--accept-package-agreements",
-            "--accept-source-agreements",
-        ]
-    if shutil.which("scoop"):
-        return ["scoop", "install", "gh"]
-    if shutil.which("choco"):
-        return ["choco", "install", "gh", "-y"]
-    return None
-
-
-def install_command():
-    """The gh install command for this platform, or None if none is usable."""
-    system = platform.system()
-    if system == "Darwin":
-        return ["brew", "install", "gh"] if shutil.which("brew") else None
-    if system == "Linux":
-        return linux_install_command()
-    if system == "Windows":
-        return windows_install_command()
-    return None
-
-
-def missing_package_manager_hint():
-    system = platform.system()
-    if system == "Darwin":
-        info("Homebrew not found. Install it from https://brew.sh, then re-run.")
-    elif system == "Linux":
-        info("No supported package manager found (apt-get, dnf, pacman, apk, zypper).")
-    elif system == "Windows":
-        info("No supported package manager found (winget, scoop, choco).")
-    else:
-        info(f"Unsupported platform: {system}")
-    info(f"You can also grab a binary from [accent]{RELEASES_URL}[/accent]")
-
-
-def install_gh(reinstall=False):
-    """Install the GitHub CLI. Returns True when `gh` ends up runnable."""
-    step("Installing GitHub CLI")
-
-    version = gh_version()
-    if version and not reinstall:
-        info(f"gh already installed ({version}); skipping install")
-        return True
-
-    command = install_command()
-    if command is None:
-        error("Could not install gh automatically.")
-        missing_package_manager_hint()
-        return False
-
-    try:
-        run_command(command, status="Installing gh", stdin=subprocess.DEVNULL, timeout=900)
-    except CommandError as exc:
-        error(f"Installing gh failed: {exc}")
-        info(f"Install it manually from [accent]{RELEASES_URL}[/accent]")
-        return False
-
-    version = gh_version()
-    if not version:
-        warning("gh installed but it is not on PATH yet")
-        info("Open a new terminal, then run `gh --version` to confirm.")
-        return False
-
-    success(f"gh installed ({version})")
-    return True
-
-
-def check_gh_auth():
-    """Report whether gh holds GitHub credentials.
-
-    `gh auth status` is read-only and exits non-zero when logged out, so it is
-    safe here. `gh auth login` is not: it needs a TTY and a browser, so leave it
-    to the user rather than blocking the run on it.
-    """
-    step("Checking GitHub authentication")
-    result = run_command(
-        ["gh", "auth", "status"],
-        status="Running gh auth status",
-        stdin=subprocess.DEVNULL,
-        timeout=60,
-        check=False,
-    )
-    if getattr(result, "returncode", None) == 0:
-        success("gh is authenticated")
-        return True
-
-    warning("gh is not authenticated")
-    info("Run [accent]gh auth login[/accent] in your terminal; it opens a browser to sign in.")
-    return False
-
-
-def print_summary(installed, authenticated, auth_checked):
-    console.print()
-    if not installed:
-        console.print(
-            Panel(
-                f"gh was not installed. Install it manually from [accent]{RELEASES_URL}[/accent], then re-run.",
-                title="setup gh incomplete",
-                border_style="warning",
-                expand=False,
-            )
-        )
-        return
-
-    lines = [f"GitHub CLI [accent]{gh_version()}[/accent] is ready."]
-    if not auth_checked:
-        lines.append("Auth check skipped; run [accent]gh auth status[/accent] to see if you are signed in.")
-    elif authenticated:
-        lines.append("You are signed in; `gh pr`, `gh issue` and Claude Code's GitHub workflows will work.")
-    else:
-        lines.append("Sign in with [accent]gh auth login[/accent] to finish setting it up.")
-
-    console.print(
-        Panel(
-            "\n".join(lines),
-            title="setup gh complete",
-            border_style="success",
-            expand=False,
-        )
-    )
-
-
-@click.command("gh", epilog=EPILOG)
-@click.option("--reinstall", is_flag=True, help="Install even if gh is already present.")
-@click.option("--skip-auth-check", is_flag=True, help="Skip the `gh auth status` check afterwards.")
-def setup_gh(reinstall, skip_auth_check):
-    """Install the GitHub CLI (gh) and check whether it is signed in.
-
-    Uses the package manager for your platform - Homebrew on macOS, apt/dnf/
-    pacman/apk/zypper on Linux, winget/scoop/choco on Windows - following
-    GitHub's official instructions (on Debian/Ubuntu that means adding GitHub's
-    keyring and apt source, since gh is not in the default repos).
-
-    An existing install is left alone unless --reinstall is passed. Signing in is
-    left to you: `gh auth login` needs an interactive terminal and a browser, so
-    this command only reports whether credentials are already present.
-    """
-    step("evo setup gh")
-    installed = install_gh(reinstall)
-    authenticated = False
-    if installed and not skip_auth_check:
-        authenticated = check_gh_auth()
-    print_summary(installed, authenticated, auth_checked=not skip_auth_check)

evo_cli-0.11.0/tests/test_gh.py

@@ -1,146 +0,0 @@
-import pytest
-from click.testing import CliRunner
-
-from evo_cli.cli import cli
-from evo_cli.commands import gh as gh_mod
-from evo_cli.commands.gh import check_gh_auth, gh_version, install_command, install_gh
-
-
-@pytest.fixture
-def runner():
-    return CliRunner()
-
-
-def only_which(*available):
-    """A shutil.which stub that finds only the named binaries."""
-    return lambda name: f"/usr/bin/{name}" if name in available else None
-
-
-def test_gh_command_is_registered():
-    assert "gh" in cli.commands["setup"].commands
-
-
-def test_gh_help_runs(runner):
-    result = runner.invoke(cli, ["setup", "gh", "--help"])
-    assert result.exit_code == 0
-    assert "GitHub CLI" in result.output
-
-
-def test_install_command_macos_uses_brew(monkeypatch):
-    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Darwin")
-    monkeypatch.setattr(gh_mod.shutil, "which", only_which("brew"))
-    assert install_command() == ["brew", "install", "gh"]
-
-
-def test_install_command_macos_without_brew(monkeypatch):
-    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Darwin")
-    monkeypatch.setattr(gh_mod.shutil, "which", only_which())
-    assert install_command() is None
-
-
-def test_install_command_apt_adds_github_repo(monkeypatch):
-    """gh is not in the default Debian/Ubuntu repos, so the keyring must be set up."""
-    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Linux")
-    monkeypatch.setattr(gh_mod.shutil, "which", only_which("apt-get"))
-    command = install_command()
-    assert command[:2] == ["bash", "-c"]
-    assert "githubcli-archive-keyring.gpg" in command[2]
-    assert "sudo apt install gh -y" in command[2]
-
-
-def test_install_command_pacman(monkeypatch):
-    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Linux")
-    monkeypatch.setattr(gh_mod.shutil, "which", only_which("pacman"))
-    assert install_command() == ["sudo", "pacman", "-S", "--noconfirm", "github-cli"]
-
-
-def test_install_command_linux_without_package_manager(monkeypatch):
-    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Linux")
-    monkeypatch.setattr(gh_mod.shutil, "which", only_which())
-    assert install_command() is None
-
-
-def test_install_command_windows_winget_is_non_interactive(monkeypatch):
-    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Windows")
-    monkeypatch.setattr(gh_mod.shutil, "which", only_which("winget"))
-    command = install_command()
-    assert command[:4] == ["winget", "install", "--id", "GitHub.cli"]
-    assert "--accept-package-agreements" in command
-
-
-def test_install_command_windows_falls_back_to_scoop(monkeypatch):
-    monkeypatch.setattr(gh_mod.platform, "system", lambda: "Windows")
-    monkeypatch.setattr(gh_mod.shutil, "which", only_which("scoop"))
-    assert install_command() == ["scoop", "install", "gh"]
-
-
-def test_gh_version_none_when_missing(monkeypatch):
-    monkeypatch.setattr(gh_mod.shutil, "which", only_which())
-    assert gh_version() is None
-
-
-def test_install_gh_skips_when_present(monkeypatch):
-    monkeypatch.setattr(gh_mod, "gh_version", lambda: "2.62.0")
-    monkeypatch.setattr(gh_mod, "run_command", lambda *a, **kw: pytest.fail("must not install"))
-    assert install_gh() is True
-
-
-def test_install_gh_reinstall_runs_the_installer(monkeypatch):
-    calls = []
-    monkeypatch.setattr(gh_mod, "gh_version", lambda: "2.62.0")
-    monkeypatch.setattr(gh_mod, "install_command", lambda: ["brew", "install", "gh"])
-    monkeypatch.setattr(gh_mod, "run_command", lambda cmd, **kw: calls.append(cmd))
-    assert install_gh(reinstall=True) is True
-    assert calls == [["brew", "install", "gh"]]
-
-
-def test_install_gh_fails_without_package_manager(monkeypatch):
-    monkeypatch.setattr(gh_mod, "gh_version", lambda: None)
-    monkeypatch.setattr(gh_mod, "install_command", lambda: None)
-    monkeypatch.setattr(gh_mod, "run_command", lambda *a, **kw: pytest.fail("must not install"))
-    assert install_gh() is False
-
-
-def test_install_gh_reports_failed_install(monkeypatch):
-    monkeypatch.setattr(gh_mod, "gh_version", lambda: None)
-    monkeypatch.setattr(gh_mod, "install_command", lambda: ["brew", "install", "gh"])
-
-    def boom(cmd, **kwargs):
-        raise gh_mod.CommandError("brew exploded")
-
-    monkeypatch.setattr(gh_mod, "run_command", boom)
-    assert install_gh() is False
-
-
-def test_install_gh_detects_binary_not_on_path(monkeypatch):
-    """A package manager can succeed while the binary is still not reachable."""
-    monkeypatch.setattr(gh_mod, "gh_version", lambda: None)
-    monkeypatch.setattr(gh_mod, "install_command", lambda: ["brew", "install", "gh"])
-    monkeypatch.setattr(gh_mod, "run_command", lambda cmd, **kw: None)
-    assert install_gh() is False
-
-
-class FakeResult:
-    def __init__(self, returncode):
-        self.returncode = returncode
-
-
-def test_check_gh_auth_signed_in(monkeypatch):
-    monkeypatch.setattr(gh_mod, "run_command", lambda cmd, **kw: FakeResult(0))
-    assert check_gh_auth() is True
-
-
-def test_check_gh_auth_signed_out(monkeypatch):
-    """`gh auth status` exits non-zero when logged out; that must not be fatal."""
-    monkeypatch.setattr(gh_mod, "run_command", lambda cmd, **kw: FakeResult(1))
-    assert check_gh_auth() is False
-
-
-def test_setup_gh_skip_auth_check(runner, monkeypatch):
-    monkeypatch.setattr(gh_mod, "install_gh", lambda reinstall: True)
-    monkeypatch.setattr(gh_mod, "gh_version", lambda: "2.62.0")
-    monkeypatch.setattr(gh_mod, "check_gh_auth", lambda: pytest.fail("must not check auth"))
-
-    result = runner.invoke(cli, ["setup", "gh", "--skip-auth-check"])
-    assert result.exit_code == 0
-    assert "Auth check skipped" in result.output