ibee-cli 0.1.0__tar.gz → 0.2.0__tar.gz

{ibee_cli-0.1.0/src/ibee_cli.egg-info → ibee_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ibee-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: Official command-line interface for the IBEE Solutions cloud platform
 Author-email: IBEE Solutions <support@ibee.ai>
 License: MIT
@@ -14,7 +14,7 @@ Classifier: Environment :: Console
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: ibee>=0.1.2
+Requires-Dist: ibee>=0.1.3
 Requires-Dist: typer>=0.12
 Requires-Dist: rich>=13.0
 Provides-Extra: dev
@@ -53,22 +53,52 @@ ibee buckets list
 ibee buckets create my-bucket
 ibee buckets delete my-bucket --yes
 
-# Secret Store
-ibee secrets stores
+# Secret Store — stores
+ibee secrets stores list
+ibee secrets stores create production-secrets --description "prod"
+ibee secrets stores get STORE_ID
+ibee secrets stores update STORE_ID --name renamed
+ibee secrets stores archive STORE_ID --yes
+
+# Secret Store — secrets
 ibee secrets list --store-id STORE_ID
-ibee secrets value SECRET_ID
+ibee secrets create --store-id STORE_ID --name db-url --value '{"url":"postgres://..."}'
+ibee secrets get SECRET_ID           # metadata
+ibee secrets value SECRET_ID         # current value
+ibee secrets set-value SECRET_ID --value '{"url":"postgres://new"}'
+ibee secrets delete SECRET_ID --yes
+
+# Compute catalog (discover placement / plans / images for `create`)
+ibee compute sites
+ibee compute plans --vm-type cloud
+ibee compute images --vm-type gpu
 
 # Cloud VMs
 ibee vms list
 ibee vms get VM_ID
+ibee vms create web-01 --plan-id PLAN_ID --template-id IMAGE_ID --ssh-key-id KEY_ID --wait
 ibee vms start VM_ID
 ibee vms stop VM_ID
 ibee vms reboot VM_ID
+ibee vms metrics VM_ID
+ibee vms delete VM_ID --yes --wait
 
-# GPU VMs
+# GPU VMs (same verbs as Cloud VMs)
 ibee gpus list
+ibee gpus create train-01 --gpu-model A100 --gpu-count 1 --plan-id PLAN_ID --wait
+ibee gpus start VM_ID
+ibee gpus stop VM_ID
+ibee gpus reboot VM_ID
+ibee gpus metrics VM_ID
+ibee gpus delete VM_ID --yes
+
+# Async operations — poll a create/delete/power action to completion
+ibee ops get OPERATION_ID --wait
 ```
 
+Create/delete/power actions are asynchronous; add `--wait` to block until the
+operation finishes, or poll it later with `ibee ops get`.
+
 Every command accepts `--json` for raw output:
 
 ```bash

ibee_cli-0.2.0/README.md

@@ -0,0 +1,95 @@
+# IBEE Solutions CLI
+
+Official command-line interface for the IBEE Solutions cloud platform. Built on the [`ibee` Python SDK](https://github.com/devs-ibee/ibee-python).
+
+## Installation
+
+```bash
+pip install ibee-cli
+```
+
+Requires Python 3.10+.
+
+## Authentication
+
+Create an API token in the portal under **Settings > API Tokens**, then:
+
+```bash
+export IBEE_TOKEN="ibee_live_xxxxxxxxxxxx"
+export IBEE_WORKSPACE_ID="710995"
+```
+
+Both can also be passed per command with `--token` and `--workspace`.
+
+## Usage
+
+```bash
+# Object storage
+ibee buckets list
+ibee buckets create my-bucket
+ibee buckets delete my-bucket --yes
+
+# Secret Store — stores
+ibee secrets stores list
+ibee secrets stores create production-secrets --description "prod"
+ibee secrets stores get STORE_ID
+ibee secrets stores update STORE_ID --name renamed
+ibee secrets stores archive STORE_ID --yes
+
+# Secret Store — secrets
+ibee secrets list --store-id STORE_ID
+ibee secrets create --store-id STORE_ID --name db-url --value '{"url":"postgres://..."}'
+ibee secrets get SECRET_ID           # metadata
+ibee secrets value SECRET_ID         # current value
+ibee secrets set-value SECRET_ID --value '{"url":"postgres://new"}'
+ibee secrets delete SECRET_ID --yes
+
+# Compute catalog (discover placement / plans / images for `create`)
+ibee compute sites
+ibee compute plans --vm-type cloud
+ibee compute images --vm-type gpu
+
+# Cloud VMs
+ibee vms list
+ibee vms get VM_ID
+ibee vms create web-01 --plan-id PLAN_ID --template-id IMAGE_ID --ssh-key-id KEY_ID --wait
+ibee vms start VM_ID
+ibee vms stop VM_ID
+ibee vms reboot VM_ID
+ibee vms metrics VM_ID
+ibee vms delete VM_ID --yes --wait
+
+# GPU VMs (same verbs as Cloud VMs)
+ibee gpus list
+ibee gpus create train-01 --gpu-model A100 --gpu-count 1 --plan-id PLAN_ID --wait
+ibee gpus start VM_ID
+ibee gpus stop VM_ID
+ibee gpus reboot VM_ID
+ibee gpus metrics VM_ID
+ibee gpus delete VM_ID --yes
+
+# Async operations — poll a create/delete/power action to completion
+ibee ops get OPERATION_ID --wait
+```
+
+Create/delete/power actions are asynchronous; add `--wait` to block until the
+operation finishes, or poll it later with `ibee ops get`.
+
+Every command accepts `--json` for raw output:
+
+```bash
+ibee --json buckets list
+```
+
+## Environments
+
+The CLI targets production by default. Use `--dev` (or `IBEE_ENV=dev`) for the development environment, or `--base-url` for a custom endpoint:
+
+```bash
+ibee --dev buckets list
+```
+
+## Related
+
+- [Python SDK](https://github.com/devs-ibee/ibee-python) — `pip install ibee`
+- [API documentation](https://ibee.ai/docs/api-reference)

{ibee_cli-0.1.0 → ibee_cli-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ibee-cli"
-version = "0.1.0"
+version = "0.2.0"
 description = "Official command-line interface for the IBEE Solutions cloud platform"
 readme = "README.md"
 license = {text = "MIT"}
@@ -19,7 +19,7 @@ classifiers = [
     "Environment :: Console",
 ]
 dependencies = [
-    "ibee>=0.1.2",
+    "ibee>=0.1.3",
     "typer>=0.12",
     "rich>=13.0",
 ]

ibee_cli-0.2.0/src/ibee_cli/commands/compute.py

@@ -0,0 +1,95 @@
+"""Compute catalog (discovery) commands: sites, plans, images.
+
+These back the choices needed to create a VM (`--plan-id`, `--template-id`,
+placement). They call the SDK's ``compute_catalog`` resource when the installed
+``ibee`` exposes it (>= 0.2.0); on older SDKs they fall back to a direct GET
+against the same gateway, so the commands work regardless of SDK version.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+import typer
+from ibee.environment import IbeeEnvironment
+
+from ..context import get_client, get_settings, require_token, require_workspace
+from ..render import handle_api_errors, print_json
+
+app = typer.Typer(help="Compute catalog: sites, plans, images", no_args_is_help=True)
+
+
+def _base_url(settings) -> str:
+    if settings.base_url:
+        return settings.base_url.rstrip("/")
+    env = IbeeEnvironment.DEVELOPMENT if settings.dev else IbeeEnvironment.DEFAULT
+    return env.value.rstrip("/")
+
+
+def _fetch(ctx: typer.Context, sdk_method: str, path: str, filters: dict):
+    """Return catalog data via the SDK method if available, else a direct GET."""
+    settings = get_settings(ctx)
+    workspace = require_workspace(settings)
+    client = get_client(settings)
+    params = {k: v for k, v in filters.items() if v is not None}
+
+    catalog = getattr(client, "compute_catalog", None)
+    if catalog is not None:
+        return getattr(catalog, sdk_method)(workspace_id=workspace, **params)
+
+    # Fallback for SDKs without compute_catalog (< 0.2.0): same gateway + auth.
+    token = require_token(settings)
+    resp = httpx.get(
+        f"{_base_url(settings)}/{path}",
+        params={"workspace_id": workspace, **params},
+        headers={"Authorization": f"Bearer {token}", "accept": "application/json"},
+        timeout=30,
+    )
+    if resp.status_code >= 400:
+        typer.secho(f"API error {resp.status_code}: {resp.text[:300]}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1)
+    return resp.json()
+
+
+@app.command("sites")
+@handle_api_errors
+def list_sites(
+    ctx: typer.Context,
+    region_id: Optional[str] = typer.Option(None, "--region-id", help="Filter by region"),
+    country_id: Optional[str] = typer.Option(None, "--country-id", help="Filter by country"),
+) -> None:
+    """List sites where cloud and GPU VMs can be placed."""
+    result = _fetch(ctx, "list_compute_sites", "compute/sites",
+                    {"region_id": region_id, "country_id": country_id})
+    print_json(result)
+
+
+@app.command("plans")
+@handle_api_errors
+def list_plans(
+    ctx: typer.Context,
+    vm_type: Optional[str] = typer.Option(None, "--vm-type", help="cloud or gpu"),
+    site_id: Optional[str] = typer.Option(None, "--site-id", help="Filter by site"),
+    currency: Optional[str] = typer.Option(None, "--currency", help="Price currency (e.g. INR, USD)"),
+    billing_interval: Optional[str] = typer.Option(None, "--billing-interval", help="e.g. hourly, monthly"),
+) -> None:
+    """List billable plans for cloud or GPU VMs (use the IDs with `vms/gpus create --plan-id`)."""
+    result = _fetch(ctx, "list_compute_plans", "compute/plans", {
+        "vm_type": vm_type, "site_id": site_id,
+        "currency": currency, "billing_interval": billing_interval,
+    })
+    print_json(result)
+
+
+@app.command("images")
+@handle_api_errors
+def list_images(
+    ctx: typer.Context,
+    vm_type: Optional[str] = typer.Option(None, "--vm-type", help="cloud or gpu"),
+    currency: Optional[str] = typer.Option(None, "--currency", help="Price currency (e.g. INR, USD)"),
+) -> None:
+    """List OS templates/images (use the IDs with `vms/gpus create --template-id`)."""
+    result = _fetch(ctx, "list_compute_images", "compute/images",
+                    {"vm_type": vm_type, "currency": currency})
+    print_json(result)

ibee_cli-0.2.0/src/ibee_cli/commands/gpus.py

@@ -0,0 +1,170 @@
+"""GPU VM commands."""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+import typer
+
+from ..context import get_client, get_settings, require_workspace
+from ..helpers import finish_operation, new_idempotency_key
+from ..render import handle_api_errors, print_json, print_table
+
+app = typer.Typer(help="GPU VMs", no_args_is_help=True)
+
+
+@app.command("list")
+@handle_api_errors
+def list_gpu_vms(ctx: typer.Context) -> None:
+    """List GPU VMs in the workspace."""
+    settings = get_settings(ctx)
+    client = get_client(settings)
+    result = client.gpu_vms.list_gpu_vms(workspace_id=require_workspace(settings))
+    if settings.as_json:
+        print_json(result)
+        return
+    vms = getattr(result, "items", None) or getattr(result, "vms", None) or []
+    print_table(
+        "GPU VMs",
+        ["ID", "Name", "Status", "GPU", "GPUs", "CPU", "RAM (MB)", "Public IP"],
+        [
+            (
+                v.id, v.name, getattr(v.status, "value", v.status),
+                getattr(v, "gpu_model", None), getattr(v, "gpu_count", None),
+                v.cpu, v.ram_mb, v.public_ip,
+            )
+            for v in vms
+        ],
+    )
+
+
+@app.command("get")
+@handle_api_errors
+def get_gpu_vm(ctx: typer.Context, vm_id: str = typer.Argument(..., help="GPU VM ID")) -> None:
+    """Show one GPU VM."""
+    settings = get_settings(ctx)
+    client = get_client(settings)
+    result = client.gpu_vms.get_gpu_vm(workspace_id=require_workspace(settings), vm_id=vm_id)
+    print_json(result)
+
+
+@app.command("create")
+@handle_api_errors
+def create_gpu_vm(
+    ctx: typer.Context,
+    name: str = typer.Argument(..., help="Display name for the GPU VM"),
+    gpu_model: str = typer.Option(..., "--gpu-model", help="GPU model (A100, H100, L40S, RTX4090)"),
+    gpu_count: int = typer.Option(1, "--gpu-count", help="Number of GPUs to attach"),
+    os_distro: str = typer.Option("ubuntu", "--os-distro", help="OS distribution"),
+    os_type: str = typer.Option("linux", "--os-type", help="OS family (linux, windows)"),
+    cpu: int = typer.Option(8, "--cpu", help="vCPUs (fallback when no plan)"),
+    ram_mb: int = typer.Option(32768, "--ram-mb", help="RAM in MB (fallback when no plan)"),
+    plan_id: Optional[str] = typer.Option(None, "--plan-id", help="GPU plan ID. See `ibee compute plans`."),
+    template_id: Optional[str] = typer.Option(None, "--template-id", help="OS template/image ID. See `ibee compute images`."),
+    disk_gb: Optional[int] = typer.Option(None, "--disk-gb", help="Root disk size in GB"),
+    ssh_key_id: Optional[List[str]] = typer.Option(None, "--ssh-key-id", help="SSH key ID to inject (repeatable)"),
+    tag: Optional[List[str]] = typer.Option(None, "--tag", help="Tag (repeatable)"),
+    wait: bool = typer.Option(False, "--wait", help="Poll until the VM is provisioned"),
+) -> None:
+    """Create a GPU VM (async — returns an operation)."""
+    settings = get_settings(ctx)
+    workspace = require_workspace(settings)
+    client = get_client(settings)
+    result = client.gpu_vms.create_gpu_vm(
+        workspace_id=workspace,
+        idempotency_key=new_idempotency_key("gpu-create", name),
+        name=name,
+        os_distro=os_distro,
+        os_type=os_type,
+        cpu=cpu,
+        ram_mb=ram_mb,
+        gpu_count=gpu_count,
+        gpu_model=gpu_model,
+        plan_id=plan_id,
+        template_id=template_id,
+        disk_gb=disk_gb,
+        ssh_key_ids=ssh_key_id or None,
+        tags=tag or None,
+    )
+    finish_operation(settings, client, workspace, result, "Create", name, wait)
+
+
+@app.command("delete")
+@handle_api_errors
+def delete_gpu_vm(
+    ctx: typer.Context,
+    vm_id: str = typer.Argument(..., help="GPU VM ID"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation"),
+    wait: bool = typer.Option(False, "--wait", help="Poll until the VM is deleted"),
+) -> None:
+    """Delete a GPU VM (async — returns an operation)."""
+    settings = get_settings(ctx)
+    if not yes:
+        typer.confirm(f"Delete GPU VM '{vm_id}'?", abort=True)
+    workspace = require_workspace(settings)
+    client = get_client(settings)
+    result = client.gpu_vms.delete_gpu_vm(
+        vm_id=vm_id,
+        workspace_id=workspace,
+        idempotency_key=new_idempotency_key("gpu-delete", vm_id),
+    )
+    finish_operation(settings, client, workspace, result, "Delete", vm_id, wait)
+
+
+@app.command("metrics")
+@handle_api_errors
+def gpu_metrics(ctx: typer.Context, vm_id: str = typer.Argument(..., help="GPU VM ID")) -> None:
+    """Show current resource-usage metrics for a GPU VM."""
+    settings = get_settings(ctx)
+    client = get_client(settings)
+    # SDK method was renamed get_gpu_vm_metrics -> get_gpu_vm_metrics_overview
+    # (ibee 0.2.0); accept either so the CLI works across SDK versions.
+    method = getattr(client.gpu_vms, "get_gpu_vm_metrics_overview", None) or client.gpu_vms.get_gpu_vm_metrics
+    result = method(workspace_id=require_workspace(settings), vm_id=vm_id)
+    print_json(result)
+
+
+def _power_action(ctx: typer.Context, vm_id: str, action: str, wait: bool) -> None:
+    settings = get_settings(ctx)
+    workspace = require_workspace(settings)
+    client = get_client(settings)
+    method = getattr(client.gpu_vms, f"{action}_gpu_vm")
+    result = method(
+        workspace_id=workspace,
+        vm_id=vm_id,
+        idempotency_key=new_idempotency_key(action, vm_id),
+    )
+    finish_operation(settings, client, workspace, result, action.capitalize(), vm_id, wait)
+
+
+@app.command("start")
+@handle_api_errors
+def start_gpu_vm(
+    ctx: typer.Context,
+    vm_id: str = typer.Argument(...),
+    wait: bool = typer.Option(False, "--wait", help="Poll until started"),
+) -> None:
+    """Start a GPU VM."""
+    _power_action(ctx, vm_id, "start", wait)
+
+
+@app.command("stop")
+@handle_api_errors
+def stop_gpu_vm(
+    ctx: typer.Context,
+    vm_id: str = typer.Argument(...),
+    wait: bool = typer.Option(False, "--wait", help="Poll until stopped"),
+) -> None:
+    """Stop a GPU VM."""
+    _power_action(ctx, vm_id, "stop", wait)
+
+
+@app.command("reboot")
+@handle_api_errors
+def reboot_gpu_vm(
+    ctx: typer.Context,
+    vm_id: str = typer.Argument(...),
+    wait: bool = typer.Option(False, "--wait", help="Poll until rebooted"),
+) -> None:
+    """Reboot a GPU VM."""
+    _power_action(ctx, vm_id, "reboot", wait)

ibee_cli-0.2.0/src/ibee_cli/commands/ops.py

@@ -0,0 +1,31 @@
+"""Compute operation (async task) commands."""
+
+from __future__ import annotations
+
+import typer
+
+from ..context import get_client, get_settings, require_workspace
+from ..helpers import wait_for_operation
+from ..render import handle_api_errors, print_json
+
+app = typer.Typer(help="Async compute operations (VM create/delete/power)", no_args_is_help=True)
+
+
+@app.command("get")
+@handle_api_errors
+def get_operation(
+    ctx: typer.Context,
+    operation_id: str = typer.Argument(..., help="Operation ID from a create/delete/power action"),
+    wait: bool = typer.Option(False, "--wait", help="Poll until the operation reaches a terminal state"),
+) -> None:
+    """Show the status of an async compute operation (cloud or GPU VM)."""
+    settings = get_settings(ctx)
+    workspace = require_workspace(settings)
+    client = get_client(settings)
+    if wait:
+        result = wait_for_operation(client, workspace, operation_id)
+    else:
+        result = client.cloud_vms.get_compute_operation(
+            operation_id=operation_id, workspace_id=workspace
+        )
+    print_json(result)