ixt-cli 0.8.0__py3-none-any.whl

ixt/cli/cmd_install.py

@@ -0,0 +1,508 @@
+"""``ixt tool add/install/uninstall`` subcommands."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from ixt.cli.render import format_exposed_bins, id_suffix
+from ixt.config.models import ToolRecord
+from ixt.config.settings import get_settings
+from ixt.core.backend import BackendType
+from ixt.core.install import display_tool_name, resolve_tool_arg
+from ixt.libs.constants import EXPOSE_MAIN
+from ixt.libs.logger import get_logger
+from ixt.libs.style import bold, cyan, dim, green, red, yellow
+
+
+def _log_not_found_hint(logger, pkg: str) -> None:
+    """Context-aware hint when install fails with 404 / package not found.
+
+    A simple name (no ``/``, no ``@``) is auto-detected as PyPI. When that
+    lookup 404s, the user most likely meant a different backend — show the
+    three concrete alternatives instead of a generic "check the name" note.
+    """
+    is_simple = "/" not in pkg and "@" not in pkg
+    if is_simple:
+        header = f"Hint: '{pkg}' not found on PyPI. Try:"
+        logger.error(f"  {dim(header)}")
+        logger.error(f"    {dim('ixt tool install @npm:' + pkg)}  {dim('(npm package)')}")
+        logger.error(f"    {dim('ixt tool install owner/' + pkg)}  {dim('(GitHub repo)')}")
+        logger.error(f"    {dim('ixt tool install @gl:owner/' + pkg)}  {dim('(GitLab repo)')}")
+    else:
+        logger.error(
+            f"  {dim('Hint: check the package name.')}"
+            f" {dim('Use owner/repo for GitHub, @scope/pkg for npm')}"
+        )
+
+
+def cmd_install(args: argparse.Namespace) -> int:
+    logger = get_logger("install")
+    dry_run = getattr(args, "dry_run", False)
+    from_path = getattr(args, "from_path", None)
+
+    if args.package and from_path:
+        logger.error("--from is mutually exclusive with the positional package spec.")
+        return 1
+    if not args.package and not from_path:
+        logger.error("either a package spec or --from PATH is required.")
+        return 1
+
+    if not from_path:
+        gate = _check_setup_file_gate(args, logger)
+        if gate is not None:
+            return gate
+
+    if dry_run:
+        if from_path:
+            return _cmd_install_from_local_dry_run(args, from_path, logger)
+        return _cmd_install_dry_run(args, logger)
+
+    if from_path:
+        return _cmd_install_from_local(args, from_path, logger)
+
+    from ixt.core.backend import BackendType, detect_backend
+    from ixt.core.install import ToolAlreadyInstalledError, install_tool
+
+    setup_path = Path(args.setup) if getattr(args, "setup", None) else None
+    asset_pattern = getattr(args, "asset_pattern", None)
+    if asset_pattern:
+        try:
+            bt = detect_backend(args.package)
+        except Exception:
+            bt = None
+        if bt is not None and bt != BackendType.BINARY:
+            logger.warn(
+                f"--asset-pattern ignored: only applies to the binary backend (detected {bt.value})"
+            )
+            asset_pattern = None
+
+    runtime_arg, node_shim = _resolve_runtime(getattr(args, "runtime", "bun"))
+
+    try:
+        record = install_tool(
+            args.package,
+            slot=args.slot,
+            force=args.reinstall,
+            backend_type=None,
+            runtime=runtime_arg,
+            setup_path=setup_path,
+            node_shim=node_shim,
+            asset_pattern=asset_pattern,
+            bare=args.bare,
+        )
+    except ToolAlreadyInstalledError as e:
+        logger.error(f"{e}")
+        logger.error(
+            f"  {dim('Hint: use --reinstall to replace it, or ixt tool upgrade ' + args.package)}"
+        )
+        return 1
+    except ValueError as e:
+        logger.error(str(e))
+        return 1
+    except Exception as e:
+        return _handle_install_error(e, args, logger)
+
+    settings = get_settings()
+    version = f" {dim(record.version)}" if record.version else ""
+    logger.info(
+        f"  {green('+')} {bold(display_tool_name(record, settings))}{version}  "
+        f"{id_suffix(record.name)}"
+    )
+    logger.info(f"    exposed: {format_exposed_bins(record.exposed_bins)}")
+
+    if args.save:
+        _save_install_to_toml(args, record, logger)
+
+    return 0
+
+
+def cmd_add(args: argparse.Namespace) -> int:
+    """Persist a tool in ixt.toml without installing it."""
+    from ixt.core.install import plan_install
+    from ixt.core.save import (
+        extract_version_from_spec,
+        save_tool,
+        tool_entry_key,
+        tool_install_spec,
+    )
+
+    logger = get_logger("add")
+    try:
+        plan = plan_install(args.package, slot=args.slot, bare=args.bare)
+    except ValueError as e:
+        logger.error(str(e))
+        return 1
+
+    asset_pattern = getattr(args, "asset_pattern", None)
+    if asset_pattern and plan.backend != BackendType.BINARY:
+        logger.warn(
+            f"--asset-pattern ignored: only applies to the binary backend "
+            f"(detected {plan.backend.value})"
+        )
+        asset_pattern = None
+
+    runtime_arg, node_shim = _resolve_runtime(getattr(args, "runtime", None))
+    runtime_out = None
+    if plan.backend == BackendType.NODE:
+        runtime_out = "node" if runtime_arg == "node" else None
+    else:
+        node_shim = None
+
+    entry_key = tool_entry_key(plan.tool_name, plan.resolved_spec, plan.backend)
+    entry_install = None
+    if args.slot is not None:
+        entry_key = args.slot
+        entry_install = tool_install_spec(plan.resolved_spec, plan.backend)
+
+    path = save_tool(
+        entry_key,
+        install=entry_install,
+        version=extract_version_from_spec(plan.resolved_spec, plan.backend),
+        expose=[] if args.bare else None,
+        node_shim=node_shim,
+        runtime=runtime_out,
+        asset_pattern=asset_pattern,
+    )
+    logger.info(f"  {green('+')} {bold(entry_key)}  {dim('saved to ' + str(path))}")
+    return 0
+
+
+def _cmd_install_from_local(args: argparse.Namespace, from_path: str, logger) -> int:
+    """Handle ``ixt tool install --from <path>`` (bypass spec/registry resolution)."""
+    from ixt.core.install import ToolAlreadyInstalledError
+    from ixt.core.install_local import install_from_local
+
+    try:
+        record = install_from_local(
+            Path(from_path),
+            slot=args.slot,
+            force=args.reinstall,
+        )
+    except ToolAlreadyInstalledError as e:
+        logger.error(f"{e}")
+        logger.error(f"  {dim('Hint: use --reinstall to replace it.')}")
+        return 1
+    except ValueError as e:
+        logger.error(str(e))
+        return 1
+
+    version = f" {dim(record.version)}" if record.version else ""
+    logger.info(
+        f"  {green('+')} {bold(display_tool_name(record))}{version}  "
+        f"{id_suffix(record.name)}  {dim('[local]')}"
+    )
+    logger.info(f"    exposed: {format_exposed_bins(record.exposed_bins)}")
+    return 0
+
+
+def _cmd_install_from_local_dry_run(args: argparse.Namespace, from_path: str, logger) -> int:
+    """Resolve a local install plan, print it, and exit without mutating."""
+    from ixt.core.install_local import plan_install_from_local
+
+    try:
+        plan = plan_install_from_local(Path(from_path), slot=args.slot)
+    except ValueError as e:
+        logger.error(str(e))
+        return 1
+
+    logger.info(f"{dim('[dry-run]')} would install from local path:")
+    logger.info(
+        f"  {bold(str(plan.source_path))}  {dim('[' + plan.backend.value + ']')}  "
+        f"{id_suffix(plan.tool_name)}"
+    )
+    logger.info(f"  source:   {plan.source_path}")
+    logger.info(f"  package:  {plan.pkg_name}")
+    logger.info(f"  env:      {dim(str(plan.env_dir))}")
+    expose_display = ", ".join(plan.expose_rules) if plan.expose_rules else dim("none")
+    logger.info(f"  would expose: {expose_display}")
+    if plan.already_installed:
+        if args.reinstall:
+            logger.info(f"  {yellow('note:')}    env exists, would be reinstalled")
+        else:
+            logger.error(f"  {red('note:')}    env exists, would fail without --reinstall")
+            return 1
+    return 0
+
+
+_RUNTIME_MAP: dict[str, tuple[str | None, bool | None]] = {
+    "bun": ("bun", True),  # default — rewrite #!node shebangs to bun
+    "bun-strict": ("bun", False),  # bun runtime, shebangs untouched (host needs node)
+    "node": ("node", None),  # node runtime — shim flag irrelevant
+}
+
+
+def _resolve_runtime(choice: str | None) -> tuple[str | None, bool | None]:
+    """Return ``(runtime, node_shim)`` for the --runtime CLI choice."""
+    return _RUNTIME_MAP.get(choice or "", (choice, None))
+
+
+def _check_setup_file_gate(args: argparse.Namespace, logger) -> int | None:
+    """Guard: --setup-file is gated behind IXT_ENABLE_SETUP_TOML (A/B test v0.1.0)."""
+    if not getattr(args, "setup", None):
+        return None
+    from ixt.config.flags import SETUP_TOML_ENV, is_setup_toml_enabled
+
+    if is_setup_toml_enabled():
+        return None
+    logger.error("ixt.setup.toml support is disabled in v0.1.0 (A/B test).")
+    logger.error(f"  {dim(f'Set {SETUP_TOML_ENV}=1 to enable --setup-file and remote fetch.')}")
+    return 1
+
+
+def _cmd_install_dry_run(args: argparse.Namespace, logger) -> int:
+    """Resolve the install plan, print it, and exit without mutating."""
+    from ixt.core.install import plan_install
+
+    setup_path = Path(args.setup) if getattr(args, "setup", None) else None
+    try:
+        plan = plan_install(
+            args.package,
+            slot=args.slot,
+            setup_path=setup_path,
+            bare=args.bare,
+        )
+    except ValueError as e:
+        logger.error(str(e))
+        return 1
+
+    logger.info(f"{dim('[dry-run]')} would install:")
+    logger.info(
+        f"  {bold(plan.resolved_spec)}  {dim('[' + plan.backend.value + ']')}  "
+        f"{id_suffix(plan.tool_name)}"
+    )
+    logger.info(f"  spec:     {plan.resolved_spec}")
+    logger.info(f"  env:      {dim(str(plan.env_dir))}")
+    expose_display = ", ".join(plan.expose_rules) if plan.expose_rules else dim("none")
+    logger.info(f"  would expose: {expose_display}")
+    if plan.inject:
+        logger.info(f"  inject:   {', '.join(cyan(p) for p in plan.inject)}")
+    if plan.already_installed:
+        if args.reinstall:
+            logger.info(f"  {yellow('note:')}    env exists, would be reinstalled")
+        else:
+            logger.error(f"  {red('note:')}    env exists, would fail without --reinstall")
+            return 1
+    if plan.backend != BackendType.PYTHON:
+        logger.info(f"  {dim('note:     version resolved at install time (network)')}")
+    return 0
+
+
+def _handle_install_error(exc: Exception, args: argparse.Namespace, logger) -> int:
+    """Map an install_tool exception to a user-facing error with actionable hint."""
+    import os
+
+    from ixt.net.http import NotFoundError, RateLimitError
+
+    err_lower = str(exc).lower()
+    body = getattr(exc, "body", "") or ""
+    is_rate_limit = (
+        isinstance(exc, RateLimitError) or "rate limit" in err_lower or "rate limit" in body.lower()
+    )
+    is_not_found = isinstance(exc, NotFoundError) or "404" in str(exc) or "not found" in err_lower
+    is_no_asset = "No compatible asset" in str(exc) or "No release matching" in str(exc)
+    is_unauthorized = "401" in str(exc) or "unauthorized" in err_lower
+
+    if is_rate_limit:
+        logger.error(f"Failed to install '{args.package}': GitHub/GitLab API rate limit reached")
+        logger.error(f"  {dim('Hint: export GITHUB_TOKEN=$(gh auth token)  (or GITLAB_TOKEN)')}")
+    elif is_unauthorized:
+        # 401 on a public release endpoint almost always means a stale token
+        # is being sent. Name the offender so the user knows where to look.
+        which = []
+        if "gitlab" in str(exc).lower() and os.environ.get("GITLAB_TOKEN"):
+            which.append("GITLAB_TOKEN")
+        if "github" in str(exc).lower() and os.environ.get("GITHUB_TOKEN"):
+            which.append("GITHUB_TOKEN")
+        if not which:
+            for var in ("GITLAB_TOKEN", "GITHUB_TOKEN"):
+                if os.environ.get(var):
+                    which.append(var)
+        logger.error(f"Failed to install '{args.package}': 401 Unauthorized")
+        if which:
+            tokens = " / ".join(which)
+            msg = f"Hint: {tokens} is set but rejected — likely expired or revoked."
+            logger.error(f"  {dim(msg)}")
+            logger.error(f"  {dim(f'       Try: unset {which[0]} (or rotate the token)')}")
+        else:
+            logger.error(f"  {dim('Hint: API rejected — check the project URL is public.')}")
+    elif is_not_found:
+        logger.error(f"Failed to install '{args.package}': not found")
+        _log_not_found_hint(logger, args.package)
+    elif is_no_asset:
+        logger.error(f"Failed to install '{args.package}': {exc}")
+        logger.error(f"  {dim('Hint: prefix the spec to force a backend (e.g. @gh:owner/repo)')}")
+    else:
+        logger.error(f"Failed to install '{args.package}': {exc}")
+
+    logger.debug(f"raw error: {type(exc).__name__}: {exc}")
+    if body:
+        logger.debug(f"response body: {body}")
+    return 1
+
+
+def _save_install_to_toml(args: argparse.Namespace, record: ToolRecord, logger) -> None:
+    """Persist the just-installed tool into ixt.toml."""
+    from ixt.core.save import (
+        extract_version_from_spec,
+        save_tool,
+        tool_entry_key,
+        tool_install_spec,
+    )
+
+    bt = BackendType(record.backend)
+    entry_key = tool_entry_key(record.name, record.spec, bt)
+    entry_install = None
+    entry_slot = _saved_entry_slot(entry_key, record)
+    if entry_slot is not None:
+        entry_key = entry_slot
+        entry_install = tool_install_spec(record.spec, bt)
+    # Only persist ``expose`` when it differs from the implicit default
+    # (``[__main__]``) — a bare install writes ``expose = []`` so apply can
+    # reproduce it faithfully.
+    expose_out: list[str] | None
+    if record.expose_rules == [EXPOSE_MAIN]:
+        expose_out = None
+    else:
+        expose_out = list(record.expose_rules)
+    save_tool(
+        entry_key,
+        install=entry_install,
+        version=extract_version_from_spec(args.package, bt),
+        expose=expose_out,
+        node_shim=record.node_shim,
+    )
+    logger.info(f"  {dim('saved to ixt.toml')}")
+
+
+def _saved_entry_slot(entry_key: str, record: ToolRecord) -> str | None:
+    from ixt.core.identity import slot_from_id
+    from ixt.core.install import plan_install
+
+    base_id = plan_install(entry_key, settings=get_settings()).tool_name
+    return slot_from_id(record.name, base_id)
+
+
+def cmd_uninstall(args: argparse.Namespace) -> int:
+    logger = get_logger("uninstall")
+    dry_run = getattr(args, "dry_run", False)
+    yes = getattr(args, "yes", False)
+    settings = get_settings()
+
+    if args.uninstall_all:
+        return _cmd_uninstall_all(logger, settings, dry_run=dry_run, yes=yes)
+    return _cmd_uninstall_one(args, logger, settings, dry_run=dry_run)
+
+
+def _cmd_uninstall_all(logger, settings, *, dry_run: bool, yes: bool) -> int:
+    meta_files = settings.iter_installed_metadata()
+    if not meta_files:
+        logger.info(f"{dim('[dry-run]')} no tools installed" if dry_run else "No tools installed")
+        return 0
+    records = [ToolRecord.load_json(mf) for mf in meta_files]
+    records_by_id = {record.name: record for record in records}
+
+    if dry_run:
+        logger.info(f"{dim('[dry-run]')} would remove {len(meta_files)} tool(s):")
+        for record in records:
+            bins = ", ".join(sorted(record.exposed_bins)) or dim("no bins")
+            display = bold(display_tool_name(record, settings))
+            logger.info(f"  {red('-')} {display}  {dim('bins:')} {bins}")
+        return 0
+
+    if not yes:
+        names = [display_tool_name(record, settings) for record in records]
+        confirmed = _confirm_uninstall_all(logger, names)
+        if confirmed is None:
+            return 1
+        if not confirmed:
+            logger.info("aborted by user")
+            return 0
+
+    from ixt.core.install import uninstall_all
+
+    results = uninstall_all(settings=settings)
+
+    errors = 0
+    for name, result in results.items():
+        display = (
+            display_tool_name(records_by_id[name], settings) if name in records_by_id else name
+        )
+        if isinstance(result, Exception):
+            logger.error(f"  {red('x')} {display}: {result}")
+            errors += 1
+        else:
+            logger.info(f"  {red('-')} {bold(display)}")
+    return 1 if errors else 0
+
+
+def _confirm_uninstall_all(logger, names: list[str]) -> bool | None:
+    """Prompt before deleting every installed tool."""
+    import sys
+
+    summary = f"About to remove {len(names)} tool(s): {', '.join(sorted(names))}"
+    if not sys.stdin.isatty():
+        logger.error(summary)
+        logger.error(f"  {dim('non-interactive session; pass --yes to confirm')}")
+        return None
+    print(summary, file=sys.stderr)
+    try:
+        answer = input("Proceed? [y/N] ").strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        print("", file=sys.stderr)
+        return False
+    return answer in ("y", "yes")
+
+
+def _cmd_uninstall_one(args: argparse.Namespace, logger, settings, *, dry_run: bool) -> int:
+    if not args.target:
+        logger.error("Specify a tool name or use --all")
+        return 1
+
+    from ixt.core.install import uninstall_tool
+
+    try:
+        tool_name = resolve_tool_arg(args.target, settings=settings)
+    except ValueError as e:
+        logger.error(str(e))
+        return 1
+
+    meta_file = settings.get_tool_metadata_file(tool_name)
+    env_dir = settings.get_tool_env_dir(tool_name)
+    record = ToolRecord.load_json(meta_file) if meta_file.exists() else None
+    display = display_tool_name(record, settings) if record else tool_name
+
+    if dry_run:
+        if not env_dir.exists():
+            logger.error(f"Tool '{args.target}' is not installed")
+            logger.error(f"  {dim('Hint: run ixt tool list to see installed tools')}")
+            return 1
+        logger.info(f"{dim('[dry-run]')} would remove:")
+        logger.info(f"  {red('-')} {bold(display)}")
+        logger.info(f"  env:      {dim(str(env_dir))}")
+        if record:
+            if record.exposed_bins:
+                logger.info("  unexpose:")
+                for name, source in sorted(record.exposed_bins.items()):
+                    logger.info(f"    {cyan(name)} {dim('->')} {dim(source)}")
+            else:
+                logger.info(f"  unexpose: {dim('none')}")
+        if args.save:
+            logger.info(f"  {dim('would remove from ixt.toml')}")
+        return 0
+
+    try:
+        uninstall_tool(tool_name)
+    except FileNotFoundError:
+        logger.error(f"Tool '{args.target}' is not installed")
+        logger.error(f"  {dim('Hint: run ixt tool list to see installed tools')}")
+        return 1
+
+    logger.info(f"  {red('-')} {bold(display)}")
+
+    if args.save:
+        from ixt.core.save import remove_tool
+
+        remove_tool(tool_name)
+        logger.info(f"  {dim('removed from ixt.toml')}")
+    return 0