enkindler 0.1.0__tar.gz

enkindler-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,41 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    name: ${{ matrix.os }} / Python ${{ matrix.python-version }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+
+      # Windows runners ship a stub `make`; install GNU make via choco.
+      - name: Install GNU make (Windows)
+        if: runner.os == 'Windows'
+        run: choco install make -y --no-progress
+
+      - name: Install
+        run: make install
+        # The Makefile wraps venv setup so it's identical across OSes.
+
+      - name: Lint
+        run: make lint
+
+      - name: Test
+        run: make test
+
+      - name: Smoke
+        run: make smoke

enkindler-0.1.0/.gitignore

@@ -0,0 +1,42 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+.venv/
+venv/
+env/
+.eggs/
+*.egg-info/
+*.egg
+build/
+dist/
+wheels/
+.installed.cfg
+
+# Generated SDK (regenerated from openapi spec at build time; never commit)
+src/enkindler_cli/_generated/
+
+# Test/coverage
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.tox/
+
+# Linters
+.ruff_cache/
+.mypy_cache/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Local config that might be created during dev runs
+*.local.toml

enkindler-0.1.0/CLAUDE.md

@@ -0,0 +1,142 @@
+# CLAUDE.md
+
+Operating manual for Claude Code (and human contributors) working in this repo.
+
+## Project Overview
+
+`enkindler-cli` is the Python command-line client for the [Enkindler](https://enkindler.enkindl.com) AI operations dashboard. Distributed on PyPI as `pip install enkindler`. Patterned after `az` and `databricks`.
+
+The CLI is **also exposed as a tool to AI agents**, so command behaviour, output, and error messages must be unambiguous and machine-parseable. When in doubt, optimize for "an LLM should be able to call this without trial and error."
+
+The companion backend repo is at `../enkindler/` (sibling). The backend exposes an OpenAPI 3 spec at `/api/openapi.json`; the CLI consumes that spec to generate a typed SDK and surface commands.
+
+## Repo layout
+
+```
+enkindler-cli/
+├── Makefile                # Source of truth for all dev/build/release commands
+├── pyproject.toml          # PEP 621 metadata; deps; ruff/pytest config
+├── README.md               # End-user docs (install, basic usage)
+├── CLAUDE.md               # ← this file
+├── docs/                   # Long-form procedures (release, sdk-sync, etc.)
+├── .github/workflows/ci.yml  # OS × Python matrix
+├── src/enkindler_cli/
+│   ├── __init__.py         # __version__
+│   ├── main.py             # Typer app + global error handler (_entry)
+│   ├── client.py           # httpx wrapper + AuthError/APIError
+│   ├── config.py           # platformdirs-based TOML config
+│   ├── commands/
+│   │   ├── auth.py         # login (device-code), logout
+│   │   ├── users.py        # whoami
+│   │   └── deployments.py  # list, get, ...
+│   └── _generated/         # ← gitignored; created by `make regen-sdk`
+└── tests/
+```
+
+## Always use `make`
+
+Every common task has a make target. Use them. Never invoke `pytest` / `ruff` / `python -m build` directly — CI uses make, so should you. This is the only way command lines stay in sync across humans, CI, and Claude.
+
+```bash
+make help          # list everything
+make install       # set up venv + install with [dev] extras
+make test          # run pytest
+make lint          # ruff check (no fix)
+make format        # ruff fix + format
+make smoke         # `enkindler --version` + `--help` smoke check
+make build         # sdist + wheel into ./dist
+make regen-sdk     # pull /api/openapi.json from backend, regenerate _generated/
+make publish       # twine upload to PyPI (needs TWINE_PASSWORD)
+make clean         # rm caches and build artifacts
+```
+
+If you need a new shell command frequently, add it as a make target — don't put it in CLAUDE.md prose.
+
+## Conventions
+
+### Commands
+- One file per noun under `src/enkindler_cli/commands/` (e.g. `deployments.py`, `helm.py`, `integrations.py`).
+- A noun with subcommands (verbs) uses a Typer sub-app: see `commands/deployments.py` — exports `app = typer.Typer()` and uses `@app.command("list")`.
+- A noun with one verb (`whoami`, `login`) is a plain function: see `commands/users.py` — register at the top level in `main.py`.
+- All commands accept `--api-url` (override env / config). Resolution: flag > `ENKINDLER_API_URL` > config file > default. Use `effective_api_url()` from `config.py`.
+
+### Errors
+- Never `raise` raw `httpx.HTTPStatusError`. Use `Client` from `client.py` — it converts non-2xx to `AuthError` (401/403) or `APIError` (other). The top-level `_entry()` in `main.py` formats both as friendly red messages with a recovery hint.
+- For business-logic exits, `raise typer.Exit(code=N)` — never `sys.exit()`.
+
+### Output
+- Human output → `rich.Console()` to stdout.
+- Errors → `rich.Console(stderr=True)`.
+- Tables are the default for list commands. Use `rich.table.Table`.
+- Don't print debug info to stdout — that breaks `--output json` (when we add it).
+
+### HTTP
+- All HTTP via `Client` from `client.py`. Always use it as a context manager.
+- One `Client` per command invocation. Don't share connection pools across commands.
+
+### Config
+- Use `platformdirs` for paths. Never hardcode `~/.enkindler` — Windows uses `%APPDATA%`.
+- TOML, not JSON or YAML.
+- Token cached in `config.toml` with 0o600 perms on POSIX. Don't put tokens in env vars or CLI args; the only sanctioned write path is `enkindler login` → `Config.save()`.
+
+### Cross-platform
+We support macOS, Linux, and Windows on Python 3.10–3.13. CI runs the full matrix. Avoid:
+- `os.path.join('/etc/...')`, hardcoded slashes — use `pathlib`
+- Shelling out to Unix-only tools (`curl`, `grep`, `sed`)
+- `subprocess` with `shell=True` — pass an arg list
+- Symlinks
+- ANSI escape codes in non-TTY output (Rich handles this if you let it)
+
+## Common Tasks
+
+### Add a new command
+1. Create or edit a file under `src/enkindler_cli/commands/`.
+2. If it's a new noun, add a sub-`Typer` and register it in `main.py` via `app.add_typer(... name="noun")`.
+3. Add a smoke test in `tests/test_smoke.py` that the new command appears in `--help`.
+4. Run `make lint test` before committing.
+
+### Add a new endpoint to call
+Once the backend annotates a new route (see backend `CLAUDE.md` → "Annotating routes for OpenAPI/CLI"):
+1. Run `make regen-sdk` (or `make regen-sdk OPENAPI_URL=http://localhost:5179/api/openapi.json` while iterating locally).
+2. Use the generated client from `_generated/` in your command. Until the SDK lands, hand-call via `Client.get` / `.post`.
+
+### Cut a release
+See `docs/release.md` (TBD — write when we cut v0.1.0). Short version:
+1. Bump `__version__` in `src/enkindler_cli/__init__.py` AND `version` in `pyproject.toml`.
+2. `make clean build`
+3. `make publish-test` → install from TestPyPI in a fresh venv, smoke-test
+4. `make publish`
+5. `git tag vX.Y.Z && git push --tags`
+
+### Backend out of sync with CLI
+If `make regen-sdk` fails or the generated SDK doesn't compile, the backend OpenAPI spec is malformed. Fix it in `../enkindler/backend/src/server.js` (the JSDoc `@openapi` block above the offending route) — see backend `CLAUDE.md` for the annotation pattern.
+
+## Testing the CLI against a real backend
+
+```bash
+make install
+make smoke                    # offline smoke
+.venv/bin/enkindler login     # device-code flow against prod backend
+.venv/bin/enkindler whoami
+.venv/bin/enkindler deployment list
+```
+
+Override the backend for local dev:
+```bash
+ENKINDLER_API_URL=http://localhost:5179 .venv/bin/enkindler login
+```
+
+## What NOT to do
+
+- Don't add a `requirements.txt`. Deps live in `pyproject.toml`.
+- Don't pin sub-dependencies in `pyproject.toml` — only direct deps.
+- Don't commit `src/enkindler_cli/_generated/` — gitignored, regenerated on demand.
+- Don't add Click decorators directly. Use Typer (which wraps Click) — it gives us free `--help` from type hints.
+- Don't break Python 3.10. We support it until end-of-life.
+- Don't import optional deps at the top of a module — gate behind `if TYPE_CHECKING:` or import inside the function. Keeps `enkindler --help` snappy.
+
+## Pointers to backend repo
+
+- Backend endpoints, auth model, RBAC, deployment infrastructure → `../enkindler/CLAUDE.md`
+- Backend OpenAPI annotation pattern → `../enkindler/CLAUDE.md` → "Annotating routes for OpenAPI/CLI"
+- Device-code auth implementation → `../enkindler/backend/src/auth/deviceCode.js`

enkindler-0.1.0/Makefile

@@ -0,0 +1,108 @@
+# enkindler-cli — canonical command set.
+#
+# Both humans and CI use these targets so there is one source of truth.
+# `make help` lists everything.
+
+PYTHON ?= python3
+VENV   ?= .venv
+
+# venv layout differs on Windows (Scripts/) vs POSIX (bin/).
+ifeq ($(OS),Windows_NT)
+    VENV_BIN := $(VENV)/Scripts
+    PYTHON   := python
+else
+    VENV_BIN := $(VENV)/bin
+endif
+PIP := $(VENV_BIN)/pip
+PY  := $(VENV_BIN)/python
+ENK := $(VENV_BIN)/enkindler
+
+# Backend OpenAPI spec — used by `make regen-sdk`. Override with
+# `make regen-sdk OPENAPI_URL=http://localhost:5179/api/openapi.json`
+# when iterating on the backend locally.
+OPENAPI_URL ?= https://enkindler.enkindl.com/api/openapi.json
+
+# Where the auto-generated openapi-python-client output lives.
+# Gitignored — regenerated from the backend spec on demand.
+SDK_DIR := src/enkindler_cli/_generated
+
+.DEFAULT_GOAL := help
+.PHONY: help setup install dev test lint format typecheck build clean publish-test publish regen-sdk smoke version
+
+help:                  ## Show this help.
+	@awk 'BEGIN { FS = ":.*?## " } /^[a-zA-Z0-9_-]+:.*?## / { printf "  \033[36m%-16s\033[0m %s\n", $$1, $$2 }' $(MAKEFILE_LIST)
+
+# ─── Local dev setup ─────────────────────────────────────────────────────────
+
+$(VENV_BIN)/python:
+	$(PYTHON) -m venv $(VENV)
+	$(PIP) install --upgrade pip
+
+setup: $(VENV_BIN)/python  ## Create virtualenv and install runtime deps only.
+	$(PIP) install -e .
+
+install: $(VENV_BIN)/python  ## Alias for `setup` + dev extras.
+	$(PIP) install -e '.[dev]'
+
+dev: install           ## Same as `install` — for muscle memory.
+
+# ─── Quality gates ───────────────────────────────────────────────────────────
+
+test: install          ## Run the test suite.
+	$(VENV_BIN)/pytest
+
+lint: install          ## Lint with ruff (no auto-fix).
+	$(VENV_BIN)/ruff check .
+
+format: install        ## Auto-format and apply safe ruff fixes.
+	$(VENV_BIN)/ruff check --fix .
+	$(VENV_BIN)/ruff format .
+
+typecheck:             ## (Stub) — add when we adopt a type checker.
+	@echo "No type checker configured yet. Add mypy or pyright when ready."
+
+smoke: install         ## Cheap end-to-end check that the script entrypoint works.
+	$(ENK) --version
+	$(ENK) --help > /dev/null
+
+version: install       ## Print the package version.
+	@$(ENK) --version
+
+# ─── Build & publish ─────────────────────────────────────────────────────────
+
+build: install         ## Build sdist + wheel into ./dist/
+	$(PIP) install --quiet build
+	$(PY) -m build
+
+publish-test: build    ## Upload to TestPyPI (requires TWINE_PASSWORD env).
+	$(PIP) install --quiet twine
+	$(VENV_BIN)/twine upload --repository testpypi dist/*
+
+publish: build         ## Upload to PyPI (requires TWINE_PASSWORD env).
+	$(PIP) install --quiet twine
+	$(VENV_BIN)/twine upload dist/*
+
+# ─── SDK regen from backend OpenAPI spec ─────────────────────────────────────
+
+regen-sdk: install     ## Regenerate the typed SDK from the backend OpenAPI spec.
+	$(PIP) install --quiet openapi-python-client
+	rm -rf $(SDK_DIR)
+	mkdir -p $(SDK_DIR)
+	$(VENV_BIN)/openapi-python-client generate \
+		--url $(OPENAPI_URL) \
+		--output-path $(SDK_DIR)/_tmp \
+		--meta none
+	# openapi-python-client puts files in <project_name>/, flatten one level
+	mv $(SDK_DIR)/_tmp/*/* $(SDK_DIR)/
+	rm -rf $(SDK_DIR)/_tmp
+	@echo "SDK regenerated into $(SDK_DIR) from $(OPENAPI_URL)"
+
+# ─── Housekeeping ────────────────────────────────────────────────────────────
+
+clean:                 ## Remove build artifacts and caches (keeps the venv).
+	rm -rf build dist *.egg-info
+	rm -rf .pytest_cache .ruff_cache .mypy_cache
+	find . -type d -name __pycache__ -prune -exec rm -rf {} +
+
+clean-all: clean       ## Also delete the virtualenv.
+	rm -rf $(VENV)

enkindler-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: enkindler
+Version: 0.1.0
+Summary: Command-line interface for the Enkindler AI operations dashboard.
+Project-URL: Homepage, https://enkindler.enkindl.com
+Project-URL: Repository, https://bitbucket.org/enkindl/enkindler-cli
+Project-URL: Issues, https://bitbucket.org/enkindl/enkindler-cli/issues
+Author: Enkindler Platform
+License: MIT
+Keywords: aks,azure,cli,enkindler,kubernetes
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: platformdirs>=4.2.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: tomli-w>=1.0.0
+Requires-Dist: tomli>=2.0.1; python_version < '3.11'
+Requires-Dist: typer>=0.12.0
+Provides-Extra: dev
+Requires-Dist: pytest-httpx>=0.30; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# enkindler CLI
+
+Command-line interface for the [Enkindler](https://enkindler.enkindl.com) AI operations dashboard. Manages AKS deployments, Helm platforms, integrations, and cluster resources from your terminal.
+
+Patterned after `az` and `databricks` — designed to be ergonomic for both humans and AI agents.
+
+## Install
+
+```bash
+pip install enkindler
+```
+
+Works on macOS, Linux, and Windows (Python 3.10+).
+
+## Quick start
+
+```bash
+# Sign in via Microsoft device-code flow (opens browser)
+enkindler login
+
+# Verify the session
+enkindler whoami
+
+# List your deployments
+enkindler deployment list
+```
+
+## Configuration
+
+Config and the cached JWT live at:
+
+| OS | Path |
+|---|---|
+| macOS | `~/Library/Application Support/enkindler/config.toml` |
+| Linux | `~/.config/enkindler/config.toml` |
+| Windows | `%APPDATA%\enkindler\config.toml` |
+
+Override the backend URL with `--api-url https://...` on any command, or set `ENKINDLER_API_URL` in the environment.
+
+## Architecture
+
+- Backend exposes an OpenAPI spec at `/api/openapi.json` (the contract).
+- This CLI consumes that spec to drive command behaviour.
+- Auth uses the Azure AD device-code flow — no browser required on the same machine, no token-pasting.
+
+## Development
+
+```bash
+python -m venv .venv && source .venv/bin/activate  # or `.venv\Scripts\activate` on Windows
+pip install -e '.[dev]'
+pytest
+ruff check .
+```
+
+## License
+
+MIT

enkindler-0.1.0/README.md

@@ -0,0 +1,57 @@
+# enkindler CLI
+
+Command-line interface for the [Enkindler](https://enkindler.enkindl.com) AI operations dashboard. Manages AKS deployments, Helm platforms, integrations, and cluster resources from your terminal.
+
+Patterned after `az` and `databricks` — designed to be ergonomic for both humans and AI agents.
+
+## Install
+
+```bash
+pip install enkindler
+```
+
+Works on macOS, Linux, and Windows (Python 3.10+).
+
+## Quick start
+
+```bash
+# Sign in via Microsoft device-code flow (opens browser)
+enkindler login
+
+# Verify the session
+enkindler whoami
+
+# List your deployments
+enkindler deployment list
+```
+
+## Configuration
+
+Config and the cached JWT live at:
+
+| OS | Path |
+|---|---|
+| macOS | `~/Library/Application Support/enkindler/config.toml` |
+| Linux | `~/.config/enkindler/config.toml` |
+| Windows | `%APPDATA%\enkindler\config.toml` |
+
+Override the backend URL with `--api-url https://...` on any command, or set `ENKINDLER_API_URL` in the environment.
+
+## Architecture
+
+- Backend exposes an OpenAPI spec at `/api/openapi.json` (the contract).
+- This CLI consumes that spec to drive command behaviour.
+- Auth uses the Azure AD device-code flow — no browser required on the same machine, no token-pasting.
+
+## Development
+
+```bash
+python -m venv .venv && source .venv/bin/activate  # or `.venv\Scripts\activate` on Windows
+pip install -e '.[dev]'
+pytest
+ruff check .
+```
+
+## License
+
+MIT

enkindler-0.1.0/pyproject.toml

@@ -0,0 +1,67 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "enkindler"
+version = "0.1.0"
+description = "Command-line interface for the Enkindler AI operations dashboard."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Enkindler Platform" }]
+keywords = ["enkindler", "cli", "aks", "kubernetes", "azure"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: System :: Systems Administration",
+]
+dependencies = [
+    "typer>=0.12.0",
+    "rich>=13.7.0",
+    "httpx>=0.27.0",
+    "platformdirs>=4.2.0",
+    "tomli>=2.0.1; python_version<'3.11'",
+    "tomli-w>=1.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-httpx>=0.30",
+    "ruff>=0.5.0",
+]
+
+[project.scripts]
+enkindler = "enkindler_cli.main:_entry"
+
+[project.urls]
+Homepage = "https://enkindler.enkindl.com"
+Repository = "https://bitbucket.org/enkindl/enkindler-cli"
+Issues = "https://bitbucket.org/enkindl/enkindler-cli/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/enkindler_cli"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "B", "UP", "SIM", "RUF"]
+ignore = ["E501"]  # line length handled by formatter
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra -q"

enkindler-0.1.0/src/enkindler_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Enkindler command-line interface."""
+
+__version__ = "0.1.0"

enkindler-0.1.0/src/enkindler_cli/client.py

@@ -0,0 +1,114 @@
+"""Thin httpx wrapper that injects the cached JWT and raises typed errors.
+
+Eventually most calls will go through the openapi-python-client generated SDK
+in `_generated/`. This wrapper handles the bootstrap concerns:
+
+  * the device-code login flow (no token yet)
+  * sanity calls like /api/health and /api/instance that don't require auth
+  * a uniform AuthError that the CLI can intercept with a "run `enkindler login`"
+    hint instead of a stack trace
+
+URL resolution is now driven by the multi-cluster Config — Client.from_cluster()
+takes a resolved Cluster object. Per-command --api-url and ENKINDLER_API_URL
+override the cluster's stored URL but reuse its token.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from .config import Cluster, Config, ConfigError, effective_url_override
+
+USER_AGENT = "enkindler-cli/0.0.1"
+
+
+class APIError(Exception):
+    """Backend returned a non-2xx status with an error envelope."""
+
+    def __init__(self, status: int, message: str):
+        super().__init__(f"{status}: {message}")
+        self.status = status
+        self.message = message
+
+
+class AuthError(APIError):
+    """401/403 — token missing, invalid, or insufficient privileges."""
+
+
+def _raise(resp: httpx.Response) -> None:
+    if resp.is_success:
+        return
+    try:
+        body: dict[str, Any] = resp.json()
+        msg = body.get("error") or body.get("message") or resp.text
+    except (ValueError, httpx.DecodingError):
+        msg = resp.text or resp.reason_phrase
+    if resp.status_code in (401, 403):
+        raise AuthError(resp.status_code, msg)
+    raise APIError(resp.status_code, msg)
+
+
+class Client:
+    """Synchronous httpx client scoped to one Enkindler backend."""
+
+    def __init__(self, base_url: str, token: str | None = None, timeout: float = 30.0):
+        headers = {"User-Agent": USER_AGENT, "Accept": "application/json"}
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+        self._http = httpx.Client(base_url=base_url, headers=headers, timeout=timeout)
+
+    @classmethod
+    def from_cluster(cls, cluster: Cluster, *, api_url_override: str | None = None) -> Client:
+        url = api_url_override or effective_url_override() or cluster.url
+        return cls(base_url=url, token=cluster.token)
+
+    @classmethod
+    def for_url(cls, url: str, *, token: str | None = None) -> Client:
+        """Bare client for endpoints that don't have a configured cluster yet
+        (e.g. `enkindler config add` verifying a fresh URL)."""
+        return cls(base_url=url.rstrip("/"), token=token)
+
+    @classmethod
+    def from_default(cls, cluster_name: str | None = None, api_url_override: str | None = None) -> Client:
+        """Convenience: resolve via Config.load() and the optional --cluster name.
+        Raises ConfigError if no cluster is configured / resolvable."""
+        cfg = Config.load()
+        cluster = cfg.resolve(cluster_name)
+        return cls.from_cluster(cluster, api_url_override=api_url_override)
+
+    def get(self, path: str, **kwargs: Any) -> Any:
+        r = self._http.get(path, **kwargs)
+        _raise(r)
+        return r.json()
+
+    def post(self, path: str, json: Any | None = None, **kwargs: Any) -> Any:
+        r = self._http.post(path, json=json, **kwargs)
+        _raise(r)
+        if r.status_code == 204 or not r.content:
+            return None
+        return r.json()
+
+    def patch(self, path: str, json: Any | None = None, **kwargs: Any) -> Any:
+        r = self._http.patch(path, json=json, **kwargs)
+        _raise(r)
+        return r.json()
+
+    def delete(self, path: str, **kwargs: Any) -> Any:
+        r = self._http.delete(path, **kwargs)
+        _raise(r)
+        return r.json() if r.content else None
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> Client:
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+
+# Re-export for command modules.
+__all__ = ["APIError", "AuthError", "Client", "Cluster", "Config", "ConfigError"]