contree-cli 0.2.3__py3-none-any.whl

contree_cli/client.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import base64
+import http.client
+import json
+import logging
+import platform
+import sys
+import time
+from collections.abc import Iterator
+from importlib.metadata import PackageNotFoundError, version
+from urllib.parse import urlencode, urlsplit
+
+log = logging.getLogger(__name__)
+
+RETRY_DELAYS = (1, 2, 4, 5, 10, 10, 10)
+
+
+def _cli_version() -> str:
+    try:
+        return version("contree-cli")
+    except PackageNotFoundError:
+        return "editable"
+
+
+CLI_USER_AGENT = (
+    f"contree-cli/{_cli_version()} "
+    f"Python/{'.'.join(map(str, sys.version_info))} "
+    f"{platform.platform()}"
+)
+
+
+
+class ApiError(Exception):
+    """Raised when the Contree API returns a non-2xx status."""
+
+    def __init__(self, status: int, reason: str, body: str) -> None:
+        self.status = status
+        self.reason = reason
+        self.body = body
+
+    def __str__(self) -> str:
+        return f"API {self.status} {self.reason}: {self.body}"
+
+
+class ContreeClient:
+    """Minimal HTTP client for the Contree REST API (stdlib only)."""
+
+    def __init__(self, url: str, token: str | None) -> None:
+        parts = urlsplit(url)
+        self._scheme = parts.scheme or "https"
+        self._host = parts.hostname or "localhost"
+        self._port = parts.port
+        self._prefix = (parts.path or "").rstrip("/")
+        self._token = token
+
+    def _connect(self) -> http.client.HTTPConnection:
+        if self._scheme == "https":
+            return http.client.HTTPSConnection(self._host, self._port)
+        return http.client.HTTPConnection(self._host, self._port)
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: bytes | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> http.client.HTTPResponse:
+        if self._token is None:
+            raise ApiError(
+                0, "Unauthorized",
+                "No token configured. Run `contree auth` first.",
+            )
+
+        merged: dict[str, str] = {
+            "Authorization": f"Bearer {self._token}",
+            "User-Agent": CLI_USER_AGENT,
+        }
+        if body is not None:
+            merged.setdefault("Content-Type", "application/json")
+        if headers:
+            merged.update(headers)
+
+        full_path = self._prefix + path
+        last_error: ApiError | None = None
+        attempts = len(RETRY_DELAYS) + 1
+
+        for attempt in range(attempts):
+            if last_error is not None:
+                delay = RETRY_DELAYS[attempt - 1]
+                log.warning(
+                    "Server error %d, retrying in %ds…",
+                    last_error.status, delay,
+                )
+                time.sleep(delay)
+
+            log.debug(
+                "%s %s body=%s",
+                method, full_path,
+                f"{len(body)}B" if body is not None else "none",
+            )
+            conn = self._connect()
+            conn.request(method, full_path, body, merged)
+            resp = conn.getresponse()
+
+            if 200 <= resp.status < 300:
+                log.debug(
+                    "%s %s -> %d %s",
+                    method, full_path, resp.status, resp.reason,
+                )
+                return resp
+
+            resp_body = resp.read().decode("utf-8", errors="replace")
+            log.debug(
+                "%s %s -> %d %s (%dB)",
+                method, full_path,
+                resp.status, resp.reason, len(resp_body),
+            )
+            error = ApiError(resp.status, resp.reason, resp_body)
+
+            if 500 <= resp.status < 600:
+                last_error = error
+                continue
+
+            raise error
+
+        assert last_error is not None
+        raise last_error
+
+    # -- convenience methods --------------------------------------------------
+
+    def get(
+        self, path: str, params: dict[str, str] | None = None,
+    ) -> http.client.HTTPResponse:
+        if params:
+            path = f"{path}?{urlencode(params)}"
+        return self.request("GET", path)
+
+    def post_json(
+        self, path: str, payload: dict[str, object],
+    ) -> http.client.HTTPResponse:
+        return self.request(
+            "POST", path,
+            body=json.dumps(payload).encode(),
+            headers={"Content-Type": "application/json"},
+        )
+
+    def patch_json(
+        self, path: str, payload: dict[str, object],
+    ) -> http.client.HTTPResponse:
+        return self.request(
+            "PATCH", path,
+            body=json.dumps(payload).encode(),
+            headers={"Content-Type": "application/json"},
+        )
+
+    def delete(self, path: str) -> http.client.HTTPResponse:
+        return self.request("DELETE", path)
+
+
+_UUID_RE_PATTERN = (
+    r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
+)
+
+
+def _is_uuid(ref: str) -> bool:
+    """Return True if *ref* looks like a UUID."""
+    import re
+    return re.match(_UUID_RE_PATTERN, ref, re.ASCII) is not None
+
+
+def _resolve_tag(client: ContreeClient, tag: str) -> str:
+    resp = client.get("/v1/images", params={"tag": tag})
+    data = json.loads(resp.read())
+    images = data.get("images", [])
+    if not images:
+        raise ApiError(404, "Not Found", f"No image with tag '{tag}'")
+    return str(images[0]["uuid"])
+
+
+def resolve_image(client: ContreeClient, ref: str) -> str:
+    """Resolve an image reference to a UUID.
+
+    Accepts a raw UUID, ``tag:NAME``, or a bare tag name.  For bare
+    references that are not valid UUIDs the function tries to resolve
+    them as tag names.
+    """
+    if ref.startswith("tag:"):
+        return _resolve_tag(client, ref[4:])
+    if _is_uuid(ref):
+        return ref
+    return _resolve_tag(client, ref)
+
+
+CHUNK_SIZE = 256 * 1024  # 256 KiB
+
+
+def stream_response(
+    resp: http.client.HTTPResponse,
+) -> Iterator[bytes]:
+    """Yield chunks from *resp*."""
+    while True:
+        chunk = resp.read(CHUNK_SIZE)
+        if not chunk:
+            break
+        yield chunk
+
+
+def decode_stream(stream: dict[str, object] | None) -> str:
+    """Decode an API StreamRepr object to a string."""
+    if not stream:
+        return ""
+    value = stream.get("value", "")
+    if not isinstance(value, str) or not value:
+        return ""
+    encoding = stream.get("encoding", "ascii")
+    if encoding == "base64":
+        return base64.b64decode(value).decode(
+            "utf-8", errors="replace",
+        )
+    return value

contree_cli/config.py

@@ -0,0 +1,116 @@
+import configparser
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".config" / "contree-cli"
+CONFIG_FILE = CONFIG_DIR / "config.ini"
+
+DEFAULT_URL = "https://contree.dev"
+PROFILE_PREFIX = "profile:"
+
+
+@dataclass(frozen=True, repr=False)
+class ConfigProfile:
+    name: str
+    url: str
+    token: str | None
+
+    def __repr__(self) -> str:
+        masked = "***" if self.token else None
+        return (
+            f"ConfigProfile(name={self.name!r},"
+            f" url={self.url!r}, token={masked!r})"
+        )
+
+
+def _section(name: str) -> str:
+    """Return the INI section name for a profile."""
+    return f"{PROFILE_PREFIX}{name}"
+
+
+def load_config(path: Path | None = None) -> ConfigProfile:
+    """Load config file and return the resolved active profile.
+
+    Resolution precedence for each field: env var > config file > default.
+    """
+    cfg_path = path or CONFIG_FILE
+    cp = configparser.ConfigParser()
+    cp.read(cfg_path)
+
+    name = os.environ.get("CONTREE_PROFILE") or cp.defaults().get("profile", "default")
+    section = _section(name)
+
+    env_token = os.environ.get("CONTREE_TOKEN")
+    env_url = os.environ.get("CONTREE_URL")
+
+    if cp.has_section(section):
+        cfg_token = cp.get(section, "token", fallback=None)
+        cfg_url = cp.get(section, "url", fallback=DEFAULT_URL)
+    else:
+        cfg_token = None
+        cfg_url = DEFAULT_URL
+
+    return ConfigProfile(
+        name=name,
+        token=env_token or cfg_token,
+        url=env_url or cfg_url,
+    )
+
+
+def _read_ini(path: Path | None = None) -> configparser.ConfigParser:
+    """Read the raw INI file into a ConfigParser."""
+    cp = configparser.ConfigParser()
+    cp.read(path or CONFIG_FILE)
+    return cp
+
+
+def profile_exists(
+    profile: str, *, path: Path | None = None,
+) -> bool:
+    """Check whether a named profile already exists."""
+    cp = _read_ini(path)
+    return cp.has_section(_section(profile))
+
+
+def save_profile(
+    profile: str, token: str, url: str,
+    *, path: Path | None = None,
+) -> None:
+    """Write/update a profile in the config file, preserving all other sections."""
+    cfg_dir = (path or CONFIG_FILE).parent if path else CONFIG_DIR
+    cfg_path = path or CONFIG_FILE
+    cp = _read_ini(cfg_path)
+    section = _section(profile)
+    if not cp.has_section(section):
+        cp.add_section(section)
+    cp.set(section, "token", token)
+    cp.set(section, "url", url)
+    cfg_dir.mkdir(parents=True, exist_ok=True)
+    with open(cfg_path, "w") as f:
+        cp.write(f)
+
+
+def list_profiles(
+    *, path: Path | None = None,
+) -> list[tuple[str, bool]]:
+    """Return (name, is_active) pairs for all profiles."""
+    cp = _read_ini(path)
+    active = cp.defaults().get("profile", "default")
+    result: list[tuple[str, bool]] = []
+    for section in cp.sections():
+        if section.startswith(PROFILE_PREFIX):
+            name = section[len(PROFILE_PREFIX):]
+            result.append((name, name == active))
+    return result
+
+
+def switch_profile(profile: str, *, path: Path | None = None) -> None:
+    """Set the active profile in [DEFAULT]."""
+    cfg_path = path or CONFIG_FILE
+    cp = _read_ini(cfg_path)
+    if not cp.has_section(_section(profile)):
+        raise ValueError(f"profile {profile!r} does not exist")
+    cp["DEFAULT"]["profile"] = profile
+    with open(cfg_path, "w") as f:
+        cp.write(f)

contree_cli/log.py

@@ -0,0 +1,40 @@
+import logging
+import sys
+from types import MappingProxyType
+
+from contree_cli.types import Colors
+
+
+class ColorFormatter(logging.Formatter):
+    LEVEL_COLORS = MappingProxyType({
+        logging.DEBUG: Colors.CYAN,
+        logging.INFO: Colors.GREEN,
+        logging.WARNING: Colors.YELLOW,
+        logging.ERROR: Colors.RED,
+        logging.CRITICAL: Colors.BOLD_RED,
+    })
+
+    TEXT_COLORS = MappingProxyType({
+        logging.DEBUG: Colors.GRAY,
+        logging.INFO: Colors.DEFAULT,
+        logging.WARNING: Colors.DEFAULT,
+        logging.ERROR: Colors.DEFAULT,
+        logging.CRITICAL: Colors.RED,
+    })
+
+    def __init__(self, *, tty: bool) -> None:
+        super().__init__()
+        self._tty = tty
+
+    def format(self, record: logging.LogRecord) -> str:
+        level_color = self.LEVEL_COLORS.get(record.levelno, Colors.DEFAULT)
+        message_color = self.TEXT_COLORS.get(record.levelno, Colors.DEFAULT)
+        lvl = level_color(f"[{record.levelname}]")
+        msg = message_color(record.getMessage())
+        return f"{lvl} {msg}"
+
+
+def setup_logging(level: int = logging.INFO) -> None:
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(ColorFormatter(tty=sys.stderr.isatty()))
+    logging.basicConfig(level=level, handlers=[handler], force=True)

contree_cli/mapped_file.py

@@ -0,0 +1,112 @@
+import dataclasses
+import grp
+import hashlib
+import os
+import pwd
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class MappedFile:
+    host_path: str
+    instance_path: str
+    uid: int
+    gid: int
+    mode: int
+
+    def sha256(self) -> str:
+        """Return hex SHA256 digest of the host file (streamed)."""
+        h = hashlib.sha256()
+        with open(self.host_path, "rb") as fh:
+            while chunk := fh.read(256 * 1024):
+                h.update(chunk)
+        return h.hexdigest()
+
+    @classmethod
+    def parse(cls, spec: str) -> "MappedFile":
+        parts = spec.split(":")
+        if not parts or not parts[0]:
+            raise ValueError(f"invalid file spec {spec!r}: host_path is required")
+
+        host_path = parts[0]
+        instance_path: str | None = None
+        uid: int | None = None
+        gid: int | None = None
+        mode: int | None = None
+
+        for part in parts[1:]:
+            if part.startswith("/"):
+                if instance_path is not None:
+                    raise ValueError(
+                        f"invalid file spec {spec!r}: duplicate instance path"
+                    )
+                instance_path = part
+            elif part.startswith("u"):
+                uid = _resolve_uid(part[1:])
+            elif part.startswith("g"):
+                gid = _resolve_gid(part[1:])
+            elif part.startswith("m"):
+                mode = _parse_mode(part[1:])
+            else:
+                raise ValueError(
+                    f"invalid file spec {spec!r}: "
+                    f"unknown field {part!r} "
+                    f"(expected /path, u<uid>, g<gid>, or m<mode>)"
+                )
+
+        needs_stat = instance_path is None or uid is None or gid is None or mode is None
+        if needs_stat:
+            try:
+                st = os.stat(host_path)
+            except OSError as exc:
+                raise ValueError(
+                    f"cannot stat host file {host_path!r}: {exc}"
+                ) from exc
+            if instance_path is None:
+                instance_path = host_path
+            if uid is None:
+                uid = st.st_uid
+            if gid is None:
+                gid = st.st_gid
+            if mode is None:
+                mode = st.st_mode & 0o7777
+
+        assert instance_path is not None
+        assert uid is not None
+        assert gid is not None
+        assert mode is not None
+        return cls(
+            host_path=host_path,
+            instance_path=instance_path,
+            uid=uid,
+            gid=gid,
+            mode=mode,
+        )
+
+
+def _resolve_uid(value: str) -> int:
+    try:
+        return int(value)
+    except ValueError:
+        pass
+    try:
+        return pwd.getpwnam(value).pw_uid
+    except KeyError:
+        return 0
+
+
+def _resolve_gid(value: str) -> int:
+    try:
+        return int(value)
+    except ValueError:
+        pass
+    try:
+        return grp.getgrnam(value).gr_gid
+    except KeyError:
+        return 0
+
+
+def _parse_mode(value: str) -> int:
+    try:
+        return int(value, 8)
+    except ValueError:
+        return 0