ixt-cli 0.10.0__tar.gz → 0.10.1__tar.gz

{ixt_cli-0.10.0 → ixt_cli-0.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: ixt-cli
-Version: 0.10.0
+Version: 0.10.1
 Summary: Universal CLI tool isolator - manage Python, Node, and binary tools with per-tool isolation
 Project-URL: Homepage, https://gitlab.com/pytgaen-group/ixt
 Project-URL: Repository, https://gitlab.com/pytgaen-group/ixt.git

{ixt_cli-0.10.0 → ixt_cli-0.10.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ixt-cli"
-version = "0.10.0" # to bump
+version = "0.10.1"  # to bump
 description = "Universal CLI tool isolator - manage Python, Node, and binary tools with per-tool isolation"
 readme = "README.md"
 requires-python = ">=3.10"

{ixt_cli-0.10.0 → ixt_cli-0.10.1}/src/ixt/__init__.py

@@ -1,8 +1,6 @@
 """ixt — Universal CLI Tool Isolator"""
 
-from importlib.metadata import version
-
-__version__ = version("ixt-cli")
+__version__ = "0.10.1"  # to bump
 __author__ = "Gaetan"
 
 __all__ = ["__author__", "__version__"]

{ixt_cli-0.10.0 → ixt_cli-0.10.1}/src/ixt/backends/binary.py

@@ -6,6 +6,7 @@ import hashlib
 import json
 import os
 import re
+import shutil
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import TYPE_CHECKING, TypedDict
@@ -20,7 +21,9 @@ from ixt.config.flags import is_setup_toml_enabled
 from ixt.config.heuristics import (
     get_name_suffix_tokens,
     get_platform_aliases,
+    has_any_token,
     is_asset_arch_compatible,
+    libc_tokens,
     load_heuristics,
     select_asset,
 )
@@ -42,6 +45,7 @@ from ixt.platform import get_arch, get_os
 __all__ = [
     "AssetSelectionError",
     "BinaryBackend",
+    "BinaryNoExecutableError",
     "BinaryPlatformError",
     "BinarySpecError",
     "HookEntry",
@@ -139,6 +143,78 @@ class BinaryPlatformError(RuntimeError):
         )
 
 
+def _empty_dir(path: Path) -> None:
+    """Remove everything inside *path*, keeping the directory itself."""
+    if not path.is_dir():
+        return
+    for entry in path.iterdir():
+        if entry.is_dir() and not entry.is_symlink():
+            shutil.rmtree(entry, ignore_errors=True)
+        else:
+            entry.unlink(missing_ok=True)
+
+
+def _doomed_by_libc(release: Release, rejected: list[tuple[Path, str]], log) -> set[str]:
+    """Return the sibling assets built against a libc this host cannot load.
+
+    A candidate turned down for a missing loader condemns every asset built
+    against the same libc: downloading them to reach the very same verdict is
+    pure waste. Must be called while the rejected files are still on disk.
+    """
+    loaders = set()
+    for path, _label in rejected:
+        info = read_elf(path)
+        if info is not None and info.interpreter and info.loader_missing():
+            loaders.add(info.interpreter)
+    if not loaders:
+        return set()
+
+    cfg = load_heuristics()
+    tokens = sorted({token for loader in loaders for token in libc_tokens(loader, cfg)})
+    if not tokens:
+        return set()
+
+    doomed = {asset.name for asset in release.assets if has_any_token(asset.name, tokens)}
+    if doomed:
+        log.debug(f"skip (needs {'/'.join(tokens)} loader): {sorted(doomed)}")
+    return doomed
+
+
+def _rejection_reason(rejected: list[tuple[Path, str]]) -> str:
+    """Describe why an unpacked asset yielded nothing runnable."""
+    if not rejected:
+        return "no executable inside"
+    return ", ".join(
+        f"{path.name} ({label})" for path, label in sorted(rejected, key=lambda item: str(item[0]))
+    )
+
+
+class BinaryNoExecutableError(RuntimeError):
+    """Raised when the selected asset extracts without a single runnable file."""
+
+    def __init__(
+        self,
+        spec: str,
+        release_tag: str,
+        asset_name: str,
+        alternatives: list[str],
+    ):
+        self.spec = spec
+        self.release_tag = release_tag
+        self.asset_name = asset_name
+        self.alternatives = alternatives
+        message = (
+            f"No executable found in '{asset_name}' for '{spec}' (release {release_tag}). "
+            "The asset carries no runnable file — a shared library, headers or a "
+            "source archive rather than the tool itself."
+        )
+        if alternatives:
+            others = ", ".join(alternatives[:10])
+            message += f" Other assets in this release: {others}."
+        message += " Point --asset-pattern at another asset."
+        super().__init__(message)
+
+
 class BinarySpecError(ValueError):
     """Raised when a spec cannot be parsed as a binary backend spec."""
 
@@ -594,25 +670,7 @@ class BinaryBackend:
         )
         if asset_pattern:
             log.debug(f"user-forced asset_pattern: {asset_pattern!r}")
-        selection_pattern = _selection_pattern(effective_pattern, release.tag)
-        if locked_binary is None:
-            try:
-                asset = self._select_asset(
-                    release, selection_pattern, tool_name, spec, repo_spec=repo_spec
-                )
-            except AssetSelectionError:
-                # A synthesized release carries only the asset its pattern named.
-                # If that asset cannot run here, the pattern is wrong for this
-                # host, not merely stale — relearn it against the full release.
-                relearned = self._relearn_release(source, repo_spec, release)
-                if relearned is None:
-                    raise
-                release = relearned
-                selection_pattern = _selection_pattern(effective_pattern, release.tag)
-                asset = self._select_asset(
-                    release, selection_pattern, tool_name, spec, repo_spec=repo_spec
-                )
-        else:
+        if locked_binary is not None:
             asset = release.assets[0]
             if not is_asset_arch_compatible(
                 asset.name,
@@ -620,36 +678,33 @@ class BinaryBackend:
                 declared_platform=locked_binary.platform,
             ):
                 raise AssetSelectionError(spec, release.tag, [asset.name])
-        log.debug(f"selected asset: {asset.name}")
-
-        archive_path = self._download_asset(
-            source,
-            repo_spec,
-            asset,
-            cache_dir,
-            tag=release.tag,
-            upgrade=upgrade,
-        )
-        log.debug(f"archive: {archive_path}")
-
-        extract_tool_name = tool_name
-        if not is_archive(asset.name) and not (setup and setup.name):
-            extract_tool_name = _derive_bare_binary_name(asset.name, tool_name, release.tag)
-
-        result = extract(archive_path, env_dir, tool_name=extract_tool_name)
-        log.debug(f"extracted to: {result.root}")
-
-        heuristics = load_heuristics()
-        rejected_executables: list[tuple[Path, str]] = []
-        executables = find_executables(
-            result.root,
-            expose=heuristics.expose,
-            log=log,
-            rejected=rejected_executables,
-        )
-        log.debug(f"executables: {[e.name for e in executables]}")
-        if not executables and rejected_executables:
-            raise BinaryPlatformError(spec, release.tag, asset.name, rejected_executables)
+            executables = self._unpack(
+                source,
+                repo_spec,
+                release,
+                asset,
+                env_dir,
+                cache_dir,
+                spec=spec,
+                tool_name=tool_name,
+                setup=setup,
+                upgrade=upgrade,
+                log=log,
+            )
+        else:
+            asset, release, executables = self._unpack_first_runnable(
+                source,
+                repo_spec,
+                release,
+                env_dir,
+                cache_dir,
+                spec=spec,
+                tool_name=tool_name,
+                setup=setup,
+                effective_pattern=effective_pattern,
+                upgrade=upgrade,
+                log=log,
+            )
 
         binaries = {exe.name: str(exe) for exe in executables}
 
@@ -758,6 +813,187 @@ class BinaryBackend:
             )
         return setup
 
+    def _unpack_candidate(
+        self,
+        source: ReleaseSource,
+        repo_spec: RepoSpec,
+        release: Release,
+        asset: Asset,
+        env_dir: Path,
+        cache_dir: Path,
+        *,
+        tool_name: str,
+        setup: SetupConfig | None,
+        upgrade: bool,
+        log,
+    ) -> tuple[list[Path], list[tuple[Path, str]]]:
+        """Download *asset* into *env_dir* and report what can run on this host.
+
+        Returns the runnable executables and, when there are none, the files
+        that were found but rejected as incompatible.
+        """
+        log.debug(f"selected asset: {asset.name}")
+        archive_path = self._download_asset(
+            source,
+            repo_spec,
+            asset,
+            cache_dir,
+            tag=release.tag,
+            upgrade=upgrade,
+        )
+        log.debug(f"archive: {archive_path}")
+
+        extract_tool_name = tool_name
+        if not is_archive(asset.name) and not (setup and setup.name):
+            extract_tool_name = _derive_bare_binary_name(asset.name, tool_name, release.tag)
+
+        result = extract(archive_path, env_dir, tool_name=extract_tool_name)
+        log.debug(f"extracted to: {result.root}")
+
+        rejected: list[tuple[Path, str]] = []
+        executables = find_executables(
+            result.root,
+            expose=load_heuristics().expose,
+            log=log,
+            rejected=rejected,
+        )
+        log.debug(f"executables: {[e.name for e in executables]}")
+        return executables, rejected
+
+    def _unpack(
+        self,
+        source: ReleaseSource,
+        repo_spec: RepoSpec,
+        release: Release,
+        asset: Asset,
+        env_dir: Path,
+        cache_dir: Path,
+        *,
+        spec: str,
+        tool_name: str,
+        setup: SetupConfig | None,
+        upgrade: bool,
+        log,
+    ) -> list[Path]:
+        """Unpack the one asset a lockfile names, which has no fallback."""
+        executables, rejected = self._unpack_candidate(
+            source,
+            repo_spec,
+            release,
+            asset,
+            env_dir,
+            cache_dir,
+            tool_name=tool_name,
+            setup=setup,
+            upgrade=upgrade,
+            log=log,
+        )
+        if executables:
+            return executables
+        if rejected:
+            raise BinaryPlatformError(spec, release.tag, asset.name, rejected)
+        raise BinaryNoExecutableError(spec, release.tag, asset.name, [])
+
+    def _unpack_first_runnable(
+        self,
+        source: ReleaseSource,
+        repo_spec: RepoSpec,
+        release: Release,
+        env_dir: Path,
+        cache_dir: Path,
+        *,
+        spec: str,
+        tool_name: str,
+        setup: SetupConfig | None,
+        effective_pattern: str | None,
+        upgrade: bool,
+        log,
+    ) -> tuple[Asset, Release, list[Path]]:
+        """Try candidates in scoring order until one unpacks to something runnable.
+
+        An archive only says what it holds once unpacked: the tool, a shared
+        library shipped under the same os/arch tokens, or a build this host has
+        no loader for. Rather than fail on an unlucky first pick, a candidate
+        that unpacks to nothing usable is dropped and its siblings get their
+        turn — releases that ship a library beside the binary, or a musl build
+        beside the glibc one, resolve on the second pass.
+        """
+        excluded: set[str] = set()
+        tried: list[str] = []
+        first_rejection: tuple[str, list[tuple[Path, str]]] | None = None
+        relearned = False
+
+        while True:
+            selection_pattern = _selection_pattern(effective_pattern, release.tag)
+            try:
+                asset = self._select_asset(
+                    release,
+                    selection_pattern,
+                    tool_name,
+                    spec,
+                    repo_spec=repo_spec,
+                    exclude=excluded,
+                )
+            except AssetSelectionError:
+                # A synthesized release carries only the asset its pattern named.
+                # If that asset cannot run here, the pattern is wrong for this
+                # host, not merely stale — relearn it against the full release.
+                wider = None if relearned else self._relearn_release(source, repo_spec, release)
+                if wider is not None:
+                    relearned = True
+                    release = wider
+                    continue
+                if first_rejection is not None:
+                    name, rejected = first_rejection
+                    raise BinaryPlatformError(spec, release.tag, name, rejected) from None
+                if tried:
+                    # Nothing in the release unpacked to a runnable file. Name the
+                    # best candidate and let the user point at another asset: an
+                    # install that exposes nothing must never look successful.
+                    raise BinaryNoExecutableError(
+                        spec,
+                        release.tag,
+                        tried[0],
+                        [a.name for a in release.assets if a.name not in tried],
+                    ) from None
+                raise
+
+            executables, rejected = self._unpack_candidate(
+                source,
+                repo_spec,
+                release,
+                asset,
+                env_dir,
+                cache_dir,
+                tool_name=tool_name,
+                setup=setup,
+                upgrade=upgrade,
+                log=log,
+            )
+            if executables:
+                return asset, release, executables
+
+            log.debug(f"asset skip: {asset.name} — {_rejection_reason(rejected)}")
+            doomed = _doomed_by_libc(release, rejected, log)
+            _empty_dir(env_dir)
+            if effective_pattern is not None:
+                # The asset was named, by the user or by the tool's setup file.
+                # Quietly installing a different one would answer a question
+                # nobody asked: report what the named asset turned out to be.
+                if rejected:
+                    raise BinaryPlatformError(spec, release.tag, asset.name, rejected)
+                raise BinaryNoExecutableError(
+                    spec,
+                    release.tag,
+                    asset.name,
+                    [a.name for a in release.assets if a.name != asset.name],
+                )
+            tried.append(asset.name)
+            if rejected and first_rejection is None:
+                first_rejection = (asset.name, rejected)
+            excluded.add(asset.name)
+            excluded |= doomed
+
     def _select_asset(
         self,
         release: Release,
@@ -766,10 +1002,12 @@ class BinaryBackend:
         main_spec: str,
         *,
         repo_spec: RepoSpec | None = None,
+        exclude: set[str] | None = None,
     ) -> Asset:
         log = get_logger("binary")
         heuristics = load_heuristics()
-        candidates = list(release.assets)
+        excluded = exclude or set()
+        candidates = [a for a in release.assets if a.name not in excluded]
         unusable: list[tuple[str, str]] = []
 
         while candidates:

{ixt_cli-0.10.0 → ixt_cli-0.10.1}/src/ixt/cli/__init__.py

@@ -9,7 +9,6 @@ def main() -> int:
     """Entry point for ixt CLI."""
     import sys
 
-    from ixt.cli.commands import COMMANDS
     from ixt.cli.parser import build_parser, normalize_verbosity
 
     # 'exec' forwards every argument after the tool name to that tool, including
@@ -32,7 +31,9 @@ def main() -> int:
         parser.print_help()
         return 0
 
-    handler = COMMANDS.get(args.command)
+    from ixt.cli.commands import get_command
+
+    handler = get_command(args.command)
     if handler is None:
         parser.print_help()
         return 1

{ixt_cli-0.10.0 → ixt_cli-0.10.1}/src/ixt/cli/argparse_completion.py

@@ -451,7 +451,16 @@ def _render_zsh(root: CompletionCommand) -> str:
             "  esac",
             "}",
             "",
-            "compdef _ixt ixt",
+            # The trailer must serve both installation modes. Sourced through
+            # eval, it registers the function. Dropped in an fpath, the file
+            # body *is* _ixt under autoload, so redefining the function is all
+            # a first call would do and the first TAB would complete nothing;
+            # calling it right away is what makes that mode work.
+            'if [ "$funcstack[1]" = "_ixt" ]; then',
+            '  _ixt "$@"',
+            "else",
+            "  compdef _ixt ixt",
+            "fi",
             "",
         ]
     )

ixt_cli-0.10.1/src/ixt/cli/commands.py

@@ -0,0 +1,89 @@
+"""Command dispatch — resolves each ``cmd_*`` from its dedicated module.
+
+The actual implementations live in ``cli/cmd_install.py``, ``cli/cmd_upgrade.py``,
+``cli/cmd_info.py``, ``cli/cmd_config.py``, ``cli/cmd_apply.py`` and
+``cli/cmd_misc.py``. This module maps command names to them for ``cli.main``.
+
+Resolution is deferred to first use: importing every handler eagerly pulled in
+the whole CLI on each invocation, including the ones that never run a command
+(``--version``, ``--help``). Module-level ``__getattr__`` keeps
+``from ixt.cli.commands import cmd_install`` working all the same.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from importlib import import_module
+from typing import Any
+
+__all__ = ["get_command"]
+
+
+# Exported symbol -> module under ``ixt.cli`` that defines it.
+_SYMBOL_MODULES: dict[str, str] = {
+    "_log_not_found_hint": "cmd_install",
+    "cmd_add": "cmd_install",
+    "cmd_apply": "cmd_apply",
+    "cmd_cache": "cmd_cache",
+    "cmd_config": "cmd_config",
+    "cmd_doctor": "cmd_misc",
+    "cmd_environment": "cmd_misc",
+    "cmd_exec": "cmd_exec",
+    "cmd_export": "cmd_apply",
+    "cmd_info": "cmd_info",
+    "cmd_install": "cmd_install",
+    "cmd_list": "cmd_info",
+    "cmd_lock": "cmd_lock",
+    "cmd_registry": "cmd_registry",
+    "cmd_runtimes": "cmd_misc",
+    "cmd_setup": "cmd_misc",
+    "cmd_shell": "cmd_misc",
+    "cmd_uninstall": "cmd_install",
+    "cmd_upgrade": "cmd_upgrade",
+    "cmd_where": "cmd_misc",
+}
+
+# CLI command name -> handler symbol.
+_COMMANDS: dict[str, str] = {
+    "add": "cmd_add",
+    "install": "cmd_install",
+    "uninstall": "cmd_uninstall",
+    "upgrade": "cmd_upgrade",
+    "list": "cmd_list",
+    "info": "cmd_info",
+    "exec": "cmd_exec",
+    "config": "cmd_config",
+    "shell": "cmd_shell",
+    "where": "cmd_where",
+    "apply": "cmd_apply",
+    "export": "cmd_export",
+    "lock": "cmd_lock",
+    "cache": "cmd_cache",
+    "registry": "cmd_registry",
+    "runtime": "cmd_runtimes",
+    "setup": "cmd_setup",
+    "environment": "cmd_environment",
+    "doctor": "cmd_doctor",
+}
+
+
+def _resolve(symbol: str) -> Any:
+    module = _SYMBOL_MODULES.get(symbol)
+    if module is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {symbol!r}")
+    return getattr(import_module(f"ixt.cli.{module}"), symbol)
+
+
+def __getattr__(name: str) -> Any:
+    """Resolve a re-exported ``cmd_*`` on first access (PEP 562)."""
+    return _resolve(name)
+
+
+def __dir__() -> list[str]:
+    return sorted([*__all__, *_SYMBOL_MODULES])
+
+
+def get_command(name: str) -> Callable[..., int] | None:
+    """Return the handler for CLI command *name*, or ``None`` if unknown."""
+    symbol = _COMMANDS.get(name)
+    return None if symbol is None else _resolve(symbol)

{ixt_cli-0.10.0 → ixt_cli-0.10.1}/src/ixt/cli/parser.py

@@ -3,18 +3,11 @@
 from __future__ import annotations
 
 import argparse
-from importlib.metadata import version
 
+from ixt import __version__
 from ixt.cli.argparse_completion import SUPPORTED_COMPLETION_SHELLS, complete_with
 
 
-def _get_version() -> str:
-    try:
-        return version("ixt-cli")
-    except Exception:
-        return "unknown"
-
-
 def effective_verbosity(args: argparse.Namespace) -> int:
     """Return global verbosity, including aliases accepted after a subcommand."""
     return (getattr(args, "verbose", 0) or 0) + (getattr(args, "_verbose_after", 0) or 0)
@@ -57,7 +50,7 @@ def build_parser() -> argparse.ArgumentParser:
         "--version",
         "-V",
         action="version",
-        version=f"%(prog)s {_get_version()}",
+        version=f"%(prog)s {__version__}",
     )
     parser.add_argument(
         "--verbose",