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

{bonito_cli-0.7.4 → bonito_cli-0.9.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.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bonito-cli
-Version: 0.7.4
+Version: 0.9.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.9.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.9.0}/bonito_cli/commands/admin.py

@@ -45,7 +45,7 @@ def verify_user(
 def set_tier(
     email: Optional[str] = typer.Option(None, "--email", "-e", help="User email (to look up org)"),
     org_id: Optional[str] = typer.Option(None, "--org", help="Organization ID"),
-    tier: str = typer.Option(..., "--tier", "-t", help="Tier: free, pro, enterprise"),
+    tier: str = typer.Option(..., "--tier", "-t", help="Tier: free, starter, pro, enterprise"),
     reason: str = typer.Option("Set via CLI", "--reason", help="Reason for tier change"),
     json_output: bool = typer.Option(False, "--json", help="JSON output"),
 ):
@@ -58,8 +58,8 @@ def set_tier(
     """
     ensure_authenticated()
 
-    if tier not in ("free", "pro", "enterprise"):
-        print_error("Tier must be: free, pro, or enterprise")
+    if tier not in ("free", "starter", "pro", "enterprise"):
+        print_error("Tier must be: free, starter, pro, or enterprise")
         raise typer.Exit(1)
 
     if not org_id and not email:

{bonito_cli-0.7.4 → bonito_cli-0.9.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.9.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.9.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.9.0}/bonito_cli/commands/plan.py

@@ -47,6 +47,7 @@ def show_plan(
         
         tier_display = {
             "free": "Free",
+            "starter": "Starter",
             "pro": "Pro",
             "enterprise": "Enterprise"
         }
@@ -135,9 +136,10 @@ def show_features(
         table = Table(show_header=True, header_style="bold")
         table.add_column("Feature")
         table.add_column("Free", style="dim" if current_tier != "free" else "bold green")
-        table.add_column("Pro", style="dim" if current_tier != "pro" else "bold green") 
+        table.add_column("Starter", style="dim" if current_tier != "starter" else "bold green")
+        table.add_column("Pro", style="dim" if current_tier != "pro" else "bold green")
         table.add_column("Enterprise", style="dim" if current_tier != "enterprise" else "bold green")
-        
+
         # Feature mapping for display
         feature_names = {
             "models": "AI Models",
@@ -157,17 +159,18 @@ def show_features(
             "custom_integrations": "Custom Integrations",
             "dedicated_support": "Dedicated Support"
         }
-        
+
         # Get features from one tier (they should all have the same keys)
         features = tiers.get("free", {}).get("features", {})
-        
+
         for feature_key, display_name in feature_names.items():
             if feature_key in features:
                 free_val = "✅" if tiers.get("free", {}).get("features", {}).get(feature_key, False) else "❌"
+                starter_val = "✅" if tiers.get("starter", {}).get("features", {}).get(feature_key, False) else "❌"
                 pro_val = "✅" if tiers.get("pro", {}).get("features", {}).get(feature_key, False) else "❌"
                 ent_val = "✅" if tiers.get("enterprise", {}).get("features", {}).get(feature_key, False) else "❌"
-                
-                table.add_row(display_name, free_val, pro_val, ent_val)
+
+                table.add_row(display_name, free_val, starter_val, pro_val, ent_val)
         
         console.print(table)
 
@@ -177,44 +180,48 @@ def show_features(
         limits_table = Table(show_header=True, header_style="bold")
         limits_table.add_column("Resource")
         limits_table.add_column("Free", style="dim" if current_tier != "free" else "bold green")
+        limits_table.add_column("Starter", style="dim" if current_tier != "starter" else "bold green")
         limits_table.add_column("Pro", style="dim" if current_tier != "pro" else "bold green")
         limits_table.add_column("Enterprise", style="dim" if current_tier != "enterprise" else "bold green")
-        
-        for tier_name in ["free", "pro", "enterprise"]:
-            tier_data = tiers.get(tier_name, {})
-            
+
         # Providers
         free_providers = tiers.get("free", {}).get("providers", 0)
-        pro_providers = tiers.get("pro", {}).get("providers", 0) 
+        starter_providers = tiers.get("starter", {}).get("providers", 0)
+        pro_providers = tiers.get("pro", {}).get("providers", 0)
         ent_providers = tiers.get("enterprise", {}).get("providers", 0)
-        
+
         limits_table.add_row(
             "Providers",
             str(free_providers) if free_providers != float('inf') else "Unlimited",
-            str(pro_providers) if pro_providers != float('inf') else "Unlimited", 
+            str(starter_providers) if starter_providers != float('inf') else "Unlimited",
+            str(pro_providers) if pro_providers != float('inf') else "Unlimited",
             str(ent_providers) if ent_providers != float('inf') else "Unlimited"
         )
-        
+
         # Gateway calls
         free_calls = tiers.get("free", {}).get("gateway_calls", 0)
+        starter_calls = tiers.get("starter", {}).get("gateway_calls", 0)
         pro_calls = tiers.get("pro", {}).get("gateway_calls", 0)
         ent_calls = tiers.get("enterprise", {}).get("gateway_calls", 0)
-        
+
         limits_table.add_row(
             "Gateway Calls/Month",
             f"{free_calls:,}" if free_calls != float('inf') else "Unlimited",
+            f"{starter_calls:,}" if starter_calls != float('inf') else "Unlimited",
             f"{pro_calls:,}" if pro_calls != float('inf') else "Unlimited",
             f"{ent_calls:,}" if ent_calls != float('inf') else "Unlimited"
         )
-        
+
         # Members
         free_members = tiers.get("free", {}).get("members", 0)
+        starter_members = tiers.get("starter", {}).get("members", 0)
         pro_members = tiers.get("pro", {}).get("members", 0)
         ent_members = tiers.get("enterprise", {}).get("members", 0)
-        
+
         limits_table.add_row(
-            "Team Members", 
+            "Team Members",
             str(free_members) if free_members != float('inf') else "Unlimited",
+            str(starter_members) if starter_members != float('inf') else "Unlimited",
             str(pro_members) if pro_members != float('inf') else "Unlimited",
             str(ent_members) if ent_members != float('inf') else "Unlimited"
         )

{bonito_cli-0.7.4 → bonito_cli-0.9.0}/bonito_cli/commands/projects.py

@@ -347,5 +347,108 @@ def project_graph(
     console.print(f"\n[dim]💡 Use --json to get full graph data for React Flow or other visualization tools.[/dim]")
 
 
+# ── project token management ─────────────────────────────────────
+# Mirrors auth.token_app shape, but for bj- project-scoped tokens.
+
+token_app = typer.Typer(help="🔑 Project-scoped access token management (bj-)")
+app.add_typer(token_app, name="token")
+
+
+@token_app.command("create")
+def project_token_create(
+    project_id: str = typer.Argument(..., help="Project ID to scope the token to"),
+    name: str = typer.Option(..., "--name", "-n", help="Token name"),
+    expires_in: int = typer.Option(90, "--expires-in", help="Expiry in days (1-365)"),
+):
+    """Create a project-scoped access token (bj-...)."""
+    ensure_authenticated()
+
+    body = {"name": name, "expires_in_days": expires_in}
+
+    try:
+        with console.status("[cyan]Creating project token…[/cyan]"):
+            result = api.post(f"/projects/{project_id}/tokens", json=body)
+
+        raw_token = result.get("token", "")
+        console.print(
+            Panel(
+                f"[green]✓ Project 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"  Project: {result.get('project_id')}\n"
+                f"  Prefix: {result.get('token_prefix')}\n"
+                f"  Expires: {result.get('expires_at', '')[:10]}",
+                title="🔑 Project Access Token",
+                border_style="green",
+            )
+        )
+    except APIError as exc:
+        console.print(f"[red]✗ {exc}[/red]")
+        raise typer.Exit(1)
+
+
+@token_app.command("list")
+def project_token_list(
+    project_id: str = typer.Argument(..., help="Project ID to list tokens for"),
+):
+    """List project-scoped access tokens for a project."""
+    ensure_authenticated()
+
+    try:
+        with console.status("[cyan]Fetching project tokens…[/cyan]"):
+            tokens = api.get(f"/projects/{project_id}/tokens")
+
+        if not tokens:
+            console.print(f"[yellow]No project tokens found for project {project_id}.[/yellow]")
+            console.print(f"  Create one: [cyan]bonito projects token create {project_id} --name my-token[/cyan]")
+            return
+
+        table = Table(title=f"Project Tokens — {project_id[:8]}…", 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 project_token_revoke(
+    project_id: str = typer.Argument(..., help="Project ID the token belongs to"),
+    token_id: str = typer.Argument(..., help="Token ID to revoke"),
+):
+    """Revoke a project-scoped access token."""
+    ensure_authenticated()
+
+    try:
+        with console.status("[cyan]Revoking project token…[/cyan]"):
+            api.delete(f"/projects/{project_id}/tokens/{token_id}")
+        console.print("[green]✓ Project token revoked[/green]")
+    except APIError as exc:
+        console.print(f"[red]✗ {exc}[/red]")
+        raise typer.Exit(1)
+
+
 if __name__ == "__main__":
     app()

{bonito_cli-0.7.4 → bonito_cli-0.9.0}/bonito_cli/utils/feature_gate.py

@@ -31,10 +31,11 @@ def require_feature(feature: str):
             
             tier_display = {
                 "free": "Free",
-                "pro": "Pro", 
+                "starter": "Starter",
+                "pro": "Pro",
                 "enterprise": "Enterprise"
             }
-            
+
             current_name = tier_display.get(current_tier, current_tier.title())
             required_name = tier_display.get(required_tier, required_tier.title())
             
@@ -75,14 +76,15 @@ def require_tier(min_tier: str):
         response = api.get("/api/subscriptions/current")
         current_tier = response.get("tier", "free")
         
-        tier_hierarchy = {"free": 0, "pro": 1, "enterprise": 2}
+        tier_hierarchy = {"free": 0, "starter": 1, "pro": 2, "enterprise": 3, "scale": 4}
         current_level = tier_hierarchy.get(current_tier, 0)
-        required_level = tier_hierarchy.get(min_tier, 2)
-        
+        required_level = tier_hierarchy.get(min_tier, 3)
+
         if current_level < required_level:
             tier_display = {
                 "free": "Free",
-                "pro": "Pro", 
+                "starter": "Starter",
+                "pro": "Pro",
                 "enterprise": "Enterprise"
             }
             

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

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