evo-cli 0.31.0__tar.gz → 0.31.2__tar.gz

{evo_cli-0.31.0 → evo_cli-0.31.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.31.0
+Version: 0.31.2
 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.31.2/evo_cli/VERSION

@@ -0,0 +1 @@
+0.31.2

{evo_cli-0.31.0 → evo_cli-0.31.2}/evo_cli/commands/openvpn.py

@@ -42,12 +42,22 @@ def _table(rows):
             _state_text(state["state"]),
             state.get("vpn_ip", ""),
             (profile.get("remotes") or [""])[0],
-            "yes" if profile.get("password") else "no",
+            _creds(profile),
             "yes" if profile.get("totp") else "no",
         )
     return table
 
 
+def _creds(profile):
+    """CREDS column: a certificate-only profile shows "cert", as it needs no username or password."""
+    if profile.get("password"):
+        return "yes"
+    try:
+        return "no" if vpn.uses_credentials(profile.get("config", "")) else "cert"
+    except vpn.CredentialError:
+        return "no"
+
+
 def _rows():
     profiles = _guard(vpn.profiles)
     return [(name, profiles[name], _guard(vpn.request, name)) for name in sorted(profiles)]
@@ -322,7 +332,7 @@ def connect(name, timeout, sudo_password_stdin, watch):
     _guard(vpn.validate_config, profile["config"])
     if not shutil.which("openvpn"):
         raise click.ClickException("Install OpenVPN first (macOS: brew install openvpn; Linux: your package manager).")
-    if not profile.get("username") or not profile.get("password"):
+    if _guard(vpn.uses_credentials, profile["config"]) and not (profile.get("username") and profile.get("password")):
         raise click.ClickException("Missing credentials; run evo openvpn credentials PROFILE.")
     if _guard(vpn.request, name)["state"] != "STOPPED":
         raise click.ClickException("This profile already has a worker; use status or disconnect first.")

{evo_cli-0.31.0 → evo_cli-0.31.2}/evo_cli/commands/update.py

@@ -18,11 +18,16 @@ from evo_cli import __version__
 from evo_cli.console import CommandError, console, info, run_command, step, success, warning
 
 PACKAGE = "evo_cli"
+TOOL_NAME = "evo-cli"
 PYPI_JSON = "https://pypi.org/pypi/{package}/json"
 
 VERSION_RE = re.compile(r"^v?(\d+(?:\.\d+)*)(?:[-_.]?(dev|alpha|a|beta|b|rc|c|pre)[-_.]?(\d*))?")
 PRE_RANK = {"dev": -4, "alpha": -3, "a": -3, "beta": -2, "b": -2, "pre": -1, "rc": -1, "c": -1}
 
+EXACT_PIN_RE = re.compile(r"^===?\s*([^\s,*]+)$")
+PLAIN_RECEIPT_KEYS = {"requirements", "python", "entrypoints", "options"}
+PLAIN_REQUIREMENT_KEYS = {"name", "extras", "specifier"}
+
 EPILOG = Text.from_markup(
     "[bold]Examples[/bold]\n\n"
     "  [cyan]evo update[/cyan]              update to the newest release\n"
@@ -31,7 +36,9 @@ EPILOG = Text.from_markup(
     "  [cyan]evo update --dry-run[/cyan]    print the commands without running them\n"
     "  [cyan]evo update --force[/cyan]      reinstall even when already current\n\n"
     "[dim]An editable checkout is updated with git (fast-forward only, refusing to touch a\n"
-    "dirty tree); a pipx, uv or pip install is upgraded with its own installer.[/dim]"
+    "dirty tree); a pipx, uv or pip install is upgraded with its own installer. A uv tool\n"
+    "pinned to an older ==version is reinstalled without the pin. The update succeeds only\n"
+    "when the installed version reaches the newest release afterwards.[/dim]"
 )
 
 
@@ -138,7 +145,79 @@ def report(install, current, latest):
     console.print()
 
 
-def build_commands(mode, allow_pre):
+def load_toml(path):
+    try:
+        import tomllib
+    except ImportError:  # Python 3.10
+        try:
+            import tomli as tomllib
+        except ImportError:
+            return {}
+    try:
+        with open(path, "rb") as handle:
+            return tomllib.load(handle)
+    except (OSError, ValueError):
+        return {}
+
+
+def normalize_name(name):
+    return re.sub(r"[-_.]+", "-", str(name or "")).lower()
+
+
+def uv_receipt(location):
+    """The `[tool]` table of a uv tool receipt and its evo-cli requirement (None when absent)."""
+    tool = load_toml(Path(location) / "uv-receipt.toml").get("tool") or {}
+    for requirement in tool.get("requirements") or []:
+        if isinstance(requirement, dict) and normalize_name(requirement.get("name")) == TOOL_NAME:
+            return tool, requirement
+    return tool, None
+
+
+def exact_pin(requirement):
+    match = EXACT_PIN_RE.match(str((requirement or {}).get("specifier") or "").strip())
+    return match.group(1) if match else None
+
+
+def requirement_text(requirement, specifier):
+    extras = requirement.get("extras") or []
+    name = requirement["name"] + (f"[{','.join(extras)}]" if extras else "")
+    return f"{name}{specifier}"
+
+
+def uv_reinstall_command(location, latest, allow_pre):
+    """Reinstall a uv tool whose receipt pins an older `==` version, since `uv tool upgrade` keeps the pin.
+
+    Only a plain receipt is rebuilt: one evo-cli requirement from the index plus an optional Python
+    request. Anything more (`--with`, a git source, index options) goes through `uv tool upgrade`,
+    and the version check afterwards says what to run.
+    """
+    tool, requirement = uv_receipt(location)
+    pinned = exact_pin(requirement)
+    if latest is None or pinned is None or parse_version(pinned) >= parse_version(latest):
+        return None
+    if set(tool) - PLAIN_RECEIPT_KEYS or any((tool.get("options") or {}).values()):
+        return None
+    if len(tool.get("requirements") or []) != 1 or set(requirement) - PLAIN_REQUIREMENT_KEYS:
+        return None
+    info(f"The uv receipt pins [accent]{TOOL_NAME}=={pinned}[/accent], so the tool is reinstalled without the pin.")
+    cmd = [
+        "uv",
+        "tool",
+        "install",
+        "--force",
+        "--refresh-package",
+        requirement["name"],
+        requirement_text(requirement, f">={latest}"),
+    ]
+    if tool.get("python"):
+        cmd += ["--python", str(tool["python"])]
+    if allow_pre:
+        cmd.append("--prerelease=allow")
+    return cmd
+
+
+def build_commands(install, latest, allow_pre):
+    mode = install["mode"]
     target = f"{PACKAGE}"
     if mode == "pipx":
         if shutil.which("pipx") is None:
@@ -150,6 +229,9 @@ def build_commands(mode, allow_pre):
     if mode == "uv":
         if shutil.which("uv") is None:
             raise click.ClickException("This looks like a uv tool install but uv is not on PATH.")
+        reinstall = uv_reinstall_command(install["location"], latest, allow_pre)
+        if reinstall:
+            return [reinstall]
         cmd = ["uv", "tool", "upgrade", target]
         if allow_pre:
             cmd.append("--prerelease=allow")
@@ -163,6 +245,80 @@ def build_commands(mode, allow_pre):
     return [cmd]
 
 
+def installed_version():
+    """The evo version the install holds now, read by a new interpreter: this process keeps the old one.
+
+    The probe drops the current directory ("") from sys.path so that a checkout's egg-info cannot answer.
+    """
+    code = (
+        "import sys; sys.path = [p for p in sys.path if p]; "
+        f"from importlib.metadata import version; print(version({PACKAGE!r}))"
+    )
+    probe = subprocess.run(
+        [sys.executable, "-c", code],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+    )
+    version = (probe.stdout or "").strip()
+    return version if probe.returncode == 0 and version else None
+
+
+def pipx_spec(location):
+    try:
+        data = json.loads((Path(location) / "pipx_metadata.json").read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return (data.get("main_package") or {}).get("package_or_url")
+
+
+def stale_hint(install, latest):
+    """Why the installer stopped short of `latest`, and the command that gets there."""
+    location = install["location"]
+    if install["mode"] == "uv":
+        _, requirement = uv_receipt(location)
+        specifier = (requirement or {}).get("specifier")
+        fix = f"uv tool install --force --refresh-package {TOOL_NAME} '{TOOL_NAME}>={latest}'"
+        if specifier:
+            receipt = Path(location) / "uv-receipt.toml"
+            return (
+                f"{receipt} pins {TOOL_NAME}{specifier}, which `uv tool upgrade` keeps. "
+                f"Reinstall without the pin:\n  {fix}"
+            )
+        return f"uv may have read a cached package index from before the release. Refresh it:\n  {fix}"
+    if install["mode"] == "pipx":
+        fix = f"pipx install --force '{TOOL_NAME}>={latest}'"
+        spec = pipx_spec(location)
+        if spec and re.search(r"[=<>~!]", spec):
+            return f"pipx installed evo as {spec}, which `pipx upgrade` keeps. Reinstall without the pin:\n  {fix}"
+        return f"Reinstall it:\n  {fix}"
+    return (
+        "A pip constraint or a cached index may hold it back. Run:\n"
+        f"  {sys.executable} -m pip install --upgrade '{TOOL_NAME}>={latest}'"
+    )
+
+
+def confirm_update(install, current, latest):
+    """Report success only for the version that is really installed now."""
+    installed = installed_version()
+    if installed is None:
+        raise click.ClickException("The installer finished, but the installed evo version cannot be read.")
+    if latest is None:
+        if installed == current:
+            warning(f"evo is still at [accent]{installed}[/accent], and PyPI did not say whether a newer one exists.")
+        else:
+            success(f"evo is now at [accent]{installed}[/accent].")
+        return
+    if parse_version(installed) < parse_version(latest):
+        raise click.ClickException(
+            f"evo is still at {installed}, not {latest}, after the update. {stale_hint(install, latest)}"
+        )
+    success(f"evo updated to [accent]{installed}[/accent].")
+    info("Open a new shell if the `evo` command still reports the old version.")
+
+
 def execute(commands, dry_run):
     for cmd in commands:
         if dry_run:
@@ -238,7 +394,7 @@ def update_editable(path, check, force, dry_run):
         success(f"evo is now at [accent]{version_file.read_text(encoding='utf-8').strip()}[/accent]")
 
 
-def update_package(mode, current, latest, check, allow_pre, force, dry_run):
+def update_package(install, current, latest, check, allow_pre, force, dry_run):
     if latest is None:
         if check:
             raise click.ClickException("Cannot determine the latest version from PyPI.")
@@ -253,10 +409,9 @@ def update_package(mode, current, latest, check, allow_pre, force, dry_run):
         info("Run [accent]evo update[/accent] to install it.")
         return
 
-    execute(build_commands(mode, allow_pre), dry_run)
+    execute(build_commands(install, latest, allow_pre), dry_run)
     if not dry_run:
-        success(f"evo updated to [accent]{latest or 'the latest release'}[/accent].")
-        info("Open a new shell if the `evo` command still reports the old version.")
+        confirm_update(install, current, latest)
 
 
 @click.command("update", epilog=EPILOG, context_settings={"help_option_names": ["-h", "--help"]})
@@ -288,4 +443,4 @@ def update(check, allow_pre, force, dry_run, timeout):
     if install["mode"] == "editable":
         update_editable(install["location"], check, force, dry_run)
         return
-    update_package(install["mode"], __version__, latest, check, allow_pre, force, dry_run)
+    update_package(install, __version__, latest, check, allow_pre, force, dry_run)

{evo_cli-0.31.0 → evo_cli-0.31.2}/evo_cli/openvpn.py

@@ -178,6 +178,11 @@ def validate_config(text):
     return remotes
 
 
+def uses_credentials(text):
+    """Whether OpenVPN will ask for a username and password; a certificate-only profile never does."""
+    return any(words[0].removeprefix("--") == "auth-user-pass" for _, words in _directives(text))
+
+
 def takes_default_route(text):
     """Whether a profile may take the default route. Only split-tunnel profiles can run beside another VPN.
 

{evo_cli-0.31.0 → evo_cli-0.31.2}/evo_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.31.0
+Version: 0.31.2
 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.31.0 → evo_cli-0.31.2}/tests/test_openvpn.py

@@ -126,6 +126,21 @@ def test_split_tunnel_is_only_what_provably_keeps_the_default_route(extra, full)
     assert vpn.takes_default_route(CONFIG + extra) is full
 
 
+CERT_ONLY = CONFIG.replace("auth-user-pass\n", "")
+
+
+@pytest.mark.parametrize(
+    "config,expected",
+    [
+        (CONFIG, True),
+        (CERT_ONLY, False),
+        (CERT_ONLY + "<key>\nauth-user-pass\n</key>\n", False),
+    ],
+)
+def test_only_auth_user_pass_asks_for_credentials(config, expected):
+    assert vpn.uses_credentials(config) is expected
+
+
 @pytest.mark.parametrize(
     "platform,output,gateway",
     [
@@ -450,6 +465,35 @@ def test_connect_stacks_a_split_tunnel_beside_a_full_one_only(store, monkeypatch
     assert "default route" not in result.output and started, result.output
 
 
+def test_cert_only_profile_connects_and_lists_without_credentials(store, monkeypatch):
+    vpn.save_profile("cert", {"config": CERT_ONLY})
+    vpn.save_profile("login", {"config": CONFIG})
+    monkeypatch.setattr(vpn, "request", lambda name, command="status": {"state": "STOPPED"})
+    monkeypatch.setattr("evo_cli.commands.openvpn.shutil.which", lambda _: "/fake/openvpn")
+    monkeypatch.setattr("evo_cli.commands.openvpn.os.geteuid", lambda: 0)
+    started = []
+
+    class Exited:
+        def __init__(self):
+            self.stdin = io.BytesIO()
+
+        def poll(self):
+            return 1
+
+    monkeypatch.setattr(
+        "evo_cli.commands.openvpn.subprocess.Popen", lambda command, **_: started.append(command) or Exited()
+    )
+    runner = CliRunner()
+    result = runner.invoke(cli, ["openvpn", "connect", "login", "--no-watch"])
+    assert result.exit_code != 0 and "Missing credentials" in result.output and not started
+    result = runner.invoke(cli, ["openvpn", "connect", "cert", "--no-watch"])
+    assert "Missing credentials" not in result.output and started, result.output
+    rows = {
+        line.split()[1]: line.split()[-2] for line in runner.invoke(cli, ["openvpn", "list"]).output.splitlines()[1:3]
+    }
+    assert rows == {"cert": "cert", "login": "no"}
+
+
 def test_pick_profile_by_number_single_or_prompt(store, monkeypatch):
     runner = CliRunner()
     totp = vpn.parse_totp(SECRET)

{evo_cli-0.31.0 → evo_cli-0.31.2}/tests/test_update.py

@@ -1,4 +1,5 @@
 import subprocess
+import sys
 
 from click.testing import CliRunner
 
@@ -18,6 +19,29 @@ def _stub_pypi(monkeypatch, versions):
     monkeypatch.setattr(update_command, "fetch_pypi", lambda package, timeout: _pypi(versions))
 
 
+def _stub_installer(monkeypatch, installed_after):
+    """Record the installer commands; the version probe then reports `installed_after`."""
+    ran = []
+    monkeypatch.setattr(update_command, "run_command", lambda cmd: ran.append([str(part) for part in cmd]))
+
+    def fake_run(cmd, **kwargs):
+        assert cmd[0] == sys.executable
+        return _result(stdout=f"{installed_after}\n")
+
+    monkeypatch.setattr(update_command.subprocess, "run", fake_run)
+    return ran
+
+
+def _uv_install(monkeypatch, tmp_path, receipt):
+    (tmp_path / "uv-receipt.toml").write_text(receipt, encoding="utf-8")
+    monkeypatch.setattr(update_command, "detect_install", lambda: {"mode": "uv", "location": tmp_path})
+    monkeypatch.setattr(update_command.shutil, "which", lambda name: f"/usr/bin/{name}")
+
+
+def _flat(output):
+    return " ".join(output.replace("│", " ").split())
+
+
 def test_update_command_is_registered():
     assert "update" in cli.commands
 
@@ -76,14 +100,113 @@ def test_update_runs_pip_upgrade_when_outdated(monkeypatch):
     _stub_pypi(monkeypatch, ["0.11.3", "0.12.0"])
     monkeypatch.setattr(update_command, "detect_install", lambda: {"mode": "pip", "location": "/venv"})
     monkeypatch.setattr(update_command, "__version__", "0.11.3")
-    monkeypatch.setattr(update_command, "build_commands", lambda mode, allow_pre: [["pip", "install", "-U", mode]])
+    monkeypatch.setattr(
+        update_command, "build_commands", lambda install, latest, allow_pre: [["pip", "install", "-U", install["mode"]]]
+    )
     calls = []
     monkeypatch.setattr(update_command, "execute", lambda commands, dry_run: calls.append((commands, dry_run)))
+    _stub_installer(monkeypatch, "0.12.0")
 
     result = CliRunner().invoke(cli, ["update"])
 
     assert result.exit_code == 0
     assert calls == [([["pip", "install", "-U", "pip"]], False)]
+    assert "evo updated to 0.12.0" in result.output
+
+
+def test_update_fails_when_the_upgrade_leaves_the_old_version(monkeypatch):
+    _stub_pypi(monkeypatch, ["0.11.3", "0.12.0"])
+    monkeypatch.setattr(update_command, "detect_install", lambda: {"mode": "pip", "location": "/venv"})
+    monkeypatch.setattr(update_command, "__version__", "0.11.3")
+    ran = _stub_installer(monkeypatch, "0.11.3")
+
+    result = CliRunner().invoke(cli, ["update"])
+
+    assert result.exit_code == 1
+    assert ran == [[sys.executable, "-m", "pip", "install", "--upgrade", "evo_cli"]]
+    assert "evo updated" not in result.output
+    assert "evo is still at 0.11.3, not 0.12.0" in _flat(result.output)
+
+
+def test_uv_update_reinstalls_over_a_stale_exact_pin(monkeypatch, tmp_path):
+    _stub_pypi(monkeypatch, ["0.31.0", "0.31.1"])
+    monkeypatch.setattr(update_command, "__version__", "0.31.0")
+    _uv_install(
+        monkeypatch,
+        tmp_path,
+        '[tool]\nrequirements = [{ name = "evo-cli", specifier = "==0.31.0" }]\n'
+        'entrypoints = [{ name = "evo", install-path = "/home/me/.local/bin/evo" }]\n',
+    )
+    ran = _stub_installer(monkeypatch, "0.31.1")
+
+    result = CliRunner().invoke(cli, ["update"])
+
+    assert result.exit_code == 0, result.output
+    assert ran == [["uv", "tool", "install", "--force", "--refresh-package", "evo-cli", "evo-cli>=0.31.1"]]
+    assert "pins evo-cli==0.31.0" in _flat(result.output)
+    assert "evo updated to 0.31.1" in result.output
+
+
+def test_uv_reinstall_keeps_extras_and_python(monkeypatch, tmp_path):
+    _stub_pypi(monkeypatch, ["0.31.0", "0.31.1"])
+    monkeypatch.setattr(update_command, "__version__", "0.31.0")
+    _uv_install(
+        monkeypatch,
+        tmp_path,
+        '[tool]\nrequirements = [{ name = "evo-cli", extras = ["image"], specifier = "==0.31.0" }]\npython = "3.13"\n',
+    )
+    ran = _stub_installer(monkeypatch, "0.31.1")
+
+    result = CliRunner().invoke(cli, ["update"])
+
+    assert result.exit_code == 0, result.output
+    assert ran == [
+        [
+            "uv",
+            "tool",
+            "install",
+            "--force",
+            "--refresh-package",
+            "evo-cli",
+            "evo-cli[image]>=0.31.1",
+            "--python",
+            "3.13",
+        ]
+    ]
+
+
+def test_uv_upgrade_held_by_a_pin_it_cannot_rebuild_fails_with_the_fix(monkeypatch, tmp_path):
+    _stub_pypi(monkeypatch, ["0.31.0", "0.31.1"])
+    monkeypatch.setattr(update_command, "__version__", "0.31.0")
+    _uv_install(
+        monkeypatch,
+        tmp_path,
+        '[tool]\nrequirements = [{ name = "evo-cli", specifier = "==0.31.0" }, { name = "rich" }]\n',
+    )
+    ran = _stub_installer(monkeypatch, "0.31.0")
+
+    result = CliRunner().invoke(cli, ["update"])
+    output = _flat(result.output)
+
+    assert result.exit_code == 1
+    assert ran == [["uv", "tool", "upgrade", "evo_cli"]]
+    assert "evo updated" not in result.output
+    assert "evo is still at 0.31.0, not 0.31.1" in output
+    assert "pins evo-cli==0.31.0" in output
+    assert "uv tool install --force --refresh-package evo-cli 'evo-cli>=0.31.1'" in output
+
+
+def test_uv_upgrade_without_a_pin_skips_the_reinstall(monkeypatch, tmp_path):
+    _stub_pypi(monkeypatch, ["0.31.0", "0.31.1"])
+    monkeypatch.setattr(update_command, "__version__", "0.31.0")
+    _uv_install(monkeypatch, tmp_path, '[tool]\nrequirements = [{ name = "evo-cli" }]\n')
+    ran = _stub_installer(monkeypatch, "0.31.1")
+
+    result = CliRunner().invoke(cli, ["update"])
+
+    assert result.exit_code == 0, result.output
+    assert ran == [["uv", "tool", "upgrade", "evo_cli"]]
+    assert "evo updated to 0.31.1" in result.output
 
 
 def test_editable_update_pulls_and_reports_head(monkeypatch, tmp_path):
@@ -167,7 +290,9 @@ def test_dry_run_prints_commands_without_running_them(monkeypatch):
     _stub_pypi(monkeypatch, ["0.11.3", "0.12.0"])
     monkeypatch.setattr(update_command, "detect_install", lambda: {"mode": "pip", "location": "/venv"})
     monkeypatch.setattr(update_command, "__version__", "0.11.3")
-    monkeypatch.setattr(update_command, "build_commands", lambda mode, allow_pre: [["pip", "install", "-U", "evo_cli"]])
+    monkeypatch.setattr(
+        update_command, "build_commands", lambda install, latest, allow_pre: [["pip", "install", "-U", "evo_cli"]]
+    )
     monkeypatch.setattr(update_command, "run_command", lambda cmd: (_ for _ in ()).throw(AssertionError("ran")))
 
     result = CliRunner().invoke(cli, ["update", "--dry-run"])

evo_cli-0.31.0/evo_cli/VERSION

@@ -1 +0,0 @@
-0.31.0