ixt-cli 0.8.0__py3-none-any.whl

ixt/net/http.py

@@ -0,0 +1,194 @@
+"""Minimal HTTP client built on urllib (stdlib only).
+
+Handles JSON GET, file downloads, auth headers, proxy, timeout, and retry.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+
+class HttpError(Exception):
+    """HTTP request failed."""
+
+    def __init__(self, url: str, status: int, reason: str, body: str = ""):
+        self.url = url
+        self.status = status
+        self.reason = reason
+        self.body = body
+        super().__init__(f"HTTP {status} {reason}: {url}")
+
+
+class RateLimitError(HttpError):
+    """GitHub/GitLab API rate limit exceeded."""
+
+    def __init__(self, url: str, status: int, reason: str, body: str = ""):
+        super().__init__(url, status, reason, body)
+
+
+class NotFoundError(HttpError):
+    """Resource not found (404)."""
+
+    def __init__(self, url: str, body: str = ""):
+        super().__init__(url, 404, "Not Found", body)
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+_DEFAULT_TIMEOUT = 30
+_DOWNLOAD_TIMEOUT = 300
+_MAX_RETRIES = 2
+_RETRY_DELAY = 1.0
+_RETRYABLE_STATUSES = {429, 500, 502, 503, 504}
+
+
+def _build_opener() -> urllib.request.OpenerDirector:
+    """Build a urllib opener with proxy support."""
+    proxy = urllib.request.ProxyHandler()
+    return urllib.request.build_opener(proxy)
+
+
+def _classify_error(url: str, exc: urllib.error.HTTPError) -> HttpError:
+    """Turn an HTTPError into a typed exception."""
+    body = ""
+    try:
+        body = exc.read().decode("utf-8", errors="replace")
+    except Exception:
+        pass
+    status = exc.code
+    reason = exc.reason if isinstance(exc.reason, str) else str(exc.reason)
+    if status == 404:
+        return NotFoundError(url, body)
+    if status in (403, 429):
+        return RateLimitError(url, status, reason, body)
+    return HttpError(url, status, reason, body)
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def get_json(
+    url: str,
+    *,
+    headers: dict[str, str] | None = None,
+    timeout: int = _DEFAULT_TIMEOUT,
+) -> Any:
+    """GET a URL and parse the response as JSON."""
+    data = get_bytes(url, headers=headers, timeout=timeout)
+    return json.loads(data)
+
+
+def get_text(
+    url: str,
+    *,
+    headers: dict[str, str] | None = None,
+    timeout: int = _DEFAULT_TIMEOUT,
+) -> str:
+    """GET a URL and return the response as text."""
+    data = get_bytes(url, headers=headers, timeout=timeout)
+    return data.decode("utf-8")
+
+
+def get_bytes(
+    url: str,
+    *,
+    headers: dict[str, str] | None = None,
+    timeout: int = _DEFAULT_TIMEOUT,
+) -> bytes:
+    """GET a URL and return raw bytes, with retry on transient errors."""
+    req = urllib.request.Request(url, method="GET")
+    req.add_header("User-Agent", "ixt/0.1")
+    req.add_header("Accept", "application/json")
+    if headers:
+        for k, v in headers.items():
+            req.add_header(k, v)
+
+    opener = _build_opener()
+    last_exc: Exception | None = None
+
+    for attempt in range(_MAX_RETRIES + 1):
+        try:
+            with opener.open(req, timeout=timeout) as resp:
+                return resp.read()
+        except urllib.error.HTTPError as exc:
+            typed = _classify_error(url, exc)
+            if exc.code not in _RETRYABLE_STATUSES or attempt == _MAX_RETRIES:
+                raise typed from exc
+            last_exc = typed
+        except urllib.error.URLError as exc:
+            if attempt == _MAX_RETRIES:
+                raise HttpError(url, 0, str(exc.reason)) from exc
+            last_exc = exc  # type: ignore[assignment]
+
+        time.sleep(_RETRY_DELAY * (attempt + 1))
+
+    raise last_exc  # type: ignore[misc]  # unreachable but keeps mypy happy
+
+
+def get_final_url(
+    url: str,
+    *,
+    headers: dict[str, str] | None = None,
+    timeout: int = _DEFAULT_TIMEOUT,
+) -> str:
+    """Issue a HEAD request following redirects and return the final URL.
+
+    Used by the GitHub ``/releases/latest`` → ``/releases/tag/{tag}`` trick to
+    resolve the current latest tag without consuming an API request.
+    """
+    req = urllib.request.Request(url, method="HEAD")
+    req.add_header("User-Agent", "ixt/0.1")
+    if headers:
+        for k, v in headers.items():
+            req.add_header(k, v)
+
+    opener = _build_opener()
+    try:
+        with opener.open(req, timeout=timeout) as resp:
+            return resp.geturl()
+    except urllib.error.HTTPError as exc:
+        raise _classify_error(url, exc) from exc
+    except urllib.error.URLError as exc:
+        raise HttpError(url, 0, str(exc.reason)) from exc
+
+
+def download_file(
+    url: str,
+    dest: Path,
+    *,
+    headers: dict[str, str] | None = None,
+    timeout: int = _DOWNLOAD_TIMEOUT,
+) -> Path:
+    """Download a URL to a local file path with streaming."""
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    tmp = dest.with_suffix(dest.suffix + ".part")
+
+    req = urllib.request.Request(url, method="GET")
+    req.add_header("User-Agent", "ixt/0.1")
+    if headers:
+        for k, v in headers.items():
+            req.add_header(k, v)
+
+    opener = _build_opener()
+    try:
+        with opener.open(req, timeout=timeout) as resp, tmp.open("wb") as f:
+            shutil.copyfileobj(resp, f)
+        tmp.rename(dest)
+    except urllib.error.HTTPError as exc:
+        tmp.unlink(missing_ok=True)
+        raise _classify_error(url, exc) from exc
+    except Exception:
+        tmp.unlink(missing_ok=True)
+        raise
+
+    return dest

ixt/net/npm.py

@@ -0,0 +1,24 @@
+"""npm registry client — used to resolve the latest version of a package."""
+
+from __future__ import annotations
+
+from urllib.parse import quote
+
+from ixt.net.http import get_json
+
+
+def latest_version_url(name: str) -> str:
+    # @scope/pkg must be URL-encoded (/ becomes %2F).
+    return f"https://registry.npmjs.org/{quote(name, safe='@')}/latest"
+
+
+def get_latest_version(name: str) -> str:
+    """Return the latest published version of *name* on the npm registry."""
+    from ixt.core.resolution_stats import record_npm_registry
+
+    record_npm_registry(name)
+    data = get_json(latest_version_url(name))
+    version = data.get("version")
+    if not isinstance(version, str) or not version:
+        raise ValueError(f"npm response for '{name}' missing version")
+    return version

ixt/net/pypi.py

@@ -0,0 +1,26 @@
+"""PyPI registry client — used to resolve the latest version of a package."""
+
+from __future__ import annotations
+
+from ixt.net.http import get_json
+
+
+def latest_version_url(name: str) -> str:
+    return f"https://pypi.org/pypi/{name}/json"
+
+
+def get_latest_version(name: str) -> str:
+    """Return the latest published version of *name* on PyPI.
+
+    Raises any http.HttpError subclass on failure (NotFoundError for unknown
+    packages, HttpError for network/timeouts).
+    """
+    from ixt.core.resolution_stats import record_pypi_registry
+
+    record_pypi_registry(name)
+    data = get_json(latest_version_url(name))
+    info = data.get("info", {})
+    version = info.get("version")
+    if not isinstance(version, str) or not version:
+        raise ValueError(f"PyPI response for '{name}' missing info.version")
+    return version

ixt/net/source.py

@@ -0,0 +1,163 @@
+"""ReleaseSource protocol and spec parsing for GitHub/GitLab detection."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Protocol, runtime_checkable
+
+# ---------------------------------------------------------------------------
+# Data models
+# ---------------------------------------------------------------------------
+
+
+@dataclass(slots=True)
+class Asset:
+    """A single downloadable asset from a release."""
+
+    name: str
+    url: str
+    size: int = 0
+
+
+@dataclass(slots=True)
+class Release:
+    """A release with its tag and assets."""
+
+    tag: str
+    assets: list[Asset] = field(default_factory=list)
+    prerelease: bool = False
+    draft: bool = False
+    resolution_source: str | None = None
+
+
+# ---------------------------------------------------------------------------
+# ReleaseSource protocol
+# ---------------------------------------------------------------------------
+
+
+@runtime_checkable
+class ReleaseSource(Protocol):
+    """Interface for fetching releases from a forge (GitHub, GitLab)."""
+
+    def get_latest_release(self, owner: str, repo: str) -> Release: ...
+
+    def get_release_by_tag(self, owner: str, repo: str, tag: str) -> Release: ...
+
+    def list_releases(self, owner: str, repo: str) -> list[Release]: ...
+
+    def download_asset(self, url: str, dest: Path) -> None: ...
+
+    def get_file_content(
+        self, owner: str, repo: str, path: str, *, ref: str | None = None
+    ) -> str | None: ...
+
+
+# Avoid circular import — Path is only needed for type checking
+from pathlib import Path  # noqa: E402
+
+# ---------------------------------------------------------------------------
+# Spec parsing
+# ---------------------------------------------------------------------------
+
+
+@dataclass(slots=True)
+class RepoSpec:
+    """Parsed result of a package specification.
+
+    Attributes:
+        host: The forge hostname (e.g. "github.com", "gitlab.com", "gitlab.company.com").
+        owner: Repository owner/org.
+        repo: Repository name.
+        version: Optional version constraint (tag or semver fragment).
+        platform: "github" or "gitlab".
+    """
+
+    host: str
+    owner: str
+    repo: str
+    version: str | None = None
+    platform: str = "github"  # "github" | "gitlab"
+
+
+def strip_version_suffix(spec: str) -> str:
+    """Drop a trailing ``@version`` from *spec*, preserving a leading ``@scope``.
+
+    ``owner/repo@v1.2.3`` -> ``owner/repo`` but ``@scope/pkg`` is left intact
+    (npm scopes are not version pins).
+    """
+    if "@" in spec and not spec.startswith("@"):
+        return spec.rsplit("@", 1)[0]
+    return spec
+
+
+def parse_spec(spec: str) -> RepoSpec | None:
+    """Parse a binary backend spec into a RepoSpec, or None if not a binary spec.
+
+    Recognized formats:
+        owner/repo                          -> GitHub (default)
+        owner/repo@version                  -> GitHub with version
+        github.com/owner/repo               -> GitHub (explicit)
+        gitlab.com/owner/repo               -> GitLab
+        gitlab.company.com/owner/repo       -> GitLab self-hosted
+        *.gitlab.*/owner/repo               -> GitLab self-hosted
+
+    Returns None for:
+        simple-name                         -> not a binary spec (PyPI or registry lookup)
+        @scope/pkg                          -> not a binary spec (npm)
+    """
+    raw = spec.strip()
+
+    # Strip version suffix
+    version: str | None = None
+    if "@" in raw:
+        # Handle @scope/pkg (npm) — starts with @
+        if raw.startswith("@"):
+            return None
+        # owner/repo@version or domain/owner/repo@version
+        raw, version = raw.rsplit("@", 1)
+        if not version:
+            version = None
+
+    # No slash → not a binary spec (simple name, needs registry lookup)
+    if "/" not in raw:
+        return None
+
+    parts = raw.split("/")
+
+    # Convention: ``.git`` clone-URL suffix on the repo segment is stripped.
+    # ``gitlab-org/cli.git`` → ``gitlab-org/cli`` so the API call hits the
+    # actual project, not a literal ``cli.git`` that doesn't exist.
+    def _strip_git(name: str) -> str:
+        return name[:-4] if name.endswith(".git") and len(name) > 4 else name
+
+    # domain/owner/repo (3+ parts → has a host)
+    if len(parts) >= 3:
+        host = parts[0]
+        owner = parts[1]
+        repo = _strip_git("/".join(parts[2:]))  # handle nested groups (GitLab)
+        platform = _detect_platform(host)
+        return RepoSpec(host=host, owner=owner, repo=repo, version=version, platform=platform)
+
+    # owner/repo (2 parts → default GitHub)
+    if len(parts) == 2:
+        owner, repo = parts
+        return RepoSpec(
+            host="github.com",
+            owner=owner,
+            repo=_strip_git(repo),
+            version=version,
+            platform="github",
+        )
+
+    return None
+
+
+def _detect_platform(host: str) -> str:
+    """Detect whether a host is GitHub or GitLab."""
+    h = host.lower()
+    if h == "github.com":
+        return "github"
+    if "gitlab" in h:
+        return "gitlab"
+    # Unknown host — assume GitLab (GitHub is the default for bare owner/repo)
+    return "gitlab"

ixt/platform/__init__.py

@@ -0,0 +1,131 @@
+"""Platform detection and utilities"""
+
+import functools
+import platform
+import sys
+from enum import Enum
+
+
+class OS(Enum):
+    """Supported operating systems"""
+
+    LINUX = "linux"
+    MACOS = "macos"
+    WINDOWS = "windows"
+
+
+class Arch(Enum):
+    """Supported architectures"""
+
+    X86_64 = "x86_64"
+    ARM64 = "arm64"
+    ARMV7 = "armv7"
+
+
+@functools.lru_cache(maxsize=1)
+def get_os() -> OS:
+    """Get the current operating system"""
+    system = platform.system().lower()
+    if system == "linux":
+        return OS.LINUX
+    elif system == "darwin":
+        return OS.MACOS
+    elif system == "windows":
+        return OS.WINDOWS
+    else:
+        raise RuntimeError(f"Unsupported OS: {system}")
+
+
+@functools.lru_cache(maxsize=1)
+def get_arch() -> Arch:
+    """Get the current architecture"""
+    machine = platform.machine().lower()
+
+    if machine in ("x86_64", "amd64", "x64"):
+        return Arch.X86_64
+    elif machine in ("arm64", "aarch64"):
+        return Arch.ARM64
+    elif machine in ("armv7", "armhf"):
+        return Arch.ARMV7
+    else:
+        raise RuntimeError(f"Unsupported architecture: {machine}")
+
+
+def is_linux() -> bool:
+    """Check if running on Linux"""
+    return get_os() == OS.LINUX
+
+
+def is_macos() -> bool:
+    """Check if running on macOS"""
+    return get_os() == OS.MACOS
+
+
+def is_windows() -> bool:
+    """Check if running on Windows"""
+    return get_os() == OS.WINDOWS
+
+
+def is_x86_64() -> bool:
+    """Check if running on x86_64 architecture"""
+    return get_arch() == Arch.X86_64
+
+
+def is_arm64() -> bool:
+    """Check if running on ARM64 architecture"""
+    return get_arch() == Arch.ARM64
+
+
+class PlatformInfo:
+    """Information about the current platform"""
+
+    def __init__(self):
+        self.os = get_os()
+        self.arch = get_arch()
+        self.python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+
+    def __repr__(self) -> str:
+        return (
+            f"PlatformInfo(os={self.os.value}, arch={self.arch.value},"
+            f" python={self.python_version})"
+        )
+
+
+def get_platform_info() -> PlatformInfo:
+    """Get current platform information"""
+    return PlatformInfo()
+
+
+def get_binary_extension() -> str:
+    """Get the binary file extension for the current OS"""
+    return ".exe" if is_windows() else ""
+
+
+def get_shell_profile_paths() -> list[str]:
+    """Get shell profile paths for the current OS
+
+    Returns:
+        List of shell profile file names (~/.bashrc, ~/.zshrc, etc.)
+    """
+    if is_windows():
+        return ["$PROFILE"]
+    else:
+        # Unix-like systems
+        return ["~/.profile", "~/.bashrc", "~/.zshrc", "~/.kshrc", "~/.tcshrc"]
+
+
+__all__ = [
+    "OS",
+    "Arch",
+    "PlatformInfo",
+    "get_arch",
+    "get_binary_extension",
+    "get_os",
+    "get_platform_info",
+    "get_shell_profile_paths",
+    "is_arm64",
+    "is_linux",
+    "is_macos",
+    "is_windows",
+    "is_x86_64",
+]

ixt/platform/win.py

@@ -0,0 +1,68 @@
+"""Windows-specific utilities (registry, PATH management, etc.)"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Callable
+from typing import Any, cast
+
+from ixt.platform import is_windows
+
+
+def _modify_user_path(mutate: Callable[[list[str]], list[str]]) -> bool:
+    """Open the user PATH registry value, apply *mutate*, and write back.
+
+    Uses REG_EXPAND_SZ so paths containing %USERPROFILE% etc. are expanded
+    correctly by the shell.  No-op on non-Windows platforms.
+    """
+    if not is_windows():
+        return True
+    try:
+        import winreg as _winreg
+
+        winreg = cast(Any, _winreg)
+
+        with winreg.ConnectRegistry(None, winreg.HKEY_CURRENT_USER) as reg:
+            with winreg.OpenKey(reg, r"Environment", 0, winreg.KEY_READ | winreg.KEY_WRITE) as key:
+                try:
+                    current_path, _ = winreg.QueryValueEx(key, "Path")
+                except FileNotFoundError:
+                    current_path = ""
+                old = [p for p in current_path.split(os.pathsep) if p]
+                new = mutate(old)
+                if new != old:
+                    winreg.SetValueEx(key, "Path", 0, winreg.REG_EXPAND_SZ, os.pathsep.join(new))
+                return True
+    except Exception as e:
+        from ixt.libs.logger import get_logger
+
+        get_logger("platform.win").warn(f"Could not modify Windows PATH: {e}")
+        return False
+
+
+def add_to_user_path(path_str: str) -> bool:
+    """Add a directory to the user PATH on Windows (no-op elsewhere)."""
+    return _modify_user_path(lambda ps: ps if path_str in ps else [*ps, path_str])
+
+
+def get_user_path() -> str | None:
+    """Return the raw HKCU Path value, or None if unset / not Windows."""
+    if not is_windows():
+        return None
+    try:
+        import winreg as _winreg
+
+        winreg = cast(Any, _winreg)
+
+        with winreg.ConnectRegistry(None, winreg.HKEY_CURRENT_USER) as reg:
+            with winreg.OpenKey(reg, r"Environment", 0, winreg.KEY_READ) as key:
+                try:
+                    value, _ = winreg.QueryValueEx(key, "Path")
+                    return value
+                except FileNotFoundError:
+                    return None
+    except Exception as e:
+        from ixt.libs.logger import get_logger
+
+        get_logger("platform.win").warn(f"Could not read Windows user PATH: {e}")
+        return None