bonito-cli 0.7.4__tar.gz → 0.8.0__tar.gz

{bonito_cli-0.7.4 → bonito_cli-0.8.0}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to the Bonito CLI will be documented in this file.
 
+## [0.8.0] - 2026-05-27
+
+### Added
+- **Personal access tokens**: `bonito auth token create`, `bonito auth token list`, `bonito auth token revoke` — manage PATs (bp-...) for programmatic API access
+- **Token login**: `bonito auth token login --token bp-...` — authenticate using a PAT instead of email/password
+
 ## [0.6.0] - 2026-05-07
 
 ### Added

{bonito_cli-0.7.4 → bonito_cli-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bonito-cli
-Version: 0.7.4
+Version: 0.8.0
 Summary: Bonito CLI — Unified multi-cloud AI management from your terminal
 Author-email: Bonito <hello@getbonito.com>
 License: MIT

{bonito_cli-0.7.4 → bonito_cli-0.8.0}/bonito_cli/__init__.py

@@ -1,3 +1,3 @@
 """Bonito CLI — Unified multi-cloud AI management from your terminal."""
 
-__version__ = "0.7.4"
+__version__ = "0.8.0"

{bonito_cli-0.7.4 → bonito_cli-0.8.0}/bonito_cli/commands/agents.py

@@ -554,5 +554,178 @@ def list_triggers(
     console.print(table)
 
 
+# ─── Scaling / HPA Commands ───
+
+scaling_app = typer.Typer(help="Agent autoscaling (HPA) management")
+app.add_typer(scaling_app, name="scaling")
+
+
+@scaling_app.command("status")
+def scaling_status(
+    agent_id: str = typer.Argument(..., help="Agent ID"),
+    json_output: bool = typer.Option(False, "--json", help="Output in JSON format"),
+):
+    """Show current autoscaling status for an agent."""
+    ensure_authenticated()
+    try:
+        data = api.get(f"/agents/{agent_id}/scaling")
+    except APIError as e:
+        print_error(f"Failed to get scaling status: {e}")
+        raise typer.Exit(1)
+
+    if json_output:
+        console.print_json(json.dumps(data))
+        return
+
+    table = Table(title="Agent Scaling Status", show_lines=True)
+    table.add_column("Property", style="cyan")
+    table.add_column("Value", style="white")
+
+    table.add_row("Autoscale Enabled", "✅" if data["autoscale_enabled"] else "❌")
+    table.add_row("Base RPM", str(data["base_rpm"]))
+    table.add_row("Effective RPM", str(data["effective_rpm"]))
+    table.add_row("Scaling Active", "🔥 Yes" if data["scaling_active"] else "No")
+    table.add_row("Current Usage", f"{data['current_rpm_usage']} RPM")
+    table.add_row("Utilization", f"{data['utilization']:.0%}")
+    table.add_row("Replica Count", str(data["replica_count"]))
+    if data.get("last_scaled_at"):
+        table.add_row("Last Scaled", data["last_scaled_at"])
+
+    cfg = data.get("config", {})
+    table.add_row("Capacity Threshold", f"{cfg.get('capacity_threshold', 0.6):.0%}")
+    table.add_row("Scale-Down Threshold", f"{cfg.get('scale_down_threshold', 0.3):.0%}")
+    table.add_row("Max Replicas", str(cfg.get("max_replicas", 5)))
+    table.add_row("Mode", cfg.get("mode", "virtual"))
+
+    console.print(table)
+
+
+@scaling_app.command("configure")
+def scaling_configure(
+    agent_id: str = typer.Argument(..., help="Agent ID"),
+    threshold: float = typer.Option(0.6, "--threshold", "-t", help="Capacity threshold (0.1-0.95)"),
+    scale_down: float = typer.Option(0.3, "--scale-down", help="Scale-down threshold"),
+    max_replicas: int = typer.Option(5, "--max-replicas", "-m", help="Max replicas (1-10)"),
+    cooldown: int = typer.Option(300, "--cooldown", help="Scale-down cooldown in seconds"),
+    mode: str = typer.Option("virtual", "--mode", help="Scaling mode: virtual or replica"),
+    enable: bool = typer.Option(True, "--enable/--disable", help="Enable or disable autoscaling"),
+):
+    """Configure autoscaling for an agent. Enterprise+ only."""
+    ensure_authenticated()
+    try:
+        data = api.post(f"/agents/{agent_id}/scaling/configure", {
+            "enabled": enable,
+            "capacity_threshold": threshold,
+            "scale_down_threshold": scale_down,
+            "max_replicas": max_replicas,
+            "scale_down_cooldown_seconds": cooldown,
+            "mode": mode,
+        })
+        print_success(f"Autoscaling {'enabled' if enable else 'disabled'} for agent {agent_id}")
+        if enable:
+            cfg = data.get("autoscale_config", {})
+            print_info(f"  Threshold: {cfg.get('capacity_threshold', 0.6):.0%} | Max replicas: {cfg.get('max_replicas', 5)} | Mode: {cfg.get('mode', 'virtual')}")
+    except APIError as e:
+        print_error(f"Failed to configure scaling: {e}")
+        raise typer.Exit(1)
+
+
+@scaling_app.command("events")
+def scaling_events(
+    agent_id: str = typer.Argument(..., help="Agent ID"),
+    limit: int = typer.Option(20, "--limit", "-n", help="Number of events to show"),
+    json_output: bool = typer.Option(False, "--json", help="Output in JSON format"),
+):
+    """List recent scaling events for an agent."""
+    ensure_authenticated()
+    try:
+        data = api.get(f"/agents/{agent_id}/scaling/events", params={"limit": limit})
+    except APIError as e:
+        print_error(f"Failed to get scaling events: {e}")
+        raise typer.Exit(1)
+
+    if json_output:
+        console.print_json(json.dumps(data))
+        return
+
+    events = data.get("events", [])
+    if not events:
+        print_info("No scaling events found.")
+        return
+
+    table = Table(title=f"Scaling Events ({data.get('total', 0)} total)")
+    table.add_column("Time", style="dim")
+    table.add_column("Type", style="cyan")
+    table.add_column("Previous RPM", justify="right")
+    table.add_column("New RPM", justify="right")
+    table.add_column("Utilization", justify="right")
+
+    for e in events:
+        event_type = e["event_type"]
+        style = "green" if "up" in event_type else "yellow"
+        table.add_row(
+            format_timestamp(e.get("created_at")),
+            f"[{style}]{event_type}[/{style}]",
+            str(e["previous_capacity"]),
+            str(e["new_capacity"]),
+            f"{e['trigger_utilization']:.0%}",
+        )
+
+    console.print(table)
+
+
+@scaling_app.command("queue")
+def scaling_queue(
+    agent_id: str = typer.Argument(..., help="Agent ID"),
+    json_output: bool = typer.Option(False, "--json", help="Output in JSON format"),
+):
+    """Show current queue depth and status for an agent."""
+    ensure_authenticated()
+    try:
+        data = api.get(f"/agents/{agent_id}/queue")
+    except APIError as e:
+        print_error(f"Failed to get queue status: {e}")
+        raise typer.Exit(1)
+
+    if json_output:
+        console.print_json(json.dumps(data))
+        return
+
+    table = Table(title="Agent Queue Status", show_lines=True)
+    table.add_column("Property", style="cyan")
+    table.add_column("Value", style="white")
+
+    table.add_row("Queue Depth", str(data.get("depth", 0)))
+    table.add_row("Status", data.get("status", "unknown"))
+    if data.get("oldest_item_age_seconds") is not None:
+        age = data["oldest_item_age_seconds"]
+        table.add_row("Oldest Item Age", f"{age}s")
+    if data.get("estimated_wait_seconds") is not None:
+        table.add_row("Estimated Wait", f"{data['estimated_wait_seconds']}s")
+    if data.get("processing") is not None:
+        table.add_row("Currently Processing", str(data["processing"]))
+
+    console.print(table)
+
+
+@scaling_app.command("manual")
+def scaling_manual(
+    agent_id: str = typer.Argument(..., help="Agent ID"),
+    direction: str = typer.Argument(..., help="Scale direction: up or down"),
+):
+    """Manually scale an agent up or down. Enterprise+ only."""
+    ensure_authenticated()
+    if direction not in ("up", "down"):
+        print_error("Direction must be 'up' or 'down'")
+        raise typer.Exit(1)
+
+    try:
+        data = api.post(f"/agents/{agent_id}/scaling/manual", {"direction": direction})
+        print_success(f"Scaled {direction}: {data['previous_rpm']} → {data['new_rpm']} RPM")
+    except APIError as e:
+        print_error(f"Failed to scale: {e}")
+        raise typer.Exit(1)
+
+
 if __name__ == "__main__":
     app()

{bonito_cli-0.7.4 → bonito_cli-0.8.0}/bonito_cli/commands/auth.py

@@ -12,6 +12,7 @@ from rich.prompt import Prompt
 from rich.table import Table
 
 from ..api import api, APIError
+from ..utils.auth import ensure_authenticated
 from ..config import (
     clear_credentials,
     is_authenticated,
@@ -275,3 +276,154 @@ def status():
         console.print(f"[red]✗ API error: {exc}[/red]")
         if exc.status_code == 401:
             console.print("  Token may be expired. Run: [cyan]bonito auth login[/cyan]")
+
+
+# ── token management ─────────────────────────────────────────
+
+token_app = typer.Typer(help="🔑 Personal access token management")
+app.add_typer(token_app, name="token")
+
+
+@token_app.command("create")
+def token_create(
+    name: str = typer.Option(..., "--name", "-n", help="Token name"),
+    scopes: Optional[str] = typer.Option(None, "--scopes", "-s", help="Comma-separated scopes (omit for full access)"),
+    expires_in: int = typer.Option(90, "--expires-in", help="Expiry in days (1-365)"),
+):
+    """Create a personal access token (bp-...)."""
+    ensure_authenticated()
+
+    body = {"name": name, "expires_in_days": expires_in}
+    if scopes:
+        body["scopes"] = [s.strip() for s in scopes.split(",")]
+
+    try:
+        with console.status("[cyan]Creating token…[/cyan]"):
+            result = api.post("/tokens", json=body)
+
+        raw_token = result.get("token", "")
+        console.print(
+            Panel(
+                f"[green]✓ Token created[/green]\n\n"
+                f"  [bold yellow]{raw_token}[/bold yellow]\n\n"
+                f"  [dim]Copy this now — it won't be shown again.[/dim]\n"
+                f"  Name: {result.get('name')}\n"
+                f"  Prefix: {result.get('token_prefix')}\n"
+                f"  Expires: {result.get('expires_at', '')[:10]}",
+                title="🔑 Personal Access Token",
+                border_style="green",
+            )
+        )
+    except APIError as exc:
+        console.print(f"[red]✗ {exc}[/red]")
+        raise typer.Exit(1)
+
+
+@token_app.command("list")
+def token_list():
+    """List your personal access tokens."""
+    ensure_authenticated()
+
+    try:
+        with console.status("[cyan]Fetching tokens…[/cyan]"):
+            tokens = api.get("/tokens")
+
+        if not tokens:
+            console.print("[yellow]No personal access tokens found.[/yellow]")
+            console.print("  Create one: [cyan]bonito auth token create --name my-token[/cyan]")
+            return
+
+        table = Table(title="Personal Access Tokens", border_style="dim")
+        table.add_column("Name", style="cyan")
+        table.add_column("Prefix")
+        table.add_column("Expires")
+        table.add_column("Last Used")
+        table.add_column("Status")
+        table.add_column("ID", style="dim")
+
+        for t in tokens:
+            status_str = "[red]Revoked[/red]" if t.get("revoked_at") else "[green]Active[/green]"
+            expires = t.get("expires_at", "")[:10]
+            last_used = t.get("last_used_at", "")
+            last_used = last_used[:10] if last_used else "Never"
+            table.add_row(
+                t.get("name", "—"),
+                t.get("token_prefix", "—"),
+                expires,
+                last_used,
+                status_str,
+                str(t.get("id", ""))[:8] + "…",
+            )
+
+        console.print(table)
+
+    except APIError as exc:
+        console.print(f"[red]✗ {exc}[/red]")
+        raise typer.Exit(1)
+
+
+@token_app.command("revoke")
+def token_revoke(
+    token_id: str = typer.Argument(..., help="Token ID to revoke"),
+):
+    """Revoke a personal access token."""
+    ensure_authenticated()
+
+    try:
+        with console.status("[cyan]Revoking token…[/cyan]"):
+            api.delete(f"/tokens/{token_id}")
+        console.print("[green]✓ Token revoked[/green]")
+    except APIError as exc:
+        console.print(f"[red]✗ {exc}[/red]")
+        raise typer.Exit(1)
+
+
+@token_app.command("login")
+def token_login(
+    token: str = typer.Option(..., "--token", "-t", help="Personal access token (bp-...)"),
+):
+    """Authenticate using a personal access token instead of email/password."""
+    if not token.startswith("bp-"):
+        console.print("[red]✗ Token must start with 'bp-' (personal access token)[/red]")
+        raise typer.Exit(1)
+
+    # Verify the token works
+    try:
+        with console.status("[cyan]Verifying token…[/cyan]"):
+            resp = httpx.get(
+                f"{api.base_url}/api/auth/me",
+                headers={"Authorization": f"Bearer {token}"},
+                timeout=15,
+            )
+
+        if resp.status_code != 200:
+            console.print("[red]✗ Token verification failed. Check the token and try again.[/red]")
+            raise typer.Exit(1)
+
+        me = resp.json()
+
+        # Store the PAT as the access_token in credentials
+        creds = {
+            "access_token": token,
+            "email": me.get("email", ""),
+            "user": me,
+        }
+        save_credentials(creds)
+
+        # Reset HTTP client
+        if api._client and not api._client.is_closed:
+            api._client.close()
+        api._client = None
+
+        console.print(
+            Panel(
+                f"[green]✓ Authenticated via PAT as [bold]{me.get('email', '')}[/bold][/green]\n"
+                f"  Organization: {me.get('org', {}).get('name', '—')}",
+                title="🔑 Token Login",
+                border_style="green",
+            )
+        )
+
+    except httpx.RequestError as exc:
+        console.print(f"[red]✗ Connection failed: {exc}[/red]")
+        raise typer.Exit(1)

{bonito_cli-0.7.4 → bonito_cli-0.8.0}/bonito_cli/commands/deploy.py

@@ -505,6 +505,28 @@ def _deploy_agents(
                 elif verbose:
                     console.print(f"    [dim yellow]! KB '{kb_name}' not found - skipping[/dim yellow]")
 
+            # Rate limit
+            if cfg.get("rate_limit_rpm"):
+                payload["rate_limit_rpm"] = cfg["rate_limit_rpm"]
+
+            # HPA / Autoscaling
+            scaling = cfg.get("scaling", {})
+            if scaling:
+                payload["autoscale_enabled"] = scaling.get("enabled", False)
+                autoscale_config = {}
+                if "capacity_threshold" in scaling:
+                    autoscale_config["capacity_threshold"] = scaling["capacity_threshold"]
+                if "scale_down_threshold" in scaling:
+                    autoscale_config["scale_down_threshold"] = scaling["scale_down_threshold"]
+                if "max_replicas" in scaling:
+                    autoscale_config["max_replicas"] = scaling["max_replicas"]
+                if "scale_down_cooldown_seconds" in scaling:
+                    autoscale_config["scale_down_cooldown_seconds"] = scaling["scale_down_cooldown_seconds"]
+                if "mode" in scaling:
+                    autoscale_config["mode"] = scaling["mode"]
+                if autoscale_config:
+                    payload["autoscale_config"] = autoscale_config
+
             # Note: agent secrets are managed via /api/secrets, not in the agent payload
 
             # Check if agent already exists — update instead of creating a duplicate

{bonito_cli-0.7.4 → bonito_cli-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bonito-cli"
-version = "0.7.4"
+version = "0.8.0"
 description = "Bonito CLI — Unified multi-cloud AI management from your terminal"
 readme = "README.md"
 license = {text = "MIT"}