bonito-cli 0.5.2__tar.gz → 0.6.1__tar.gz

{bonito_cli-0.5.2 → bonito_cli-0.6.1}/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to the Bonito CLI will be documented in this file.
 
+## [0.6.0] - 2026-05-07
+
+### Added
+- **8 new command modules** for full API parity:
+  - `bonito rbac` — role-based access control (roles, permissions, assignments)
+  - `bonito compliance` — SOC-2, HIPAA, GDPR, ISO27001 policy checks
+  - `bonito approval` — human-in-the-loop approval queue management
+  - `bonito scheduler` — cron-based autonomous agent execution
+  - `bonito audit` — audit log viewing and export
+  - `bonito memory` — persistent agent memory management
+  - `bonito mcp` — MCP server registration and management per-agent
+  - `bonito routing` — routing policy builder (cost/latency/balanced/failover/ab_test)
+
+### Fixed
+- **`bonito deploy` now updates existing agents** instead of creating duplicates on re-deploy. Model, prompt, and config changes in `bonito.yaml` now propagate correctly.
+- P0 bugs: signup flow, secrets API calls, stale URLs
+
+### Changed
+- Deploy summary now shows `~` (yellow) for updated agents vs `v` (green) for newly created ones
+
+
 ## [0.5.1] - 2026-03-02
 
 ### Added

{bonito_cli-0.5.2 → bonito_cli-0.6.1}/PKG-INFO

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

{bonito_cli-0.5.2 → bonito_cli-0.6.1}/bonito_cli/__init__.py

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

{bonito_cli-0.5.2 → bonito_cli-0.6.1}/bonito_cli/app.py

@@ -26,6 +26,14 @@ from .commands.sso import app as sso_app
 from .commands.plan import app as plan_app
 from .commands.deploy import app as deploy_app
 from .commands.secrets import app as secrets_app
+from .commands.rbac import app as rbac_app
+from .commands.compliance import app as compliance_app
+from .commands.approval import app as approval_app
+from .commands.scheduler import app as scheduler_app
+from .commands.audit import app as audit_app
+from .commands.memory import app as memory_app
+from .commands.mcp import app as mcp_app
+from .commands.routing import app as routing_app
 
 console = Console()
 
@@ -88,6 +96,14 @@ app.add_typer(sso_app,         name="sso",         help="🔐 SAML Single Sign-O
 app.add_typer(plan_app,        name="plan",        help="💎 Subscription plans & usage")
 app.add_typer(deploy_app,      name="deploy",      help="📦 Deploy from bonito.yaml")
 app.add_typer(secrets_app,     name="secrets",     help="🔐 Org secrets management")
+app.add_typer(rbac_app,        name="rbac",        help="🛡️  Role-based access control")
+app.add_typer(compliance_app,  name="compliance",  help="📋 Compliance checks & reports")
+app.add_typer(approval_app,    name="approval",    help="✅ Agent approval workflows")
+app.add_typer(scheduler_app,   name="scheduler",   help="⏰ Agent scheduling")
+app.add_typer(audit_app,       name="audit",       help="📝 Audit logs")
+app.add_typer(memory_app,      name="memory",      help="🧠 Agent persistent memory")
+app.add_typer(mcp_app,         name="mcp",         help="🔌 MCP server management")
+app.add_typer(routing_app,     name="routing",     help="🔀 Routing rule management")
 
 
 # ── Callbacks ──────────────────────────────────────────────────

bonito_cli-0.6.1/bonito_cli/commands/approval.py

@@ -0,0 +1,207 @@
+"""Agent approval workflow commands."""
+
+from __future__ import annotations
+
+import json as _json
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.prompt import Prompt
+
+from ..api import api, APIError
+from ..utils.auth import ensure_authenticated
+from ..utils.display import (
+    get_output_format,
+    print_error,
+    print_info,
+    print_success,
+    print_table,
+    print_dict_as_table,
+    format_timestamp,
+)
+
+console = Console()
+app = typer.Typer(help="Agent approval queue and human-in-the-loop workflows")
+
+
+# -- list-pending ------------------------------------------------------
+
+
+@app.command("list-pending")
+def list_pending(
+    org_id: str = typer.Option(..., "--org", help="Organization ID"),
+    agent_id: Optional[str] = typer.Option(None, "--agent", help="Filter by agent ID"),
+    risk_level: Optional[str] = typer.Option(None, "--risk", help="Filter by risk level (low/medium/high/critical)"),
+    limit: int = typer.Option(50, "--limit", "-l", help="Max results"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """List pending approval actions."""
+    fmt = get_output_format(json_output)
+    ensure_authenticated()
+
+    params = {"limit": limit}
+    if agent_id:
+        params["agent_id"] = agent_id
+    if risk_level:
+        params["risk_level"] = risk_level
+
+    try:
+        with console.status("[cyan]Fetching pending approvals...[/cyan]"):
+            items = api.get(f"/organizations/{org_id}/approvals/queue", params=params)
+
+        if fmt == "json":
+            console.print_json(_json.dumps(items, default=str))
+        else:
+            if items:
+                data = [
+                    {
+                        "ID": str(i.get("id", ""))[:8] + "...",
+                        "Agent": i.get("agent_name", ""),
+                        "Action": i.get("action_type", ""),
+                        "Risk": i.get("risk_level", ""),
+                        "Requester": i.get("requester_name", "") or "",
+                        "Created": format_timestamp(i.get("created_at")),
+                    }
+                    for i in items
+                ]
+                print_table(data, title="Pending Approvals")
+                print_info(f"{len(items)} pending action(s)")
+            else:
+                print_info("No pending approvals.")
+    except APIError as exc:
+        print_error(f"Failed to list pending approvals: {exc}")
+
+
+# -- approve -----------------------------------------------------------
+
+
+@app.command("approve")
+def approve(
+    action_id: str = typer.Argument(..., help="Approval action ID"),
+    notes: Optional[str] = typer.Option(None, "--notes", "-n", help="Review notes"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """Approve a pending action."""
+    fmt = get_output_format(json_output)
+    ensure_authenticated()
+
+    body = {"action": "approve"}
+    if notes:
+        body["review_notes"] = notes
+
+    try:
+        with console.status("[cyan]Approving action...[/cyan]"):
+            result = api.post(f"/approvals/{action_id}/review", body)
+
+        if fmt == "json":
+            console.print_json(_json.dumps(result, default=str))
+        else:
+            print_success(f"Action {action_id} approved")
+    except APIError as exc:
+        print_error(f"Failed to approve action: {exc}")
+
+
+# -- reject ------------------------------------------------------------
+
+
+@app.command("reject")
+def reject(
+    action_id: str = typer.Argument(..., help="Approval action ID"),
+    notes: Optional[str] = typer.Option(None, "--notes", "-n", help="Rejection reason"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """Reject a pending action."""
+    fmt = get_output_format(json_output)
+    ensure_authenticated()
+
+    body = {"action": "reject"}
+    if notes:
+        body["review_notes"] = notes
+
+    try:
+        with console.status("[cyan]Rejecting action...[/cyan]"):
+            result = api.post(f"/approvals/{action_id}/review", body)
+
+        if fmt == "json":
+            console.print_json(_json.dumps(result, default=str))
+        else:
+            print_success(f"Action {action_id} rejected")
+    except APIError as exc:
+        print_error(f"Failed to reject action: {exc}")
+
+
+# -- get-config --------------------------------------------------------
+
+
+@app.command("get-config")
+def get_config(
+    agent_id: str = typer.Argument(..., help="Agent ID"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """List approval configs for an agent."""
+    fmt = get_output_format(json_output)
+    ensure_authenticated()
+
+    try:
+        with console.status("[cyan]Fetching approval configs...[/cyan]"):
+            configs = api.get(f"/agents/{agent_id}/approval-configs")
+
+        if fmt == "json":
+            console.print_json(_json.dumps(configs, default=str))
+        else:
+            if configs:
+                data = [
+                    {
+                        "ID": str(c.get("id", ""))[:8] + "...",
+                        "Action Type": c.get("action_type", ""),
+                        "Requires Approval": "Yes" if c.get("requires_approval") else "No",
+                        "Timeout (hrs)": str(c.get("timeout_hours", "")),
+                        "Required Approvers": str(c.get("required_approvers", 1)),
+                    }
+                    for c in configs
+                ]
+                print_table(data, title="Approval Configs")
+            else:
+                print_info("No approval configs found for this agent.")
+    except APIError as exc:
+        print_error(f"Failed to get approval configs: {exc}")
+
+
+# -- update-config -----------------------------------------------------
+
+
+@app.command("update-config")
+def update_config(
+    config_id: str = typer.Argument(..., help="Approval config ID"),
+    requires_approval: Optional[bool] = typer.Option(None, "--requires-approval", help="Whether approval is required"),
+    timeout_hours: Optional[int] = typer.Option(None, "--timeout-hours", help="Approval timeout in hours"),
+    required_approvers: Optional[int] = typer.Option(None, "--required-approvers", help="Number of required approvers"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """Update an approval configuration."""
+    fmt = get_output_format(json_output)
+    ensure_authenticated()
+
+    body = {}
+    if requires_approval is not None:
+        body["requires_approval"] = requires_approval
+    if timeout_hours is not None:
+        body["timeout_hours"] = timeout_hours
+    if required_approvers is not None:
+        body["required_approvers"] = required_approvers
+
+    if not body:
+        print_error("No updates specified")
+        return
+
+    try:
+        with console.status("[cyan]Updating approval config...[/cyan]"):
+            result = api.put(f"/approval-configs/{config_id}", body)
+
+        if fmt == "json":
+            console.print_json(_json.dumps(result, default=str))
+        else:
+            print_success("Approval config updated successfully")
+    except APIError as exc:
+        print_error(f"Failed to update approval config: {exc}")

bonito_cli-0.6.1/bonito_cli/commands/audit.py

@@ -0,0 +1,79 @@
+"""Audit log commands."""
+
+from __future__ import annotations
+
+import json as _json
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from ..api import api, APIError
+from ..utils.auth import ensure_authenticated
+from ..utils.display import (
+    get_output_format,
+    print_error,
+    print_info,
+    print_table,
+    format_timestamp,
+)
+
+console = Console()
+app = typer.Typer(help="Audit log viewer")
+
+
+@app.command("list")
+def list_logs(
+    action: Optional[str] = typer.Option(None, "--action", "-a", help="Filter by action (e.g. create, update, delete)"),
+    resource_type: Optional[str] = typer.Option(None, "--resource", "-r", help="Filter by resource type"),
+    user_name: Optional[str] = typer.Option(None, "--user", "-u", help="Filter by user name"),
+    date_from: Optional[str] = typer.Option(None, "--from", help="Filter from date (ISO format: 2026-01-01)"),
+    date_to: Optional[str] = typer.Option(None, "--to", help="Filter to date (ISO format: 2026-12-31)"),
+    page: int = typer.Option(1, "--page", help="Page number"),
+    page_size: int = typer.Option(20, "--page-size", help="Page size (max 100)"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """List audit logs with optional filters."""
+    fmt = get_output_format(json_output)
+    ensure_authenticated()
+
+    params = {"page": page, "page_size": page_size}
+    if action:
+        params["action"] = action
+    if resource_type:
+        params["resource_type"] = resource_type
+    if user_name:
+        params["user_name"] = user_name
+    if date_from:
+        params["date_from"] = date_from
+    if date_to:
+        params["date_to"] = date_to
+
+    try:
+        with console.status("[cyan]Fetching audit logs...[/cyan]"):
+            result = api.get("/audit", params=params)
+
+        if fmt == "json":
+            console.print_json(_json.dumps(result, default=str))
+        else:
+            items = result.get("items", [])
+            total = result.get("total", 0)
+
+            if items:
+                data = [
+                    {
+                        "Timestamp": format_timestamp(i.get("created_at")),
+                        "User": i.get("user_name", ""),
+                        "Action": i.get("action", ""),
+                        "Resource": i.get("resource_type", ""),
+                        "Resource ID": str(i.get("resource_id", ""))[:8] + "..." if i.get("resource_id") else "",
+                        "Details": (str(i.get("details", "")) or "")[:40],
+                    }
+                    for i in items
+                ]
+                print_table(data, title="Audit Logs")
+                print_info(f"Page {page} - Showing {len(items)} of {total} total entries")
+            else:
+                print_info("No audit log entries found.")
+    except APIError as exc:
+        print_error(f"Failed to list audit logs: {exc}")

{bonito_cli-0.5.2 → bonito_cli-0.6.1}/bonito_cli/commands/auth.py

@@ -33,21 +33,24 @@ def signup(
     password: Optional[str] = typer.Option(None, "--password", "-p", help="Account password"),
     name: Optional[str] = typer.Option(None, "--name", "-n", help="Full name"),
     org: Optional[str] = typer.Option(None, "--org", "-o", help="Organization name"),
+    invite_code: Optional[str] = typer.Option(None, "--invite-code", "-i", help="Invite code (required for invite-only registration)"),
     non_interactive: bool = typer.Option(False, "--non-interactive", help="Non-interactive mode (requires all fields as flags)"),
     api_url: Optional[str] = typer.Option(None, "--api-url", help="Custom API URL"),
 ):
     """
     Sign up for a new Bonito account.
 
+    After signup you must verify your email before logging in.
+
     Examples:
         bonito auth signup
-        bonito auth signup --email admin@company.com --name "John Doe" --org "ACME Corp"
-        bonito auth signup --non-interactive --email admin@company.com --password secret --name "John Doe" --org "ACME Corp"
+        bonito auth signup --invite-code ABC123
+        bonito auth signup --email admin@company.com --name "John Doe" --org "ACME Corp" --invite-code ABC123
     """
     # In non-interactive mode, all fields must be provided as flags
     if non_interactive:
-        if not all([email, password, name, org]):
-            console.print("[red]✗ In non-interactive mode, all fields (--email, --password, --name, --org) are required[/red]")
+        if not all([email, password, name]):
+            console.print("[red]✗ In non-interactive mode, --email, --password, and --name are required[/red]")
             raise typer.Exit(1)
     else:
         # Interactive prompts
@@ -57,11 +60,13 @@ def signup(
             password = Prompt.ask("[cyan]Password[/cyan]", password=True)
         if not name:
             name = Prompt.ask("[cyan]Full name[/cyan]")
-        if not org:
-            org = Prompt.ask("[cyan]Organization name[/cyan]")
+        if not invite_code:
+            invite_code = Prompt.ask("[cyan]Invite code (leave blank if not required)[/cyan]", default="")
+            if not invite_code:
+                invite_code = None
 
-    if not all([email, password, name, org]):
-        console.print("[red]✗ All fields (email, password, name, organization) are required[/red]")
+    if not all([email, password, name]):
+        console.print("[red]✗ Email, password, and name are required[/red]")
         raise typer.Exit(1)
 
     # Allow overriding the API URL
@@ -74,53 +79,43 @@ def signup(
         api._client = None
 
     try:
+        body = {
+            "email": email,
+            "password": password,
+            "name": name,
+        }
+        if invite_code:
+            body["invite_code"] = invite_code
+
         with console.status("[cyan]Creating account…[/cyan]"):
             resp = httpx.post(
                 f"{api.base_url}/api/auth/register",
-                json={
-                    "email": email,
-                    "password": password,
-                    "name": name,
-                },
+                json=body,
                 timeout=15,
             )
 
-        if resp.status_code != 200:
+        if resp.status_code not in (200, 201):
             detail = "Registration failed"
             try:
-                detail = resp.json().get("detail", detail)
+                err = resp.json()
+                detail = err.get("detail") or err.get("message", detail)
             except Exception:
                 pass
             console.print(f"[red]✗ {detail}[/red]")
             raise typer.Exit(1)
 
         data = resp.json()
-        
-        # Auto-login after successful signup
-        creds = {
-            "access_token": data["access_token"],
-            "refresh_token": data.get("refresh_token"),
-            "email": email,
-        }
-        save_credentials(creds)
-
-        # Fetch user profile
-        try:
-            me = api.get("/auth/me")
-            creds["user"] = me
-            save_credentials(creds)
-            org_name = me.get("org", {}).get("name", "—")
-            console.print(
-                Panel(
-                    f"[green]✓ Account created and logged in as [bold]{email}[/bold][/green]\n"
-                    f"  Organization: {org_name}\n"
-                    f"  Role: {me.get('role', 'member')}",
-                    title="🎉 Welcome to Bonito",
-                    border_style="green",
-                )
+        message = data.get("message", "Account created")
+
+        console.print(
+            Panel(
+                f"[green]✓ {message}[/green]\n\n"
+                f"  Please verify your email, then run:\n"
+                f"  [cyan]bonito auth login --email {email}[/cyan]",
+                title="🎉 Welcome to Bonito",
+                border_style="green",
             )
-        except Exception:
-            console.print(f"[green]✓ Account created and logged in as {email}[/green]")
+        )
 
     except httpx.RequestError as exc:
         console.print(f"[red]✗ Connection failed: {exc}[/red]")

bonito_cli-0.6.1/bonito_cli/commands/compliance.py

@@ -0,0 +1,110 @@
+"""Compliance checks and reporting commands."""
+
+from __future__ import annotations
+
+import json as _json
+
+import typer
+from rich.console import Console
+
+from ..api import api, APIError
+from ..utils.auth import ensure_authenticated
+from ..utils.display import (
+    get_output_format,
+    print_error,
+    print_info,
+    print_success,
+    print_table,
+    print_dict_as_table,
+)
+
+console = Console()
+app = typer.Typer(help="Compliance checks and reporting")
+
+
+# -- run-check ---------------------------------------------------------
+
+
+@app.command("run-check")
+def run_check(
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """Run a compliance scan across all providers."""
+    fmt = get_output_format(json_output)
+    ensure_authenticated()
+
+    try:
+        with console.status("[cyan]Running compliance scan...[/cyan]"):
+            result = api.post("/compliance/scan")
+
+        if fmt == "json":
+            console.print_json(_json.dumps(result, default=str))
+        else:
+            print_success("Compliance scan completed")
+            if isinstance(result, dict):
+                print_dict_as_table(result, title="Scan Results")
+    except APIError as exc:
+        print_error(f"Failed to run compliance scan: {exc}")
+
+
+# -- list-checks -------------------------------------------------------
+
+
+@app.command("list-checks")
+def list_checks(
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """List all compliance checks and their status."""
+    fmt = get_output_format(json_output)
+    ensure_authenticated()
+
+    try:
+        with console.status("[cyan]Fetching compliance checks...[/cyan]"):
+            checks = api.get("/compliance/checks")
+
+        if fmt == "json":
+            console.print_json(_json.dumps(checks, default=str))
+        else:
+            if checks:
+                data = [
+                    {
+                        "Check": c.get("name", c.get("check_id", "")),
+                        "Framework": c.get("framework", ""),
+                        "Status": c.get("status", ""),
+                        "Severity": c.get("severity", ""),
+                        "Last Run": str(c.get("last_checked_at", ""))[:10] if c.get("last_checked_at") else "",
+                    }
+                    for c in checks
+                ]
+                print_table(data, title="Compliance Checks")
+                print_info(f"{len(checks)} check(s)")
+            else:
+                print_info("No compliance checks found.")
+    except APIError as exc:
+        print_error(f"Failed to list compliance checks: {exc}")
+
+
+# -- get-report --------------------------------------------------------
+
+
+@app.command("get-report")
+def get_report(
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """Get the full compliance report."""
+    fmt = get_output_format(json_output)
+    ensure_authenticated()
+
+    try:
+        with console.status("[cyan]Generating compliance report...[/cyan]"):
+            report = api.get("/compliance/report")
+
+        if fmt == "json":
+            console.print_json(_json.dumps(report, default=str))
+        else:
+            if isinstance(report, dict):
+                print_dict_as_table(report, title="Compliance Report")
+            else:
+                console.print(report)
+    except APIError as exc:
+        print_error(f"Failed to get compliance report: {exc}")