aircloud-cli 0.1.0__tar.gz

aircloud_cli-0.1.0/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: aircloud-cli
+Version: 0.1.0
+Summary: AirCloud CLI — endpoint management, SSH, and container exec
+Author-email: AirCloud Team <support@aieev.com>
+License: Proprietary
+Project-URL: Homepage, https://aieev.com
+Project-URL: Repository, https://github.com/aieev/aircloud-cli
+Keywords: aircloud,ssh,cli,endpoint,exec
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Classifier: Topic :: System :: Shells
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: websockets>=12.0
+Requires-Dist: click>=8.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: paramiko>=3.0
+Requires-Dist: cryptography>=3.0
+
+# aircloud-cli
+
+CLI for the [AirCloud](https://aieev.com) platform — endpoint management,
+SSH access, and container shell exec.
+
+## Install
+
+```bash
+pip install aircloud-cli
+```
+
+Requires Python 3.9+.
+
+## Quick start
+
+```bash
+# one-time setup
+aircloud config set api-key <YOUR_API_KEY>
+aircloud config set api-base-url <API_BASE_URL>
+
+# inspect endpoints
+aircloud endpoints list
+aircloud endpoints get <endpoint_id>
+
+# open a shell in a container
+aircloud ssh <endpoint_id>            # public-key auth, sshd-based
+aircloud exec <endpoint_id>           # docker exec over WS, no sshd needed
+```
+
+## Commands
+
+### `aircloud config`
+
+Manage CLI configuration in `~/.aircloud/config.json`.
+
+```bash
+aircloud config set api-key <key>
+aircloud config set api-base-url <url>
+aircloud config list
+aircloud config get <key>
+```
+
+### `aircloud endpoints`
+
+```bash
+aircloud endpoints list                          # paged list
+aircloud endpoints get <id>                      # detail
+aircloud endpoints start <id>
+aircloud endpoints stop <id>
+aircloud endpoints scale <id> --replicas N
+aircloud endpoints patch <id> --command "..." --port 8080 --env KEY=VALUE
+aircloud endpoints replicas <id>                 # current replicas
+aircloud endpoints logs <id> [--replica-id X] [--start-line N --end-line M]
+```
+
+### `aircloud ssh`
+
+SSH into a container via WebSocket tunnel using public-key authentication.
+
+```bash
+aircloud ssh <endpoint_id>                       # auto-discover ~/.ssh/id_*
+aircloud ssh <endpoint_id> -i ~/.ssh/aircloud_key
+aircloud ssh <endpoint_id> -r <replica_id>       # pin to specific replica
+aircloud ssh <endpoint_id> --tunnel-only         # open tunnel only
+```
+
+Auto-discovers identity files in this order: `~/.ssh/id_ed25519`,
+`~/.ssh/id_ecdsa`, `~/.ssh/id_rsa`. Override with `-i / --identity-file`.
+
+The container image must have `sshd` running and consume the
+`AIRCLOUD_AUTHORIZED_KEYS` environment variable (AirCloud-provided template
+images do this by default).
+
+### `aircloud exec`
+
+Open an interactive shell in the container via `docker exec` over a
+WebSocket. Works on any image — no `sshd` required.
+
+```bash
+aircloud exec <endpoint_id>
+aircloud exec <endpoint_id> -r <replica_id>      # pin replica
+aircloud exec <endpoint_id> -c "/bin/sh"         # custom command
+```
+
+### `aircloud whoami`
+
+Print the identity associated with the current API key.
+
+```bash
+aircloud whoami
+```
+
+## Status
+
+This is an early functional release. Interfaces may change before `1.0.0`.
+
+## License
+
+Proprietary. © AIEEV / AirCloud.

aircloud_cli-0.1.0/README.md

@@ -0,0 +1,99 @@
+# aircloud-cli
+
+CLI for the [AirCloud](https://aieev.com) platform — endpoint management,
+SSH access, and container shell exec.
+
+## Install
+
+```bash
+pip install aircloud-cli
+```
+
+Requires Python 3.9+.
+
+## Quick start
+
+```bash
+# one-time setup
+aircloud config set api-key <YOUR_API_KEY>
+aircloud config set api-base-url <API_BASE_URL>
+
+# inspect endpoints
+aircloud endpoints list
+aircloud endpoints get <endpoint_id>
+
+# open a shell in a container
+aircloud ssh <endpoint_id>            # public-key auth, sshd-based
+aircloud exec <endpoint_id>           # docker exec over WS, no sshd needed
+```
+
+## Commands
+
+### `aircloud config`
+
+Manage CLI configuration in `~/.aircloud/config.json`.
+
+```bash
+aircloud config set api-key <key>
+aircloud config set api-base-url <url>
+aircloud config list
+aircloud config get <key>
+```
+
+### `aircloud endpoints`
+
+```bash
+aircloud endpoints list                          # paged list
+aircloud endpoints get <id>                      # detail
+aircloud endpoints start <id>
+aircloud endpoints stop <id>
+aircloud endpoints scale <id> --replicas N
+aircloud endpoints patch <id> --command "..." --port 8080 --env KEY=VALUE
+aircloud endpoints replicas <id>                 # current replicas
+aircloud endpoints logs <id> [--replica-id X] [--start-line N --end-line M]
+```
+
+### `aircloud ssh`
+
+SSH into a container via WebSocket tunnel using public-key authentication.
+
+```bash
+aircloud ssh <endpoint_id>                       # auto-discover ~/.ssh/id_*
+aircloud ssh <endpoint_id> -i ~/.ssh/aircloud_key
+aircloud ssh <endpoint_id> -r <replica_id>       # pin to specific replica
+aircloud ssh <endpoint_id> --tunnel-only         # open tunnel only
+```
+
+Auto-discovers identity files in this order: `~/.ssh/id_ed25519`,
+`~/.ssh/id_ecdsa`, `~/.ssh/id_rsa`. Override with `-i / --identity-file`.
+
+The container image must have `sshd` running and consume the
+`AIRCLOUD_AUTHORIZED_KEYS` environment variable (AirCloud-provided template
+images do this by default).
+
+### `aircloud exec`
+
+Open an interactive shell in the container via `docker exec` over a
+WebSocket. Works on any image — no `sshd` required.
+
+```bash
+aircloud exec <endpoint_id>
+aircloud exec <endpoint_id> -r <replica_id>      # pin replica
+aircloud exec <endpoint_id> -c "/bin/sh"         # custom command
+```
+
+### `aircloud whoami`
+
+Print the identity associated with the current API key.
+
+```bash
+aircloud whoami
+```
+
+## Status
+
+This is an early functional release. Interfaces may change before `1.0.0`.
+
+## License
+
+Proprietary. © AIEEV / AirCloud.

aircloud_cli-0.1.0/aircloud_cli/client.py

@@ -0,0 +1,166 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+import httpx
+
+
+class AirCloudError(Exception):
+    """Base exception for AirCloud CLI client."""
+
+
+class AirCloudAPIError(AirCloudError):
+    """Raised when the AirCloud API returns an error response."""
+
+    def __init__(self, message: str, status_code: int | None = None):
+        super().__init__(message)
+        self.status_code = status_code
+
+
+@dataclass
+class AirCloudClient:
+    base_url: str
+    api_key: str
+    timeout: int = 30
+    _http: httpx.Client = field(init=False, repr=False)
+
+    def __post_init__(self):
+        self._http = httpx.Client(
+            base_url=self.base_url.rstrip("/"),
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Accept": "application/json",
+            },
+            timeout=self.timeout,
+        )
+
+    def _request_json(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: dict[str, Any] | None = None,
+        body: dict[str, Any] | None = None,
+    ) -> Any:
+        params = {k: v for k, v in (query or {}).items() if v is not None} or None
+        try:
+            response = self._http.request(
+                method.upper(),
+                path,
+                params=params,
+                json=body,
+            )
+            response.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            detail = exc.response.text
+            message = f"API request failed with HTTP {exc.response.status_code}"
+            if detail:
+                try:
+                    error_payload = exc.response.json()
+                    message = error_payload.get("detail") or error_payload.get("message") or message
+                except Exception:
+                    message = detail
+            raise AirCloudAPIError(message, status_code=exc.response.status_code) from exc
+        except httpx.ConnectError as exc:
+            raise AirCloudError(f"Failed to reach AirCloud API: {exc}") from exc
+
+        if not response.text:
+            return None
+        return response.json()
+
+    def get_me(self) -> dict[str, Any]:
+        return self._request_json("GET", "/external/api/v1/me")
+
+    def list_endpoints(
+        self,
+        *,
+        search: str | None = None,
+        is_active: bool | None = None,
+        page: int = 1,
+        size: int = 50,
+    ) -> dict[str, Any]:
+        return self._request_json(
+            "GET",
+            "/external/api/v1/endpoints",
+            query={
+                "search": search,
+                "is_active": str(is_active).lower() if is_active is not None else None,
+                "page": page,
+                "size": size,
+            },
+        )
+
+    def get_endpoint(self, endpoint_id: str) -> dict[str, Any]:
+        return self._request_json("GET", f"/external/api/v1/endpoints/{endpoint_id}")
+
+    def get_replicas(self, endpoint_id: str) -> list[dict[str, Any]]:
+        return self._request_json(
+            "GET",
+            f"/external/api/v1/endpoints/{endpoint_id}/replicas",
+        )
+
+    def list_logs(
+        self,
+        endpoint_id: str,
+        *,
+        replica_id: str | None = None,
+        include_history: bool = True,
+    ) -> list[dict[str, Any]]:
+        return self._request_json(
+            "GET",
+            f"/external/api/v1/endpoints/{endpoint_id}/logs",
+            query={
+                "replica_id": replica_id,
+                "include_history": str(include_history).lower(),
+            },
+        )
+
+    def read_log_file(
+        self,
+        endpoint_id: str,
+        *,
+        node_id: str,
+        filename: str,
+        start_line: int = 1,
+        end_line: int = 200,
+    ) -> dict[str, Any]:
+        return self._request_json(
+            "GET",
+            f"/external/api/v1/endpoints/{endpoint_id}/logs/file",
+            query={
+                "node_id": node_id,
+                "filename": filename,
+                "start_line": start_line,
+                "end_line": end_line,
+            },
+        )
+
+    def start_endpoint(self, endpoint_id: str) -> dict[str, Any]:
+        return self._request_json(
+            "POST",
+            f"/external/api/v1/endpoints/{endpoint_id}/start",
+        )
+
+    def stop_endpoint(self, endpoint_id: str) -> dict[str, Any]:
+        return self._request_json(
+            "POST",
+            f"/external/api/v1/endpoints/{endpoint_id}/stop",
+        )
+
+    def scale_endpoint(self, endpoint_id: str, num_replicas: int) -> dict[str, Any]:
+        return self._request_json(
+            "POST",
+            f"/external/api/v1/endpoints/{endpoint_id}/scale",
+            body={"num_replicas": num_replicas},
+        )
+
+    def patch_endpoint(
+        self,
+        endpoint_id: str,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        body = {k: v for k, v in kwargs.items() if v is not None}
+        return self._request_json(
+            "PATCH",
+            f"/external/api/v1/endpoints/{endpoint_id}",
+            body=body,
+        )

aircloud_cli-0.1.0/aircloud_cli/config.py

@@ -0,0 +1,35 @@
+import json
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".aircloud"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+DEFAULT_API_BASE_URL = "https://your-aircloud-host.example.com"
+
+
+def _load() -> dict:
+    if CONFIG_FILE.exists():
+        return json.loads(CONFIG_FILE.read_text())
+    return {}
+
+
+def _save(data: dict):
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(data, indent=2))
+
+
+def get(key: str) -> str | None:
+    return _load().get(key)
+
+
+def set(key: str, value: str):
+    data = _load()
+    data[key] = value
+    _save(data)
+
+
+def get_api_base_url() -> str:
+    return get("api-base-url") or DEFAULT_API_BASE_URL
+
+
+def get_api_key() -> str | None:
+    return get("api-key")

aircloud_cli-0.1.0/aircloud_cli/container_exec.py

@@ -0,0 +1,149 @@
+import asyncio
+import json
+import os
+import sys
+import termios
+import tty
+
+import websockets
+
+
+async def _run_exec(ws_url: str, api_key: str, cmd: list[str]):
+    headers = {"Authorization": f"Bearer {api_key}"}
+
+    try:
+        ws = await websockets.connect(
+            ws_url,
+            additional_headers=headers,
+            ping_interval=None,
+            max_size=None,
+        )
+    except websockets.exceptions.InvalidStatusCode as e:
+        if e.status_code in (401, 403):
+            print(f"  Access denied (HTTP {e.status_code}). Check API key.")
+        elif e.status_code == 302:
+            print("  Authentication failed (redirected to login).")
+        else:
+            print(f"  WebSocket handshake failed: HTTP {e.status_code}")
+        return
+    except Exception as e:
+        print(f"  Failed to connect: {e}")
+        return
+
+    if not sys.stdin.isatty():
+        print("  exec requires an interactive TTY (stdin).")
+        await ws.close()
+        return
+
+    fd = sys.stdin.fileno()
+    old_attr = termios.tcgetattr(fd)
+    tty.setraw(fd)
+
+    loop = asyncio.get_event_loop()
+    stopping = asyncio.Event()
+
+    input_buffer = bytearray()
+    exit_task: asyncio.Task | None = None
+
+    def schedule_close():
+        nonlocal exit_task
+        if exit_task and not exit_task.done():
+            exit_task.cancel()
+
+        async def _close():
+            try:
+                await asyncio.sleep(2.0)
+                try:
+                    await ws.close(code=1000, reason="client-initiated close")
+                except Exception:
+                    pass
+                stopping.set()
+            except asyncio.CancelledError:
+                pass
+
+        exit_task = asyncio.create_task(_close())
+
+    def inspect_input(data: bytes):
+        for b in data:
+            if b == 0x04:  # Ctrl-D
+                schedule_close()
+                input_buffer.clear()
+            elif b in (0x0D, 0x0A):  # CR / LF
+                line = (
+                    bytes(input_buffer)
+                    .decode("utf-8", errors="replace")
+                    .strip()
+                )
+                if line == "exit" or line.endswith(" exit"):
+                    schedule_close()
+                input_buffer.clear()
+            elif b == 0x7F:  # Backspace
+                if input_buffer:
+                    input_buffer.pop()
+            else:
+                input_buffer.append(b)
+
+    async def send_bytes(data: bytes):
+        try:
+            await ws.send(data)
+        except websockets.exceptions.ConnectionClosed:
+            stopping.set()
+        except Exception:
+            stopping.set()
+
+    def on_stdin_readable():
+        try:
+            data = os.read(fd, 1024)
+        except OSError:
+            stopping.set()
+            return
+        if not data:
+            stopping.set()
+            return
+        inspect_input(data)
+        asyncio.ensure_future(send_bytes(data))
+
+    async def ws_to_stdout():
+        try:
+            async for msg in ws:
+                if isinstance(msg, bytes):
+                    os.write(sys.stdout.fileno(), msg)
+                elif isinstance(msg, str):
+                    os.write(sys.stdout.fileno(), msg.encode())
+        except (asyncio.CancelledError, websockets.exceptions.ConnectionClosed):
+            pass
+        finally:
+            stopping.set()
+
+    try:
+        await ws.send(json.dumps({"cmd": cmd, "tty": True}))
+        loop.add_reader(fd, on_stdin_readable)
+        ws_task = asyncio.create_task(ws_to_stdout())
+
+        await stopping.wait()
+
+        ws_task.cancel()
+        try:
+            await ws_task
+        except (asyncio.CancelledError, Exception):
+            pass
+    finally:
+        try:
+            loop.remove_reader(fd)
+        except Exception:
+            pass
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_attr)
+        if exit_task and not exit_task.done():
+            exit_task.cancel()
+        try:
+            await ws.close()
+        except Exception:
+            pass
+
+
+def start_exec(ws_url: str, api_key: str, cmd: list[str]):
+    """Open a docker exec session to an endpoint's container over WS."""
+    try:
+        asyncio.run(_run_exec(ws_url, api_key, cmd))
+    except KeyboardInterrupt:
+        pass