wayscloud-cli 0.1.0__tar.gz

wayscloud_cli-0.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: wayscloud-cli
+Version: 0.1.0
+Summary: WAYSCloud CLI — command-line interface for WAYSCloud platform
+License: Proprietary
+Project-URL: Homepage, https://wayscloud.net
+Project-URL: Documentation, https://docs.wayscloud.net/cli
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.25
+Requires-Dist: typer>=0.9
+Requires-Dist: rich>=13.0
+Requires-Dist: websockets>=12.0
+
+# WAYSCloud CLI
+
+Command-line interface for WAYSCloud platform services.
+
+## Install
+
+```bash
+pip install wayscloud-cli
+```
+
+## Usage
+
+```bash
+cloud login --token <pat-from-portal>
+cloud whoami
+cloud vps list
+cloud vps plans
+cloud shell connect
+```
+
+## Documentation
+
+See [docs/en/23-cli.md](https://docs.wayscloud.net/cli) for full documentation.

wayscloud_cli-0.1.0/README.md

@@ -0,0 +1,23 @@
+# WAYSCloud CLI
+
+Command-line interface for WAYSCloud platform services.
+
+## Install
+
+```bash
+pip install wayscloud-cli
+```
+
+## Usage
+
+```bash
+cloud login --token <pat-from-portal>
+cloud whoami
+cloud vps list
+cloud vps plans
+cloud shell connect
+```
+
+## Documentation
+
+See [docs/en/23-cli.md](https://docs.wayscloud.net/cli) for full documentation.

wayscloud_cli-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wayscloud-cli"
+version = "0.1.0"
+description = "WAYSCloud CLI — command-line interface for WAYSCloud platform"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "Proprietary"}
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "httpx>=0.25",
+    "typer>=0.9",
+    "rich>=13.0",
+    "websockets>=12.0",
+]
+
+[project.urls]
+Homepage = "https://wayscloud.net"
+Documentation = "https://docs.wayscloud.net/cli"
+
+[project.scripts]
+cloud = "wayscloud_cli.__main__:main"

wayscloud_cli-0.1.0/setup.cfg

@@ -0,0 +1,11 @@
+[metadata]
+name = wayscloud-cli
+version = 0.1.0
+
+[options]
+packages = find:
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

wayscloud_cli-0.1.0/wayscloud_cli/__init__.py

@@ -0,0 +1,2 @@
+"""WAYSCloud CLI — cloud command."""
+__version__ = "0.1.0"

wayscloud_cli-0.1.0/wayscloud_cli/__main__.py

@@ -0,0 +1,61 @@
+"""
+WAYSCloud CLI entry point.
+
+Binary name: cloud (C21)
+Package name: wayscloud-cli (C21)
+"""
+
+import typer
+
+from . import __version__
+from .output import set_json_mode, set_no_color
+from .commands.login import app as login_app
+from .commands.vps import app as vps_app
+from .commands.shell import app as shell_app
+
+app = typer.Typer(
+    name="cloud",
+    help="WAYSCloud CLI",
+    no_args_is_help=True,
+    add_completion=True,
+)
+
+
+# Global options callback
+@app.callback(invoke_without_command=True)
+def global_options(
+    ctx: typer.Context,
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON (C11)"),
+    no_color: bool = typer.Option(False, "--no-color", help="Disable colors"),
+    version: bool = typer.Option(False, "--version", help="Show version"),
+):
+    """WAYSCloud CLI"""
+    if version:
+        print(f"WAYSCloud CLI {__version__}")
+        raise typer.Exit()
+
+    set_json_mode(json_output)
+    set_no_color(no_color)
+
+    if ctx.invoked_subcommand is None:
+        print(ctx.get_help())
+        raise typer.Exit()
+
+
+# Register command groups
+app.add_typer(login_app, name="auth", help="Login, logout, whoami")
+app.add_typer(vps_app, name="vps", help="Virtual Private Servers")
+app.add_typer(shell_app, name="shell", help="Interactive CloudShell")
+
+# Top-level shortcuts for login/logout/whoami
+app.command("login")(login_app.registered_commands[0].callback)
+app.command("logout")(login_app.registered_commands[1].callback)
+app.command("whoami")(login_app.registered_commands[2].callback)
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

wayscloud_cli-0.1.0/wayscloud_cli/client.py

@@ -0,0 +1,94 @@
+"""
+HTTP client for WAYSCloud API (C28, C29).
+
+All requests use Authorization: Bearer <token> (C28).
+Error responses follow {error, code, message} format (C29).
+"""
+
+import sys
+from typing import Optional
+
+import httpx
+
+from .config import API_BASE
+
+
+def get_client(token: str, timeout: float = 15.0) -> httpx.Client:
+    """Create HTTP client with auth header (C28)."""
+    return httpx.Client(
+        base_url=API_BASE,
+        headers={"Authorization": f"Bearer {token}"},
+        timeout=timeout,
+    )
+
+
+def api_get(token: str, path: str, params: Optional[dict] = None) -> dict:
+    """GET request to API. Returns parsed JSON or exits with error."""
+    with get_client(token) as client:
+        resp = client.get(path, params=params)
+    return _handle_response(resp)
+
+
+def api_post(token: str, path: str, json_body: Optional[dict] = None) -> dict:
+    """POST request to API."""
+    with get_client(token) as client:
+        resp = client.post(path, json=json_body)
+    return _handle_response(resp)
+
+
+def api_delete(token: str, path: str) -> dict:
+    """DELETE request to API."""
+    with get_client(token) as client:
+        resp = client.delete(path)
+    return _handle_response(resp)
+
+
+def _handle_response(resp: httpx.Response) -> dict:
+    """Handle API response. Returns data or raises SystemExit with error (C13, C29)."""
+    if resp.status_code == 200 or resp.status_code == 201:
+        try:
+            return resp.json()
+        except Exception:
+            return {"status": "ok"}
+
+    if resp.status_code == 204:
+        return {"status": "ok"}
+
+    # Error handling (C29)
+    try:
+        body = resp.json()
+        detail = body.get("detail", "Unknown error")
+        if isinstance(detail, dict):
+            msg = detail.get("error", str(detail))
+        elif isinstance(detail, list):
+            msg = "; ".join(d.get("msg", str(d)) for d in detail)
+        else:
+            msg = str(detail)
+    except Exception:
+        msg = resp.text[:200] if resp.text else "Unknown error"
+
+    # Map HTTP status to exit code (C13)
+    if resp.status_code in (401, 403):
+        _error(msg, exit_code=2)
+    elif resp.status_code == 404:
+        _error(msg, exit_code=1)
+    elif resp.status_code == 422:
+        _error(msg, exit_code=1)
+    else:
+        _error(msg, exit_code=3)
+
+    return {}  # unreachable
+
+
+def _error(msg: str, exit_code: int = 1) -> None:
+    """Print error to stderr and exit (C13)."""
+    import json as json_mod
+    from .output import is_json_mode
+
+    if is_json_mode():
+        err = {"error": "api_error", "code": exit_code, "message": msg}
+        print(json_mod.dumps(err), file=sys.stderr)
+    else:
+        print(f"Error: {msg}", file=sys.stderr)
+
+    sys.exit(exit_code)

wayscloud_cli-0.1.0/wayscloud_cli/commands/login.py

@@ -0,0 +1,88 @@
+"""
+cloud login / logout / whoami commands (C1, C2, C3).
+
+login validates token against API before saving (C1).
+"""
+
+import typer
+
+from ..config import resolve_token, save_token, delete_token, API_BASE
+from ..output import print_object, print_error, is_json_mode, print_json
+
+app = typer.Typer(help="Authentication")
+
+
+@app.command()
+def login(
+    token: str = typer.Option(..., "--token", help="PAT token from portal"),
+):
+    """Login with a CLI token from the WAYSCloud portal.
+
+    Token is validated against API before saving (C1).
+    Saved to ~/.wayscloud/credentials with chmod 600 (C24).
+    """
+    # Validate format
+    if not token.startswith("wayscloud_pat_"):
+        print_error("invalid_token", "Invalid token format. Expected: wayscloud_pat_...", exit_code=2)
+
+    # Validate against API before saving (C1)
+    import httpx
+    try:
+        resp = httpx.get(
+            f"{API_BASE}/api/v1/dashboard/account/profile",
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=10,
+        )
+    except httpx.ConnectError:
+        print_error("network_error", f"Cannot reach {API_BASE}", exit_code=3)
+    except Exception as e:
+        print_error("network_error", str(e), exit_code=3)
+
+    if resp.status_code == 401:
+        print_error("invalid_token", "Token is invalid or expired", exit_code=2)
+    if resp.status_code == 403:
+        print_error("forbidden", "Token does not have required permissions", exit_code=2)
+    if resp.status_code != 200:
+        print_error("api_error", f"API returned {resp.status_code}", exit_code=3)
+
+    # Token is valid — save it (C2)
+    save_token(token)
+
+    if is_json_mode():
+        print_json({"status": "ok", "message": "Login successful"})
+    else:
+        profile = resp.json()
+        print("WAYSCloud CLI v0.1.0")
+        print(f"Logged in as: {profile.get('email', 'unknown')}")
+        print(f"Customer: {profile.get('customer_id', 'unknown')}")
+        print(f"Token saved to ~/.wayscloud/credentials")
+
+
+@app.command()
+def logout():
+    """Remove saved credentials."""
+    if delete_token():
+        print("Logged out. Token removed.")
+    else:
+        print("No saved credentials found.")
+
+
+@app.command()
+def whoami(
+    token: str = typer.Option(None, "--token", help="Override token"),
+):
+    """Show current authenticated identity."""
+    resolved = resolve_token(token)
+    if not resolved:
+        print_error("not_authenticated", "Not logged in. Run: cloud login --token <pat>", exit_code=2)
+
+    from ..client import api_get
+    profile = api_get(resolved, "/api/v1/dashboard/account/profile")
+
+    fields = [
+        ("customer_id", "Customer ID"),
+        ("email", "Email"),
+        ("name", "Name"),
+        ("customer_type", "Type"),
+    ]
+    print_object(profile, fields)

wayscloud_cli-0.1.0/wayscloud_cli/commands/shell.py

@@ -0,0 +1,138 @@
+"""
+cloud shell — interactive CloudShell via WebSocket (C14, C25, C30).
+
+Connects to wss://shell.wayscloud.services/ws with Authorization header.
+PAT must have shell:connect scope (C6).
+"""
+
+import sys
+import json
+import asyncio
+from typing import Optional
+
+import typer
+
+from ..config import resolve_token, SHELL_WS
+from ..output import print_error
+
+app = typer.Typer(help="Interactive shell")
+
+
+@app.command("connect")
+def connect(
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Connect to interactive CloudShell.
+
+    Requires shell:connect scope on your CLI token.
+    """
+    resolved = resolve_token(token)
+    if not resolved:
+        print_error("not_authenticated", "Not logged in. Run: cloud login --token <pat>", exit_code=2)
+
+    try:
+        asyncio.run(_shell_session(resolved))
+    except KeyboardInterrupt:
+        print("\nSession ended.")
+
+
+async def _shell_session(token: str) -> None:
+    """Run interactive WebSocket shell session."""
+    import websockets
+
+    # Connect with Authorization header (C14, C30 — never query string)
+    headers = {"Authorization": f"Bearer {token}"}
+
+    try:
+        async with websockets.connect(
+            SHELL_WS,
+            additional_headers=headers,
+            open_timeout=10,
+            close_timeout=5,
+            ping_interval=30,
+        ) as ws:
+            print("WAYSCloud Shell v0.1.0")
+            print("Type 'cloud help' for commands, 'exit' to quit.\n")
+
+            # Start reader task
+            reader_task = asyncio.create_task(_read_messages(ws))
+
+            # Input loop
+            try:
+                await _input_loop(ws)
+            finally:
+                reader_task.cancel()
+                try:
+                    await reader_task
+                except asyncio.CancelledError:
+                    pass
+
+    except Exception as e:
+        err = str(e)
+        # Map connection errors to exit codes (C13, C16)
+        if "403" in err:
+            print("Error: Authentication failed or missing shell:connect scope.", file=sys.stderr)
+            sys.exit(2)
+        elif "Connection refused" in err or "unreachable" in err.lower():
+            print(f"Error: Cannot connect to shell service.", file=sys.stderr)
+            sys.exit(3)
+        else:
+            print(f"Error: {err}", file=sys.stderr)
+            sys.exit(3)
+
+
+async def _read_messages(ws) -> None:
+    """Read and display messages from WebSocket."""
+    try:
+        async for raw in ws:
+            try:
+                msg = json.loads(raw)
+                msg_type = msg.get("type", "")
+                data = msg.get("data", "")
+
+                if msg_type == "output":
+                    print(data, end="", flush=True)
+                elif msg_type == "prompt":
+                    print(data, end="", flush=True)
+                elif msg_type == "error":
+                    print(f"\nError: {data}", file=sys.stderr)
+                elif msg_type == "history":
+                    pass  # Could populate readline history
+                elif msg_type == "ratelimit":
+                    print(f"\nRate limited. Try again later.", file=sys.stderr)
+                elif msg_type == "close":
+                    print(f"\n{data}")
+                    break
+
+            except json.JSONDecodeError:
+                print(raw, end="", flush=True)
+
+    except asyncio.CancelledError:
+        raise
+    except Exception:
+        pass
+
+
+async def _input_loop(ws) -> None:
+    """Read user input and send to WebSocket."""
+    loop = asyncio.get_event_loop()
+
+    while True:
+        try:
+            line = await loop.run_in_executor(None, sys.stdin.readline)
+            if not line:
+                break
+
+            command = line.strip()
+            if command.lower() in ("exit", "quit", "q"):
+                break
+
+            await ws.send(json.dumps({"type": "input", "data": command}))
+
+        except (EOFError, KeyboardInterrupt):
+            break
+
+    try:
+        await ws.close()
+    except Exception:
+        pass

wayscloud_cli-0.1.0/wayscloud_cli/commands/vps.py

@@ -0,0 +1,194 @@
+"""
+cloud vps commands — first v1 resource commands.
+
+All calls go directly to API with PAT auth (not through CloudShell).
+"""
+
+import typer
+from typing import Optional
+
+from ..config import resolve_token
+from ..client import api_get, api_post, api_delete
+from ..output import print_table, print_object, print_error, print_json, is_json_mode
+
+app = typer.Typer(help="Virtual Private Servers")
+
+
+def _require_token(token: Optional[str]) -> str:
+    resolved = resolve_token(token)
+    if not resolved:
+        print_error("not_authenticated", "Not logged in. Run: cloud login --token <pat>", exit_code=2)
+    return resolved
+
+
+@app.command("list")
+def list_vps(
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+    status: Optional[str] = typer.Option(None, help="Filter by status"),
+    region: Optional[str] = typer.Option(None, help="Filter by region"),
+):
+    """List your VPS instances."""
+    t = _require_token(token)
+    params = {}
+    if status:
+        params["status"] = status
+    if region:
+        params["region"] = region
+
+    data = api_get(t, "/api/v1/dashboard/vps/", params=params)
+
+    instances = data.get("instances", data) if isinstance(data, dict) else data
+
+    if is_json_mode():
+        print_json(instances if isinstance(instances, list) else [])
+        return
+
+    if not instances:
+        print("No VPS instances found.")
+        return
+
+    rows = []
+    for v in (instances if isinstance(instances, list) else []):
+        rows.append({
+            "id": v.get("id", "")[:12],
+            "hostname": v.get("hostname", v.get("display_name", "")),
+            "status": v.get("status", ""),
+            "ip": v.get("ipv4_address", v.get("ip_address", "")),
+            "plan": v.get("plan_code", ""),
+            "region": v.get("region", ""),
+        })
+
+    print_table(rows, [
+        ("id", "ID", 14),
+        ("hostname", "Hostname", 24),
+        ("status", "Status", 12),
+        ("ip", "IP", 16),
+        ("plan", "Plan", 16),
+        ("region", "Region", 8),
+    ])
+
+
+@app.command("info")
+def info_vps(
+    vps_id: str = typer.Argument(..., help="VPS ID"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Show VPS details."""
+    t = _require_token(token)
+    data = api_get(t, f"/api/v1/dashboard/vps/{vps_id}")
+
+    print_object(data, [
+        ("id", "ID"),
+        ("hostname", "Hostname"),
+        ("status", "Status"),
+        ("power_state", "Power"),
+        ("ipv4_address", "IPv4"),
+        ("os_template", "OS"),
+        ("plan_code", "Plan"),
+        ("region", "Region"),
+        ("created_at", "Created"),
+    ])
+
+
+@app.command("plans")
+def list_plans(
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+    region: Optional[str] = typer.Option(None, help="Filter by region"),
+):
+    """List available VPS plans."""
+    t = _require_token(token)
+    params = {}
+    if region:
+        params["region"] = region
+
+    data = api_get(t, "/api/v1/dashboard/vps/plans", params=params)
+
+    plans = data if isinstance(data, list) else []
+
+    if is_json_mode():
+        print_json(plans)
+        return
+
+    rows = []
+    for p in plans:
+        rows.append({
+            "code": p.get("plan_code", ""),
+            "vcpu": p.get("vcpu", ""),
+            "ram": f"{p.get('ram_mb', 0) // 1024}GB",
+            "disk": f"{p.get('disk_gb', 0)}GB",
+            "price": f"{p.get('monthly_price', '')} {p.get('currency', '')}",
+        })
+
+    print_table(rows, [
+        ("code", "Plan", 24),
+        ("vcpu", "vCPU", 6),
+        ("ram", "RAM", 8),
+        ("disk", "Disk", 8),
+        ("price", "Price/mo", 14),
+    ])
+
+
+@app.command("status")
+def vps_status(
+    vps_id: str = typer.Argument(..., help="VPS ID"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Get real-time VPS status."""
+    t = _require_token(token)
+    data = api_get(t, f"/api/v1/dashboard/vps/{vps_id}/status")
+    print_object(data, [
+        ("status", "Status"),
+        ("power_state", "Power"),
+        ("uptime", "Uptime"),
+        ("cpu_usage", "CPU"),
+        ("memory_usage", "Memory"),
+    ])
+
+
+@app.command("start")
+def start_vps(
+    vps_id: str = typer.Argument(..., help="VPS ID"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Start a VPS."""
+    t = _require_token(token)
+    data = api_post(t, f"/api/v1/dashboard/vps/{vps_id}/start")
+    if is_json_mode():
+        print_json(data)
+    else:
+        print(f"VPS {vps_id}: {data.get('message', 'starting')}")
+
+
+@app.command("stop")
+def stop_vps(
+    vps_id: str = typer.Argument(..., help="VPS ID"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+):
+    """Stop a VPS."""
+    t = _require_token(token)
+    data = api_post(t, f"/api/v1/dashboard/vps/{vps_id}/stop")
+    if is_json_mode():
+        print_json(data)
+    else:
+        print(f"VPS {vps_id}: {data.get('message', 'stopping')}")
+
+
+@app.command("delete")
+def delete_vps(
+    vps_id: str = typer.Argument(..., help="VPS ID"),
+    token: Optional[str] = typer.Option(None, "--token", help="Override token"),
+    confirm: bool = typer.Option(False, "--confirm", help="Skip confirmation"),
+):
+    """Delete a VPS (permanent)."""
+    t = _require_token(token)
+
+    if not confirm:
+        print(f"This will permanently delete VPS {vps_id} and all its data.")
+        print("Use --confirm to proceed.")
+        raise typer.Exit(code=1)
+
+    data = api_delete(t, f"/api/v1/dashboard/vps/{vps_id}")
+    if is_json_mode():
+        print_json(data)
+    else:
+        print(f"VPS {vps_id}: deleted")

wayscloud_cli-0.1.0/wayscloud_cli/config.py

@@ -0,0 +1,77 @@
+"""
+Configuration and token resolution (C2, C3, C22, C24).
+
+Token priority:
+  1. --token flag
+  2. WAYSCLOUD_TOKEN env var
+  3. ~/.wayscloud/credentials file
+"""
+
+import json
+import os
+import stat
+from pathlib import Path
+from typing import Optional
+
+CONFIG_DIR = Path.home() / ".wayscloud"
+CREDENTIALS_FILE = CONFIG_DIR / "credentials"
+ENV_VAR = "WAYSCLOUD_TOKEN"
+
+# API base URL (C25 — public endpoint)
+API_BASE = os.environ.get("WAYSCLOUD_API_URL", "https://api.wayscloud.services")
+SHELL_WS = "wss://shell.wayscloud.services/ws"
+
+
+def resolve_token(explicit_token: Optional[str] = None) -> Optional[str]:
+    """Resolve token using priority order (C3):
+    1. Explicit --token flag
+    2. WAYSCLOUD_TOKEN env var
+    3. ~/.wayscloud/credentials file
+    """
+    # 1. Explicit flag
+    if explicit_token:
+        return explicit_token
+
+    # 2. Environment variable
+    env_token = os.environ.get(ENV_VAR)
+    if env_token:
+        return env_token
+
+    # 3. Credentials file
+    if CREDENTIALS_FILE.exists():
+        try:
+            data = json.loads(CREDENTIALS_FILE.read_text())
+            return data.get("token")
+        except (json.JSONDecodeError, OSError):
+            return None
+
+    return None
+
+
+def save_token(token: str) -> None:
+    """Save token to credentials file (C2, C24)."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+    data = {
+        "version": 1,
+        "token": token,
+        "created_at": _now_iso(),
+    }
+
+    CREDENTIALS_FILE.write_text(json.dumps(data, indent=2))
+
+    # chmod 600 (C24)
+    CREDENTIALS_FILE.chmod(stat.S_IRUSR | stat.S_IWUSR)
+
+
+def delete_token() -> bool:
+    """Delete saved credentials. Returns True if file existed."""
+    if CREDENTIALS_FILE.exists():
+        CREDENTIALS_FILE.unlink()
+        return True
+    return False
+
+
+def _now_iso() -> str:
+    from datetime import datetime, timezone
+    return datetime.now(timezone.utc).isoformat()

wayscloud_cli-0.1.0/wayscloud_cli/output.py

@@ -0,0 +1,104 @@
+"""
+Output formatting (C11, C12, C29).
+
+--json is alias for --format json (C11).
+list → array, info → object, error → {error, code, message} (C12).
+"""
+
+import json
+import sys
+from typing import Any, List, Optional
+
+# Global state set by CLI flags
+_json_mode = False
+_no_color = False
+
+
+def set_json_mode(enabled: bool) -> None:
+    global _json_mode
+    _json_mode = enabled
+
+
+def set_no_color(enabled: bool) -> None:
+    global _no_color
+    _no_color = enabled
+
+
+def is_json_mode() -> bool:
+    return _json_mode
+
+
+def print_json(data: Any) -> None:
+    """Print data as JSON to stdout (C12)."""
+    print(json.dumps(data, indent=2, default=str))
+
+
+def print_table(rows: List[dict], columns: List[tuple]) -> None:
+    """Print data as formatted table.
+
+    Args:
+        rows: List of dicts
+        columns: List of (key, header, width) tuples
+    """
+    if _json_mode:
+        print_json(rows)
+        return
+
+    if not rows:
+        print("No results.")
+        return
+
+    try:
+        from rich.console import Console
+        from rich.table import Table
+
+        console = Console(no_color=_no_color)
+        table = Table(show_header=True, header_style="bold" if not _no_color else None)
+
+        for key, header, _ in columns:
+            table.add_column(header)
+
+        for row in rows:
+            table.add_row(*[str(row.get(key, "")) for key, _, _ in columns])
+
+        console.print(table)
+
+    except ImportError:
+        # Fallback without rich
+        header = "  ".join(h.ljust(w) for _, h, w in columns)
+        print(header)
+        print("-" * len(header))
+        for row in rows:
+            line = "  ".join(str(row.get(k, "")).ljust(w) for k, _, w in columns)
+            print(line)
+
+
+def print_object(data: dict, fields: Optional[List[tuple]] = None) -> None:
+    """Print single object as key-value pairs.
+
+    Args:
+        data: Dict to display
+        fields: Optional list of (key, label) tuples to control display order
+    """
+    if _json_mode:
+        print_json(data)
+        return
+
+    if fields:
+        for key, label in fields:
+            val = data.get(key, "")
+            print(f"  {label}: {val}")
+    else:
+        for key, val in data.items():
+            print(f"  {key}: {val}")
+
+
+def print_error(code: str, message: str, exit_code: int = 1) -> None:
+    """Print error in consistent format (C29) and exit."""
+    if _json_mode:
+        err = {"error": code, "code": exit_code, "message": message}
+        print(json.dumps(err), file=sys.stderr)
+    else:
+        print(f"Error: {message}", file=sys.stderr)
+
+    sys.exit(exit_code)

wayscloud_cli-0.1.0/wayscloud_cli.egg-info/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: wayscloud-cli
+Version: 0.1.0
+Summary: WAYSCloud CLI — command-line interface for WAYSCloud platform
+License: Proprietary
+Project-URL: Homepage, https://wayscloud.net
+Project-URL: Documentation, https://docs.wayscloud.net/cli
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.25
+Requires-Dist: typer>=0.9
+Requires-Dist: rich>=13.0
+Requires-Dist: websockets>=12.0
+
+# WAYSCloud CLI
+
+Command-line interface for WAYSCloud platform services.
+
+## Install
+
+```bash
+pip install wayscloud-cli
+```
+
+## Usage
+
+```bash
+cloud login --token <pat-from-portal>
+cloud whoami
+cloud vps list
+cloud vps plans
+cloud shell connect
+```
+
+## Documentation
+
+See [docs/en/23-cli.md](https://docs.wayscloud.net/cli) for full documentation.

wayscloud_cli-0.1.0/wayscloud_cli.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+setup.cfg
+wayscloud_cli/__init__.py
+wayscloud_cli/__main__.py
+wayscloud_cli/client.py
+wayscloud_cli/config.py
+wayscloud_cli/output.py
+wayscloud_cli.egg-info/PKG-INFO
+wayscloud_cli.egg-info/SOURCES.txt
+wayscloud_cli.egg-info/dependency_links.txt
+wayscloud_cli.egg-info/entry_points.txt
+wayscloud_cli.egg-info/requires.txt
+wayscloud_cli.egg-info/top_level.txt
+wayscloud_cli/commands/__init__.py
+wayscloud_cli/commands/login.py
+wayscloud_cli/commands/shell.py
+wayscloud_cli/commands/vps.py

wayscloud_cli-0.1.0/wayscloud_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

wayscloud_cli-0.1.0/wayscloud_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cloud = wayscloud_cli.__main__:main

wayscloud_cli-0.1.0/wayscloud_cli.egg-info/requires.txt

@@ -0,0 +1,4 @@
+httpx>=0.25
+typer>=0.9
+rich>=13.0
+websockets>=12.0

wayscloud_cli-0.1.0/wayscloud_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+wayscloud_cli